feat: export continuity hard-gate and watchdog workstream

scripts/test_subagent_delivery_watchdog.mjs

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { spawnSync } from 'node:child_process';
+
+const ROOT_DIR = path.resolve(import.meta.dirname, '..');
+const WATCHDOG_SCRIPT = path.join(ROOT_DIR, 'scripts', 'subagent_delivery_watchdog.mjs');
+
+function createFixtureRunner() {
+  const fixtureRoot = mkdtempSync(path.join(tmpdir(), 'subagent-watchdog-test-'));
+
+  function writeFixture(name, content) {
+    const fixturePath = path.join(fixtureRoot, name);
+    const body = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+    writeFileSync(fixturePath, body);
+    return fixturePath;
+  }
+
+  function runWatchdog(args = [], options = {}) {
+    const result = spawnSync(process.execPath, [WATCHDOG_SCRIPT, ...args], {
+      cwd: ROOT_DIR,
+      encoding: 'utf8',
+      ...options,
+    });
+
+    return {
+      status: result.status,
+      signal: result.signal,
+      stdout: result.stdout ?? '',
+      stderr: result.stderr ?? '',
+      error: result.error ?? null,
+    };
+  }
+
+  function cleanup() {
+    rmSync(fixtureRoot, { recursive: true, force: true });
+  }
+
+  return {
+    fixtureRoot,
+    writeFixture,
+    runWatchdog,
+    cleanup,
+  };
+}
+
+const tests = [];
+
+function test(name, fn) {
+  tests.push({ name, fn });
+}
+
+function printResult(prefix, name, detail = '') {
+  const suffix = detail ? ` ${detail}` : '';
+  process.stdout.write(`${prefix} ${name}${suffix}\n`);
+}
+
+test('fixture runner can invoke watchdog skeleton with a generated input file', () => {
+  const runner = createFixtureRunner();
+
+  try {
+    const inputPath = runner.writeFixture('dispatch.json', {
+      runId: 'fixture-run-001',
+      childSessionKey: 'session:test',
+    });
+
+    const result = runner.runWatchdog(['--compact', '--input', inputPath]);
+
+    assert.equal(result.status, 0, `expected zero exit status, got ${result.status}\n${result.stderr}`);
+    assert.equal(result.stderr, '');
+
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.tool, 'subagent_delivery_watchdog');
+    assert.equal(payload.result.status, 'not_implemented');
+    assert.equal(payload.input.path, inputPath);
+    assert.equal(payload.input.exists, true);
+  } finally {
+    runner.cleanup();
+  }
+});
+
+
+
+test('watchdog reports active before SLA when dispatch exists and no completion receipt has arrived yet', () => {
+  const runner = createFixtureRunner();
+
+  try {
+    const inputPath = runner.writeFixture('dispatch-before-sla.json', {
+      runId: 'fixture-run-active-before-sla',
+      childSessionKey: 'session:active-before-sla',
+      dispatchAt: '2026-04-24T10:00:00.000Z',
+      expectedBy: '2026-04-24T10:10:00.000Z',
+      currentTime: '2026-04-24T10:05:00.000Z',
+    });
+
+    const result = runner.runWatchdog(['--compact', '--input', inputPath]);
+
+    assert.equal(result.status, 0, `expected zero exit status, got ${result.status}
+${result.stderr}`);
+    assert.equal(result.stderr, '');
+
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.input.path, inputPath);
+    assert.equal(payload.input.exists, true);
+    assert.equal(payload.result.status, 'active');
+  } finally {
+    runner.cleanup();
+  }
+});
+
+
+test('watchdog reports suspect delivery failure after SLA when dispatch exists and no completion receipt has arrived yet', () => {
+  const runner = createFixtureRunner();
+
+  try {
+    const inputPath = runner.writeFixture('dispatch-beyond-sla.json', {
+      runId: 'fixture-run-suspect-delivery-failure',
+      childSessionKey: 'session:suspect-delivery-failure',
+      dispatchAt: '2026-04-24T10:00:00.000Z',
+      expectedBy: '2026-04-24T10:10:00.000Z',
+      currentTime: '2026-04-24T10:15:00.000Z',
+    });
+
+    const result = runner.runWatchdog(['--compact', '--input', inputPath]);
+
+    assert.equal(result.status, 0, `expected zero exit status, got ${result.status}
+${result.stderr}`);
+    assert.equal(result.stderr, '');
+
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.input.path, inputPath);
+    assert.equal(payload.input.exists, true);
+    assert.equal(payload.result.status, 'suspect_delivery_failure');
+  } finally {
+    runner.cleanup();
+  }
+});
+
+
+test('watchdog reports completed when dispatch exists and completion receipt has arrived', () => {
+  const runner = createFixtureRunner();
+
+  try {
+    const inputPath = runner.writeFixture('dispatch-completed.json', {
+      runId: 'fixture-run-completed',
+      childSessionKey: 'session:completed',
+      dispatchAt: '2026-04-24T10:00:00.000Z',
+      expectedBy: '2026-04-24T10:10:00.000Z',
+      currentTime: '2026-04-24T10:05:00.000Z',
+      completionReceiptAt: '2026-04-24T10:04:00.000Z',
+    });
+
+    const result = runner.runWatchdog(['--compact', '--input', inputPath]);
+
+    assert.equal(result.status, 0, `expected zero exit status, got ${result.status}
+${result.stderr}`);
+    assert.equal(result.stderr, '');
+
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.input.path, inputPath);
+    assert.equal(payload.input.exists, true);
+    assert.equal(payload.result.status, 'completed');
+  } finally {
+    runner.cleanup();
+  }
+});
+
+test('watchdog reports done but not forwarded when child run is marked done without a main-thread completion receipt', () => {
+  const runner = createFixtureRunner();
+
+  try {
+    const inputPath = runner.writeFixture('dispatch-done-not-forwarded.json', {
+      runId: 'fixture-run-done-not-forwarded',
+      childSessionKey: 'session:done-not-forwarded',
+      dispatchAt: '2026-04-24T10:00:00.000Z',
+      expectedBy: '2026-04-24T10:10:00.000Z',
+      currentTime: '2026-04-24T10:05:00.000Z',
+      childRunStatus: 'done',
+    });
+
+    const result = runner.runWatchdog(['--compact', '--input', inputPath]);
+
+    assert.equal(result.status, 0, `expected zero exit status, got ${result.status}
+${result.stderr}`);
+    assert.equal(result.stderr, '');
+
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.input.path, inputPath);
+    assert.equal(payload.input.exists, true);
+    assert.equal(payload.result.status, 'done_but_not_forwarded');
+  } finally {
+    runner.cleanup();
+  }
+});
+
+test('fixture runner exposes missing-input behavior for future fail-first cases', () => {
+  const runner = createFixtureRunner();
+
+  try {
+    const missingPath = path.join(runner.fixtureRoot, 'missing.json');
+    const result = runner.runWatchdog(['--compact', '--input', missingPath]);
+
+    assert.equal(result.status, 0, `expected zero exit status, got ${result.status}\n${result.stderr}`);
+
+    const payload = JSON.parse(result.stdout);
+    assert.equal(payload.ok, true);
+    assert.equal(payload.input.path, missingPath);
+    assert.equal(payload.input.exists, false);
+    assert.equal(payload.result.status, 'not_implemented');
+  } finally {
+    runner.cleanup();
+  }
+});
+
+function main() {
+  let passed = 0;
+
+  for (const { name, fn } of tests) {
+    try {
+      fn();
+      passed += 1;
+      printResult('PASS', name);
+    } catch (error) {
+      printResult('FAIL', name, error instanceof Error ? `- ${error.message}` : `- ${String(error)}`);
+      if (error instanceof Error && error.stack) {
+        process.stderr.write(`${error.stack}\n`);
+      }
+      process.exitCode = 1;
+    }
+  }
+
+  const failed = tests.length - passed;
+  process.stdout.write(`\nSummary: ${passed} passed, ${failed} failed, ${tests.length} total\n`);
+}
+
+main();