osborn 0.9.251 → 0.9.252

package/dist/content/content-script.js

@@ -0,0 +1,107 @@
+/**
+ * content-script.ts — Stage A script generation: one script per brief.
+ * A period yields at most 1 highlight (61-90s narrated timeline) + up to 3
+ * how-tos (~150s "if you're in this situation…"); content-run enforces the count.
+ *
+ * Writing rules and per-tier beats come ONLY from content-script-rules.ts
+ * (SCRIPT_RULES / TIER_TEMPLATES), so they can be replaced without touching
+ * this logic. Dev-voice lines must be verbatim user rows: the model is shown
+ * row-tagged rows and must cite the row; content-checks.ts verifies every dev
+ * line deterministically before anything else runs. Throws CapError / Error.
+ */
+import { recordView } from './lens-db.js';
+import { llmJson } from './content-llm.js';
+import { FORMAT_CATALOG, SCRIPT_RULES, TIER_TEMPLATES, WORDS_PER_SECOND } from './content-script-rules.js';
+const ROWS_MAX_CHARS = 40_000;
+const PAGE_MAX_CHARS = 40_000;
+const MAX_LINES = 60;
+export const countWords = (s) => (s.match(/[A-Za-z0-9][A-Za-z0-9'’.-]*/g) ?? []).length;
+export const estimateSeconds = (lines) => Number((lines.reduce((n, l) => n + countWords(l.text), 0) / WORDS_PER_SECOND).toFixed(1));
+export function tierBounds(tier) {
+    const t = TIER_TEMPLATES[tier];
+    return { min: t.minS, max: t.maxS, target: t.targetS };
+}
+export function lengthCheck(s) {
+    const b = tierBounds(s.tier);
+    const seconds = estimateSeconds(s.lines);
+    return { ok: seconds >= b.min && seconds <= b.max, seconds, min: b.min, max: b.max };
+}
+/** Row-tagged session rows for the brief's range (widened to the whole period when thin), capped. */
+export function rowsForBrief(records, brief) {
+    let rows = records.filter(r => r.id >= brief.fromRow && r.id <= brief.toRow);
+    if (rows.filter(r => r.speaker === 'user').length < 4)
+        rows = records;
+    const out = [];
+    let used = 0;
+    // Keep the range's start in view: walk forward, stop at the cap.
+    for (const r of rows) {
+        const c = recordView(r).length + 2;
+        if (used + c > ROWS_MAX_CHARS && out.length)
+            break;
+        used += c;
+        out.push(r);
+    }
+    return out;
+}
+export const SCRIPT_SYSTEM = 'You write the spoken script for a developer\'s own short vertical video, made from their real work session with an AI coding agent. ' +
+    'You never invent facts. Developer lines are copied verbatim from the user rows given. Reply with ONE JSON object only.';
+export function scriptPrompt(brief, page, rows, researchText) {
+    const t = TIER_TEMPLATES[brief.tier];
+    const fmt = FORMAT_CATALOG.find(f => f.id === brief.format);
+    return [
+        '<period_page>',
+        page.length > PAGE_MAX_CHARS ? page.slice(0, PAGE_MAX_CHARS) : page,
+        '</period_page>',
+        '<session_rows> (header = [#row | timestamp | speaker]; dev lines may ONLY copy from rows whose speaker is "user")',
+        rows.map(recordView).join('\n\n'),
+        '</session_rows>',
+        '<research> (what people actually hit; cite nothing, just speak to it)',
+        researchText || '(none)',
+        '</research>',
+        `BRIEF:\n- Viewer: ${brief.viewer}\n- They are living through: ${brief.situation}\n- Angle: ${brief.angle}\n- Problems to speak to: ${brief.problems.join(' | ') || '(none)'}\n` +
+            (brief.stake ? `- STAKE (show it): ${brief.stake.quantity}: BEFORE ${brief.stake.before} -> AFTER ${brief.stake.after}\n` : '') +
+            `- Built on: "${brief.story}" (rows ${brief.fromRow}-${brief.toRow})\n- Format: ${fmt ? `${fmt.name} — beats: ${fmt.beats}` : brief.format}` +
+            (brief.owner ? `\n- Developer (owns the video): ${brief.owner.name}${brief.owner.handle ? ` (${brief.owner.handle})` : ''}` : '\n- Developer name unknown: no name in the sign-off'),
+        `TIER: ${t.label}. ${t.promise}\nBeats:\n${t.beats.map((b, i) => `${i + 1}. ${b}`).join('\n')}\n` +
+            `BUDGET: ${t.budget}\nLENGTH: ${t.words.min}-${t.words.max} spoken words in total (hard limit ${t.minS}-${t.maxS}s at ${WORDS_PER_SECOND} words/s). Dev lines: ${t.devLines.min}-${t.devLines.max}.`,
+        `RULES:\n${SCRIPT_RULES.map(r => `- ${r}`).join('\n')}`,
+        'Output ONLY: {"title": "<= 80 chars", "hook": "one line", "lines": [{"speaker": "narrator"|"dev"|"agent", "text": "...", "row": <row number, dev lines only>}], ' +
+            '"causes": [each distinct cause (fault or catch needing its own fix) the script tells, one short phrase each], ' +
+            '"terms": [each load-bearing term the viewer must understand, as written]}',
+    ].join('\n\n');
+}
+const SPEAKER = {
+    dev: 'dev', developer: 'dev', user: 'dev', agent: 'agent', assistant: 'agent', ai: 'agent', narrator: 'narrator', narr: 'narrator',
+};
+/** Tolerant parse of the model's reply into a Script. Never throws. */
+export function normalizeScript(raw, brief) {
+    const j = raw && typeof raw === 'object' ? raw : {};
+    const src = Array.isArray(j.lines) ? j : j.script && typeof j.script === 'object' ? j.script : j;
+    const lines = [];
+    for (const l of Array.isArray(src.lines) ? src.lines.slice(0, MAX_LINES) : []) {
+        const who = String(l?.speaker ?? l?.voice ?? l?.who ?? 'narrator').toLowerCase().trim();
+        const text = String(l?.text ?? l?.say ?? l?.line ?? '').replace(/\s+/g, ' ').trim();
+        if (!text)
+            continue;
+        const speaker = SPEAKER[who] ?? 'narrator';
+        const rowN = Math.floor(Number(String(l?.row ?? l?.source_row ?? '').replace(/^#/, '')));
+        lines.push({ speaker, text, ...(Number.isFinite(rowN) && rowN > 0 ? { row: rowN } : {}) });
+    }
+    const list = (v) => (Array.isArray(v) ? v : []).map(x => String(typeof x === 'object' && x ? (x.text ?? x.term ?? x.cause ?? '') : x).replace(/\s+/g, ' ').trim()).filter(Boolean).slice(0, 30);
+    const clip = (s, n) => String(s ?? '').replace(/\s+/g, ' ').trim().slice(0, n);
+    return {
+        id: brief.id, tier: brief.tier, title: clip(src.title, 120), hook: clip(src.hook, 280), lines,
+        causes: list(src.causes ?? j.causes), terms: list(src.terms ?? j.terms),
+        words: lines.reduce((n, l) => n + countWords(l.text), 0), estSeconds: estimateSeconds(lines),
+    };
+}
+/** Generate one script. One model call. */
+export async function writeScript(brief, page, records, researchText, llm) {
+    const rows = rowsForBrief(records, brief);
+    const maxOut = brief.tier === 'howto' ? 3000 : 1800;
+    const r = await llmJson(llm, { what: `script ${brief.id}`, system: SCRIPT_SYSTEM, user: scriptPrompt(brief, page, rows, researchText), maxOut, temperature: 0.4 });
+    return { script: normalizeScript(r.json, brief), costUsd: r.costUsd };
+}
+const LABEL = { narrator: 'NARRATOR', dev: 'DEVELOPER (verbatim)', agent: 'AGENT' };
+/** Plain transcript (one line per spoken line) — the ingest `transcript` field. */
+export const scriptTranscript = (s) => s.lines.map(l => `${LABEL[l.speaker]}: ${l.text}`).join('\n');

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

@@ -63,5 +63,12 @@ export declare function contentHashFor(p: Pick<IngestPage, 'sessionId' | 'startR
 export declare function buildIngestPayload(p: IngestPage, scrub?: (s: string) => string): Record<string, unknown>;
 /** POST one page to content_ingest. Never throws; returns the state to record in the manifest. */
 export declare function ingestPage(p: IngestPage, o?: IngestOptions): Promise<IngestState>;
+/**
+ * The content_ingest RPC call itself, shared by library pages and Stage A script
+ * drafts (content-ingest.ts). `payload` must already be redacted and must carry
+ * `content_hash`; null = only resolve config (returns skipped when not configured).
+ * Never throws. Logs outcomes only (never the token, headers or body).
+ */
+export declare function postContentIngest(payload: Record<string, unknown> | null, contentHash: string, tag: string, o?: IngestOptions): Promise<IngestState>;
 /** Does this manifest entry still need an ingest attempt? */
 export declare function needsIngest(state: IngestState | undefined, currentHash: string): boolean;

package/dist/content/lens-ingest.js

@@ -85,16 +85,33 @@ export function buildIngestPayload(p, scrub = s => s) {
 }
 /** POST one page to content_ingest. Never throws; returns the state to record in the manifest. */
 export async function ingestPage(p, o = {}) {
-    const log = o.log ?? (() => { });
-    const at = new Date().toISOString();
     let contentHash = '';
-    const tag = `library: ingest period ${p.index} (#${p.startRowId})`;
     try {
         contentHash = contentHashFor(p);
+        if (!resolveIngestConfig().ok)
+            return postContentIngest(null, contentHash, '', o);
+        return postContentIngest(buildIngestPayload(p, o.scrub), contentHash, `library: ingest period ${p.index} (#${p.startRowId})`, o);
+    }
+    catch {
+        (o.log ?? (() => { }))(`library: ingest period ${p.index} (#${p.startRowId}) → failed: network (will retry next run)`);
+        return { status: 'error', reason: 'network', contentHash, at: new Date().toISOString() };
+    }
+}
+/**
+ * The content_ingest RPC call itself, shared by library pages and Stage A script
+ * drafts (content-ingest.ts). `payload` must already be redacted and must carry
+ * `content_hash`; null = only resolve config (returns skipped when not configured).
+ * Never throws. Logs outcomes only (never the token, headers or body).
+ */
+export async function postContentIngest(payload, contentHash, tag, o = {}) {
+    const log = o.log ?? (() => { });
+    const at = new Date().toISOString();
+    try {
         const cfg = resolveIngestConfig();
         if (!cfg.ok)
             return { status: 'skipped', reason: cfg.reason, contentHash, at };
-        const payload = buildIngestPayload(p, o.scrub);
+        if (!payload)
+            return { status: 'skipped', reason: 'no-payload', contentHash, at };
         const body = JSON.stringify({ p_token: cfg.token, p_payload: payload });
         const bytes = Buffer.byteLength(body, 'utf-8');
         if (bytes > INGEST_MAX_BYTES) {

package/dist/content/transcript-sanitizer.js

@@ -107,6 +107,12 @@ export const SECRET_RULES = [
         re: /(?<![A-Za-z0-9_])snx_proj_[A-Za-z0-9_-]{20,}/g,
         replace: '[REDACTED-SONIOX-KEY]',
     },
+    // Bare Soniox key (snx_<body>, no proj_ segment); the 16-char floor skips prefix mentions.
+    {
+        kind: 'SONIOX-KEY',
+        re: /(?<![A-Za-z0-9_])snx_(?!proj_)[A-Za-z0-9]{16,}/g,
+        replace: '[REDACTED-SONIOX-KEY]',
+    },
     // JWTs (header.payload.signature, base64url).
     {
         kind: 'JWT',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.9.251",
+  "version": "0.9.252",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {