osborn 0.9.249 → 0.9.251

package/dist/content/lens-audio.js

@@ -0,0 +1,105 @@
+/**
+ * lens-audio.ts — OPTIONAL, pluggable session-recording lookup (no paid calls).
+ *
+ * LiveKit egress is not enabled today, so this is a convention-based local
+ * lookup. Checks, in order:
+ *   1. <projectDir>/recordings/<sessionId>.<media-ext>
+ *   2. $OSBORN_RECORDINGS_DIR/<sessionId>.<media-ext>
+ * An optional sidecar <sessionId>.json ({ "startedAt": ISO | epoch-ms | "started_at": ns })
+ * pins the recording start exactly; without it the start is approximated by the
+ * first transcript record's timestamp and offsets are marked approximate.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+const MEDIA_EXT = ['.mp4', '.webm', '.ogg', '.opus', '.m4a', '.mp3', '.wav', '.mkv'];
+function parseStart(meta) {
+    if (!meta || typeof meta !== 'object')
+        return null;
+    const v = meta.startedAt ?? meta.started_at ?? meta.startTime;
+    if (typeof v === 'string') {
+        if (/^\d+$/.test(v))
+            return parseStart({ startedAt: Number(v) });
+        const t = Date.parse(v);
+        return Number.isFinite(t) ? t : null;
+    }
+    if (typeof v === 'number' && Number.isFinite(v)) {
+        if (v > 1e17)
+            return Math.floor(v / 1e6); // ns (LiveKit egress started_at)
+        if (v > 1e14)
+            return Math.floor(v / 1e3); // µs
+        if (v > 1e11)
+            return v; // ms
+        return v * 1000; // s
+    }
+    return null;
+}
+function lookIn(dir, sessionId) {
+    if (!dir || !existsSync(dir))
+        return null;
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return null;
+    }
+    const media = names.find(n => n.startsWith(sessionId + '.') && MEDIA_EXT.some(e => n.toLowerCase().endsWith(e)));
+    if (!media)
+        return null;
+    let startedAtMs = null;
+    const side = join(dir, `${sessionId}.json`);
+    if (existsSync(side)) {
+        try {
+            startedAtMs = parseStart(JSON.parse(readFileSync(side, 'utf-8')));
+        }
+        catch {
+            /* bad sidecar → approximate */
+        }
+    }
+    return { path: join(dir, media), startedAtMs };
+}
+/** Pluggable lookup. Returns null when no recording exists (the normal case today). */
+export function findSessionRecording(sessionId, projectDir) {
+    if (!sessionId || !/^[A-Za-z0-9._-]{1,128}$/.test(sessionId))
+        return null;
+    try {
+        if (projectDir) {
+            const r = lookIn(join(projectDir, 'recordings'), sessionId);
+            if (r)
+                return r;
+        }
+        const envDir = process.env.OSBORN_RECORDINGS_DIR;
+        return envDir ? lookIn(envDir, sessionId) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Choose the alignment origin: sidecar start (exact) or first transcript record (approximate). */
+export function alignRecording(rec, firstRecordIso) {
+    if (rec.startedAtMs !== null) {
+        return { path: rec.path, startIso: new Date(rec.startedAtMs).toISOString(), approximate: false, basis: 'sidecar startedAt' };
+    }
+    if (firstRecordIso && Number.isFinite(Date.parse(firstRecordIso))) {
+        return { path: rec.path, startIso: firstRecordIso, approximate: true, basis: 'first session record timestamp' };
+    }
+    return null;
+}
+/** Default adapter: the local convention lookup above (null today — no egress). */
+export const localRecordingAdapter = {
+    align(sessionId, projectDir, firstRecordIso) {
+        const rec = findSessionRecording(sessionId, projectDir);
+        return rec ? alignRecording(rec, firstRecordIso) : null;
+    },
+};
+/** Clip offset "H:MM:SS" of a quote relative to the recording start; null if before start. */
+export function clipOffset(quoteIso, startIso) {
+    const d = Date.parse(quoteIso) - Date.parse(startIso);
+    if (!Number.isFinite(d) || d < 0)
+        return null;
+    const s = Math.floor(d / 1000);
+    const hh = Math.floor(s / 3600);
+    const mm = Math.floor((s % 3600) / 60);
+    const ss = s % 60;
+    return `${hh}:${String(mm).padStart(2, '0')}:${String(ss).padStart(2, '0')}`;
+}

package/dist/content/lens-clip-arc.d.ts

@@ -0,0 +1,80 @@
+/**
+ * lens-clip-arc.ts — pass two, step 3: "understand what really happened".
+ *
+ * One model call reads the expanded window(s) (transcript FIRST, instructions
+ * AFTER, as lens-model.ts) and returns a human arc. Every beat is carried by the
+ * USER'S OWN verbatim lines; facts only support. Each line is then verified
+ * deterministically with lens-quotes (same rules as pass one) and the speaker is
+ * taken from the matched row, never the model. A "user" line that is really a
+ * pasted review/log/doc (text after a paste marker in that row) is demoted to
+ * support. A beat left with no verified user line is marked "no user voice".
+ */
+import { type DbRecord } from './lens-db.js';
+import { type Quote } from './lens-quotes.js';
+export declare const SINGLE_BEATS: readonly ["goal", "obstacle", "attempts", "turning_point", "fix", "payoff"];
+export interface ArcLine extends Quote {
+    /** true = user's own spoken words; false = assistant or pasted text (support only). */
+    voice: boolean;
+    /** Compilation: which clip (A, B, …) the row belongs to. */
+    clip?: string;
+}
+export interface ArcBeat {
+    beat: string;
+    summary: string;
+    clip?: string;
+    userLines: ArcLine[];
+    supportLines: ArcLine[];
+    noUserVoice: boolean;
+    dropped: number;
+}
+export interface Arc {
+    title: string;
+    question: string;
+    beats: ArcBeat[];
+    genuine: {
+        answers: boolean;
+        why: string;
+    } | null;
+    cut: {
+        clip: string;
+        what: string;
+        why: string;
+    }[];
+    linesDropped: number;
+    demotedPasted: number;
+}
+/** True when `quote` sits inside pasted material of `rowText` (a review, log, doc) rather than the user's words. */
+export declare function isPastedSpan(rowText: string, quote: string): boolean;
+export interface RawLine {
+    text?: unknown;
+    timestamp?: unknown;
+    row?: unknown;
+}
+/**
+ * Verify every line of every beat against the window rows. Pure + deterministic.
+ * `clipOf` maps a row id to its clip label (compilation).
+ */
+export declare function verifyBeats(raw: {
+    beat?: unknown;
+    summary?: unknown;
+    clip?: unknown;
+    user_lines?: unknown;
+    support_lines?: unknown;
+}[], records: DbRecord[], clipOf?: (row: number) => string | undefined): {
+    beats: ArcBeat[];
+    dropped: number;
+    demoted: number;
+};
+export interface ArcPromptOpts {
+    mode: 'single' | 'compilation';
+    /** Reverse mode: the demand thread the clip must answer. */
+    thread?: string;
+    /** Compilation topic. */
+    topic?: string;
+}
+/** Windows labelled A, B, … with dates; transcript first, task after. */
+export declare function arcPrompt(windows: {
+    label: string;
+    records: DbRecord[];
+}[], o: ArcPromptOpts): string;
+export declare function readArc(raw: string, records: DbRecord[], clipOf?: (row: number) => string | undefined): Arc | null;

package/dist/content/lens-clip-arc.js

@@ -0,0 +1,148 @@
+/**
+ * lens-clip-arc.ts — pass two, step 3: "understand what really happened".
+ *
+ * One model call reads the expanded window(s) (transcript FIRST, instructions
+ * AFTER, as lens-model.ts) and returns a human arc. Every beat is carried by the
+ * USER'S OWN verbatim lines; facts only support. Each line is then verified
+ * deterministically with lens-quotes (same rules as pass one) and the speaker is
+ * taken from the matched row, never the model. A "user" line that is really a
+ * pasted review/log/doc (text after a paste marker in that row) is demoted to
+ * support. A beat left with no verified user line is marked "no user voice".
+ */
+import { recordView } from './lens-db.js';
+import { buildRecordIndex, looseText, parseJsonObject, verifyQuote } from './lens-quotes.js';
+export const SINGLE_BEATS = ['goal', 'obstacle', 'attempts', 'turning_point', 'fix', 'payoff'];
+/** Paste markers: text at/after one of these in a user row is not the user's own voice. */
+const PASTE_MARKER = /\[review\]|(?:^| )#{1,4} \S|\breject:|\bapprove:|\[liked\]|\[disliked\]|<\/?[a-z_]+>|^\[time: [^\]]*\] (?:#|\[)/;
+/** True when `quote` sits inside pasted material of `rowText` (a review, log, doc) rather than the user's words. */
+export function isPastedSpan(rowText, quote) {
+    const row = looseText(rowText);
+    const q = looseText(quote);
+    const at = row.indexOf(q);
+    if (at === -1)
+        return false;
+    const m = PASTE_MARKER.exec(row);
+    if (m && m.index <= at)
+        return true;
+    return row.length > 4000 && at > 600;
+}
+/**
+ * Verify every line of every beat against the window rows. Pure + deterministic.
+ * `clipOf` maps a row id to its clip label (compilation).
+ */
+export function verifyBeats(raw, records, clipOf = () => undefined) {
+    const idx = buildRecordIndex(records);
+    const byId = new Map(records.map(r => [r.id, r]));
+    let dropped = 0;
+    let demoted = 0;
+    const beats = [];
+    for (const b of raw) {
+        const name = typeof b?.beat === 'string' ? b.beat.trim() : '';
+        if (!name)
+            continue;
+        const user = [];
+        const support = [];
+        let bd = 0;
+        const lines = [
+            ...(Array.isArray(b.user_lines) ? b.user_lines.slice(0, 2) : []),
+            ...(Array.isArray(b.support_lines) ? b.support_lines.slice(0, 2) : []),
+        ];
+        const seen = new Set();
+        for (const l of lines) {
+            const v = verifyQuote(l, idx);
+            if (!v) {
+                bd++;
+                continue;
+            }
+            const key = `${v.row}:${looseText(v.text)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const src = byId.get(v.row);
+            const pasted = v.speaker === 'user' && !!src && isPastedSpan(src.text, v.text);
+            if (pasted)
+                demoted++;
+            const line = { ...v, voice: v.speaker === 'user' && !pasted, clip: clipOf(v.row) };
+            if (line.voice && user.length < 2)
+                user.push(line);
+            else if (!line.voice && support.length < 2)
+                support.push(line);
+        }
+        dropped += bd;
+        beats.push({
+            beat: name,
+            summary: typeof b.summary === 'string' ? b.summary.trim() : '',
+            clip: typeof b.clip === 'string' ? b.clip.trim() : user[0]?.clip ?? support[0]?.clip,
+            userLines: user,
+            supportLines: support,
+            noUserVoice: user.length === 0,
+            dropped: bd,
+        });
+    }
+    return { beats, dropped, demoted };
+}
+const LINE_RULES = 'LINES: each line = {"text": exact verbatim substring (12-300 chars) copied character-for-character from ONE record, ' +
+    '"timestamp": that record\'s exact timestamp from its [#row | timestamp | speaker] header, "row": its row number (digits only)}. ' +
+    'ONE contiguous span: no ellipses, no skipped words, no joined sentences, no typo fixes — the person speaks by voice, so keep ' +
+    'their disfluencies exactly. "user_lines": 1-2 lines from USER records that are the person\'s OWN spoken words at that moment ' +
+    '(their frustration, their clue, their reaction) — NOT text they pasted (reviews, logs, docs, links). "support_lines": 0-2 ' +
+    'assistant lines that state the technical fact. Never quote secrets, keys, tokens, emails, client names, or personal details; ' +
+    'keep masked tags like [client] as they are.';
+/** Windows labelled A, B, … with dates; transcript first, task after. */
+export function arcPrompt(windows, o) {
+    const blocks = windows.map(w => {
+        const d0 = w.records[0]?.timestamp.slice(0, 10);
+        const d1 = w.records[w.records.length - 1]?.timestamp.slice(0, 10);
+        return `<clip id="${w.label}" dates="${d0}${d1 !== d0 ? ` to ${d1}` : ''}">\n${w.records.map(recordView).join('\n\n')}\n</clip>`;
+    });
+    const montage = o.mode === 'single' && windows.length > 1;
+    const head = o.mode === 'single' && !montage
+        ? 'Below is one contiguous stretch of a raw, unedited voice work session between a person (user) and their AI coding ' +
+            'assistant (assistant), pulled from a much longer session. Read all of it; your task follows.'
+        : `Below are ${windows.length} stretches from DIFFERENT points in time (possibly hours or days apart) of ONE long, raw, ` +
+            'unedited voice work session between a person (user) and their AI coding assistant. Read all of them; your task follows.';
+    const thread = o.thread ? `\n<demand_thread>\n${o.thread.slice(0, 12_000)}\n</demand_thread>` : '';
+    const task = o.mode === 'single'
+        ? 'TASK: like a streamer clipping a highlight, find the ONE human story in this stretch and tell it answer-first. ' +
+            `Beats, in order: ${SINGLE_BEATS.join(', ')} — goal (what they were trying to do and why it mattered), obstacle ` +
+            '(the symptom), attempts (what was tried, dead ends), turning_point (the clue), fix, payoff. Build each beat around ' +
+            'what the PERSON said at that moment; technical facts only support. If a beat truly has no user line, give an empty ' +
+            'user_lines array — do not force one.' +
+            (montage
+                ? ' This is a short MONTAGE of steps ("did this -> did this -> did this") across the stretches: keep the beats in ' +
+                    'chronological order, give each beat its "clip" id, and make "summary" a one-line step label.'
+                : '')
+        : `TASK: stitch these clips into ONE coherent, edited episode about: ${o.topic || 'the recurring topic'}. Keep the full ` +
+            'message, cut the noise (tangents, interruptions, retries, filler). Beats in chronological order showing how the ' +
+            'understanding evolved: first understanding, what was tried first, what failed and why, the re-think, what finally ' +
+            'worked, how it was verified. 5-8 beats; each beat names its "clip" id and carries only what serves the through-line. ' +
+            'Also list what you cut as noise.';
+    const genuine = o.thread
+        ? ' The clip must answer the demand_thread above. Add "genuine": {"answers": true|false, "why": one line} — true ONLY if ' +
+            'this stretch shows real, first-hand experience that actually addresses the thread\'s core problem (not merely the same keywords).'
+        : '';
+    const shape = o.mode === 'single'
+        ? '{"title": short topic title, "question": the one question this clip answers, "beats": [{"beat", ' +
+            (montage ? '"clip": "A", ' : '') + '"summary": one line, ' +
+            '"user_lines": [...], "support_lines": [...]}]' + (o.thread ? ', "genuine": {...}' : '') + '}'
+        : '{"title", "question": the question the episode answers, "beats": [{"beat": short name, "clip": "A", "summary", ' +
+            '"user_lines": [...], "support_lines": [...]}], "cut": [{"clip": "A", "what": short description, "why": "tangent|interruption|retry|filler|off-topic"}]}';
+    return [head, ...blocks, thread, task + genuine, LINE_RULES, `Output ONLY: ${shape}`].filter(Boolean).join('\n\n');
+}
+export function readArc(raw, records, clipOf) {
+    const o = parseJsonObject(raw);
+    if (!o || !Array.isArray(o.beats))
+        return null;
+    const v = verifyBeats(o.beats, records, clipOf);
+    const g = o.genuine;
+    const cut = Array.isArray(o.cut) ? o.cut : [];
+    return {
+        title: String(o.title ?? '').trim(),
+        question: String(o.question ?? '').trim(),
+        beats: v.beats,
+        genuine: g && typeof g === 'object' ? { answers: g.answers === true, why: String(g.why ?? '').trim() } : null,
+        cut: cut.map(c => ({ clip: String(c?.clip ?? ''), what: String(c?.what ?? ''), why: String(c?.why ?? '') })).filter(c => c.what),
+        linesDropped: v.dropped,
+        demotedPasted: v.demoted,
+    };
+}

package/dist/content/lens-clip-formats.d.ts

@@ -0,0 +1,58 @@
+/**
+ * lens-clip-formats.ts — pass two, step 4-5: cut the verified arc into formats,
+ * then check them. Topic-only voice by default; first-person only in the post
+ * variants, flagged. The user's VERIFIED lines are the on-screen quotes.
+ *
+ * Checks never block, they FLAG: deterministic (on-screen quote must be a
+ * verified user line, asset paths must appear in the source rows, first person
+ * in topic-only formats, length targets) + the pipeline-e2e truth-check (draft +
+ * source rows → list of ungrounded claims) on every format.
+ */
+import { type DbRecord } from './lens-db.js';
+import type { Arc } from './lens-clip-arc.js';
+export interface ScriptBeat {
+    label: string;
+    seconds: number;
+    voiceover: string;
+    onScreenQuote: {
+        row: number;
+        text: string;
+    } | null;
+    timeJump?: string;
+    assets: {
+        kind: string;
+        ref: string;
+        note: string;
+    }[];
+}
+export interface Formats {
+    hook: string;
+    script: ScriptBeat[];
+    /** Compilation only: derived cuts of the long script. */
+    medium: ScriptBeat[];
+    short: ScriptBeat[];
+    linkedin: string;
+    linkedinFirstPerson: string;
+    x: string;
+    xFirstPerson: string;
+    comment: string;
+    flags: string[];
+}
+export declare function arcForPrompt(arc: Arc): string;
+export declare function formatsPrompt(sources: {
+    label: string;
+    records: DbRecord[];
+}[], arc: Arc, o: {
+    mode: 'single' | 'compilation';
+    thread?: string;
+}): string;
+export declare function readFormats(raw: string): Formats | null;
+/** First-person words outside quoted spans. */
+export declare function hasFirstPerson(text: string): boolean;
+/** Deterministic checks. Mutates nothing in place except removing unverified on-screen quotes; returns flags. */
+export declare function checkFormats(f: Formats, arc: Arc, sourceText: string): string[];
+/** Plain-text renderings fed to the truth-check, one per format. */
+export declare function formatTexts(f: Formats): [string, string][];
+/** The pipeline-e2e truth-check prompt (same wording), source FIRST, instructions after. */
+export declare function truthCheckPrompt(sourceText: string, draft: string): string;
+export declare function parseStringArray(raw: string): string[] | null;

package/dist/content/lens-clip-formats.js

@@ -0,0 +1,175 @@
+/**
+ * lens-clip-formats.ts — pass two, step 4-5: cut the verified arc into formats,
+ * then check them. Topic-only voice by default; first-person only in the post
+ * variants, flagged. The user's VERIFIED lines are the on-screen quotes.
+ *
+ * Checks never block, they FLAG: deterministic (on-screen quote must be a
+ * verified user line, asset paths must appear in the source rows, first person
+ * in topic-only formats, length targets) + the pipeline-e2e truth-check (draft +
+ * source rows → list of ungrounded claims) on every format.
+ */
+import { recordView } from './lens-db.js';
+import { looseText, parseJsonObject } from './lens-quotes.js';
+const str = (v) => (typeof v === 'string' ? v.trim() : '');
+const lineJson = (l) => ({ row: l.row, date: l.timestamp.slice(0, 10), text: l.text, ...(l.clip ? { clip: l.clip } : {}) });
+export function arcForPrompt(arc) {
+    return JSON.stringify({
+        title: arc.title,
+        question: arc.question,
+        beats: arc.beats.map(b => ({
+            beat: b.beat,
+            clip: b.clip,
+            summary: b.summary,
+            user_lines: b.userLines.map(lineJson),
+            support_lines: b.supportLines.map(lineJson),
+            ...(b.noUserVoice ? { note: 'no user voice' } : {}),
+        })),
+    }, null, 1);
+}
+export function formatsPrompt(sources, arc, o) {
+    const src = sources.map(s => `<clip id="${s.label}">\n${s.records.map(recordView).join('\n\n')}\n</clip>`).join('\n\n');
+    const script = o.mode === 'single'
+        ? '"script": EXACTLY 4 beats, 30-50 seconds total, answer-first (the payoff/clue up front, then how). If the arc spans ' +
+            'several clips it is a montage of steps: chronological, each beat "label" a one-line step label.'
+        : '"script": the LONG-FORM episode, 2-4 minutes total (6-10 beats, chronological); every beat whose clip is days/weeks after ' +
+            'the previous one gets "time_jump" (e.g. "two weeks later") computed from the clip dates. "medium": 60-90s cut derived ' +
+            'from the long script (4-6 beats); "short": 30-45s cut (3-4 beats). Medium/short reuse long-script beats and quotes.';
+    const beatShape = '{"label", "seconds", "voiceover": TOPIC-ONLY narration (no I/we/my), "on_screen_quote": {"row", "text"} copied EXACTLY from ' +
+        'one of the arc user_lines (or null), ' +
+        (o.mode === 'compilation' ? '"time_jump": "" or e.g. "two weeks later", ' : '') +
+        '"assets": [{"kind": "code"|"diagram"|"screen"|"log"|"reenactment", "ref": real file path / log line / thing to draw that ' +
+        'appears in the source, "note"}]}. Any reenactment MUST be kind "reenactment".';
+    return [
+        'Below are the SOURCE rows (ground truth) and then a VERIFIED story arc built from them. Your task follows.',
+        src,
+        `<arc>\n${arcForPrompt(arc)}\n</arc>`,
+        o.thread ? `<demand_thread>\n${o.thread.slice(0, 12_000)}\n</demand_thread>` : '',
+        'TASK: cut the arc into publishable formats. The person\'s own verified lines carry the story; technical facts support it. ' +
+            'Use ONLY facts present in the source rows — no invented numbers, timings, names or outcomes. Client details stay masked ' +
+            '([client] etc.). No hype, no emoji, no clickbait.',
+        `FORMATS: "hook": one line, topic-only. ${script} Script beat = ${beatShape} ` +
+            '"linkedin": 120-200 words, topic-only voice (no I/we/my). "linkedin_first_person": the same post in first person ' +
+            '(it will be flagged for the person\'s approval). "x": <= 280 characters, topic-only. "x_first_person": <= 280, first person. ' +
+            (o.thread
+                ? '"comment": a GitHub/HN reply to the demand_thread: answer ONLY what the thread asks, from this grounded experience, ' +
+                    'concrete and short (80-180 words). No promotion, no product plug; if mentioning the tool is unavoidable, prefix that ' +
+                    'sentence with "[disclosure]".'
+                : '"comment": "".'),
+        'Output ONLY: {"hook", "script": [...], ' + (o.mode === 'compilation' ? '"medium": [...], "short": [...], ' : '') +
+            '"linkedin", "linkedin_first_person", "x", "x_first_person", "comment"}',
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+}
+function readBeats(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.map(b => ({
+        label: str(b?.label),
+        seconds: Number(b?.seconds) || 0,
+        voiceover: str(b?.voiceover),
+        onScreenQuote: b?.on_screen_quote && str(b.on_screen_quote.text) ? { row: Number(String(b.on_screen_quote.row).replace(/^#/, '')) || 0, text: str(b.on_screen_quote.text) } : null,
+        timeJump: str(b?.time_jump) || undefined,
+        assets: Array.isArray(b?.assets) ? b.assets.map((a) => ({ kind: str(a?.kind), ref: str(a?.ref), note: str(a?.note) })).filter((a) => a.ref) : [],
+    }));
+}
+export function readFormats(raw) {
+    const o = parseJsonObject(raw);
+    if (!o)
+        return null;
+    return {
+        hook: str(o.hook), script: readBeats(o.script), medium: readBeats(o.medium), short: readBeats(o.short),
+        linkedin: str(o.linkedin), linkedinFirstPerson: str(o.linkedin_first_person), x: str(o.x), xFirstPerson: str(o.x_first_person),
+        comment: str(o.comment), flags: [],
+    };
+}
+const FIRST_PERSON = /\b(I|I'm|I've|I'd|my|me|mine|we|we're|we've|our|ours|us)\b/;
+/** First-person words outside quoted spans. */
+export function hasFirstPerson(text) {
+    return FIRST_PERSON.test(text.replace(/"[^"]*"|“[^”]*”/g, ' '));
+}
+/** Deterministic checks. Mutates nothing in place except removing unverified on-screen quotes; returns flags. */
+export function checkFormats(f, arc, sourceText) {
+    const flags = [];
+    const verified = arc.beats.flatMap(b => b.userLines);
+    const src = looseText(sourceText);
+    for (const [name, beats] of [['script', f.script], ['medium', f.medium], ['short', f.short]]) {
+        for (const b of beats) {
+            if (b.onScreenQuote) {
+                const q = looseText(b.onScreenQuote.text);
+                const hit = verified.find(l => looseText(l.text).includes(q) || q.includes(looseText(l.text)));
+                if (!hit || q.length < 12) {
+                    flags.push(`${name} "${b.label}": on-screen quote is not a verified user line — removed`);
+                    b.onScreenQuote = null;
+                }
+                else
+                    b.onScreenQuote = { row: hit.row, text: hit.text };
+            }
+            if (hasFirstPerson(b.voiceover))
+                flags.push(`${name} "${b.label}": first person in topic-only narration`);
+            for (const a of b.assets) {
+                const pathLike = /[\w-]+\/[\w./-]+|\b[\w-]+\.(?:ts|js|tsx|json|md|sh|yml|yaml|toml|py)\b/.exec(a.ref);
+                if (pathLike && !src.includes(looseText(pathLike[0])))
+                    flags.push(`${name} "${b.label}": asset "${pathLike[0]}" not found in source rows`);
+                if (/reenact|recreat|mock/i.test(`${a.ref} ${a.note}`) && a.kind !== 'reenactment')
+                    flags.push(`${name} "${b.label}": unlabeled reenactment "${a.ref}"`);
+            }
+        }
+        if (beats.length) {
+            const secs = beats.reduce((s, b) => s + b.seconds, 0);
+            const words = beats.reduce((s, b) => s + b.voiceover.split(/\s+/).filter(Boolean).length, 0);
+            flags.push(`${name}: ${beats.length} beats, ${secs}s stated, ~${Math.round(words / 2.5)}s at 150 wpm`);
+        }
+    }
+    if (hasFirstPerson(f.hook))
+        flags.push('hook: first person in topic-only format');
+    if (hasFirstPerson(f.linkedin))
+        flags.push('linkedin: first person in topic-only post');
+    if (hasFirstPerson(f.x))
+        flags.push('x: first person in topic-only post');
+    const wc = f.linkedin.split(/\s+/).filter(Boolean).length;
+    if (wc && (wc < 120 || wc > 200))
+        flags.push(`linkedin: ${wc} words (target 120-200)`);
+    for (const [n, t] of [['x', f.x], ['x_first_person', f.xFirstPerson]])
+        if ([...t].length > 280)
+            flags.push(`${n}: ${[...t].length} chars (> 280)`);
+    if (f.linkedinFirstPerson)
+        flags.push('linkedin_first_person: FIRST-PERSON variant — needs the person\'s approval');
+    if (f.xFirstPerson)
+        flags.push('x_first_person: FIRST-PERSON variant — needs the person\'s approval');
+    if (/\[disclosure\]/i.test(f.comment))
+        flags.push('comment: contains a [disclosure] product mention — check it is directly relevant');
+    return flags;
+}
+/** Plain-text renderings fed to the truth-check, one per format. */
+export function formatTexts(f) {
+    const beats = (bs) => bs.map(b => `${b.timeJump ? `(${b.timeJump}) ` : ''}${b.voiceover}${b.onScreenQuote ? ` [on screen: "${b.onScreenQuote.text}"]` : ''}`).join('\n');
+    const out = [['hook', f.hook], ['script', beats(f.script)], ['medium', beats(f.medium)], ['short', beats(f.short)],
+        ['linkedin', f.linkedin], ['linkedin_first_person', f.linkedinFirstPerson], ['x', f.x], ['x_first_person', f.xFirstPerson], ['comment', f.comment]];
+    return out.filter(([, t]) => t.trim());
+}
+/** The pipeline-e2e truth-check prompt (same wording), source FIRST, instructions after. */
+export function truthCheckPrompt(sourceText, draft) {
+    return [
+        `SOURCE RECORDS (ground truth, speaker-tagged):\n${sourceText}`,
+        `DRAFT POST:\n${draft}`,
+        '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 [].',
+    ].join('\n\n');
+}
+export function parseStringArray(raw) {
+    const s = raw.trim().replace(/^```(?:json)?\s*/i, '').replace(/```\s*$/i, '').trim();
+    const a = s.indexOf('[');
+    const b = s.lastIndexOf(']');
+    if (a === -1 || b < a)
+        return null;
+    try {
+        const arr = JSON.parse(s.slice(a, b + 1));
+        return Array.isArray(arr) ? arr.map(x => String(x ?? '').trim()).filter(Boolean) : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/content/lens-clip-search.d.ts

@@ -0,0 +1,51 @@
+/**
+ * lens-clip-search.ts — REVERSE direction + compilation topic search.
+ *
+ * demand thread (or topic) → a few search queries (one cheap model call) → the
+ * recall store's OWN search (session-store.ts recall(): FTS5 BM25 + vector, RRF,
+ * read-only) over session.db → keep only conversation rows the lens may read
+ * (sanitized user/assistant main rows) → cluster nearby hits → anchors.
+ * A weak cluster (few distinct queries / few hits) is reported as such; the
+ * caller then refuses to force a draft.
+ */
+import type { DbRecord } from './lens-db.js';
+/** Public thread → plain text. GitHub issues/PRs and HN items via their JSON APIs; anything else as stripped HTML. */
+export declare function fetchThread(url: string, maxComments?: number): Promise<{
+    title: string;
+    text: string;
+}>;
+/** Short prompt: demand thread / topic → core problem + 3-5 search queries (instructions after the material). */
+export declare function queriesPrompt(material: string, kind: 'thread' | 'topic'): string;
+export declare function readQueries(raw: string): {
+    problem: string;
+    queries: string[];
+} | null;
+export interface SearchCluster {
+    rows: number[];
+    score: number;
+    hits: number;
+    queries: string[];
+    firstTs: string;
+    lastTs: string;
+}
+export interface SearchResult {
+    clusters: SearchCluster[];
+    mode: 'hybrid' | 'keyword';
+    weak: boolean;
+    weakWhy: string;
+}
+/** Group hits into clusters of nearby conversation rows and rank them. Pure. */
+export declare function rankClusters(records: DbRecord[], hits: Map<number, {
+    score: number;
+    queries: Set<string>;
+}>, mergeRows?: number): SearchCluster[];
+/** Weak = the best cluster is matched by < 2 distinct queries or has < 3 hits. */
+export declare function isWeak(c: SearchCluster | undefined, nQueries: number): {
+    weak: boolean;
+    why: string;
+};
+/**
+ * Run each query through recall() (hybrid when an embedder is available, else
+ * keyword), keep only rows present in `records` (the sanitized conversation view).
+ */
+export declare function searchSession(dbPath: string, records: DbRecord[], queries: string[], topK?: number): Promise<SearchResult>;