@gobing-ai/knowledge-kit 0.1.7 → 0.1.9

package/dist/index.js

@@ -42732,6 +42732,9 @@ async function runInvoke(opts) {
     echoError(`Plugin entry '${record.name}' failed (exit code ${proc.exitCode}): ${errMsg}`);
     return proc.exitCode;
   }
+  if (proc.stderr !== "") {
+    echoError(`[plugin:${record.name}] ${proc.stderr}`);
+  }
   if (!existsSync3(absOutPath)) {
     echoError(`Plugin entry succeeded but did not write output file: ${absOutPath}`);
     return 1;
@@ -42977,6 +42980,90 @@ var DAILY_VOICE_ARTIFACTS = [
     kind: "text",
     pattern: "{stamp}_19_run-report_report.md",
     producerNode: "run-report"
+  },
+  {
+    id: "episode-pool",
+    label: "Episode pool",
+    kind: "json",
+    pattern: "10-collect/pool.json",
+    producerNode: "extract"
+  },
+  {
+    id: "episode-annotated",
+    label: "QC annotation input",
+    kind: "json",
+    pattern: "21-plan/{stamp}_04_quality-control-content_annotated.json",
+    producerNode: "qc-content"
+  },
+  {
+    id: "episode-qc-rejections",
+    label: "QC rejections",
+    kind: "json",
+    pattern: "21-plan/{stamp}_04_quality-control-content_candidates.rejected.json",
+    producerNode: "qc-content"
+  },
+  {
+    id: "episode-exclusions",
+    label: "Topic exclusions",
+    kind: "json",
+    pattern: "21-plan/{stamp}_04_quality-control-content_exclusions.json",
+    producerNode: "qc-content"
+  },
+  {
+    id: "episode-candidates",
+    label: "Post-QC candidates",
+    kind: "json",
+    pattern: "21-plan/{stamp}_04_quality-control-content_candidates.json",
+    producerNode: "qc-content"
+  },
+  {
+    id: "episode-plan",
+    label: "Episode plan",
+    kind: "json",
+    pattern: "21-plan/{stamp}_03_plan_plan.json",
+    producerNode: "plan"
+  },
+  {
+    id: "episode-floor-refusal",
+    label: "QC floor refusal",
+    kind: "json",
+    pattern: "21-plan/{stamp}_04_quality-control-content_floor-refusal.json",
+    producerNode: "qc-content"
+  },
+  {
+    id: "episode-duration",
+    label: "Duration verdict",
+    kind: "json",
+    pattern: "30-audio/{stamp}_11_generate_content_duration.json",
+    producerNode: "duration"
+  },
+  {
+    id: "episode-duration-refusal",
+    label: "Duration refusal",
+    kind: "json",
+    pattern: "30-audio/{stamp}_11_generate_content_duration-refusal.json",
+    producerNode: "duration"
+  },
+  {
+    id: "episode-script-refusal",
+    label: "Script refusal",
+    kind: "json",
+    pattern: "30-audio/{stamp}_11_generate_content_duration-refusal.json",
+    producerNode: "generate"
+  },
+  {
+    id: "episode-script-refusal-fallback",
+    label: "Script refusal (fallback)",
+    kind: "json",
+    pattern: "30-audio/{stamp}_11_generate_content_duration-refusal.json",
+    producerNode: "generate-fallback"
+  },
+  {
+    id: "episode-script-refusal-fallback2",
+    label: "Script refusal (second fallback)",
+    kind: "json",
+    pattern: "30-audio/{stamp}_11_generate_content_duration-refusal.json",
+    producerNode: "generate-fallback2"
   }
 ];
 var ITC_ARTIFACTS = [
@@ -44621,6 +44708,23 @@ function statusOf(rank) {
     return "dropped";
   return "none";
 }
+function parseSourceCounts(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return null;
+  const counts = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0)
+      return null;
+    counts[key] = value;
+  }
+  return counts;
+}
 
 class CollectViewDao extends BaseDao {
   constructor(adapter) {
@@ -44721,6 +44825,66 @@ class CollectViewDao extends BaseDao {
     const rows = await this.adapter.queryAll("SELECT DISTINCT topic AS topic FROM selections WHERE topic <> '' ORDER BY topic");
     return rows.map((row) => row.topic);
   }
+  async channelYield(sinceMs, untilMs) {
+    const rows = untilMs === undefined ? await this.adapter.queryAll(`SELECT date(first_seen_at / 1000, 'unixepoch', 'localtime') AS day,
+                              source AS source,
+                              COUNT(*) AS items
+                       FROM items WHERE first_seen_at >= ?
+                       GROUP BY day, source
+                       ORDER BY day DESC, items DESC, source ASC`, sinceMs) : await this.adapter.queryAll(`SELECT date(first_seen_at / 1000, 'unixepoch', 'localtime') AS day,
+                              source AS source,
+                              COUNT(*) AS items
+                       FROM items WHERE first_seen_at >= ? AND first_seen_at < ?
+                       GROUP BY day, source
+                       ORDER BY day DESC, items DESC, source ASC`, sinceMs, untilMs);
+    return rows.map((row) => ({
+      day: row.day,
+      source: row.source === "" ? "(none)" : row.source,
+      items: row.items
+    }));
+  }
+  async channelRunYield(fromMs, untilMs) {
+    const rows = await this.adapter.queryAll(`SELECT date(started_at / 1000, 'unixepoch', 'localtime') AS day,
+                    started_at AS startedAt,
+                    source_counts_json AS sourceCountsJson
+             FROM collect_runs WHERE started_at >= ? AND started_at < ?
+             ORDER BY started_at ASC`, fromMs, untilMs);
+    const byDay = new Map;
+    for (const row of rows) {
+      const entry = byDay.get(row.day) ?? { runs: 0, plugins: {} };
+      entry.runs += 1;
+      const counts = parseSourceCounts(row.sourceCountsJson);
+      if (counts === null) {
+        entry.plugins = null;
+      } else if (entry.plugins !== null) {
+        for (const [plugin, count] of Object.entries(counts)) {
+          entry.plugins[plugin] = (entry.plugins[plugin] ?? 0) + count;
+        }
+      }
+      byDay.set(row.day, entry);
+    }
+    const history = await this.adapter.queryAll(`SELECT started_at AS startedAt, source_counts_json AS sourceCountsJson
+             FROM collect_runs WHERE started_at < ?
+             ORDER BY started_at ASC`, untilMs);
+    const lastPositiveAt = {};
+    for (const row of history) {
+      const counts = parseSourceCounts(row.sourceCountsJson);
+      if (counts === null)
+        continue;
+      for (const [plugin, count] of Object.entries(counts)) {
+        if (count > 0)
+          lastPositiveAt[plugin] = row.startedAt;
+      }
+    }
+    return {
+      days: [...byDay.entries()].map(([day, entry]) => ({
+        day,
+        runs: entry.runs,
+        plugins: entry.plugins
+      })),
+      lastPositiveAt
+    };
+  }
   async itemsPage(runId, filter, page, policy) {
     const params = [];
     const conditions = [];
@@ -45737,6 +45901,12 @@ var SOURCE_COUNTS = {
   code: "board.store.row-invalid",
   message: "A stored run row carries source counts that are not valid JSON."
 };
+var NAMED_PLUGINS = ["aihot-ingest", "horizon-ingest", "last30days-ingest"];
+var CHANNELS_PAGE_SIZE = 30;
+var CHANNEL_INVALID = {
+  code: "board.store.channel-invalid",
+  message: "A stored run row carries plugin counts that are not nonnegative integers."
+};
 async function sessionFor(deps) {
   const fs = deps.fs ?? createNodeFileSystem();
   const dbPath = join5(deps.projectPath, DEFAULT_STORE_DB_PATH);
@@ -46043,6 +46213,103 @@ function emptyItems(runId, query, sources) {
     diagnostics: []
   };
 }
+function hostTimeZone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function emptyChannels(query, diagnostics) {
+  return {
+    schemaVersion: 1,
+    availability: "unavailable",
+    fromMs: query.fromMs,
+    untilMs: query.untilMs,
+    timeZone: hostTimeZone(),
+    page: query.page,
+    pageSize: CHANNELS_PAGE_SIZE,
+    totalDays: 0,
+    sources: [],
+    plugins: [],
+    byDay: [],
+    bySource: {},
+    runsByDay: [],
+    lastPositiveAt: {},
+    diagnostics
+  };
+}
+async function storeChannels(deps, query) {
+  const session = await sessionFor(deps);
+  if (!session.ok)
+    return emptyChannels(query, session.diagnostics);
+  const { store, diagnostics } = session.session;
+  try {
+    const [itemDays, runYield] = await Promise.all([
+      store.collectView.channelYield(query.fromMs, query.untilMs),
+      store.collectView.channelRunYield(query.fromMs, query.untilMs)
+    ]);
+    const sources = [...new Set(itemDays.map((row) => row.source))].sort();
+    const bySource = {};
+    const itemByDay = new Map;
+    for (const row of itemDays) {
+      const entry = itemByDay.get(row.day) ?? { total: 0, sources: {} };
+      entry.total += row.items;
+      entry.sources[row.source] = (entry.sources[row.source] ?? 0) + row.items;
+      itemByDay.set(row.day, entry);
+      bySource[row.source] = (bySource[row.source] ?? 0) + row.items;
+    }
+    const runByDay = new Map(runYield.days.map((day) => [day.day, day]));
+    const observedPlugins = new Set;
+    for (const day of runYield.days) {
+      if (day.plugins !== null)
+        for (const plugin of Object.keys(day.plugins))
+          observedPlugins.add(plugin);
+    }
+    for (const plugin of Object.keys(runYield.lastPositiveAt))
+      observedPlugins.add(plugin);
+    const plugins = [...new Set([...NAMED_PLUGINS, ...observedPlugins])].sort();
+    const days = [...new Set([...itemByDay.keys(), ...runByDay.keys()])].sort().reverse();
+    const totalDays = days.length;
+    const offset = (Math.max(1, query.page) - 1) * CHANNELS_PAGE_SIZE;
+    const pageDays = days.slice(offset, offset + CHANNELS_PAGE_SIZE);
+    const byDay = pageDays.map((day) => {
+      const item = itemByDay.get(day);
+      const sourcesOfDay = {};
+      for (const source of sources)
+        sourcesOfDay[source] = item?.sources[source] ?? 0;
+      return { day, total: item?.total ?? 0, sources: sourcesOfDay };
+    });
+    const runsByDay = pageDays.map((day) => {
+      const run = runByDay.get(day);
+      const pluginsOfDay = run?.plugins === null ? null : Object.fromEntries(plugins.map((plugin) => [plugin, run?.plugins?.[plugin] ?? 0]));
+      return { day, runs: run?.runs ?? 0, plugins: pluginsOfDay };
+    });
+    const lastPositiveAt = {};
+    for (const plugin of plugins)
+      lastPositiveAt[plugin] = runYield.lastPositiveAt[plugin] ?? null;
+    const channelDiagnostics = [...diagnostics];
+    if (runYield.days.some((day) => day.plugins === null))
+      channelDiagnostics.push(CHANNEL_INVALID);
+    return {
+      schemaVersion: 1,
+      availability: "available",
+      fromMs: query.fromMs,
+      untilMs: query.untilMs,
+      timeZone: hostTimeZone(),
+      page: query.page,
+      pageSize: CHANNELS_PAGE_SIZE,
+      totalDays,
+      sources,
+      plugins,
+      byDay,
+      bySource,
+      runsByDay,
+      lastPositiveAt,
+      diagnostics: channelDiagnostics
+    };
+  } catch {
+    return emptyChannels(query, [...diagnostics, UNREADABLE]);
+  } finally {
+    await store.close();
+  }
+}
 
 // src/board/daily-voice.ts
 var isTrue = (settings, key) => settings[key] === "true";
@@ -46258,6 +46525,280 @@ function channelOutcomes(settings, availability, textOf) {
 function stringArray(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
 }
+var FUNNEL_EXCLUSION_ROWS = 100;
+var FUNNEL_TEXT_CHARS = 200;
+function parseAnyJson(raw) {
+  if (raw === undefined)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function nonNegativeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function arrayCount(value) {
+  return Array.isArray(value) ? value.length : null;
+}
+function minutesFromSeconds(seconds) {
+  return Math.round(seconds / 60 * 10) / 10;
+}
+function exclusionRow(entry) {
+  const record = asRecord3(entry);
+  if (record === null || typeof record.rule !== "string")
+    return null;
+  return {
+    rule: record.rule.slice(0, FUNNEL_TEXT_CHARS),
+    matched: typeof record.matched === "string" ? record.matched.slice(0, FUNNEL_TEXT_CHARS) : ""
+  };
+}
+function measuredRefusalOf(record) {
+  if (record === null || record.stage === "script")
+    return null;
+  const measuredMinutes = nonNegativeNumber(record.measuredMinutes);
+  const minMinutes = nonNegativeNumber(record.minMinutes);
+  if (measuredMinutes === null || minMinutes === null)
+    return null;
+  return {
+    measuredMinutes,
+    estimatedMinutes: nonNegativeNumber(record.estimatedMinutes),
+    minMinutes,
+    keptCount: nonNegativeNumber(record.keptCount),
+    id: "episode-duration-refusal"
+  };
+}
+function scriptRefusalOf(availability, jsonOf) {
+  for (const id of [
+    "episode-script-refusal",
+    "episode-script-refusal-fallback",
+    "episode-script-refusal-fallback2"
+  ]) {
+    if (availability.get(id) !== "available")
+      continue;
+    const record = jsonOf(id);
+    if (record === null || record.stage !== "script")
+      continue;
+    return {
+      estimatedMinutes: nonNegativeNumber(record.estimatedMinutes),
+      minMinutes: nonNegativeNumber(record.minMinutes),
+      keptCount: nonNegativeNumber(record.keptCount),
+      id
+    };
+  }
+  return null;
+}
+function floorRefusalOf(record) {
+  if (record === null)
+    return null;
+  return {
+    estimatedMinutes: nonNegativeNumber(record.estimatedMinutes),
+    minMinutes: nonNegativeNumber(record.minMinutes),
+    id: "episode-floor-refusal"
+  };
+}
+function projectFunnel(settings, availability, textOf, outcome) {
+  const diagnostics = [];
+  const evidence = {};
+  const rawOf = (id) => parseAnyJson(textOf(id));
+  const poolRecord = rawOf("episode-pool");
+  const poolCount = arrayCount(poolRecord);
+  if (poolCount !== null)
+    evidence.poolCount = "episode-pool";
+  const annotatedCount = arrayCount(rawOf("episode-annotated"));
+  if (annotatedCount !== null)
+    evidence.annotatedCount = "episode-annotated";
+  const qcRejectedCount = arrayCount(asRecord3(rawOf("episode-qc-rejections"))?.rejected);
+  if (qcRejectedCount !== null)
+    evidence.qcRejectedCount = "episode-qc-rejections";
+  const exclusionsRecord = asRecord3(rawOf("episode-exclusions"));
+  const topicKeptCount = arrayCount(exclusionsRecord?.kept);
+  if (topicKeptCount !== null)
+    evidence.topicKeptCount = "episode-exclusions";
+  const plannedCount = arrayCount(rawOf("episode-plan"));
+  if (plannedCount !== null)
+    evidence.plannedCount = "episode-plan";
+  const exclusions = [];
+  const excludedRaw = Array.isArray(exclusionsRecord?.excluded) ? exclusionsRecord.excluded : [];
+  const truncated = excludedRaw.length > FUNNEL_EXCLUSION_ROWS || excludedRaw.some((entry) => typeof entry?.rule === "string" && entry.rule.length > FUNNEL_TEXT_CHARS);
+  for (const entry of excludedRaw.slice(0, FUNNEL_EXCLUSION_ROWS)) {
+    const row = exclusionRow(entry);
+    if (row !== null)
+      exclusions.push(row);
+  }
+  if (truncated) {
+    diagnostics.push({
+      code: "board.daily.funnel.truncated",
+      message: `Exclusion evidence was bounded to ${FUNNEL_EXCLUSION_ROWS} rows of ${FUNNEL_TEXT_CHARS} characters.`
+    });
+  }
+  const measured = measuredRefusalOf(asRecord3(rawOf("episode-duration-refusal")));
+  const script = scriptRefusalOf(availability, (id) => asRecord3(rawOf(id)) ?? null);
+  const floor = floorRefusalOf(asRecord3(rawOf("episode-floor-refusal")));
+  const refusalPresent = measured !== null || script !== null || floor !== null;
+  const candidatesRecord = asRecord3(rawOf("episode-candidates"));
+  const candidateDocs = arrayCount(metadataOf(candidatesRecord ?? {})?.docs);
+  const dedupKeptCount = refusalPresent ? null : candidateDocs;
+  if (dedupKeptCount !== null)
+    evidence.dedupKeptCount = "episode-candidates";
+  const verdict = asRecord3(rawOf("episode-duration"));
+  const verdictMeasured = nonNegativeNumber(verdict?.measuredMinutes);
+  const verdictMin = nonNegativeNumber(verdict?.minMinutes);
+  const verdictMax = nonNegativeNumber(verdict?.maxMinutes);
+  const audioSeconds = nonNegativeNumber(asRecord3(asRecord3(rawOf("audio-record"))?.metadata)?.duration);
+  let measuredMinutes = null;
+  if (measured !== null) {
+    measuredMinutes = measured.measuredMinutes;
+    evidence.measuredMinutes = measured.id;
+  } else if (verdictMeasured !== null) {
+    measuredMinutes = verdictMeasured;
+    evidence.measuredMinutes = "episode-duration";
+  } else if (audioSeconds !== null) {
+    measuredMinutes = minutesFromSeconds(audioSeconds);
+    evidence.measuredMinutes = "audio-record";
+  }
+  let estimatedMinutes = null;
+  if (measured?.estimatedMinutes != null) {
+    estimatedMinutes = measured.estimatedMinutes;
+    evidence.estimatedMinutes = measured.id;
+  } else if (script?.estimatedMinutes != null) {
+    estimatedMinutes = script.estimatedMinutes;
+    evidence.estimatedMinutes = script.id;
+  } else if (floor?.estimatedMinutes != null) {
+    estimatedMinutes = floor.estimatedMinutes;
+    evidence.estimatedMinutes = floor.id;
+  }
+  const settingsNumber = (key) => {
+    const value = Number(settings[key]);
+    return settings[key] !== undefined && Number.isFinite(value) && value >= 0 ? value : null;
+  };
+  let minMinutes = measured?.minMinutes ?? script?.minMinutes ?? floor?.minMinutes ?? verdictMin;
+  if (minMinutes !== null)
+    evidence.minMinutes = measured?.id ?? script?.id ?? floor?.id ?? "episode-duration";
+  else if (settingsNumber("episode_min_minutes") !== null) {
+    minMinutes = settingsNumber("episode_min_minutes");
+    evidence.minMinutes = "captured-settings";
+  }
+  let maxMinutes = verdictMax;
+  if (maxMinutes !== null)
+    evidence.maxMinutes = "episode-duration";
+  else if (settingsNumber("episode_max_minutes") !== null) {
+    maxMinutes = settingsNumber("episode_max_minutes");
+    evidence.maxMinutes = "captured-settings";
+  }
+  if (poolCount !== null && annotatedCount !== null && poolCount !== annotatedCount) {
+    diagnostics.push({
+      code: "board.daily.funnel.mismatch",
+      message: `Stage evidence disagrees: the pool records ${poolCount} item(s) while the annotation input carries ${annotatedCount}; both are shown as recorded.`
+    });
+  }
+  let gate = null;
+  if (outcome === "full" || outcome === "partial") {
+    if (refusalPresent) {
+      diagnostics.push({
+        code: "board.daily.funnel.contradictory",
+        message: "A refusal artifact is present beside a recorded content outcome; the outcome stands and the gate stays unset."
+      });
+    }
+  } else {
+    if (measured !== null)
+      gate = "episode-duration";
+    else if (script !== null)
+      gate = "script";
+    else if (floor !== null)
+      gate = "qc-floor";
+    else if (poolCount === 0)
+      gate = "empty-pool";
+    else if (poolCount !== null && poolCount > 0 && candidateDocs === 0)
+      gate = "qc-empty";
+    else
+      gate = "unknown";
+    if (gate === "empty-pool")
+      evidence.gate = "episode-pool";
+    else if (gate === "qc-empty")
+      evidence.gate = "episode-candidates";
+    else if (gate !== "unknown")
+      evidence.gate = measured?.id ?? script?.id ?? floor?.id ?? "";
+  }
+  return {
+    poolCount,
+    annotatedCount,
+    qcRejectedCount,
+    topicKeptCount,
+    dedupKeptCount,
+    plannedCount,
+    estimatedMinutes,
+    measuredMinutes,
+    minMinutes,
+    maxMinutes,
+    gate,
+    exclusions,
+    evidence,
+    diagnostics
+  };
+}
+function boundedText(value, limit = FUNNEL_TEXT_CHARS) {
+  return typeof value === "string" && value !== "" ? value.slice(0, limit) : null;
+}
+function countProjection(value, key = "count") {
+  return Array.isArray(value) ? { [key]: value.length } : null;
+}
+function sanitizeFunnelArtifact(workflow, artifactId, raw) {
+  if (workflow !== "kk-daily-ai-voice2")
+    return null;
+  const parsed = parseAnyJson(raw);
+  if (parsed === null && raw !== undefined)
+    return { note: "malformed" };
+  const record = asRecord3(parsed);
+  switch (artifactId) {
+    case "episode-pool":
+    case "episode-annotated":
+    case "episode-plan":
+      return countProjection(parsed);
+    case "episode-qc-rejections":
+      return countProjection(record?.rejected, "rejectedCount");
+    case "episode-candidates":
+      return countProjection(metadataOf(record ?? {})?.docs, "docCount");
+    case "episode-exclusions": {
+      if (record === null)
+        return null;
+      const excluded = Array.isArray(record.excluded) ? record.excluded : [];
+      return {
+        keptCount: arrayCount(record.kept),
+        excluded: excluded.slice(0, FUNNEL_EXCLUSION_ROWS).map((entry) => exclusionRow(entry)).filter((row) => row !== null)
+      };
+    }
+    case "episode-floor-refusal":
+      return record === null ? null : {
+        estimatedMinutes: nonNegativeNumber(record.estimatedMinutes),
+        minMinutes: nonNegativeNumber(record.minMinutes),
+        candidateChars: nonNegativeNumber(record.candidateChars),
+        reason: boundedText(record.reason)
+      };
+    case "episode-duration":
+      return record === null ? null : {
+        measuredMinutes: nonNegativeNumber(record.measuredMinutes),
+        minMinutes: nonNegativeNumber(record.minMinutes),
+        maxMinutes: nonNegativeNumber(record.maxMinutes),
+        ok: typeof record.ok === "boolean" ? record.ok : null
+      };
+    case "episode-duration-refusal":
+    case "episode-script-refusal":
+    case "episode-script-refusal-fallback":
+    case "episode-script-refusal-fallback2":
+      return record === null ? null : {
+        stage: record.stage === "script" ? "script" : null,
+        measuredMinutes: nonNegativeNumber(record.measuredMinutes),
+        estimatedMinutes: nonNegativeNumber(record.estimatedMinutes),
+        minMinutes: nonNegativeNumber(record.minMinutes),
+        keptCount: nonNegativeNumber(record.keptCount),
+        reason: boundedText(record.reason)
+      };
+    default:
+      return null;
+  }
+}
 function projectDailyResults(input) {
   const { record, detail, marker } = input;
   const terminal = isTerminalStatus(detail.status);
@@ -46300,6 +46841,7 @@ function projectDailyResults(input) {
     channels,
     quality,
     safety,
+    funnel: projectFunnel(record.settings, availability, textOf, outcome),
     progress: projectProgress(input.actions, record.topology),
     counts: {
       artifactsAvailable: availableCount,
@@ -46988,6 +47530,13 @@ function createBoardReader(options) {
         }
       };
     }
+    const sanitized = sanitizeFunnelArtifact(workflow, artifactId, observed.text);
+    if (sanitized !== null) {
+      return {
+        status: 200,
+        body: { schemaVersion: 1, artifact: artifactId, projection: sanitized }
+      };
+    }
     return {
       status: range === null ? 200 : 206,
       body: {
@@ -47018,6 +47567,9 @@ function createBoardReader(options) {
   async function storeSelectionsFor(query) {
     return { status: 200, body: await storeSelections({ projectPath, fs }, query) };
   }
+  async function storeChannelsFor(query) {
+    return { status: 200, body: await storeChannels({ projectPath, fs }, query) };
+  }
   const server = Bun.serve({
     hostname: "127.0.0.1",
     port,
@@ -47049,11 +47601,12 @@ function createBoardReader(options) {
       }
       const overviewMatch = /^\/api\/workflows\/([^/]+)\/store\/overview$/.exec(path);
       const selectionsMatch = /^\/api\/workflows\/([^/]+)\/store\/selections$/.exec(path);
+      const channelsMatch = /^\/api\/workflows\/([^/]+)\/store\/channels$/.exec(path);
       const storeItemsMatch = /^\/api\/workflows\/([^/]+)\/store\/items$/.exec(path);
       const runStoreSelectionsMatch = /^\/api\/workflows\/([^/]+)\/runs\/([^/]+)\/store\/selections$/.exec(path);
       const runStoreMatch = /^\/api\/workflows\/([^/]+)\/runs\/([^/]+)\/store$/.exec(path);
       const runStoreItemsMatch = /^\/api\/workflows\/([^/]+)\/runs\/([^/]+)\/store\/items$/.exec(path);
-      const storeMatch = overviewMatch ?? selectionsMatch ?? storeItemsMatch ?? runStoreSelectionsMatch ?? runStoreMatch ?? runStoreItemsMatch;
+      const storeMatch = overviewMatch ?? selectionsMatch ?? channelsMatch ?? storeItemsMatch ?? runStoreSelectionsMatch ?? runStoreMatch ?? runStoreItemsMatch;
       if (storeMatch !== null) {
         const storeRaw = storeMatch[1] ?? "";
         if (decodeURIComponent(storeRaw) !== STORE_WORKFLOW) {
@@ -47073,6 +47626,13 @@ function createBoardReader(options) {
           const response = await storeSelectionsFor(query.query);
           return jsonResponse(response.body, response.status, cors);
         }
+        if (channelsMatch !== null) {
+          const query = parseChannelsQuery(url.searchParams);
+          if ("response" in query)
+            return jsonResponse(query.response.body, query.response.status, cors);
+          const response = await storeChannelsFor(query.query);
+          return jsonResponse(response.body, response.status, cors);
+        }
         if (storeItemsMatch !== null) {
           const query = parseItemsQuery(url.searchParams);
           if ("response" in query)
@@ -47145,6 +47705,7 @@ var LABEL_VALUE_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
 var SELECTION_FILTERS = ["selected", "published", "dropped", "none"];
 var ITEMS_QUERY_KEYS = new Set(["page", "source", "seen", "decision", "value", "selection", "search"]);
 var SELECTIONS_QUERY_KEYS = new Set(["page", "runId", "topic", "status", "search"]);
+var CHANNELS_QUERY_KEYS = new Set(["from", "until", "page"]);
 function invalidQuery(message) {
   return { status: 400, body: { code: "board.query.invalid", message } };
 }
@@ -47245,6 +47806,40 @@ function parseSelectionsQuery(params) {
     }
   };
 }
+function parseChannelsQuery(params) {
+  for (const key of params.keys()) {
+    if (!CHANNELS_QUERY_KEYS.has(key))
+      return { response: invalidQuery("Unknown query parameter.") };
+  }
+  for (const key of CHANNELS_QUERY_KEYS) {
+    if (params.getAll(key).length > 1)
+      return { response: invalidQuery("Duplicate query parameter.") };
+  }
+  const rawFrom = params.get("from");
+  const rawUntil = params.get("until");
+  if (rawFrom === null || rawUntil === null) {
+    return { response: invalidQuery("`from` and `until` are required.") };
+  }
+  const fromMs = parseEpochMs(rawFrom);
+  const untilMs = parseEpochMs(rawUntil);
+  if (fromMs === null || untilMs === null) {
+    return { response: invalidQuery("`from` and `until` must be nonnegative integer epoch milliseconds.") };
+  }
+  if (fromMs >= untilMs)
+    return { response: invalidQuery("`from` must be less than `until`.") };
+  const rawPage = params.get("page");
+  const page = rawPage === null ? 1 : Number(rawPage);
+  if (rawPage !== null && (!/^\d+$/.test(rawPage) || !Number.isSafeInteger(page) || page < 1)) {
+    return { response: invalidQuery("`page` must be an integer of at least 1.") };
+  }
+  return { query: { fromMs, untilMs, page } };
+}
+function parseEpochMs(raw) {
+  if (!/^\d+$/.test(raw))
+    return null;
+  const value = Number(raw);
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
 function parseQuery(params) {
   if (params.size === 0)
     return null;
@@ -47685,6 +48280,9 @@ function noContentReason(workDir, runDate, poolCount) {
   if (measured !== null && measuredEstimate !== null && durationFloor !== null && keptCount !== null) {
     return `no-content: the episode ran ${measured} min (pre-spend estimate ${measuredEstimate} min), below the ${durationFloor} min floor \u2014 duration refusal after synthesis (pool ${poolCount ?? 0}, kept ${keptCount})`;
   }
+  if (duration?.stage === "script" && measuredEstimate !== null && durationFloor !== null && keptCount !== null) {
+    return `no-content: the authored script estimates ${measuredEstimate} min of speech, below the ${durationFloor} min floor \u2014 script gate refusal before the TTS spend (pool ${poolCount ?? 0}, kept ${keptCount})`;
+  }
   const floor = readRefusal(join7(workDir, "21-plan", `${runDate}_04_quality-control-content_floor-refusal.json`));
   const estimated = num(floor?.estimatedMinutes);
   const minMinutes = num(floor?.minMinutes);
@@ -48332,6 +48930,9 @@ async function collectSourceDocs(discovery, source, timeoutMs) {
       const why = proc.timedOut === true ? `timed out after ${timeoutMs}ms` : `exited with code ${proc.exitCode}`;
       throw new Error(`Plugin '${source.plugin}' ${why}: ${proc.stderr || proc.stdout || "no output"}`);
     }
+    if (proc.stderr !== "") {
+      echoError(`[source:${source.plugin}] ${proc.stderr.trim()}`);
+    }
     if (!await fs.exists(outTmp)) {
       throw new Error(`Plugin '${source.plugin}' succeeded but did not write an output file`);
     }
@@ -49085,7 +49686,7 @@ function checkOne(record, options) {
   if (!existsSync6(record.check)) {
     return { name: record.name, kind: record.kind, status: "error", detail: "probe entry missing" };
   }
-  const timeoutMs = options.timeout !== undefined ? Number(options.timeout) : 30000;
+  const timeoutMs = options.timeout !== undefined ? Number(options.timeout) : 60000;
   const result = spawnPluginProbe({
     entryPath: record.check,
     cwd: record.dir,
@@ -49201,7 +49802,9 @@ var SCHEDULES_REL = "plugins/kk/schedules";
 var CHECKOUT_ROOT2 = resolve17(import.meta.dir, "../../../..");
 var SCHEDULE_TEMPLATES = {
   "kk-collect": { launchd: "launchd.plist.tmpl", cron: "cron.tmpl" },
-  "kk-serve": { launchd: "kk-serve.launchd.plist.tmpl" }
+  "kk-serve": { launchd: "kk-serve.launchd.plist.tmpl" },
+  "kk-daily-publish3-cn-peak": { cron: "kk-daily-publish3-cn-peak.cron.tmpl" },
+  "kk-daily-publish3-overseas": { cron: "kk-daily-publish3-overseas.cron.tmpl" }
 };
 var REPO_PLACEHOLDER = "{{repo}}";
 var HOME_PLACEHOLDER = "{{home}}";
@@ -49915,9 +50518,18 @@ var ItcPlanTargetRequestSchema = object2({
   plugin: string2().min(1),
   profile: string2().min(1).optional()
 }).strict();
+var PublishWindowSchema = _enum2(["after-generate", "cn-peak", "overseas-rss"]);
 var PublishPresetTargetSchema = object2({
   plugin: string2().min(1),
-  profile: string2().min(1).optional()
+  profile: string2().min(1).optional(),
+  id: string2().min(1).optional(),
+  operation: string2().min(1).optional(),
+  variant: string2().min(1).optional(),
+  tier: number2().int().min(0).max(3).optional(),
+  window: PublishWindowSchema.optional(),
+  mode: _enum2(["off", "dummy", "draft"]).optional(),
+  required: boolean2().optional(),
+  options: record(string2(), unknown()).optional()
 }).strict();
 var PublishPresetSchema = object2({
   schemaVersion: literal(1).default(1),
@@ -50092,6 +50704,11 @@ async function resolveItcTargets(input, fs = createNodeFileSystem()) {
     origin: "none"
   };
 }
+async function loadPublishPreset(slug, roots = {}, fs = createNodeFileSystem()) {
+  const projectRoot = roots.projectRoot ? resolve19(roots.projectRoot) : process.cwd();
+  const packageRoot = roots.packageRoot ? resolve19(roots.packageRoot) : await resolveDefaultPackageRoot(fs);
+  return resolvePresetFromRoots(fs, slug.trim(), projectRoot, packageRoot);
+}
 async function hasCoverImage(fs, workDir) {
   const dir = join17(workDir, "4-illustrations");
   if (!await fs.exists(dir))
@@ -50609,7 +51226,13 @@ var ItcReceiptSchema = object2({
   aggregatePath: string2().optional(),
   publicUrlVerified: boolean2().optional(),
   url: string2().optional(),
-  durationMs: number2().optional()
+  durationMs: number2().optional(),
+  target: string2().min(1).optional(),
+  window: string2().min(1).optional(),
+  dummy: boolean2().optional(),
+  error: string2().optional(),
+  startedAt: string2().optional(),
+  finishedAt: string2().optional()
 }).strict();
 async function findCover(fs, workDir) {
   const dir = join19(workDir, "4-illustrations");
@@ -50824,6 +51447,32 @@ async function prepareTargetPayloads(fs, workDir, plan, plugins) {
   await fs.writeFile(join19(publishDir, "publish-plan.json"), `${JSON.stringify(plan, null, 2)}
 `);
 }
+async function probePlugin(plugin, executor = new NodeProcessExecutor) {
+  if (!plugin.check)
+    return { ok: true };
+  const probe = await executor.run({
+    command: process.execPath,
+    args: [plugin.check, "check"],
+    env: pluginProcessEnv(plugin.kind, plugin.name),
+    timeout: 60000
+  });
+  if (probe.exitCode === 0)
+    return { ok: true };
+  let detail = "";
+  try {
+    const last = probe.stdout.trim().split(`
+`).filter(Boolean).at(-1) ?? "";
+    const parsed = JSON.parse(last);
+    if (parsed.detail) {
+      detail = `${parsed.status ?? "refused"}: ${parsed.detail}`;
+      for (const value of Object.values(pluginEnvFromConfig(plugin.kind, plugin.name))) {
+        if (value)
+          detail = detail.split(value).join("<redacted>");
+      }
+    }
+  } catch {}
+  return { ok: false, ...detail ? { detail } : {} };
+}
 async function itcCheckTargets(args, fs = createNodeFileSystem(), executor = new NodeProcessExecutor) {
   const [workDir = ""] = args;
   if (!workDir) {
@@ -50840,69 +51489,33 @@ async function itcCheckTargets(args, fs = createNodeFileSystem(), executor = new
   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: pluginProcessEnv(plugin.kind, plugin.name),
-        timeout: 60000
-      });
-      if (probe.exitCode !== 0) {
-        let detail = "";
-        try {
-          const last = probe.stdout.trim().split(`
-`).filter(Boolean).at(-1) ?? "";
-          const parsed = JSON.parse(last);
-          if (parsed.detail) {
-            detail = `${parsed.status ?? "refused"}: ${parsed.detail}`;
-            for (const value of Object.values(pluginEnvFromConfig(plugin.kind, plugin.name))) {
-              if (value)
-                detail = detail.split(value).join("<redacted>");
-            }
-          }
-        } catch {}
-        const botName = plugin.browserSession?.profileName ?? plugin.name;
-        echoError(detail ? `channel probe for '${target.plugin}' refused: ${detail}` : `channel probe for '${target.plugin}' refused: run \`kk bot open/login ${botName}\` to authenticate`);
-        return 1;
-      }
+    if (!plugin?.check)
+      continue;
+    const probe = await probePlugin(plugin, executor);
+    if (!probe.ok) {
+      const botName = plugin.browserSession?.profileName ?? plugin.name;
+      echoError(probe.detail ? `channel probe for '${target.plugin}' refused: ${probe.detail}` : `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 = join19(workDir, "4-publish");
-  const planPath = join19(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: ${join19(workDir, "itc-options.json")} has no parentRunId`);
-    return 1;
-  }
-  const receiptsDir = join19(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 = join19(receiptsDir, `${target.plugin}.json`);
+async function sendRows(options) {
+  const fs = options.fs ?? createNodeFileSystem();
+  const dispatch = options.dispatch ?? runFanout;
+  const { rows, publishDir, receiptsDir, parentRunId, planDigest, retry, label } = options;
+  const result = { sent: [], skipped: [], receipts: [] };
+  for (const row of rows) {
+    const startedAt = new Date().toISOString();
+    const targetReceiptPath = join19(receiptsDir, `${row.key}.json`);
     let reattempt = false;
-    if (isRetry) {
+    if (retry) {
       if (!await fs.exists(targetReceiptPath))
         continue;
       try {
         const priorReceipt = JSON.parse(await fs.readFile(targetReceiptPath));
-        if (priorReceipt.status === "succeeded" || priorReceipt.effect !== "none") {
+        if (priorReceipt.status === "succeeded" || priorReceipt.effect !== "none")
           continue;
-        }
       } catch {
         continue;
       }
@@ -50910,31 +51523,80 @@ async function itcSendTargets(args, fs = createNodeFileSystem(), dispatch = runF
     } else if (await fs.exists(targetReceiptPath)) {
       try {
         const prior = JSON.parse(await fs.readFile(targetReceiptPath));
-        if (prior.status === "succeeded")
+        const dummyOnly = prior.dummy === true && row.mode !== "dummy";
+        if (prior.status === "succeeded" && !dummyOnly)
           continue;
-        const mayAlreadyBeLive = (prior.status === "uncertain" || prior.effect === "unknown") && (target.mode === "live" || prior.mode === "live");
+        const mayAlreadyBeLive = (prior.status === "uncertain" || prior.effect === "unknown") && (row.mode === "live" || prior.mode === "live");
         if (mayAlreadyBeLive) {
-          echoError(`itc-send-targets: ${target.plugin} has an unknown-effect live receipt (may already be published) \u2014 resolve it before resending; skipped`);
+          echoError(`${label}: ${row.key} has an unknown-effect live receipt (may already be published) \u2014 resolve it before resending; skipped`);
+          result.skipped.push(row.key);
           continue;
         }
       } catch {}
       reattempt = true;
     }
-    const payloadRel = target.payloadPath ?? `4-publish/content.${target.plugin}.json`;
-    const payloadPath = join19(workDir, payloadRel);
+    let payloadPath = row.payloadPath;
+    let preparedError;
+    if (options.preparePayload) {
+      const prepared = await options.preparePayload(row);
+      if ("error" in prepared) {
+        preparedError = prepared.error;
+      } else {
+        payloadPath = prepared.payloadPath;
+      }
+    }
     const payloadRaw = await fs.exists(payloadPath) ? await fs.readFile(payloadPath) : "{}";
     const payloadDigest = createHash6("sha256").update(payloadRaw).digest("hex");
-    const outPath = join19(publishDir, `fanout-result.${target.plugin}${isRetry ? ".retry" : ""}.json`);
+    if (preparedError !== undefined) {
+      const receipt = {
+        ...row.receiptExtras ?? {},
+        schemaVersion: 1,
+        parentRunId,
+        planDigest,
+        payloadDigest,
+        plugin: row.plugin,
+        profile: row.profile,
+        mode: row.mode === "live" ? "live" : "draft",
+        attemptId: retry ? "retry-1" : "attempt-1",
+        status: "failed",
+        effect: "none",
+        publicUrlVerified: false,
+        error: preparedError
+      };
+      await fs.writeFile(targetReceiptPath, `${JSON.stringify(receipt, null, 2)}
+`);
+      result.receipts.push(receipt);
+      if (options.onReceipt)
+        await options.onReceipt(receipt);
+      continue;
+    }
+    if (row.mode === "dummy") {
+      if (options.dummyReceipt === undefined) {
+        echoError(`${label}: ${row.key} is dummy but no dummy receipt writer is configured; skipped`);
+        result.skipped.push(row.key);
+        continue;
+      }
+      const receipt = await options.dummyReceipt(row, { payloadPath, payloadDigest, startedAt });
+      await fs.writeFile(targetReceiptPath, `${JSON.stringify(receipt, null, 2)}
+`);
+      result.receipts.push(receipt);
+      if (receipt.status === "succeeded")
+        result.sent.push(row.key);
+      if (options.onReceipt)
+        await options.onReceipt(receipt);
+      continue;
+    }
+    const outPath = join19(publishDir, `fanout-result.${row.key}${retry ? ".retry" : ""}.json`);
     if (reattempt && await fs.exists(outPath))
       await fs.deleteFile(outPath);
     const fanoutArgs = [
       "--content",
       payloadPath,
       "--target",
-      target.plugin,
+      row.plugin,
       "--out",
       outPath,
-      ...target.transport === "browser" ? ["--serial-target", target.plugin] : []
+      ...row.transport === "browser" ? ["--serial-target", row.plugin] : []
     ];
     let fanoutExit = 0;
     if (!await fs.exists(outPath)) {
@@ -50948,7 +51610,7 @@ async function itcSendTargets(args, fs = createNodeFileSystem(), dispatch = runF
     if (await fs.exists(outPath)) {
       try {
         const agg = JSON.parse(await fs.readFile(outPath));
-        const found = (agg.targets ?? []).find((t) => t.target === target.plugin);
+        const found = (agg.targets ?? []).find((t) => t.target === row.plugin);
         if (found)
           outcome = found;
       } catch {
@@ -50961,37 +51623,45 @@ async function itcSendTargets(args, fs = createNodeFileSystem(), dispatch = runF
     let publicUrlVerified = false;
     if (isSuccess) {
       effect = "confirmed";
-      if (target.mode === "live" && outcome.url) {
+      if (row.mode === "live" && outcome.url) {
         publicUrlVerified = itcDelivery?.publicUrlVerified === true;
       }
     } else if (itcDelivery?.effect === "none") {
       effect = "none";
     }
     const receipt = {
+      ...row.receiptExtras ?? {},
       schemaVersion: 1,
       parentRunId,
       planDigest,
       payloadDigest,
-      plugin: target.plugin,
-      profile: target.profile,
-      mode: target.mode,
-      attemptId: isRetry ? "retry-1" : "attempt-1",
+      plugin: row.plugin,
+      profile: row.profile,
+      mode: row.mode === "live" ? "live" : "draft",
+      attemptId: retry ? "retry-1" : "attempt-1",
       status: isSuccess ? "succeeded" : effect === "unknown" ? "uncertain" : "failed",
       effect,
       publicUrlVerified,
       ...outcome.url ? { url: outcome.url } : {},
+      ...outcome.error ? { error: outcome.error } : {},
       ...outcome.durationMs !== undefined ? { durationMs: outcome.durationMs } : {},
       aggregatePath: outPath
     };
     await fs.writeFile(targetReceiptPath, `${JSON.stringify(receipt, null, 2)}
 `);
+    result.receipts.push(receipt);
+    if (receipt.status === "succeeded")
+      result.sent.push(row.key);
+    if (options.onReceipt)
+      await options.onReceipt(receipt);
   }
-  return 0;
+  return result;
 }
-async function itcReconcileReceipts(args, fs = createNodeFileSystem()) {
+async function itcSendTargets(args, fs = createNodeFileSystem(), dispatch = runFanout) {
   const [workDir = ""] = args;
+  const isRetry = args.includes("--retry");
   if (!workDir) {
-    echoError("usage: itc-reconcile-receipts <work_dir>");
+    echoError("usage: itc-send-targets <work_dir> [--retry]");
     return 1;
   }
   const publishDir = join19(workDir, "4-publish");
@@ -50999,14 +51669,57 @@ async function itcReconcileReceipts(args, fs = createNodeFileSystem()) {
   if (!await fs.exists(planPath))
     return 0;
   const plan = JSON.parse(await fs.readFile(planPath));
-  const chosenPath = join19(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,
+  if (!plan.targets || plan.targets.length === 0)
+    return 0;
+  const parentRunId = (await readOptionsSnapshot(fs, workDir))?.parentRunId;
+  if (!parentRunId) {
+    echoError(`itc-send-targets: ${join19(workDir, "itc-options.json")} has no parentRunId`);
+    return 1;
+  }
+  const receiptsDir = join19(publishDir, "receipts");
+  await fs.ensureDir(receiptsDir);
+  const planRaw = await fs.readFile(planPath);
+  const planDigest = createHash6("sha256").update(planRaw).digest("hex");
+  const rows = plan.targets.map((target) => ({
+    key: target.plugin,
+    plugin: target.plugin,
+    profile: target.profile,
+    mode: target.mode,
+    payloadPath: join19(workDir, target.payloadPath ?? `4-publish/content.${target.plugin}.json`),
+    transport: target.transport
+  }));
+  await sendRows({
+    rows,
+    publishDir,
+    receiptsDir,
+    parentRunId,
+    planDigest,
+    retry: isRetry,
+    label: "itc-send-targets",
+    fs,
+    dispatch
+  });
+  return 0;
+}
+async function itcReconcileReceipts(args, fs = createNodeFileSystem()) {
+  const [workDir = ""] = args;
+  if (!workDir) {
+    echoError("usage: itc-reconcile-receipts <work_dir>");
+    return 1;
+  }
+  const publishDir = join19(workDir, "4-publish");
+  const planPath = join19(publishDir, "publish-plan.json");
+  if (!await fs.exists(planPath))
+    return 0;
+  const plan = JSON.parse(await fs.readFile(planPath));
+  const chosenPath = join19(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
@@ -51562,6 +52275,922 @@ async function runItcPrepare(args, fs) {
   return 0;
 }
 
+// src/publish-matrix-stage.ts
+init_dist3();
+
+// src/publish-matrix.ts
+import { createHash as createHash8 } from "crypto";
+import { dirname as dirname12, join as join21, resolve as resolve21 } from "path";
+init_dist3();
+init_dist();
+init_zod();
+var BundleVariantSchema = object2({
+  path: string2().min(1),
+  sha256: string2().min(1)
+}).strict();
+var BundleSchema = object2({
+  schemaVersion: literal(1).default(1),
+  runId: string2().min(1),
+  runDate: string2().min(1),
+  parentRunId: string2().min(1).optional(),
+  runs: array(string2()).default([]),
+  episode: object2({ title: string2().min(1), guid: string2().optional() }).strict(),
+  variants: record(string2(), BundleVariantSchema)
+}).strict();
+var PublishPlanRowSchema = object2({
+  id: string2().min(1),
+  plugin: string2().min(1),
+  operation: string2().min(1).optional(),
+  variant: string2().min(1),
+  tier: number2().int().min(0).max(3),
+  window: PublishWindowSchema,
+  mode: _enum2(["dummy", "draft", "live"]),
+  required: boolean2(),
+  approval: _enum2(["none", "required"]),
+  status: literal("planned"),
+  profile: string2().min(1).optional(),
+  payloadPath: string2().min(1),
+  payloadDigest: string2().min(1)
+}).strict();
+var PublishPlanSchema = object2({
+  schemaVersion: literal(1).default(1),
+  window: PublishWindowSchema,
+  bundleRunId: string2().min(1),
+  parentRunId: string2().min(1),
+  presetName: string2().min(1),
+  presetDigest: string2().min(1),
+  rows: array(PublishPlanRowSchema)
+}).strict();
+var PublishOutcomeRowSchema = object2({
+  id: string2().min(1),
+  tier: number2().int().min(0).max(3),
+  required: boolean2(),
+  status: _enum2(["succeeded", "failed", "uncertain", "missing"]),
+  effect: _enum2(["none", "confirmed", "unknown"]).optional(),
+  dummy: boolean2()
+}).strict();
+var PublishOutcomeSchema = object2({
+  schemaVersion: literal(1).default(1),
+  window: PublishWindowSchema,
+  runDate: string2().min(1),
+  status: _enum2(["full", "partial", "none", "dummy"]),
+  published: number2().int().min(0),
+  targets: number2().int().min(0),
+  rows: array(PublishOutcomeRowSchema)
+}).strict();
+function classifyPublishMatrix(plan, receipts, runDate) {
+  const byTarget = new Map;
+  for (const receipt of receipts) {
+    const key = receipt.target ?? receipt.plugin;
+    byTarget.set(key, receipt);
+  }
+  const rows = plan.rows.map((row) => {
+    const receipt = byTarget.get(row.id);
+    return {
+      id: row.id,
+      tier: row.tier,
+      required: row.required,
+      status: receipt?.status ?? "missing",
+      ...receipt?.effect !== undefined ? { effect: receipt.effect } : {},
+      dummy: receipt?.dummy === true
+    };
+  });
+  const real = rows.filter((row) => !row.dummy);
+  const succeeded = real.filter((row) => row.status === "succeeded");
+  const status = real.length === 0 ? "dummy" : succeeded.length === real.length ? "full" : succeeded.length > 0 ? "partial" : "none";
+  return {
+    schemaVersion: 1,
+    window: plan.window,
+    runDate,
+    status,
+    published: succeeded.length,
+    targets: real.length,
+    rows
+  };
+}
+var LEGACY_RESULT_FILES = [
+  { plugin: "surfdash-pub", file: "_14_publish-surfdash_result.json" },
+  { plugin: "podcast-pub", file: "_16_publish-podcast_result.json" }
+];
+function slugify2(value) {
+  return value.trim().replace(/[\s/]+/g, "-");
+}
+function targetId(target) {
+  if (target.id)
+    return target.id;
+  if (target.operation)
+    return `${target.plugin}.${slugify2(target.operation)}`;
+  return target.plugin;
+}
+function flagValue(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1)
+    return;
+  const value = args[idx + 1];
+  return value !== undefined && !value.startsWith("--") ? value : undefined;
+}
+function listValue(args, flag) {
+  const raw = flagValue(args, flag);
+  if (raw === undefined)
+    return [];
+  return raw.split(",").map((token) => token.trim()).filter(Boolean);
+}
+async function appendEvent(fs, publishDir, event) {
+  await fs.ensureDir(publishDir);
+  const path = join21(publishDir, "publish-events.jsonl");
+  const prior = await fs.exists(path) ? await fs.readFile(path) : "";
+  await fs.writeFile(path, `${prior}${JSON.stringify({ at: new Date().toISOString(), ...event })}
+`);
+}
+var LINK_SOURCES = [
+  { placeholder: "{{article_url}}", plugin: "surfdash-pub", receipt: "article" },
+  { placeholder: "{{podcast_url}}", plugin: "podcast-pub", receipt: "podcast" }
+];
+async function readPlan(fs, workDir, window) {
+  const planPath = join21(workDir, "4-publish", `plan.${window}.json`);
+  if (!await fs.exists(planPath)) {
+    throw new Error(`no plan at ${planPath}; run publish-matrix-plan first`);
+  }
+  const parsed = PublishPlanSchema.safeParse(JSON.parse(await fs.readFile(planPath)));
+  if (!parsed.success) {
+    throw new Error(`malformed plan at ${planPath}: ${parsed.error.message}`);
+  }
+  return parsed.data;
+}
+async function composePlan(fs, input) {
+  const bundleAbs = resolve21(input.bundlePath);
+  if (!await fs.exists(bundleAbs))
+    throw new Error(`bundle not found: ${bundleAbs}`);
+  const bundleParsed = BundleSchema.safeParse(JSON.parse(await fs.readFile(bundleAbs)));
+  if (!bundleParsed.success) {
+    throw new Error(`malformed bundle at ${bundleAbs}: ${bundleParsed.error.message}`);
+  }
+  const bundle = bundleParsed.data;
+  const bundleDir = dirname12(bundleAbs);
+  const { preset, digest } = await loadPublishPreset(input.preset, { ...input.projectRoot ? { projectRoot: input.projectRoot } : {} }, fs);
+  const inWindow = preset.targets.filter((target) => (target.window ?? "after-generate") === input.window && (target.mode ?? "draft") !== "off");
+  const matches = (target, token) => target.plugin === token || target.id === token;
+  for (const token of [...input.channels, ...input.liveChannels]) {
+    if (!preset.targets.some((target) => matches(target, token))) {
+      throw new Error(`channel '${token}' is not listed in preset '${preset.name}'`);
+    }
+  }
+  for (const token of [...input.channels, ...input.liveChannels]) {
+    if (!inWindow.some((target) => matches(target, token))) {
+      throw new Error(`channel '${token}' has no target in window '${input.window}'`);
+    }
+  }
+  const selected = input.channels.length === 0 ? inWindow : inWindow.filter((target) => input.channels.some((token) => matches(target, token)));
+  const rows = [];
+  const seen = new Set;
+  for (const target of selected) {
+    const id = targetId(target);
+    if (seen.has(id))
+      throw new Error(`duplicate target id '${id}' in preset '${preset.name}'`);
+    seen.add(id);
+    const liveToken = input.liveChannels.find((token) => matches(target, token));
+    if (liveToken !== undefined && target.mode === "dummy") {
+      throw new Error(`channel '${liveToken}' is dummy-only and cannot be promoted to live`);
+    }
+    const mode = input.dummy ? "dummy" : liveToken !== undefined ? "live" : target.mode === "dummy" ? "dummy" : "draft";
+    if (target.variant === undefined) {
+      throw new Error(`target '${id}' has no variant; a publish-matrix target must name one`);
+    }
+    const entry = bundle.variants[`${target.variant}@${target.plugin}`] ?? bundle.variants[target.variant];
+    if (entry === undefined) {
+      throw new Error(`bundle has no variant '${target.variant}' for target '${id}'`);
+    }
+    const variantPath = resolve21(bundleDir, entry.path);
+    if (!await fs.exists(variantPath))
+      throw new Error(`variant file not found: ${variantPath}`);
+    const variantRaw = await fs.readFile(variantPath);
+    const actual = createHash8("sha256").update(variantRaw).digest("hex");
+    if (actual !== entry.sha256) {
+      throw new Error(`variant digest mismatch for '${target.variant}': expected ${entry.sha256}, got ${actual}`);
+    }
+    const parsedContent = ContentSchema.safeParse(JSON.parse(variantRaw));
+    if (!parsedContent.success) {
+      throw new Error(`variant '${target.variant}' is not valid Content: ${parsedContent.error.message}`);
+    }
+    const payload = {
+      ...parsedContent.data,
+      metadata: {
+        ...parsedContent.data.metadata ?? {},
+        ...target.options ?? {},
+        ...target.operation !== undefined ? { operation: target.operation } : {},
+        publishStatus: mode === "live" ? "public" : "draft"
+      }
+    };
+    const payloadRelative = `4-publish/payloads/content.${id}.json`;
+    const payloadText = `${JSON.stringify(payload, null, 2)}
+`;
+    rows.push({
+      id,
+      plugin: target.plugin,
+      ...target.operation !== undefined ? { operation: target.operation } : {},
+      variant: target.variant,
+      tier: target.tier ?? 3,
+      window: input.window,
+      mode,
+      required: target.required ?? false,
+      approval: mode === "live" ? "required" : "none",
+      status: "planned",
+      ...target.profile !== undefined ? { profile: target.profile } : {},
+      payloadPath: payloadRelative,
+      payloadDigest: createHash8("sha256").update(payloadText).digest("hex")
+    });
+    await fs.ensureDir(join21(input.workDir, "4-publish", "payloads"));
+    await fs.writeFile(join21(input.workDir, payloadRelative), payloadText);
+  }
+  return {
+    schemaVersion: 1,
+    window: input.window,
+    bundleRunId: bundle.runId,
+    parentRunId: bundle.parentRunId ?? bundle.runId,
+    presetName: preset.name,
+    presetDigest: digest,
+    rows
+  };
+}
+async function planPublishMatrix(args, deps = {}) {
+  const fs = deps.fs ?? createNodeFileSystem();
+  const [workDir = ""] = args;
+  const bundlePath = flagValue(args, "--bundle");
+  const presetFlag = flagValue(args, "--preset");
+  const windowArg = flagValue(args, "--window");
+  const channels = listValue(args, "--channels");
+  const liveChannels = listValue(args, "--live-channels");
+  const dummy = args.includes("--dummy");
+  if (!workDir || bundlePath === undefined || windowArg === undefined) {
+    echoError("usage: publish-matrix-plan <work_dir> --bundle <bundle.json> [--preset <slug>] --window <after-generate|cn-peak|overseas-rss> [--channels a,b] [--live-channels a,b] [--dummy]");
+    return 1;
+  }
+  const parsedWindow = PublishWindowSchema.safeParse(windowArg);
+  if (!parsedWindow.success) {
+    echoError(`publish-matrix-plan: unknown window '${windowArg}'`);
+    return 1;
+  }
+  if (dummy && liveChannels.length > 0) {
+    echoError("publish-matrix-plan: --dummy is a rehearsal and cannot be combined with --live-channels");
+    return 1;
+  }
+  try {
+    const preset = presetFlag ?? await readPublishPresetSelector(process.env, fs);
+    const plan = await composePlan(fs, {
+      workDir,
+      bundlePath,
+      preset,
+      window: parsedWindow.data,
+      channels,
+      liveChannels,
+      dummy,
+      ...deps.projectRoot ? { projectRoot: deps.projectRoot } : {}
+    });
+    const publishDir = join21(workDir, "4-publish");
+    await fs.ensureDir(publishDir);
+    await fs.writeFile(join21(publishDir, `plan.${plan.window}.json`), `${JSON.stringify(plan, null, 2)}
+`);
+    for (const row of plan.rows) {
+      await appendEvent(fs, publishDir, {
+        event: "planned",
+        window: plan.window,
+        id: row.id,
+        plugin: row.plugin,
+        mode: row.mode,
+        tier: row.tier
+      });
+    }
+    echo(`${plan.rows.length} target(s) planned for window ${plan.window}`);
+    return 0;
+  } catch (err) {
+    echoError(`publish-matrix-plan: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+async function checkPublishMatrix(args, deps = {}) {
+  const fs = deps.fs ?? createNodeFileSystem();
+  const [workDir = ""] = args;
+  const windowArg = flagValue(args, "--window");
+  const presetFlag = flagValue(args, "--preset");
+  const allWindows = args.includes("--all-windows");
+  const presetMode = allWindows;
+  if (!workDir || windowArg === undefined && !presetMode) {
+    echoError("usage: publish-matrix-check <work_dir> --window <after-generate|cn-peak|overseas-rss> | [--preset <slug>] --all-windows");
+    return 1;
+  }
+  const plugins = deps.plugins ?? discoverAllPlugins().plugins;
+  const byName = new Map(plugins.map((plugin) => [plugin.name, plugin]));
+  const executor = deps.executor ?? new NodeProcessExecutor;
+  const probes = [];
+  try {
+    let names;
+    let outFile;
+    let label;
+    if (presetMode) {
+      const { preset } = await loadPublishPreset(presetFlag ?? await readPublishPresetSelector(process.env, fs), { ...deps.projectRoot ? { projectRoot: deps.projectRoot } : {} }, fs);
+      const unknown = preset.targets.filter((target) => !byName.has(target.plugin));
+      if (unknown.length > 0) {
+        echoError(`publish-matrix-check: preset '${preset.name}' names uninstalled plugin(s): ${unknown.map((target) => target.plugin).join(", ")}`);
+        return 1;
+      }
+      names = [
+        ...new Set(preset.targets.filter((target) => (target.mode ?? "draft") !== "off" && target.mode !== "dummy").map((target) => target.plugin))
+      ];
+      label = "preflight";
+      outFile = "check.preflight.json";
+    } else {
+      const parsedWindow = PublishWindowSchema.safeParse(windowArg);
+      if (!parsedWindow.success) {
+        echoError(`publish-matrix-check: unknown window '${windowArg}'`);
+        return 1;
+      }
+      const plan = await readPlan(fs, workDir, parsedWindow.data);
+      names = [...new Set(plan.rows.filter((row) => row.mode !== "dummy").map((row) => row.plugin))];
+      label = plan.window;
+      outFile = `check.${plan.window}.json`;
+    }
+    for (const name of names) {
+      const plugin = byName.get(name);
+      if (plugin === undefined) {
+        probes.push({ plugin: name, ok: false, detail: "plugin not installed" });
+        echoError(`publish-matrix-check: plugin '${name}' is not installed`);
+        continue;
+      }
+      const probe = await probePlugin(plugin, executor);
+      probes.push({ plugin: name, ok: probe.ok, ...probe.detail ? { detail: probe.detail } : {} });
+      if (!probe.ok) {
+        echoError(`publish-matrix-check: channel probe for '${name}' refused: ${probe.detail ?? "unknown"}`);
+      }
+    }
+    const publishDir = join21(workDir, "4-publish");
+    await fs.ensureDir(publishDir);
+    await fs.writeFile(join21(publishDir, outFile), `${JSON.stringify({ schemaVersion: 1, window: label, plugins: probes }, null, 2)}
+`);
+    echo(names.length === 0 ? "no probes" : `${probes.length} probe(s) recorded for ${label}`);
+    return 0;
+  } catch (err) {
+    echoError(`publish-matrix-check: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+async function runPublishMatrixClassify(args, deps = {}) {
+  const fs = deps.fs ?? createNodeFileSystem();
+  const [workDir = ""] = args;
+  const windowArg = flagValue(args, "--window");
+  const runDate = flagValue(args, "--run-date");
+  if (!workDir || windowArg === undefined || runDate === undefined) {
+    echoError("usage: publish-matrix-classify <work_dir> --window <w> --run-date <stamp>");
+    return 1;
+  }
+  const parsedWindow = PublishWindowSchema.safeParse(windowArg);
+  if (!parsedWindow.success) {
+    echoError(`publish-matrix-classify: unknown window '${windowArg}'`);
+    return 1;
+  }
+  const publishDir = join21(workDir, "4-publish");
+  let plan;
+  try {
+    plan = await readPlan(fs, workDir, parsedWindow.data);
+  } catch (err) {
+    echoError(`publish-matrix-classify: ${err instanceof Error ? err.message : String(err)}`);
+    await fs.ensureDir(publishDir);
+    const none = {
+      schemaVersion: 1,
+      window: parsedWindow.data,
+      runDate,
+      status: "none",
+      published: 0,
+      targets: 0,
+      rows: []
+    };
+    await fs.writeFile(join21(publishDir, `outcome.${parsedWindow.data}.json`), `${JSON.stringify(none, null, 2)}
+`);
+    await fs.writeFile(join21(publishDir, `publish-status.${parsedWindow.data}.txt`), `none
+`);
+    await fs.writeFile(join21(workDir, "publish-classify.summary.txt"), `${JSON.stringify({ status: "none", published: 0, targets: 0 })}
+`);
+    return 0;
+  }
+  const receiptsDir = join21(publishDir, "receipts");
+  const receipts = [];
+  for (const row of plan.rows) {
+    const path = join21(receiptsDir, `${row.id}.json`);
+    if (!await fs.exists(path))
+      continue;
+    try {
+      receipts.push(JSON.parse(await fs.readFile(path)));
+    } catch {}
+  }
+  const outcome = classifyPublishMatrix(plan, receipts, runDate);
+  await fs.ensureDir(publishDir);
+  await fs.writeFile(join21(publishDir, `outcome.${outcome.window}.json`), `${JSON.stringify(outcome, null, 2)}
+`);
+  await fs.writeFile(join21(publishDir, `publish-status.${outcome.window}.txt`), `${outcome.status}
+`);
+  await fs.writeFile(join21(workDir, "publish-classify.summary.txt"), `${JSON.stringify({ status: outcome.status, published: outcome.published, targets: outcome.targets })}
+`);
+  if (outcome.window === "after-generate") {
+    const legacyDir = join21(workDir, "31-publish");
+    for (const source of LEGACY_RESULT_FILES) {
+      const row = plan.rows.find((candidate) => candidate.plugin === source.plugin && candidate.tier === 0);
+      if (row === undefined || row.mode === "dummy")
+        continue;
+      const receipt = receipts.find((candidate) => (candidate.target ?? candidate.plugin) === row.id);
+      if (receipt === undefined || receipt.dummy === true || receipt.aggregatePath === undefined)
+        continue;
+      const aggregate = receipt.aggregatePath;
+      if (!await fs.exists(aggregate))
+        continue;
+      await fs.ensureDir(legacyDir);
+      await fs.writeFile(join21(legacyDir, `${runDate}${source.file}`), await fs.readFile(aggregate));
+    }
+  }
+  echo(outcome.status);
+  return 0;
+}
+async function writeDummyReceipt(fs, row, context) {
+  const base = {
+    ...row.receiptExtras ?? {},
+    schemaVersion: 1,
+    parentRunId: context.parentRunId,
+    planDigest: context.planDigest,
+    payloadDigest: context.payloadDigest,
+    plugin: row.plugin,
+    profile: row.profile,
+    mode: "draft",
+    attemptId: "attempt-1",
+    status: "succeeded",
+    effect: "none",
+    publicUrlVerified: false,
+    dummy: true,
+    url: `dummy://${row.key}`,
+    startedAt: context.startedAt,
+    finishedAt: new Date().toISOString()
+  };
+  let invalid;
+  try {
+    const raw = await fs.readFile(context.payloadPath);
+    const parsed = ContentSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success)
+      invalid = parsed.error.message;
+  } catch (err) {
+    invalid = err instanceof Error ? err.message : String(err);
+  }
+  if (invalid === undefined)
+    return base;
+  return {
+    ...base,
+    status: "failed",
+    effect: "none",
+    error: "invalid-payload",
+    url: undefined
+  };
+}
+async function readSucceeded(fs, receiptsDir, id) {
+  const path = join21(receiptsDir, `${id}.json`);
+  if (!await fs.exists(path))
+    return false;
+  try {
+    return JSON.parse(await fs.readFile(path)).status === "succeeded";
+  } catch {
+    return false;
+  }
+}
+async function readLinkMap(fs, receiptsDir, rows) {
+  const map = {};
+  for (const source of LINK_SOURCES) {
+    const row = rows.find((candidate) => candidate.plugin === source.plugin && candidate.tier === 0);
+    if (row === undefined)
+      continue;
+    const path = join21(receiptsDir, `${row.id}.json`);
+    if (!await fs.exists(path))
+      continue;
+    try {
+      const receipt = JSON.parse(await fs.readFile(path));
+      if (receipt.status === "succeeded" && receipt.url)
+        map[source.receipt] = receipt.url;
+    } catch {}
+  }
+  return map;
+}
+async function sendPublishMatrix(args, deps = {}) {
+  const fs = deps.fs ?? createNodeFileSystem();
+  const [workDir = ""] = args;
+  const windowArg = flagValue(args, "--window");
+  const tierArg = flagValue(args, "--tier");
+  const retry = args.includes("--retry");
+  if (!workDir || windowArg === undefined) {
+    echoError("usage: publish-matrix-send <work_dir> --window <w> [--retry] [--tier <n>]");
+    return 1;
+  }
+  const parsedWindow = PublishWindowSchema.safeParse(windowArg);
+  if (!parsedWindow.success) {
+    echoError(`publish-matrix-send: unknown window '${windowArg}'`);
+    return 1;
+  }
+  let onlyTier;
+  if (tierArg !== undefined) {
+    onlyTier = Number(tierArg);
+    if (!Number.isInteger(onlyTier) || onlyTier < 0 || onlyTier > 3) {
+      echoError(`publish-matrix-send: --tier must be 0-3, got '${tierArg}'`);
+      return 1;
+    }
+  }
+  try {
+    const plan = await readPlan(fs, workDir, parsedWindow.data);
+    const publishDir = join21(workDir, "4-publish");
+    const receiptsDir = join21(publishDir, "receipts");
+    await fs.ensureDir(receiptsDir);
+    const planDigest = createHash8("sha256").update(await fs.readFile(join21(publishDir, `plan.${plan.window}.json`))).digest("hex");
+    const succeededAlready = (id) => readSucceeded(fs, receiptsDir, id);
+    const tiers = [...new Set(plan.rows.map((row) => row.tier))].sort((a, b) => a - b);
+    const pending = onlyTier === undefined ? plan.rows : plan.rows.filter((row) => row.tier === onlyTier);
+    let tierZeroBroken = false;
+    for (const tier of tiers) {
+      const rows = pending.filter((row) => row.tier === tier);
+      if (rows.length === 0)
+        continue;
+      if (tierZeroBroken) {
+        for (const row of rows) {
+          await appendEvent(fs, publishDir, {
+            event: "skipped",
+            window: plan.window,
+            id: row.id,
+            plugin: row.plugin,
+            reason: "tier-0-required-failed"
+          });
+        }
+        continue;
+      }
+      const links = tier === 0 ? {} : await readLinkMap(fs, receiptsDir, plan.rows);
+      const sendRowsInput = rows.map((row) => ({
+        key: row.id,
+        plugin: row.plugin,
+        profile: row.profile ?? "article",
+        mode: row.mode,
+        payloadPath: join21(workDir, row.payloadPath),
+        transport: "fanout",
+        receiptExtras: { target: row.id, window: plan.window }
+      }));
+      await sendRows({
+        rows: sendRowsInput,
+        publishDir,
+        receiptsDir,
+        parentRunId: plan.parentRunId,
+        planDigest,
+        retry,
+        label: "publish-matrix-send",
+        fs,
+        ...deps.dispatch ? { dispatch: deps.dispatch } : {},
+        dummyReceipt: (row, context) => writeDummyReceipt(fs, row, { ...context, parentRunId: plan.parentRunId, planDigest }),
+        preparePayload: async (row) => {
+          if (tier === 0)
+            return { payloadPath: row.payloadPath };
+          const raw = await fs.exists(row.payloadPath) ? await fs.readFile(row.payloadPath) : "";
+          let resolved = raw;
+          for (const source of LINK_SOURCES) {
+            const url = links[source.receipt];
+            if (url === undefined)
+              continue;
+            resolved = resolved.split(source.placeholder).join(url);
+          }
+          if (LINK_SOURCES.some((source) => resolved.includes(source.placeholder))) {
+            return { error: "unresolved-link" };
+          }
+          const resolvedPath = join21(workDir, "4-publish", "payloads", `content.${row.key}.resolved.json`);
+          await fs.writeFile(resolvedPath, resolved);
+          return { payloadPath: resolvedPath };
+        },
+        onReceipt: async (receipt) => {
+          await appendEvent(fs, publishDir, {
+            event: receipt.status === "succeeded" ? "sent" : "failed",
+            window: plan.window,
+            id: receipt.target ?? receipt.plugin,
+            plugin: receipt.plugin,
+            mode: receipt.mode,
+            effect: receipt.effect,
+            ...receipt.error ? { error: receipt.error } : {}
+          });
+        }
+      });
+      if (tier === 0) {
+        tierZeroBroken = false;
+        for (const row of rows) {
+          if (!row.required)
+            continue;
+          if (await succeededAlready(row.id))
+            continue;
+          tierZeroBroken = true;
+          break;
+        }
+      }
+    }
+    echo(`window ${plan.window}: ${pending.length} target(s) dispatched`);
+    return 0;
+  } catch (err) {
+    echoError(`publish-matrix-send: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+var RssGateResultSchema = object2({
+  schemaVersion: literal(1).default(1),
+  date: string2().min(1),
+  feedUrl: string2().min(1),
+  hit: boolean2(),
+  reason: _enum2(["guid", "title", "missing", "fetch-failed"]),
+  detail: string2().optional()
+}).strict();
+function feedItems(xml) {
+  const items = [];
+  for (const block of xml.matchAll(/<item>([\s\S]*?)<\/item>/g)) {
+    const body = block[1] ?? "";
+    const title = /<title>(?:<!\[CDATA\[)?([\s\S]*?)(?:\]\]>)?<\/title>/.exec(body)?.[1]?.trim() ?? "";
+    const guid = /<guid[^>]*>([\s\S]*?)<\/guid>/.exec(body)?.[1]?.trim() ?? "";
+    items.push({ title, guid });
+  }
+  return items;
+}
+function matchRssGate(items, date, guid) {
+  if (guid !== "" && items.some((item) => item.guid === guid))
+    return "guid";
+  if (items.some((item) => item.title.includes(date)))
+    return "title";
+  return "missing";
+}
+async function runPublishMatrixRssGate(args, deps = {}) {
+  const fs = deps.fs ?? createNodeFileSystem();
+  const [workDir = ""] = args;
+  const date = flagValue(args, "--date");
+  const feedUrl = flagValue(args, "--feed") ?? "https://podcast.salty.vip/rss/";
+  if (!workDir || date === undefined) {
+    echoError("usage: publish-matrix-rss-gate <work_dir> --date <YYYY-MM-DD> [--feed <url>]");
+    return 1;
+  }
+  const publishDir = join21(workDir, "4-publish");
+  let guid = "";
+  const receiptsDir = join21(publishDir, "receipts");
+  if (await fs.exists(receiptsDir)) {
+    for (const planWindow of ["after-generate", "cn-peak"]) {
+      const planPath = join21(publishDir, `plan.${planWindow}.json`);
+      if (!await fs.exists(planPath))
+        continue;
+      const plan = JSON.parse(await fs.readFile(planPath));
+      for (const row of plan.rows) {
+        if (row.plugin !== "podcast-pub")
+          continue;
+        const receiptPath = join21(receiptsDir, `${row.id}.json`);
+        if (!await fs.exists(receiptPath))
+          continue;
+        const receipt = JSON.parse(await fs.readFile(receiptPath));
+        if (typeof receipt.guid === "string")
+          guid = receipt.guid;
+      }
+    }
+  }
+  const write = async (result) => {
+    await fs.ensureDir(publishDir);
+    await fs.writeFile(join21(publishDir, "rss-gate.json"), `${JSON.stringify(result, null, 2)}
+`);
+    await appendEvent(fs, publishDir, {
+      event: result.hit ? "gate-hit" : "gate-miss",
+      window: "overseas-rss",
+      reason: result.reason,
+      date: result.date
+    });
+    if (!result.hit) {
+      const incident = {
+        schemaVersion: 1,
+        date: result.date,
+        class: "rss-lag",
+        reason: `feed ${result.feedUrl} has no episode for ${result.date} (${result.reason})`,
+        evidence: ["4-publish/rss-gate.json", ...result.detail === undefined ? [] : [result.detail]]
+      };
+      await fs.writeFile(join21(publishDir, "incident.json"), `${JSON.stringify(incident, null, 2)}
+`);
+      await fs.writeFile(join21(publishDir, "incident.md"), [
+        `# Overseas window missed \u2014 ${result.date}`,
+        "",
+        `The podcast feed \`${result.feedUrl}\` does not carry the ${result.date} episode (${result.reason}).`,
+        "Class `rss-lag`: the episode is not in the feed yet.",
+        result.detail === undefined ? "" : `Detail: ${result.detail}`,
+        "",
+        "Next: confirm the generation run published the podcast tier-0 target, then re-run the",
+        "overseas window for this date. An automatic repair only resends `effect: none` tier-0 rows."
+      ].filter((line) => line !== "").join(`
+`));
+      echoError(`publish-matrix-rss-gate: miss (${result.reason}) for ${result.date}`);
+    }
+    return result.hit ? 0 : 3;
+  };
+  let xml;
+  try {
+    const read = deps.readFeed ?? (async (url) => (await fetch(url)).text());
+    xml = await read(feedUrl);
+  } catch (err) {
+    return write({
+      schemaVersion: 1,
+      date,
+      feedUrl,
+      hit: false,
+      reason: "fetch-failed",
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+  const reason = matchRssGate(feedItems(xml), date, guid);
+  return write({ schemaVersion: 1, date, feedUrl, hit: reason !== "missing", reason });
+}
+async function runPublishMatrixWaitUntil(args, deps = {}) {
+  const [target = "", zone = ""] = args;
+  const match = /^(\d{1,2}):(\d{2})$/.exec(target);
+  if (!match || zone === "") {
+    echoError("usage: publish-matrix-wait-until <HH:MM> <Area/City>");
+    return 1;
+  }
+  const hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  if (hours > 23 || minutes > 59) {
+    echoError(`publish-matrix-wait-until: '${target}' is not a valid wall-clock time`);
+    return 1;
+  }
+  const now = deps.now ?? Date.now;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const offsetAt = (at) => {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      hour12: false,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    }).formatToParts(new Date(at));
+    const get = (type) => Number(parts.find((part) => part.type === type)?.value ?? "0");
+    const asUtc = Date.UTC(get("year"), get("month") - 1, get("day"), get("hour") % 24, get("minute"), get("second"));
+    return Math.round((asUtc - at) / 60000);
+  };
+  const wall = new Intl.DateTimeFormat("en-US", {
+    timeZone: zone,
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit"
+  }).formatToParts(new Date(now()));
+  const part = (type) => Number(wall.find((entry) => entry.type === type)?.value ?? "0");
+  const localHour = part("hour") % 24;
+  const localMinute = part("minute");
+  const already = localHour * 60 + localMinute;
+  if (already >= hours * 60 + minutes) {
+    echo(`publish-matrix-wait-until: ${zone} is already past ${target}`);
+    return 0;
+  }
+  let wait = (hours * 60 + minutes - already) * 60000;
+  const delta = offsetAt(now() + wait) - offsetAt(now());
+  wait -= delta * 60000;
+  if (wait <= 0) {
+    echo(`publish-matrix-wait-until: ${zone} is already past ${target}`);
+    return 0;
+  }
+  echo(`publish-matrix-wait-until: sleeping ${Math.round(wait / 60000)} min to ${target} ${zone}`);
+  await sleep(wait);
+  return 0;
+}
+var DEFAULT_PUBLISH_PRESET = "daily-ai-voice";
+async function readPublishPresetSelector(env = process.env, fs = createNodeFileSystem()) {
+  const configPath = resolveItcConfigPath(env, env.HOME ?? "");
+  if (!await fs.exists(configPath))
+    return DEFAULT_PUBLISH_PRESET;
+  let parsed;
+  try {
+    parsed = Bun.YAML.parse(await fs.readFile(configPath));
+  } catch {
+    throw new Error(`config file is not valid YAML: ${configPath}`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    return DEFAULT_PUBLISH_PRESET;
+  const workflows = parsed.workflows;
+  if (workflows === null || typeof workflows !== "object" || Array.isArray(workflows))
+    return DEFAULT_PUBLISH_PRESET;
+  const block = workflows["kk-daily-ai-voice3"];
+  if (block === undefined)
+    return DEFAULT_PUBLISH_PRESET;
+  if (block === null || typeof block !== "object" || Array.isArray(block)) {
+    throw new Error("config key 'workflows.kk-daily-ai-voice3' must be a mapping");
+  }
+  const settings = block;
+  for (const key of Object.keys(settings)) {
+    if (key !== "publish_preset") {
+      throw new Error(`config key 'workflows.kk-daily-ai-voice3.${key}' is not a declared setting (allowed: publish_preset)`);
+    }
+  }
+  const value = settings.publish_preset;
+  if (value === undefined)
+    return DEFAULT_PUBLISH_PRESET;
+  if (typeof value !== "string" || !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(value)) {
+    throw new Error("config key 'workflows.kk-daily-ai-voice3.publish_preset' must be a lowercase hyphenated slug");
+  }
+  return value;
+}
+async function runPublishMatrixBundle(args, deps = {}) {
+  const fs = deps.fs ?? createNodeFileSystem();
+  const [workDir = ""] = args;
+  const runDate = flagValue(args, "--run-date");
+  const parentRunId = flagValue(args, "--run-id");
+  if (!workDir || runDate === undefined || parentRunId === undefined) {
+    echoError("usage: publish-matrix-bundle <work_dir> --run-date <YYYY-MM-DD> --run-id <voice3 run id>");
+    return 1;
+  }
+  const variantsDir = join21(workDir, "30-variants");
+  if (!await fs.exists(variantsDir)) {
+    echoError(`publish-matrix-bundle: no variants at ${variantsDir}; run daily-bundle-variants first`);
+    return 1;
+  }
+  try {
+    const entries = (await fs.readDir(variantsDir)).filter((file) => file.endsWith(".content.json")).sort();
+    if (entries.length === 0)
+      throw new Error(`no *.content.json under ${variantsDir}`);
+    const variants = {};
+    for (const file of entries) {
+      const key = file.replace(/\.content\.json$/, "").replaceAll("_", ":");
+      const raw = await fs.readFile(join21(variantsDir, file));
+      const parsed = ContentSchema.safeParse(JSON.parse(raw));
+      if (!parsed.success) {
+        throw new Error(`variant '${key}' is not valid Content: ${parsed.error.message}`);
+      }
+      variants[key] = {
+        path: `30-variants/${file}`,
+        sha256: createHash8("sha256").update(raw).digest("hex")
+      };
+    }
+    const hasOwnedVariant = Object.keys(variants).some((key) => key === "article" || key === "episode");
+    if (!hasOwnedVariant) {
+      echoError("publish-matrix-bundle: no article/episode variant \u2014 the publication contract needs both");
+      return 1;
+    }
+    const articleTitle = await readVariantTitle(fs, workDir, variants);
+    const bundle = {
+      schemaVersion: 1,
+      runId: `${runDate}-${parentRunId}`,
+      runDate,
+      parentRunId,
+      runs: [],
+      episode: { title: articleTitle === "" ? `\u6BCF\u65E5AI\u4E71\u7096 \xB7 ${runDate}` : articleTitle },
+      variants
+    };
+    const validated = BundleSchema.parse(bundle);
+    const bundlePath = join21(workDir, "bundle.json");
+    if (await fs.exists(bundlePath)) {
+      try {
+        const prior = BundleSchema.parse(JSON.parse(await fs.readFile(bundlePath)));
+        if (prior.runs.length > 0)
+          validated.runs = prior.runs;
+      } catch {}
+    }
+    await fs.writeFile(bundlePath, `${JSON.stringify(validated, null, 2)}
+`);
+    echo(`bundle frozen: ${Object.keys(variants).length} variant(s) -> ${bundlePath}`);
+    return 0;
+  } catch (err) {
+    echoError(`publish-matrix-bundle: ${err instanceof Error ? err.message : String(err)}`);
+    return 1;
+  }
+}
+async function readVariantTitle(fs, workDir, variants) {
+  for (const key of ["episode", "episode@podcast-pub", "article"]) {
+    const entry = variants[key];
+    if (entry === undefined)
+      continue;
+    try {
+      const parsed = ContentSchema.parse(JSON.parse(await fs.readFile(join21(workDir, entry.path))));
+      if (parsed.title !== undefined && parsed.title.trim() !== "")
+        return parsed.title.trim();
+    } catch {}
+  }
+  return "";
+}
+
+// src/publish-matrix-stage.ts
+async function runPublishMatrixStage(args, fs = createNodeFileSystem()) {
+  const [stageName, ...rest] = args;
+  switch (stageName) {
+    case "publish-matrix-plan":
+      return planPublishMatrix(rest, { fs });
+    case "publish-matrix-check":
+      return checkPublishMatrix(rest, { fs });
+    case "publish-matrix-send":
+      return sendPublishMatrix(rest, { fs });
+    case "publish-matrix-classify":
+      return runPublishMatrixClassify(rest, { fs });
+    case "publish-matrix-bundle":
+      return runPublishMatrixBundle(rest, { fs });
+    case "publish-matrix-rss-gate":
+      return runPublishMatrixRssGate(rest, { fs });
+    case "publish-matrix-wait-until":
+      return runPublishMatrixWaitUntil(rest);
+    default:
+      return;
+  }
+}
+
 // src/commands/stage.ts
 var ROOT_GLOBALS = new Set(["-v", "--verbose"]);
 function normalizeStageArgs(argv) {
@@ -51577,10 +53206,11 @@ function normalizeStageArgs(argv) {
 }
 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-")) {
+    const stageName = args[0] ?? "";
+    if (stageName.startsWith("itc-") || stageName.startsWith("publish-matrix-")) {
       return (async () => {
-        const itcCode = await runItcStage(args);
-        const code = itcCode !== undefined ? itcCode : await runStageCancellable(args);
+        const nativeCode = stageName.startsWith("itc-") ? await runItcStage(args) : await runPublishMatrixStage(args);
+        const code = nativeCode !== undefined ? nativeCode : await runStageCancellable(args);
         if (code !== 0) {
           throw new CommanderError(code, "kk.stage.failed", `stage failed with exit code ${code}`);
         }
@@ -51596,7 +53226,7 @@ function registerStageCommand(program) {
 }
 
 // src/commands/store.ts
-import { dirname as dirname12, join as join22, resolve as resolve22 } from "path";
+import { dirname as dirname13, join as join23, resolve as resolve23 } from "path";
 init_dist3();
 init_commander();
 
@@ -51604,16 +53234,16 @@ init_commander();
 init_dist3();
 import { randomUUID as randomUUID2 } from "crypto";
 import { tmpdir as tmpdir3 } from "os";
-import { join as join21, resolve as resolve21 } from "path";
+import { join as join22, resolve as resolve22 } from "path";
 var STORE_CATALOG_PATH_REL = "plugins/kk/decisions/kk-items.yaml";
 var SPUR_CONFIG_PATH_REL = ".spur/config.yaml";
 var EVIDENCE_MAX_CHARS = 2000;
 var SUBPROCESS_FALLBACK_AFTER = 2;
 async function resolveCatalogPath(projectRoot, fs = createNodeFileSystem()) {
   const candidates = [
-    resolve21(projectRoot, STORE_CATALOG_PATH_REL),
-    resolve21(import.meta.dir, "../../..", STORE_CATALOG_PATH_REL),
-    resolve21(import.meta.dir, "..", STORE_CATALOG_PATH_REL)
+    resolve22(projectRoot, STORE_CATALOG_PATH_REL),
+    resolve22(import.meta.dir, "../../..", STORE_CATALOG_PATH_REL),
+    resolve22(import.meta.dir, "..", STORE_CATALOG_PATH_REL)
   ];
   for (const candidate of candidates) {
     if (await fs.exists(candidate))
@@ -51633,7 +53263,7 @@ async function loadInjectedHub() {
 }
 async function readDecisionRouting(projectRoot, fs = createNodeFileSystem()) {
   const catalogPath = await resolveCatalogPath(projectRoot, fs);
-  const configPath = join21(projectRoot, SPUR_CONFIG_PATH_REL);
+  const configPath = join22(projectRoot, SPUR_CONFIG_PATH_REL);
   if (!await fs.exists(configPath))
     return { catalogPath, routing: { makers: {} } };
   let parsed;
@@ -51717,8 +53347,8 @@ function createBufferedDecisionFetch(inner = fetch) {
 var bufferedDecisionFetch = createBufferedDecisionFetch();
 function runDecisionSubprocess(decisionId, input, maker, fs = createNodeFileSystem()) {
   const command = process.env.KK_SPUR_BIN ?? "spur";
-  const scratch = join21(tmpdir3(), `kk-decision-${randomUUID2()}`);
-  const evidencePath = join21(scratch, "evidence.md");
+  const scratch = join22(tmpdir3(), `kk-decision-${randomUUID2()}`);
+  const evidencePath = join22(scratch, "evidence.md");
   try {
     fs.writeFile(evidencePath, input.body);
     const args = [
@@ -51752,7 +53382,7 @@ 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 = resolve22(import.meta.dir, "../../../..");
+var CHECKOUT_ROOT3 = resolve23(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 };
@@ -51833,7 +53463,7 @@ function sourceCountsOf3(docs) {
   return counts;
 }
 async function writeNewIds(fs, path, ids) {
-  await fs.ensureDir(dirname12(path));
+  await fs.ensureDir(dirname13(path));
   await fs.writeFile(path, `${JSON.stringify([...new Set(ids)], null, 2)}
 `);
 }
@@ -51954,8 +53584,8 @@ async function readAnnotations(fs, outputPath) {
 async function heuristicAnnotations(fs, scratch, runId, items) {
   if (items.length === 0)
     return new Map;
-  const inputPath = join22(scratch, "label-input.json");
-  const outputPath = join22(scratch, "label-out.json");
+  const inputPath = join23(scratch, "label-input.json");
+  const outputPath = join23(scratch, "label-out.json");
   await fs.ensureDir(scratch);
   const docs = items.map((item) => ({
     id: item.id,
@@ -52174,7 +53804,7 @@ function parseDecisions(raw) {
   return ids;
 }
 async function readCatalogVersion(fs) {
-  const candidates = [resolve22(process.cwd(), CATALOG_PATH_REL), resolve22(CHECKOUT_ROOT3, CATALOG_PATH_REL)];
+  const candidates = [resolve23(process.cwd(), CATALOG_PATH_REL), resolve23(CHECKOUT_ROOT3, CATALOG_PATH_REL)];
   for (const path of candidates) {
     try {
       if (!await fs.exists(path))
@@ -52306,7 +53936,7 @@ async function labelAction(options) {
     const mode = parseLabelMode(options.mode);
     const configPath = resolveKkConfigPath();
     const dbPath = await resolveStorePath(configPath, options.db);
-    const scratch = join22(dirname12(plan.kind === "new-ids" ? plan.newIds : dbPath), LABEL_SCRATCH_DIR);
+    const scratch = join23(dirname13(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;
@@ -52351,8 +53981,8 @@ async function resolveProfilePath(fs, topic) {
     throw new Error(`--topic must be a lowercase slug (e.g. ai-news), got '${topic}'`);
   }
   const candidates = [
-    resolve22(process.cwd(), PROFILE_DIR_REL, `${topic}.yaml`),
-    resolve22(CHECKOUT_ROOT3, PROFILE_DIR_REL, `${topic}.yaml`)
+    resolve23(process.cwd(), PROFILE_DIR_REL, `${topic}.yaml`),
+    resolve23(CHECKOUT_ROOT3, PROFILE_DIR_REL, `${topic}.yaml`)
   ];
   for (const path of candidates) {
     if (await fs.exists(path))
@@ -52389,7 +54019,7 @@ async function extractAction(options) {
     try {
       const policy = (await readStoreConfig(resolveKkConfigPath())).labels;
       const docs = (await store.items.selectByProfile(query, policy)).map(toPoolDoc2);
-      await fs.ensureDir(dirname12(options.out));
+      await fs.ensureDir(dirname13(options.out));
       await fs.writeFile(options.out, `${JSON.stringify(docs, null, 2)}
 `);
       consoleOutput.write(JSON.stringify({ count: docs.length }));
@@ -52424,6 +54054,65 @@ async function countPoolItems(fs, path) {
     return 0;
   }
 }
+var DEFAULT_STATS_DAYS = 14;
+async function statsAction(options) {
+  try {
+    const days = Number(options.days === "" ? DEFAULT_STATS_DAYS : options.days);
+    if (!Number.isInteger(days) || days <= 0) {
+      throw new Error(`--days must be a positive integer, got '${options.days}'`);
+    }
+    const sinceMs = Date.now() - days * 86400000;
+    const dbPath = await resolveStorePath(resolveKkConfigPath(), options.db);
+    const store = await openStore({ path: dbPath });
+    try {
+      const rows = await store.collectView.channelYield(sinceMs);
+      const sources = [...new Set(rows.map((row) => row.source))].sort();
+      const byDay = new Map;
+      for (const row of rows) {
+        const entry = byDay.get(row.day) ?? new Map;
+        entry.set(row.source, (entry.get(row.source) ?? 0) + row.items);
+        byDay.set(row.day, entry);
+      }
+      const bySource = {};
+      for (const row of rows) {
+        bySource[row.source] = (bySource[row.source] ?? 0) + row.items;
+      }
+      const window = [...byDay.entries()].map(([day, counts]) => ({
+        day,
+        total: [...counts.values()].reduce((sum, n) => sum + n, 0),
+        sources: Object.fromEntries([...counts.entries()].sort(([a], [b]) => a.localeCompare(b)))
+      }));
+      if (options.json === true) {
+        consoleOutput.write(JSON.stringify({ days, byDay: window, bySource }));
+        return;
+      }
+      consoleOutput.write(renderChannelTable(window, sources, bySource));
+    } finally {
+      await store.close();
+    }
+  } catch (error) {
+    failLoud5("kk.store.stats.failed", error);
+  }
+}
+function renderChannelTable(window, sources, bySource) {
+  if (window.length === 0)
+    return "no items in the window";
+  const headers = ["day", ...sources, "total"];
+  const body = window.map((entry) => [
+    entry.day,
+    ...sources.map((source) => String(entry.sources[source] ?? 0)),
+    String(entry.total)
+  ]);
+  const footer = [
+    "TOTAL",
+    ...sources.map((source) => String(bySource[source] ?? 0)),
+    String(window.reduce((sum, entry) => sum + entry.total, 0))
+  ];
+  const widths = headers.map((header, i) => Math.max(header.length, ...body.map((row) => (row[i] ?? "").length), (footer[i] ?? "").length));
+  const line = (row) => row.map((cell, i) => i === 0 ? cell.padEnd(widths[i] ?? 0) : cell.padStart(widths[i] ?? 0)).join("  ");
+  return [line(headers), ...body.map(line), line(footer)].join(`
+`);
+}
 async function poolCountAction(options) {
   try {
     const min = Number(options.min);
@@ -52543,6 +54232,7 @@ function registerStoreCommand(program) {
   store.command("label").description("Label items as raw observations, heuristic-first; prints the {verdict, confidence, labeled, model, fallback, consults, consultMs} line, or re-label a historical pool with --replay").option("--run <id>", "Collect run id the labels belong to (required with --new-ids)").option("--new-ids <path>", "Input path listing the item ids this pass must decide").option("--replay <selector>", "Re-label a historical pool (mutually exclusive with --new-ids): 'topic:<profile>', 'run:<collect-run-id>' or 'since:<n><s|m|h|d>'; requires --maker").option("--decisions <ids>", `Comma-separated decision ids a --replay routes (default: ${CATALOG_DECISION_IDS.join(",")})`).option("--maker <name>", "Decision maker override for the catalog calls (defaults to .spur/config.yaml decisions.maker; required with --replay)").option("--mode <mode>", "Labeling mode: 'heuristic' (default) asks the model only where the keyword pass is unsure; 'decision' asks it for every item", "heuristic").option("--window <duration>", "Only items first seen within this window ('<n>s|m|h|d') for a 'topic:' replay selector", DEFAULT_EXTRACT_WINDOW).option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(labelAction);
   store.command("extract").description("Select a topic pool from the stored labels via a profile; writes Doc[] and prints {count}").requiredOption("--topic <topic>", `Topic profile name (reads ${PROFILE_DIR_REL}/<topic>.yaml)`).option("--window <duration>", "Only items first seen within this window ('<n>s|m|h|d')", DEFAULT_EXTRACT_WINDOW).option("--limit <n>", "Pool cap (default: the profile limit, else 20)").option("--include-selected", "Include items whose stories are already selected or published for --topic").requiredOption("--out <path>", "Output Doc[] JSON path (the fan-in blended.json shape)").option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(extractAction);
   store.command("pool-count").description("Guard predicate: exit 0 when the pool file holds at least --min items (prints {count, min})").argument("<file>", "Pool artifact: a Doc[] JSON file or an object carrying metadata.docs").requiredOption("--min <n>", "Minimum item count for exit 0").action((file, options) => poolCountAction({ file, min: options.min }));
+  store.command("stats").description("New-item yield per local day per source channel (read-only channel-width report)").option("--days <n>", "Trailing window in days", String(DEFAULT_STATS_DAYS)).option("--json", "Print the {days, byDay, bySource} JSON instead of the table").option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(statsAction);
   store.command("select").description("Record a run\u2019s planned set as selected stories for --topic (idempotent); prints {selected}").requiredOption("--topic <topic>", "Topic profile the selection belongs to (e.g. ai-news)").requiredOption("--workflow <name>", "Workflow that made the selection (provenance)").requiredOption("--run <id>", "Run id the selection belongs to").requiredOption("--in <path>", "Input file: a Doc[] or an object carrying metadata.docs").option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(selectAction);
   store.command("mark-published").description("Promote a run\u2019s selected rows to published; prints {published} (0 is exit 0)").requiredOption("--topic <topic>", "Topic profile the selection belongs to (e.g. ai-news)").requiredOption("--run <id>", "Run id whose selected rows are promoted").option("--in <path>", "Optional file listing the ids to promote (same shapes as select)").option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(markPublishedAction);
   store.command("release").description("Drop a run\u2019s selected rows so its items re-enter the pool; prints {released}").requiredOption("--run <id>", "Run id whose selected rows are dropped").option("--topic <topic>", "Narrow the release to one topic (default: every topic the run selected for)").option("--db <path>", "Store database path (default: kk config store.db_path, else .works/kk.db)").action(releaseAction);