@gobing-ai/knowledge-kit 0.1.4 → 0.1.6

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,95 @@ export function dailySafetyGate(args: string[]): void {
     });
 }
 
+/**
+ * `daily-preflight <workflow.yaml>…` — assert the stage runner that `kk stage` just loaded
+ * advertises every `kk stage <name>` these workflow definitions invoke.
+ *
+ * WHY (2026-10-20): the scheduler runs the CHECKOUT's workflow YAML while `kk stage` resolves the
+ * runner from the INSTALLED package (`apps/cli/src/stage.ts`). A commit that adds a stage therefore
+ * outruns the global install silently, and the mismatch only surfaces where the new stage is first
+ * reached. That day's 04:30 run died 29 minutes in at `safety` with `unknown stage:
+ * daily-safety-verdict` (present in the checkout, absent from the installed 0.1.4) and published
+ * nothing. This runs as the first command of the run's `prepare` node, so the same skew costs one
+ * cheap step and names both the missing stages and the refresh command.
+ *
+ * The known-name set is the dispatch switch of the sibling `kk-workflow-stages.ts` — the file beside
+ * this one, i.e. the copy actually in force, never a checkout-vs-install guess.
+ */
+export function dailyPreflight(args: string[]): void {
+    const files = args.filter((arg) => arg !== '');
+    timed('', 'preflight', () => {
+        if (files.length === 0) failWith(2, 'daily-preflight: pass at least one workflow YAML path');
+        const runner = join(import.meta.dir, 'kk-workflow-stages.ts');
+        if (!isFile(runner)) failWith(1, `daily-preflight.runner-missing: ${runner} is not beside this stage body`);
+        const known = new Set(
+            [...readFileSync(runner, 'utf-8').matchAll(/^\s*case '([a-z][a-z0-9-]*)':/gm)].map((match) =>
+                String(match[1]),
+            ),
+        );
+        const missing: string[] = [];
+        for (const file of files) {
+            if (!isFile(file)) failWith(1, `daily-preflight.workflow-missing: ${file}`);
+            for (const match of readFileSync(file, 'utf-8').matchAll(/\bkk stage ([a-z][a-z0-9-]*)/g)) {
+                const name = String(match[1]);
+                if (!known.has(name)) missing.push(`${name} (needed by ${basename(file)})`);
+            }
+        }
+        if (missing.length > 0) {
+            failWith(
+                1,
+                `daily-preflight.runner-stale: the installed stage runner ${runner} does not know ${missing.join(', ')} — refresh it (install the released kk package, or rsync plugins/kk/scripts/ per AGENTS.md) before the scheduled run`,
+            );
+        }
+        console.log(
+            `preflight: stage runner advertises every stage ${files.map((file) => basename(file)).join(' + ')} invokes`,
+        );
+    });
+}
+
+/**
+ * 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

@@ -159,6 +159,20 @@ async function loadDailyStages(): Promise<typeof import('./daily-stages.ts')> {
         );
     }
 }
+/**
+ * Load the audio-quality diagnostic lazily: it shells out to ffprobe/ffmpeg and is only needed when an
+ * operator asks for it, so the runner must not pay for it on every stage (and an install without
+ * ffmpeg on PATH still runs every other stage).
+ */
+async function loadAudioQuality(): Promise<typeof import('./audio-quality.ts')> {
+    try {
+        return await import('./audio-quality.ts');
+    } catch {
+        return fail(
+            'audio-quality.ts not found next to kk-workflow-stages.ts — install or refresh the kk package (bun link in a checkout)',
+        );
+    }
+}
 export const ERRNO_REASONS: Record<string, string> = {
     EACCES: 'Permission denied',
     EROFS: 'Read-only file system',
@@ -1593,6 +1607,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);
@@ -1633,6 +1652,16 @@ if (import.meta.main)
             dailyScript(rest);
             break;
         }
+        case 'audio-quality': {
+            const { runAudioQuality } = await loadAudioQuality();
+            await runAudioQuality(rest);
+            break;
+        }
+        case 'daily-preflight': {
+            const { dailyPreflight } = await loadDailyStages();
+            dailyPreflight(rest);
+            break;
+        }
         case 'daily-safety-prep': {
             const { dailySafetyPrep } = await loadDailyStages();
             dailySafetyPrep(rest);
@@ -1643,6 +1672,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

@@ -25,9 +25,15 @@ vars:
   # Voice driver switch — voxcpm (voxcpm-tts) | gemini (gemini-tts) | voicebox (voice-gen)
   # | ominivoice (omni-voice-gen). The generate tier below mirrors the fallback order, and the
   # fit/duration gates take their spoken-char rate from this var — switching drivers here is enough.
-  # 2026-10-15 production test (operator decision): voxcpm first, then gemini, then omni. voxcpm
-  # rendered that episode in 21.8 min at a measured 5.19 字/秒 (fitted at 5.2); if the audio verdict
-  # is good this is the standing order, otherwise revert this default to "gemini".
+  # 2026-10-20 (operator decision): voxcpm STAYS the primary. It is audibly echoey - a 40 ms periodic
+  # reflection on renders longer than ~30 s plus a pause floor only 16-22 dB below speech, measured by
+  # `kk stage audio-quality` on every episode's raw model output since 10-15 (cepstrum 40 ms @ 26-31 dB
+  # / pauseFloor -16..-22 dB, versus gemini's 20-25 ms @ 19-20 dB / -34..-37 dB) - and no exposed knob
+  # (cfg_value, inference_timesteps, normalize, denoise) or usable checkpoint fixes it (VoxCPM1.5:
+  # 80 ms @ 31 dB; VoxCPM-0.5B loses the lattice but measures -15.5 dB at 16 kHz). The operator keeps
+  # the local driver for its speed and cost and will monitor it episode by episode until a proper fix
+  # exists; flipping this one var to "gemini" is the escape hatch (measured dry: 20-25 ms / -34..-37 dB)
+  # at the price of a 1h47m-2h21m remote render.
   vdriver: "voxcpm"
   intro_music: ".works/kk-daily-ai-voice/AI每日资讯_8秒播客片头.mp3"
   surfdash_root: "/Users/robin/xprojects/surfdash"
@@ -113,11 +119,18 @@ nodes:
       the artifact directories and the safety revise budget. `kk ledger sync` records runs that
       already finished without a ledger row (failed ones included) — a fail-fast DAG never reaches
       its own `ledger` node, so the next run's prepare is the backfill (design §7).
+      The `daily-preflight` stage runs FIRST: the scheduler executes this checkout's YAML while
+      `kk stage` resolves its stage runner from the installed package, so a run whose YAML names a
+      stage the installed runner lacks must fail here, naming the stage, instead of 29 minutes later
+      inside the nested safety machine (2026-10-20: `unknown stage: daily-safety-verdict`, nothing
+      published).
     action:
       kind: shell
       options:
         command: >-
-          kk daily prepare --workflow kk-daily-ai-voice2 --run-date "${vars.run_date}" --ledger-sync
+          kk stage daily-preflight plugins/kk/workflows/kk-daily-ai-voice2.yaml
+          plugins/kk/workflows/kk-daily-safety.yaml
+          && kk daily prepare --workflow kk-daily-ai-voice2 --run-date "${vars.run_date}" --ledger-sync
           --run "${vars.__runId}" --definition-digest "${vars.__definitionDigest}"
           --setting window="${vars.window}" --setting language="${vars.language}" --setting vdriver="${vars.vdriver}"
           --setting skip_review="${vars.skip_review}" --setting transcode_mp3="${vars.transcode_mp3}"
@@ -181,14 +194,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: >-
@@ -545,7 +561,7 @@ nodes:
           kk stage daily-wrap-docs "${vars.work_dir}" "${vars.run_date}" "${vars.voice_profile}"
 
   - id: generate
-    description: "Voice tier, primary driver (vars.vdriver — voxcpm while the 2026-10-15 production test runs). onError: continue — the fallback siblings below are the loud chain (same pattern as 0238 R2)."
+    description: "Voice tier, primary driver (vars.vdriver — voxcpm; its 40 ms lattice is known and monitored, see the vdriver comment). onError: continue — the fallback siblings below are the loud chain (same pattern as 0238 R2)."
     # wrap-docs is a data dependency, not a sibling: daily-generate reads its _10_wrap-docs_docs.json
     # as the TTS input. Without this edge the two nodes race in the same wave (0212 dogfood finding).
     dependsOn: [script, safety, review, wrap-docs]
@@ -567,7 +583,7 @@ nodes:
   # its plugin id and the cache ignores foreign-driver sections, so a failed attempt can neither be
   # relabeled nor mix voices). Non-final siblings continue on error; the last one is loud.
   - id: generate-fallback
-    description: "Voice tier fallback 1: gemini (gemini-tts) when the primary driver left no valid Content"
+    description: "Voice tier fallback 1: gemini (gemini-tts) when the primary driver left no valid Content — the measured-dry escape hatch from voxcpm's lattice"
     dependsOn: [generate]
     condition:
       kind: shell

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: