@gobing-ai/knowledge-kit 0.1.5 → 0.1.6

package/.claude-plugin/marketplace.json

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

package/dist/index.js

@@ -51661,7 +51661,8 @@ async function createItemDecisionAsker(options = {}) {
   const injected = options.hub ?? await loadInjectedHub();
   const fallback = options.fallback ?? (injected === undefined ? (decisionId, input, maker) => runDecisionSubprocess(decisionId, input, maker, fs) : undefined);
   const hub = injected ?? await (await import("@gobing-ai/ts-ai-decision")).createDecisionHub({
-    catalogs: [catalogPath]
+    catalogs: [catalogPath],
+    builtins: { makerOptions: { fetch: bufferedDecisionFetch } }
   });
   const backendFailures = new Map;
   return {
@@ -51696,6 +51697,24 @@ async function createItemDecisionAsker(options = {}) {
     }
   };
 }
+function createBufferedDecisionFetch(inner = fetch) {
+  return async (input, init) => {
+    const response = await inner(input, init);
+    const text = await response.text();
+    const buffered = {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      body: null,
+      text: async () => text,
+      json: async () => JSON.parse(text),
+      clone: () => buffered
+    };
+    return buffered;
+  };
+}
+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()}`);

package/package.json

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

package/plugins/generations/daily-article-gen/dist/index.js

@@ -12399,12 +12399,14 @@ ${items}
 `;
 }
 var AI_NEWS_TAG = "ai-news";
+var AI_DAILY_SUB_CATEGORY_TAG = "sub-category:ai-daily";
 function tagsFor(docs) {
   const existing = docs.flatMap((d) => {
     const meta = d.metadata;
     return Array.isArray(meta?.tags) ? meta.tags.filter((t) => typeof t === "string") : [];
   });
-  return [AI_NEWS_TAG, ...existing.filter((t) => t !== AI_NEWS_TAG)];
+  const mandatory = [AI_NEWS_TAG, AI_DAILY_SUB_CATEGORY_TAG];
+  return [...new Set([...mandatory, ...existing.filter((t) => !mandatory.includes(t))])];
 }
 var LEADING_H1_RE = /^#(?!#)\s*[^\n]+\n+/.source;
 var NOTE_EXCLUDED_RE = /\u672A\u5199\u5165[\uFF1A:](.*)/g;

package/plugins/generations/daily-article-gen/src/index.ts

@@ -122,16 +122,18 @@ export function renderDailyArticle(docs: Doc[], date: string): string {
     return `# ${episodeTitle(date)}\n\n${intro}\n\n${items}\n`;
 }
 
-/** Single-source daily tag: stamped on every Content this generator emits (task 0119). */
+/** Single-source daily tags: stamped on every Content this generator emits (task 0119 + sub-category series tag). */
 const AI_NEWS_TAG = 'ai-news';
+const AI_DAILY_SUB_CATEGORY_TAG = 'sub-category:ai-daily';
 
-/** Merge existing item tags (deduped) with the mandatory `ai-news` tag, first position. */
+/** Merge existing item tags (deduped) with the mandatory `ai-news` and `sub-category:ai-daily` tags, leading positions. */
 function tagsFor(docs: Doc[]): string[] {
     const existing = docs.flatMap((d) => {
         const meta = d.metadata as Record<string, unknown> | undefined;
         return Array.isArray(meta?.tags) ? meta.tags.filter((t): t is string => typeof t === 'string') : [];
     });
-    return [AI_NEWS_TAG, ...existing.filter((t) => t !== AI_NEWS_TAG)];
+    const mandatory = [AI_NEWS_TAG, AI_DAILY_SUB_CATEGORY_TAG];
+    return [...new Set([...mandatory, ...existing.filter((t) => !mandatory.includes(t))])];
 }
 
 /** A leading H1 line — agent bodies used to carry their own title; the canonical title is computed (task 0189 R4). */

package/plugins/generations/voxcpm-tts/README.md

@@ -79,6 +79,24 @@ that evidence belongs to task 0258.
 > Grade any render with `scripts/audit-speaker-consistency.py` (needs this plugin's venv):
 > a per-item F0 spread over 45 Hz means the profile is not anchoring a speaker.
 
+### Known artifact: a 40 ms echo lattice on long renders (2026-10-20)
+
+A `reference`-anchored profile renders short text clean and long text with a 40 ms (≈25 Hz) periodic
+reflection plus a pause floor only 16–22 dB below speech — heard as 「回声感、瓮声瓮气」. Measured on the
+raw model output (no ffmpeg join, no mp3): `kk stage audio-quality` reports `cepstrum 40 ms @ 27–31 dB`
+for renders >30 s, `pause floor −16…−22 dB`, while a 10 s render of the same profile/text measures
+`22 ms @ 19 dB / −22.5 dB` and the same days' `gemini-tts` episodes measure `20–25 ms @ 19–20 dB /
+−34…−37 dB`. `inference_timesteps`, `cfg_value` and `normalize` do not move it (measured 2026-10-20).
+
+```bash
+# reproducible in ~2.5 min, no episode needed:
+plugins/generations/voxcpm-tts/.venv/bin/python \
+  plugins/generations/voxcpm-tts/scripts/probe-long-render.py --out /tmp/voxcpm-probe
+kk stage audio-quality /tmp/voxcpm-probe/long-baseline.wav
+```
+
+Treat a driver/profile change as unproven until a LONG render is measured, not a single sentence.
+
 ## Control policy
 
 `normalize` maps directly; an explicit `seed` calls `torch.manual_seed` before synthesis (the
@@ -90,3 +108,16 @@ one for every segment, derived from its `emotion`, and the anchored clip already
 A per-request `engine`,
 `personality=true` or an active `effects_chain` is rejected. Speed stays in shared postprocessing.
 Transcription is omitted, so ASR-dependent QC is reported unavailable (not passing evidence).
+
+#### API/library claim sources and confidence
+
+The externally changeable claims this file makes about the installed `voxcpm` package, each with the
+artifact it was read from. This block is enforced by `structure/api-library-claim-citation` (the file
+is in that rule's `--require-block` registry), so a HIGH claim without a citation fails the gate.
+
+| Claim | Source | Local verification | Confidence |
+| --- | --- | --- | --- |
+| `reference_wav_path` is accepted only by VoxCPM2 checkpoints; any other model id refuses it, so a `reference` profile is VoxCPM2-only while older checkpoints clone through `prompt_wav_path` + `prompt_text` | installed `voxcpm` package | `plugins/generations/voxcpm-tts/.venv/lib/python3.12/site-packages/voxcpm/core.py:239` (`ValueError("reference_wav_path is only supported with VoxCPM2 models")`); reproduced with `scripts/probe-long-render.py --model openbmb/VoxCPM1.5` | HIGH |
+| `generate()`/`_generate()` exposes `cfg_value` (default 2.0), `inference_timesteps` (10), `normalize`, `denoise` and `max_len`, and this plugin passes none of them — the profile and text are the only inputs it sets | installed `voxcpm` package plus this plugin's worker | `…/site-packages/voxcpm/core.py:180`–`:193` (signature and defaults) and `python/worker.py:252`–`:262` (the three `generate(...)` call shapes) | HIGH |
+| `VOXCPM_MODEL` defaults to `openbmb/VoxCPM2`, the model self-reports its output rate, and that rate is what the WAV header carries (no resampling in this plugin) | this plugin's worker | `python/worker.py:181` (`environ.get("VOXCPM_MODEL", "openbmb/VoxCPM2")`), `:207` (`int(model.tts_model.sample_rate)`) and `:264` (`write_pcm16_wav(dest, pcm, sample_rate)`) | HIGH |
+| A `reference` profile pins one speaker (median-pitch swing 22–26 Hz, sd 9–12 Hz) while `instruct` samples a new speaker per request (141 Hz swing), so multi-segment work needs a reference or continuation profile | measured on this machine, 2026-10-15, three texts | `scripts/audit-speaker-consistency.py` grades a render; the 2026-10-15 figures are the ones its docstring records | MEDIUM |

package/plugins/generations/voxcpm-tts/scripts/probe-long-render.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Reproduce the long-form voxcpm "echo / hollow" artifact in ~2.5 minutes.
+
+Why this exists: the 2026-10-20 operator report ("回声感、瓮声瓮气") is not reproducible on a short
+sentence — a 10 s render comes out clean — but it IS reproducible on a paragraph of ~450 Chinese
+characters, which is the length the daily pipeline actually renders per section. Measured 2026-10-20
+with `kk stage audio-quality` (real-cepstrum echo probe + pause floor):
+
+    short render (~10 s)      cepstrum 22 ms @ 19 dB   pause floor -22.5 dB   clean
+    long render  (~72 s)      cepstrum 40 ms @ 30 dB   pause floor -16.1 dB   reproduced
+    shipped 2026-10-20 §00    cepstrum 40 ms @ 23 dB   pause floor -15.7 dB   reproduced
+
+So the artifact is duration-dependent, and a knob experiment has to use a LONG text or it measures
+nothing. The same run measured `inference_timesteps=20` (29.6 dB) and `cfg_value=2.5` (31.5 dB) against
+the default's 30 dB: none of the exposed sampler knobs remove the 40 ms periodicity.
+
+Usage (needs the plugin venv):
+
+    plugins/generations/voxcpm-tts/.venv/bin/python \
+        plugins/generations/voxcpm-tts/scripts/probe-long-render.py [--out /tmp/voxcpm-probe]
+
+    kk stage audio-quality /tmp/voxcpm-probe/long-baseline.wav   # then read cepstrum + pauseFloor
+
+Options: `--text-file <path>` (default: the built-in paragraph below), `--ref <wav>` (default: the
+operator's `robin-news` clip), `--steps N`, `--cfg F`, `--normalize`, `--name <label>`.
+
+The verdict vocabulary lives in `plugins/kk/scripts/audio-quality.ts` (`kk stage audio-quality`);
+this script only renders.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import os
+import sys
+import time
+import wave
+
+DEFAULT_TEXT = (
+    "大家好，今天是2026年10月20日，星期二。这里是由Robin为你带来的咸话咸说之每日AI乱炖。"
+    "今天聊两件跟动手有关的事，一位自称几乎不懂游戏开发的作者，靠编程智能体把一款手机端的即时战略游戏"
+    "一路做到能离线运行；另一件是 Google 开源了让 PyTorch 跑上 TPU 的项目。两条线索都指向同一件事："
+    "工具链的边界在移动，真正决定成败的不是模型榜单，而是谁能把验收口径写清楚。"
+    "先说游戏那条，作者的说法很朴素，他不写引擎，只把需求拆成可以验证的小步，让智能体一步一步改，"
+    "每一步都跑一次构建，坏了自己回滚。这种做法听起来笨，但它把不确定性压到了单步之内，"
+    "出问题的时候能立刻定位到底层接口还是生成逻辑。我更在意的是这套流程对工程团队的启示："
+    "当生成成本降到几乎为零，稀缺的就不是代码，而是判断哪一步值得交给机器、哪一步必须留给人验。"
+)
+DEFAULT_REF = os.path.expanduser("~/.config/kk/voices/robin-news.wav")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Render one long-form voxcpm sample for echo triage.")
+    parser.add_argument("--text-file", default=None, help="UTF-8 text to render (default: built-in paragraph)")
+    parser.add_argument("--ref", default=DEFAULT_REF, help="reference clip (default: %(default)s)")
+    parser.add_argument("--out", default="/tmp/voxcpm-probe", help="output directory (default: %(default)s)")
+    parser.add_argument("--name", default="long-baseline", help="output file stem (default: %(default)s)")
+    parser.add_argument("--steps", type=int, default=10, help="inference_timesteps (default 10, the plugin's)")
+    parser.add_argument("--cfg", type=float, default=2.0, help="cfg_value (default 2.0, the plugin's)")
+    parser.add_argument("--normalize", action="store_true", help="pass normalize=True")
+    parser.add_argument(
+        "--mode",
+        choices=["reference", "continuation", "instruct"],
+        default="reference",
+        help="reference cloning (VoxCPM2 only), prompt continuation, or instruct-only (default reference)",
+    )
+    parser.add_argument("--prompt-text", default=None, help="transcript of --ref, required by --mode continuation")
+    parser.add_argument(
+        "--denoise",
+        action="store_true",
+        help="load the ZipEnhancer denoiser and pass denoise=True (the plugin ships load_denoiser=False)",
+    )
+    parser.add_argument("--model", default="openbmb/VoxCPM2", help="hub id or local snapshot")
+    args = parser.parse_args()
+
+    text = open(args.text_file, encoding="utf-8").read().strip() if args.text_file else DEFAULT_TEXT
+    if not text:
+        print("probe: empty text", file=sys.stderr)
+        return 2
+    if not os.path.isfile(args.ref):
+        print(f"probe: reference clip not found: {args.ref}", file=sys.stderr)
+        return 2
+    os.makedirs(args.out, exist_ok=True)
+
+    # The model prints its own progress on stdout; keep this script's stdout for the summary.
+    with contextlib.redirect_stdout(sys.stderr):
+        import numpy as np
+        import voxcpm
+
+        model = voxcpm.VoxCPM.from_pretrained(
+            args.model, load_denoiser=args.denoise, optimize=False, device=None
+        )
+    sample_rate = int(model.tts_model.sample_rate)
+
+    if args.mode == "continuation" and not args.prompt_text:
+        print("probe: --mode continuation needs --prompt-text (the transcript of --ref)", file=sys.stderr)
+        return 2
+    # Only VoxCPM2 accepts `reference_wav_path`; every other checkpoint clones through a prompt pair.
+    anchoring = {
+        "reference": {"reference_wav_path": args.ref},
+        "continuation": {"prompt_wav_path": args.ref, "prompt_text": args.prompt_text or ""},
+        "instruct": {},
+    }[args.mode]
+
+    started = time.time()
+    with contextlib.redirect_stdout(sys.stderr):
+        waveform = model.generate(
+            text=text,
+            cfg_value=args.cfg,
+            inference_timesteps=args.steps,
+            normalize=args.normalize,
+            denoise=args.denoise,
+            **anchoring,
+        )
+    samples = np.clip(np.asarray(waveform).squeeze(), -1.0, 1.0)
+    path = os.path.join(args.out, f"{args.name}.wav")
+    with wave.open(path, "wb") as handle:
+        handle.setnchannels(1)
+        handle.setsampwidth(2)
+        handle.setframerate(sample_rate)
+        handle.writeframes((samples * 32767).astype(np.int16).tobytes())
+
+    seconds = len(samples) / sample_rate
+    print(
+        f"{path}  {seconds:.1f}s  sr={sample_rate}  chars={len(text)}  "
+        f"mode={args.mode} steps={args.steps} cfg={args.cfg} normalize={args.normalize} denoise={args.denoise}  render={time.time() - started:.1f}s"
+    )
+    print("measure it with: kk stage audio-quality " + path, file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/plugins/kk/plugin.json

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

package/plugins/kk/scripts/audio-quality.ts

@@ -0,0 +1,635 @@
+#!/usr/bin/env bun
+/**
+ * Audio quality triage for narrated episodes — MEASURE ONLY, never wired into the daily pipeline.
+ *
+ * WHY THIS EXISTS (2026-10-20): the operator reported that episodes rendered through `voxcpm` (from
+ * 2026-10-15 on) sound hollow and echoey ("瓮声瓮气，有明显回声感") while the earlier `gemini-tts`
+ * episodes do not. The pipeline's `daily-voice-audit` checks speaker consistency and the duration gate
+ * checks length; nothing measured the ACOUSTIC character, so a regression in the voice reference or in
+ * the driver could ship for days unnoticed. This tool makes that character measurable, so a
+ * driver/profile change is judged on numbers rather than memory.
+ *
+ * It is a `kk stage` body and NOT a pipeline node: `kk-daily-ai-voice2` never calls it, so the daily
+ * generate → publish path keeps its own gates (duration, speaker audit) and this stays the tool an
+ * operator reaches for when an episode sounds wrong. Living in `plugins/kk/scripts/` rather than the
+ * repo's root `scripts/` is deliberate — root `scripts/` is build/release tooling run from a checkout,
+ * while this measures what the installed product produces, so it must ship with the plugin and resolve
+ * from an installed package (`kk stage audio-quality …`), exactly like every other stage body here.
+ * It is not driver-specific either, so `plugins/generations/voxcpm-tts/scripts/` (where the
+ * VoxCPM-only `audit-speaker-consistency.py` lives) would have been the wrong home.
+ *
+ *   kk stage audio-quality <file…>                          # human report per file
+ *   kk stage audio-quality --json <file…>                   # machine report
+ *   kk stage audio-quality --baseline <good> <file…>        # per-band delta against a known-good file
+ *   kk stage audio-quality --treat <ref-in> <ref-out>       # de-box a REFERENCE clip (not an episode)
+ *   bun run audio:quality <file…>                           # the same body from a checkout
+ *
+ * WHAT IS MEASURED, mapped to the two complaints:
+ *
+ *  "回声感" (echo / ringing)
+ *   - `decay` — the energy-decay curve 50/100/200/400 ms after each speech offset whose next 500 ms
+ *     stays quiet (so the following syllable cannot be mistaken for a tail). A dry studio read is
+ *     -20 dB or lower at 100 ms and keeps falling; a room/echo tail plateaus around -10…-15 dB. This
+ *     is the primary reverb instrument.
+ *   - `cepstrum` — real-cepstrum peak in the 20–120 ms quefrency band. A single reflection puts a
+ *     periodic ripple in the log spectrum, so its cepstrum peaks at the delay. Starting at 20 ms keeps
+ *     the pitch period (5–12 ms for a human voice, and its multiples) out of the way; a residual peak
+ *     near 2× the pitch period is why this is reported as evidence, not as the verdict.
+ *   - `echo` — envelope-autocorrelation repetition (first-differenced so slow syllable modulation
+ *     cannot fake a lag). Corroborates a doubled render / comb filter at a fixed delay.
+ *
+ *  "瓮声瓮气" (boxy / hollow)
+ *   - `bands` — average spectrum in octave-ish bands, as dB relative to full band; "boxy" is a
+ *     250–500 Hz plateau with a 2–4 kHz deficit, reported as `boxy` dB (positive = boxy).
+ *   - `centroidHz` / `rolloff85Hz` — one number each for "dark vs bright"; speech naturally sits low,
+ *     so these are compared against a baseline rather than thresholded.
+ *   - `pauseFloorDb` (+ `quantiles`) — how far the quietest 20 % of frames fall below median speech.
+ *     A reverb bed or a wash keeps this high; measured on this repo's corpus: gemini episodes −37 dB,
+ *     voxcpm episodes −19.6 dB, the shared `robin-news.wav` reference −27.7 dB.
+ *
+ * Thresholds are advisory (calibrated 2026-10-20 against 10-12…10-14 gemini episodes, 10-15…10-20
+ * voxcpm episodes and the reference clip); every metric is printed, so a threshold miss never hides a
+ * number. `--treat` exists because the actionable repair for a cloned voice is the REFERENCE, not the
+ * finished episode: the model reproduces its prompt's room, so the prompt is what gets corrected.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+/** Analysis rate: cheap, and Nyquist 12 kHz still covers everything that matters for speech. */
+const ANALYSIS_RATE = 24_000;
+/** Short-term envelope frame: 20 ms → 50 points per second. */
+const FRAME_MS = 20;
+
+export interface BandPowers {
+    /** Band label → level in dB relative to the full-band power. */
+    readonly bands: Record<string, number>;
+    readonly centroidHz: number;
+    readonly rolloff85Hz: number;
+}
+
+export interface CepstrumEcho {
+    /** Quefrency of the cepstral peak: the delay of the repeated material, in milliseconds. */
+    readonly delayMs: number;
+    /** Peak height above the median cepstrum in the search range, in dB. */
+    readonly prominenceDb: number;
+}
+
+export interface EchoMeasure {
+    readonly lagMs: number;
+    readonly strength: number;
+}
+
+export interface DecayCurve {
+    readonly at50: number;
+    readonly at100: number;
+    readonly at200: number;
+    /** First 20 ms step at or below −30 dB, in ms (500 = never), 0 when no offset qualifies. */
+    readonly tailMs: number;
+    /** Qualifying offsets the medians came from (0 = the audio never pauses). */
+    readonly offsets: number;
+}
+
+export interface EnvelopeQuantiles {
+    readonly p05: number;
+    readonly p20: number;
+    readonly p50: number;
+    readonly p70: number;
+}
+
+export interface AudioReport {
+    readonly file: string;
+    readonly sampleRate: number;
+    readonly seconds: number;
+    readonly peakDbfs: number;
+    readonly rmsDbfs: number;
+    readonly crestDb: number;
+    readonly dcOffset: number;
+    readonly clippedSamples: number;
+    readonly quantiles: EnvelopeQuantiles;
+    readonly pauseFloorDb: number;
+    readonly decay: DecayCurve;
+    readonly cepstrum: CepstrumEcho | null;
+    readonly echo: EchoMeasure | null;
+    readonly spectrum: BandPowers;
+    /** Advisory flags; empty means "nothing in this tool's vocabulary fired". */
+    readonly flags: readonly string[];
+}
+
+/** Advisory thresholds (see the header for the calibration corpus). */
+export const THRESHOLDS = {
+    /** 20th-percentile frame level vs median speech; above this the read has a wash. */
+    pauseFloorDb: -30,
+    /** Level 200 ms after an offset, in dB: a dry read is below ~−32. */
+    decay200Db: -32,
+    echoStrength: 0.3,
+    cepstrumDb: 25,
+} as const;
+
+const BAND_EDGES: readonly [string, number, number][] = [
+    ['60-125', 60, 125],
+    ['125-250', 125, 250],
+    ['250-500', 250, 500],
+    ['500-1k', 500, 1000],
+    ['1k-2k', 1000, 2000],
+    ['2k-4k', 2000, 4000],
+    ['4k-8k', 4000, 8000],
+    ['8k-12k', 8000, 12_000],
+];
+
+function percentile(sorted: readonly number[], p: number): number {
+    if (sorted.length === 0) return 0;
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.round((p / 100) * (sorted.length - 1))));
+    return sorted[index] as number;
+}
+
+function median(values: readonly number[]): number {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    return percentile(sorted, 50);
+}
+
+/** ffprobe the first audio stream. */
+export function probe(file: string): { sampleRate: number; channels: number; seconds: number } {
+    const run = spawnSync(
+        'ffprobe',
+        [
+            '-v',
+            'error',
+            '-select_streams',
+            'a:0',
+            '-show_entries',
+            'stream=sample_rate,channels',
+            '-show_entries',
+            'format=duration',
+            '-of',
+            'default=noprint_wrappers=1',
+            file,
+        ],
+        { encoding: 'buffer' },
+    );
+    if (run.status !== 0) throw new Error(`ffprobe failed for ${file}: ${run.stderr?.toString().trim()}`);
+    const text = run.stdout.toString();
+    const value = (key: string): number => Number(new RegExp(`^${key}=(.+)$`, 'm').exec(text)?.[1] ?? 0);
+    return { sampleRate: value('sample_rate'), channels: value('channels'), seconds: value('duration') };
+}
+
+/** Decode to mono s16 PCM at {@link ANALYSIS_RATE} (ffmpeg resamples). */
+export function decodeMono(file: string, rate = ANALYSIS_RATE): Int16Array {
+    const run = spawnSync(
+        'ffmpeg',
+        ['-v', 'error', '-i', file, '-ac', '1', '-ar', String(rate), '-f', 's16le', '-acodec', 'pcm_s16le', '-'],
+        { maxBuffer: 1024 * 1024 * 1024 },
+    );
+    if (run.status !== 0) throw new Error(`ffmpeg decode failed for ${file}: ${run.stderr?.toString().trim()}`);
+    const buf = run.stdout as Buffer;
+    return new Int16Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
+}
+
+/** Short-term RMS envelope, one point per {@link FRAME_MS}. */
+export function envelope(pcm: Int16Array, rate = ANALYSIS_RATE): Float64Array {
+    const frame = Math.max(1, Math.round((rate * FRAME_MS) / 1000));
+    const frames = Math.floor(pcm.length / frame);
+    const out = new Float64Array(frames);
+    for (let i = 0; i < frames; i += 1) {
+        let sum = 0;
+        const base = i * frame;
+        for (let j = 0; j < frame; j += 1) {
+            const s = (pcm[base + j] as number) / 32768;
+            sum += s * s;
+        }
+        out[i] = Math.sqrt(sum / frame);
+    }
+    return out;
+}
+
+/** Envelope quantiles in dB relative to median speech (p70 = 0 by construction). */
+export function envelopeQuantiles(env: Float64Array): EnvelopeQuantiles {
+    const db = Array.from(env, (v) => 20 * Math.log10(Math.max(v, 1e-7))).sort((a, b) => a - b);
+    const p70 = percentile(db, 70);
+    return {
+        p05: Number((percentile(db, 5) - p70).toFixed(1)),
+        p20: Number((percentile(db, 20) - p70).toFixed(1)),
+        p50: Number((percentile(db, 50) - p70).toFixed(1)),
+        p70: 0,
+    };
+}
+
+/** Pause floor: the 20th-percentile frame level minus median speech, in dB. */
+export function pauseFloorDb(env: Float64Array): number {
+    return envelopeQuantiles(env).p20;
+}
+
+/**
+ * Energy-decay curve across PHRASE ENDS — the reverb instrument.
+ *
+ * Offsets are found as runs of frames at least 20 dB below the phrase level that last ≥80 ms; for each
+ * run the peak of the preceding 100 ms is the reference, and the level 50/100/200/400 ms after that
+ * peak is recorded. A dry read is already 20 dB down by 100 ms and keeps falling; a room tail plateaus
+ * around −10…−15 dB. (An earlier version keyed on local maxima, which found nothing: in a continuous
+ * narration read every local maximum sits mid-phrase, so "200 ms of quiet after the peak" never holds.)
+ */
+export function decayCurve(env: Float64Array): DecayCurve {
+    const db = Array.from(env, (v) => 20 * Math.log10(Math.max(v, 1e-7)));
+    const speech = percentile(
+        [...db].sort((a, b) => a - b),
+        70,
+    );
+    const quietBelow = speech - 20;
+    const buckets = {
+        at50: [] as number[],
+        at100: [] as number[],
+        at200: [] as number[],
+        tail: [] as number[],
+    };
+    const RAMP = Math.round(80 / FRAME_MS);
+    const LOOKBACK = Math.round(100 / FRAME_MS);
+    for (let s = LOOKBACK; s < db.length; s += 1) {
+        if ((db[s] as number) >= quietBelow) continue;
+        let runEnd = s;
+        while (runEnd < db.length && (db[runEnd] as number) < quietBelow) runEnd += 1;
+        const runLength = runEnd - s;
+        s = runEnd;
+        if (runLength < RAMP) continue;
+        let peakIndex = -1;
+        let peak = -Infinity;
+        for (let j = Math.max(0, s - runLength - LOOKBACK); j < s; j += 1) {
+            if ((db[j] as number) > peak) {
+                peak = db[j] as number;
+                peakIndex = j;
+            }
+        }
+        if (peakIndex < 0 || peak < speech) continue;
+        const rel = (ms: number): number | null => {
+            const j = peakIndex + Math.round(ms / FRAME_MS);
+            return j < db.length ? Number(((db[j] as number) - peak).toFixed(1)) : null;
+        };
+        const v50 = rel(50);
+        const v100 = rel(100);
+        const v200 = rel(200);
+        if (v50 === null || v100 === null || v200 === null) continue;
+        buckets.at50.push(v50);
+        buckets.at100.push(v100);
+        buckets.at200.push(v200);
+        let tail = 500;
+        for (let ms = FRAME_MS; ms <= 500; ms += FRAME_MS) {
+            const value = rel(ms);
+            if (value !== null && value <= -30) {
+                tail = ms;
+                break;
+            }
+        }
+        buckets.tail.push(tail);
+    }
+    const round1 = (value: number): number => Number(value.toFixed(1));
+    return {
+        at50: round1(median(buckets.at50)),
+        at100: round1(median(buckets.at100)),
+        at200: round1(median(buckets.at200)),
+        tailMs: buckets.tail.length === 0 ? 0 : median(buckets.tail),
+        offsets: buckets.tail.length,
+    };
+}
+
+/**
+ * Envelope-autocorrelation repetition in the 40–160 ms lag range, on the FIRST-DIFFERENCED envelope so
+ * the slow syllable/modulation trend cannot masquerade as a repetition (measured 2026-10-20: the raw
+ * envelope reported 0.83 at the minimum lag on every file, a dry gemini read included).
+ */
+export function echoMeasure(env: Float64Array): EchoMeasure | null {
+    if (env.length < 40) return null;
+    const n = env.length - 1;
+    const centred = new Float64Array(n);
+    let mean = 0;
+    for (let i = 0; i < n; i += 1) {
+        centred[i] = (env[i + 1] as number) - (env[i] as number);
+        mean += centred[i] as number;
+    }
+    mean /= n;
+    let energy = 0;
+    for (let i = 0; i < n; i += 1) {
+        centred[i] = (centred[i] as number) - mean;
+        energy += (centred[i] as number) ** 2;
+    }
+    if (energy <= 0) return null;
+    const minLag = Math.max(2, Math.round(40 / FRAME_MS));
+    const maxLag = Math.min(n - 2, Math.round(160 / FRAME_MS));
+    const scores = new Float64Array(maxLag + 2);
+    let best = { lag: minLag, strength: 0 };
+    for (let lag = minLag; lag <= maxLag; lag += 1) {
+        let sum = 0;
+        for (let i = 0; i + lag < n; i += 1) sum += (centred[i] as number) * (centred[i + lag] as number);
+        const value = sum / energy;
+        scores[lag] = value;
+        if (value > best.strength) best = { lag, strength: value };
+    }
+    if (best.strength <= 0) return null;
+    const neighbourhood = [scores[best.lag - 1] ?? 0, scores[best.lag + 1] ?? 0];
+    if (neighbourhood.some((value) => value >= best.strength)) return null;
+    return { lagMs: best.lag * FRAME_MS, strength: Number(best.strength.toFixed(3)) };
+}
+
+/** In-place iterative radix-2 FFT; `re`/`im` must be power-of-two length. */
+export function fft(re: Float64Array, im: Float64Array): void {
+    const n = re.length;
+    for (let i = 1, j = 0; i < n; i += 1) {
+        let bit = n >> 1;
+        for (; j & bit; bit >>= 1) j ^= bit;
+        j ^= bit;
+        if (i < j) {
+            [re[i], re[j]] = [re[j] as number, re[i] as number];
+            [im[i], im[j]] = [im[j] as number, im[i] as number];
+        }
+    }
+    for (let len = 2; len <= n; len <<= 1) {
+        const angle = (-2 * Math.PI) / len;
+        const wRe = Math.cos(angle);
+        const wIm = Math.sin(angle);
+        for (let i = 0; i < n; i += len) {
+            let curRe = 1;
+            let curIm = 0;
+            for (let k = 0; k < len / 2; k += 1) {
+                const evenRe = re[i + k] as number;
+                const evenIm = im[i + k] as number;
+                const oddRe = re[i + k + len / 2] as number;
+                const oddIm = im[i + k + len / 2] as number;
+                const tRe = oddRe * curRe - oddIm * curIm;
+                const tIm = oddRe * curIm + oddIm * curRe;
+                re[i + k] = evenRe + tRe;
+                im[i + k] = evenIm + tIm;
+                re[i + k + len / 2] = evenRe - tRe;
+                im[i + k + len / 2] = evenIm - tIm;
+                const nextRe = curRe * wRe - curIm * wIm;
+                curIm = curRe * wIm + curIm * wRe;
+                curRe = nextRe;
+            }
+        }
+    }
+}
+
+/**
+ * Real-cepstrum echo probe. A reflection adds a periodic ripple to the log-magnitude spectrum whose
+ * period is 1/delay, so the cepstrum (inverse transform of that log spectrum) peaks at the delay.
+ * The search starts at 20 ms: a 5–12 ms pitch period and its multiples would otherwise dominate.
+ * Frames are capped so a 20-minute episode still costs about a second.
+ */
+export function cepstrumEcho(pcm: Int16Array, rate = ANALYSIS_RATE): CepstrumEcho | null {
+    const size = 8192;
+    const frames = Math.floor(pcm.length / size);
+    if (frames < 2) return null;
+    const step = Math.max(1, Math.floor(frames / 400));
+    const logPower = new Float64Array(size);
+    const window = Float64Array.from({ length: size }, (_, i) => 0.5 - 0.5 * Math.cos((2 * Math.PI * i) / size));
+    let used = 0;
+    for (let f = 0; f < frames; f += step) {
+        const re = new Float64Array(size);
+        const im = new Float64Array(size);
+        for (let i = 0; i < size; i += 1) re[i] = ((pcm[f * size + i] as number) / 32768) * (window[i] as number);
+        fft(re, im);
+        for (let k = 0; k < size; k += 1) {
+            logPower[k] =
+                (logPower[k] as number) + Math.log(Math.max((re[k] as number) ** 2 + (im[k] as number) ** 2, 1e-20));
+        }
+        used += 1;
+    }
+    if (used === 0) return null;
+    for (let k = 0; k < size; k += 1) logPower[k] = (logPower[k] as number) / used;
+    // The real cepstrum is the inverse transform of the (real, even) log spectrum; fft/N is that inverse.
+    const re = Float64Array.from(logPower);
+    const im = new Float64Array(size);
+    fft(re, im);
+    const cepstrum = Float64Array.from(re, (value) => Math.abs(value) / size);
+    const perMs = rate / 1000;
+    const lo = Math.max(2, Math.round(20 * perMs));
+    const hi = Math.min(Math.floor(size / 2) - 1, Math.round(120 * perMs));
+    const slice: number[] = [];
+    for (let q = lo; q <= hi; q += 1) slice.push(cepstrum[q] as number);
+    slice.sort((a, b) => a - b);
+    const floor = percentile(slice, 50);
+    let best = { q: lo, value: 0 };
+    for (let q = lo; q <= hi; q += 1) {
+        const value = cepstrum[q] as number;
+        if (value > best.value) best = { q, value };
+    }
+    const prominenceDb = 20 * Math.log10(Math.max(best.value, 1e-12) / Math.max(floor, 1e-12));
+    return { delayMs: Math.round((best.q / perMs) * 10) / 10, prominenceDb: Number(prominenceDb.toFixed(1)) };
+}
+
+/** Average power spectrum over Hann-windowed 2048-sample frames, plus bands/centroid/rolloff. */
+export function spectrum(pcm: Int16Array, rate = ANALYSIS_RATE): BandPowers {
+    const size = 2048;
+    const frames = Math.floor(pcm.length / size);
+    const power = new Float64Array(size / 2);
+    const window = Float64Array.from({ length: size }, (_, i) => 0.5 - 0.5 * Math.cos((2 * Math.PI * i) / size));
+    for (let f = 0; f < frames; f += 1) {
+        const re = new Float64Array(size);
+        const im = new Float64Array(size);
+        for (let i = 0; i < size; i += 1) re[i] = ((pcm[f * size + i] as number) / 32768) * (window[i] as number);
+        fft(re, im);
+        for (let k = 0; k < size / 2; k += 1) {
+            power[k] = (power[k] as number) + (re[k] as number) ** 2 + (im[k] as number) ** 2;
+        }
+    }
+    if (frames > 0) for (let k = 0; k < power.length; k += 1) power[k] = (power[k] as number) / frames;
+    const binHz = rate / size;
+    const total = power.reduce((a, b) => a + b, 0) || 1;
+    const bands: Record<string, number> = {};
+    for (const [label, low, high] of BAND_EDGES) {
+        const lo = Math.max(1, Math.floor(low / binHz));
+        const hi = Math.min(power.length - 1, Math.ceil(high / binHz));
+        let sum = 0;
+        for (let k = lo; k <= hi; k += 1) sum += power[k] as number;
+        bands[label] = Number((10 * Math.log10(Math.max(sum / total, 1e-20))).toFixed(1));
+    }
+    let weighted = 0;
+    let cumulative = 0;
+    let rolloff = 0;
+    for (let k = 1; k < power.length; k += 1) {
+        const p = power[k] as number;
+        weighted += p * k * binHz;
+        cumulative += p;
+        if (rolloff === 0 && cumulative >= total * 0.85) rolloff = k * binHz;
+    }
+    return { bands, centroidHz: Math.round(weighted / total), rolloff85Hz: Math.round(rolloff) };
+}
+
+/** Boxy = the 250–500 Hz band sits above the 2–4 kHz band (a hollow, cupped read). */
+export function boxinessDb(bands: BandPowers): number {
+    return Number((((bands.bands['250-500'] as number) - (bands.bands['2k-4k'] as number)) as number).toFixed(1));
+}
+
+export function analyse(file: string): AudioReport {
+    const meta = probe(file);
+    const pcm = decodeMono(file);
+    if (pcm.length === 0) throw new Error(`${file}: decoded no audio samples`);
+    const env = envelope(pcm);
+    let peak = 0;
+    let sum = 0;
+    let dc = 0;
+    let clipped = 0;
+    for (let i = 0; i < pcm.length; i += 1) {
+        const s = (pcm[i] as number) / 32768;
+        const abs = Math.abs(s);
+        if (abs > peak) peak = abs;
+        if (abs >= 0.999) clipped += 1;
+        sum += s * s;
+        dc += s;
+    }
+    const rms = Math.sqrt(sum / pcm.length);
+    const quantiles = envelopeQuantiles(env);
+    const decay = decayCurve(env);
+    const cepstrum = cepstrumEcho(pcm);
+    const echo = echoMeasure(env);
+    const spec = spectrum(pcm);
+
+    const flags: string[] = [];
+    if (quantiles.p20 > THRESHOLDS.pauseFloorDb) flags.push(`washy-pauses:${quantiles.p20}dB`);
+    if (decay.offsets > 0 && decay.at200 > THRESHOLDS.decay200Db) flags.push(`reverb-tail:${decay.at200}dB@200ms`);
+    // A strong tail never lets the level fall 20 dB below the phrase level, so no offset qualifies:
+    // absence of quiet runs, together with a high pause floor, IS the reverb finding.
+    if (decay.offsets === 0 && quantiles.p20 > THRESHOLDS.pauseFloorDb) flags.push('no-quiet-runs');
+    if (echo !== null && echo.strength >= THRESHOLDS.echoStrength) flags.push(`echo:${echo.lagMs}ms@${echo.strength}`);
+    if (cepstrum !== null && cepstrum.prominenceDb >= THRESHOLDS.cepstrumDb) {
+        flags.push(`cepstral-echo:${cepstrum.delayMs}ms@${cepstrum.prominenceDb}dB`);
+    }
+    if (clipped > 0) flags.push(`clipped:${clipped}`);
+
+    return {
+        file,
+        sampleRate: meta.sampleRate,
+        seconds: Math.round((pcm.length / ANALYSIS_RATE) * 10) / 10,
+        peakDbfs: Number((20 * Math.log10(Math.max(peak, 1e-7))).toFixed(1)),
+        rmsDbfs: Number((20 * Math.log10(Math.max(rms, 1e-7))).toFixed(1)),
+        crestDb: Number((20 * Math.log10(Math.max(peak, 1e-7) / Math.max(rms, 1e-7))).toFixed(1)),
+        dcOffset: Number((dc / pcm.length).toFixed(5)),
+        clippedSamples: clipped,
+        quantiles,
+        pauseFloorDb: quantiles.p20,
+        decay,
+        cepstrum,
+        echo,
+        spectrum: spec,
+        flags,
+    };
+}
+
+/** Corrective chain for a REFERENCE clip: not a de-reverb, but it removes the boxy room tone. */
+export const TREAT_FILTER =
+    'highpass=f=80,equalizer=f=320:t=q:w=1.2:g=-3.5,equalizer=f=3000:t=q:w=1.0:g=2,acompressor=threshold=-18dB:ratio=2.5:attack=8:release=180,alimiter=limit=0.95';
+
+export function treat(input: string, output: string): void {
+    const { sampleRate } = probe(input);
+    const run = spawnSync(
+        'ffmpeg',
+        [
+            '-y',
+            '-hide_banner',
+            '-loglevel',
+            'error',
+            '-i',
+            input,
+            '-af',
+            TREAT_FILTER,
+            '-ar',
+            String(sampleRate),
+            '-ac',
+            '1',
+            '-c:a',
+            'pcm_s16le',
+            output,
+        ],
+        { encoding: 'buffer' },
+    );
+    if (run.status !== 0) throw new Error(`ffmpeg treat failed: ${run.stderr?.toString().trim()}`);
+}
+
+function printReport(report: AudioReport, baseline?: AudioReport): void {
+    const spec = report.spectrum;
+    console.log(`\n${report.file}`);
+    console.log(
+        `  ${report.seconds}s @ ${report.sampleRate} Hz · peak ${report.peakDbfs} dBFS · rms ${report.rmsDbfs} dBFS · crest ${report.crestDb} dB · dc ${report.dcOffset}`,
+    );
+    console.log(
+        `  decay 50/100/200 ms: ${report.decay.at50}/${report.decay.at100}/${report.decay.at200} dB · tail ${report.decay.tailMs} ms over ${report.decay.offsets} offsets`,
+    );
+    console.log(
+        `  pauseFloor ${report.pauseFloorDb} dB (p05/p20/p50 ${report.quantiles.p05}/${report.quantiles.p20}/${report.quantiles.p50}) · cepstrum ${
+            report.cepstrum === null ? 'n/a' : `${report.cepstrum.delayMs} ms @ ${report.cepstrum.prominenceDb} dB`
+        } · echo ${report.echo === null ? 'none' : `${report.echo.lagMs} ms @ ${report.echo.strength}`} · boxy ${boxinessDb(spec)} dB`,
+    );
+    console.log(`  centroid ${spec.centroidHz} Hz · rolloff85 ${spec.rolloff85Hz} Hz`);
+    console.log(
+        `  bands ${Object.entries(spec.bands)
+            .map(([label, db]) => `${label}:${db}`)
+            .join('  ')}`,
+    );
+    if (baseline !== undefined) {
+        const delta = Object.entries(spec.bands)
+            .map(
+                ([label, db]) => `${label}:${((db as number) - (baseline.spectrum.bands[label] as number)).toFixed(1)}`,
+            )
+            .join('  ');
+        console.log(`  Δvs baseline ${delta}`);
+    }
+    console.log(`  verdict ${report.flags.length === 0 ? 'no flag' : report.flags.join(', ')}`);
+}
+
+export async function main(argv: string[]): Promise<void> {
+    const files: string[] = [];
+    let baseline: string | undefined;
+    let json = false;
+    let treatMode: [string, string] | undefined;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] as string;
+        if (arg === '--json') {
+            json = true;
+            continue;
+        }
+        if (arg === '--baseline') {
+            i += 1;
+            baseline = argv[i] as string;
+            continue;
+        }
+        if (arg === '--treat') {
+            treatMode = [argv[i + 1] as string, argv[i + 2] as string];
+            i += 2;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            console.log(
+                'usage: kk stage audio-quality [--json] [--baseline <file>] <file…>\n       kk stage audio-quality --treat <reference-in> <reference-out>',
+            );
+            return;
+        }
+        files.push(arg);
+    }
+    if (treatMode !== undefined) {
+        treat(treatMode[0], treatMode[1]);
+        console.log(`treated ${treatMode[0]} -> ${treatMode[1]}\n  chain ${TREAT_FILTER}`);
+        return;
+    }
+    if (files.length === 0) {
+        console.error('usage: kk stage audio-quality [--json] [--baseline <file>] <file…>');
+        process.exit(2);
+    }
+    const baselineReport = baseline === undefined ? undefined : analyse(baseline);
+    const reports = files.map((file) => analyse(file));
+    if (json) {
+        console.log(
+            JSON.stringify(baselineReport === undefined ? reports : { baseline: baselineReport, reports }, null, 2),
+        );
+        return;
+    }
+    for (const report of reports) printReport(report, baselineReport);
+}
+
+/**
+ * Stage entry point: `kk stage audio-quality [--json] [--baseline <file>] <file…>`.
+ *
+ * The stage runner passes the args after the stage name, so this is the same parser the direct
+ * `bun run audio:quality` entry uses — one body, two spellings.
+ */
+export async function runAudioQuality(args: string[]): Promise<void> {
+    await main(args);
+}
+
+if (import.meta.main) await runAudioQuality(process.argv.slice(2));

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

@@ -1981,6 +1981,52 @@ 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

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',
@@ -1638,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);

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}"
@@ -548,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]
@@ -570,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/publishings/surfdash-pub/dist/index.js

@@ -12423,6 +12423,10 @@ ${crossLinkFor(locale, request.dateIso, request.showNotesUrl)}
     if (md !== before) {
       await fs.writeFile(indexMd, md);
       written.push(indexMd);
+      const assetsDir = join(dir, "assets");
+      if (await fs.exists(assetsDir) && !written.includes(join(assetsDir, "cover.png"))) {
+        written.push(assetsDir);
+      }
       changed += 1;
     }
   }
@@ -12437,6 +12441,14 @@ var COVER_EXTS = new Set([".png", ".jpg", ".jpeg", ".webp", ".gif"]);
 function slugify2(str) {
   return str.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/[\s_]+/g, "-");
 }
+function normalizeTag(raw) {
+  const match = raw.match(/^\s*sub-category\s*:(.*)$/i);
+  if (match) {
+    const subSlug = slugify2(match[1] ?? "");
+    return subSlug ? `sub-category:${subSlug}` : "";
+  }
+  return slugify2(raw);
+}
 function mapContentToSurfingMarkdown(content, options = {}) {
   let title = content.title;
   if (!title) {
@@ -12452,9 +12464,13 @@ function mapContentToSurfingMarkdown(content, options = {}) {
       description = paragraphs[0];
     }
   }
-  const rawTags = Array.isArray(content.metadata?.tags) ? content.metadata.tags : Array.isArray(content.metadata?.keywords) ? content.metadata.keywords : [];
+  const rawTags = Array.isArray(content.metadata?.tags) ? [...content.metadata.tags] : Array.isArray(content.metadata?.keywords) ? [...content.metadata.keywords] : [];
+  if (typeof content.metadata?.subCategory === "string" && content.metadata.subCategory.trim().length > 0) {
+    const subRaw = content.metadata.subCategory.trim();
+    rawTags.push(/^sub-category\s*:/i.test(subRaw) ? subRaw : `sub-category:${subRaw}`);
+  }
   const tags = [
-    ...new Set(rawTags.filter((t) => typeof t === "string" && t.trim().length > 0).map((t) => slugify2(t)))
+    ...new Set(rawTags.filter((t) => typeof t === "string" && t.trim().length > 0).map((t) => normalizeTag(t)))
   ].filter((tag) => tag.length > 0);
   const isoDate = options.publishDate ?? new Date().toISOString().slice(0, 10);
   const firstRefUrl = content.references?.[0]?.url;
@@ -12743,7 +12759,17 @@ async function patchPost(options) {
   if (outcome.changed === 0)
     echoError(`patch: no post bytes changed for ${outcome.slug}`);
   const synced = await syncPost({ postPath: postPath.postPath });
-  const commit = await commitPostPaths(surfdashRoot, outcome.written.map((path) => relative(surfdashRoot, path)), `feat: cover + podcast cross-link for ${outcome.slug} (kk daily patch)`, process.env.SURFDASH_AUTO_PUSH !== "0");
+  const commitPaths = new Set(outcome.written.map((path) => relative(surfdashRoot, path)));
+  for (const locale of PATCH_LOCALES) {
+    const indexMd = localeIndexPath(postPath.postPath, locale);
+    if (!indexMd)
+      continue;
+    const assetsDir = join2(dirname3(indexMd), "assets");
+    if (existsSync2(assetsDir)) {
+      commitPaths.add(relative(surfdashRoot, assetsDir));
+    }
+  }
+  const commit = await commitPostPaths(surfdashRoot, [...commitPaths], `feat: cover + podcast cross-link for ${outcome.slug} (kk daily patch)`, process.env.SURFDASH_AUTO_PUSH !== "0");
   if (!commit.ok)
     return fail(`patch: ${commit.error}`);
   const metadata = {
@@ -12922,6 +12948,7 @@ export {
   main2 as main,
   mapContentToSurfingMarkdown,
   normalizeLocaleFrontmatter,
+  normalizeTag,
   processPublishIO,
   pushPostGit,
   slugify2 as slugify,

package/plugins/publishings/surfdash-pub/src/index.ts

@@ -6,7 +6,7 @@ import { type Content, ContentSchema, type Result, ResultSchema } from '@gobing-
 import type { PublishTransport, PublishTransportPayload } from '@gobing-ai/publish-harness';
 import { createNodeFileSystem } from '@gobing-ai/ts-runtime';
 import { echoError } from '@gobing-ai/ts-utils';
-import { type PatchPostOutcome, patchPostFiles } from './patch';
+import { localeIndexPath, PATCH_LOCALES, type PatchPostOutcome, patchPostFiles } from './patch';
 
 /** Result target name for this plugin. */
 const TARGET = 'surfdash';
@@ -62,6 +62,19 @@ export function slugify(str: string): string {
         .replace(/[\s_]+/g, '-');
 }
 
+/**
+ * Normalizes a raw tag string for frontmatter: preserves `sub-category:<slug>` prefixes
+ * while slugifying the value portion (or ordinary tags).
+ */
+export function normalizeTag(raw: string): string {
+    const match = raw.match(/^\s*sub-category\s*:(.*)$/i);
+    if (match) {
+        const subSlug = slugify(match[1] ?? '');
+        return subSlug ? `sub-category:${subSlug}` : '';
+    }
+    return slugify(raw);
+}
+
 /**
  * Maps Content object into Surfing frontmatter and body per the publish spec.
  */
@@ -86,18 +99,23 @@ export function mapContentToSurfingMarkdown(content: Content, options: MapConten
     }
 
     const rawTags: unknown[] = Array.isArray(content.metadata?.tags)
-        ? content.metadata.tags
+        ? [...content.metadata.tags]
         : Array.isArray(content.metadata?.keywords)
-          ? content.metadata.keywords
+          ? [...content.metadata.keywords]
           : [];
+    if (typeof content.metadata?.subCategory === 'string' && content.metadata.subCategory.trim().length > 0) {
+        const subRaw = content.metadata.subCategory.trim();
+        rawTags.push(/^sub-category\s*:/i.test(subRaw) ? subRaw : `sub-category:${subRaw}`);
+    }
     // `slugify` drops non-ASCII, so a Chinese tag (`硬件发布`) collapsed to '' and shipped as an empty
     // YAML tag — the site renders it as a blank chip (seen on 20261011-ai-2026-10-11). Case variants
-    // also collapsed to the same slug twice (`AI` + `ai`), so the set dedupes.
+    // also collapsed to the same slug twice (`AI` + `ai`), so the set dedupes. `normalizeTag` preserves
+    // `sub-category:<slug>` colon prefixes so sub-category series tags survive into frontmatter.
     const tags = [
         ...new Set(
             rawTags
                 .filter((t): t is string => typeof t === 'string' && t.trim().length > 0)
-                .map((t: string) => slugify(t)),
+                .map((t: string) => normalizeTag(t)),
         ),
     ].filter((tag) => tag.length > 0);
 
@@ -519,9 +537,18 @@ async function patchPost(options: SurfdashPubOptions): Promise<Result> {
     }
     if (outcome.changed === 0) echoError(`patch: no post bytes changed for ${outcome.slug}`);
     const synced = await syncPost({ postPath: postPath.postPath });
+    const commitPaths = new Set(outcome.written.map((path) => relative(surfdashRoot, path)));
+    for (const locale of PATCH_LOCALES) {
+        const indexMd = localeIndexPath(postPath.postPath, locale);
+        if (!indexMd) continue;
+        const assetsDir = join(dirname(indexMd), 'assets');
+        if (existsSync(assetsDir)) {
+            commitPaths.add(relative(surfdashRoot, assetsDir));
+        }
+    }
     const commit = await commitPostPaths(
         surfdashRoot,
-        outcome.written.map((path) => relative(surfdashRoot, path)),
+        [...commitPaths],
         `feat: cover + podcast cross-link for ${outcome.slug} (kk daily patch)`,
         process.env.SURFDASH_AUTO_PUSH !== '0',
     );

package/plugins/publishings/surfdash-pub/src/patch.ts

@@ -137,6 +137,10 @@ export async function patchPostFiles(request: PatchPostRequest): Promise<PatchPo
         if (md !== before) {
             await fs.writeFile(indexMd, md);
             written.push(indexMd);
+            const assetsDir = join(dir, 'assets');
+            if ((await fs.exists(assetsDir)) && !written.includes(join(assetsDir, 'cover.png'))) {
+                written.push(assetsDir);
+            }
             changed += 1;
         }
     }

package/plugins/kk/workflows/feature-verification.yaml

@@ -1,89 +0,0 @@
-# Feature-scoped verification pass (ADR-119, feature D62, task 0872; D63 task
-# 0915 remediation folds the evidence contract into a workflow-owned script).
-#
-# Owns a lifecycle boundary no per-task graph owns: the repo-wide checks whose
-# invariant spans the repository rather than a single task's diff. They run
-# once per feature, deliberately the slow pass; `feature-lifecycle`'s verifying
-# entry invokes this workflow (task 0880 caller wiring), and its verifying→done
-# guard refuses to complete the feature until this pass records PASS (ADR-119
-# consequence: a feature is not done until it passes).
-#
-# Run: spur workflow run feature-verification.yaml --vars '{"featureId":"D63"}'
-#
-# No project-side override is required (task 1185, A33). Since the pass moved into the
-# application (1176 / efd78f058) the bundled definition owns it end to end, so a
-# project-layer copy of this file (plus a rooted port under `.spur/scripts/`) is a
-# leftover — the port was written against an entry export contract that has since
-# changed. Remove the override so this definition applies, or migrate the port to the
-# current app-owned operation `runFeatureVerification` (the generated inline bundle's
-# export). If a stale consumer is still reached, feature-lifecycle's `verifying` entry
-# names it: the override path, the consumer script, the export it requires that the
-# shipped entry no longer provides, and the entry path. Reinstalling or upgrading the
-# plugin cannot supply a retired export — only the two remedies above can.
-#
-# Shape: verify -> done | failed. The onEnter step runs `spur feature verify`
-# (D63 task 0915; script-absorption PR-5 retired the feature-verification-steps
-# plugin script): it
-# resolves this very definition for the verifier identity (name, source path,
-# layer, definition digest), records the RUNNING receipt (run-scoped +
-# feature-latest copies), registers the run-scoped receipt as a run artifact,
-# runs the configured verification command via the safe launch splitter, and
-# completes the receipt PASS/FAIL with the after-pass proof-input digest. A
-# changed tree during the pass records FAIL.
-#
-# Reliability (aligned with task-pipeline / ADR-043): no agent.run nodes; the
-# verification command comes from `vars.verificationCmd` below and is never
-# interpolated through a shell. The always-exit-0 onEnter means missing,
-# corrupt or FAIL evidence routes to `failed` via the guard (fail-closed),
-# never a silent PASS; infrastructure errors exit nonzero and surface.
-"$schema": "@gobing-ai/spur/schemas/state-machine-workflow.schema.json"
-kind: state-machine
-name: feature-verification
-version: "1"
-description: "Feature-scoped verification pass (ADR-119): runs the repo-wide check set once per feature and records a bound PASS/FAIL evidence receipt. Invoked by feature-lifecycle's verifying entry."
-iterationBound: 2
-initialState: verify
-terminalStates:
-  - done
-  - failed
-failureStates:
-  - failed
-vars:
-  featureId: "X"
-  spurBin: "spur"
-  verificationCmd: "bun run spur-check"
-  __runId: ""
-
-states:
-  - id: verify
-    description: >
-      Run the repo-wide check set via `spur feature verify`, which
-      records the bound evidence receipt (verifier identity, checked-input
-      digest, run identity) and the coarse status file, always exit 0 so the
-      transition guard routes missing/corrupt/FAIL to `failed`.
-    onEnter:
-      - kind: shell
-        options:
-          command: >-
-            mkdir -p .spur/run; $spurBin feature verify "$featureId" --run-id "$__runId" --no-logo || printf 'FAIL feature-verification failed closed — spur feature verify exited nonzero\n' > ".spur/run/$__runId-feature-verification.status"; exit 0
-
-  - id: done
-    description: Terminal — repo-wide checks passed and the receipt is bound.
-
-  - id: failed
-    description: Terminal — repo-wide checks failed or the evidence is missing/corrupt.
-
-transitions:
-  - from: verify
-    to: done
-    description: Repo-wide checks passed — `spur feature verify` completed the receipt with PASS.
-    guard:
-      kind: shell
-      options:
-        command: 'test "$(cat .spur/run/$__runId-feature-verification.status 2>/dev/null)" = PASS'
-  - from: verify
-    to: failed
-    terminalReason: failed-check
-    description: Repo-wide checks failed (or the evidence is missing/corrupt) — stop at failed.
-    guard:
-      kind: always