reprobe 0.0.0-stage → 0.1.0

package/dist/redact.d.ts

@@ -0,0 +1,3 @@
+export declare function redactText(s: string): string;
+export declare function redactValue<T>(v: T): T;
+export declare function initials(name: string | null | undefined): string;

package/dist/redact.js

@@ -0,0 +1,98 @@
+// Redaction helpers for bug-repro output. Replacement order in redactText matters.
+const SENSITIVE_KEYS = new Set([
+    'phone',
+    'phonenumber',
+    'email',
+    'token',
+    'firebaseuid',
+    'password',
+    'accesstoken',
+    'authorization',
+    'clientsecret',
+    'idtoken',
+    'refreshtoken',
+    'upiid',
+    'apikey',
+    'awsaccesskeyid',
+    'googleaccessid',
+    'secret',
+]);
+const POSTGRES_PASSWORD = /(\bpostgres(?:ql)?:\/\/[^\s:/@]+):[^\s@]+@/g;
+const URL_PASSWORD = /(\bhttps?:\/\/[^\s:/@]+):[^\s/@]+@/gi;
+const JWT = /\beyJ[A-Za-z0-9_-]{7,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g;
+const BEARER = /\bBearer\s+[\w~+\/=\[\]-]+(?:\.[\w~+\/=\[\]-]+)*/g;
+const SECRET_ASSIGNMENT = /(["']?(?:access[_-]?token|refresh[_-]?token|id[_-]?token|token|api[_-]?key|client[_-]?secret|password|secret)["']?\s*[:=]\s*)("(?:\\.|[^"\\])*(?:"|$)|'(?:\\.|[^'\\])*(?:'|$)|[^&,\s;"'<>]+)/gi;
+const BASIC_AUTH = /(["']?Authorization["']?\s*:\s*["']?Basic\s+)[A-Za-z0-9+/=]+/gi;
+const SECRET_KEY = /(?<![A-Za-z0-9_-])(?:sk-lf-|pk-lf-|sk-|sntryu_|lsv2_|ghp_|gho_|xox)[A-Za-z0-9_-]{8,}/g;
+const QUERY_PARAM = /([?&](?:access_token|token|key|sig|signature|x-amz-(?:credential|signature|security-token)|x-goog-(?:credential|signature)|awsaccesskeyid|googleaccessid|key-pair-id|policy)=)[^&#\s"'<>]+/gi;
+const EMAIL = /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g;
+const PHONE_PLUS91 = /\+91(?:[ -]?\d){10}(?!\d)/g;
+const PHONE_PLUS_LONG = /\+\d{11,13}(?!\d)/g;
+const PHONE_PLUS_FORMATTED = /\+(?:\d[ .()-]?){8,15}(?!\d)/g;
+const PHONE_US_FORMATTED = /(?<!\d)(?:\+?1[ .-]?)?\(?[2-9]\d{2}\)?[ .-][2-9]\d{2}[ .-]\d{4}(?!\d)/g;
+const PHONE_LOCAL = /(?<![\w.-])[6-9]\d{9}(?![\w-]|\.\d)/g;
+export function redactText(s) {
+    return s
+        .replace(POSTGRES_PASSWORD, '$1:[redacted]@')
+        .replace(URL_PASSWORD, '$1:[redacted]@')
+        .replace(JWT, '[jwt]')
+        .replace(BEARER, 'Bearer [redacted]')
+        .replace(BASIC_AUTH, '$1[redacted]')
+        .replace(SECRET_ASSIGNMENT, (_match, key, value) => {
+        if (value.startsWith('"'))
+            return `${key}"[redacted]${value.endsWith('"') ? '"' : ''}`;
+        if (value.startsWith("'"))
+            return `${key}'[redacted]${value.endsWith("'") ? "'" : ''}`;
+        return `${key}[redacted]`;
+    })
+        .replace(SECRET_KEY, '[secret]')
+        .replace(QUERY_PARAM, '$1[redacted]')
+        .replace(EMAIL, '[email]')
+        .replace(PHONE_PLUS91, '[phone]')
+        .replace(PHONE_PLUS_LONG, '[phone]')
+        .replace(PHONE_PLUS_FORMATTED, '[phone]')
+        .replace(PHONE_US_FORMATTED, '[phone]')
+        .replace(PHONE_LOCAL, '[phone]');
+}
+export function redactValue(v) {
+    return walk(v, 0);
+}
+function walk(v, depth) {
+    if (typeof v === 'string') {
+        const trimmed = v.trim();
+        if (depth < 3 && (trimmed.startsWith('{') || trimmed.startsWith('[') || trimmed.startsWith('"{') || trimmed.startsWith('"['))) {
+            try {
+                const parsed = JSON.parse(v);
+                return JSON.stringify(walk(parsed, depth + 1));
+            }
+            catch {
+                // Truncated JSON is still handled by the text patterns below.
+            }
+        }
+        return redactText(v);
+    }
+    if (Array.isArray(v))
+        return v.map((item) => walk(item, depth));
+    if (isPlainObject(v)) {
+        const out = {};
+        for (const [k, val] of Object.entries(v)) {
+            const normalizedKey = k.toLowerCase().replace(/[^a-z0-9]/g, '');
+            const sensitive = SENSITIVE_KEYS.has(normalizedKey) && val !== null && val !== undefined;
+            out[redactText(k)] = sensitive ? '[redacted]' : walk(val, depth);
+        }
+        return out;
+    }
+    return v;
+}
+function isPlainObject(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === Object.prototype || proto === null;
+}
+export function initials(name) {
+    const words = (name ?? '').trim().split(/\s+/).filter(Boolean).slice(0, 3);
+    if (words.length === 0)
+        return '?';
+    return words.map((w) => `${w.charAt(0).toUpperCase()}.`).join('');
+}

package/dist/report.d.ts

@@ -0,0 +1,7 @@
+import type { Diagnosis } from './diagnosis.ts';
+import type { Narrative } from './llm.ts';
+import type { Finding, Gathered } from './types.ts';
+import type { VerifyResult } from './verify.ts';
+export declare function renderMarkdown(caseId: string, g: Gathered, findings: Finding[], narrative: Narrative | {
+    error: string;
+} | null, verify?: VerifyResult[], diagnosis?: Diagnosis | null): string;

package/dist/report.js

@@ -0,0 +1,145 @@
+import { redactText } from "./redact.js";
+const inline = (s) => redactText(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/[\\`*_{}\[\]()#+!|~]/g, '\\$&').replace(/[\r\n]/g, ' ');
+const cell = inline;
+const code = (s) => {
+    const safe = redactText(s).replace(/[\r\n]/g, ' ');
+    const ticks = '`'.repeat(Math.max(1, ...[...safe.matchAll(/`+/g)].map((m) => m[0].length + 1)));
+    const padded = safe.startsWith('`') || safe.endsWith('`') || (safe.startsWith(' ') && safe.endsWith(' ')) ? ` ${safe} ` : safe;
+    return `${ticks}${padded}${ticks}`;
+};
+function cite(id, byId) {
+    const e = byId.get(id);
+    if (!e)
+        return '[evidence unavailable]';
+    const displayId = inline(id);
+    let href = '';
+    if (e.link && !/[\u0000-\u001f\u007f]/.test(e.link)) {
+        try {
+            const url = new URL(redactText(e.link));
+            if (/^https?:$/.test(url.protocol) && !url.username && !url.password)
+                href = url.href.replace(/[()]/g, (c) => c === '(' ? '%28' : '%29');
+        }
+        catch {
+            href = '';
+        }
+    }
+    const ref = href ? `[${displayId}](${href})` : code(id);
+    return `${ref} ${e.at ? `(${inline(e.at)}) ` : ''}${cell(e.summary.slice(0, 200))}`;
+}
+/** The report keeps every cited row, every non-log row, and only the warnings/failures among log lines. */
+const codeCell = (s) => code(s).replace(/\|/g, '\\|');
+function timelineRows(g, findings, narrative, diagnosis) {
+    const diagnosisCitations = diagnosis ? [...(diagnosis.rootCause?.evidence ?? []), ...diagnosis.summary.flatMap((c) => c.evidence), ...diagnosis.hypotheses.flatMap((c) => c.evidence)] : [];
+    const narrativeCitations = narrative && !('error' in narrative) ? [...narrative.summary.flatMap((c) => c.evidence), ...narrative.hypotheses.flatMap((c) => c.evidence)] : [];
+    const cited = new Set([...findings.flatMap((f) => f.evidence), ...diagnosisCitations, ...narrativeCitations]);
+    return g.evidence.filter((e) => cited.has(e.id) || !['logs', 'archive'].includes(e.source) || ['http.5xx', 'http.4xx', 'log.error', 'log.warn'].includes(e.kind)).sort((a, b) => {
+        const normalize = (at) => at && /^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d+)?)?$/.test(at) ? `${at}Z` : at;
+        const atA = a.at ? Date.parse(normalize(a.at)) : NaN;
+        const atB = b.at ? Date.parse(normalize(b.at)) : NaN;
+        const time = Number.isFinite(atA) && Number.isFinite(atB) ? atA - atB : (a.at ?? '') < (b.at ?? '') ? -1 : (a.at ?? '') > (b.at ?? '') ? 1 : 0;
+        return time || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    });
+}
+export function renderMarkdown(caseId, g, findings, narrative, verify = [], diagnosis = null) {
+    const byId = new Map(g.evidence.map((e) => [e.id, e]));
+    const out = [];
+    const i = g.input;
+    out.push(`# reprobe ${inline(caseId)}`, '');
+    out.push(`> ${inline(i.complaint).replace(/\n/g, '\n> ')}`, '');
+    const given = [i.trace && `trace ${code(i.trace)}`, i.user && `user ${code(i.user)}`, i.chat && `chat ${code(i.chat)}`, i.sentry && `sentry ${code(i.sentry)}`].filter(Boolean);
+    out.push(`- **Input:** ${given.length ? given.join(', ') : 'complaint only'}`);
+    out.push(`- **Window:** ${inline(g.window.from)} to ${inline(g.window.to)}`);
+    const subject = g.subject.label ?? (g.subject.userId ? `user ${g.subject.userId}` : g.subject.sessionIds[0] ? `session ${g.subject.sessionIds[0]}` : 'not resolved');
+    out.push(`- **Subject:** ${inline(subject)}${g.subject.how ? ` (${inline(g.subject.how)})` : ''}`);
+    out.push(`- **Evidence:** ${g.evidence.length} items from ${[...new Set(g.evidence.map((e) => inline(e.source)))].sort().join(', ') || 'no source'}`, '');
+    if (diagnosis) {
+        const ids = (c) => c.evidence.map((id) => (byId.has(id) ? code(id) : '[evidence unavailable]')).join(' ');
+        out.push('## Diagnosis', '', `_By ${cell(diagnosis.agent)}. Every claim below cites evidence ids that exist in evidence.json; ${diagnosis.dropped.length} claim(s) that did not were dropped._`, '');
+        if (diagnosis.rootCause) {
+            out.push(`**Root cause [${diagnosis.rootCause.confidence.toUpperCase()}]:** ${inline(diagnosis.rootCause.text)}`, '', 'Evidence:');
+            for (const id of diagnosis.rootCause.evidence)
+                out.push(`- ${cite(id, byId)}`);
+            out.push('');
+        }
+        else
+            out.push('No root cause survived citation checks.', '');
+        for (const c of diagnosis.summary)
+            out.push(`- ${inline(c.text)} ${ids(c)}`);
+        if (diagnosis.hypotheses.length) {
+            out.push('', 'Other hypotheses:');
+            for (const c of diagnosis.hypotheses)
+                out.push(`- ${inline(c.text)} ${ids(c)}`);
+        }
+        if (diagnosis.unknowns.length) {
+            out.push('', 'Not known:');
+            for (const u of diagnosis.unknowns)
+                out.push(`- ${inline(u)}`);
+        }
+        if (diagnosis.fix)
+            out.push('', `**Fix:** ${inline(diagnosis.fix.text)}${diagnosis.fix.commit ? ` (commit ${code(diagnosis.fix.commit)})` : ''}`);
+        if (diagnosis.dropped.length) {
+            out.push('', 'Dropped (no valid citation):');
+            for (const t of diagnosis.dropped)
+                out.push(`- ~~${cell(t)}~~`);
+        }
+        out.push('');
+    }
+    out.push(diagnosis ? '## Detector findings' : '## Likely root cause', '');
+    if (!findings.length)
+        out.push('No failure signature matched the evidence. Read the timeline and the source table: missing sources are the first thing to fix.', '');
+    findings.forEach((f, n) => {
+        out.push(`### ${n + 1}. [${f.confidence.toUpperCase()}] ${inline(f.title)}`, '');
+        out.push(inline(f.rootCause), '');
+        out.push('Evidence:');
+        for (const id of f.evidence)
+            out.push(`- ${cite(id, byId)}`);
+        if (f.unknowns.length) {
+            out.push('', 'Not known from the evidence:');
+            for (const u of f.unknowns)
+                out.push(`- ${inline(u)}`);
+        }
+        if (f.replay) {
+            out.push('', `Replay: ${inline(f.replay.description)}.`);
+            for (const file of f.replay.files)
+                out.push(`- ${code(`replay/${file.path}`)} (${file.mode === 'append' ? 'appended to the existing file' : 'new file'})`);
+            out.push(`- Run at any commit: ${code(`reprobe verify ${caseId} <commit>`)} (runs ${code(f.replay.command.join(' '))} in a detached worktree)`);
+        }
+        out.push('');
+    });
+    if (verify.length) {
+        out.push('## Replay results', '', '| commit | sha | outcome | detail |', '|---|---|---|---|');
+        for (const v of verify)
+            out.push(`| ${cell(v.commit)} | ${cell(v.sha.slice(0, 10))} | **${cell(v.outcome.toUpperCase())}** | ${cell(v.detail)} |`);
+        out.push('');
+    }
+    if (narrative || !diagnosis)
+        out.push('## Summary', '');
+    if (!narrative) {
+        if (!diagnosis)
+            out.push('No summary yet: run `reprobe agent <case>` to investigate with Claude Code or Codex, or pass `--summary` for a short cited LLM summary.');
+    }
+    else if ('error' in narrative)
+        out.push(`LLM summary unavailable: ${inline(narrative.error)}. The findings above are deterministic and complete without it.`);
+    else {
+        out.push(`_Written by ${inline(narrative.model)}. Citation IDs are checked against the evidence list; claim accuracy is not independently verified. ${narrative.dropped.length} uncited claim(s) were dropped._`, '');
+        for (const c of narrative.summary)
+            out.push(`- ${inline(c.text)} ${c.evidence.map((id) => byId.has(id) ? code(id) : '[evidence unavailable]').join(' ')}`);
+        if (narrative.hypotheses.length) {
+            out.push('', 'Other hypotheses:');
+            for (const c of narrative.hypotheses)
+                out.push(`- ${inline(c.text)} ${c.evidence.map((id) => byId.has(id) ? code(id) : '[evidence unavailable]').join(' ')}`);
+        }
+    }
+    out.push('');
+    out.push('## Sources', '', '| source | state | detail |', '|---|---|---|');
+    for (const s of [...g.sources].sort((a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : a.state < b.state ? -1 : a.state > b.state ? 1 : 0))
+        out.push(`| ${cell(s.source)} | ${s.state === 'ok' ? 'ok' : `**${s.state}**`} | ${cell(s.detail)} |`);
+    out.push('');
+    const rows = timelineRows(g, findings, narrative, diagnosis);
+    out.push('## Timeline', '', `${rows.length} of ${g.evidence.length} items (all cited items, all DB/trace rows, and log warnings/failures). Everything is in \`evidence.json\`.`, '');
+    out.push('| time (UTC) | source | what | id |', '|---|---|---|---|');
+    for (const e of rows)
+        out.push(`| ${e.at ? cell(e.at) : '-'} | ${cell(e.source)} | ${cell(e.summary.slice(0, 220))} | ${codeCell(e.id)} |`);
+    out.push('');
+    return out.join('\n');
+}

package/dist/sources/langfuse.d.ts

@@ -0,0 +1,36 @@
+import type { Evidence, SourceStatus, Window } from '../types.ts';
+export declare function parseLangfuseTrace(input: string): string | null;
+export interface LangfuseClient {
+    base: string;
+    get(path: string): Promise<{
+        status: number;
+        body: any;
+    }>;
+}
+export declare function langfuseClient(fetchImpl?: typeof fetch): Promise<LangfuseClient | null>;
+/**
+ * Product-specific facts read off one observation (a pack knows its agent's output shapes).
+ * `flags` lands in the evidence data for detectors; `bits` are appended to the summary.
+ */
+export type ObservationAnnotator = (o: {
+    type: string;
+    name: string;
+    input: unknown;
+    output: unknown;
+    metadata: unknown;
+}) => {
+    flags: Record<string, unknown>;
+    bits: string[];
+};
+/**
+ * v2 observations is the supported read path, but it does not serve older traces; the v1 trace
+ * endpoint does until Langfuse removes it (announced for 2026-11-16). Try v2, fall back to v1, and say which.
+ */
+export declare function fetchTrace(client: LangfuseClient, traceId: string, annotate?: ObservationAnnotator): Promise<{
+    status: SourceStatus;
+    evidence: Evidence[];
+    userId?: string;
+    sessionId?: string;
+    at?: string;
+}>;
+export declare function findTraceIds(client: LangfuseClient, w: Window, userId?: string, sessionIds?: string[]): Promise<string[]>;

package/dist/sources/langfuse.js

@@ -0,0 +1,147 @@
+import { config, resolveSecret } from "../config.js";
+import { retryingFetch } from "../exec.js";
+import { redactText, redactValue } from "../redact.js";
+export function parseLangfuseTrace(input) {
+    const m = input.match(/traces\/([0-9a-f]{32})/i) ?? input.match(/traceId=([0-9a-f]{32})/i) ?? input.trim().match(/^([0-9a-f]{32})$/i);
+    return m ? m[1].toLowerCase() : null;
+}
+export async function langfuseClient(fetchImpl = retryingFetch()) {
+    const lf = config.sources.langfuse;
+    if (!lf)
+        return null;
+    const [pk, sk, rawBase] = (await Promise.all([resolveSecret(lf.publicKey), resolveSecret(lf.secretKey), resolveSecret(lf.baseUrl)])).map((r) => r.value);
+    if (!pk || !sk || !rawBase)
+        return null;
+    const base = rawBase.replace(/\/+$/, '');
+    const auth = `Basic ${Buffer.from(`${pk}:${sk}`).toString('base64')}`;
+    return {
+        base,
+        async get(path) {
+            let res;
+            try {
+                res = await fetchImpl(`${base}${path}`, { headers: { authorization: auth }, signal: AbortSignal.timeout(120_000) });
+            }
+            catch (e) {
+                throw new Error(redactText(e instanceof Error ? e.message : String(e)));
+            }
+            const text = await res.text();
+            let body = null;
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                body = text;
+            }
+            return { status: res.status, body };
+        },
+    };
+}
+function parse(v) {
+    if (typeof v !== 'string')
+        return v;
+    try {
+        return JSON.parse(v);
+    }
+    catch {
+        return v;
+    }
+}
+function toEvidence(o, link, annotate) {
+    const meta = (parse(o.metadata) ?? {});
+    const extra = annotate?.({ type: o.type, name: o.name, input: o.input ?? null, output: o.output ?? null, metadata: o.metadata ?? null }) ?? { flags: {}, bits: [] };
+    const flags = extra.flags;
+    const bits = [`${o.type.toLowerCase()} ${o.name}`];
+    if (o.level && o.level !== 'DEFAULT')
+        bits.push(`level ${o.level}`);
+    if (o.statusMessage)
+        bits.push(`status "${String(o.statusMessage).slice(0, 160)}"`);
+    bits.push(...extra.bits);
+    return {
+        id: `langfuse:obs:${o.id}`,
+        source: 'langfuse',
+        at: o.startTime,
+        kind: `langfuse.${o.type.toLowerCase()}`,
+        summary: bits.join(' · '),
+        data: {
+            traceId: o.traceId,
+            id: o.id,
+            parent: o.parentObservationId ?? null,
+            type: o.type,
+            name: o.name,
+            level: o.level ?? null,
+            startTime: o.startTime,
+            endTime: o.endTime ?? null,
+            runId: meta.runId ?? null,
+            stepIndex: meta.stepIndex ?? null,
+            agentName: meta.agentName ?? null,
+            turnId: meta.turnId ?? null,
+            flags,
+            inputPreview: JSON.stringify(redactValue(o.input ?? null)).slice(0, 800),
+            outputPreview: JSON.stringify(redactValue(o.output ?? null)).slice(0, 2000),
+        },
+        link,
+    };
+}
+/**
+ * v2 observations is the supported read path, but it does not serve older traces; the v1 trace
+ * endpoint does until Langfuse removes it (announced for 2026-11-16). Try v2, fall back to v1, and say which.
+ */
+export async function fetchTrace(client, traceId, annotate) {
+    const v2 = await client.get(`/api/public/v2/observations?traceId=${traceId}&fields=core,basic,io,metadata&limit=200`);
+    let observations = v2.status === 200 && Array.isArray(v2.body?.data) ? v2.body.data : [];
+    let via = 'v2 observations';
+    let trace = null;
+    if (!observations.length) {
+        const v1 = await client.get(`/api/public/traces/${traceId}`);
+        if (v1.status === 404) {
+            return { status: { source: 'langfuse', state: 'not-found', detail: `trace ${traceId} not found (deleted or past retention)` }, evidence: [] };
+        }
+        if (v1.status !== 200)
+            return { status: { source: 'langfuse', state: 'error', detail: `trace ${traceId}: HTTP ${v1.status}` }, evidence: [] };
+        trace = v1.body;
+        observations = (trace.observations ?? []).map((o) => ({ ...o, traceId }));
+        via = 'deprecated v1 trace endpoint (snapshot kept in the case dir)';
+    }
+    const projectId = trace?.projectId ?? observations[0]?.projectId ?? '';
+    const link = `${client.base}/project/${projectId}/traces/${traceId}`;
+    const evidence = [];
+    const userId = trace?.userId ?? observations.find((o) => o.userId)?.userId ?? undefined;
+    const sessionId = trace?.sessionId ?? observations.find((o) => o.sessionId)?.sessionId ?? undefined;
+    const at = trace?.timestamp ?? observations.map((o) => o.startTime).sort()[0];
+    evidence.push({
+        id: `langfuse:trace:${traceId}`,
+        source: 'langfuse',
+        at: at ?? null,
+        kind: 'langfuse.trace',
+        summary: `trace ${trace?.name ?? observations.find((o) => !o.parentObservationId)?.name ?? '?'} with ${observations.length} observations${trace?.release ? `, server release ${trace.release}` : ''}`,
+        data: { traceId, release: trace?.release ?? null, userId: userId ?? null, sessionId: sessionId ?? null, tags: trace?.tags ?? [], output: trace?.output ?? null },
+        link,
+    });
+    for (const o of [...observations].sort((a, b) => a.startTime.localeCompare(b.startTime) || a.id.localeCompare(b.id))) {
+        evidence.push(toEvidence(o, link, annotate));
+    }
+    return { status: { source: 'langfuse', state: 'ok', detail: `trace ${traceId}: ${observations.length} observations via ${via}` }, evidence, userId, sessionId, at };
+}
+export async function findTraceIds(client, w, userId, sessionIds = []) {
+    const ids = new Set();
+    if (userId) {
+        const query = new URLSearchParams({ userId, fromStartTime: w.from, toStartTime: w.to, fields: 'core', limit: '200' });
+        const r = await client.get(`/api/public/v2/observations?${query}`);
+        for (const o of r.status === 200 && Array.isArray(r.body?.data) ? r.body.data : []) {
+            if (typeof o?.traceId === 'string')
+                ids.add(o.traceId);
+        }
+    }
+    if (!ids.size) {
+        const identities = [...(userId ? [{ userId }] : []), ...sessionIds.map((sessionId) => ({ sessionId }))];
+        for (const identity of identities) {
+            const query = new URLSearchParams({ ...identity, fromTimestamp: w.from, toTimestamp: w.to, limit: '50' });
+            const r = await client.get(`/api/public/traces?${query}`);
+            for (const t of r.status === 200 && Array.isArray(r.body?.data) ? r.body.data : []) {
+                if (typeof t?.id === 'string')
+                    ids.add(t.id);
+            }
+        }
+    }
+    return [...ids].sort();
+}

package/dist/sources/langsmith.d.ts

@@ -0,0 +1,9 @@
+import type { Evidence, SourceStatus } from '../types.ts';
+interface Result {
+    status: SourceStatus;
+    evidence: Evidence[];
+}
+/** Accepts a share URL or a bare share UUID; returns the share UUID, or null. */
+export declare function parseLangsmithShare(input: string): string | null;
+export declare function gatherLangsmith(share: string, fetchImpl?: typeof fetch): Promise<Result>;
+export {};

package/dist/sources/langsmith.js

@@ -0,0 +1,130 @@
+import { redactText, redactValue } from "../redact.js";
+const API = 'https://api.smith.langchain.com/api/v1/public';
+const WEB = 'https://smith.langchain.com/public';
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TIMEOUT_MS = 20_000;
+/** Accepts a share URL or a bare share UUID; returns the share UUID, or null. */
+export function parseLangsmithShare(input) {
+    const s = input.trim();
+    if (UUID.test(s))
+        return s;
+    let url;
+    try {
+        url = new URL(s);
+    }
+    catch {
+        return null;
+    }
+    const id = /\/public\/([^/]+)/.exec(url.pathname)?.[1];
+    return id !== undefined && UUID.test(id) ? id : null;
+}
+export async function gatherLangsmith(share, fetchImpl = fetch) {
+    const none = (state, detail) => ({
+        status: { source: 'langsmith', state, detail },
+        evidence: [],
+    });
+    let res;
+    try {
+        res = await fetchImpl(`${API}/${share}/run`, { method: 'GET', signal: AbortSignal.timeout(TIMEOUT_MS) });
+    }
+    catch (e) {
+        return none('unreachable', errorMessage(e));
+    }
+    if (res.status === 404) {
+        return none('expired', `share token not found (trace deleted, unshared, or past LangSmith retention): ${share}`);
+    }
+    if (!res.ok)
+        return none('error', `HTTP ${res.status}`);
+    let top;
+    try {
+        top = (await res.json());
+    }
+    catch (e) {
+        return none('error', `invalid JSON: ${errorMessage(e)}`);
+    }
+    if (!top || typeof top.id !== 'string')
+        return none('error', 'unexpected response: no run id');
+    // Best effort: if the list call fails, report the top run alone.
+    let listed = [];
+    try {
+        const q = await fetchImpl(`${API}/${share}/runs/query`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ limit: 100 }),
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+        if (q.ok)
+            listed = arr((await q.json()).runs);
+    }
+    catch {
+        listed = [];
+    }
+    const rest = listed.filter((r) => typeof r?.id === 'string' && r.id !== top.id).sort(byStartThenId);
+    const runs = [top, ...rest];
+    return {
+        status: { source: 'langsmith', state: 'ok', detail: `${runs.length} runs` },
+        evidence: runs.map((r) => toEvidence(r, share)),
+    };
+}
+function toEvidence(run, share) {
+    const tools = toolNames(run.outputs);
+    const error = run.error ? ` ERROR: ${errorText(run.error).slice(0, 200)}` : '';
+    const toolPart = tools.length > 0 ? ` tools=[${tools.join(',')}]` : '';
+    return {
+        id: `langsmith:run:${run.id}`,
+        source: 'langsmith',
+        at: withZone(run.start_time),
+        kind: 'langsmith.run',
+        summary: `${run.run_type ?? ''} ${run.name ?? ''}`.trim() + error + toolPart,
+        data: {
+            id: run.id,
+            name: run.name ?? null,
+            run_type: run.run_type ?? null,
+            status: run.status ?? null,
+            error: run.error ?? null,
+            start_time: run.start_time ?? null,
+            end_time: run.end_time ?? null,
+            parent_run_id: run.parent_run_id ?? null,
+            inputs_preview: preview(run.inputs),
+            outputs_preview: preview(run.outputs),
+        },
+        link: `${WEB}/${share}/r`,
+    };
+}
+function toolNames(outputs) {
+    const names = [];
+    const steps = arr(outputs?.output);
+    for (const step of steps) {
+        for (const msg of arr(step?.update?.messages)) {
+            for (const call of arr(msg?.tool_calls)) {
+                if (typeof call?.name === 'string')
+                    names.push(call.name);
+            }
+        }
+    }
+    return names;
+}
+function byStartThenId(a, b) {
+    const sa = a.start_time ?? '';
+    const sb = b.start_time ?? '';
+    if (sa !== sb)
+        return sa < sb ? -1 : 1;
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+function withZone(t) {
+    if (!t)
+        return null;
+    return /(?:Z|[+-]\d{2}:?\d{2})$/i.test(t) ? t : `${t}Z`;
+}
+function preview(v) {
+    return JSON.stringify(redactValue(v ?? null)).slice(0, 800);
+}
+function errorText(e) {
+    return redactText(typeof e === 'string' ? e : JSON.stringify(redactValue(e)) ?? '');
+}
+function arr(x) {
+    return Array.isArray(x) ? x : [];
+}
+function errorMessage(e) {
+    return redactText(e instanceof Error ? e.message : String(e));
+}

package/dist/sources/logs.d.ts

@@ -0,0 +1,40 @@
+import { type Runner } from '../exec.ts';
+import type { Evidence, SourceStatus, Window } from '../types.ts';
+export interface LogLine {
+    at: string;
+    text: string;
+    level: string;
+    context: string | null;
+    method: string | null;
+    path: string | null;
+    status: number | null;
+    userId: string | null;
+    clientVersion: string | null;
+}
+/** Normalises the three shapes Railway logs come in: `--json` objects, `<ts> [level] <nest line>`, and `<ts> [LEVEL] key=value`. */
+export declare function parseLogLine(raw: string): LogLine | null;
+export declare function inWindow(at: string, w: Window): boolean;
+/** Lines worth keeping: anything about the people we care about, every warning/error, every failed request. */
+export declare function relevant(l: LogLine, ids: string[]): boolean;
+/**
+ * Railway emits a multi-line message (an error object, a stack trace) as one line per row, all with
+ * the same timestamp. Fold those rows back into the line that started them, in source order.
+ */
+export declare function mergeContinuations(lines: LogLine[]): LogLine[];
+export declare function dedupe(lines: LogLine[]): LogLine[];
+type Result = {
+    status: SourceStatus;
+    evidence: Evidence[];
+};
+/** Every configured log source, filtered to lines that mention the ids or look like failures. */
+export declare function gatherLogs(w: Window, ids: string[], runner?: Runner): Promise<Result[]>;
+export declare const globRegex: (g: string) => RegExp;
+/**
+ * Log-shaped tool output from a saved Claude Code transcript. Assistant messages are excluded, but
+ * the transcript does not prove which command produced the output or whether it was edited later.
+ */
+export declare function gatherArchive(w: Window, ids: string[], runner?: Runner): Promise<{
+    status: SourceStatus;
+    evidence: Evidence[];
+}>;
+export {};