osborn 0.9.251 → 0.9.252

package/dist/content/compaction-lens-worker.d.ts

@@ -13,10 +13,15 @@
  *       copy to <path> instead of content-profile.md and leaves the HWM alone.
  *   node compaction-lens-worker.js --library <sessionId> [--cwd <dir>] [--dry] [--out-dir <dir>]
  *       LIBRARY step only (manual / dry run). Takes the per-project lock itself.
- * Per-compaction runs do TWO independent, fail-open steps under one lock:
+ *   node compaction-lens-worker.js --content <sessionId> [--cwd <dir>] [--dry] [--research-refresh]
+ *       CONTENT step (Stage A) only: manual / the per-project "Refresh research"
+ *       backend. --dry = no ingest (still spends, capped). Takes the per-project lock.
+ * Per-compaction runs do THREE independent, fail-open steps under one lock:
  *   1. the content lens (content-profile.md + HWM), unchanged;
  *   2. the library step (lens-library.ts): one period-map page for the period
- *      that just ended + INDEX.md. A failure in either never stops the other.
+ *      that just ended + INDEX.md;
+ *   3. the content step (content-run.ts, Stage A): research → briefs → scripts →
+ *      checks → draft ingest for that period. A failure in any never stops the others.
  * Fully self-contained: top-level try/catch, redacted log in the project dir,
  * refreshes + releases the per-project lock, always exits.
  */

package/dist/content/compaction-lens-worker.js

@@ -13,10 +13,15 @@
  *       copy to <path> instead of content-profile.md and leaves the HWM alone.
  *   node compaction-lens-worker.js --library <sessionId> [--cwd <dir>] [--dry] [--out-dir <dir>]
  *       LIBRARY step only (manual / dry run). Takes the per-project lock itself.
- * Per-compaction runs do TWO independent, fail-open steps under one lock:
+ *   node compaction-lens-worker.js --content <sessionId> [--cwd <dir>] [--dry] [--research-refresh]
+ *       CONTENT step (Stage A) only: manual / the per-project "Refresh research"
+ *       backend. --dry = no ingest (still spends, capped). Takes the per-project lock.
+ * Per-compaction runs do THREE independent, fail-open steps under one lock:
  *   1. the content lens (content-profile.md + HWM), unchanged;
  *   2. the library step (lens-library.ts): one period-map page for the period
- *      that just ended + INDEX.md. A failure in either never stops the other.
+ *      that just ended + INDEX.md;
+ *   3. the content step (content-run.ts, Stage A): research → briefs → scripts →
+ *      checks → draft ingest for that period. A failure in any never stops the others.
  * Fully self-contained: top-level try/catch, redacted log in the project dir,
  * refreshes + releases the per-project lock, always exits.
  */
@@ -27,15 +32,36 @@ import { resolveSessionDb } from './lens-db.js';
 import { acquireLock, refuseOutPath, releaseLock, resolveProjectDir, touchLock } from './lens-paths.js';
 import { logLine } from './lens-profile.js';
 import { runLibraryStep } from './lens-library.js';
-// ≤2 big windows + reduce at ≤6 min/call, then the library step (1 call ≤6 min + model meta).
-const INCREMENTAL_TIMEOUT_MS = 35 * 60_000;
+import { runContentStep } from './content-run.js';
+// ≤2 big windows + reduce at ≤6 min/call, then the library step (1 call ≤6 min + model meta),
+// then the content step (Stage A: ~10-18 small calls, ≤4 min each, capped in $).
+const INCREMENTAL_TIMEOUT_MS = 45 * 60_000;
 const BACKFILL_TIMEOUT_MS = 3 * 60 * 60_000;
 const LIBRARY_TIMEOUT_MS = 15 * 60_000;
+const CONTENT_TIMEOUT_MS = 20 * 60_000;
 function argVal(argv, flag) {
     const i = argv.indexOf(flag);
     return i >= 0 ? argv[i + 1] : undefined;
 }
 function parseJob(argv) {
+    if (argv[0] === '--content') {
+        const sessionId = argv[1];
+        if (!sessionId || sessionId.startsWith('--'))
+            throw new Error('usage: --content <sessionId> [--cwd <dir>] [--dry] [--research-refresh]');
+        const cwd = argVal(argv, '--cwd');
+        const db = resolveSessionDb(sessionId, null, cwd);
+        const projectDir = db ? dirname(dirname(dirname(db))) : null;
+        if (!projectDir || !acquireLock(projectDir))
+            throw new Error(`content: project dir ${projectDir ?? '(none)'} missing or locked`);
+        return {
+            opts: { sessionId, cwd, mode: 'incremental' },
+            kind: 'content',
+            content: { dry: argv.includes('--dry'), researchRefresh: argv.includes('--research-refresh') },
+            lockDir: projectDir,
+            logDir: projectDir,
+            timeoutMs: CONTENT_TIMEOUT_MS,
+        };
+    }
     if (argv[0] === '--library') {
         const sessionId = argv[1];
         if (!sessionId || sessionId.startsWith('--'))
@@ -135,7 +161,7 @@ async function main() {
         const t0 = Date.now();
         let lensErr = null;
         // Step 1 — content lens (skipped by the --library entry).
-        if (job.kind !== 'library') {
+        if (job.kind !== 'library' && job.kind !== 'content') {
             try {
                 const r = await runCompactionLens({
                     ...job.opts,
@@ -155,7 +181,8 @@ async function main() {
         }
         // Step 2 — library page for the period that just ended (per-compaction + --library only; never backfill).
         // runLibraryStep never throws; any failure is logged and the worker still exits cleanly.
-        if (job.opts.mode === 'incremental') {
+        let libPeriod = null;
+        if (job.opts.mode === 'incremental' && job.kind !== 'content') {
             if (lockDir)
                 touchLock(lockDir);
             const lib = await runLibraryStep({
@@ -169,12 +196,38 @@ async function main() {
             logLine(logDir, `session ${sid}: library status=${lib.status} cost=$${lib.costUsd.toFixed(4)}${lib.page ? ` page=${lib.page}` : ''}`);
             if (job.kind === 'library')
                 process.stdout.write(`${JSON.stringify({ status: lib.status, page: lib.page, index: lib.index, period: lib.period, cost: lib.costUsd, errors: lib.errors })}\n`);
+            if (lib.status === 'written')
+                libPeriod = lib.period;
+        }
+        // Step 3 — content plan (Stage A) for the period (per-compaction + --content; never backfill / --library).
+        // runContentStep never throws; the try is belt and braces so nothing here can fail the worker.
+        if (job.opts.mode === 'incremental' && job.kind !== 'library') {
+            try {
+                if (lockDir)
+                    touchLock(lockDir);
+                const c = await runContentStep({
+                    sessionId: job.opts.sessionId,
+                    projectDir: lockDir,
+                    cwd: job.opts.cwd,
+                    period: libPeriod,
+                    dry: job.content?.dry,
+                    researchRefresh: job.content?.researchRefresh,
+                    keepAlive: () => lockDir && touchLock(lockDir),
+                    log: m => logLine(logDir, `session ${sid} [content]: ${m}`),
+                });
+                logLine(logDir, `session ${sid}: content status=${c.status} pieces=${c.pieces.length} cost=$${c.costUsd.toFixed(4)}${c.capHit ? ` cap=${c.capHit}` : ''}`);
+                if (job.kind === 'content')
+                    process.stdout.write(`${JSON.stringify(c)}\n`);
+            }
+            catch (err) {
+                logLine(logDir, `content step error (ignored): ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
         return lensErr ? 1 : 0;
     }
     catch (err) {
         logLine(logDir, `worker error: ${err instanceof Error ? err.stack || err.message : String(err)}`);
-        if (err instanceof Error && /^(backfill|library):/.test(err.message))
+        if (err instanceof Error && /^(backfill|library|content):/.test(err.message))
             process.stderr.write(`${err.message}\n`);
         return 1;
     }

package/dist/content/compaction-lens.js

@@ -14,12 +14,14 @@
  *  7. HN gap check (fail-open), optional recording, client-redact the entry,
  *     APPEND to <project>/content-profile.md (or a scratch file); advance HWM
  */
-import { dirname } from 'node:path';
+import { basename, dirname } from 'node:path';
 import { loadConversationRows, packWindows, resolveSessionDb } from './lens-db.js';
 import { buildRecordIndex, explainQuote, parseJsonObject, readAngles, readCapabilities, splitByEvidence, verifyItems, } from './lens-quotes.js';
 import { Budget, chat, getModelInfo, mapPrompt, reducePrompt, windowTokensFor } from './lens-model.js';
 import { DENYLIST_FILE, hasBillingQuote, isBillingAngle, isBillingCapability, loadClientRedactor } from './lens-redact.js';
 import { gapCheck } from './lens-hn.js';
+import { makeScrubber } from './content-redact.js';
+import { gateQueries, privateSegments } from './content-query-gate.js';
 import { alignRecording, findSessionRecording } from './lens-audio.js';
 import { appendProfile, formatEntry, writeScratch } from './lens-profile.js';
 import { findTranscriptBySessionId, isProjectDir, readHwm, refuseOutPath, resolveProjectDir, writeHwm } from './lens-paths.js';
@@ -197,8 +199,17 @@ export async function runCompactionLens(opts) {
         bumpHwm(covered);
         return { ...r, status: 'nothing-survived' };
     }
+    // Outbound HN queries are model output built from session text: scrub, then the same
+    // deterministic gate research uses (project basename / cwd segments never leave the machine).
+    // gapCheck([]) makes no fetch and returns its neutral "no queries" result.
+    const sc = makeScrubber(projectDir);
+    const privateTerms = privateSegments([opts.cwd, process.env.OSBORN_CWD, basename(projectDir)]);
     for (const a of fin.c.angles) {
-        r.angles.push({ title: a.title, why: a.why, quotes: a.quotes, gap: await gapCheck(a.queries) });
+        const scrubbed = (a.queries ?? []).map(q => sc.scrub(String(q ?? '')).replace(/\[[^\]]*\]/g, ' ').replace(/\s+/g, ' ').trim()).filter(q => q.length >= 3);
+        const queries = gateQueries(scrubbed, privateTerms);
+        if ((a.queries ?? []).length > queries.length)
+            log(`gap check "${a.title.slice(0, 60)}": ${(a.queries ?? []).length - queries.length} query(ies) held back by the outbound gate`);
+        r.angles.push({ title: a.title, why: a.why, quotes: a.quotes, gap: await gapCheck(queries) });
     }
     r.capabilities = fin.c.capabilities.map(c => ({
         name: c.name, did: c.did, evidence: c.evidence, proof: c.proof, quotes: c.quotes,

package/dist/content/content-brief.d.ts

@@ -0,0 +1,90 @@
+/**
+ * content-brief.ts — Stage A planning: which pieces a period yields, and the
+ * brief for each (rules §2-§4, §8a).
+ *
+ *   planPieces()  one OpenRouter call over the period's library page →
+ *                 ≤1 highlight + ≤3 how-to candidates, each with a subtopic,
+ *                 1-2 search queries and the row range it is built from.
+ *   buildBriefs() one call over the candidates + their research digests →
+ *                 per piece: VIEWER (from research), situation, tier, format
+ *                 (from the catalog), the research problems it speaks to.
+ * Deterministic validation after each call: unknown tiers/formats, rows outside
+ * the period, or a missing viewer fall back to safe defaults rather than failing.
+ * Throws CapError (cap) or Error (model) — content-run records either.
+ */
+import { type ContentLlmOptions } from './content-llm.js';
+import { type Tier } from './content-script-rules.js';
+import type { TopicResearch } from './content-research.js';
+export declare const OWNER_FILE = "content-owner.json";
+export interface PieceCandidate {
+    id: string;
+    kind: Tier;
+    subtopic: string;
+    story: string;
+    queries: string[];
+    fromRow: number;
+    toRow: number;
+    why: string;
+}
+export interface Owner {
+    name: string;
+    handle?: string;
+}
+export interface Stake {
+    /** What is measured, e.g. "facts recalled after compaction". */
+    quantity: string;
+    before: string;
+    after: string;
+}
+export interface Brief {
+    id: string;
+    tier: Tier;
+    subtopic: string;
+    story: string;
+    fromRow: number;
+    toRow: number;
+    /** WHO is consuming it (rules §4), picked from the research. */
+    viewer: string;
+    /** What that viewer is living through. */
+    situation: string;
+    /** Format id from FORMAT_CATALOG. */
+    format: string;
+    angle: string;
+    /** Research problems (§8a) the piece speaks to. */
+    problems: string[];
+    /** WHAT-WORKS rule 1: the before -> after quantity or verdict the piece shows. Null = no provable stake (not scripted). */
+    stake: Stake | null;
+    researchKey: string;
+    owner: Owner | null;
+    autoGenerated: true;
+}
+/** Developer who owns the pieces (rules §6): env first, then <project>/content-owner.json. Null when unknown. */
+export declare function loadOwner(projectDir: string | null): Owner | null;
+export declare const PLAN_SYSTEM: string;
+export declare function planPrompt(page: string, maxHighlights: number, maxHowtos: number, range: {
+    from: number;
+    to: number;
+}): string;
+export declare function validateCandidates(raw: unknown, range: {
+    from: number;
+    to: number;
+}, maxPieces: number): PieceCandidate[];
+/** Plan this period's pieces. One model call. */
+export declare function planPieces(page: string, range: {
+    from: number;
+    to: number;
+}, maxPieces: number, llm: ContentLlmOptions): Promise<{
+    candidates: PieceCandidate[];
+    costUsd: number;
+}>;
+export declare const BRIEF_SYSTEM: string;
+export declare function catalogText(tier: Tier): string;
+export declare function briefPrompt(cands: PieceCandidate[], research: Map<string, TopicResearch>): string;
+/** A stake needs all three parts, and before must differ from after. */
+export declare function validStake(v: unknown): Stake | null;
+export declare function validateBriefs(raw: unknown, cands: PieceCandidate[], research: Map<string, TopicResearch>, owner: Owner | null): Brief[];
+/** Build all briefs for a period in one model call. */
+export declare function buildBriefs(cands: PieceCandidate[], research: Map<string, TopicResearch>, owner: Owner | null, llm: ContentLlmOptions): Promise<{
+    briefs: Brief[];
+    costUsd: number;
+}>;

package/dist/content/content-brief.js

@@ -0,0 +1,165 @@
+/**
+ * content-brief.ts — Stage A planning: which pieces a period yields, and the
+ * brief for each (rules §2-§4, §8a).
+ *
+ *   planPieces()  one OpenRouter call over the period's library page →
+ *                 ≤1 highlight + ≤3 how-to candidates, each with a subtopic,
+ *                 1-2 search queries and the row range it is built from.
+ *   buildBriefs() one call over the candidates + their research digests →
+ *                 per piece: VIEWER (from research), situation, tier, format
+ *                 (from the catalog), the research problems it speaks to.
+ * Deterministic validation after each call: unknown tiers/formats, rows outside
+ * the period, or a missing viewer fall back to safe defaults rather than failing.
+ * Throws CapError (cap) or Error (model) — content-run records either.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { llmJson } from './content-llm.js';
+import { briefRules, FORMAT_CATALOG, TIER_TEMPLATES } from './content-script-rules.js';
+import { researchDigest } from './content-research.js';
+import { gateQueries } from './content-query-gate.js';
+export const OWNER_FILE = 'content-owner.json';
+const PAGE_MAX_CHARS = 60_000;
+const str = (v, n = 300) => String(v ?? '').replace(/\s+/g, ' ').trim().slice(0, n);
+/** Developer who owns the pieces (rules §6): env first, then <project>/content-owner.json. Null when unknown. */
+export function loadOwner(projectDir) {
+    const name = str(process.env.OSBORN_CONTENT_OWNER_NAME, 80);
+    if (name)
+        return { name, handle: str(process.env.OSBORN_CONTENT_OWNER_HANDLE, 80) || undefined };
+    if (!projectDir)
+        return null;
+    try {
+        const p = join(projectDir, OWNER_FILE);
+        if (!existsSync(p))
+            return null;
+        const o = JSON.parse(readFileSync(p, 'utf-8'));
+        const n = str(o?.name, 80);
+        return n ? { name: n, handle: str(o?.handle ?? o?.github, 80) || undefined } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const PLAN_SYSTEM = 'You plan short developer videos from ONE period of a developer\'s work session with an AI coding agent. ' +
+    'You only use what the period page shows. Reply with ONE JSON object only.';
+export function planPrompt(page, maxHighlights, maxHowtos, range) {
+    return [
+        'Below is the library page for one work period (goal, ranked work, arc, stories, quotes with row numbers).',
+        '<period_page>',
+        page.length > PAGE_MAX_CHARS ? page.slice(0, PAGE_MAX_CHARS) : page,
+        '</period_page>',
+        `TASK: pick at most ${maxHighlights} highlight and at most ${maxHowtos} how-to piece(s).`,
+        `- highlight = ${TIER_TEMPLATES.highlight.promise} Pick the period's strongest arc.`,
+        `- howto = ${TIER_TEMPLATES.howto.promise} Only for something concrete someone else could copy. Skip if the period has none.`,
+        'Each piece: {"id": "p1"..., "kind": "highlight"|"howto", "subtopic": the problem space in 3-8 words a stranger would search, ' +
+            '"story": the story title from the page it is built on, "queries": 1-2 SHORT searches (2-4 words) for the underlying general problem, phrased the way outsiders search HN / GitHub issues ' +
+            '(e.g. "claude code compaction", "api key machine auth"); no project-specific names or phrases, ' +
+            `"from_row", "to_row": the row range on the page it comes from (within ${range.from}-${range.to}), "why": one line}.`,
+        'Never plan pieces about invoices, payments owed, contracts or rates. Keep [client]-style tags; never guess names.',
+        'Output ONLY: {"pieces": [...]}',
+    ].join('\n\n');
+}
+export function validateCandidates(raw, range, maxPieces) {
+    const list = Array.isArray(raw?.pieces) ? raw.pieces : Array.isArray(raw) ? raw : [];
+    const out = [];
+    let highlights = 0;
+    let howtos = 0;
+    for (const p of list) {
+        const k = str(p?.kind ?? p?.tier, 20).toLowerCase().replace(/[^a-z]/g, '');
+        const kind = k.startsWith('highlight') ? 'highlight' : k.startsWith('howto') ? 'howto' : null;
+        const subtopic = str(p?.subtopic ?? p?.topic ?? p?.title ?? p?.story, 120);
+        if (!kind || !subtopic)
+            continue;
+        if (kind === 'highlight' ? highlights >= 1 : howtos >= 3)
+            continue;
+        if (out.length >= maxPieces)
+            break;
+        const a = Math.floor(Number(p?.from_row ?? p?.fromRow));
+        const b = Math.floor(Number(p?.to_row ?? p?.toRow));
+        const fromRow = Number.isFinite(a) && a >= range.from && a <= range.to ? a : range.from;
+        const toRow = Number.isFinite(b) && b >= fromRow && b <= range.to ? b : range.to;
+        // Outbound gate (structure rules here; research re-gates with the project's private path terms before any fetch).
+        const queries = gateQueries((Array.isArray(p?.queries) ? p.queries : []).map((q) => str(q, 60))).slice(0, 2);
+        const fallback = gateQueries([subtopic.split(' ').slice(0, 5).join(' ')]);
+        if (kind === 'highlight')
+            highlights++;
+        else
+            howtos++;
+        out.push({ id: `${kind}-${kind === 'highlight' ? highlights : howtos}`, kind, subtopic, story: str(p?.story, 160), queries: queries.length ? queries : fallback, fromRow, toRow, why: str(p?.why, 200) });
+    }
+    // Highlight first, then how-tos (stable ids → stable content hashes across reruns).
+    return out.sort((x, y) => (x.kind === y.kind ? 0 : x.kind === 'highlight' ? -1 : 1));
+}
+/** Plan this period's pieces. One model call. */
+export async function planPieces(page, range, maxPieces, llm) {
+    if (maxPieces <= 0)
+        return { candidates: [], costUsd: 0 };
+    const maxHow = Math.min(3, Math.max(0, maxPieces - 1));
+    const r = await llmJson(llm, { what: 'plan', system: PLAN_SYSTEM, user: planPrompt(page, 1, maxHow, range), maxOut: 1500, temperature: 0.2 });
+    return { candidates: validateCandidates(r.json, range, maxPieces), costUsd: r.costUsd };
+}
+export const BRIEF_SYSTEM = 'You write video briefs for a developer\'s own short videos. Every brief starts with WHO is watching and what they are living through, ' +
+    'taken from the research given (never invented). Reply with ONE JSON object only.';
+export function catalogText(tier) {
+    return FORMAT_CATALOG.filter(f => f.tiers.includes(tier))
+        .map(f => `- ${f.id}: ${f.name}. Needs: ${f.needs}. Beats: ${f.beats}. Use when: ${f.whenToUse}. Evidence: ${f.evidence}.`)
+        .join('\n');
+}
+export function briefPrompt(cands, research) {
+    const blocks = cands.map(c => {
+        const r = research.get(c.id);
+        return [
+            `PIECE ${c.id} (${TIER_TEMPLATES[c.kind].label})`,
+            `Subtopic: ${c.subtopic}. Built on: "${c.story}" (rows ${c.fromRow}-${c.toRow}). Why: ${c.why}`,
+            r ? researchDigest(r) : 'RESEARCH: none available',
+            `FORMATS that fit this tier:\n${catalogText(c.kind)}`,
+        ].join('\n');
+    });
+    return [
+        ...blocks,
+        `RULES:\n${briefRules().map(r => `- ${r}`).join('\n')}`,
+        'For EACH piece return {"id", "viewer": who is consuming it (role + situation, from the research), "situation": what they are living through (1 line), ' +
+            '"format": one format id from its list, "angle": the one-line promise of the piece to that viewer, ' +
+            '"problems": 1-3 of the research problems/scenarios it speaks to (copy their text), ' +
+            '"stake": {"quantity": what is measured, "before": the value/verdict before, "after": the same quantity after} taken from the session, or null if the session shows no provable before/after}.',
+        'Output ONLY: {"briefs": [...]}',
+    ].join('\n\n');
+}
+/** A stake needs all three parts, and before must differ from after. */
+export function validStake(v) {
+    const o = v && typeof v === 'object' ? v : null;
+    if (!o)
+        return null;
+    const quantity = str(o.quantity ?? o.what, 160);
+    const before = str(o.before, 120);
+    const after = str(o.after, 120);
+    if (!quantity || !before || !after || before.toLowerCase() === after.toLowerCase())
+        return null;
+    return { quantity, before, after };
+}
+const DEFAULT_FORMAT = { highlight: 'narrated-timeline', howto: 'two-voice-hud' };
+export function validateBriefs(raw, cands, research, owner) {
+    const list = Array.isArray(raw?.briefs) ? raw.briefs : [];
+    const byId = new Map(list.map(b => [str(b?.id, 40), b]));
+    return cands.map((c, i) => {
+        const b = byId.get(c.id) ?? list[i] ?? {};
+        const r = research.get(c.id);
+        const fmt = str(b?.format, 40).toLowerCase();
+        const format = FORMAT_CATALOG.some(f => f.id === fmt && f.tiers.includes(c.kind)) ? fmt : DEFAULT_FORMAT[c.kind];
+        const viewer = str(b?.viewer ?? b?.audience, 200) || r?.viewers[0]?.text || `developers working on ${c.subtopic}`;
+        const problems = (Array.isArray(b?.problems) ? b.problems : []).map((p) => str(p, 240)).filter(Boolean).slice(0, 3);
+        return {
+            id: c.id, tier: c.kind, subtopic: c.subtopic, story: c.story, fromRow: c.fromRow, toRow: c.toRow,
+            viewer, situation: str(b?.situation, 240) || (r?.problems[0]?.text ?? c.subtopic), format, angle: str(b?.angle, 240) || c.why,
+            problems: problems.length ? problems : (r?.problems ?? []).slice(0, 2).map(p => p.text),
+            stake: validStake(b?.stake), researchKey: r?.key ?? '', owner, autoGenerated: true,
+        };
+    });
+}
+/** Build all briefs for a period in one model call. */
+export async function buildBriefs(cands, research, owner, llm) {
+    if (!cands.length)
+        return { briefs: [], costUsd: 0 };
+    const r = await llmJson(llm, { what: 'brief', system: BRIEF_SYSTEM, user: briefPrompt(cands, research), maxOut: 1500, temperature: 0.2 });
+    return { briefs: validateBriefs(r.json, cands, research, owner), costUsd: r.costUsd };
+}

package/dist/content/content-checks.d.ts

@@ -0,0 +1,88 @@
+/**
+ * content-checks.ts — Stage A gates. A HARD flag ⇒ the piece is "blocked":
+ * never ingested, never auto-fixed (content-run records the flags).
+ * HARD always: dev-voice pre-pass, truth-check, length below the tier min or
+ * more than +15% over the tier max, an empty script.
+ * ADVISORY by default (warnings → the draft's quality_flags; still ingested):
+ * the structure gate (stake / "no visible proof", causes, terms/min, spoken
+ * versions/codes), up to +15% over the tier max, and the audience check.
+ * OSBORN_CONTENT_STRICT=1 makes every advisory warning a hard flag again.
+ *
+ * Order (cheapest first; a failing stage skips the paid ones after it):
+ *   1. length      deterministic: estimated seconds within the tier bounds.
+ *   2. dev-voice   deterministic pre-pass (rules §7): every dev line must be a
+ *                  substring of ONE user row of the period. Ellipsis cuts ("…" / "...")
+ *                  are allowed only if every piece is ≥12 chars, the pieces occur in
+ *                  order in that row, and they cover ≥80% of the row span they were
+ *                  cut from (so a cut can't flip the meaning). Records the row id.
+ *                  Also caps dev lines per tier (a highlight is not a quote chain).
+ *   3. truth-check LLM, PINNED: deepseek/deepseek-chat on deepinfra/fp4 with
+ *                  allow_fallbacks:false (as videos-test-3/vt3-render.ts); the served
+ *                  provider must be DeepInfra. Cached by sha256(draft+sources+prompt+model+provider).
+ *   4. audience    LLM (same pin): rules §4 — every quote/term familiar to the viewer or set up nearby.
+ */
+import type { DbRecord } from './lens-db.js';
+import { type ContentLlmOptions } from './content-llm.js';
+import { type CheckSummary } from './content-manifest.js';
+import { type ScriptLimits } from './content-script-rules.js';
+import { type Script, type ScriptLine } from './content-script.js';
+import type { Brief } from './content-brief.js';
+export declare const CHECK_CACHE_DIR = ".content-check-cache";
+export declare const MIN_PIECE_CHARS = 12;
+export declare const MIN_CUT_COVERAGE = 0.8;
+/** Non-strict: a script may run up to this fraction over the tier max (flagged, not blocked). */
+export declare const OVER_LENGTH_TOLERANCE = 0.15;
+export declare const NO_PROOF_FLAG = "no visible proof: brief has no before -> after stake quantity (rule 1: stake and proof both visible)";
+/** Whitespace + typographic quote/dash normalisation only (never wording). */
+export declare const normText: (s: string) => string;
+/** Pieces of a dev line split at ellipsis cuts (leading/trailing cuts allowed). */
+export declare const devPieces: (text: string) => string[];
+/** Match pieces in order inside `row`. Returns the covered span ratio, or null when not all found. */
+export declare function matchInRow(row: string, pieces: string[]): number | null;
+export interface PrepassResult {
+    ok: boolean;
+    flags: string[];
+    rows: {
+        line: number;
+        row: number;
+        match: string;
+    }[];
+}
+/** Deterministic dev-voice pre-pass. `rows` = the period's records (only user rows are eligible). */
+export declare function devVoicePrepass(lines: ScriptLine[], rows: DbRecord[], tier?: Script['tier']): PrepassResult;
+export declare const draftText: (s: Script) => string;
+/** pipeline-e2e LEG 5 / vt3-render.ts truth-check prompt, unchanged. */
+export declare const TRUTH_SYSTEM: string;
+export declare const truthUser: (sources: string, draft: string) => string;
+export declare const AUDIENCE_SYSTEM = "You are an editor checking a short developer video script for ONE target viewer. Reply with ONE JSON object only.";
+export declare const audienceUser: (brief: Pick<Brief, "viewer" | "situation">, draft: string) => string;
+/** Flags from any reply shape: ["..."], {flags:[...]}, [{claim|item|text}], … */
+export declare function flagsFrom(json: unknown): string[];
+/** Spoken software versions / error codes (WHAT-WORKS rule 4). Starting patterns; dev lines are exempt (verbatim). */
+export declare const VERSION_CODE_PATTERNS: RegExp[];
+export interface StructureResult {
+    ok: boolean;
+    flags: string[];
+    causes: number;
+    termsPerMin: number;
+}
+/** WHAT-WORKS deterministic gate, run on the script BEFORE any LLM judge. Thresholds: scriptLimits() (env-tunable). */
+export declare function structureCheck(s: Script, brief: Pick<Brief, 'stake'>, limits?: ScriptLimits): StructureResult;
+export interface CheckContext {
+    projectDir: string | null;
+    llm: ContentLlmOptions;
+    /** The period's records (session.db, redacted) — dev lines are matched against the user rows. */
+    records: DbRecord[];
+    /** Truth-check ground truth: library page + cited rows + research digest (already scrubbed). */
+    sources: string;
+}
+/**
+ * All gates for one script. `flags` (hard) non-empty ⇒ blocked. `warnings` are advisory
+ * quality flags (empty under OSBORN_CONTENT_STRICT=1, where they are hard flags instead).
+ * Throws CapError / Error (piece → capped / error).
+ */
+export declare function runChecks(s: Script, brief: Brief, ctx: CheckContext): Promise<{
+    summary: CheckSummary;
+    flags: string[];
+    warnings: string[];
+}>;