feat: export continuity hard-gate and watchdog workstream

scripts/subagent_delivery_watchdog.mjs

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+const ROOT_DIR = path.resolve(import.meta.dirname, '..');
+const STATE_DIR = path.join(ROOT_DIR, 'state', 'subagent-delivery-watchdog');
+
+function parseArgs(argv) {
+  const args = {
+    compact: false,
+    input: null,
+    help: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+
+    if (token === '--compact') {
+      args.compact = true;
+      continue;
+    }
+
+    if (token === '--help' || token === '-h') {
+      args.help = true;
+      continue;
+    }
+
+    if (token === '--input') {
+      args.input = argv[i + 1] ?? null;
+      i += 1;
+      continue;
+    }
+
+    if (token.startsWith('--input=')) {
+      args.input = token.slice('--input='.length) || null;
+      continue;
+    }
+  }
+
+  return args;
+}
+
+function printHelp() {
+  const lines = [
+    'Usage: node scripts/subagent_delivery_watchdog.mjs [--compact] [--input <path>]',
+    '',
+    'Minimal CLI skeleton for the subagent delivery watchdog.',
+  ];
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function tryReadInput(inputPath) {
+  if (!inputPath) {
+    return {
+      path: null,
+      exists: false,
+      bytes: 0,
+      preview: '',
+    };
+  }
+
+  try {
+    const content = fs.readFileSync(inputPath, 'utf8');
+    return {
+      path: inputPath,
+      exists: true,
+      bytes: Buffer.byteLength(content, 'utf8'),
+      preview: content.slice(0, 200),
+      content,
+    };
+  } catch (error) {
+    return {
+      path: inputPath,
+      exists: false,
+      bytes: 0,
+      preview: '',
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function tryParseJson(content) {
+  if (typeof content !== 'string' || content.length === 0) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+function writeDispatchReceiptState(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const { runId, childSessionKey, dispatchAt, expectedBy } = payload;
+
+  if (![runId, childSessionKey, dispatchAt, expectedBy].every((value) => typeof value === 'string' && value.length > 0)) {
+    return null;
+  }
+
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+
+  const statePath = path.join(STATE_DIR, `${runId}.json`);
+  const dispatchRecord = {
+    runId,
+    childSessionKey,
+    dispatchAt,
+    expectedBy,
+  };
+
+  fs.writeFileSync(statePath, `${JSON.stringify(dispatchRecord, null, 2)}\n`, 'utf8');
+
+  return {
+    statePath,
+    record: dispatchRecord,
+  };
+}
+
+function writeCompletionReceiptState(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return null;
+  }
+
+  const { runId } = payload;
+  const completionReceivedAt = payload.completionReceivedAt ?? payload.completionReceiptAt ?? null;
+  const forwardedToMain = payload.forwardedToMain;
+  const resultSource = payload.resultSource;
+
+  if (typeof runId !== 'string' || runId.length === 0) {
+    return null;
+  }
+
+  const completionUpdates = {};
+
+  if (typeof completionReceivedAt === 'string' && completionReceivedAt.length > 0) {
+    completionUpdates.completionReceivedAt = completionReceivedAt;
+  }
+
+  if (typeof forwardedToMain === 'boolean') {
+    completionUpdates.forwardedToMain = forwardedToMain;
+  }
+
+  if (typeof resultSource === 'string' && resultSource.length > 0) {
+    completionUpdates.resultSource = resultSource;
+  }
+
+  if (Object.keys(completionUpdates).length === 0) {
+    return null;
+  }
+
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+
+  const statePath = path.join(STATE_DIR, `${runId}.json`);
+  let currentRecord = {};
+
+  if (fs.existsSync(statePath)) {
+    try {
+      currentRecord = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    } catch {
+      currentRecord = {};
+    }
+  }
+
+  const nextRecord = {
+    ...currentRecord,
+    runId,
+    ...completionUpdates,
+  };
+
+  fs.writeFileSync(statePath, `${JSON.stringify(nextRecord, null, 2)}\n`, 'utf8');
+
+  return {
+    statePath,
+    record: nextRecord,
+    updatedFields: Object.keys(completionUpdates),
+  };
+}
+
+function parseTime(value) {
+  if (typeof value !== 'string' || value.length === 0) {
+    return null;
+  }
+
+  const timestamp = Date.parse(value);
+  return Number.isNaN(timestamp) ? null : timestamp;
+}
+
+function recomputeStatus(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return 'not_implemented';
+  }
+
+  const completionReceivedAt = payload.completionReceivedAt ?? payload.completionReceiptAt ?? null;
+  if (parseTime(completionReceivedAt) !== null) {
+    return 'completed';
+  }
+
+  const hasDispatch = [payload.runId, payload.childSessionKey, payload.dispatchAt, payload.expectedBy].every(
+    (value) => typeof value === 'string' && value.length > 0,
+  );
+
+  if (!hasDispatch) {
+    return 'not_implemented';
+  }
+
+  const childRunStatus = typeof payload.childRunStatus === 'string'
+    ? payload.childRunStatus.trim().toLowerCase()
+    : null;
+
+  if (childRunStatus === 'done') {
+    return 'done_but_not_forwarded';
+  }
+
+  const expectedBy = parseTime(payload.expectedBy);
+  const currentTime = parseTime(payload.currentTime);
+
+  if (expectedBy === null || currentTime === null) {
+    return 'not_implemented';
+  }
+
+  if (currentTime > expectedBy) {
+    return 'suspect_delivery_failure';
+  }
+
+  return 'active';
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const input = tryReadInput(args.input);
+  const inputPayload = input.exists ? tryParseJson(input.content) : null;
+  const dispatchWrite = writeDispatchReceiptState(inputPayload);
+  const completionWrite = writeCompletionReceiptState(inputPayload);
+  const status = recomputeStatus(inputPayload);
+
+  if ('content' in input) {
+    delete input.content;
+  }
+
+  const records = [];
+  if (dispatchWrite) {
+    records.push(dispatchWrite.record);
+  }
+  if (completionWrite) {
+    records.push(completionWrite.record);
+  }
+
+  const response = {
+    ok: true,
+    tool: 'subagent_delivery_watchdog',
+    version: 'skeleton-v4',
+    mode: 'receipt-write',
+    args: {
+      compact: args.compact,
+      input: args.input,
+    },
+    input,
+    result: {
+      status,
+      message: status === 'not_implemented'
+        ? 'Dispatch and completion receipt writes are implemented; status recompute only handles basic active/suspect/completed states.'
+        : 'Basic watchdog status recompute completed.',
+      records,
+      dispatchReceiptWrite: dispatchWrite,
+      completionReceiptWrite: completionWrite,
+    },
+  };
+
+  const spacing = args.compact ? 0 : 2;
+  process.stdout.write(`${JSON.stringify(response, null, spacing)}\n`);
+}
+
+main();