osborn 0.9.251 → 0.9.252

package/dist/content/content-checks.js

@@ -0,0 +1,249 @@
+/**
+ * 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 { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CHECK_MODEL, CHECK_PROVIDER, CHECK_PROVIDER_NAME, isContentStrict, llmJson } from './content-llm.js';
+import { writeAtomic } from './content-manifest.js';
+import { AUDIENCE_RULES, TIER_TEMPLATES, scriptLimits } from './content-script-rules.js';
+import { lengthCheck } from './content-script.js';
+export const CHECK_CACHE_DIR = '.content-check-cache';
+export const MIN_PIECE_CHARS = 12;
+export const MIN_CUT_COVERAGE = 0.8;
+/** Non-strict: a script may run up to this fraction over the tier max (flagged, not blocked). */
+export const OVER_LENGTH_TOLERANCE = 0.15;
+export 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 const normText = (s) => String(s ?? '')
+    .replace(/[‘’‛′]/g, "'")
+    .replace(/[“”‟″]/g, '"')
+    .replace(/[–—]/g, '-')
+    .replace(/\s+/g, ' ')
+    .trim();
+const ELLIPSIS = /\s*(?:…|\.\.\.)\s*/;
+const stripWrapQuotes = (s) => s.replace(/^["'\s]+|["'\s]+$/g, '');
+/** Pieces of a dev line split at ellipsis cuts (leading/trailing cuts allowed). */
+export const devPieces = (text) => normText(text).split(ELLIPSIS).map(stripWrapQuotes).filter(Boolean);
+/** Match pieces in order inside `row`. Returns the covered span ratio, or null when not all found. */
+export function matchInRow(row, pieces) {
+    const hay = normText(row);
+    let at = 0;
+    let first = -1;
+    let end = 0;
+    for (const p of pieces) {
+        const k = hay.indexOf(p, at);
+        if (k < 0)
+            return null;
+        if (first < 0)
+            first = k;
+        at = k + p.length;
+        end = at;
+    }
+    const kept = pieces.reduce((n, p) => n + p.length, 0);
+    return end > first ? kept / (end - first) : 1;
+}
+/** Deterministic dev-voice pre-pass. `rows` = the period's records (only user rows are eligible). */
+export function devVoicePrepass(lines, rows, tier) {
+    const users = rows.filter(r => r.speaker === 'user');
+    const res = { ok: true, flags: [], rows: [] };
+    let devCount = 0;
+    lines.forEach((l, i) => {
+        if (l.speaker !== 'dev')
+            return;
+        devCount++;
+        const n = i + 1;
+        const pieces = devPieces(l.text);
+        if (!pieces.length)
+            return void res.flags.push(`dev line ${n}: empty`);
+        const short = pieces.find(p => p.length < MIN_PIECE_CHARS);
+        if (short)
+            return void res.flags.push(`dev line ${n}: piece "${short}" is under ${MIN_PIECE_CHARS} chars`);
+        // The cited row first, then every other user row.
+        const order = [...users.filter(r => r.id === l.row), ...users.filter(r => r.id !== l.row)];
+        let best = null;
+        for (const r of order) {
+            const cov = matchInRow(r.text, pieces);
+            if (cov === null)
+                continue;
+            if (pieces.length === 1 || cov >= MIN_CUT_COVERAGE) {
+                best = { row: r.id, cov };
+                break;
+            }
+            if (!best || cov > best.cov)
+                best = { row: r.id, cov };
+        }
+        if (!best)
+            return void res.flags.push(`dev line ${n}: not verbatim in any user row of the period`);
+        if (pieces.length > 1 && best.cov < MIN_CUT_COVERAGE) {
+            return void res.flags.push(`dev line ${n}: ellipsis cuts keep ${(best.cov * 100).toFixed(0)}% of row #${best.row} span (< ${MIN_CUT_COVERAGE * 100}%)`);
+        }
+        res.rows.push({ line: n, row: best.row, match: pieces.length > 1 ? `ellipsis ${(best.cov * 100).toFixed(0)}%` : 'substring' });
+    });
+    if (tier && devCount > TIER_TEMPLATES[tier].devLines.max)
+        res.flags.push(`${devCount} dev lines > ${TIER_TEMPLATES[tier].devLines.max} allowed for ${tier} (not a quote chain)`);
+    res.ok = res.flags.length === 0;
+    return res;
+}
+const TAG = {
+    dev: '[DEVELOPER, verbatim user line; … marks elided words]',
+    agent: '[AGENT]',
+    narrator: '[NARRATOR]',
+};
+export const draftText = (s) => `ON-SCREEN TITLE: ${s.title}\nHOOK: ${s.hook}\n\nNARRATION (one line per caption):\n` + s.lines.map((l, i) => `${i + 1}. ${TAG[l.speaker]} ${l.text}`).join('\n');
+/** pipeline-e2e LEG 5 / vt3-render.ts truth-check prompt, unchanged. */
+export const TRUTH_SYSTEM = 'You are a strict fact-checking editor. You are given a DRAFT post and the SOURCE records (the ONLY ' +
+    'ground truth). Identify every factual claim, event, metric, or specific detail in the draft that is ' +
+    'NOT directly supported by the source records. Treat invented stories, numbers, or named mechanisms as ' +
+    'unsupported. Do NOT rewrite or soften the post. Return ONLY a JSON array of strings — each string one ' +
+    'specific ungrounded claim (quote or tight paraphrase from the draft). If every claim is grounded, return [].';
+export const truthUser = (sources, draft) => `SOURCE RECORDS (ground truth, speaker-tagged):\n${sources}\n\nDRAFT POST:\n${draft}\n\nList the ungrounded claims as a JSON array of strings.`;
+export const AUDIENCE_SYSTEM = 'You are an editor checking a short developer video script for ONE target viewer. Reply with ONE JSON object only.';
+export const audienceUser = (brief, draft) => `${AUDIENCE_RULES}\n\nTARGET VIEWER: ${brief.viewer}\nTHEY ARE LIVING THROUGH: ${brief.situation}\n\nSCRIPT:\n${draft}\n\n` +
+    'List each quote or term that lands with no context for this viewer. Output ONLY: {"flags": [{"item": quote or term, "why": one line}]} — [] when every one passes.';
+/** Flags from any reply shape: ["..."], {flags:[...]}, [{claim|item|text}], … */
+export function flagsFrom(json) {
+    let arr = json;
+    if (json && typeof json === 'object' && !Array.isArray(json)) {
+        const o = json;
+        arr = [o.flags, o.unsupported, o.issues, o.claims, o.unfamiliar].find(Array.isArray) ?? [];
+    }
+    if (!Array.isArray(arr))
+        return [];
+    return arr
+        .map(x => (typeof x === 'string' ? x : x && typeof x === 'object' ? [x.claim ?? x.item ?? x.text ?? x.term ?? '', x.why ?? x.reason ?? ''].filter(Boolean).join(' — ') : ''))
+        .map(s => String(s).replace(/\s+/g, ' ').trim())
+        .filter(Boolean)
+        .slice(0, 20);
+}
+/** Spoken software versions / error codes (WHAT-WORKS rule 4). Starting patterns; dev lines are exempt (verbatim). */
+export const VERSION_CODE_PATTERNS = [
+    /\b\d+\.\d+\.\d+\b/, // 0.9.73
+    /\bv\d+(?:\.\d+)+\b/i, // v2.1
+    /\bversion\s+\d+(?:\.\d+)*\b/i, // version 186
+    /\b(?:HTTP|status|error|exit|code)\s*(?:code\s*)?\d{3,5}\b/i, // HTTP 502, error 1006, exit code 137
+    /\b\d{3,5}\s+(?:error|status code)\b/i, // 404 error
+    /\b(?:ws|websocket)\s+\d{4}\b/i, // WS 1006
+    /\bE[A-Z]{4,}\b/, // ENOENT, EADDRINUSE, ECONNRESET
+];
+/** WHAT-WORKS deterministic gate, run on the script BEFORE any LLM judge. Thresholds: scriptLimits() (env-tunable). */
+export function structureCheck(s, brief, limits = scriptLimits()) {
+    const flags = [];
+    if (!brief.stake)
+        flags.push(NO_PROOF_FLAG);
+    const seconds = lengthCheck(s).seconds;
+    const causes = s.causes.length;
+    const maxC = limits.maxCauses[s.tier];
+    if (causes === 0)
+        flags.push('script declares no cause');
+    else {
+        if (causes > maxC)
+            flags.push(`${causes} causes > ${maxC} allowed for ${s.tier}`);
+        if (seconds / causes < limits.secondsPerCause)
+            flags.push(`${(seconds / causes).toFixed(0)}s per cause < ${limits.secondsPerCause}s (${causes} causes in ~${seconds.toFixed(0)}s)`);
+    }
+    const termsPerMin = seconds > 0 ? Number((s.terms.length / (seconds / 60)).toFixed(2)) : 0;
+    if (termsPerMin > limits.maxTermsPerMin[s.tier])
+        flags.push(`${termsPerMin} load-bearing terms/min > ${limits.maxTermsPerMin[s.tier]} (${s.terms.length} terms)`);
+    const spoken = [{ n: 0, text: s.title }, { n: 0, text: s.hook }, ...s.lines.map((l, i) => ({ n: i + 1, text: l.speaker === 'dev' ? '' : l.text }))];
+    for (const { n, text } of spoken) {
+        const re = VERSION_CODE_PATTERNS.find(p => p.test(text));
+        if (re)
+            flags.push(`${n ? `line ${n}` : 'title/hook'}: spoken version or error code ("${text.match(re)[0]}")`);
+    }
+    return { ok: flags.length === 0, flags, causes, termsPerMin };
+}
+function cachePath(projectDir, key) {
+    return projectDir ? join(projectDir, CHECK_CACHE_DIR, `${key}.json`) : null;
+}
+/** Pinned LLM judge with a content-addressed cache. Throws CapError / Error. */
+async function pinnedJudge(kind, system, user, ctx) {
+    const key = createHash('sha256').update(JSON.stringify({ kind, system, user, model: CHECK_MODEL, provider: CHECK_PROVIDER })).digest('hex');
+    const p = cachePath(ctx.projectDir, key);
+    if (p) {
+        try {
+            const c = JSON.parse(readFileSync(p, 'utf-8'));
+            if (c?.key === key && Array.isArray(c.flags))
+                return { flags: c.flags, provider: String(c.provider), cacheKey: key, cached: true };
+        }
+        catch {
+            /* miss */
+        }
+    }
+    const r = await llmJson(ctx.llm, {
+        what: kind === 'truth' ? 'truth-check' : 'audience-check', system, user, maxOut: 1200, temperature: 0,
+        model: CHECK_MODEL, pin: { endpoint: CHECK_PROVIDER, name: CHECK_PROVIDER_NAME },
+    });
+    if (r.json === null)
+        throw new Error(`${kind}-check: unparseable reply`);
+    const flags = flagsFrom(r.json);
+    if (p) {
+        try {
+            mkdirSync(join(ctx.projectDir, CHECK_CACHE_DIR), { recursive: true });
+            writeAtomic(p, JSON.stringify({ key, kind, model: CHECK_MODEL, provider: r.provider, flags, at: new Date().toISOString() }, null, 2) + '\n');
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    return { flags, provider: r.provider, cacheKey: key, cached: false };
+}
+/**
+ * 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 async function runChecks(s, brief, ctx) {
+    const strict = isContentStrict();
+    const length = lengthCheck(s);
+    const prepass = devVoicePrepass(s.lines, ctx.records, s.tier);
+    const structure = structureCheck(s, brief);
+    const summary = { prepass, truth: null, audience: null, length, structure };
+    const flags = [];
+    const warnings = [];
+    // Advisory unless strict: same text either way, only where it lands differs.
+    const soft = (f) => (strict ? flags : warnings).push(f);
+    if (!length.ok) {
+        const msg = `length ~${length.seconds}s outside ${length.min}-${length.max}s for ${s.tier}`;
+        const tolerated = length.seconds > length.max && length.seconds <= length.max * (1 + OVER_LENGTH_TOLERANCE);
+        if (tolerated)
+            soft(`${msg} (within +${OVER_LENGTH_TOLERANCE * 100}% over-length tolerance)`);
+        else
+            flags.push(msg);
+    }
+    flags.push(...prepass.flags);
+    structure.flags.forEach(soft);
+    if (!s.lines.length)
+        flags.push('script has no lines');
+    if (flags.length)
+        return { summary, flags, warnings };
+    const draft = draftText(s);
+    const t = await pinnedJudge('truth', TRUTH_SYSTEM, truthUser(ctx.sources, draft), ctx);
+    summary.truth = { ok: t.flags.length === 0, flags: t.flags, model: CHECK_MODEL, provider: t.provider, cacheKey: t.cacheKey, cached: t.cached };
+    if (t.flags.length)
+        return { summary, flags: t.flags.map(f => `truth: ${f}`), warnings };
+    const a = await pinnedJudge('audience', AUDIENCE_SYSTEM, audienceUser(brief, draft), ctx);
+    summary.audience = { ok: a.flags.length === 0, flags: a.flags, model: CHECK_MODEL, provider: a.provider };
+    a.flags.forEach(f => soft(`audience: ${f}`));
+    return { summary, flags, warnings };
+}

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

@@ -0,0 +1,51 @@
+/**
+ * content-ingest.ts — sends a CHECKED script draft (no flags) to the cloud
+ * library through the same content_ingest RPC as library pages
+ * (lens-ingest.ts postContentIngest: sync-token auth, anon key, the
+ * Content-Profile: public header, size cap, never throws, never sends status).
+ *
+ * Mapping (no new content type):
+ *   type          text_post (Stage B later attaches media to the SAME row → short / audio_video)
+ *   source_kind   script_highlight | script_howto
+ *   content_hash  sha256(session, period start row, piece id) — stable per piece, so a
+ *                 re-ingest upserts and a later media attach hits the same row
+ *   source_anchors  project_slug (basename(projectDir), as lens-library), period, brief,
+ *                 research citations, check result, quality_flags (advisory warnings),
+ *                 dev-voice row ids, auto_generated: true
+ * Every string in the payload goes through scrubDeep() (content-redact.ts) first.
+ * Blocked pieces never reach this module (content-run).
+ */
+import { type IngestOptions, type IngestState } from './lens-ingest.js';
+import type { CheckSummary } from './content-manifest.js';
+import type { Brief } from './content-brief.js';
+import { type Script } from './content-script.js';
+export declare const AUTO_LABEL = "Auto-generated draft";
+export interface ScriptDraft {
+    sessionId: string;
+    projectDir: string | null;
+    period: {
+        index: number;
+        startRowId: number;
+        endRowId: number;
+        page: string;
+    };
+    brief: Brief;
+    script: Script;
+    checks: CheckSummary;
+    /** Advisory quality warnings (not blocking) → source_anchors.quality_flags + "Draft quality notes:" in the body. */
+    qualityFlags?: string[];
+    citations: {
+        url: string;
+        title: string;
+        source: string;
+    }[];
+    model: string;
+}
+export declare const pieceContentHash: (sessionId: string, startRowId: number, pieceId: string) => string;
+export declare const projectSlugFor: (projectDir: string | null) => string | null;
+/** The draft as markdown (the `body` field), labelled as auto-generated. */
+export declare function scriptMarkdown(d: ScriptDraft): string;
+export declare function buildScriptPayload(d: ScriptDraft, scrubDeep?: <T>(v: T) => T): Record<string, unknown>;
+export declare const isIngestConfigured: () => boolean;
+/** Ingest one checked script draft. Never throws. */
+export declare function ingestScript(d: ScriptDraft, scrubDeep: <T>(v: T) => T, o?: IngestOptions): Promise<IngestState>;

package/dist/content/content-ingest.js

@@ -0,0 +1,107 @@
+/**
+ * content-ingest.ts — sends a CHECKED script draft (no flags) to the cloud
+ * library through the same content_ingest RPC as library pages
+ * (lens-ingest.ts postContentIngest: sync-token auth, anon key, the
+ * Content-Profile: public header, size cap, never throws, never sends status).
+ *
+ * Mapping (no new content type):
+ *   type          text_post (Stage B later attaches media to the SAME row → short / audio_video)
+ *   source_kind   script_highlight | script_howto
+ *   content_hash  sha256(session, period start row, piece id) — stable per piece, so a
+ *                 re-ingest upserts and a later media attach hits the same row
+ *   source_anchors  project_slug (basename(projectDir), as lens-library), period, brief,
+ *                 research citations, check result, quality_flags (advisory warnings),
+ *                 dev-voice row ids, auto_generated: true
+ * Every string in the payload goes through scrubDeep() (content-redact.ts) first.
+ * Blocked pieces never reach this module (content-run).
+ */
+import { createHash } from 'node:crypto';
+import { basename } from 'node:path';
+import { postContentIngest, resolveIngestConfig } from './lens-ingest.js';
+import { CHECK_MODEL, CHECK_PROVIDER } from './content-llm.js';
+import { FORMAT_CATALOG, TIER_TEMPLATES } from './content-script-rules.js';
+import { scriptTranscript } from './content-script.js';
+export const AUTO_LABEL = 'Auto-generated draft';
+const SESSION_ID_RE = /^[a-zA-Z0-9._-]{1,128}$/;
+export const pieceContentHash = (sessionId, startRowId, pieceId) => createHash('sha256').update(`content-script\n${sessionId}\n${startRowId}\n${pieceId}`).digest('hex');
+export const projectSlugFor = (projectDir) => (projectDir ? basename(projectDir) : null);
+const LABEL = { narrator: 'NARRATOR', dev: 'DEVELOPER (verbatim)', agent: 'AGENT' };
+/** The draft as markdown (the `body` field), labelled as auto-generated. */
+export function scriptMarkdown(d) {
+    const b = d.brief;
+    const s = d.script;
+    const fmt = FORMAT_CATALOG.find(f => f.id === b.format);
+    const devRow = new Map(d.checks.prepass.rows.map(r => [r.line, r.row]));
+    const q = d.qualityFlags ?? [];
+    return [
+        `> **${AUTO_LABEL}** — written by the content pipeline from this session; review before publishing.`,
+        `# ${s.title || '(untitled)'}`,
+        s.hook ? `*${s.hook}*` : '',
+        q.length ? `**Draft quality notes:** this draft passed the hard checks but is weak on ${q.length} point(s):\n${q.map(f => `- ${f}`).join('\n')}` : '',
+        '## Brief',
+        `- **Viewer:** ${b.viewer}`,
+        `- **Living through:** ${b.situation}`,
+        `- **Tier:** ${TIER_TEMPLATES[b.tier].label} · ~${s.estSeconds}s (${s.words} words)`,
+        `- **Format:** ${fmt?.name ?? b.format}`,
+        b.stake ? `- **Stake:** ${b.stake.quantity}: ${b.stake.before} → ${b.stake.after}` : '',
+        `- **Angle:** ${b.angle}`,
+        b.problems.length ? `- **Speaks to:** ${b.problems.join('; ')}` : '',
+        '## Script',
+        ...s.lines.map((l, i) => `${i + 1}. **${LABEL[l.speaker]}:** ${l.text}${l.speaker === 'dev' && devRow.has(i + 1) ? ` _(row #${devRow.get(i + 1)})_` : ''}`),
+        d.citations.length ? '## Research threads' : '',
+        ...d.citations.map(c => `- [${c.title}](${c.url}) (${c.source})`),
+        '## Checks',
+        `- Dev-voice pre-pass: ${d.checks.prepass.ok ? 'pass' : 'FAIL'} · length ~${d.checks.length.seconds}s (${d.checks.length.min}-${d.checks.length.max}s)`,
+        d.checks.truth ? `- Truth-check (${d.checks.truth.model} via ${d.checks.truth.provider}): ${d.checks.truth.flags.length} flag(s)` : '',
+        d.checks.audience ? `- Audience check: ${d.checks.audience.flags.length} flag(s)` : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+export function buildScriptPayload(d, scrubDeep = v => v) {
+    const s = d.script;
+    const b = d.brief;
+    const payload = {
+        type: 'text_post',
+        title: `${AUTO_LABEL}: ${s.title || b.subtopic}`.slice(0, 200),
+        hook: s.hook || null,
+        body: scriptMarkdown(d),
+        transcript: scriptTranscript(s),
+        transcript_segments: s.lines.map((l, i) => ({ i: i + 1, speaker: l.speaker, text: l.text, ...(l.row ? { row: l.row } : {}) })),
+        source_session_id: SESSION_ID_RE.test(d.sessionId) ? d.sessionId : null,
+        source_kind: b.tier === 'highlight' ? 'script_highlight' : 'script_howto',
+        source_anchors: {
+            auto_generated: true,
+            label: AUTO_LABEL,
+            project_slug: projectSlugFor(d.projectDir),
+            piece_id: b.id,
+            period: { index: d.period.index, start_row_id: d.period.startRowId, end_row_id: d.period.endRowId, page: d.period.page },
+            brief: {
+                viewer: b.viewer, situation: b.situation, tier: b.tier, format: b.format, angle: b.angle, problems: b.problems,
+                stake: b.stake, subtopic: b.subtopic, story: b.story, from_row: b.fromRow, to_row: b.toRow, owner: b.owner,
+            },
+            research: { key: b.researchKey, citations: d.citations },
+            checks: { ...d.checks, flags: 0 },
+            quality_flags: d.qualityFlags ?? [],
+            dev_rows: d.checks.prepass.rows,
+            est_seconds: s.estSeconds,
+            generator: { model: d.model, check_model: CHECK_MODEL, check_provider: CHECK_PROVIDER },
+        },
+        content_hash: pieceContentHash(d.sessionId, d.period.startRowId, b.id),
+    };
+    // Redact every string, then restore the hash (hex, untouched by design but never trust a scrubber with it).
+    return { ...scrubDeep(payload), content_hash: payload.content_hash };
+}
+export const isIngestConfigured = () => resolveIngestConfig().ok;
+/** Ingest one checked script draft. Never throws. */
+export async function ingestScript(d, scrubDeep, o = {}) {
+    const hash = pieceContentHash(d.sessionId, d.period.startRowId, d.brief.id);
+    let payload = null;
+    try {
+        payload = buildScriptPayload(d, scrubDeep);
+    }
+    catch {
+        return { status: 'error', reason: 'payload', contentHash: hash, at: new Date().toISOString() };
+    }
+    return postContentIngest(payload, hash, `content: ingest ${d.brief.id} (period ${d.period.index})`, o);
+}

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

@@ -0,0 +1,134 @@
+/**
+ * content-llm.ts — Stage A's flags, spend caps and its ONE model-call path.
+ * OpenRouter ONLY (OPENROUTER_API_KEY) — never the Claude subscription / Anthropic SDK.
+ *
+ * Flags:
+ *   OSBORN_CONTENT_PIPELINE  default ON; 0/off/false/no = off. OSBORN_CONTENT_LENS=0 also turns it off.
+ * Caps (a hit = status "capped", never an error):
+ *   OSBORN_CONTENT_PERIOD_USD  default 0.75 (cumulative per period, kept in the content manifest)
+ *   OSBORN_CONTENT_DAILY_USD   default 2.00 (UTC day, per MACHINE: $OSBORN_HOME or ~/.osborn/content-spend-ledger.json,
+ *                              locked read-modify-write so concurrent workers across projects share one cap)
+ *   OSBORN_CONTENT_MAX_PIECES  default 4 (1 highlight + up to 3 how-tos)
+ * Every call reserves its WORST case (prompt + max output) against both caps up
+ * front and writes it to the ledger before the fetch; it is reconciled to the
+ * actual cost after. A failed call is charged the worst case, and a hard exit
+ * mid-call leaves the worst case in the ledger, so the caps stay hard.
+ * All outbound prompt text goes through the caller's scrub() first.
+ */
+export declare const LEDGER_FILE = "content-spend-ledger.json";
+export declare const DEFAULT_GEN_MODEL = "minimax/minimax-m3";
+/** Pinned judge (proven in videos-test-3/vt3-render.ts): model + provider endpoint, no fallbacks. */
+export declare const CHECK_MODEL = "deepseek/deepseek-chat";
+export declare const CHECK_PROVIDER = "deepinfra/fp4";
+export declare const CHECK_PROVIDER_NAME = "DeepInfra";
+export declare const priceFor: (model: string) => {
+    p: number;
+    c: number;
+};
+/** OFF when OSBORN_CONTENT_PIPELINE, OSBORN_CONTENT_LENS or OSBORN_CONTENT_INGEST is 0/off/false/no: ingest off ⇒ no LLM spend at all. */
+export declare function isContentPipelineEnabled(): boolean;
+/**
+ * OSBORN_CONTENT_STRICT=1 restores hard blocks for the quality gates (structure,
+ * over-length tolerance, missing stake, audience). Default: those are advisory —
+ * the piece is still scripted and ingested as a draft with quality_flags attached.
+ * Dev-voice, truth-check, redaction, the outbound-query gate and the caps are hard either way.
+ */
+export declare function isContentStrict(): boolean;
+export interface ContentCaps {
+    periodUsd: number;
+    dailyUsd: number;
+    maxPieces: number;
+}
+export declare function contentCaps(): ContentCaps;
+export declare const genModel: () => string;
+/** Machine-scoped ledger dir: $OSBORN_HOME, else ~/.osborn. The DAY cap is per machine, not per project. */
+export declare function ledgerDir(): string;
+export declare const ledgerPath: () => string;
+interface Ledger {
+    days: Record<string, number>;
+}
+/** The machine ledger (UTC day → USD). */
+export declare function readLedger(): Ledger;
+/** Spend recorded (incl. open reservations) on this machine today, across every project. */
+export declare function daySpent(now?: number): number;
+export type CapKind = 'period' | 'day' | 'time';
+export declare class CapError extends Error {
+    readonly cap: CapKind;
+    readonly needUsd: number;
+    constructor(cap: CapKind, needUsd: number);
+}
+/** A worst-case amount already written to the machine ledger; settle() reconciles it to the actual cost. */
+export interface Reservation {
+    day: string;
+    usd: number;
+    inLedger: boolean;
+    settled: boolean;
+}
+/**
+ * Per-run spend guard: the per-period cap (cumulative, per project, in memory +
+ * content manifest), the per-day cap (per MACHINE, in the locked ledger) and an
+ * optional wall-clock deadline after which no new call starts.
+ */
+export declare class SpendGuard {
+    /** Kept for callers/logs; the day ledger is machine-scoped, not under this dir. */
+    readonly projectDir: string | null;
+    readonly caps: ContentCaps;
+    /** Spend already recorded for this period by earlier runs. */
+    periodUsd: number;
+    /** Epoch ms after which reserve() refuses new calls (CapError 'time'). */
+    readonly deadline: number | null;
+    runUsd: number;
+    calls: number;
+    capHit: CapKind | null;
+    constructor(
+    /** Kept for callers/logs; the day ledger is machine-scoped, not under this dir. */
+    projectDir: string | null, caps: ContentCaps, 
+    /** Spend already recorded for this period by earlier runs. */
+    periodUsd?: number, 
+    /** Epoch ms after which reserve() refuses new calls (CapError 'time'). */
+    deadline?: number | null);
+    /**
+     * Reserve a worst-case spend of `usd`: throws CapError if it would cross a cap
+     * (or the deadline passed); otherwise writes it to the machine ledger BEFORE the
+     * call, so a hard exit mid-call still counts it. Fails closed if the ledger lock
+     * cannot be taken.
+     */
+    reserve(usd: number): Reservation;
+    private hit;
+    /** Reconcile a reservation to the actual cost (once). The in-memory totals always move; the ledger is best-effort. */
+    settle(r: Reservation, actualUsd: number): void;
+}
+export interface LlmCall {
+    /** Short tag for logs ("research", "script", "truth-check"...). Never the prompt. */
+    what: string;
+    system: string;
+    user: string;
+    maxOut: number;
+    model?: string;
+    temperature?: number;
+    /** Pin provider: order=[endpoint], allow_fallbacks:false; the served provider must equal `name`. */
+    pin?: {
+        endpoint: string;
+        name: string;
+    };
+}
+export interface LlmResult {
+    content: string;
+    json: any;
+    costUsd: number;
+    provider: string;
+    model: string;
+    finish: string;
+}
+/** Lenient JSON extraction: strips fences, takes the outermost {...} or [...]. Null when unparseable. */
+export declare function parseJsonLoose(s: string): any;
+export interface ContentLlmOptions {
+    apiKey: string;
+    guard: SpendGuard;
+    scrub: (s: string) => string;
+    fetchImpl?: typeof fetch;
+    log?: (m: string) => void;
+}
+/** One chat call → JSON. Throws CapError on a cap, Error on HTTP/timeout/provider mismatch. */
+export declare function llmJson(o: ContentLlmOptions, call: LlmCall): Promise<LlmResult>;
+export {};