@gobing-ai/knowledge-kit 0.0.36 → 0.1.0

package/dist/index.js

@@ -31845,6 +31845,7 @@ var init_types = () => {};
 // ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.28+531271cb50a1e275/node_modules/@gobing-ai/ts-runtime/dist/index.js
 var init_dist3 = __esm(() => {
   init_file_system_node();
+  init_process_executor();
   init_runtime_node_bun();
   init_process_executor();
   init_config();
@@ -37325,7 +37326,7 @@ ${section}
 `;
 }
 function selectMissingRuns(entries, markdown) {
-  return entries.filter((entry) => entry.status !== "running" && !ledgerHasRun(markdown, entry.runId)).sort((left, right) => (left.startedAt ?? "").localeCompare(right.startedAt ?? "")).map((entry) => entry.runId);
+  return entries.filter((entry) => entry.status !== "running" && entry.isDryRun !== true && !ledgerHasRun(markdown, entry.runId)).sort((left, right) => (left.startedAt ?? "").localeCompare(right.startedAt ?? "")).map((entry) => entry.runId);
 }
 function rowCells(row) {
   const cells = row.replaceAll("\\|", ESCAPED_PIPE_SENTINEL).split("|");
@@ -38535,6 +38536,195 @@ var init_profile_dir2 = __esm(() => {
   init_dist6();
 });
 
+// ../../packages/publish-harness/src/browser-anti-detection.ts
+function resolveOptions(options) {
+  const shieldProfile = options.shieldProfile === true;
+  const suppressFileChooser = options.suppressFileChooser === true;
+  if (!shieldProfile && !suppressFileChooser)
+    return;
+  const raw = options.allowedOrigins;
+  if (raw === undefined || raw.length === 0) {
+    throw new Error("kk anti-detection: enabled flags require a nonempty allowedOrigins list");
+  }
+  const allowedOrigins = raw.map((entry) => {
+    let url;
+    try {
+      url = new URL(entry);
+    } catch {
+      throw new Error(`kk anti-detection: allowedOrigins entry is not a valid URL: '${entry}'`);
+    }
+    if (url.protocol !== "https:" && url.protocol !== "http:" || url.username !== "" || url.password !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "" || url.origin === "null") {
+      throw new Error(`kk anti-detection: allowedOrigins entry must be a bare http(s) origin: '${entry}'`);
+    }
+    return url.origin;
+  });
+  return { allowedOrigins, shieldProfile, suppressFileChooser };
+}
+function installerScript(config) {
+  const payload = JSON.stringify(config);
+  return `(() => {
+    const cfg = ${payload};
+    const allowed = new Set(cfg.allowedOrigins);
+    if (!allowed.has(location.origin)) return;
+    const existing = window['${INSTALL_KEY}'];
+    const signature = JSON.stringify([cfg.allowedOrigins.slice().sort(), cfg.shieldProfile, cfg.suppressFileChooser]);
+    if (existing) {
+        if (existing.signature === signature) return;
+        throw new Error('kk anti-detection: already installed with a different configuration on this document');
+    }
+    const originals = {};
+    const SHIELD_PATH = ${JSON.stringify(SHIELD_PATH)};
+    const nativeLike = (wrapper) => {
+        wrapper.toString = function () { return 'function () { [native code] }'; };
+        return wrapper;
+    };
+    const resolveUrl = (input) => {
+        try {
+            if (typeof Request === 'function' && input instanceof Request) return new URL(input.url);
+            return new URL(String(input), document.baseURI);
+        } catch {
+            return null;
+        }
+    };
+    const isShield = (url) => url !== null && url.origin === location.origin && allowed.has(url.origin) && url.pathname === SHIELD_PATH;
+    const receipt = () => JSON.stringify({ code: 0, success: true, msg: 'ok', data: { st: Date.now() } });
+    if (cfg.shieldProfile) {
+        const originalFetch = window.fetch;
+        originals.fetch = originalFetch;
+        window.fetch = nativeLike(function (input) {
+            if (isShield(resolveUrl(input))) {
+                return Promise.resolve(new Response(receipt(), { status: 200, headers: { 'content-type': 'application/json' } }));
+            }
+            return originalFetch.apply(this, arguments);
+        });
+        const originalSendBeacon = navigator.sendBeacon.bind(navigator);
+        originals.sendBeacon = originalSendBeacon;
+        navigator.sendBeacon = nativeLike(function (url) {
+            if (isShield(resolveUrl(url))) return true;
+            return originalSendBeacon.apply(navigator, arguments);
+        });
+        const XHR = window.XMLHttpRequest;
+        const originalOpen = XHR.prototype.open;
+        const originalSend = XHR.prototype.send;
+        const originalAbort = XHR.prototype.abort;
+        originals.xhr = { XHR, open: originalOpen, send: originalSend, abort: originalAbort };
+        XHR.prototype.open = nativeLike(function (method, url) {
+            this['__kkShield'] = isShield(resolveUrl(url))
+                ? { async: arguments.length < 3 || arguments[2] !== false, aborted: false, delivered: false }
+                : null;
+            return originalOpen.apply(this, arguments);
+        });
+        XHR.prototype.send = nativeLike(function () {
+            const hit = this['__kkShield'];
+            if (!hit) return originalSend.apply(this, arguments);
+            if (!hit.async) throw new Error('kk anti-detection: synchronous XHR to the shield path is not supported');
+            const self = this;
+            const define = (name, value) => {
+                try {
+                    Object.defineProperty(self, name, { value, configurable: true });
+                } catch {}
+            };
+            setTimeout(() => {
+                if (hit.aborted || hit.delivered) return;
+                hit.delivered = true;
+                const body = receipt();
+                define('readyState', 4);
+                define('status', 200);
+                define('statusText', 'OK');
+                define('responseText', body);
+                if (self.responseType === 'json') define('response', JSON.parse(body));
+                else define('response', body);
+                self.dispatchEvent(new Event('readystatechange'));
+                self.dispatchEvent(new Event('load'));
+                self.dispatchEvent(new Event('loadend'));
+            }, 0);
+        });
+        XHR.prototype.abort = nativeLike(function () {
+            if (this['__kkShield']) this['__kkShield'].aborted = true;
+            return originalAbort.apply(this, arguments);
+        });
+    }
+    if (cfg.suppressFileChooser) {
+        const originalClick = HTMLInputElement.prototype.click;
+        originals.inputClick = originalClick;
+        HTMLInputElement.prototype.click = nativeLike(function () {
+            const install = window['${INSTALL_KEY}'];
+            const batch = install ? install.pending : null;
+            if (!(this instanceof HTMLInputElement) || this.type !== 'file' || !Array.isArray(batch)) {
+                return originalClick.apply(this, arguments);
+            }
+            // Enforce the multiple constraint BEFORE consumption: a single-file input keeps native
+            // behavior and the queue stays available for a multiple-capable input.
+            if (batch.length > 1 && !this.multiple) return originalClick.apply(this, arguments);
+            const transfer = new DataTransfer();
+            for (const file of batch) transfer.items.add(file);
+            // Assignment first: a failure here preserves the queue and surfaces the real error.
+            this.files = transfer.files;
+            install.pending = null;
+            this.dispatchEvent(new Event('input', { bubbles: true }));
+            this.dispatchEvent(new Event('change', { bubbles: true }));
+        });
+    }
+    window['${INSTALL_KEY}'] = { signature, originals, chooser: cfg.suppressFileChooser };
+})()`;
+}
+async function injectBrowserAntiDetection(page, options = {}) {
+  const config = resolveOptions(options);
+  if (config === undefined)
+    return;
+  await page.evaluate(installerScript(config));
+  await page.addInitScript(installerScript(config));
+}
+function validatePendingFiles(files) {
+  if (files.length === 0)
+    throw new Error("kk file queue: files must be a nonempty batch");
+  if (files.length > MAX_QUEUED_FILES) {
+    throw new Error(`kk file queue: at most ${MAX_QUEUED_FILES} files per batch, got ${files.length}`);
+  }
+  let totalBytes = 0;
+  for (const file of files) {
+    if (typeof file?.name !== "string" || file.name.trim() === "") {
+      throw new Error("kk file queue: every file needs a nonempty name");
+    }
+    if (typeof file?.mimeType !== "string" || !/^[\w.+-]+\/[\w.+-]+$/.test(file.mimeType)) {
+      throw new Error(`kk file queue: file '${file.name}' needs a type/subtype MIME string`);
+    }
+    if (typeof file?.base64 !== "string" || file.base64.length === 0) {
+      throw new Error(`kk file queue: file '${file.name}' needs nonempty base64 bytes`);
+    }
+    const bytes = Buffer.from(file.base64, "base64");
+    if (bytes.toString("base64") !== file.base64) {
+      throw new Error(`kk file queue: file '${file.name}' base64 is not valid standard base64`);
+    }
+    totalBytes += bytes.length;
+  }
+  if (totalBytes > MAX_QUEUED_BYTES) {
+    throw new Error(`kk file queue: decoded batch is ${totalBytes} bytes, above the ${MAX_QUEUED_BYTES}-byte limit`);
+  }
+  return totalBytes;
+}
+function queueScript(files) {
+  const payload = JSON.stringify(files);
+  return `(() => {
+    const install = window['${INSTALL_KEY}'];
+    if (!install || !install.chooser) {
+        throw new Error('kk file queue: no chooser hook is installed on this document \u2014 call injectBrowserAntiDetection with suppressFileChooser first');
+    }
+    install.pending = ${payload}.map((file) => {
+        const bytes = Uint8Array.from(atob(file.base64), (char) => char.charCodeAt(0));
+        return new File([bytes], file.name, { type: file.mimeType });
+    });
+})();`;
+}
+async function queueBrowserFiles(page, files) {
+  validatePendingFiles(files);
+  await page.evaluate(queueScript(files));
+}
+var SHIELD_PATH = "/shield/webprofile", INSTALL_KEY = "__kkAntiDetection", MAX_QUEUED_FILES = 20, MAX_QUEUED_BYTES;
+var init_browser_anti_detection = __esm(() => {
+  MAX_QUEUED_BYTES = 8 * 1024 * 1024;
+});
+
 // ../../packages/publish-harness/src/browser.ts
 var exports_browser = {};
 __export(exports_browser, {
@@ -38560,6 +38750,7 @@ __export(exports_browser, {
   fillCodeMirror: () => fillCodeMirror,
   findLeftoverTransaction: () => findLeftoverTransaction,
   findShadowControl: () => findShadowControl,
+  injectBrowserAntiDetection: () => injectBrowserAntiDetection,
   isSafeBotName: () => isSafeBotName,
   kkBrowserLauncher: () => kkBrowserLauncher,
   listBots: () => listBots,
@@ -38571,6 +38762,7 @@ __export(exports_browser, {
   openChannelSession: () => openChannelSession,
   parseBotMetadata: () => parseBotMetadata,
   pasteHtml: () => pasteHtml,
+  queueBrowserFiles: () => queueBrowserFiles,
   readBotMetadata: () => readBotMetadata,
   readBotSavedMetadata: () => readBotSavedMetadata,
   readScopedSignal: () => readScopedSignal,
@@ -39255,6 +39447,7 @@ var init_browser = __esm(() => {
   init_src();
   init_profile_dir2();
   init_profile_lease();
+  init_browser_anti_detection();
   init_bot();
   init_bot_transaction();
   init_profile_lease();
@@ -41446,6 +41639,83 @@ import { existsSync as existsSync3, readFileSync as readFileSync5, statSync as s
 import { homedir as homedir2 } from "os";
 import { isAbsolute, join as join2, resolve as resolve2 } from "path";
 
+// ../../packages/kk-core/src/content-limits.ts
+var PLATFORM_CONTENT_LIMITS = Object.freeze({
+  schemaVersion: 5,
+  tagLimits: Object.freeze({
+    default: 7,
+    imageText: Object.freeze({
+      instagram: 5,
+      douyin: 5,
+      kuaishou: 4,
+      weixin: 1,
+      xiaohongshu: 10
+    }),
+    shortVideo: Object.freeze({
+      douyin: 5,
+      kuaishou: 4,
+      xiaohongshu: 10,
+      bilibili: 10,
+      zhihu: 5,
+      tiktok: 20,
+      youtube: 60
+    })
+  }),
+  titleCapabilities: Object.freeze({
+    dynamic: Object.freeze({
+      bilibili: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      zhihu: Object.freeze({ max: 50, unit: "utf16_code_units" }),
+      douban: Object.freeze({ max: 70, unit: "utf16_code_units" }),
+      x: null,
+      threads: null,
+      weibo: null,
+      jike: null,
+      zsxq: null,
+      toutiao: null,
+      juejin: null
+    }),
+    imageText: Object.freeze({
+      xiaohongshu: Object.freeze({ max: 20, unit: "xiaohongshu_title_weighted" }),
+      weixin: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      douyin: Object.freeze({ max: 20, unit: "utf16_code_units" }),
+      shipinhao: Object.freeze({ max: 22, unit: "utf16_code_units" }),
+      reddit: Object.freeze({ max: 300, unit: "utf16_code_units" })
+    }),
+    article: Object.freeze({
+      juejin: Object.freeze({ max: 100, unit: "utf16_code_units" }),
+      csdn: Object.freeze({ max: 100, unit: "utf16_code_units" }),
+      cnblogs: Object.freeze({ max: 128, unit: "utf16_code_units" }),
+      weibo: Object.freeze({ max: 30, unit: "utf16_code_units" }),
+      sspai: Object.freeze({ max: 80, unit: "utf16_code_units" })
+    }),
+    shortVideo: Object.freeze({
+      shipinhao: Object.freeze({ max: 16, unit: "utf16_code_units" }),
+      douyin: Object.freeze({ max: 30, unit: "utf16_code_units" }),
+      bilibili: Object.freeze({ max: 80, unit: "utf16_code_units" })
+    })
+  }),
+  bodyCapabilities: Object.freeze({
+    dynamic: Object.freeze({
+      threads: Object.freeze({ max: 500, unit: "unicode_code_points", behavior: "split_thread" }),
+      x: Object.freeze({ max: 280, unit: "weighted", behavior: "split_thread" }),
+      weibo: Object.freeze({ max: 2000, unit: "unicode_code_points" }),
+      jike: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    }),
+    imageText: Object.freeze({
+      xiaohongshu: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      douyin: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    }),
+    article: Object.freeze({
+      wechatmp: Object.freeze({ max: 50000, unit: "unicode_code_points" }),
+      juejin: Object.freeze({ max: 50000, unit: "unicode_code_points" })
+    }),
+    shortVideo: Object.freeze({
+      douyin: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      kuaishou: Object.freeze({ max: 1000, unit: "unicode_code_points" }),
+      shipinhao: Object.freeze({ max: 1000, unit: "unicode_code_points" })
+    })
+  })
+});
 // ../../packages/kk-core/src/kinds.ts
 init_zod();
 
@@ -41567,6 +41837,67 @@ var BrowserSessionDescriptorSchema = object2({
     }
   }).optional()
 }).strict();
+var ContentCountUnitSchema = _enum2([
+  "utf16_code_units",
+  "unicode_code_points",
+  "weighted",
+  "xiaohongshu_title_weighted"
+]);
+var LimitEntrySchema = object2({
+  max: number2().int().positive(),
+  unit: ContentCountUnitSchema
+}).strict();
+var PublishingProfileLimitsSchema = object2({
+  title: LimitEntrySchema.optional(),
+  body: LimitEntrySchema.optional()
+}).strict();
+var PublishingProfileRequiresSchema = object2({
+  cover: boolean2().optional(),
+  orderedImages: boolean2().optional()
+}).strict();
+var PublishingProfileModeBindingSchema = object2({
+  metadata: record(string2(), unknown())
+}).strict();
+var PublishingProfileModesSchema = object2({
+  draft: PublishingProfileModeBindingSchema.optional(),
+  live: PublishingProfileModeBindingSchema.optional()
+}).strict().superRefine((modes, ctx) => {
+  if (modes.draft === undefined && modes.live === undefined) {
+    ctx.addIssue({
+      code: "custom",
+      message: 'modes must define at least one of "draft" or "live"'
+    });
+  }
+});
+var PublishingProfileSchema = object2({
+  format: string2().min(1),
+  locale: string2().regex(/^(source|[a-z]{2,3}(-[A-Za-z0-9]+)*)$/, {
+    message: 'locale must be "source" or a valid language tag'
+  }),
+  limits: PublishingProfileLimitsSchema.optional(),
+  requires: PublishingProfileRequiresSchema.optional(),
+  modes: PublishingProfileModesSchema
+}).strict();
+var PublishingCapabilitiesSchema = object2({
+  defaultProfile: string2().min(1),
+  profiles: record(string2().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/), PublishingProfileSchema)
+}).strict().superRefine((data, ctx) => {
+  const keys = Object.keys(data.profiles);
+  if (keys.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["profiles"],
+      message: "profiles record must be nonempty"
+    });
+  }
+  if (!(data.defaultProfile in data.profiles)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultProfile"],
+      message: `defaultProfile "${data.defaultProfile}" must reference a declared profile`
+    });
+  }
+});
 var PluginManifestSchemaBase = looseObject({
   name: string2().min(1),
   kind: PluginKindSchema,
@@ -41575,23 +41906,31 @@ var PluginManifestSchemaBase = looseObject({
   version: string2().optional(),
   description: string2().optional(),
   operations: record(string2(), PluginOperationSchema).optional(),
-  browserSession: BrowserSessionDescriptorSchema.optional()
+  browserSession: BrowserSessionDescriptorSchema.optional(),
+  publishing: PublishingCapabilitiesSchema.optional()
 });
 var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx) => {
-  if (manifest.browserSession === undefined)
-    return;
-  if (manifest.kind !== "publish") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["browserSession"],
-      message: `browserSession requires kind "publish", not "${manifest.kind}"`
-    });
+  if (manifest.browserSession !== undefined) {
+    if (manifest.kind !== "publish") {
+      ctx.addIssue({
+        code: "custom",
+        path: ["browserSession"],
+        message: `browserSession requires kind "publish", not "${manifest.kind}"`
+      });
+    }
+    if (manifest.check === undefined) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["browserSession"],
+        message: "browserSession requires a check probe entry that owns the session routines"
+      });
+    }
   }
-  if (manifest.check === undefined) {
+  if (manifest.publishing !== undefined && manifest.kind !== "publish") {
     ctx.addIssue({
       code: "custom",
-      path: ["browserSession"],
-      message: "browserSession requires a check probe entry that owns the session routines"
+      path: ["publishing"],
+      message: `publishing requires kind "publish", not "${manifest.kind}"`
     });
   }
 });
@@ -41834,7 +42173,8 @@ function consumeManifest(dirPath, expectedKind, origin, plugins, diagnostics, se
     version: manifest.version,
     description: manifest.description,
     ...manifest.operations !== undefined ? { operations: manifest.operations } : {},
-    ...manifest.browserSession !== undefined ? { browserSession: manifest.browserSession } : {}
+    ...manifest.browserSession !== undefined ? { browserSession: manifest.browserSession } : {},
+    ...manifest.publishing !== undefined ? { publishing: manifest.publishing } : {}
   });
 }
 function listSortedDir(absDir) {
@@ -42257,7 +42597,7 @@ var WORKFLOW_SETTINGS = {
   "kk-daily-ai-voice2": {
     window: { kind: "duration" },
     language: { kind: "choice", values: ["en", "zh", "ja"] },
-    vdriver: { kind: "choice", values: ["voicebox", "ominivoice", "gemini"] },
+    vdriver: { kind: "choice", values: ["voicebox", "ominivoice", "gemini", "voxcpm"] },
     skip_review: { kind: "boolean" },
     transcode_mp3: { kind: "boolean" },
     cover_enabled: { kind: "boolean" },
@@ -42290,7 +42630,13 @@ var WORKFLOW_SETTINGS = {
     cover_enabled: { kind: "boolean" },
     inline_images: { kind: "boolean" },
     max_revisions: { kind: "integer" },
-    source_locale: { kind: "choice", values: ["en", "zh", "ja"] }
+    source_locale: { kind: "choice", values: ["en", "zh", "ja"] },
+    writer: { kind: "choice", values: ["itc-generating", "topic"] },
+    playbook: { kind: "choice", values: ["generic", "english", "wechat"] },
+    publish_preset: { kind: "string" },
+    topic_profile: { kind: "string" },
+    publish_targets: { kind: "string" },
+    seo: { kind: "choice", values: ["off", "handoff"] }
   }
 };
 var CONFIDENCE_LEVELS = ["HIGH", "MEDIUM", "LOW"];
@@ -43374,6 +43720,15 @@ function revisionUsage(progress, settings) {
   }
   return { revise, autoRevise, total: revise + autoRevise, budget: revisionBudget(settings), recorded: true };
 }
+function revisionUsageFromChild(parentProgress, childEvidence, childProgress, settings) {
+  const parentStates = asRecord2(parentProgress)?.states;
+  if (Array.isArray(parentStates))
+    return revisionUsage(parentProgress, settings);
+  if (childEvidence.childRunId === null) {
+    return { revise: null, autoRevise: null, total: null, budget: revisionBudget(settings), recorded: false };
+  }
+  return revisionUsage(childProgress, settings);
+}
 function resultRows(parsed) {
   if (parsed === null)
     return [];
@@ -43516,11 +43871,17 @@ function projectItcResults(input) {
     selectedOutline: preview("outline-approved"),
     draft: preview("draft"),
     judge,
-    revisions: revisionUsage(input.progress, record.settings),
+    revisions: input.child === undefined ? revisionUsage(input.progress, record.settings) : revisionUsageFromChild(input.progress, input.child.evidence, input.child.progress, record.settings),
     targets,
     report,
     counts
   };
+  if (input.child !== undefined && input.child.evidence.reason !== null) {
+    diagnostics.push({
+      code: "board.itc.child-unverified",
+      message: `${input.child.evidence.reason}; revision counts and child progress are unavailable.`
+    });
+  }
   if (resultSpecs.length === 0 && reportRecord === null) {
     diagnostics.push({
       code: "board.publish.unavailable",
@@ -45790,7 +46151,7 @@ var ITEM_DECISION_IDS = [
 ];
 var FIRST_SEEN_AT = "first_seen_at";
 var DEFAULT_EXTRACT_LIMIT = 20;
-var PROFILE_KEYS = new Set(["topic", "where", "order", "limit"]);
+var PROFILE_KEYS = new Set(["topic", "where", "order", "limit", "publishPreset"]);
 
 class ProfileInvalidError extends Error {
   constructor(message) {
@@ -45884,7 +46245,14 @@ function parseProfile(yaml) {
     }
     limit = document2.limit;
   }
-  return { topic: topic.trim(), where, order, limit };
+  let publishPreset;
+  if (document2.publishPreset !== undefined) {
+    if (typeof document2.publishPreset !== "string" || !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(document2.publishPreset.trim())) {
+      throw new ProfileInvalidError(`publishPreset: expected a lowercase hyphenated slug, got ${JSON.stringify(document2.publishPreset)}`);
+    }
+    publishPreset = document2.publishPreset.trim();
+  }
+  return { topic: topic.trim(), where, order, limit, ...publishPreset !== undefined ? { publishPreset } : {} };
 }
 function compileProfile(profile, options) {
   return {
@@ -45902,7 +46270,7 @@ init_output2();
 
 // src/stage.ts
 init_dist();
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
 import { realpathSync as realpathSync4, statSync as statSync6 } from "fs";
 import { dirname as dirname6, join as join5, resolve as resolve6 } from "path";
 var STAGES_REL = "plugins/kk/scripts/kk-workflow-stages.ts";
@@ -45964,6 +46332,64 @@ function forwardChildOutput(chunk, write) {
   write(text.endsWith(`
 `) ? text.slice(0, -1) : text);
 }
+var FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+var CANCEL_ESCALATION_MS = 5000;
+var SIGNAL_EXIT_CODES = { SIGINT: 130, SIGTERM: 143, SIGHUP: 129 };
+function runStageCancellable(args, execPath = process.execPath, argv1) {
+  const script = resolveStagesScript(argv1);
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn2(execPath, [script, ...args], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env,
+      detached: true
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout?.on("data", (chunk) => stdoutChunks.push(Buffer.from(chunk)));
+    child.stderr?.on("data", (chunk) => stderrChunks.push(Buffer.from(chunk)));
+    let escalation;
+    const forward = (signal) => {
+      const pid = child.pid;
+      if (pid === undefined)
+        return;
+      try {
+        process.kill(-pid, signal);
+      } catch {
+        try {
+          child.kill(signal);
+        } catch {}
+      }
+      escalation ??= setTimeout(() => {
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch {}
+      }, CANCEL_ESCALATION_MS);
+    };
+    const handlers = new Map;
+    for (const signal of FORWARDED_SIGNALS) {
+      const handler = () => forward(signal);
+      handlers.set(signal, handler);
+      process.on(signal, handler);
+    }
+    const disarm = () => {
+      for (const [signal, handler] of handlers)
+        process.removeListener(signal, handler);
+      handlers.clear();
+      if (escalation !== undefined)
+        clearTimeout(escalation);
+    };
+    child.on("error", (err) => {
+      disarm();
+      rejectPromise(new Error(`failed to spawn stage runner at ${script}: ${err.message}`));
+    });
+    child.on("close", (code, signal) => {
+      disarm();
+      forwardChildOutput(Buffer.concat(stdoutChunks), echo);
+      forwardChildOutput(Buffer.concat(stderrChunks), echoError);
+      resolvePromise(code ?? (signal === null ? 1 : SIGNAL_EXIT_CODES[signal] ?? 1));
+    });
+  });
+}
 
 // src/commands/daily.ts
 var parseJson3 = JSON.parse;
@@ -46867,6 +47293,7 @@ async function dispatchOne(target, dispatch, timeoutMs) {
       ok: false,
       status: "failed",
       error: result.error ?? result.message ?? "publish failed",
+      ...result.metadata !== undefined ? { metadata: result.metadata } : {},
       durationMs
     };
   } catch (err) {
@@ -47322,9 +47749,9 @@ function registerExecutorCommand(program) {
   withRunOptions(executor.command("run").description("Invoke a plugin with input/output files and contract validation").argument("<plugin>", "Name of the plugin to invoke")).action(runInvokeAction);
   withFaninOptions(executor.command("fan-in").alias("fanin").description("Merge N Doc[] JSON inputs into one deduplicated Doc[] output")).action(runFaninAction);
   withFanoutOptions(executor.command("fan-out").alias("fanout").description("Publish one Content JSON to N targets, aggregating per-target results")).action(runFanoutAction);
-  withRunOptions(program.command("invoke", { hidden: true }).description("Alias for `executor run` (deprecated)").argument("<plugin>", "Name of the plugin to invoke")).action(runInvokeAction);
-  withFaninOptions(program.command("fanin", { hidden: true }).description("Alias for `executor fan-in` (deprecated)")).action(runFaninAction);
-  withFanoutOptions(program.command("fanout", { hidden: true }).description("Alias for `executor fan-out` (deprecated)")).action(runFanoutAction);
+  withRunOptions(program.command("invoke", { hidden: true }).description("[deprecated] Alias for `executor run`").argument("<plugin>", "Name of the plugin to invoke")).action(runInvokeAction);
+  withFaninOptions(program.command("fanin", { hidden: true }).description("[deprecated] Alias for `executor fan-in`")).action(runFaninAction);
+  withFanoutOptions(program.command("fanout", { hidden: true }).description("[deprecated] Alias for `executor fan-out`")).action(runFanoutAction);
 }
 
 // src/cli.ts
@@ -47381,9 +47808,10 @@ async function lockReleaseAction(options) {
   }
 }
 function registerLockCommand(parent, hidden = false) {
-  const lock = parent.command("lock", { hidden }).description("Single-flight locks over the store");
-  lock.command("acquire").description("Take the named lock for this run; prints {acquired} or {skipped, holder} (exit 0 both ways)").requiredOption("--name <lock>", "Lock name (e.g. collect)").requiredOption("--run <id>", "Owning run id (re-entrant for the same id)").option("--ttl <ms>", "Claim lifetime for a dead holder, in milliseconds", String(DEFAULT_LOCK_TTL_MS)).option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(lockAcquireAction);
-  lock.command("release").description("Release the named lock iff this run still owns it; prints {released}").requiredOption("--name <lock>", "Lock name (e.g. collect)").requiredOption("--run <id>", "Owning run id").option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(lockReleaseAction);
+  const legacy = hidden ? "[deprecated] " : "";
+  const lock = parent.command("lock", { hidden }).description(`${legacy}Single-flight locks over the store`);
+  lock.command("acquire").description(`${legacy}Take the named lock for this run; prints {acquired} or {skipped, holder} (exit 0 both ways)`).requiredOption("--name <lock>", "Lock name (e.g. collect)").requiredOption("--run <id>", "Owning run id (re-entrant for the same id)").option("--ttl <ms>", "Claim lifetime for a dead holder, in milliseconds", String(DEFAULT_LOCK_TTL_MS)).option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(lockAcquireAction);
+  lock.command("release").description(`${legacy}Release the named lock iff this run still owns it; prints {released}`).requiredOption("--name <lock>", "Lock name (e.g. collect)").requiredOption("--run <id>", "Owning run id").option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(lockReleaseAction);
 }
 
 // src/commands/plugin.ts
@@ -47590,12 +48018,12 @@ function registerPluginCommand(program) {
   registerStatusVerb(plugin, "status", "List discovered plugins grouped by kind with a per-plugin health mark", false);
   plugin.command("check [names...]").description("Run each selected plugin\u2019s readiness probe; exits nonzero on refused or errored plugins").option("--kind <kind>", "Filter plugins by kind (ingestion, generator, publish)").option("--json", "Output machine-readable verdict rows").option("--headed", "Run probes with a visible browser window").option("--timeout <ms>", "Per-plugin probe timeout in milliseconds").option("--plugins-root <dir>", "Exclusive root containing plugins (isolation/tests only)").option("--plugins-path <dir>", "Extra plugin root to union with defaults (repeatable)", collectPath, []).action(checkAction);
   plugin.command("login <name>").description("Run the plugin\u2019s interactive login probe with inherited stdio").option("--plugins-root <dir>", "Exclusive root containing plugins (isolation/tests only)").option("--plugins-path <dir>", "Extra plugin root to union with defaults (repeatable)", collectPath, []).action(loginAction);
-  registerStatusVerb(plugin, "list", "Alias for `plugin status` (deprecated)", true);
-  registerStatusVerb(plugin, "doctor", "Alias for `plugin status` (deprecated)", true);
-  const plugins = program.command("plugins", { hidden: true }).description("Alias for `plugin status` (deprecated)");
-  registerStatusVerb(plugins, "status", "Alias for `plugin status` (deprecated)", true);
-  registerStatusVerb(plugins, "list", "Alias for `plugin status` (deprecated)", true);
-  registerStatusVerb(plugins, "doctor", "Alias for `plugin status` (deprecated)", true);
+  registerStatusVerb(plugin, "list", "[deprecated] Alias for `plugin status`", true);
+  registerStatusVerb(plugin, "doctor", "[deprecated] Alias for `plugin status`", true);
+  const plugins = program.command("plugins", { hidden: true }).description("[deprecated] Alias for `plugin status`");
+  registerStatusVerb(plugins, "status", "[deprecated] Alias for `plugin status`", true);
+  registerStatusVerb(plugins, "list", "[deprecated] Alias for `plugin status`", true);
+  registerStatusVerb(plugins, "doctor", "[deprecated] Alias for `plugin status`", true);
 }
 
 // src/commands/schedule.ts
@@ -47655,123 +48083,2421 @@ function registerScheduleCommand(program) {
 
 // src/commands/stage.ts
 init_commander();
-var ROOT_GLOBALS = new Set(["-v", "--verbose"]);
-function normalizeStageArgs(argv) {
-  let i = 2;
-  while (i < argv.length && ROOT_GLOBALS.has(argv[i])) {
-    i += 1;
-  }
-  const next = argv[i + 1];
-  if (argv[i] !== "stage" || next === undefined || next === "run" || next === "--help" || next === "-h") {
-    return [...argv];
+
+// src/itc-stage.ts
+import { createHash as createHash7 } from "crypto";
+import { join as join19 } from "path";
+init_dist3();
+init_dist();
+
+// src/itc-config.ts
+init_dist3();
+import { createHash as createHash2 } from "crypto";
+import { dirname as dirname10, isAbsolute as isAbsolute8, join as join15, resolve as resolve18 } from "path";
+
+class ItcConfigInvalidError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ItcConfigInvalidError";
   }
-  return [...argv.slice(0, i + 1), "run", ...argv.slice(i + 1)];
-}
-function registerStageCommand(program) {
-  program.command("stage").description("Run a kk-workflow-stages.ts stage (workflow orchestration steps)").command("run").description("Run one stage by name with positional pass-through").argument("<args...>", "Stage name followed by its positional arguments").allowUnknownOption(true).action((args) => {
-    const code = runStage(args);
-    if (code !== 0) {
-      throw new CommanderError(code, "kk.stage.failed", `stage failed with exit code ${code}`);
-    }
-  });
 }
 
-// src/commands/store.ts
-import { dirname as dirname10, join as join15, resolve as resolve18 } from "path";
-init_dist3();
-init_commander();
-init_output2();
-var HEURISTIC_MAKER = "heuristic";
-var LABEL_PLUGIN = "episode-plan-gen";
-var LABEL_SCRATCH_DIR = "label";
-var PROFILE_DIR_REL = "plugins/kk/decisions/extract";
-var CHECKOUT_ROOT3 = resolve18(import.meta.dir, "../../../..");
-var CATALOG_PATH_REL = "plugins/kk/decisions/kk-items.yaml";
-var TOPIC_SLUG = /^[a-z0-9][a-z0-9-]*$/;
-var WINDOW_UNITS = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
-var DEFAULT_EXTRACT_WINDOW = "24h";
-var CATEGORY_DECISION_ID = "kk-item-category";
-var CATEGORY_LABELS = ["ai-news", "ai-technical", "ai-research", "ai-industry", "non-ai"];
-var SCORE_DIMENSIONS = ["quality", "importance", "urgency", "impact"];
-var AUDIENCE_LABELS = ["general", "practitioner", "researcher"];
-var LABEL_DECISIONS = [
-  { id: CATEGORY_DECISION_ID, kind: "choice", labels: CATEGORY_LABELS },
-  { id: "kk-item-quality", kind: "score", levels: 6 },
-  { id: "kk-item-importance", kind: "score", levels: 6 },
-  { id: "kk-item-urgency", kind: "score", levels: 6 },
-  { id: "kk-item-impact", kind: "score", levels: 6 },
-  { id: CHINA_POLITICS_DECISION_ID, kind: "score", levels: 4 },
-  { id: "kk-item-sensitivity", kind: "score", levels: 4 },
-  { id: "kk-item-audience", kind: "choice", labels: AUDIENCE_LABELS }
-];
-var HEURISTIC_DECISION_IDS = [
-  CATEGORY_DECISION_ID,
-  ...SCORE_DIMENSIONS.map((dimension) => `kk-item-${dimension}`)
-];
-var KEYWORD_MAKER = "keyword";
-var CHINA_POLITICS_BODY_HEAD = 200;
-function failLoud5(code, error) {
-  const cause = error instanceof Error ? error.message : String(error);
-  const message = `${code}: ${cause}`;
-  consoleOutput.error(message);
-  throw new CommanderError(1, code, message);
+class ItcLaunchInvalidError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ItcLaunchInvalidError";
+  }
+}
+var COMPILED_DEFAULTS = {
+  writer: "itc-generating",
+  playbook: "generic",
+  sourceLocale: "en",
+  research: false,
+  judge: false,
+  unslop: false,
+  auto: false,
+  maxRevisions: 2,
+  coverEnabled: false,
+  inlineImages: false,
+  publishTargets: "",
+  publishLive: false,
+  seo: "off",
+  dated: false
+};
+var WRITERS = new Set(["itc-generating", "topic"]);
+var PLAYBOOKS = new Set(["generic", "english", "wechat"]);
+var LOCALES = new Set(["en", "zh", "ja"]);
+var SEO_MODES = new Set(["off", "handoff"]);
+var ITC_KEYS = new Set([
+  "writer",
+  "playbook",
+  "source_locale",
+  "research",
+  "judge",
+  "unslop",
+  "auto",
+  "max_revisions",
+  "topic_profile",
+  "publish_preset",
+  "workspace",
+  "seo"
+]);
+var SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function isSafeSlug(value) {
+  return SLUG.test(value);
 }
-async function migrateAction(options) {
+function slugifyTopicName(name) {
+  if (name.includes("\x00"))
+    return null;
+  const normalized = name.normalize("NFC").toLowerCase();
+  const unsafe = new RegExp(`[/\\\\${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}]`);
+  if (unsafe.test(normalized))
+    return null;
+  const slug = normalized.replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "");
+  if (slug === "" || slug === "." || slug === "..")
+    return null;
+  return slug;
+}
+function expandHome3(value, homeDir) {
+  if (value === "~")
+    return homeDir;
+  if (value.startsWith("~/"))
+    return join15(homeDir, value.slice(2));
+  return value;
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value ?? null);
+  if (Array.isArray(value))
+    return `[${value.map(canonicalJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+}
+function digestItcOptions(options) {
+  return createHash2("sha256").update(canonicalJson(options)).digest("hex");
+}
+function resolveItcConfigPath(env, homeDir) {
+  const explicit = env.KK_CONFIG;
+  if (explicit !== undefined && explicit.trim() !== "")
+    return expandHome3(explicit.trim(), homeDir);
+  return join15(homeDir, ".config", "kk", "config.yaml");
+}
+async function readItcConfigBlock(configPath, fs = createNodeFileSystem()) {
+  if (!await fs.exists(configPath))
+    return {};
+  let text;
   try {
-    const dbPath = await resolveStorePath(resolveKkConfigPath(), options.db);
-    const store = await openStore({ path: dbPath });
-    const applied = store.appliedMigrations;
-    await store.close();
-    consoleOutput.write(JSON.stringify({ db: dbPath, applied }));
-  } catch (error) {
-    failLoud5("kk.store.migrate.failed", error);
+    text = await fs.readFile(configPath);
+  } catch {
+    throw new ItcConfigInvalidError(`config file is unreadable: ${configPath}`);
   }
-}
-async function readDocList2(fs, path, label) {
-  if (!await fs.exists(path)) {
-    throw new Error(`input file not found: ${path}`);
+  let parsed;
+  try {
+    parsed = Bun.YAML.parse(text);
+  } catch {
+    throw new ItcConfigInvalidError(`config file is not valid YAML: ${configPath}`);
   }
-  return readPluginJson(fs, path, DocListSchema, label, "is not a Doc[]");
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new ItcConfigInvalidError(`config file has no top-level mapping: ${configPath}`);
+  }
+  const root = parsed;
+  for (const key of ["works_dir", "workflows_dir"]) {
+    if (root[key] !== undefined && (typeof root[key] !== "string" || root[key].trim() === "")) {
+      throw new ItcConfigInvalidError(`config key '${key}' must be a nonempty path string`);
+    }
+  }
+  const workflows = root.workflows;
+  if (workflows === undefined)
+    return {};
+  if (workflows === null || typeof workflows !== "object" || Array.isArray(workflows)) {
+    throw new ItcConfigInvalidError("config key 'workflows' must be a mapping");
+  }
+  const block = workflows["kk-itc"];
+  if (block === undefined)
+    return {};
+  if (block === null || typeof block !== "object" || Array.isArray(block)) {
+    throw new ItcConfigInvalidError("config key 'workflows.kk-itc' must be a mapping");
+  }
+  return validateItcBlock(block);
 }
-async function invalidatedIds(items, docs) {
-  const byId = new Map;
-  for (const doc of docs) {
-    byId.set(itemId(doc), doc);
+function validateItcBlock(raw) {
+  for (const key of Object.keys(raw)) {
+    if (!ITC_KEYS.has(key)) {
+      throw new ItcConfigInvalidError(`config key 'workflows.kk-itc.${key}' is not a declared ITC setting (allowed: ${[...ITC_KEYS].join(", ")})`);
+    }
   }
-  const invalidated = [];
-  for (const [id, doc] of byId) {
-    const stored = await items.findById(id);
-    if (stored === undefined) {
-      continue;
+  const out = {};
+  const enumAt = (key, allowed) => {
+    const value = raw[key];
+    if (value === undefined)
+      return;
+    if (typeof value !== "string" || !allowed.has(value)) {
+      throw new ItcConfigInvalidError(`config key 'workflows.kk-itc.${key}' must be one of ${[...allowed].join("|")}`);
     }
-    if (stored.title !== (doc.title ?? "") || stored.body !== doc.body) {
-      invalidated.push(id);
+    return value;
+  };
+  const boolAt = (key) => {
+    const value = raw[key];
+    if (value === undefined)
+      return;
+    if (typeof value !== "boolean") {
+      throw new ItcConfigInvalidError(`config key 'workflows.kk-itc.${key}' must be a boolean`);
+    }
+    return value;
+  };
+  const slugAt = (key) => {
+    const value = raw[key];
+    if (value === undefined)
+      return;
+    if (typeof value !== "string" || !isSafeSlug(value)) {
+      throw new ItcConfigInvalidError(`config key 'workflows.kk-itc.${key}' must be a lowercase hyphenated slug`);
     }
+    return value;
+  };
+  const writer = enumAt("writer", WRITERS);
+  if (writer !== undefined)
+    out.writer = writer;
+  const playbook = enumAt("playbook", PLAYBOOKS);
+  if (playbook !== undefined)
+    out.playbook = playbook;
+  const sourceLocale = enumAt("source_locale", LOCALES);
+  if (sourceLocale !== undefined)
+    out.source_locale = sourceLocale;
+  for (const key of ["research", "judge", "unslop", "auto"]) {
+    const value = boolAt(key);
+    if (value !== undefined)
+      out[key] = value;
   }
-  return invalidated;
-}
-function sourceCountsOf2(docs) {
-  const counts = {};
-  for (const doc of docs) {
-    const sources = doc.metadata?.sources;
-    if (!Array.isArray(sources))
-      continue;
-    for (const source of sources) {
-      const file = source?.file;
-      if (typeof file === "string" && file !== "")
-        counts[file] = (counts[file] ?? 0) + 1;
+  const maxRevisions = raw.max_revisions;
+  if (maxRevisions !== undefined) {
+    if (typeof maxRevisions !== "number" || !Number.isInteger(maxRevisions) || maxRevisions < 0 || maxRevisions > 10) {
+      throw new ItcConfigInvalidError("config key 'workflows.kk-itc.max_revisions' must be an integer from 0 to 10");
     }
+    out.max_revisions = maxRevisions;
   }
-  return counts;
-}
-async function writeNewIds(fs, path, ids) {
-  await fs.ensureDir(dirname10(path));
-  await fs.writeFile(path, `${JSON.stringify([...new Set(ids)], null, 2)}
-`);
-}
-async function ingestAction(options) {
-  try {
-    const fs = createNodeFileSystem();
+  const topicProfile = slugAt("topic_profile");
+  if (topicProfile !== undefined)
+    out.topic_profile = topicProfile;
+  const publishPreset = slugAt("publish_preset");
+  if (publishPreset !== undefined)
+    out.publish_preset = publishPreset;
+  const workspace = raw.workspace;
+  if (workspace !== undefined) {
+    if (workspace === null || typeof workspace !== "object" || Array.isArray(workspace)) {
+      throw new ItcConfigInvalidError("config key 'workflows.kk-itc.workspace' must be a mapping");
+    }
+    const ws = workspace;
+    for (const key of Object.keys(ws)) {
+      if (key !== "dated") {
+        throw new ItcConfigInvalidError(`config key 'workflows.kk-itc.workspace.${key}' is not declared`);
+      }
+    }
+    if (ws.dated !== undefined && typeof ws.dated !== "boolean") {
+      throw new ItcConfigInvalidError("config key 'workflows.kk-itc.workspace.dated' must be a boolean");
+    }
+    out.workspace = ws.dated === undefined ? {} : { dated: ws.dated };
+  }
+  const seo = raw.seo;
+  if (seo !== undefined) {
+    if (seo === null || typeof seo !== "object" || Array.isArray(seo)) {
+      throw new ItcConfigInvalidError("config key 'workflows.kk-itc.seo' must be a mapping");
+    }
+    const seoRecord = seo;
+    for (const key of Object.keys(seoRecord)) {
+      if (key !== "mode") {
+        throw new ItcConfigInvalidError(`config key 'workflows.kk-itc.seo.${key}' is not declared`);
+      }
+    }
+    const mode = seoRecord.mode;
+    if (mode !== undefined) {
+      if (typeof mode !== "string" || !SEO_MODES.has(mode)) {
+        throw new ItcConfigInvalidError("config key 'workflows.kk-itc.seo.mode' must be one of off|handoff");
+      }
+      out.seo = { mode };
+    } else {
+      out.seo = {};
+    }
+  }
+  return out;
+}
+async function readWorksRoot(configPath, env, homeDir, fs) {
+  const fromEnv = env.KK_WORKS_DIR;
+  if (fromEnv !== undefined && fromEnv.trim() !== "") {
+    const expanded = expandHome3(fromEnv.trim(), homeDir);
+    return isAbsolute8(expanded) ? expanded : resolve18(process.cwd(), expanded);
+  }
+  if (!await fs.exists(configPath))
+    return join15(homeDir, ".config", "kk", "works");
+  try {
+    const parsed = Bun.YAML.parse(await fs.readFile(configPath));
+    const raw = parsed?.works_dir;
+    if (typeof raw === "string" && raw.trim() !== "") {
+      const expanded = expandHome3(raw.trim(), homeDir);
+      return isAbsolute8(expanded) ? expanded : resolve18(dirname10(configPath), expanded);
+    }
+  } catch {}
+  return join15(homeDir, ".config", "kk", "works");
+}
+function parseRunDate(raw) {
+  if (!/^\d{8}$/.test(raw))
+    return null;
+  const year = Number(raw.slice(0, 4));
+  const month = Number(raw.slice(4, 6));
+  const day = Number(raw.slice(6, 8));
+  const date = new Date(Date.UTC(year, month - 1, day));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day)
+    return null;
+  return raw;
+}
+function resolveSource(input) {
+  const topic = input.topic !== undefined && input.topic !== "" ? input.topic : undefined;
+  const inputFile = input.inputFile !== undefined && input.inputFile !== "" ? input.inputFile : undefined;
+  const fromCollect = input.fromCollect !== undefined && input.fromCollect !== "" ? input.fromCollect : undefined;
+  const set = [topic, inputFile, fromCollect].filter((v) => v !== undefined);
+  if (set.length === 0) {
+    throw new ItcLaunchInvalidError("exactly one of --topic, --input-file or --from-collect is required");
+  }
+  if (set.length > 1) {
+    throw new ItcLaunchInvalidError("exactly one of --topic, --input-file or --from-collect is required (two given)");
+  }
+  if (topic !== undefined)
+    return { sourceKind: "topic", sourceValue: topic };
+  if (inputFile !== undefined)
+    return { sourceKind: "input_file", sourceValue: inputFile };
+  return { sourceKind: "from_collect", sourceValue: fromCollect };
+}
+function pick2(...values) {
+  for (const value of values)
+    if (value !== undefined)
+      return value;
+  return;
+}
+async function resolveItcOptions(input, context = {}, fs = createNodeFileSystem()) {
+  const env = context.env ?? process.env;
+  const homeDir = context.homeDir ?? env.HOME ?? "~";
+  const cwd = context.cwd ?? process.cwd();
+  const now = context.now ?? (() => new Date);
+  const configPath = resolveItcConfigPath(env, homeDir);
+  const block = await readItcConfigBlock(configPath, fs);
+  const worksRoot = await readWorksRoot(configPath, env, homeDir, fs);
+  const source = resolveSource(input);
+  const autoFromFlag = input.auto;
+  const autoFromConfig = block.auto;
+  const autoEffective = pick2(autoFromFlag, autoFromConfig) ?? COMPILED_DEFAULTS.auto;
+  const autoIsExplicitLaunch = autoFromFlag !== undefined;
+  const impliedWhenAuto = (value, configured) => {
+    if (value !== undefined)
+      return value;
+    if (autoIsExplicitLaunch && autoEffective)
+      return true;
+    if (configured !== undefined)
+      return configured;
+    if (autoEffective)
+      return true;
+    return;
+  };
+  const playbook = pick2(input.playbook, block.playbook) ?? COMPILED_DEFAULTS.playbook;
+  if (!PLAYBOOKS.has(playbook)) {
+    throw new ItcLaunchInvalidError(`--playbook must be one of ${[...PLAYBOOKS].join("|")}`);
+  }
+  const writer = pick2(input.writer, block.writer) ?? COMPILED_DEFAULTS.writer;
+  if (!WRITERS.has(writer)) {
+    throw new ItcLaunchInvalidError(`--writer must be one of ${[...WRITERS].join("|")}`);
+  }
+  const explicitLocale = pick2(input.sourceLocale, block.source_locale);
+  const sourceLocale = explicitLocale ?? (playbook === "wechat" ? "zh" : COMPILED_DEFAULTS.sourceLocale);
+  if (!LOCALES.has(sourceLocale)) {
+    throw new ItcLaunchInvalidError(`--source-locale must be one of ${[...LOCALES].join("|")}`);
+  }
+  const maxRevisions = pick2(input.maxRevisions, block.max_revisions) ?? COMPILED_DEFAULTS.maxRevisions;
+  if (!Number.isInteger(maxRevisions) || maxRevisions < 0 || maxRevisions > 10) {
+    throw new ItcLaunchInvalidError("--max-revisions must be an integer from 0 to 10");
+  }
+  const seo = pick2(input.seo, block.seo?.mode) ?? COMPILED_DEFAULTS.seo;
+  if (!SEO_MODES.has(seo)) {
+    throw new ItcLaunchInvalidError("--seo must be one of off|handoff");
+  }
+  const publishPreset = pick2(input.publishPreset, block.publish_preset);
+  if (publishPreset !== undefined && !isSafeSlug(publishPreset)) {
+    throw new ItcLaunchInvalidError("--publish-preset must be a lowercase hyphenated slug");
+  }
+  const topicProfile = pick2(input.topicProfile, block.topic_profile);
+  if (topicProfile !== undefined && !isSafeSlug(topicProfile)) {
+    throw new ItcLaunchInvalidError("--topic-profile must be a lowercase hyphenated slug");
+  }
+  const runDateInput = input.runDate;
+  let runDate = null;
+  if (runDateInput !== undefined && runDateInput !== "") {
+    runDate = parseRunDate(runDateInput);
+    if (runDate === null) {
+      throw new ItcLaunchInvalidError("--run-date must be a real calendar date as YYYYMMDD");
+    }
+  }
+  const force = input.force ?? false;
+  const frozen = now();
+  if (runDate === null && block.workspace?.dated) {
+    runDate = `${frozen.getFullYear()}${String(frozen.getMonth() + 1).padStart(2, "0")}${String(frozen.getDate()).padStart(2, "0")}`;
+  }
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const intake = source.sourceKind === "from_collect";
+  const draft = {
+    schemaVersion: 1,
+    status: intake ? "intake" : "prepared",
+    parentRunId: input.parentRunId ?? "",
+    launchProjectRoot: resolve18(input.projectRoot ?? cwd),
+    worksRoot,
+    workDir: null,
+    topicName: intake ? null : source.sourceValue,
+    displayTitle: null,
+    writer,
+    playbook,
+    sourceLocale,
+    research: impliedWhenAuto(input.research, block.research) ?? COMPILED_DEFAULTS.research,
+    judge: impliedWhenAuto(input.judge, block.judge) ?? COMPILED_DEFAULTS.judge,
+    unslop: impliedWhenAuto(input.unslop, block.unslop) ?? COMPILED_DEFAULTS.unslop,
+    auto: autoEffective,
+    maxRevisions,
+    coverEnabled: input.coverEnabled ?? COMPILED_DEFAULTS.coverEnabled,
+    inlineImages: input.inlineImages ?? COMPILED_DEFAULTS.inlineImages,
+    publishTargets: input.publishTargets ?? COMPILED_DEFAULTS.publishTargets,
+    publishLive: input.publishLive ?? COMPILED_DEFAULTS.publishLive,
+    publishPreset: publishPreset ?? null,
+    publishPresetSource: input.publishPreset !== undefined ? "launch" : publishPreset !== undefined ? "config" : null,
+    topicProfile: topicProfile ?? null,
+    seo,
+    sourceKind: source.sourceKind,
+    sourceValue: source.sourceValue,
+    refreshCollect: input.refreshCollect ?? false,
+    dated: runDate !== null,
+    force,
+    timezone,
+    runDate
+  };
+  const expandedInput = {
+    ...input,
+    ...input.dir !== undefined ? { dir: expandHome3(input.dir, homeDir) } : {},
+    ...input.workDir !== undefined ? { workDir: expandHome3(input.workDir, homeDir) } : {}
+  };
+  const withWorkspace = intake ? draft : applyWorkspace(draft, expandedInput);
+  return {
+    ...withWorkspace,
+    frozenAt: frozen.toISOString(),
+    optionsDigest: digestItcOptions(withWorkspace)
+  };
+}
+function workspaceNameFor(sourceKind, value) {
+  if (sourceKind === "topic")
+    return value;
+  const base = value.split(/[/\\]/).pop() ?? "";
+  const stem = base.replace(/\.[^.]*$/, "");
+  return stem === "" ? "itc-run" : stem;
+}
+function applyWorkspace(draft, input) {
+  const workspace = resolveItcWorkspace(draft, workspaceNameFor(draft.sourceKind, draft.sourceValue), input);
+  return { ...draft, status: "prepared", workDir: workspace.workDir, topicName: workspace.topicName };
+}
+function finalizeItcCollectedOptions(options, chosen, input = {}) {
+  const { optionsDigest: _intakeDigest, frozenAt, ...draft } = options;
+  const workspace = resolveItcWorkspace(draft, chosen.topicName, input);
+  const prepared = {
+    ...draft,
+    status: "prepared",
+    workDir: workspace.workDir,
+    topicName: workspace.topicName,
+    displayTitle: chosen.displayTitle,
+    topicProfile: draft.topicProfile ?? chosen.topicProfile
+  };
+  return { ...prepared, frozenAt, optionsDigest: digestItcOptions(prepared) };
+}
+function resolveItcWorkspace(options, topic, input = {}) {
+  const slug = slugifyTopicName(topic);
+  if (slug === null) {
+    throw new ItcLaunchInvalidError(`topic name '${topic}' cannot form a safe workspace path; pass an explicit --dir or a lowercase slug topic`);
+  }
+  const override = input.dir ?? input.workDir;
+  if (override !== undefined && override.trim() !== "") {
+    const expanded = override.trim().replace(/^~(?=\/|$)/, "");
+    const base = expanded === override.trim() ? override.trim() : expanded;
+    return {
+      workDir: isAbsolute8(base) ? base : resolve18(options.launchProjectRoot, base),
+      topicName: slug,
+      dated: input.runDate !== undefined
+    };
+  }
+  const leaf = options.runDate !== null ? join15(slug, options.runDate) : slug;
+  return { workDir: join15(options.worksRoot, "kk-itc", leaf), topicName: slug, dated: options.runDate !== null };
+}
+async function writeItcOptionsSnapshot(workDir, options, fs = createNodeFileSystem()) {
+  const path = join15(workDir, "itc-options.json");
+  await fs.ensureDir(workDir);
+  await fs.writeFile(path, `${JSON.stringify(options, null, 2)}
+`);
+  return path;
+}
+async function verifyItcOptionsSnapshot(workDir, options, fs = createNodeFileSystem()) {
+  const path = join15(workDir, "itc-options.json");
+  if (!await fs.exists(path))
+    return { ok: true };
+  let saved;
+  try {
+    saved = JSON.parse(await fs.readFile(path));
+  } catch {
+    return { ok: false, reason: `existing snapshot is unreadable or invalid JSON: ${path}` };
+  }
+  const frozenKeys = [
+    "schemaVersion",
+    "worksRoot",
+    "workDir",
+    "topicName",
+    "sourceLocale",
+    "publishPreset",
+    "publishTargets",
+    "publishLive",
+    "seo",
+    "maxRevisions",
+    "optionsDigest"
+  ];
+  for (const key of frozenKeys) {
+    if (saved[key] !== options[key]) {
+      return {
+        ok: false,
+        reason: `resume refused: frozen option '${key}' changed (${String(saved[key])} -> ${String(options[key])})`
+      };
+    }
+  }
+  return { ok: true };
+}
+
+// src/itc-decision.ts
+init_dist3();
+init_zod();
+import { createHash as createHash3 } from "crypto";
+import { dirname as dirname11 } from "path";
+var ItcDecisionCandidateSchema = object2({
+  id: string2().min(1),
+  title: string2().optional(),
+  description: string2().optional(),
+  metadata: record(string2(), unknown()).optional()
+}).strict();
+var ItcDecisionRequestSchema = object2({
+  schemaVersion: literal(1).default(1),
+  parentRunId: string2().min(1),
+  decisionId: _enum2(["kk-itc-topic-choice", "kk-itc-outline-choice", "kk-itc-preset-choice"]),
+  candidateDigest: string2().min(1).optional(),
+  candidates: array(ItcDecisionCandidateSchema).min(1),
+  evidenceFiles: array(string2()).default([]),
+  outPath: string2().min(1),
+  maker: string2().optional(),
+  explicitChoice: string2().optional()
+}).strict();
+async function compactEvidenceFile(fs, filePath) {
+  if (!await fs.exists(filePath))
+    return;
+  try {
+    const text = await fs.readFile(filePath);
+    const originalLength = text.length;
+    const truncated = originalLength > 1800;
+    const content = text.slice(0, 1800);
+    return {
+      file: filePath,
+      originalLength,
+      retainedLength: content.length,
+      truncated,
+      content
+    };
+  } catch {
+    return;
+  }
+}
+async function itcDecision(request, fs = createNodeFileSystem(), executor = new NodeProcessExecutor) {
+  const fallback = request.decisionId === "kk-itc-preset-choice" ? "none" : "defer";
+  const candidateDigest = request.candidateDigest ?? createHash3("sha256").update(JSON.stringify(request.candidates)).digest("hex");
+  const validCandidateIds = new Set(request.candidates.map((c) => c.id));
+  const allowedValues = new Set;
+  if (request.decisionId === "kk-itc-preset-choice") {
+    allowedValues.add("suggested");
+    allowedValues.add("none");
+  } else {
+    for (const id of validCandidateIds) {
+      allowedValues.add(id);
+    }
+    allowedValues.add("defer");
+  }
+  await fs.ensureDir(dirname11(request.outPath));
+  if (request.explicitChoice !== undefined) {
+    const choice = request.explicitChoice.trim();
+    const isValid = allowedValues.has(choice);
+    const selectedValue = isValid ? choice : fallback;
+    const result = {
+      schemaVersion: 1,
+      parentRunId: request.parentRunId,
+      decisionId: request.decisionId,
+      candidateDigest,
+      value: selectedValue,
+      source: isValid ? "explicit" : "default",
+      reason: isValid ? "explicit operator choice" : `explicit choice '${choice}' was not allowed; fell back to '${fallback}'`,
+      maker: "operator",
+      selected: selectedValue !== fallback
+    };
+    await fs.writeFile(request.outPath, `${JSON.stringify(result, null, 2)}
+`);
+    return result;
+  }
+  const tmpEvidenceFiles = [];
+  const evidenceArgs = [];
+  const evidenceFiles = request.evidenceFiles ?? [];
+  for (const [index, ef] of evidenceFiles.entries()) {
+    const compacted = await compactEvidenceFile(fs, ef);
+    if (compacted) {
+      const tmpPath = `${request.outPath}.evidence-${index}.json`;
+      await fs.writeFile(tmpPath, JSON.stringify(compacted));
+      tmpEvidenceFiles.push(tmpPath);
+      evidenceArgs.push("--evidence", tmpPath);
+    }
+  }
+  let paramKey = "candidates";
+  if (request.decisionId === "kk-itc-outline-choice")
+    paramKey = "options";
+  if (request.decisionId === "kk-itc-preset-choice")
+    paramKey = "suggestion";
+  const paramValue = request.candidates.map((c) => `${c.id}: ${c.title ?? c.description ?? c.id}`).join("; ");
+  const spurBin = process.env.SPUR_BIN || "spur";
+  const argv = [
+    "decision",
+    "run",
+    request.decisionId,
+    "--param",
+    `${paramKey}=${paramValue}`,
+    ...evidenceArgs,
+    ...request.maker ? ["--maker", request.maker] : [],
+    "--json"
+  ];
+  let resultValue = fallback;
+  let resultSource = "default";
+  let resultReason = "decision run invocation failed";
+  let resultMaker = "catalog-fallback";
+  let resultConfidence = null;
+  try {
+    const res = await executor.run({
+      command: spurBin,
+      args: argv,
+      env: process.env,
+      timeout: 30000
+    });
+    const stdout = typeof res.stdout === "string" ? res.stdout : "";
+    const stderr = typeof res.stderr === "string" ? res.stderr : "";
+    if (res.exitCode === 0 && stdout !== "") {
+      try {
+        const parsed = JSON.parse(stdout);
+        const val = typeof parsed.value === "string" ? parsed.value.trim() : String(parsed.value ?? "");
+        if (allowedValues.has(val)) {
+          resultValue = val;
+          resultSource = parsed.source === "default" ? "default" : "model";
+          resultReason = typeof parsed.reason === "string" ? parsed.reason : "model decision";
+          resultMaker = typeof parsed.maker === "string" ? parsed.maker : "model";
+          resultConfidence = typeof parsed.confidence === "number" ? parsed.confidence : null;
+        } else {
+          resultValue = fallback;
+          resultSource = "default";
+          resultReason = `model output "${val}" is not among valid candidates [${[...validCandidateIds].join(", ")}]`;
+          resultMaker = typeof parsed.maker === "string" ? parsed.maker : "catalog-fallback";
+        }
+      } catch (jsonErr) {
+        resultReason = `failed to parse decision json: ${jsonErr instanceof Error ? jsonErr.message : String(jsonErr)}`;
+      }
+    } else {
+      resultReason = `spur decision run exited with code ${res.exitCode ?? 1}: ${stderr.trim() || "unknown error"}`;
+    }
+  } catch (spawnErr) {
+    resultReason = `failed to spawn spur decision run: ${spawnErr instanceof Error ? spawnErr.message : String(spawnErr)}`;
+  } finally {
+    for (const tf of tmpEvidenceFiles) {
+      try {
+        await fs.deleteFile(tf);
+      } catch {}
+    }
+  }
+  const decisionResult = {
+    schemaVersion: 1,
+    parentRunId: request.parentRunId,
+    decisionId: request.decisionId,
+    candidateDigest,
+    value: resultValue,
+    source: resultSource,
+    reason: resultReason,
+    maker: resultMaker,
+    selected: resultValue !== fallback,
+    ...resultConfidence !== null ? { confidence: resultConfidence } : {}
+  };
+  await fs.writeFile(request.outPath, `${JSON.stringify(decisionResult, null, 2)}
+`);
+  return decisionResult;
+}
+
+// src/itc-plan.ts
+import { createHash as createHash4 } from "crypto";
+import { join as join16, resolve as resolve19 } from "path";
+init_dist3();
+init_zod();
+var ItcTargetsOriginSchema = _enum2([
+  "explicit-targets",
+  "explicit-preset",
+  "workflow-config",
+  "topic-profile",
+  "none"
+]);
+var ItcPlanTargetRequestSchema = object2({
+  plugin: string2().min(1),
+  profile: string2().min(1).optional()
+}).strict();
+var PublishPresetTargetSchema = object2({
+  plugin: string2().min(1),
+  profile: string2().min(1).optional()
+}).strict();
+var PublishPresetSchema = object2({
+  schemaVersion: literal(1).default(1),
+  name: string2().min(1),
+  targets: array(PublishPresetTargetSchema).min(1)
+}).strict();
+var ItcPlanRequestSchema = object2({
+  schemaVersion: literal(1).optional(),
+  workDir: string2().min(1),
+  sourceLocale: string2().min(1),
+  live: boolean2(),
+  targets: array(ItcPlanTargetRequestSchema),
+  origin: ItcTargetsOriginSchema.optional(),
+  presetName: string2().optional(),
+  presetDigest: string2().optional(),
+  sourceContentDigest: string2().optional(),
+  configDigest: string2().optional()
+});
+var SLUG_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+async function resolveDefaultPackageRoot(fs) {
+  let dir = resolve19(process.cwd());
+  for (;; ) {
+    if (await fs.exists(join16(dir, "plugins/kk/publish-presets")))
+      return dir;
+    const parent = resolve19(dir, "..");
+    if (parent === dir)
+      return process.cwd();
+    dir = parent;
+  }
+}
+function parseTargetTokens(raw) {
+  const tokens = raw.split(",").map((t) => t.trim()).filter(Boolean);
+  if (tokens.length === 0) {
+    throw new Error("explicit targets input is empty");
+  }
+  return tokens.map((token) => {
+    const colonIdx = token.indexOf(":");
+    if (colonIdx !== -1) {
+      return {
+        plugin: token.slice(0, colonIdx),
+        profile: token.slice(colonIdx + 1)
+      };
+    }
+    return { plugin: token };
+  });
+}
+function normalizeTargetList(targets) {
+  if (targets.length === 0) {
+    throw new Error("explicit targets input is empty");
+  }
+  const pluginProfiles = new Map;
+  const unique = [];
+  for (const t of targets) {
+    if (pluginProfiles.has(t.plugin)) {
+      const existing = pluginProfiles.get(t.plugin);
+      if (existing !== t.profile) {
+        throw new Error(`conflicting profiles for plugin ${t.plugin}: "${existing ?? ""}" vs "${t.profile ?? ""}"`);
+      }
+      continue;
+    }
+    pluginProfiles.set(t.plugin, t.profile);
+    unique.push({ plugin: t.plugin, ...t.profile ? { profile: t.profile } : {} });
+  }
+  return unique;
+}
+async function resolvePresetFromRoots(fs, slug, projectRoot, packageRoot) {
+  if (!SLUG_REGEX.test(slug)) {
+    throw new Error(`invalid publish preset slug '${slug}': must be lowercase alphanumeric with hyphens`);
+  }
+  const projectDir = resolve19(projectRoot, ".kk/publish-presets");
+  const projectPath = resolve19(projectDir, `${slug}.json`);
+  if (await fs.exists(projectPath)) {
+    return readPresetFile(fs, projectPath, projectDir, slug);
+  }
+  const pkgDir = resolve19(packageRoot, "plugins/kk/publish-presets");
+  const pkgPath = resolve19(pkgDir, `${slug}.json`);
+  if (await fs.exists(pkgPath)) {
+    return readPresetFile(fs, pkgPath, pkgDir, slug);
+  }
+  throw new Error(`publish preset '${slug}' not found in ${projectPath} or ${pkgPath}`);
+}
+async function readPresetFile(fs, path, root, slug) {
+  if (!path.startsWith(root)) {
+    throw new Error(`path traversal rejected for preset '${slug}'`);
+  }
+  let text;
+  try {
+    text = await fs.readFile(path);
+  } catch (err) {
+    throw new Error(`malformed publish preset at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let parsed;
+  try {
+    parsed = PublishPresetSchema.safeParse(JSON.parse(text));
+  } catch (err) {
+    throw new Error(`malformed publish preset at ${path}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  if (!parsed.success) {
+    throw new Error(`malformed publish preset at ${path}: ${parsed.error.message}`);
+  }
+  return { preset: parsed.data, digest: createHash4("sha256").update(text).digest("hex") };
+}
+async function resolveItcTargets(input, fs = createNodeFileSystem()) {
+  const projectRoot = input.projectRoot ? resolve19(input.projectRoot) : process.cwd();
+  const packageRoot = input.packageRoot ? resolve19(input.packageRoot) : await resolveDefaultPackageRoot(fs);
+  if (input.explicitTargets !== undefined) {
+    if (typeof input.explicitTargets === "string") {
+      if (input.explicitTargets.trim() === "") {
+        throw new Error("explicit targets input is empty");
+      }
+      const parsed = parseTargetTokens(input.explicitTargets);
+      return {
+        targets: normalizeTargetList(parsed),
+        origin: "explicit-targets"
+      };
+    }
+    if (Array.isArray(input.explicitTargets)) {
+      if (input.explicitTargets.length === 0) {
+        throw new Error("explicit targets input is empty");
+      }
+      return {
+        targets: normalizeTargetList(input.explicitTargets),
+        origin: "explicit-targets"
+      };
+    }
+  }
+  if (input.explicitPreset !== undefined) {
+    if (input.explicitPreset.trim() === "") {
+      throw new Error("explicit publish preset input is empty");
+    }
+    const { preset, digest } = await resolvePresetFromRoots(fs, input.explicitPreset.trim(), projectRoot, packageRoot);
+    return {
+      targets: normalizeTargetList(preset.targets),
+      origin: "explicit-preset",
+      presetName: preset.name,
+      presetDigest: digest
+    };
+  }
+  if (input.workflowConfigPreset !== undefined) {
+    if (input.workflowConfigPreset.trim() === "") {
+      throw new Error("workflow config publish preset input is empty");
+    }
+    const { preset, digest } = await resolvePresetFromRoots(fs, input.workflowConfigPreset.trim(), projectRoot, packageRoot);
+    return {
+      targets: normalizeTargetList(preset.targets),
+      origin: "workflow-config",
+      presetName: preset.name,
+      presetDigest: digest
+    };
+  }
+  if (input.topicProfile !== undefined) {
+    const topicSlug = input.topicProfile.trim();
+    if (!SLUG_REGEX.test(topicSlug)) {
+      throw new Error("topicProfile must be a lowercase hyphenated slug");
+    }
+    const profilePath = input.topicProfilePath !== undefined && await fs.exists(input.topicProfilePath) ? input.topicProfilePath : resolve19(packageRoot, "plugins/kk/decisions/extract", `${topicSlug}.yaml`);
+    if (await fs.exists(profilePath)) {
+      const profile = parseProfile(await fs.readFile(profilePath));
+      if (profile.publishPreset) {
+        const { preset, digest } = await resolvePresetFromRoots(fs, profile.publishPreset, projectRoot, packageRoot);
+        return {
+          targets: normalizeTargetList(preset.targets),
+          origin: "topic-profile",
+          presetName: preset.name,
+          presetDigest: digest
+        };
+      }
+    }
+  }
+  return {
+    targets: [],
+    origin: "none"
+  };
+}
+async function hasCoverImage(fs, workDir) {
+  const dir = join16(workDir, "4-illustrations");
+  if (!await fs.exists(dir))
+    return false;
+  try {
+    const files = await fs.readDir(dir);
+    return files.some((f) => f.startsWith("cover."));
+  } catch {
+    return false;
+  }
+}
+async function hasOrderedImages(fs, workDir) {
+  const path = join16(workDir, "4-publish", "content.json");
+  if (!await fs.exists(path))
+    return false;
+  try {
+    const data = JSON.parse(await fs.readFile(path));
+    const images = data.metadata?.images;
+    return Array.isArray(images) && images.length > 0 && (await Promise.all(images.map(async (img) => typeof img === "string" && img.trim().length > 0 && await fs.exists(resolve19(workDir, img))))).every(Boolean);
+  } catch {
+    return false;
+  }
+}
+async function buildItcPublishPlan(request, plugins, fs = createNodeFileSystem()) {
+  const pluginsByName = new Map(plugins.map((p) => [p.name, p]));
+  const hasCover = await hasCoverImage(fs, request.workDir);
+  const pluginProfiles = new Map;
+  const uniqueTargets = [];
+  for (const t of request.targets) {
+    const plugin = pluginsByName.get(t.plugin);
+    if (plugin?.kind !== "publish" || !plugin.publishing) {
+      throw new Error(`unsupported publish target: ${t.plugin} (unknown or not an article target)`);
+    }
+    const profileName = t.profile ?? plugin.publishing.defaultProfile;
+    const existingProfile = pluginProfiles.get(t.plugin);
+    if (existingProfile !== undefined) {
+      if (existingProfile !== profileName) {
+        throw new Error(`conflicting profiles for plugin ${t.plugin}: "${existingProfile}" vs "${profileName}"`);
+      }
+      continue;
+    }
+    pluginProfiles.set(t.plugin, profileName);
+    uniqueTargets.push({ plugin: t.plugin, profile: profileName });
+  }
+  const variants = {};
+  const fanoutMap = new Map;
+  const browser = [];
+  const targetDetails = [];
+  for (const targetReq of uniqueTargets) {
+    const plugin = pluginsByName.get(targetReq.plugin);
+    if (!plugin?.publishing) {
+      continue;
+    }
+    const profileName = targetReq.profile ?? plugin.publishing.defaultProfile;
+    const profile = plugin.publishing.profiles[profileName];
+    if (!profile) {
+      throw new Error(`target ${targetReq.plugin} has no profile "${profileName}"`);
+    }
+    const modeKey = request.live ? "live" : "draft";
+    const modeBinding = profile.modes[modeKey];
+    if (!modeBinding) {
+      if (request.live) {
+        throw new Error(`target ${targetReq.plugin} refuses a live publish`);
+      }
+      throw new Error(`target ${targetReq.plugin} has no draft mode; it needs publish_live=true`);
+    }
+    if (profile.requires?.cover && !hasCover) {
+      throw new Error(`target ${targetReq.plugin} needs a cover image at 4-illustrations/cover.* in ${request.workDir}`);
+    }
+    if (profile.requires?.orderedImages && !await hasOrderedImages(fs, request.workDir)) {
+      throw new Error(`target ${targetReq.plugin} requires ordered metadata.images with real paths; a hero cover alone does not satisfy that requirement`);
+    }
+    const locale = profile.locale === "source" ? request.sourceLocale : profile.locale;
+    const format = profile.format;
+    const variant = `${locale}-${format}`;
+    const sharesSourceArticle = variant === `${request.sourceLocale}-article`;
+    const file = sharesSourceArticle ? "content.json" : `content.${variant}.json`;
+    const adapt = !sharesSourceArticle;
+    const switches = { ...modeBinding.metadata };
+    if (!variants[variant]) {
+      variants[variant] = {
+        file,
+        adapt,
+        limits: profile.limits ?? (sharesSourceArticle ? undefined : {}),
+        switches: {}
+      };
+    }
+    Object.assign(variants[variant].switches, switches);
+    const isBrowser = plugin.browserSession !== undefined;
+    if (isBrowser) {
+      browser.push({ target: targetReq.plugin, variant });
+    } else {
+      const group = fanoutMap.get(variant);
+      if (group) {
+        if (!group.includes(targetReq.plugin))
+          group.push(targetReq.plugin);
+      } else {
+        fanoutMap.set(variant, [targetReq.plugin]);
+      }
+    }
+    targetDetails.push({
+      target: targetReq.plugin,
+      plugin: targetReq.plugin,
+      profile: profileName,
+      variant,
+      transport: isBrowser ? "browser" : "fanout",
+      mode: modeKey,
+      metadata: switches
+    });
+  }
+  const fanout = [...fanoutMap.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([variant, targets]) => ({ variant, targets }));
+  return {
+    ...request.schemaVersion !== undefined ? { schemaVersion: 1, targets: targetDetails } : {},
+    ...request.origin !== undefined ? { origin: request.origin } : {},
+    ...request.presetName !== undefined ? { presetName: request.presetName } : {},
+    ...request.presetDigest !== undefined ? { presetDigest: request.presetDigest } : {},
+    live: request.live,
+    sourceLocale: request.sourceLocale,
+    variants,
+    fanout,
+    browser
+  };
+}
+
+// src/itc-publish.ts
+import { createHash as createHash6 } from "crypto";
+import { join as join18 } from "path";
+init_dist3();
+init_dist();
+init_zod();
+
+// src/itc-topic.ts
+import { createHash as createHash5 } from "crypto";
+import { join as join17, resolve as resolve20 } from "path";
+init_dist3();
+init_dist();
+init_zod();
+var WINDOW_UNITS = {
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 24 * 60 * 60 * 1000
+};
+function parseWindow(raw) {
+  const str = raw ? raw.trim() : "24h";
+  const match = /^(\d+)([smhd])$/.exec(str);
+  const amount = match?.[1];
+  const unit = match?.[2];
+  if (amount === undefined || unit === undefined) {
+    throw new Error(`--window must be '<n>s|m|h|d' (e.g. 24h), got '${raw ?? ""}'`);
+  }
+  const milliseconds = Number(amount) * (WINDOW_UNITS[unit] ?? 0);
+  if (milliseconds <= 0) {
+    throw new Error(`--window must be greater than zero, got '${raw ?? ""}'`);
+  }
+  return milliseconds;
+}
+function toPoolDoc(item) {
+  return {
+    id: item.id,
+    title: item.title,
+    body: item.body,
+    ...item.sourceUri === null ? {} : { sourceUri: item.sourceUri },
+    ...item.mediaType === null ? {} : { mediaType: item.mediaType },
+    metadata: { ...item.metadata, labels: item.labels }
+  };
+}
+function resolveKkConfigPath2() {
+  return process.env.KK_CONFIG || resolve20(process.env.HOME || "~", ".config/kk/config.yaml");
+}
+async function resolveTopicProfilePath(fs, topic, customPath) {
+  if (customPath !== undefined && await fs.exists(customPath)) {
+    return customPath;
+  }
+  const rel = join17("plugins/kk/decisions/extract", `${topic}.yaml`);
+  let dir = resolve20(process.cwd());
+  for (;; ) {
+    const candidate = join17(dir, rel);
+    if (await fs.exists(candidate))
+      return candidate;
+    const parent = resolve20(dir, "..");
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  throw new Error(`no profile for topic '${topic}': expected ${rel} under the cwd or one of its ancestors`);
+}
+var ItcTopicExtractRequestSchema = object2({
+  schemaVersion: literal(1).default(1),
+  parentRunId: string2().min(1),
+  intakeDir: string2().min(1),
+  topicProfile: string2().min(1),
+  window: string2().optional().default("24h"),
+  limit: number2().int().positive().optional().default(20),
+  dbPath: string2().optional(),
+  profilePath: string2().optional(),
+  refreshRun: object2({
+    runId: string2().min(1),
+    status: _enum2(["succeeded", "failed", "locked", "skipped"]),
+    outputDocsPath: string2().optional()
+  }).optional()
+});
+async function itcTopicExtract(request, fs = createNodeFileSystem()) {
+  request = ItcTopicExtractRequestSchema.parse(request);
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(request.topicProfile))
+    throw new Error("invalid topic profile slug");
+  if (request.refreshRun?.status === "failed")
+    throw new Error("requested collection refresh failed (failed)");
+  const profilePath = await resolveTopicProfilePath(fs, request.topicProfile, request.profilePath);
+  const profileText = await fs.readFile(profilePath);
+  const profile = parseProfile(profileText);
+  const query = compileProfile(profile, {
+    windowMs: parseWindow(request.window),
+    now: Date.now(),
+    limit: request.limit,
+    excludeTopic: request.topicProfile
+  });
+  const storePath = await resolveStorePath(resolveKkConfigPath2(), request.dbPath);
+  const store = await openStore({ path: storePath });
+  let docs;
+  try {
+    let policy = {
+      priority: DEFAULT_LABEL_PRIORITY,
+      decisionPriority: {},
+      minConfidence: DEFAULT_MIN_CONFIDENCE
+    };
+    try {
+      policy = (await readStoreConfig(resolveKkConfigPath2())).labels;
+    } catch {}
+    const rawDocs = await store.items.selectByProfile(query, policy);
+    docs = array(DocSchema).parse(rawDocs.map(toPoolDoc));
+  } finally {
+    await store.close();
+  }
+  if (docs.length === 0) {
+    if (request.refreshRun && request.refreshRun.status !== "succeeded") {
+      throw new Error(`requested collection refresh failed (${request.refreshRun.status}) and existing store pool is empty for profile '${request.topicProfile}'`);
+    }
+    throw new Error(`no usable topic; collection store pool is empty for profile '${request.topicProfile}'`);
+  }
+  await fs.ensureDir(request.intakeDir);
+  const poolDigest = createHash5("sha256").update(JSON.stringify(docs)).digest("hex");
+  const manifest = {
+    schemaVersion: 1,
+    parentRunId: request.parentRunId,
+    topicProfile: request.topicProfile,
+    window: request.window,
+    limit: request.limit,
+    extractedAt: new Date().toISOString(),
+    poolDigest,
+    ...request.refreshRun?.runId ? { collectRunId: request.refreshRun.runId } : {}
+  };
+  await fs.writeFile(join17(request.intakeDir, "topic-pool.json"), `${JSON.stringify(docs, null, 2)}
+`);
+  await fs.writeFile(join17(request.intakeDir, "topic-pool-manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+  return { count: docs.length, poolDigest };
+}
+var ItcTopicCandidateSchema = object2({
+  id: _enum2(["a", "b", "c"]),
+  title: string2().min(1).max(200),
+  reason: string2().min(1).max(1000),
+  itemIds: array(string2().min(1)).min(1),
+  sourceUrls: array(string2().url()).min(1)
+});
+var ItcTopicCandidatesArtifactSchema = object2({
+  schemaVersion: literal(1).default(1),
+  parentRunId: string2().min(1),
+  poolDigest: string2().min(1),
+  candidates: array(ItcTopicCandidateSchema).min(1).max(3)
+});
+var ItcTopicValidateRequestSchema = object2({
+  schemaVersion: literal(1).default(1),
+  intakeDir: string2().min(1),
+  parentRunId: string2().min(1)
+});
+async function itcTopicValidate(request, fs = createNodeFileSystem()) {
+  const manifestPath = join17(request.intakeDir, "topic-pool-manifest.json");
+  const poolPath = join17(request.intakeDir, "topic-pool.json");
+  const candidatesPath = join17(request.intakeDir, "topic-candidates.json");
+  if (!await fs.exists(manifestPath) || !await fs.exists(poolPath)) {
+    throw new Error(`topic pool artifacts not found in ${request.intakeDir}`);
+  }
+  if (!await fs.exists(candidatesPath)) {
+    throw new Error(`topic-candidates.json not found in ${request.intakeDir}`);
+  }
+  const manifest = JSON.parse(await fs.readFile(manifestPath));
+  const poolDocs = array(DocSchema).parse(JSON.parse(await fs.readFile(poolPath)));
+  const rawCandidates = JSON.parse(await fs.readFile(candidatesPath));
+  const parsed = ItcTopicCandidatesArtifactSchema.safeParse(rawCandidates);
+  if (!parsed.success) {
+    throw new Error(`invalid topic candidates artifact: ${parsed.error.message}`);
+  }
+  const artifact = parsed.data;
+  if (artifact.parentRunId !== request.parentRunId || artifact.parentRunId !== manifest.parentRunId) {
+    throw new Error(`parentRunId mismatch: request ${request.parentRunId} vs candidates ${artifact.parentRunId} vs manifest ${manifest.parentRunId}`);
+  }
+  const currentDigest = createHash5("sha256").update(JSON.stringify(poolDocs)).digest("hex");
+  if (artifact.poolDigest !== manifest.poolDigest || currentDigest !== manifest.poolDigest) {
+    throw new Error(`stale candidates: poolDigest mismatch (candidates ${artifact.poolDigest} vs pool ${manifest.poolDigest})`);
+  }
+  const candidateIds = new Set;
+  for (const c of artifact.candidates) {
+    if (candidateIds.has(c.id)) {
+      throw new Error(`duplicate candidate id '${c.id}'`);
+    }
+    candidateIds.add(c.id);
+  }
+  const poolDocMap = new Map(poolDocs.map((d) => [d.id, d]));
+  for (const c of artifact.candidates) {
+    for (const itemId of c.itemIds) {
+      const doc = poolDocMap.get(itemId);
+      if (!doc) {
+        throw new Error(`candidate '${c.id}' cites unknown item ID '${itemId}' not present in topic-pool.json`);
+      }
+    }
+    for (const url of c.sourceUrls) {
+      const matchingDoc = c.itemIds.map((id) => poolDocMap.get(id)).find((doc) => doc?.sourceUri === url);
+      if (!matchingDoc) {
+        throw new Error(`candidate '${c.id}' sourceUrl '${url}' does not match any referenced item sourceUri in topic-pool.json`);
+      }
+    }
+  }
+  await fs.writeFile(join17(request.intakeDir, ".topic-candidates-valid"), `${new Date().toISOString()}
+`);
+  return { valid: true };
+}
+var ItcTopicSelectRequestSchema = object2({
+  schemaVersion: literal(1).default(1),
+  intakeDir: string2().min(1),
+  parentRunId: string2().min(1),
+  selectedCandidateId: _enum2(["a", "b", "c"]),
+  dbPath: string2().optional()
+});
+async function itcTopicSelect(request, fs = createNodeFileSystem()) {
+  await itcTopicValidate(request, fs);
+  const manifestPath = join17(request.intakeDir, "topic-pool-manifest.json");
+  const poolPath = join17(request.intakeDir, "topic-pool.json");
+  const candidatesPath = join17(request.intakeDir, "topic-candidates.json");
+  if (!await fs.exists(manifestPath) || !await fs.exists(poolPath) || !await fs.exists(candidatesPath)) {
+    throw new Error(`intake artifacts missing in ${request.intakeDir}`);
+  }
+  const manifest = JSON.parse(await fs.readFile(manifestPath));
+  const poolDocs = JSON.parse(await fs.readFile(poolPath));
+  const candidatesArtifact = JSON.parse(await fs.readFile(candidatesPath));
+  const candidate = candidatesArtifact.candidates.find((c) => c.id === request.selectedCandidateId);
+  if (!candidate) {
+    throw new Error(`selected candidate '${request.selectedCandidateId}' not found in candidates list: [${candidatesArtifact.candidates.map((c) => c.id).join(", ")}]`);
+  }
+  const selectedDocSet = new Set(candidate.itemIds);
+  const selectedDocs = poolDocs.filter((d) => selectedDocSet.has(d.id));
+  const selectedDocsPath = join17(request.intakeDir, "selected-docs.json");
+  await fs.writeFile(selectedDocsPath, `${JSON.stringify(selectedDocs, null, 2)}
+`);
+  const chosenSource = {
+    schemaVersion: 1,
+    parentRunId: request.parentRunId,
+    topicProfile: manifest.topicProfile,
+    candidateId: candidate.id,
+    poolDigest: manifest.poolDigest,
+    topicName: candidate.title,
+    displayTitle: candidate.title,
+    itemIds: candidate.itemIds,
+    selectedDocsPath
+  };
+  await fs.writeFile(join17(request.intakeDir, "chosen-source.json"), `${JSON.stringify(chosenSource, null, 2)}
+`);
+  const storePath = await resolveStorePath(resolveKkConfigPath2(), request.dbPath);
+  const store = await openStore({ path: storePath });
+  try {
+    const now = Date.now();
+    const rows = [];
+    for (const [index, itemId] of candidate.itemIds.entries()) {
+      const item = await store.items.findById(itemId);
+      if (!item) {
+        throw new Error(`item '${itemId}' not found in store`);
+      }
+      rows.push({
+        topic: manifest.topicProfile,
+        itemId: item.id,
+        runId: request.parentRunId,
+        storyId: item.storyId ?? item.id,
+        workflow: "kk-itc",
+        rank: index + 1
+      });
+    }
+    await store.selections.insertMany(rows, now);
+  } finally {
+    await store.close();
+  }
+  return { selectedCandidateId: candidate.id, itemIds: candidate.itemIds };
+}
+var ItcSelectionSettleRequestSchema = object2({
+  schemaVersion: literal(1).default(1),
+  intakeDir: string2().min(1),
+  parentRunId: string2().min(1),
+  topicProfile: string2().min(1),
+  outcome: _enum2(["published", "uncertain", "author_only", "draft_only", "failed"]),
+  dbPath: string2().optional()
+});
+async function itcSelectionSettle(request, fs = createNodeFileSystem()) {
+  const storePath = await resolveStorePath(resolveKkConfigPath2(), request.dbPath);
+  if (request.outcome === "published") {
+    let itemIds;
+    const chosenSourcePath = join17(request.intakeDir, "chosen-source.json");
+    if (await fs.exists(chosenSourcePath)) {
+      try {
+        const chosen = JSON.parse(await fs.readFile(chosenSourcePath));
+        if (Array.isArray(chosen.itemIds)) {
+          itemIds = chosen.itemIds;
+        }
+      } catch {
+        itemIds = undefined;
+      }
+    }
+    const store = await openStore({ path: storePath });
+    try {
+      const count = await store.selections.updateStatus(request.parentRunId, request.topicProfile, "published", itemIds);
+      return { settled: count, action: "marked_published" };
+    } finally {
+      await store.close();
+    }
+  }
+  if (request.outcome === "uncertain") {
+    const reconcileInfo = {
+      schemaVersion: 1,
+      parentRunId: request.parentRunId,
+      topicProfile: request.topicProfile,
+      settledAt: new Date().toISOString(),
+      status: "retained_for_reconciliation",
+      reason: "unresolved possible remote effects",
+      guidance: "reconcile status manually via kk store mark-published or kk store release"
+    };
+    await fs.ensureDir(request.intakeDir);
+    await fs.writeFile(join17(request.intakeDir, ".selection-reconcile.json"), `${JSON.stringify(reconcileInfo, null, 2)}
+`);
+    return { settled: "retained", action: "reconcile_retained" };
+  }
+  const store = await openStore({ path: storePath });
+  try {
+    const count = await store.selections.updateStatus(request.parentRunId, request.topicProfile, "dropped");
+    return { settled: count, action: "released" };
+  } finally {
+    await store.close();
+  }
+}
+async function runItcTopicStage(stageName, args, fs = createNodeFileSystem()) {
+  const requestIdx = args.indexOf("--request");
+  const requestFile = requestIdx !== -1 ? args[requestIdx + 1] : undefined;
+  if (requestFile === undefined || requestFile === "") {
+    echoError(`${stageName}: --request <JSON-file> is required`);
+    return 1;
+  }
+  if (!await fs.exists(requestFile)) {
+    echoError(`${stageName}: request file not found: ${requestFile}`);
+    return 1;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(await fs.readFile(requestFile));
+  } catch (err) {
+    echoError(`${stageName}: invalid JSON in request file: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  try {
+    if (stageName === "itc-topic-extract") {
+      const parsed = ItcTopicExtractRequestSchema.parse(raw);
+      const res = await itcTopicExtract(parsed, fs);
+      echo(JSON.stringify(res));
+      return 0;
+    }
+    if (stageName === "itc-topic-validate") {
+      const parsed = ItcTopicValidateRequestSchema.parse(raw);
+      const res = await itcTopicValidate(parsed, fs);
+      echo(JSON.stringify(res));
+      return 0;
+    }
+    if (stageName === "itc-topic-select") {
+      const parsed = ItcTopicSelectRequestSchema.parse(raw);
+      const res = await itcTopicSelect(parsed, fs);
+      echo(JSON.stringify(res));
+      return 0;
+    }
+    if (stageName === "itc-selection-settle") {
+      const parsed = ItcSelectionSettleRequestSchema.parse(raw);
+      const res = await itcSelectionSettle(parsed, fs);
+      echo(JSON.stringify(res));
+      return 0;
+    }
+  } catch (err) {
+    echoError(`${stageName}: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  return;
+}
+
+// src/itc-publish.ts
+var ItcDeliveryMetadataSchema = object2({
+  schemaVersion: literal(1).default(1),
+  effect: _enum2(["none", "confirmed", "unknown"]),
+  publicUrlVerified: boolean2().optional()
+}).strict();
+var ItcReceiptSchema = object2({
+  schemaVersion: literal(1).default(1),
+  parentRunId: string2().min(1),
+  planDigest: string2().min(1),
+  payloadDigest: string2().min(1),
+  plugin: string2().min(1),
+  profile: string2().min(1),
+  mode: _enum2(["draft", "live"]),
+  attemptId: string2().min(1),
+  status: _enum2(["succeeded", "failed", "uncertain"]),
+  effect: _enum2(["none", "confirmed", "unknown"]),
+  resultDigest: string2().optional(),
+  aggregatePath: string2().optional(),
+  publicUrlVerified: boolean2().optional(),
+  url: string2().optional(),
+  durationMs: number2().optional()
+}).strict();
+async function findCover(fs, workDir) {
+  const dir = join18(workDir, "4-illustrations");
+  if (!await fs.exists(dir))
+    return;
+  const cover = (await fs.readDir(dir)).find((file) => file.startsWith("cover."));
+  return cover ? join18("4-illustrations", cover) : undefined;
+}
+async function readFrontmatter(fs, path) {
+  if (!await fs.exists(path))
+    return {};
+  const text = await fs.readFile(path);
+  if (!text.startsWith("---"))
+    return {};
+  const end = text.indexOf(`
+---`, 3);
+  if (end < 0)
+    return {};
+  const out = {};
+  for (const line of text.slice(4, end).split(`
+`)) {
+    const m = /^([\w-]+):\s*(.+)$/.exec(line);
+    if (m?.[1] && m[2])
+      out[m[1]] = m[2].trim().replace(/^['"]|['"]$/g, "");
+  }
+  return out;
+}
+function splitList(value) {
+  return value.replace(/^\[|\]$/g, "").split(",").map((entry) => entry.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+}
+async function itcMaterializePlan(args, fs = createNodeFileSystem()) {
+  const [workDir = "", ...positional] = args;
+  if (!workDir) {
+    echoError("usage: itc-materialize-plan <work_dir> [targets] [source_locale] [publish_live] [preset]");
+    return 1;
+  }
+  const snapshot = await readOptionsSnapshot(fs, workDir);
+  const [targetsArg = "", sourceLocale = "", liveArg = "", presetArg = ""] = snapshot ? [snapshot.publishTargets, snapshot.sourceLocale, String(snapshot.publishLive), ""] : positional;
+  const live = liveArg === "true";
+  const draftPath = join18(workDir, "3-draft-draft-article.md");
+  if (!await fs.exists(draftPath)) {
+    echoError(`final draft not found: ${draftPath}`);
+    return 1;
+  }
+  const lines = (await fs.readFile(draftPath)).split(`
+`);
+  const h1 = lines.findIndex((line) => /^#\s+\S/.test(line));
+  if (h1 < 0) {
+    echoError(`no H1 title in ${draftPath}`);
+    return 1;
+  }
+  const title = lines[h1]?.replace(/^#\s+/, "").trim() ?? "";
+  const body = [...lines.slice(0, h1), ...lines.slice(h1 + 1)].join(`
+`).trim();
+  if (!body) {
+    echoError(`empty body in ${draftPath}`);
+    return 1;
+  }
+  const content = { title, format: "markdown", body };
+  const outlinePath = join18(workDir, "2-outline", "outline-approved.md");
+  if (await fs.exists(outlinePath))
+    content.outline = (await fs.readFile(outlinePath)).trim();
+  const docsPath = join18(workDir, "docs.json");
+  if (await fs.exists(docsPath)) {
+    try {
+      const docs = JSON.parse(await fs.readFile(docsPath));
+      if (Array.isArray(docs)) {
+        content.references = docs.map((doc) => ({
+          ...typeof doc.sourceUri === "string" ? { url: doc.sourceUri } : {},
+          ...typeof doc.title === "string" ? { title: doc.title } : {},
+          ...typeof doc.id === "string" ? { cite: doc.id } : {}
+        }));
+      }
+    } catch {}
+  }
+  const metadata = { published: live };
+  const cover = await findCover(fs, workDir);
+  if (cover)
+    metadata.coverImage = cover;
+  const brief = await readFrontmatter(fs, join18(workDir, "brief.md"));
+  if (brief.tags)
+    metadata.tags = splitList(brief.tags);
+  if (brief.keywords)
+    metadata.keywords = splitList(brief.keywords);
+  if (brief.description)
+    metadata.description = brief.description;
+  content.metadata = metadata;
+  const publishDir = join18(workDir, "4-publish");
+  await fs.ensureDir(publishDir);
+  await fs.writeFile(join18(publishDir, "content.json"), `${JSON.stringify(content, null, 2)}
+`);
+  const fromLaunch = snapshot?.publishPresetSource === "launch" ? snapshot.publishPreset : null;
+  const fromConfig = snapshot?.publishPresetSource === "config" ? snapshot.publishPreset : null;
+  let resolvedTargets;
+  try {
+    resolvedTargets = await resolveItcTargets({
+      explicitTargets: targetsArg ? targetsArg : undefined,
+      explicitPreset: presetArg ? presetArg : fromLaunch ?? undefined,
+      workflowConfigPreset: fromConfig ?? undefined,
+      topicProfile: snapshot?.topicProfile ?? undefined,
+      projectRoot: snapshot?.launchProjectRoot
+    }, fs);
+  } catch (err) {
+    echoError(`itc-materialize-plan: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  if (resolvedTargets.origin === "topic-profile" && snapshot) {
+    const decision = await itcDecision({
+      parentRunId: snapshot.parentRunId,
+      decisionId: "kk-itc-preset-choice",
+      candidates: [
+        {
+          id: "suggested",
+          title: `${resolvedTargets.presetName}: ${resolvedTargets.targets.map((t) => t.plugin).join(", ")}`
+        }
+      ],
+      outPath: join18(workDir, "4-publish", "preset-decision.json")
+    }, fs);
+    if (decision.value !== "suggested")
+      resolvedTargets = { targets: [], origin: "none" };
+  }
+  if (resolvedTargets.targets.length === 0) {
+    const emptyPlan = {
+      schemaVersion: 1,
+      live,
+      sourceLocale: sourceLocale || "en",
+      origin: resolvedTargets.origin,
+      variants: {},
+      fanout: [],
+      browser: [],
+      targets: []
+    };
+    await fs.writeFile(join18(publishDir, "publish-plan.json"), `${JSON.stringify(emptyPlan, null, 2)}
+`);
+    return 0;
+  }
+  const { plugins } = discoverAllPlugins();
+  const req = {
+    schemaVersion: 1,
+    workDir,
+    sourceLocale: sourceLocale || "en",
+    live,
+    targets: resolvedTargets.targets,
+    origin: resolvedTargets.origin,
+    presetName: resolvedTargets.presetName,
+    presetDigest: resolvedTargets.presetDigest
+  };
+  try {
+    const plan = await buildItcPublishPlan(req, plugins, fs);
+    const planPath = join18(publishDir, "publish-plan.json");
+    await fs.writeFile(planPath, `${JSON.stringify(plan, null, 2)}
+`);
+    await prepareTargetPayloads(fs, workDir, plan, plugins);
+    return 0;
+  } catch (err) {
+    echoError(`itc-materialize-plan: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+async function readOptionsSnapshot(fs, workDir) {
+  const path = join18(workDir, "itc-options.json");
+  if (!await fs.exists(path))
+    return;
+  return JSON.parse(await fs.readFile(path));
+}
+async function prepareTargetPayloads(fs, workDir, plan, plugins) {
+  const publishDir = join18(workDir, "4-publish");
+  if (!plan.targets || plan.targets.length === 0)
+    return;
+  const planned = new Set(plan.targets.map((t) => t.plugin));
+  const modeKeys = new Set(["operation", "published", "publishStatus", "private", "mode"]);
+  for (const plugin of plugins) {
+    if (!planned.has(plugin.name))
+      continue;
+    for (const profile of Object.values(plugin.publishing?.profiles ?? {})) {
+      for (const binding of Object.values(profile.modes)) {
+        for (const key of Object.keys(binding?.metadata ?? {}))
+          modeKeys.add(key);
+      }
+    }
+  }
+  for (const target of plan.targets) {
+    const variantEntry = plan.variants[target.variant];
+    const baseFile = variantEntry?.file ?? "content.json";
+    let basePath = join18(publishDir, baseFile);
+    if (!await fs.exists(basePath)) {
+      basePath = join18(publishDir, "content.json");
+    }
+    if (!await fs.exists(basePath))
+      continue;
+    const baseContent = JSON.parse(await fs.readFile(basePath));
+    const cleanedMetadata = { ...baseContent.metadata ?? {} };
+    for (const k of modeKeys) {
+      delete cleanedMetadata[k];
+    }
+    const isolatedContent = {
+      ...baseContent,
+      metadata: {
+        ...cleanedMetadata,
+        ...target.metadata
+      }
+    };
+    const targetFileName = `content.${target.plugin}.json`;
+    const targetFilePath = join18(publishDir, targetFileName);
+    const contentStr = `${JSON.stringify(isolatedContent, null, 2)}
+`;
+    await fs.writeFile(targetFilePath, contentStr);
+    const payloadDigest = createHash6("sha256").update(contentStr).digest("hex");
+    target.payloadPath = `4-publish/${targetFileName}`;
+    target.payloadDigest = payloadDigest;
+  }
+  await fs.writeFile(join18(publishDir, "publish-plan.json"), `${JSON.stringify(plan, null, 2)}
+`);
+}
+async function itcCheckTargets(args, fs = createNodeFileSystem(), executor = new NodeProcessExecutor) {
+  const [workDir = ""] = args;
+  if (!workDir) {
+    echoError("usage: itc-check-targets <work_dir>");
+    return 1;
+  }
+  const planPath = join18(workDir, "4-publish/publish-plan.json");
+  if (!await fs.exists(planPath))
+    return 0;
+  const plan = JSON.parse(await fs.readFile(planPath));
+  if (!plan.targets || plan.targets.length === 0)
+    return 0;
+  const { plugins } = discoverAllPlugins();
+  const byName = new Map(plugins.map((p) => [p.name, p]));
+  for (const target of plan.targets) {
+    const plugin = byName.get(target.plugin);
+    if (plugin?.check) {
+      const probe = await executor.run({
+        command: process.execPath,
+        args: [plugin.check, "check"],
+        env: process.env,
+        timeout: 60000
+      });
+      if (probe.exitCode !== 0) {
+        const botName = plugin.browserSession?.profileName ?? plugin.name;
+        echoError(`channel probe for '${target.plugin}' refused: run \`kk bot open/login ${botName}\` to authenticate`);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+async function itcSendTargets(args, fs = createNodeFileSystem(), dispatch = runFanout) {
+  const [workDir = ""] = args;
+  const isRetry = args.includes("--retry");
+  if (!workDir) {
+    echoError("usage: itc-send-targets <work_dir> [--retry]");
+    return 1;
+  }
+  const publishDir = join18(workDir, "4-publish");
+  const planPath = join18(publishDir, "publish-plan.json");
+  if (!await fs.exists(planPath))
+    return 0;
+  const plan = JSON.parse(await fs.readFile(planPath));
+  if (!plan.targets || plan.targets.length === 0)
+    return 0;
+  const parentRunId = (await readOptionsSnapshot(fs, workDir))?.parentRunId;
+  if (!parentRunId) {
+    echoError(`itc-send-targets: ${join18(workDir, "itc-options.json")} has no parentRunId`);
+    return 1;
+  }
+  const receiptsDir = join18(publishDir, "receipts");
+  await fs.ensureDir(receiptsDir);
+  const planRaw = await fs.readFile(planPath);
+  const planDigest = createHash6("sha256").update(planRaw).digest("hex");
+  for (const target of plan.targets) {
+    const targetReceiptPath = join18(receiptsDir, `${target.plugin}.json`);
+    if (isRetry) {
+      if (!await fs.exists(targetReceiptPath))
+        continue;
+      try {
+        const priorReceipt = JSON.parse(await fs.readFile(targetReceiptPath));
+        if (priorReceipt.status === "succeeded" || priorReceipt.effect !== "none") {
+          continue;
+        }
+      } catch {
+        continue;
+      }
+    } else if (await fs.exists(targetReceiptPath)) {
+      try {
+        const prior = JSON.parse(await fs.readFile(targetReceiptPath));
+        if (prior.status === "succeeded")
+          continue;
+      } catch {}
+    }
+    const payloadRel = target.payloadPath ?? `4-publish/content.${target.plugin}.json`;
+    const payloadPath = join18(workDir, payloadRel);
+    const payloadRaw = await fs.exists(payloadPath) ? await fs.readFile(payloadPath) : "{}";
+    const payloadDigest = createHash6("sha256").update(payloadRaw).digest("hex");
+    const outPath = join18(publishDir, `fanout-result.${target.plugin}${isRetry ? ".retry" : ""}.json`);
+    const fanoutArgs = [
+      "--content",
+      payloadPath,
+      "--target",
+      target.plugin,
+      "--out",
+      outPath,
+      ...target.transport === "browser" ? ["--serial-target", target.plugin] : []
+    ];
+    let fanoutExit = 0;
+    if (!await fs.exists(outPath)) {
+      try {
+        fanoutExit = await dispatch(fanoutArgs);
+      } catch {
+        fanoutExit = 1;
+      }
+    }
+    let outcome = {};
+    if (await fs.exists(outPath)) {
+      try {
+        const agg = JSON.parse(await fs.readFile(outPath));
+        const found = (agg.targets ?? []).find((t) => t.target === target.plugin);
+        if (found)
+          outcome = found;
+      } catch {
+        outcome = { ok: false, status: "failed", error: "failed to parse fanout result" };
+      }
+    }
+    const isSuccess = fanoutExit === 0 && outcome.ok === true && outcome.status === "published";
+    const itcDelivery = outcome.metadata?.itcDelivery;
+    let effect = "unknown";
+    let publicUrlVerified = false;
+    if (isSuccess) {
+      effect = "confirmed";
+      if (target.mode === "live" && outcome.url) {
+        publicUrlVerified = itcDelivery?.publicUrlVerified === true;
+      }
+    } else if (itcDelivery?.effect === "none") {
+      effect = "none";
+    }
+    const receipt = {
+      schemaVersion: 1,
+      parentRunId,
+      planDigest,
+      payloadDigest,
+      plugin: target.plugin,
+      profile: target.profile,
+      mode: target.mode,
+      attemptId: isRetry ? "retry-1" : "attempt-1",
+      status: isSuccess ? "succeeded" : effect === "unknown" ? "uncertain" : "failed",
+      effect,
+      publicUrlVerified,
+      ...outcome.url ? { url: outcome.url } : {},
+      ...outcome.durationMs !== undefined ? { durationMs: outcome.durationMs } : {},
+      aggregatePath: outPath
+    };
+    await fs.writeFile(targetReceiptPath, `${JSON.stringify(receipt, null, 2)}
+`);
+  }
+  return 0;
+}
+async function itcReconcileReceipts(args, fs = createNodeFileSystem()) {
+  const [workDir = ""] = args;
+  if (!workDir) {
+    echoError("usage: itc-reconcile-receipts <work_dir>");
+    return 1;
+  }
+  const publishDir = join18(workDir, "4-publish");
+  const planPath = join18(publishDir, "publish-plan.json");
+  if (!await fs.exists(planPath))
+    return 0;
+  const plan = JSON.parse(await fs.readFile(planPath));
+  const chosenPath = join18(workDir, "chosen-source.json");
+  const chosen = await fs.exists(chosenPath) ? JSON.parse(await fs.readFile(chosenPath)) : undefined;
+  const settle = async (outcome) => {
+    if (chosen === undefined)
+      return;
+    await itcSelectionSettle({
+      schemaVersion: 1,
+      intakeDir: workDir,
+      parentRunId: chosen.parentRunId,
+      topicProfile: chosen.topicProfile,
+      outcome
+    }, fs);
+  };
+  if (!plan.targets || plan.targets.length === 0) {
+    await settle("author_only");
+    return 0;
+  }
+  const receiptsDir = join18(publishDir, "receipts");
+  const receipts = [];
+  for (const target of plan.targets) {
+    const rPath = join18(receiptsDir, `${target.plugin}.json`);
+    if (!await fs.exists(rPath)) {
+      echoError(`itc-reconcile-receipts: missing receipt for target '${target.plugin}'`);
+      return 1;
+    }
+    try {
+      const r = JSON.parse(await fs.readFile(rPath));
+      receipts.push(r);
+    } catch {
+      echoError(`itc-reconcile-receipts: corrupt receipt for target '${target.plugin}'`);
+      return 1;
+    }
+  }
+  const liveSuccess = receipts.some((r) => r.mode === "live" && r.status === "succeeded");
+  const hasUncertain = receipts.some((r) => r.effect === "unknown" || r.status === "uncertain");
+  const allSucceeded = receipts.every((r) => r.status === "succeeded");
+  await settle(liveSuccess ? "published" : hasUncertain ? "uncertain" : allSucceeded ? "draft_only" : "failed");
+  return 0;
+}
+async function itcExportSeo(args, fs = createNodeFileSystem()) {
+  const [workDir = "", mode = "handoff"] = args;
+  if (!workDir) {
+    echoError("usage: itc-export-seo <work_dir> [mode]");
+    return 1;
+  }
+  const seoDir = join18(workDir, "seo");
+  await fs.ensureDir(seoDir);
+  if (mode === "off") {
+    await fs.writeFile(join18(seoDir, "prepublish-request.json"), `${JSON.stringify({ schemaVersion: 1, mode: "off", status: "not-assessed" }, null, 2)}
+`);
+    await fs.writeFile(join18(seoDir, "published-pages.json"), `${JSON.stringify({ schemaVersion: 1, mode: "off", pages: [], status: "not-assessed" }, null, 2)}
+`);
+    return 0;
+  }
+  const prepublish = {
+    schemaVersion: 1,
+    mode: "handoff",
+    status: "ready",
+    draftFile: "3-draft-draft-article.md"
+  };
+  await fs.writeFile(join18(seoDir, "prepublish-request.json"), `${JSON.stringify(prepublish, null, 2)}
+`);
+  const receiptsDir = join18(workDir, "4-publish/receipts");
+  const verifiedPages = [];
+  if (await fs.exists(receiptsDir)) {
+    for (const file of (await fs.readDir(receiptsDir)).filter((f) => f.endsWith(".json"))) {
+      try {
+        const r = JSON.parse(await fs.readFile(join18(receiptsDir, file)));
+        if (r.mode === "live" && r.effect === "confirmed" && r.publicUrlVerified === true && r.url) {
+          verifiedPages.push({ plugin: r.plugin, url: r.url });
+        }
+      } catch {}
+    }
+  }
+  const publishedPages = {
+    schemaVersion: 1,
+    mode: "handoff",
+    status: verifiedPages.length > 0 ? "assessed" : "not-assessed",
+    pages: verifiedPages,
+    ...verifiedPages.length === 0 ? { reason: "no verified public live URLs available" } : {}
+  };
+  await fs.writeFile(join18(seoDir, "published-pages.json"), `${JSON.stringify(publishedPages, null, 2)}
+`);
+  return 0;
+}
+async function itcReportSummary(args, fs = createNodeFileSystem()) {
+  const [workDir = "", maxRevisions = "2"] = args;
+  if (!workDir) {
+    echoError("usage: itc-report-summary <work_dir> [max_revisions]");
+    return 1;
+  }
+  const reportDir = join18(workDir, "5-report");
+  await fs.ensureDir(reportDir);
+  let verdict = "PASS";
+  let outcome = "done";
+  const verdictPath = join18(workDir, ".itc-verdict.json");
+  if (await fs.exists(verdictPath)) {
+    try {
+      const v = JSON.parse(await fs.readFile(verdictPath));
+      verdict = v.verdict ?? "PASS";
+      if (verdict !== "PASS")
+        outcome = "failed";
+    } catch {
+      outcome = "failed";
+    }
+  }
+  let revisions = 0;
+  const revPath = join18(workDir, ".auto-revise-count");
+  if (await fs.exists(revPath)) {
+    try {
+      revisions = Number((await fs.readFile(revPath)).trim()) || 0;
+    } catch {
+      revisions = 0;
+    }
+  }
+  const receiptsDir = join18(workDir, "4-publish/receipts");
+  const receipts = [];
+  if (await fs.exists(receiptsDir)) {
+    for (const file of (await fs.readDir(receiptsDir)).filter((f) => f.endsWith(".json"))) {
+      try {
+        const r = JSON.parse(await fs.readFile(join18(receiptsDir, file)));
+        receipts.push(r);
+      } catch {}
+    }
+  }
+  if (receipts.some((r) => r.status !== "succeeded")) {
+    outcome = "failed";
+  }
+  const planPath = join18(workDir, "4-publish/publish-plan.json");
+  let targetContract;
+  if (await fs.exists(planPath)) {
+    const planRaw = await fs.readFile(planPath);
+    const planDigest = createHash6("sha256").update(planRaw).digest("hex");
+    const expected = (JSON.parse(planRaw).targets ?? []).map((t) => t.plugin).sort();
+    const observed = receipts.map((r) => r.plugin).sort();
+    const stale = receipts.filter((r) => r.planDigest !== planDigest).map((r) => r.plugin);
+    if (expected.join(`
+`) !== observed.join(`
+`) || stale.length > 0) {
+      targetContract = { expected, observed, stale };
+      outcome = "failed";
+    }
+  }
+  const reportJson = {
+    outcome,
+    verdict,
+    revisions,
+    receipts,
+    ...targetContract ? { targetContractFailure: targetContract } : {},
+    maxRevisions: Number(maxRevisions) || 2
+  };
+  await fs.writeFile(join18(reportDir, "report.json"), `${JSON.stringify(reportJson, null, 2)}
+`);
+  const md = [
+    "# ITC Publication Run Report",
+    "",
+    `- Outcome: ${outcome}`,
+    `- Verdict: ${verdict}`,
+    `- Revisions: ${revisions}`,
+    `- Target Receipts: ${receipts.length}`,
+    ...targetContract ? [
+      `- Target contract failure: expected [${targetContract.expected.join(", ")}], observed [${targetContract.observed.join(", ")}], stale [${targetContract.stale.join(", ")}]`
+    ] : [],
+    "",
+    "## Targets",
+    ...receipts.map((r) => `- ${r.plugin} (${r.profile}): status=${r.status}, effect=${r.effect}`)
+  ].join(`
+`);
+  await fs.writeFile(join18(reportDir, "report.md"), `${md}
+`);
+  return 0;
+}
+async function itcAuthorVerdict(args, fs = createNodeFileSystem()) {
+  const [workDir = ""] = args;
+  if (!workDir) {
+    echoError("usage: itc-author-verdict <work_dir>");
+    return 1;
+  }
+  const auto = process.env.KK_ITC_AUTO === "true";
+  const maxRevisions = Number(process.env.KK_ITC_MAX_REVISIONS ?? "2") || 2;
+  const readCount = async (name) => {
+    const p = join18(workDir, name);
+    if (!await fs.exists(p))
+      return 0;
+    const n = Number((await fs.readFile(p)).trim());
+    return Number.isFinite(n) ? n : 0;
+  };
+  const verdictPath = join18(workDir, ".itc-verdict.json");
+  let verdict = "";
+  let confidence = "";
+  if (await fs.exists(verdictPath)) {
+    try {
+      const v = JSON.parse(await fs.readFile(verdictPath));
+      verdict = typeof v.verdict === "string" ? v.verdict : "";
+      confidence = typeof v.confidence === "string" ? v.confidence : "";
+    } catch {
+      verdict = "malformed";
+    }
+  }
+  let disposition;
+  if (verdict === "") {
+    disposition = "finish";
+  } else if (verdict === "PASS" && ["HIGH", "MEDIUM", "LOW"].includes(confidence)) {
+    disposition = "finish";
+  } else if (verdict === "NEEDS_REVISION") {
+    if (auto) {
+      disposition = await readCount(".auto-revise-count") < maxRevisions ? "autorevise" : "fail";
+    } else {
+      disposition = await readCount(".revise-count") < 3 ? "revise" : "fail";
+    }
+  } else {
+    disposition = "fail";
+  }
+  await fs.ensureDir(join18(workDir, ".itc"));
+  await fs.writeFile(join18(workDir, ".itc/disposition.txt"), `${disposition}
+`);
+  return 0;
+}
+
+// src/itc-stage.ts
+async function runItcStage(args, fs = createNodeFileSystem()) {
+  if (args.length === 0)
+    return;
+  const stageName = args[0];
+  if (stageName === "itc-publish-plan") {
+    return runItcPublishPlan(args.slice(1), fs);
+  }
+  if (stageName === "itc-materialize-plan") {
+    return itcMaterializePlan(args.slice(1), fs);
+  }
+  if (stageName === "itc-check-targets") {
+    return itcCheckTargets(args.slice(1), fs);
+  }
+  if (stageName === "itc-send-targets") {
+    return itcSendTargets(args.slice(1), fs);
+  }
+  if (stageName === "itc-reconcile-receipts") {
+    return itcReconcileReceipts(args.slice(1), fs);
+  }
+  if (stageName === "itc-export-seo") {
+    return itcExportSeo(args.slice(1), fs);
+  }
+  if (stageName === "itc-report-summary") {
+    return itcReportSummary(args.slice(1), fs);
+  }
+  if (stageName === "itc-prepare") {
+    return runItcPrepare(args.slice(1), fs);
+  }
+  if (stageName === "itc-author-verdict") {
+    return itcAuthorVerdict(args.slice(1), fs);
+  }
+  if (stageName === "itc-decision") {
+    return runItcDecision(args.slice(1), fs);
+  }
+  if (stageName === "itc-author-complete") {
+    return runItcAuthorComplete(args.slice(1), fs);
+  }
+  if (stageName === "itc-topic-extract" || stageName === "itc-topic-validate" || stageName === "itc-topic-select" || stageName === "itc-selection-settle") {
+    return runItcTopicStage(stageName, args.slice(1), fs);
+  }
+  return;
+}
+async function runItcPublishPlan(args, fs) {
+  let request;
+  const requestIdx = args.indexOf("--request");
+  if (requestIdx !== -1) {
+    const filePath = args[requestIdx + 1];
+    if (filePath === undefined || filePath === "" || !await fs.exists(filePath)) {
+      echoError(`itc-publish-plan: request file not found: ${filePath ?? ""}`);
+      return 1;
+    }
+    try {
+      const raw = JSON.parse(await fs.readFile(filePath));
+      const parsed = ItcPlanRequestSchema.safeParse(raw);
+      if (!parsed.success) {
+        echoError(`itc-publish-plan: invalid request schema: ${parsed.error.message}`);
+        return 1;
+      }
+      request = parsed.data;
+    } catch (err) {
+      echoError(`itc-publish-plan: failed to read request file: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  } else {
+    const [workDir = "", targetsArg = "", sourceLocale = "", liveArg = ""] = args;
+    if (!workDir || !targetsArg || !sourceLocale) {
+      echoError("usage: itc-publish-plan <work_dir> <targets> <source_locale> <publish_live>");
+      return 1;
+    }
+    const live = liveArg === "true";
+    const targetTokens = targetsArg.split(",").map((t) => t.trim()).filter(Boolean);
+    const targets = targetTokens.map((token) => {
+      const colonIdx = token.indexOf(":");
+      if (colonIdx !== -1) {
+        return {
+          plugin: token.slice(0, colonIdx),
+          profile: token.slice(colonIdx + 1)
+        };
+      }
+      return { plugin: token };
+    });
+    request = {
+      workDir,
+      sourceLocale,
+      live,
+      targets
+    };
+  }
+  try {
+    const { plugins } = discoverAllPlugins();
+    const plan = await buildItcPublishPlan(request, plugins, fs);
+    const outDir = join19(request.workDir, "4-publish");
+    await fs.ensureDir(outDir);
+    await fs.writeFile(join19(outDir, "publish-plan.json"), `${JSON.stringify(plan, null, 4)}
+`);
+    return 0;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    echoError(msg);
+    return 1;
+  }
+}
+async function runItcDecision(args, fs) {
+  if (args[0] === "--outline" || args[0] === "--topic")
+    return runSlotDecision(args, fs);
+  const requestIdx = args.indexOf("--request");
+  const requestFile = requestIdx !== -1 ? args[requestIdx + 1] : undefined;
+  if (!requestFile) {
+    echoError("itc-decision: --request <JSON-file> is required");
+    return 1;
+  }
+  if (!await fs.exists(requestFile)) {
+    echoError(`itc-decision: request file not found: ${requestFile}`);
+    return 1;
+  }
+  try {
+    const raw = JSON.parse(await fs.readFile(requestFile));
+    const parsed = ItcDecisionRequestSchema.parse(raw);
+    await itcDecision(parsed, fs);
+    return 0;
+  } catch (err) {
+    echoError(`itc-decision: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+async function runSlotDecision(args, fs) {
+  const [mode, dir = "", parentRunId = ""] = args;
+  if (!dir || !parentRunId) {
+    echoError(`itc-decision: usage: itc-decision ${mode} <dir> <parentRunId>`);
+    return 1;
+  }
+  try {
+    if (mode === "--topic") {
+      const candidatesPath = join19(dir, "topic-candidates.json");
+      const artifact = JSON.parse(await fs.readFile(candidatesPath));
+      const result = await itcDecision({
+        parentRunId,
+        decisionId: "kk-itc-topic-choice",
+        candidates: artifact.candidates.map((c) => ({ id: c.id, title: c.title, description: c.reason })),
+        evidenceFiles: [candidatesPath],
+        outPath: join19(dir, "topic-decision.json")
+      }, fs);
+      echo(result.value);
+      return 0;
+    }
+    const outlineDir = join19(dir, "2-outline");
+    const candidates = [];
+    const evidenceFiles = [];
+    for (const id of ["a", "b", "c"]) {
+      const file = join19(outlineDir, `outline-option-${id}.md`);
+      if (!await fs.exists(file))
+        continue;
+      const heading = (await fs.readFile(file)).split(`
+`).find((line) => line.trim() !== "") ?? id;
+      candidates.push({ id, title: heading.replace(/^#+\s*/, "").trim() });
+      evidenceFiles.push(file);
+    }
+    if (candidates.length === 0)
+      throw new Error(`no outline options in ${outlineDir}`);
+    evidenceFiles.push(join19(outlineDir, "outline-recommendation.json"));
+    const result = await itcDecision({
+      parentRunId,
+      decisionId: "kk-itc-outline-choice",
+      candidates,
+      evidenceFiles,
+      outPath: join19(outlineDir, "outline-decision.json")
+    }, fs);
+    const pick = result.value === "defer" ? "" : result.value;
+    if (pick === "")
+      echoError(`itc-decision: outline choice deferred to the operator: ${result.reason}`);
+    await fs.writeFile(join19(outlineDir, ".auto-pick"), pick);
+    return 0;
+  } catch (err) {
+    echoError(`itc-decision: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+async function runItcAuthorComplete(args, fs) {
+  const [workDir = "", parentRunId = "", reviewModeArg = ""] = args;
+  if (!workDir || !parentRunId) {
+    echoError("usage: itc-author-complete <work_dir> <parentRunId> [reviewMode]");
+    return 1;
+  }
+  const draftPath = join19(workDir, "3-draft-draft-article.md");
+  if (!await fs.exists(draftPath)) {
+    echoError(`itc-author-complete: draft not found: ${draftPath}`);
+    return 1;
+  }
+  const draftText = await fs.readFile(draftPath);
+  if (draftText.trim().length === 0) {
+    echoError(`itc-author-complete: empty draft in ${draftPath}`);
+    return 1;
+  }
+  const draftDigest = createHash7("sha256").update(draftText).digest("hex");
+  const outlinePath = join19(workDir, "2-outline/outline-approved.md");
+  if (!await fs.exists(outlinePath)) {
+    echoError(`itc-author-complete: approved outline not found: ${outlinePath}`);
+    return 1;
+  }
+  const outlineText = await fs.readFile(outlinePath);
+  if (outlineText.trim().length === 0) {
+    echoError(`itc-author-complete: empty outline in ${outlinePath}`);
+    return 1;
+  }
+  const outlineDigest = createHash7("sha256").update(outlineText).digest("hex");
+  const verdictPath = join19(workDir, ".itc-verdict.json");
+  let judgeDigest = null;
+  let reviewMode = reviewModeArg === "manual" ? "manual" : "judged";
+  if (await fs.exists(verdictPath)) {
+    try {
+      const verdictRaw = await fs.readFile(verdictPath);
+      const verdictData = JSON.parse(verdictRaw);
+      if (verdictData.verdict !== "PASS") {
+        echoError(`itc-author-complete: judge verdict is not PASS: ${String(verdictData.verdict)}`);
+        return 1;
+      }
+      const conf = String(verdictData.confidence ?? "");
+      if (!["HIGH", "MEDIUM", "LOW"].includes(conf)) {
+        echoError(`itc-author-complete: judge confidence must be HIGH, MEDIUM, or LOW, got '${conf}'`);
+        return 1;
+      }
+      judgeDigest = createHash7("sha256").update(verdictRaw).digest("hex");
+      reviewMode = "judged";
+    } catch (err) {
+      echoError(`itc-author-complete: invalid verdict JSON: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  } else {
+    reviewMode = "manual";
+  }
+  const runPath = join19(workDir, ".itc/author-run.json");
+  let childRunId = `${parentRunId}-author`;
+  if (await fs.exists(runPath)) {
+    try {
+      const runMeta = JSON.parse(await fs.readFile(runPath));
+      if (runMeta.childRunId)
+        childRunId = runMeta.childRunId;
+    } catch {}
+  }
+  const completeReceipt = {
+    schemaVersion: 1,
+    parentRunId,
+    childRunId,
+    draftDigest,
+    outlineDigest,
+    judgeDigest,
+    reviewMode,
+    status: "complete"
+  };
+  const itcDir = join19(workDir, ".itc");
+  await fs.ensureDir(itcDir);
+  await fs.writeFile(join19(itcDir, "author-complete.json"), `${JSON.stringify(completeReceipt, null, 2)}
+`);
+  return 0;
+}
+async function runItcPrepare(args, fs) {
+  const requestIdx = args.indexOf("--request");
+  const requestFile = requestIdx !== -1 ? args[requestIdx + 1] : undefined;
+  if (requestFile === undefined || requestFile === "") {
+    echoError("itc-prepare: --request <launch.json> is required");
+    return 1;
+  }
+  if (!await fs.exists(requestFile)) {
+    echoError(`itc-prepare: request file not found: ${requestFile}`);
+    return 1;
+  }
+  let launch;
+  try {
+    launch = JSON.parse(await fs.readFile(requestFile));
+  } catch (err) {
+    echoError(`itc-prepare: invalid JSON in ${requestFile}: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  let options;
+  try {
+    options = await resolveItcOptions(launch, {
+      ...process.env.KK_CONFIG ? { env: process.env } : {}
+    }, fs);
+  } catch (err) {
+    echoError(`itc-prepare: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  const chosenIdx = args.indexOf("--chosen");
+  const intakeDir = chosenIdx !== -1 ? args[chosenIdx + 1] : undefined;
+  if (intakeDir !== undefined) {
+    if (options.status !== "intake") {
+      echoError("itc-prepare: --chosen applies only to a --from-collect launch");
+      return 1;
+    }
+    const chosenPath = join19(intakeDir, "chosen-source.json");
+    if (!await fs.exists(chosenPath)) {
+      echoError(`itc-prepare: chosen source not found: ${chosenPath}`);
+      return 1;
+    }
+    let chosen;
+    try {
+      chosen = JSON.parse(await fs.readFile(chosenPath));
+      if (chosen.parentRunId !== options.parentRunId) {
+        throw new Error(`chosen source belongs to run '${chosen.parentRunId}', not '${options.parentRunId}'`);
+      }
+      options = finalizeItcCollectedOptions(options, chosen, launch);
+    } catch (err) {
+      echoError(`itc-prepare: ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  }
+  const workDir = options.workDir;
+  if (workDir === null) {
+    echo(JSON.stringify(options));
+    return 0;
+  }
+  const reuseCheck = await verifyItcOptionsSnapshot(workDir, options, fs);
+  if (reuseCheck.ok === false && !options.force) {
+    echoError(`itc-prepare: ${reuseCheck.reason}`);
+    return 1;
+  }
+  try {
+    await writeItcOptionsSnapshot(workDir, options, fs);
+    if (intakeDir !== undefined) {
+      const copies = [
+        ["chosen-source.json", "chosen-source.json"],
+        ["selected-docs.json", "docs.json"],
+        ["topic-pool-manifest.json", "topic-pool-manifest.json"]
+      ];
+      for (const [from, to] of copies) {
+        const src = join19(intakeDir, from);
+        if (await fs.exists(src))
+          await fs.writeFile(join19(workDir, to), await fs.readFile(src));
+      }
+    }
+  } catch (err) {
+    echoError(`itc-prepare: cannot write the workspace at ${workDir}: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+  echo(JSON.stringify(options));
+  return 0;
+}
+
+// src/commands/stage.ts
+var ROOT_GLOBALS = new Set(["-v", "--verbose"]);
+function normalizeStageArgs(argv) {
+  let i = 2;
+  while (i < argv.length && ROOT_GLOBALS.has(argv[i])) {
+    i += 1;
+  }
+  const next = argv[i + 1];
+  if (argv[i] !== "stage" || next === undefined || next === "run" || next === "--help" || next === "-h") {
+    return [...argv];
+  }
+  return [...argv.slice(0, i + 1), "run", ...argv.slice(i + 1)];
+}
+function registerStageCommand(program) {
+  program.command("stage").description("Run a kk-workflow-stages.ts stage (workflow orchestration steps)").command("run").description("Run one stage by name with positional pass-through").argument("<args...>", "Stage name followed by its positional arguments").allowUnknownOption(true).action((args) => {
+    if (args[0]?.startsWith("itc-")) {
+      return (async () => {
+        const itcCode = await runItcStage(args);
+        const code = itcCode !== undefined ? itcCode : await runStageCancellable(args);
+        if (code !== 0) {
+          throw new CommanderError(code, "kk.stage.failed", `stage failed with exit code ${code}`);
+        }
+      })();
+    }
+    return (async () => {
+      const code = await runStageCancellable(args);
+      if (code !== 0) {
+        throw new CommanderError(code, "kk.stage.failed", `stage failed with exit code ${code}`);
+      }
+    })();
+  });
+}
+
+// src/commands/store.ts
+import { dirname as dirname12, join as join20, resolve as resolve21 } from "path";
+init_dist3();
+init_commander();
+init_output2();
+var HEURISTIC_MAKER = "heuristic";
+var LABEL_PLUGIN = "episode-plan-gen";
+var LABEL_SCRATCH_DIR = "label";
+var PROFILE_DIR_REL = "plugins/kk/decisions/extract";
+var CHECKOUT_ROOT3 = resolve21(import.meta.dir, "../../../..");
+var CATALOG_PATH_REL = "plugins/kk/decisions/kk-items.yaml";
+var TOPIC_SLUG = /^[a-z0-9][a-z0-9-]*$/;
+var WINDOW_UNITS2 = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+var DEFAULT_EXTRACT_WINDOW = "24h";
+var CATEGORY_DECISION_ID = "kk-item-category";
+var CATEGORY_LABELS = ["ai-news", "ai-technical", "ai-research", "ai-industry", "non-ai"];
+var SCORE_DIMENSIONS = ["quality", "importance", "urgency", "impact"];
+var AUDIENCE_LABELS = ["general", "practitioner", "researcher"];
+var LABEL_DECISIONS = [
+  { id: CATEGORY_DECISION_ID, kind: "choice", labels: CATEGORY_LABELS },
+  { id: "kk-item-quality", kind: "score", levels: 6 },
+  { id: "kk-item-importance", kind: "score", levels: 6 },
+  { id: "kk-item-urgency", kind: "score", levels: 6 },
+  { id: "kk-item-impact", kind: "score", levels: 6 },
+  { id: CHINA_POLITICS_DECISION_ID, kind: "score", levels: 4 },
+  { id: "kk-item-sensitivity", kind: "score", levels: 4 },
+  { id: "kk-item-audience", kind: "choice", labels: AUDIENCE_LABELS }
+];
+var HEURISTIC_DECISION_IDS = [
+  CATEGORY_DECISION_ID,
+  ...SCORE_DIMENSIONS.map((dimension) => `kk-item-${dimension}`)
+];
+var KEYWORD_MAKER = "keyword";
+var CHINA_POLITICS_BODY_HEAD = 200;
+function failLoud5(code, error) {
+  const cause = error instanceof Error ? error.message : String(error);
+  const message = `${code}: ${cause}`;
+  consoleOutput.error(message);
+  throw new CommanderError(1, code, message);
+}
+async function migrateAction(options) {
+  try {
+    const dbPath = await resolveStorePath(resolveKkConfigPath(), options.db);
+    const store = await openStore({ path: dbPath });
+    const applied = store.appliedMigrations;
+    await store.close();
+    consoleOutput.write(JSON.stringify({ db: dbPath, applied }));
+  } catch (error) {
+    failLoud5("kk.store.migrate.failed", error);
+  }
+}
+async function readDocList2(fs, path, label) {
+  if (!await fs.exists(path)) {
+    throw new Error(`input file not found: ${path}`);
+  }
+  return readPluginJson(fs, path, DocListSchema, label, "is not a Doc[]");
+}
+async function invalidatedIds(items, docs) {
+  const byId = new Map;
+  for (const doc of docs) {
+    byId.set(itemId(doc), doc);
+  }
+  const invalidated = [];
+  for (const [id, doc] of byId) {
+    const stored = await items.findById(id);
+    if (stored === undefined) {
+      continue;
+    }
+    if (stored.title !== (doc.title ?? "") || stored.body !== doc.body) {
+      invalidated.push(id);
+    }
+  }
+  return invalidated;
+}
+function sourceCountsOf2(docs) {
+  const counts = {};
+  for (const doc of docs) {
+    const sources = doc.metadata?.sources;
+    if (!Array.isArray(sources))
+      continue;
+    for (const source of sources) {
+      const file = source?.file;
+      if (typeof file === "string" && file !== "")
+        counts[file] = (counts[file] ?? 0) + 1;
+    }
+  }
+  return counts;
+}
+async function writeNewIds(fs, path, ids) {
+  await fs.ensureDir(dirname12(path));
+  await fs.writeFile(path, `${JSON.stringify([...new Set(ids)], null, 2)}
+`);
+}
+async function ingestAction(options) {
+  try {
+    const fs = createNodeFileSystem();
     const docs = await readDocList2(fs, options.in, `Store ingest input '${options.in}'`);
     const dbPath = await resolveStorePath(resolveKkConfigPath(), options.db);
     const story = (await readStoreConfig(resolveKkConfigPath())).story;
@@ -47886,8 +50612,8 @@ async function readAnnotations(fs, outputPath) {
 async function heuristicAnnotations(fs, scratch, runId, items) {
   if (items.length === 0)
     return new Map;
-  const inputPath = join15(scratch, "label-input.json");
-  const outputPath = join15(scratch, "label-out.json");
+  const inputPath = join20(scratch, "label-input.json");
+  const outputPath = join20(scratch, "label-out.json");
   await fs.ensureDir(scratch);
   const docs = items.map((item) => ({
     id: item.id,
@@ -48056,7 +50782,7 @@ function keywordRow(item, term, runId, catalogVersion) {
 }
 async function labelItem(fs, scratch, item, annotation, mode, maker, runId, catalogVersion, chinaPoliticsTerms) {
   const routed = mode === "decision" || annotation?.needsModel === true;
-  const evidencePath = join15(scratch, `evidence-${item.id}.md`);
+  const evidencePath = join20(scratch, `evidence-${item.id}.md`);
   await fs.writeFile(evidencePath, item.body);
   let consults = 0;
   let consultMs = 0;
@@ -48090,7 +50816,7 @@ async function labelItem(fs, scratch, item, annotation, mode, maker, runId, cata
   return { rows, consults, consultMs, refused };
 }
 async function replayItem(fs, scratch, item, decisionIds, maker, runId, catalogVersion) {
-  const evidencePath = join15(scratch, `evidence-${item.id}.md`);
+  const evidencePath = join20(scratch, `evidence-${item.id}.md`);
   await fs.writeFile(evidencePath, item.body);
   const rows = [];
   let consults = 0;
@@ -48118,7 +50844,7 @@ function parseReplaySelector(raw) {
     throw new Error(`--replay must be 'topic:<profile>', 'run:<collect-run-id>' or 'since:<n><s|m|h|d>', got '${raw}'`);
   }
   if (kind === "since")
-    parseWindow(value);
+    parseWindow2(value);
   return { kind, value };
 }
 function parseDecisions(raw) {
@@ -48137,7 +50863,7 @@ function parseDecisions(raw) {
   return ids;
 }
 async function readCatalogVersion(fs) {
-  const candidates = [resolve18(process.cwd(), CATALOG_PATH_REL), resolve18(CHECKOUT_ROOT3, CATALOG_PATH_REL)];
+  const candidates = [resolve21(process.cwd(), CATALOG_PATH_REL), resolve21(CHECKOUT_ROOT3, CATALOG_PATH_REL)];
   for (const path of candidates) {
     try {
       if (!await fs.exists(path))
@@ -48215,13 +50941,13 @@ async function replayItemIds(fs, store, selector, window, policy) {
   if (selector.kind === "run")
     return store.items.idsByRun(selector.value);
   if (selector.kind === "since")
-    return store.items.idsSince(Date.now() - parseWindow(selector.value));
+    return store.items.idsSince(Date.now() - parseWindow2(selector.value));
   const profilePath = await resolveProfilePath(fs, selector.value);
   const profile = parseProfile(await fs.readFile(profilePath));
   if (profile.topic !== selector.value) {
     throw new ProfileInvalidError(`profile '${profilePath}' declares topic '${profile.topic}', not '${selector.value}'`);
   }
-  const query = compileProfile(profile, { windowMs: parseWindow(window), now: Date.now() });
+  const query = compileProfile(profile, { windowMs: parseWindow2(window), now: Date.now() });
   return (await store.items.selectByProfile(query, policy)).map((doc) => doc.id);
 }
 async function replaySelected(fs, store, selector, decisions, window, maker, catalogVersion, scratch, policy) {
@@ -48265,7 +50991,7 @@ async function labelAction(options) {
     const mode = parseLabelMode(options.mode);
     const configPath = resolveKkConfigPath();
     const dbPath = await resolveStorePath(configPath, options.db);
-    const scratch = join15(dirname10(plan.kind === "new-ids" ? plan.newIds : dbPath), LABEL_SCRATCH_DIR);
+    const scratch = join20(dirname12(plan.kind === "new-ids" ? plan.newIds : dbPath), LABEL_SCRATCH_DIR);
     const store = await openStore({ path: dbPath });
     const catalogVersion = await readCatalogVersion(fs);
     const labels = (await readStoreConfig(configPath)).labels;
@@ -48283,14 +51009,14 @@ async function labelAction(options) {
     failLoud5("kk.store.label.failed", error);
   }
 }
-function parseWindow(raw) {
+function parseWindow2(raw) {
   const match = /^(\d+)([smhd])$/.exec(raw.trim());
   const amount = match?.[1];
   const unit = match?.[2];
   if (amount === undefined || unit === undefined) {
     throw new Error(`--window must be '<n>s|m|h|d' (e.g. 24h), got '${raw}'`);
   }
-  const milliseconds = Number(amount) * (WINDOW_UNITS[unit] ?? 0);
+  const milliseconds = Number(amount) * (WINDOW_UNITS2[unit] ?? 0);
   if (milliseconds <= 0) {
     throw new Error(`--window must be greater than zero, got '${raw}'`);
   }
@@ -48308,8 +51034,8 @@ async function resolveProfilePath(fs, topic) {
     throw new Error(`--topic must be a lowercase slug (e.g. ai-news), got '${topic}'`);
   }
   const candidates = [
-    resolve18(process.cwd(), PROFILE_DIR_REL, `${topic}.yaml`),
-    resolve18(CHECKOUT_ROOT3, PROFILE_DIR_REL, `${topic}.yaml`)
+    resolve21(process.cwd(), PROFILE_DIR_REL, `${topic}.yaml`),
+    resolve21(CHECKOUT_ROOT3, PROFILE_DIR_REL, `${topic}.yaml`)
   ];
   for (const path of candidates) {
     if (await fs.exists(path))
@@ -48317,7 +51043,7 @@ async function resolveProfilePath(fs, topic) {
   }
   throw new Error(`no profile for topic '${topic}': expected one of ${candidates.join(" or ")}`);
 }
-function toPoolDoc(item) {
+function toPoolDoc2(item) {
   return {
     id: item.id,
     title: item.title,
@@ -48336,7 +51062,7 @@ async function extractAction(options) {
       throw new ProfileInvalidError(`profile '${profilePath}' declares topic '${profile.topic}', not '${options.topic}'`);
     }
     const query = compileProfile(profile, {
-      windowMs: parseWindow(options.window),
+      windowMs: parseWindow2(options.window),
       now: Date.now(),
       ...options.limit === undefined ? {} : { limit: parseLimit(options.limit) },
       ...options.includeSelected === true ? {} : { excludeTopic: options.topic }
@@ -48345,8 +51071,8 @@ async function extractAction(options) {
     const store = await openStore({ path: dbPath });
     try {
       const policy = (await readStoreConfig(resolveKkConfigPath())).labels;
-      const docs = (await store.items.selectByProfile(query, policy)).map(toPoolDoc);
-      await fs.ensureDir(dirname10(options.out));
+      const docs = (await store.items.selectByProfile(query, policy)).map(toPoolDoc2);
+      await fs.ensureDir(dirname12(options.out));
       await fs.writeFile(options.out, `${JSON.stringify(docs, null, 2)}
 `);
       consoleOutput.write(JSON.stringify({ count: docs.length }));