@gobing-ai/knowledge-kit 0.1.4 → 0.1.5

package/plugins/ingestions/web-search/dist/index.js

@@ -4827,7 +4827,7 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.30/node_modules/@gobing-ai/ts-utils/dist/errors.js
+// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.32/node_modules/@gobing-ai/ts-utils/dist/errors.js
 var ErrorCode;
 var init_errors3 = __esm(() => {
   ErrorCode = {
@@ -4838,7 +4838,7 @@ var init_errors3 = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.30/node_modules/@gobing-ai/ts-utils/dist/api-response.js
+// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.32/node_modules/@gobing-ai/ts-utils/dist/api-response.js
 var API_ERROR_CODES, ERROR_CODE_TO_HTTP, CLIENT_SAFE_CODES;
 var init_api_response = __esm(() => {
   init_errors3();
@@ -4861,13 +4861,13 @@ var init_api_response = __esm(() => {
   CLIENT_SAFE_CODES = new Set([ErrorCode.NotFound, ErrorCode.Validation, ErrorCode.Conflict]);
 });
 
-// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.30/node_modules/@gobing-ai/ts-utils/dist/cursor.js
+// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.32/node_modules/@gobing-ai/ts-utils/dist/cursor.js
 var init_cursor = () => {};
 
-// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.30/node_modules/@gobing-ai/ts-utils/dist/event-severity.js
+// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.32/node_modules/@gobing-ai/ts-utils/dist/event-severity.js
 var init_event_severity = () => {};
 
-// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.30/node_modules/@gobing-ai/ts-utils/dist/output.js
+// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.32/node_modules/@gobing-ai/ts-utils/dist/output.js
 function processStream(name) {
   const proc = globalThis.process;
   const stream = proc?.[name];
@@ -4885,7 +4885,7 @@ function echoError(message, target = defaultStderrTarget ?? processStream("stder
 }
 var defaultStderrTarget;
 
-// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.30/node_modules/@gobing-ai/ts-utils/dist/index.js
+// ../../node_modules/.bun/@gobing-ai+ts-utils@0.5.32/node_modules/@gobing-ai/ts-utils/dist/index.js
 var init_dist = __esm(() => {
   init_api_response();
   init_cursor();
@@ -11883,7 +11883,7 @@ var init_dist2 = __esm(() => {
   $visitAsync = visit.visitAsync;
 });
 
-// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.30+fa3ca66e1fba4d51/node_modules/@gobing-ai/ts-runtime/dist/config.js
+// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.32+180a6e424da77181/node_modules/@gobing-ai/ts-runtime/dist/config.js
 var configSchema;
 var init_config = __esm(() => {
   init_dist2();
@@ -11907,7 +11907,7 @@ var init_config = __esm(() => {
   });
 });
 
-// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.30+fa3ca66e1fba4d51/node_modules/@gobing-ai/ts-runtime/dist/file-system-node.js
+// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.32+180a6e424da77181/node_modules/@gobing-ai/ts-runtime/dist/file-system-node.js
 import { appendFileSync, cpSync, createReadStream, createWriteStream, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
 import { dirname, resolve as resolvePath } from "path";
 function createNodeFileSystem(root, paths) {
@@ -12269,7 +12269,7 @@ var PluginManifestSchema = PluginManifestSchemaBase.superRefine((manifest, ctx)
     });
   }
 });
-// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.30+fa3ca66e1fba4d51/node_modules/@gobing-ai/ts-runtime/dist/index.js
+// ../../node_modules/.bun/@gobing-ai+ts-runtime@0.5.32+180a6e424da77181/node_modules/@gobing-ai/ts-runtime/dist/index.js
 init_file_system_node();
 init_config();
 
@@ -14400,7 +14400,7 @@ var ConfigError = class extends Error {
   }
 };
 
-// ../../node_modules/.bun/@gobing-ai+ts-infra@0.5.30+72430983864a6768/node_modules/@gobing-ai/ts-infra/dist/logger.js
+// ../../node_modules/.bun/@gobing-ai+ts-infra@0.5.32+7037256b2d91fd75/node_modules/@gobing-ai/ts-infra/dist/logger.js
 var ROOT_CATEGORY = "app";
 function toLogTapeLevel(level) {
   return level === "warn" ? "warning" : level;

package/plugins/kk/decisions/kk-podcast.yaml

@@ -0,0 +1,44 @@
+# Solo-podcast outline binding (task 0317 R7).
+#
+# The outline gate in `kk-solo-podcast` (`outline-select`) always paused. Under an auto profile the
+# pipeline now asks this catalog decision over the written option files first and only pauses when
+# the decision cannot answer confidently — the same pattern `kk-itc` uses for its outline slot
+# (`plugins/kk/workflows/kk-itc-author.yaml` → `outline-autopick` → `itc-decision`).
+#
+# The fallback is a declared label because the catalog format requires one, but the workflow never
+# treats a fallback as a pick: its projection reads `degraded` and defers to the operator gate when
+# the answer did not come from a maker.
+#
+# Resolution: registered through `decisions.paths` in `.spur/config.yaml`
+# (project-relative `plugins/kk/decisions`).
+$schema: "@gobing-ai/spur/schemas/decision-catalog.schema.json"
+version: 1
+
+defaults:
+    # A low-confidence answer still names a slot; the workflow's own `degraded` check is what decides
+    # whether the answer is usable, so folding it into the fallback would lose the distinction.
+    minConfidence: 0
+
+decisions:
+    kk-podcast-outline:
+        type: choice
+        description: >-
+            Which written outline option should this episode follow, given the briefing and the
+            option files as evidence?
+        parameters:
+            briefing:
+                type: string
+                description: >-
+                    The briefing summary the options were written from (thesis, listener takeaways,
+                    audience, target spoken duration, tone).
+        criteria:
+            a: >-
+                The narrative / storytelling arc — the option that leads with a story or a single
+                thread and earns its conclusion.
+            b: >-
+                The analytical / explainer breakdown — the option that decomposes the topic into
+                ordered mechanics a listener can follow.
+            c: >-
+                The third written alternative, when the option files include one; never chosen when
+                no `outline-option-c.md` exists.
+        fallback: a

package/plugins/kk/decisions/kk-safety.yaml

@@ -0,0 +1,46 @@
+# Publish-verdict decision for the daily content-safety gate (task 0317 R6).
+#
+# `kk-daily-safety` used to read the judge's self-reported `confidence` field in a shell `jq`
+# filter on the accept edge. The verdict is now a catalog decision over the SAME artifacts as
+# evidence, so the outcome is calibrated, ledgered (`decision_logs`) and carries a declared
+# fallback. The fallback is `escalate`, never `pass`: a missing, unreadable or garbled report has
+# to land on a recorded human decision, not on a silent publish.
+#
+# Resolution: registered through `decisions.paths` in `.spur/config.yaml`
+# (project-relative `plugins/kk/decisions`). No maker is named here on purpose — the project
+# (`decisions.makers` / `decisions.maker`) decides which backend answers, and spur degrades to this
+# catalog's fallback when no maker is configured or available.
+$schema: "@gobing-ai/spur/schemas/decision-catalog.schema.json"
+version: 1
+
+defaults:
+    # The gate's own review already screened the drafts; this decision only files the publish
+    # verdict, so a low-confidence model answer keeps its own value (an explicit pass/escalate/
+    # exclude) instead of being folded into the fallback.
+    minConfidence: 0
+
+decisions:
+    kk-safety-verdict:
+        type: choice
+        description: >-
+            Final publish verdict for the reviewed article + VoiceScript pair, from the
+            content-safety report and the content-judge verdict as evidence.
+        parameters:
+            report:
+                type: string
+                description: >-
+                    Summary of the safety report and the judge verdict the gate consumed (per-platform
+                    decisions, judge findings, and the gate's own pass/escalate/exclude/revise/block
+                    classification).
+        criteria:
+            pass: >-
+                Every platform decision is OK and the judge verdict is PASS on unchanged drafts — the
+                pair is publishable as it stands.
+            escalate: >-
+                Admitted only through a recorded human decision, or the evidence is missing, garbled or
+                contradicts itself. The safe landing for anything the evidence cannot settle.
+            exclude: >-
+                Publishable but not on every target — admission-only findings (per-platform rules,
+                formal fits) mean named platforms are dropped while the remaining targets publish at
+                recorded risk.
+        fallback: escalate

package/plugins/kk/plugin.json

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

package/plugins/kk/scripts/daily-stages.ts

@@ -60,6 +60,7 @@ import {
     readFileSync,
     renameSync,
     rmSync,
+    statSync,
     unlinkSync,
     writeFileSync,
 } from 'node:fs';
@@ -284,6 +285,79 @@ function applyFloorGate(
     );
 }
 
+/** Widest window the extract ladder may reach; a "daily" show must not import a week-old story. */
+const LADDER_MAX_MS = 72 * 3_600_000;
+
+const WINDOW_UNIT_MS: Record<string, number> = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+
+/** `'24h'` → milliseconds, mirroring `kk store extract --window`'s grammar. null when unparsable. */
+function parseWindowMs(window: string): number | null {
+    const match = /^(\d+)([smhd])$/.exec(window.trim());
+    if (match === null) return null;
+    const unit = WINDOW_UNIT_MS[match[2] as string];
+    const ms = Number(match[1]) * (unit ?? 0);
+    return ms > 0 ? ms : null;
+}
+
+/** Milliseconds → the hour form the store CLI takes. Whole hours only: every ladder step is ×2/×3. */
+function formatWindowMs(ms: number): string {
+    return `${Math.max(1, Math.round(ms / 3_600_000))}h`;
+}
+
+/**
+ * Pool extraction with a conditional window ladder (2026-10-19 operator decision, superseding the
+ * 0266 D1 blanket rejection). `kk store extract` reads one first_seen window and `applyFloorGate`
+ * then refuses a pool that cannot reach `episode_min_minutes`. Together they ate whole days: an
+ * episode consumes 6-12 stories while a day of collection adds ~3-13 qualifying ones, so the 04:30
+ * runs of 2026-10-18 and 2026-10-19 saw 2- and 3-item pools and closed as no-content while older
+ * unselected items sat in the store. The ladder keeps the configured window as the first choice and
+ * widens (×2, ×3, capped at 72h) ONLY when that pool's estimate misses the floor — a rich day is
+ * extracted exactly once, and a thin one is filled from the backlog instead of dropped.
+ *
+ * The store's `selections` ledger still excludes every story a previous run took, so a widened
+ * window can only add items no episode has used. The estimate here runs on the raw pool (before QC
+ * and dedup), so it is an upper bound: the ladder can stop one step early, never one late.
+ */
+export function dailyExtract(args: string[]): void {
+    const [workDir = '', topic = '', window = '', minMinutes = '', vdriver = ''] = args;
+    if (!workDir) fail('missing work_dir');
+    if (!topic) fail('missing topic');
+    const poolPath = join(workDir, '10-collect', 'pool.json');
+    const base = parseWindowMs(window === '' ? '24h' : window);
+    if (base === null) fail(`extract: invalid window: ${window || '(empty)'}`);
+    const floor = Number(minMinutes);
+    const gated = minMinutes !== '' && Number.isFinite(floor) && floor > 0;
+    const windows: number[] = [base];
+    for (const factor of gated ? [2, 3] : []) {
+        const ms = base * factor;
+        if (ms > LADDER_MAX_MS) break;
+        windows.push(ms);
+    }
+    timed(workDir, 'extract', () => {
+        mkdirSync(join(workDir, '10-collect'), { recursive: true });
+        let chosen: { window: string; docs: unknown[] } | null = null;
+        for (const ms of windows) {
+            const label = formatWindowMs(ms);
+            const attempt = join(workDir, '10-collect', `.pool-${label}.json`);
+            kk(['store', 'extract', '--topic', topic, '--window', label, '--out', attempt]);
+            const parsed = readJson(attempt);
+            const docs = Array.isArray(parsed) ? (parsed as unknown[]) : [];
+            const estimate = estimateSpokenMinutes(docs, vdriver);
+            chosen = { window: label, docs };
+            const verdict = gated
+                ? `estimated ${estimate.minutes} min — ${estimate.seconds >= floor * 60 ? 'clears' : 'below'} the ${floor} min floor`
+                : 'floor gate off';
+            console.error(`extract: ${label} pool ${docs.length} item(s), ${verdict}`);
+            if (!gated || estimate.seconds >= floor * 60) break;
+            rmSync(attempt, { force: true });
+        }
+        const picked = chosen ?? { window: formatWindowMs(base), docs: [] as unknown[] };
+        sted('write', poolPath, () => writeJsonText(poolPath, picked.docs));
+        for (const ms of windows)
+            rmSync(join(workDir, '10-collect', `.pool-${formatWindowMs(ms)}.json`), { force: true });
+    });
+}
+
 export function dailyArticle(args: string[]): void {
     const [workDir = '', runDate = '', pluginsPath = ''] = args;
     const articleMd = join(workDir, '22-article', `${runDate}_06_article_article.md`);
@@ -1907,6 +1981,49 @@ export function dailySafetyGate(args: string[]): void {
     });
 }
 
+/**
+ * Task 0317 R6 — fold the gate's own classification, its stamp and the `kk-safety-verdict` catalog
+ * decision into ONE accept/refuse token the `judge -> clean` guard reads as a single predicate
+ * (ADR-115 caps that guard at 5 logical commands, so the logic lives here).
+ *
+ * The gate stays authoritative on `block`/`revise`; the decision can only refuse an outcome the gate
+ * already admitted. The decision replaced the judge's self-reported `confidence` field, which the
+ * accept guard used to re-parse in shell: its fallback is `escalate`, so missing or garbled evidence
+ * lands on a recorded human decision instead of a silent publish.
+ *
+ * Writes `24-script/<date>_09_safety-verdict.status` = `accept`, or `refuse` after naming the
+ * offending value on stderr. Never exits non-zero: routing belongs to the transitions.
+ */
+export function dailySafetyVerdict(args: string[]): void {
+    const [workDir = '', runDate = ''] = args;
+    const statusFile = safetyPath(workDir, runDate, 'safety-judge_status.txt');
+    const stampFile = safetyPath(workDir, runDate, 'safety-judge_stamp.json');
+    const decisionFile = safetyPath(workDir, runDate, 'safety-verdict.decision');
+    const token = safetyPath(workDir, runDate, 'safety-verdict.status');
+    const ADMITTED = new Set(['pass', 'escalate', 'exclude']);
+    timed(workDir, 'safety-verdict-check', () => {
+        const status = isFile(statusFile) ? readFileSync(statusFile, 'utf-8').trim() : '';
+        const stamp = isFile(stampFile) ? statSync(stampFile).size : 0;
+        // A missing/unreadable decision row is a refusal, never an approval: `onError: continue` on
+        // the decide action is what can leave it absent.
+        let verdict = '';
+        if (isFile(decisionFile)) {
+            const row = JSON.parse(readFileSync(decisionFile, 'utf-8')) as { value?: unknown };
+            verdict = String(row.value ?? '');
+        }
+        let refusal = '';
+        if (!ADMITTED.has(status)) {
+            refusal = `kk-daily-safety.judge.verdict-refused: gate status [${status}] is not an admitted outcome, so these drafts must not publish`;
+        } else if (stamp === 0) {
+            refusal = `kk-daily-safety.judge.verdict-refused: gate stamp missing for status ${status}, so these drafts must not publish`;
+        } else if (!ADMITTED.has(verdict)) {
+            refusal = `kk-daily-safety.judge.decision-refused: kk-safety-verdict [${verdict}] must admit pass|escalate|exclude, so these drafts must not publish`;
+        }
+        if (refusal !== '') console.error(refusal);
+        sted('write', token, () => writeRaw(token, refusal === '' ? 'accept' : 'refuse'));
+    });
+}
+
 /**
  * Post-remediation bookkeeping for the `safety-revise` state: the agent edited the drafts, this
  * stage checks they are still the artifacts the rest of the pipeline consumes and spends one unit

package/plugins/kk/scripts/kk-workflow-stages.ts

@@ -1593,6 +1593,11 @@ if (import.meta.main)
         case 'collect-prepare':
             collectPrepare(rest);
             break;
+        case 'daily-extract': {
+            const { dailyExtract } = await loadDailyStages();
+            dailyExtract(rest);
+            break;
+        }
         case 'daily-plan': {
             const { dailyPlan } = await loadDailyStages();
             dailyPlan(rest);
@@ -1643,6 +1648,11 @@ if (import.meta.main)
             dailySafetyGate(rest);
             break;
         }
+        case 'daily-safety-verdict': {
+            const { dailySafetyVerdict } = await loadDailyStages();
+            dailySafetyVerdict(rest);
+            break;
+        }
         case 'daily-safety-revise': {
             const { dailySafetyRevise } = await loadDailyStages();
             dailySafetyRevise(rest);

package/plugins/kk/workflows/kk-daily-ai-voice2.yaml

@@ -181,14 +181,17 @@ nodes:
       kk-collect wrote, minus every story already selected or published for the ai-news topic (the
       store's `selections` ledger, written by the `select` node below). Writes
       <work_dir>/10-collect/pool.json (the fan-in blended.json shape) and prints {count}. An empty
-      pool writes [] and exits 0 — the run's no-content path, not a failure.
+      pool writes [] and exits 0 — the run's no-content path, not a failure. The `daily-extract`
+      stage widens the window (×2, ×3, capped at 72h) only when the configured window's pool cannot
+      reach `episode_min_minutes` (2026-10-19): a published episode consumes more stories than a day
+      of collection supplies, so the tight window alone closed 2026-10-18/19 as no-content while
+      older unselected items sat in the store.
     dependsOn: [read-run-date]
     action:
       kind: shell
       options:
         command: >-
-          kk store extract --topic ai-news --window "${vars.window}"
-          --out "${vars.work_dir}/10-collect/pool.json"
+          kk stage daily-extract "${vars.work_dir}" ai-news "${vars.window}" "${vars.episode_min_minutes}" "${vars.vdriver}"
 
   - id: plan
     description: >-

package/plugins/kk/workflows/kk-daily-safety.yaml

@@ -93,6 +93,31 @@ states:
         options:
           command: >-
             kk stage daily-safety-gate "${vars.work_dir}" "${vars.run_date}" "${vars.safety_max_revise}"
+      # 0317 R6: the publish verdict is a catalog DECISION over the same artifacts the gate read,
+      # not the judge's self-reported `confidence` re-parsed in a shell jq filter. `onError:
+      # continue` keeps a catalog/maker problem from aborting the machine — the accept guard below
+      # then refuses an absent row, which is the fail-closed direction.
+      - kind: decide
+        onError: continue
+        options:
+          id: safety-verdict
+          decision: kk-safety-verdict
+          params:
+            report: >-
+              Safety report ${vars.work_dir}/24-script/${vars.run_date}_09_safety-review_report.json,
+              judge verdict ${vars.work_dir}/24-script/${vars.run_date}_09_safety-judge_verdict.json,
+              and the gate's own classification in
+              ${vars.work_dir}/24-script/${vars.run_date}_09_safety-judge_status.txt.
+          evidence:
+            - ${vars.work_dir}/24-script/${vars.run_date}_09_safety-review_report.json
+            - ${vars.work_dir}/24-script/${vars.run_date}_09_safety-judge_verdict.json
+            - ${vars.work_dir}/24-script/${vars.run_date}_09_safety-judge_status.txt
+          resultFile: ${vars.work_dir}/24-script/${vars.run_date}_09_safety-verdict.decision
+      # Fold gate status + stamp + decision into the single accept token the accept guard reads.
+      - kind: shell
+        options:
+          command: >-
+            kk stage daily-safety-verdict "${vars.work_dir}" "${vars.run_date}"
       - kind: file.read.into-var
         options:
           path: ${vars.work_dir}/24-script/${vars.run_date}_09_safety-judge_status.txt
@@ -139,20 +164,22 @@ transitions:
   - from: judge
     to: clean
     description: >-
-      An admitted outcome: an explicit PASS (confidence HIGH|MEDIUM|LOW) with a stamp, or a
-      NEEDS_REVISION the gate has already classified `exclude` after the revise budget (admission-only
-      residue publishes at recorded risk — 2026-10-08). The gate writes safety-judge_stamp.json for
-      exactly pass|escalate|exclude. The verdict read is the same confidence-aware jq filter the itc/example judges
-      use (byte-identical, so the one contract cannot drift): a `verdict: PASS` whose `confidence`
-      is missing or outside HIGH|MEDIUM|LOW reads as `PASS!`, which this accept guard never matches,
-      and the refusal names the offending value on stderr first. The gate already blocks such a
-      verdict, so this guard is the belt-and-braces admission check on the accept edge, and it can
-      never strand the run: the unconditional `judge -> block` below always matches.
+      An admitted outcome: the gate classified the run pass|escalate|exclude and wrote its stamp,
+      AND the `kk-safety-verdict` decision (task 0317 R6) admits the same pair. The decision replaced
+      the judge's self-reported `confidence` re-parsed in a shell jq filter: it reads the report, the
+      verdict and the gate status as evidence and declares `escalate` as its fallback, so a missing
+      or garbled evidence set lands on a recorded human decision instead of a silent publish. The
+      gate stays authoritative on `block`/`revise`, which is why the status check is not redundant:
+      a decision cannot overrule the gate. An absent or out-of-vocabulary decision row refuses the
+      edge (fail-closed), and the unconditional `judge -> block` below always matches, so the loop
+      can never strand.
     guard:
       kind: shell
       options:
+        # One predicate over one result file (ADR-115): the three tokens are folded by
+        # `kk stage daily-safety-verdict`, which names any refusal on stderr.
         command: >-
-          jq -n -e --arg v "$(jq -r 'if (.verdict // "") == "PASS" then (.verdict + (if ((.confidence // "") | test("^(HIGH|MEDIUM|LOW)$")) then "" else "!" end)) else (.verdict // "") end' "${vars.work_dir}/24-script/${vars.run_date}_09_safety-judge_verdict.json" 2>/dev/null)" --arg s "$(jq -r '.status // ""' "${vars.work_dir}/24-script/${vars.run_date}_09_safety-judge_stamp.json" 2>/dev/null)" --arg bytes "$(wc -c < "${vars.work_dir}/24-script/${vars.run_date}_09_safety-judge_stamp.json" 2>/dev/null)" 'if (($v == "PASS" or ($v == "NEEDS_REVISION" and $s == "exclude")) and (($bytes | gsub("[^0-9]"; "") | tonumber? // 0) > 0)) then true else ("kk-daily-safety.judge.confidence-refused: verdict " + $v + " — a judge PASS is only usable with confidence HIGH|MEDIUM|LOW, so these drafts must not publish" | halt_error(1)) end' >/dev/null
+          test "$(cat "${vars.work_dir}/24-script/${vars.run_date}_09_safety-verdict.status" 2>/dev/null)" = accept
 
   - from: judge
     to: revise

package/plugins/kk/workflows/kk-solo-podcast.yaml

@@ -18,6 +18,9 @@ vars:
   work_dir: ""
   force: "false"
   outline: ""
+  # Auto profile (0317 R7): bind the outline from the option evidence instead of pausing, and fall
+  # back to the operator gate whenever the decision is not confident.
+  auto: "false"
   script_approved: ""
   target_duration_min: "8"
   words_per_min: "150"
@@ -102,6 +105,43 @@ states:
           decision:
             mode: never
 
+  - id: outline-autopick
+    description: "Auto profile — bind the outline from the written options; defer to the operator gate on low confidence (0317 R7)"
+    onEnter:
+      # ONE evidence file: option c is optional, and a missing `--evidence` path fails the decide action.
+      - kind: shell
+        options:
+          command: >-
+            mkdir -p "${vars.work_dir}/2-outline"; ev="${vars.work_dir}/2-outline/.outline-evidence.md"; : > "$ev";
+            for s in a b c; do f="${vars.work_dir}/2-outline/outline-option-$s.md"; if [ -f "$f" ]; then printf '## option %s\n%s\n' "$s" "$(cat "$f")" >> "$ev"; fi; done;
+            exit 0
+      - kind: decide
+        onError: continue
+        options:
+          id: podcast-outline
+          decision: kk-podcast-outline
+          params:
+            briefing: >-
+              Episode briefing at ${vars.work_dir}/1-briefing-briefing.md; target spoken duration
+              ${vars.target_duration_min} minutes; language ${vars.language}.
+          evidence:
+            - ${vars.work_dir}/2-outline/.outline-evidence.md
+          resultFile: ${vars.work_dir}/2-outline/.outline-decision.json
+      # Project the row into the ONE token `outline-commit` reads. A degraded (fallback) row is not a
+      # pick — the same rule the kk-itc outline slot uses — so the operator gate still decides.
+      - kind: shell
+        options:
+          command: >-
+            pick="${vars.work_dir}/2-outline/.auto-pick"; : > "$pick";
+            if ! jq -e '.degraded == false' "${vars.work_dir}/2-outline/.outline-decision.json" >/dev/null 2>&1; then exit 0; fi;
+            v="$(jq -r '.value // ""' "${vars.work_dir}/2-outline/.outline-decision.json")";
+            if [ -f "${vars.work_dir}/2-outline/outline-option-$v.md" ]; then printf '%s\n' "$v" > "$pick"; fi;
+            exit 0
+      - kind: file.read.into-var
+        options:
+          path: ${vars.work_dir}/2-outline/.auto-pick
+          var: outline
+
   - id: outline-commit
     description: "Copy selected outline to outline-approved.md"
     onEnter:
@@ -239,8 +279,32 @@ transitions:
       kind: always
 
   - from: outline-write
+    to: outline-autopick
+    description: "Auto profile, no pre-selected outline -> bind the outline from the option evidence"
+    guard:
+      kind: shell
+      options:
+        command: 'test -z "${vars.outline}" && test "${vars.auto}" = "true"'
+
+  - from: outline-write
+    to: outline-select
+    description: "Interactive profile, no pre-selected outline -> pause for operator selection"
+    guard:
+      kind: shell
+      options:
+        command: 'test -z "${vars.outline}" && test "${vars.auto}" != "true"'
+
+  - from: outline-autopick
+    to: outline-commit
+    description: "Decision bound a confident option -> commit it"
+    guard:
+      kind: shell
+      options:
+        command: 'test -n "${vars.outline}"'
+
+  - from: outline-autopick
     to: outline-select
-    description: "Outline not pre-selected -> pause for operator selection"
+    description: "Decision deferred (fallback or unconfident) -> pause for operator selection"
     guard:
       kind: shell
       options: