@gobing-ai/knowledge-kit 0.0.16 → 0.0.18

package/plugins/generations/news-report-gen/src/index.ts

@@ -17,7 +17,12 @@ import { echoError } from '@gobing-ai/ts-utils';
  *   workflow from the filter Content's metadata.docs). Scores live in
  *   `metadata.scores` (quality/importance/urgency/impact 0-5).
  * - `NEWS_REPORT_REJECTED_FILE` — the filter's rejected audit path
- *   (`2-plan/candidates.rejected.json`, RejectedDoc[] of {doc, reasons});
+ *   (`2-plan/candidates.rejected.json`, RejectedDoc[] of {doc, reasons})
+ * - `NEWS_REPORT_BLENDED_FILE` — the collect stage's blended fan-in output
+ *   (`1-ingest/<date>_02_collect_blended.json`); absent or unreadable -> the
+ *   语料构成 section is omitted, never throw.
+ * - `NEWS_REPORT_QC_FILE` — the generate stage's QC audit path
+ *   (`3-audio/<date>_11_generate_content.json`); absent -> the 音频 QC block is omitted;
  *   absent or unreadable -> reject counts render as 0, never throw.
  * - `NEWS_REPORT_TIMING_FILE` — `<work_dir>/step-timing.json` JSONL of
  *   {step, startedAt, endedAt} appended by the workflow shell steps; missing
@@ -144,6 +149,51 @@ interface RejectedAudit {
     reasons: string[];
 }
 
+/** Generate-stage audio QC summary rendered into the run report (task 0139 R5b). */
+export interface QcSummary {
+    passed: boolean;
+    overallScore: number;
+    /** Per-issue-type counts, most frequent first; `duration_anomaly: <detail>` counts as its type. */
+    issues: { type: string; count: number }[];
+}
+
+/**
+ * Read the generate stage's QC audit (`<run_date>_11_generate_content.json`) (task 0139 R5b).
+ *
+ * Best-effort by contract: an absent, unreadable, or malformed file returns `null` and the report
+ * omits the section — a run report must never fail a run. Issue types are the text before the first
+ * `:` so a detailed `duration_anomaly: expected …` rolls up under one row.
+ */
+export async function readQcSummary(path: string | undefined): Promise<QcSummary | null> {
+    if (!path || path.trim() === '') return null;
+    try {
+        const parsed = JSON.parse(await Bun.file(path).text()) as { metadata?: { qc?: unknown } } | null;
+        const qc = parsed?.metadata?.qc;
+        if (qc === null || typeof qc !== 'object') return null;
+        const record = qc as { passed?: unknown; overallScore?: unknown; segmentAudits?: unknown };
+        const counts = new Map<string, number>();
+        const audits = Array.isArray(record.segmentAudits) ? record.segmentAudits : [];
+        for (const audit of audits) {
+            const issues = (audit as { issues?: unknown } | null)?.issues;
+            if (!Array.isArray(issues)) continue;
+            for (const issue of issues) {
+                if (typeof issue !== 'string') continue;
+                const type = issue.split(':')[0]?.trim() || issue;
+                counts.set(type, (counts.get(type) ?? 0) + 1);
+            }
+        }
+        return {
+            passed: record.passed === true,
+            overallScore: typeof record.overallScore === 'number' ? record.overallScore : 0,
+            issues: [...counts.entries()]
+                .map(([type, count]) => ({ type, count }))
+                .sort((a, b) => b.count - a.count || a.type.localeCompare(b.type)),
+        };
+    } catch {
+        return null;
+    }
+}
+
 /** Parse the timing JSONL; unreadable/missing -> [] (never throw). Last entry per step wins. */
 export async function readTiming(path: string | undefined): Promise<TimingEntry[]> {
     if (!path || path.trim() === '') return [];
@@ -180,7 +230,13 @@ function durationMs(entry: TimingEntry): number | null {
 export function renderReportMarkdown(
     docs: Doc[],
     date: string,
-    options: { rejected?: { doc: Doc; reasons: string[] }[]; timing?: TimingEntry[] } = {},
+    options: {
+        rejected?: { doc: Doc; reasons: string[] }[];
+        timing?: TimingEntry[];
+        qc?: QcSummary | null;
+        planAudit?: PlanAuditRow[] | null;
+        blended?: BlendedDoc[] | null;
+    } = {},
 ): string {
     const lines: string[] = [`# 每日 AI 语音运行报告 — ${date}`, ''];
     lines.push('## 选稿评分（保留候选）', '');
@@ -221,6 +277,52 @@ export function renderReportMarkdown(
     lines.push(`| category allowlist | — | ${counts.category} |`);
     lines.push('');
 
+    const blended = options.blended ?? null;
+    if (blended !== null && blended.length > 0) {
+        // 20260917 funnel: selection can only be judged against what arrived — the blended
+        // input's source/category composition exposes the uncategorized mass that plan
+        // under-ranks (e.g. 47 of 52 docs with no category -> 2 selected).
+        const comp = corpusComposition(blended);
+        lines.push(`## 语料构成（fan-in 输入，共 ${comp.total} 条）`, '');
+        lines.push('| 来源 | 条数 |', '| --- | --- |');
+        for (const g of comp.sources) lines.push(`| ${g.key} | ${g.count} |`);
+        lines.push('');
+        lines.push('| 类别 | 条数 |', '| --- | --- |');
+        for (const g of comp.categories) lines.push(`| ${g.key} | ${g.count} |`);
+        lines.push('');
+    }
+
+    const planAudit = options.planAudit ?? null;
+    if (planAudit !== null && planAudit.length > 0) {
+        // 20260917 funnel: the report only showed the 2 survivors — every fetched title, its
+        // scores and its elimination reason now render here (selection is auditable end to end).
+        lines.push(`## 选稿漏斗（全量审计，共 ${planAudit.length} 条）`, '');
+        lines.push(
+            '| 来源 | 标题 | 类别 | q | i | u | im | score | 去向 |',
+            '| --- | --- | --- | --- | --- | --- | --- | --- | --- |',
+        );
+        for (const row of planAudit) {
+            const s = row.scores ?? {};
+            const title = (row.title || row.id).replace(/\|/g, '\\|').slice(0, 60);
+            lines.push(
+                `| ${row.source} | ${title} | ${row.category} | ${s.quality ?? '—'} | ${s.importance ?? '—'} | ${s.urgency ?? '—'} | ${s.impact ?? '—'} | ${row.planScore ?? '—'} | ${row.disposition} |`,
+            );
+        }
+        lines.push('');
+    }
+
+    const qc = options.qc ?? null;
+    if (qc !== null) {
+        // 0139 R5b: the audio QC verdict is otherwise invisible in the report — this run published
+        // an episode whose audit said `passed:false`, and nothing but the artifact recorded it.
+        lines.push('## 音频 QC', '');
+        lines.push('| 指标 | 值 |', '| --- | --- |');
+        lines.push(`| 综合评分 | ${qc.overallScore} |`);
+        lines.push(`| 通过 | ${qc.passed ? '是' : '否'} |`);
+        for (const issue of qc.issues) lines.push(`| ${issue.type} | ${issue.count} |`);
+        lines.push('');
+    }
+
     const timing = options.timing ?? [];
     if (timing.length > 0) {
         lines.push('## 步耗时', '');
@@ -240,22 +342,109 @@ export function renderReportMarkdown(
     return lines.join('\n');
 }
 
-/** Read the rejected audit; absent/unreadable/malformed -> [] (never throw). */
+/**
+ * Read the rejected audit; absent/unreadable/malformed -> [] (never throw).
+ *
+ * Two writer shapes: a bare `RejectedAudit[]` (older producers) and episode-plan-gen's
+ * `{ rejected, config, total }` envelope (`processFilterIO` — the live one). Reading only the
+ * array shape reported 0 rejections for every real run (task 0138 D1).
+ */
 export async function readRejectedAudit(path: string | undefined): Promise<RejectedAudit[]> {
     if (!path || path.trim() === '') return [];
     try {
-        const parsed = JSON.parse(await Bun.file(path).text());
-        return Array.isArray(parsed) ? (parsed as RejectedAudit[]) : [];
+        const parsed: unknown = JSON.parse(await Bun.file(path).text());
+        if (Array.isArray(parsed)) return parsed as RejectedAudit[];
+        const rejected = (parsed as { rejected?: unknown } | null)?.rejected;
+        return Array.isArray(rejected) ? (rejected as RejectedAudit[]) : [];
     } catch {
         return [];
     }
 }
 
+/** One row of episode-plan-gen's `<out>.audit.json` selection trail (plan mode). */
+export interface PlanAuditRow {
+    id: string;
+    source: string;
+    title: string;
+    category: string;
+    scores: Record<string, number>;
+    planScore: number | null;
+    disposition: 'gate' | 'url-merge' | 'title-merge' | 'cap' | 'topN' | 'selected';
+}
+
+/** Read the plan-mode audit envelope `{ total, rows }`; absent/unreadable/malformed -> null (never throw). */
+export async function readPlanAudit(path: string | undefined): Promise<PlanAuditRow[] | null> {
+    if (!path || path.trim() === '') return null;
+    try {
+        const parsed: unknown = JSON.parse(await Bun.file(path).text());
+        const rows = (parsed as { rows?: unknown } | null)?.rows;
+        return Array.isArray(rows) ? (rows as PlanAuditRow[]) : null;
+    } catch {
+        return null;
+    }
+}
+
+/** Minimal shape the 语料构成 section needs from a blended fan-in doc (tolerant on purpose). */
+export interface BlendedDoc {
+    title?: unknown;
+    id?: unknown;
+    source?: unknown;
+    category?: unknown;
+    metadata?: { source?: unknown; category?: unknown };
+}
+
+export interface CorpusCount {
+    key: string;
+    count: number;
+}
+
+/** Read the blended fan-in input; absent/unreadable/malformed/not-an-array -> null (never throw). */
+export async function readBlendedCorpus(path: string | undefined): Promise<BlendedDoc[] | null> {
+    if (!path || path.trim() === '') return null;
+    try {
+        const parsed: unknown = JSON.parse(await Bun.file(path).text());
+        const docs = Array.isArray(parsed) ? parsed : (parsed as { docs?: unknown } | null)?.docs;
+        return Array.isArray(docs) ? (docs as BlendedDoc[]) : null;
+    } catch {
+        return null;
+    }
+}
+
+/** Tally blended docs by source and by category (missing fields bucket as （无）), most frequent first. */
+export function corpusComposition(docs: BlendedDoc[]): {
+    total: number;
+    sources: CorpusCount[];
+    categories: CorpusCount[];
+} {
+    const tally = (pick: (d: BlendedDoc) => unknown): CorpusCount[] => {
+        const counts = new Map<string, number>();
+        for (const d of docs) {
+            const raw = pick(d);
+            const key = typeof raw === 'string' && raw.trim() !== '' ? raw : '（无）';
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+        }
+        return [...counts.entries()]
+            .map(([key, count]) => ({ key, count }))
+            .sort((a, b) => b.count - a.count || (a.key < b.key ? -1 : 1));
+    };
+    return {
+        total: docs.length,
+        sources: tally((d) => d.metadata?.source ?? d.source),
+        categories: tally((d) => d.metadata?.category ?? d.category),
+    };
+}
+
 /** Build the report Content from a kept-candidate Doc[]. */
 export function docsToContent(
     docs: Doc[],
     date: string,
-    options: { rejected?: { doc: Doc; reasons: string[] }[]; timing?: TimingEntry[] },
+    options: {
+        rejected?: { doc: Doc; reasons: string[] }[];
+        timing?: TimingEntry[];
+        qc?: QcSummary | null;
+        planAudit?: PlanAuditRow[] | null;
+        blended?: BlendedDoc[] | null;
+    },
 ): Content {
     return ContentSchema.parse({
         title: `每日 AI 语音运行报告 — ${date}`,
@@ -274,7 +463,10 @@ export async function processGeneratorIO(inputPath: string, outputPath: string):
     const docs = DocListSchema.parse(await readJsonFile(inputPath));
     const rejected = await readRejectedAudit(process.env.NEWS_REPORT_REJECTED_FILE);
     const timing = await readTiming(process.env.NEWS_REPORT_TIMING_FILE);
-    const content = docsToContent(docs, dateFromEnv(), { rejected, timing });
+    const qc = await readQcSummary(process.env.NEWS_REPORT_QC_FILE);
+    const planAudit = await readPlanAudit(process.env.NEWS_REPORT_PLAN_AUDIT_FILE);
+    const blended = await readBlendedCorpus(process.env.NEWS_REPORT_BLENDED_FILE);
+    const content = docsToContent(docs, dateFromEnv(), { rejected, timing, qc, planAudit, blended });
     const fs = createNodeFileSystem();
     const outDir = dirname(outputPath);
     if (outDir && outDir !== '.') await fs.ensureDir(outDir);

package/plugins/generations/omni-voice-gen/src/omni_voice_gen/pipeline.py

@@ -210,7 +210,7 @@ def _render(
             "profile": resolve_profile(profile, registry),
             "instruct": segment_instruct,
             "seed": None if segment.seed is None else int(segment.seed),
-            "speed": None,
+            "speed": None if segment.speed is None else float(segment.speed),
         }
         wav, duration, retries, transcription, dip = _render_verified(backend, spec)
 
@@ -303,3 +303,19 @@ def run(
     except BaseException:
         _delete(out_path, audio_path, mp3_path)
         raise
+
+    # R5a (task 0139): repetition is the one QC issue the verify loop cannot fix and the one that
+    # damages credibility on air, so it fails the run — but only AFTER content.json is on disk, and
+    # outside the delete-on-failure try above, so the operator can inspect the audit that condemned
+    # it. The audio and MP3 stay too: this is a review stop, not a corrupt-artifact cleanup. Recovery
+    # is HITL YAML inspection plus a re-run; Q&A item 3 ships this with no override knob.
+    repeated = [
+        audit.get("segmentIndex")
+        for audit in content.metadata.get("qc", {}).get("segmentAudits", [])
+        if "repetition_detected" in audit.get("issues", [])
+    ]
+    if repeated:
+        indexes = ", ".join(str(index) for index in repeated)
+        raise RuntimeError(
+            f"segment(s) {indexes} carry repetition_detected — content.json written for inspection"
+        )

package/plugins/generations/omni-voice-gen/src/omni_voice_gen/qc.py

@@ -24,13 +24,6 @@ MAX_RATE_ZH = 15.0
 MAX_RATE_EN = 30.0
 MAX_RATE_OTHER = 25.0
 
-MAX_DURATION_ZH = 15.0
-MAX_DURATION_EN = 30.0
-MAX_DURATION_OTHER = 20.0
-
-MAX_DURATION_ZH_DIVISOR = 15.0
-MAX_DURATION_EN_DIVISOR = 20.0
-MAX_DURATION_OTHER_DIVISOR = 15.0
 
 RE_CHAR_RUN = re.compile(r"(.)\1{2,}", re.DOTALL)
 RE_WORD_RUN = re.compile(r"(.{2,3}?)\1{2,}", re.DOTALL)
@@ -185,21 +178,10 @@ def audit_voice_segments(
         abs_anomaly = duration > max_sec + MAX_ABS_DIFF_SEC if max_sec > 0 else False
         max_rate = MAX_RATE_ZH if language.startswith("zh") else MAX_RATE_EN if language.startswith("en") else MAX_RATE_OTHER
         rate_anomaly = duration > 0 and (len(text) / duration) > max_rate
-        max_possible = (
-            MAX_DURATION_ZH
-            if language.startswith("zh")
-            else MAX_DURATION_EN
-            if language.startswith("en")
-            else MAX_DURATION_OTHER
-        ) + len(text) / (
-            MAX_DURATION_ZH_DIVISOR
-            if language.startswith("zh")
-            else MAX_DURATION_EN_DIVISOR
-            if language.startswith("en")
-            else MAX_DURATION_OTHER_DIVISOR
-        )
-        abs_ceiling_anomaly = duration > max_possible
-        duration_anomaly = ratio_anomaly or abs_anomaly or rate_anomaly or abs_ceiling_anomaly
+        # The former abs-ceiling term (duration > MAX_DURATION_<lang> + len(text)/<divisor>)
+        # compared against a fastest-speech floor, so any segment over ~39 chars flagged even
+        # when inside its expected range; genuinely overlong audio stays covered by ratio/abs/rate.
+        duration_anomaly = ratio_anomaly or abs_anomaly or rate_anomaly
         if duration_anomaly:
             issues.append(
                 f"duration_anomaly: expected {min_sec:.2f}s-{max_sec:.2f}s, got {duration:.2f}s"

package/plugins/generations/omni-voice-gen/src/omni_voice_gen/voicescript.py

@@ -70,6 +70,7 @@ class VoiceSegment:
     engine: Any = None
     language: Any = None
     gap_ms: Any = None
+    speed: Any = None
     max_chunk_chars: Any = None
     crossfade_ms: Any = None
     personality: Any = None
@@ -334,6 +335,13 @@ def validate_voice_script(script: VoiceScript, sink: WarnSink) -> None:
         ):
             raise ValueError("gap_ms must be non-negative")
 
+        if segment.speed is not None and (
+            isinstance(segment.speed, bool)
+            or not isinstance(segment.speed, (int, float))
+            or not 0.5 <= float(segment.speed) <= 2.0
+        ):
+            raise ValueError("speed must be between 0.5 and 2.0")
+
         if segment.seed is not None and (not _is_int(segment.seed) or segment.seed < 0):
             raise ValueError("seed must be a non-negative integer")