@gobing-ai/knowledge-kit 0.1.10 → 0.1.11

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
     },
     "plugins": [
         {
-            "version": "0.1.10",
+            "version": "0.1.11",
             "name": "kk",
             "source": "./plugins/kk",
             "description": "knowledge-kit — a set of toolkit for knowledge management"

package/dist/index.js

@@ -37862,9 +37862,11 @@ var init_dist6 = __esm(() => {
 // ../../packages/publish-harness/src/bot-fs.ts
 import {
   chmodSync,
+  closeSync,
   copyFileSync,
   lstatSync,
   mkdirSync as mkdirSync4,
+  openSync,
   readdirSync as readdirSync4,
   realpathSync as realpathSync5,
   rmdirSync
@@ -37906,6 +37908,9 @@ function rmdir(path) {
 function chmod(path, mode) {
   chmodSync(path, mode);
 }
+function createExclusiveFile(path) {
+  closeSync(openSync(path, "wx", 384));
+}
 function copyProfileEntry(src, dest, options = {}) {
   const stat = lstat(src);
   if (stat === null)
@@ -38790,6 +38795,8 @@ __export(exports_browser, {
   canonicalize: () => canonicalize,
   captureSessionFacts: () => captureSessionFacts,
   checkChannelSession: () => checkChannelSession,
+  chmod: () => chmod,
+  createExclusiveFile: () => createExclusiveFile,
   createKkBrowserLauncher: () => createKkBrowserLauncher,
   createShadowFinder: () => createShadowFinder,
   enterDelegatedLease: () => enterDelegatedLease,
@@ -38807,6 +38814,7 @@ __export(exports_browser, {
   loginBot: () => loginBot,
   logoutBot: () => logoutBot,
   markdownToHtml: () => markdownToHtml,
+  mkdirExclusive: () => mkdirExclusive,
   normalizeBotDefaultUrl: () => normalizeBotDefaultUrl,
   normalizeSessionExpiry: () => normalizeSessionExpiry,
   normalizeSessionIdentity: () => normalizeSessionIdentity,
@@ -38821,6 +38829,7 @@ __export(exports_browser, {
   resolveBotProfileDir: () => resolveBotProfileDir,
   resolveChannelProfileDir: () => resolveChannelProfileDir,
   resolveSelector: () => resolveSelector,
+  rmdir: () => rmdir,
   runProfileCli: () => runProfileCli,
   uploadFile: () => uploadFile,
   verifyLeaseHeld: () => verifyLeaseHeld,
@@ -39625,6 +39634,7 @@ var init_browser = __esm(() => {
   init_dist();
   init_bot();
   init_bot_fs();
+  init_bot_fs();
   init_bot_transaction();
   init_src();
   init_profile_dir2();
@@ -48182,11 +48192,47 @@ async function prepareAction(options) {
     failLoud2("kk.daily.prepare.failed", error);
   }
 }
-function targetsOf(path) {
-  if (!existsSync5(path))
-    return [];
-  const parsed = parseJson3(readFileSync7(path, "utf-8"));
-  return Array.isArray(parsed?.targets) ? parsed.targets.filter((e) => e !== null && typeof e === "object") : [];
+var PRIMARY_PUBLISH_TARGETS = ["surfdash-pub", "podcast-pub"];
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function failedPrimaryTarget(target, reason) {
+  return { target, ok: false, status: "failed", error: reason };
+}
+function readPrimaryReceipt(path, expectedTarget) {
+  if (!existsSync5(path)) {
+    const issue = `${expectedTarget} receipt file is missing`;
+    return { targets: [failedPrimaryTarget(expectedTarget, issue)], issue };
+  }
+  let parsed;
+  try {
+    parsed = parseJson3(readFileSync7(path, "utf-8"));
+  } catch {
+    const issue = `${expectedTarget} receipt is not valid JSON`;
+    return { targets: [failedPrimaryTarget(expectedTarget, issue)], issue };
+  }
+  if (!isRecord2(parsed) || !Array.isArray(parsed.targets)) {
+    const issue = `${expectedTarget} receipt has no targets array`;
+    return { targets: [failedPrimaryTarget(expectedTarget, issue)], issue };
+  }
+  const rawTargets = parsed.targets;
+  const targets = rawTargets.filter(isRecord2);
+  const issues = [];
+  if (targets.length !== rawTargets.length) {
+    issues.push(`${expectedTarget} receipt contains malformed target records`);
+  }
+  if (targets.length === 0) {
+    issues.push(`${expectedTarget} receipt targets array is empty`);
+  }
+  const observedExpected = targets.some((entry) => entry.target === expectedTarget);
+  if (!observedExpected) {
+    targets.push(failedPrimaryTarget(expectedTarget, `${expectedTarget} receipt has no named target record`));
+    issues.push(`${expectedTarget} receipt has no named target record`);
+  }
+  return { targets, issue: issues.length === 0 ? undefined : issues.join("; ") };
+}
+function isPublishedPrimaryTarget(entry) {
+  return PRIMARY_PUBLISH_TARGETS.some((target) => target === entry.target) && entry.ok === true && entry.status === "published";
 }
 async function publishClassifyAction(options) {
   try {
@@ -48196,14 +48242,36 @@ async function publishClassifyAction(options) {
     const statusPath = join7(dir, `${runDate}_17_publish_publish-status.txt`);
     const surfdash = join7(dir, `${runDate}_14_publish-surfdash_result.json`);
     const podcast = join7(dir, `${runDate}_16_publish-podcast_result.json`);
-    const bothWritten = existsSync5(surfdash) && existsSync5(podcast);
-    const targets = bothWritten ? [...targetsOf(surfdash), ...targetsOf(podcast)] : [];
-    const okCount = targets.filter((entry) => entry.ok === true && entry.status === "published").length;
+    const receipts = [readPrimaryReceipt(surfdash, "surfdash-pub"), readPrimaryReceipt(podcast, "podcast-pub")];
+    const targets = receipts.flatMap((receipt) => receipt.targets);
+    const receiptIssues = receipts.flatMap((receipt) => receipt.issue === undefined ? [] : [receipt.issue]);
+    const okCount = targets.filter(isPublishedPrimaryTarget).length;
     const total = targets.length;
-    const status = okCount > 0 && okCount === total ? "full" : okCount > 0 ? "partial" : "none";
+    const exactPrimarySet = receiptIssues.length === 0 && targets.length === PRIMARY_PUBLISH_TARGETS.length && PRIMARY_PUBLISH_TARGETS.every((target) => targets.filter((entry) => entry.target === target).length === 1) && targets.every(isPublishedPrimaryTarget);
+    let status = exactPrimarySet ? "full" : okCount > 0 ? "partial" : "none";
     mkdirSync3(dir, { recursive: true });
-    writeFileSync4(resultPath, `${JSON.stringify({ ok: okCount === total && total > 0, targets }, null, 2)}`);
-    writeFileSync4(statusPath, status);
+    const writeClassification = (completenessError) => {
+      const result = {
+        ok: status === "full",
+        targets,
+        ...receiptIssues.length === 0 ? {} : { issues: receiptIssues },
+        ...completenessError === undefined ? {} : { completenessError }
+      };
+      writeFileSync4(resultPath, `${JSON.stringify(result, null, 2)}`);
+      writeFileSync4(statusPath, status);
+    };
+    writeClassification();
+    const writeSummary = (missing, completenessError) => {
+      writeFileSync4(join7(workDir, "publish-classify.summary.txt"), `${JSON.stringify({
+        status,
+        published: okCount,
+        targets: total,
+        ...receiptIssues.length === 0 ? {} : { issues: receiptIssues },
+        ...completenessError === undefined ? {} : { completenessError },
+        missing
+      })}
+`);
+    };
     writeFileSync4(join7(workDir, "publish-classify.summary.txt"), `${JSON.stringify({ status, published: okCount, targets: total })}
 `);
     if (options.foldTail === true) {
@@ -48219,20 +48287,45 @@ async function publishClassifyAction(options) {
           failLoud2("kk.daily.publish-classify.patch-failed", new Error(`exit ${code}`));
       }
     }
-    runStage(["daily-publish-completeness", workDir, runDate]);
+    let completenessError;
+    let completenessCode = 1;
+    try {
+      completenessCode = runStage(["daily-publish-completeness", workDir, runDate]);
+    } catch (error) {
+      completenessError = `completeness stage failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
     const completenessPath = join7(dir, `${runDate}_17_publish_completeness.json`);
     let missing = [];
-    if (existsSync5(completenessPath)) {
+    if (completenessError === undefined && completenessCode !== 0) {
+      completenessError = `completeness stage exited ${completenessCode}`;
+    } else if (completenessError === undefined && !existsSync5(completenessPath)) {
+      completenessError = "completeness result artifact is missing";
+    } else if (completenessError === undefined) {
       try {
         const parsed = parseJson3(readFileSync7(completenessPath, "utf-8"));
-        if (Array.isArray(parsed?.missing)) {
-          missing = parsed.missing.filter((item) => typeof item === "string");
+        if (!isRecord2(parsed) || !Array.isArray(parsed.missing) || !parsed.missing.every((item) => typeof item === "string")) {
+          completenessError = "completeness result has no valid missing[] probe";
+        } else {
+          missing = parsed.missing;
         }
       } catch {
-        missing = [];
+        completenessError = "completeness result is not valid JSON";
       }
     }
-    consoleOutput.write(JSON.stringify({ status, published: okCount, targets: total, missing }));
+    if (completenessError !== undefined)
+      missing = ["completeness"];
+    if (completenessError !== undefined && status === "full")
+      status = "partial";
+    writeClassification(completenessError);
+    writeSummary(missing, completenessError);
+    consoleOutput.write(JSON.stringify({
+      status,
+      published: okCount,
+      targets: total,
+      missing,
+      ...receiptIssues.length === 0 ? {} : { issues: receiptIssues },
+      ...completenessError === undefined ? {} : { completenessError }
+    }));
   } catch (error) {
     if (error instanceof CommanderError)
       throw error;
@@ -52761,7 +52854,8 @@ async function readSucceeded(fs, receiptsDir, id) {
   }
 }
 async function readLinkMap(fs, receiptsDir, rows) {
-  const map = {};
+  const real = {};
+  const all = {};
   for (const source of LINK_SOURCES) {
     const row = rows.find((candidate) => candidate.plugin === source.plugin && candidate.tier === 0);
     if (row === undefined)
@@ -52771,11 +52865,14 @@ async function readLinkMap(fs, receiptsDir, rows) {
       continue;
     try {
       const receipt = JSON.parse(await fs.readFile(path));
-      if (receipt.status === "succeeded" && receipt.url)
-        map[source.receipt] = receipt.url;
+      if (receipt.status !== "succeeded" || !receipt.url)
+        continue;
+      all[source.receipt] = receipt.url;
+      if (receipt.dummy !== true)
+        real[source.receipt] = receipt.url;
     } catch {}
   }
-  return map;
+  return { real, all };
 }
 async function sendPublishMatrix(args, deps = {}) {
   const fs = deps.fs ?? createNodeFileSystem();
@@ -52826,7 +52923,7 @@ async function sendPublishMatrix(args, deps = {}) {
         }
         continue;
       }
-      const links = tier === 0 ? {} : await readLinkMap(fs, receiptsDir, plan.rows);
+      const linkMaps = tier === 0 ? { real: {}, all: {} } : await readLinkMap(fs, receiptsDir, plan.rows);
       const sendRowsInput = rows.map((row) => ({
         key: row.id,
         plugin: row.plugin,
@@ -52851,12 +52948,13 @@ async function sendPublishMatrix(args, deps = {}) {
           if (tier === 0)
             return { payloadPath: row.payloadPath };
           const raw = await fs.exists(row.payloadPath) ? await fs.readFile(row.payloadPath) : "";
+          const links = row.mode === "dummy" ? linkMaps.all : linkMaps.real;
           let resolved = raw;
           for (const source of LINK_SOURCES) {
             const url = links[source.receipt];
             if (url === undefined)
               continue;
-            resolved = resolved.split(source.placeholder).join(url);
+            resolved = resolved.split(source.placeholder).join(JSON.stringify(url).slice(1, -1));
           }
           if (LINK_SOURCES.some((source) => resolved.includes(source.placeholder))) {
             return { error: "unresolved-link" };
@@ -52988,7 +53086,12 @@ async function runPublishMatrixRssGate(args, deps = {}) {
   };
   let xml;
   try {
-    const read = deps.readFeed ?? (async (url) => (await fetch(url)).text());
+    const read = deps.readFeed ?? (async (url) => {
+      const res = await fetch(url, { signal: AbortSignal.timeout(30000) });
+      if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+      return res.text();
+    });
     xml = await read(feedUrl);
   } catch (err) {
     return write({
@@ -53127,7 +53230,7 @@ async function runPublishMatrixBundle(args, deps = {}) {
     }
     const hasOwnedVariant = Object.keys(variants).some((key) => key === "article" || key === "episode");
     if (!hasOwnedVariant) {
-      echoError("publish-matrix-bundle: no article/episode variant \u2014 the publication contract needs both");
+      echoError("publish-matrix-bundle: no article/episode variant \u2014 the publication contract needs at least one");
       return 1;
     }
     const articleTitle = await readVariantTitle(fs, workDir, variants);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/knowledge-kit",
-    "version": "0.1.10",
+    "version": "0.1.11",
     "description": "An ingest → create → publish content pipeline CLI (Bun).",
     "repository": {
         "type": "git",

package/plugins/kk/plugin.json

@@ -1,5 +1,5 @@
 {
     "name": "kk",
-    "version": "0.1.10",
+    "version": "0.1.11",
     "description": "knowledge-kit Claude Code plugin: skills, commands, subagents, hooks, and rules"
 }

package/plugins/kk/scripts/daily-scheduled-run.ts

@@ -0,0 +1,298 @@
+#!/usr/bin/env bun
+/** Supervise one scheduled daily run and persist its terminal outcome even after a deadline. */
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+
+const { values } = parseArgs({
+    options: {
+        repo: { type: 'string', default: process.cwd() },
+        'works-dir': { type: 'string' },
+        'run-id': { type: 'string' },
+        'timeout-ms': { type: 'string', default: '13500000' },
+        receipt: { type: 'string' },
+        agent: { type: 'string', default: 'inline' },
+        'retry-agent': { type: 'string', default: 'claude' },
+        'required-channels': { type: 'string', default: 'wechat,locales,cms-resync' },
+        'wechat-live': { type: 'boolean', default: false },
+    },
+});
+const timeoutMs = Number(values['timeout-ms']);
+if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) {
+    console.error('daily-scheduled-run: --timeout-ms must be a positive integer');
+    process.exit(2);
+}
+const repo = resolve(values.repo);
+const now = new Date();
+const stamp = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}`;
+const runId = values['run-id'] ?? `daily-ai-voice-${stamp}-${now.getTime()}`;
+const workDir = join(resolve(values['works-dir'] ?? join(repo, '.works')), 'kk-daily-ai-voice2', stamp);
+const receiptPath = resolve(values.receipt ?? join(workDir, 'schedule-receipt.json'));
+const startedAt = now.toISOString();
+mkdirSync(dirname(receiptPath), { recursive: true });
+const vars = {
+    publish_enabled: 'true',
+    skip_review: 'true',
+    agent: values.agent,
+    agent_retry: values['retry-agent'],
+    wechat_live: values['wechat-live'] === true ? 'true' : 'false',
+    work_dir: workDir,
+    run_date: stamp,
+};
+writeFileSync(receiptPath, JSON.stringify({ runId, startedAt, status: 'running', workDir }, null, 2));
+let interrupted = false;
+let timedOut = false;
+let spawnError = '';
+let forceKill: ReturnType<typeof setTimeout> | undefined;
+const child = spawn(
+    'spur',
+    [
+        '--no-logo',
+        'workflow',
+        'run',
+        'plugins/kk/workflows/kk-daily-ai-voice2.yaml',
+        '--run-id',
+        runId,
+        '--vars',
+        JSON.stringify(vars),
+        '--quiet',
+    ],
+    { cwd: repo, detached: true, stdio: 'inherit' },
+);
+
+const ownedPids = new Set<number>();
+/** Snapshot descendants before the root exits, including workers that created their own groups. */
+function rememberDescendants(): void {
+    if (child.pid === undefined) return;
+    ownedPids.add(child.pid);
+    const snapshot = spawnSync('ps', ['-axo', 'pid=,ppid='], { encoding: 'utf-8', timeout: 5000 });
+    const rows = snapshot.stdout
+        .trim()
+        .split('\n')
+        .map((line) => line.trim().split(/\s+/).map(Number));
+    const descendants = new Set([child.pid]);
+    let added = true;
+    while (added) {
+        added = false;
+        for (const [pid, parent] of rows) {
+            if (pid !== undefined && parent !== undefined && descendants.has(parent) && !descendants.has(pid)) {
+                descendants.add(pid);
+                added = true;
+            }
+        }
+    }
+    for (const pid of descendants) ownedPids.add(pid);
+}
+
+/** Stop only the recorded owned tree; process-group signals also catch late same-group forks. */
+function signalOwned(signal: NodeJS.Signals): void {
+    if (child.pid === undefined) return;
+    rememberDescendants();
+    for (const pid of [...ownedPids].reverse()) {
+        try {
+            process.kill(-pid, signal);
+        } catch {}
+        try {
+            process.kill(pid, signal);
+        } catch {}
+    }
+}
+
+function terminate(): void {
+    signalOwned('SIGTERM');
+    if (forceKill === undefined) {
+        forceKill = setTimeout(() => {
+            signalOwned('SIGKILL');
+        }, 300);
+    }
+}
+const onSignal = (): void => {
+    interrupted = true;
+    terminate();
+};
+process.once('SIGTERM', onSignal);
+process.once('SIGINT', onSignal);
+const deadline = setTimeout(() => {
+    timedOut = true;
+    terminate();
+}, timeoutMs);
+const exitCode = await new Promise<number>((done) => {
+    child.once('error', (error) => {
+        spawnError = error.message;
+        done(1);
+    });
+    child.once('close', (code) => done(code ?? 1));
+});
+clearTimeout(deadline);
+if (forceKill !== undefined) clearTimeout(forceKill);
+// A killed shell can leave owned descendants that ignore TERM. Always finish the group before
+// recording a terminal outcome; no detached grandchild may continue to publish after a timeout.
+if (child.pid !== undefined && (timedOut || interrupted || exitCode !== 0)) {
+    terminate();
+    await Bun.sleep(300);
+    signalOwned('SIGKILL');
+    await Bun.sleep(100);
+}
+const workflowStatus = timedOut ? 'timed-out' : interrupted ? 'interrupted' : exitCode === 0 ? 'done' : 'failed';
+const primaryPublishStatus = readOptional(join(workDir, '31-publish', `${stamp}_17_publish_publish-status.txt`));
+const runSummary = readOptional(join(workDir, 'run-report.summary.txt'));
+const cleanup: { command: string; exitCode: number | null }[] = [];
+let reservationRecovery: { status: string; reason: string; released?: number } = {
+    status: 'retained',
+    reason: 'workflow completed; publication settlement owns its reservations',
+};
+if (workflowStatus !== 'done' || runSummary?.startsWith('no-content:')) {
+    // The caller gives the nested safety run this exact id. Unknown/already-terminal ids are
+    // harmless cleanup failures; they never override the original workflow failure.
+    if (workflowStatus !== 'done') {
+        for (const id of [`${runId}-safety`, runId]) {
+            const result = spawnSync('spur', ['workflow', 'cancel', id, '--json'], {
+                cwd: repo,
+                encoding: 'utf-8',
+                timeout: 20000,
+            });
+            cleanup.push({ command: `spur workflow cancel ${id}`, exitCode: result.status });
+        }
+    }
+    // Only a complete trace proving no channel send began permits recycling reservations. A
+    // missing receipt alone is insufficient: a remote send may have succeeded before it crashed.
+    const trace = spawnSync('spur', ['workflow', 'trace', runId, '--json'], {
+        cwd: repo,
+        encoding: 'utf-8',
+        timeout: 20000,
+    });
+    reservationRecovery = { status: 'retained', reason: 'publication state could not be established' };
+    try {
+        const parsed = JSON.parse(trace.stdout) as {
+            run?: { runId?: string; workflowName?: string; status?: string; startedAt?: string };
+            events?: { kind?: string; node?: string; status?: string }[];
+        };
+        const sendNodes = new Set([
+            'publish-surfdash',
+            'publish-podcast',
+            'xhs-publish',
+            'wechat-publish',
+            'translate-localize',
+            'translate',
+            'translate-retry',
+            'translate-sync',
+            'publish-classify',
+        ]);
+        const validTrace =
+            trace.status === 0 &&
+            parsed.run?.runId === runId &&
+            parsed.run?.workflowName === 'kk-daily-ai-voice2' &&
+            parsed.run?.status === (workflowStatus === 'done' ? 'done' : 'failed') &&
+            Date.parse(parsed.run.startedAt ?? '') >= Date.parse(startedAt) - 1000 &&
+            Date.parse(parsed.run.startedAt ?? '') <= Date.now() &&
+            Array.isArray(parsed.events) &&
+            parsed.events.length > 0;
+        const sendStarted = parsed.events?.some(
+            (event) => event.kind === 'action' && sendNodes.has(event.node ?? '') && event.status !== 'skipped',
+        );
+        if (validTrace && !sendStarted) {
+            // Cancellation is durable before reuse. Require a second stable snapshot after the
+            // owned processes are gone, so an in-flight or partially finalized row cannot pass.
+            await Bun.sleep(200);
+            const secondTrace = spawnSync('spur', ['workflow', 'trace', runId, '--json'], {
+                cwd: repo,
+                encoding: 'utf-8',
+                timeout: 20000,
+            });
+            const second = JSON.parse(secondTrace.stdout) as typeof parsed;
+            if (
+                secondTrace.status !== 0 ||
+                JSON.stringify(second.run) !== JSON.stringify(parsed.run) ||
+                JSON.stringify(second.events) !== JSON.stringify(parsed.events)
+            ) {
+                throw new Error('failed-run trace is not stable after cancellation');
+            }
+            const release = spawnSync('kk', ['store', 'release', '--topic', 'ai-news', '--run', runId], {
+                cwd: repo,
+                encoding: 'utf-8',
+                timeout: 20000,
+            });
+            cleanup.push({ command: 'kk store release (verified pre-publication failure)', exitCode: release.status });
+            const result = release.status === 0 ? (JSON.parse(release.stdout) as { released?: unknown }) : null;
+            reservationRecovery =
+                result !== null && typeof result.released === 'number'
+                    ? { status: 'released', reason: 'trace proves no channel send began', released: result.released }
+                    : { status: 'retained', reason: 'reservation release did not produce a valid receipt' };
+        } else if (sendStarted) {
+            reservationRecovery = { status: 'retained', reason: 'a channel send began; preserve uncertain delivery' };
+        }
+    } catch {
+        // Unreadable/truncated evidence or an unexpected CLI shape must never cause reuse of a
+        // potentially aired story. Keep the reservation and the original failure visible.
+    }
+}
+const ledger = spawnSync('kk', ['ledger', 'sync', '--workflow', 'kk-daily-ai-voice2', '--work-dir', workDir], {
+    cwd: repo,
+    encoding: 'utf-8',
+    timeout: 20000,
+});
+cleanup.push({ command: 'kk ledger sync', exitCode: ledger.status });
+function readOptional(path: string): string | null {
+    try {
+        return readFileSync(path, 'utf-8').trim();
+    } catch {
+        return null;
+    }
+}
+const requiredChannels = values['required-channels']
+    .split(',')
+    .map((channel) => channel.trim())
+    .filter(Boolean);
+let channelCompleteness: { channel: string; state: string; detail?: string }[] = [];
+try {
+    const parsed = JSON.parse(
+        readOptional(join(workDir, '31-publish', `${stamp}_17_publish_completeness.json`)) ?? 'null',
+    ) as { rows?: unknown } | null;
+    if (Array.isArray(parsed?.rows)) {
+        channelCompleteness = parsed.rows.filter(
+            (row): row is { channel: string; state: string; detail?: string } =>
+                row !== null &&
+                typeof row === 'object' &&
+                typeof row.channel === 'string' &&
+                typeof row.state === 'string',
+        );
+    }
+} catch {}
+const missingRequiredChannels = requiredChannels.filter((channel) => {
+    const rows = channelCompleteness.filter((row) => row.channel === channel);
+    return rows.length !== 1 || rows[0]?.state !== 'done';
+});
+// A terminal green workflow can mean "no content" or failed delivery. Make that observable to
+// the scheduler instead of equating the workflow's process exit with a published edition.
+const status =
+    workflowStatus !== 'done'
+        ? workflowStatus
+        : runSummary?.startsWith('no-content:')
+          ? 'no-content'
+          : primaryPublishStatus === 'full' && missingRequiredChannels.length === 0
+            ? 'done'
+            : 'incomplete';
+const receipt = {
+    runId,
+    startedAt,
+    completedAt: new Date().toISOString(),
+    status,
+    exitCode: timedOut ? 124 : interrupted ? 143 : exitCode !== 0 ? exitCode : status === 'done' ? 0 : 4,
+    workDir,
+    timeoutMs,
+    agent: values.agent,
+    retryAgent: values['retry-agent'],
+    error: spawnError || null,
+    primaryPublishStatus,
+    channelCompleteness,
+    missingRequiredChannels,
+    runSummary,
+    reservationRecovery,
+    cleanup,
+};
+writeFileSync(receiptPath, `${JSON.stringify(receipt, null, 2)}\n`);
+console.log(JSON.stringify(receipt));
+process.removeListener('SIGTERM', onSignal);
+process.removeListener('SIGINT', onSignal);
+process.exit(receipt.exitCode);