profclaw 2.0.0 → 2.4.0

package/dist/agents/receipt/receipt-types.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Run receipt types (spec: docs/specs/run-receipt-v0.md).
+ * Shared by the writer, verifier and viewer.
+ */
+export declare const RECEIPT_VERSION = "0";
+/** `prev` of the first event: 64 zeros. */
+export declare const GENESIS_HASH: string;
+export interface RunStartData {
+    goal: string;
+    verifyCommand: string;
+    repoHead: string | null;
+    branch: string;
+    tool: {
+        name: string;
+        version: string;
+    };
+}
+export interface AttemptStartData {
+    attempt: number;
+    model?: string;
+}
+export interface ToolCallData {
+    attempt: number;
+    name: string;
+    argsSummary: string;
+    redacted: boolean;
+    durationMs: number;
+    ok: boolean;
+}
+export type FileChangeKind = 'created' | 'modified' | 'deleted';
+export interface FileChangeData {
+    path: string;
+    status: FileChangeKind;
+    beforeSha256: string | null;
+    afterSha256: string | null;
+    diffSha256: string;
+    diff?: string;
+    diffTruncated?: boolean;
+}
+export interface VerifierResultData {
+    attempt: number;
+    command: string;
+    exitCode: number | null;
+    passed: boolean;
+    output: string;
+    failureScore: number;
+    durationMs?: number;
+    timedOut?: boolean;
+}
+export interface UsageData {
+    attempt: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+    costUsd: number;
+    model?: string;
+}
+export interface RollbackData {
+    attempt: number;
+    reason: string;
+}
+export type ReceiptOutcome = 'verified' | 'improved' | 'unchanged' | 'worse' | 'agent_error';
+export interface AttemptEndData {
+    attempt: number;
+    outcome: ReceiptOutcome;
+    rolledBack: boolean;
+}
+export interface RunEndData {
+    stopReason: string;
+    verified: boolean;
+    totals: {
+        attempts: number;
+        totalTokens: number;
+        costUsd: number;
+        filesChanged: number;
+    };
+}
+export interface ReceiptDataMap {
+    run_start: RunStartData;
+    attempt_start: AttemptStartData;
+    tool_call: ToolCallData;
+    file_change: FileChangeData;
+    verifier_result: VerifierResultData;
+    usage: UsageData;
+    rollback: RollbackData;
+    attempt_end: AttemptEndData;
+    run_end: RunEndData;
+}
+export type ReceiptEventType = keyof ReceiptDataMap;
+export declare const RECEIPT_EVENT_TYPES: readonly ReceiptEventType[];
+export interface ReceiptSignature {
+    alg: 'ed25519';
+    /** base64 SPKI DER */
+    publicKey: string;
+    /** base64 Ed25519 signature over the UTF-8 bytes of the run_end hash */
+    sig: string;
+}
+interface EventBase {
+    v: typeof RECEIPT_VERSION;
+    seq: number;
+    ts: string;
+    prev: string;
+    hash: string;
+}
+export type ReceiptEvent = {
+    [K in ReceiptEventType]: EventBase & {
+        type: K;
+        data: ReceiptDataMap[K];
+        signature?: ReceiptSignature;
+    };
+}[ReceiptEventType];
+/** Anything that can record receipt events. runVerifiedGoal only needs this. */
+export interface ReceiptSink {
+    append<K extends ReceiptEventType>(type: K, data: ReceiptDataMap[K]): ReceiptEvent;
+}
+export type VerifyFailureReason = 'unreadable' | 'empty' | 'invalid_json' | 'invalid_event' | 'seq_mismatch' | 'prev_mismatch' | 'hash_mismatch' | 'bad_first_event' | 'event_after_run_end' | 'truncated' | 'bad_signature' | 'unsigned' | 'untrusted_key';
+export interface SignatureStatus {
+    present: boolean;
+    valid?: boolean;
+    publicKey?: string;
+}
+export interface VerifyResult {
+    ok: boolean;
+    eventCount: number;
+    /** seq of the first bad event, or the seq where an event was expected (truncation) */
+    firstBadSeq?: number;
+    reason?: VerifyFailureReason;
+    message: string;
+    signature: SignatureStatus;
+    /** Hash of the last event read, when the chain was readable that far */
+    lastHash?: string;
+}
+export {};
+//# sourceMappingURL=receipt-types.d.ts.map

package/dist/agents/receipt/receipt-types.js

@@ -0,0 +1,19 @@
+/**
+ * Run receipt types (spec: docs/specs/run-receipt-v0.md).
+ * Shared by the writer, verifier and viewer.
+ */
+export const RECEIPT_VERSION = '0';
+/** `prev` of the first event: 64 zeros. */
+export const GENESIS_HASH = '0'.repeat(64);
+export const RECEIPT_EVENT_TYPES = [
+    'run_start',
+    'attempt_start',
+    'tool_call',
+    'file_change',
+    'verifier_result',
+    'usage',
+    'rollback',
+    'attempt_end',
+    'run_end',
+];
+//# sourceMappingURL=receipt-types.js.map

package/dist/agents/receipt/receipt-verify.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Receipt verifier: chain integrity, completeness and optional signature.
+ * Reports the first bad seq and why. Spec: docs/specs/run-receipt-v0.md
+ */
+import type { ReceiptEvent, VerifyResult } from './receipt-types.js';
+export interface VerifyOptions {
+    /** Trusted public key (PEM, or base64 SPKI DER). If set, the receipt must be signed by it. */
+    expectedPublicKey?: string;
+    /** Fail an unsigned receipt. Implied by expectedPublicKey. */
+    requireSignature?: boolean;
+}
+/** Normalise a PEM or base64 DER public key to base64 SPKI DER. */
+export declare function normalizePublicKey(input: string): string;
+/** Verify receipt text (JSON Lines). */
+export declare function verifyReceiptText(text: string, options?: VerifyOptions): VerifyResult;
+export declare function verifyReceiptFile(path: string, options?: VerifyOptions): VerifyResult;
+/** Parse events without verifying. For viewers; callers should verify separately. */
+export declare function parseReceiptText(text: string): ReceiptEvent[];
+//# sourceMappingURL=receipt-verify.d.ts.map

package/dist/agents/receipt/receipt-verify.js

@@ -0,0 +1,176 @@
+/**
+ * Receipt verifier: chain integrity, completeness and optional signature.
+ * Reports the first bad seq and why. Spec: docs/specs/run-receipt-v0.md
+ */
+import { createPublicKey, verify as edVerify } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { computeEventHash } from './receipt-writer.js';
+import { GENESIS_HASH, RECEIPT_EVENT_TYPES, RECEIPT_VERSION } from './receipt-types.js';
+const HEX64 = /^[0-9a-f]{64}$/;
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+/** Normalise a PEM or base64 DER public key to base64 SPKI DER. */
+export function normalizePublicKey(input) {
+    const trimmed = input.trim();
+    const key = trimmed.includes('-----BEGIN')
+        ? createPublicKey(trimmed)
+        : createPublicKey({ key: Buffer.from(trimmed, 'base64'), format: 'der', type: 'spki' });
+    return key.export({ type: 'spki', format: 'der' }).toString('base64');
+}
+function fail(events, seq, reason, message, extra = {}) {
+    return { ok: false, eventCount: events, firstBadSeq: seq, reason, message, signature: { present: false }, ...extra };
+}
+/** Structural check of one parsed line. Returns a problem description or null. */
+function shapeProblem(obj) {
+    if (obj['v'] !== RECEIPT_VERSION)
+        return `unsupported version ${JSON.stringify(obj['v'])}`;
+    if (typeof obj['seq'] !== 'number' || !Number.isInteger(obj['seq']))
+        return 'seq is not an integer';
+    if (typeof obj['ts'] !== 'string')
+        return 'ts is not a string';
+    if (typeof obj['type'] !== 'string')
+        return 'type is not a string';
+    if (!isRecord(obj['data']))
+        return 'data is not an object';
+    if (typeof obj['prev'] !== 'string' || !HEX64.test(obj['prev']))
+        return 'prev is not a sha256 hex string';
+    if (typeof obj['hash'] !== 'string' || !HEX64.test(obj['hash']))
+        return 'hash is not a sha256 hex string';
+    return null;
+}
+/** Verify receipt text (JSON Lines). */
+export function verifyReceiptText(text, options = {}) {
+    const lines = text.split('\n');
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    if (lines.length === 0)
+        return fail(0, 0, 'empty', 'Receipt is empty: expected a run_start event at seq 0');
+    let prev = GENESIS_HASH;
+    let runEnd;
+    let count = 0;
+    for (let i = 0; i < lines.length; i++) {
+        let parsed;
+        try {
+            parsed = JSON.parse(lines[i]);
+        }
+        catch {
+            return fail(count, i, 'invalid_json', `Line ${i + 1} (seq ${i}) is not valid JSON`);
+        }
+        if (!isRecord(parsed))
+            return fail(count, i, 'invalid_event', `Line ${i + 1} (seq ${i}) is not a JSON object`);
+        const problem = shapeProblem(parsed);
+        if (problem)
+            return fail(count, i, 'invalid_event', `Event at seq ${i}: ${problem}`);
+        if (runEnd) {
+            return fail(count, i, 'event_after_run_end', `Event at seq ${i} follows run_end`);
+        }
+        if (parsed['seq'] !== i) {
+            return fail(count, i, 'seq_mismatch', `Expected seq ${i} but found seq ${String(parsed['seq'])}: events were reordered, or one was deleted or inserted`);
+        }
+        if (parsed['prev'] !== prev) {
+            return fail(count, i, 'prev_mismatch', `seq ${i}: prev does not match the hash of seq ${i - 1}: the previous event was changed or removed`);
+        }
+        const expected = computeEventHash(parsed);
+        if (parsed['hash'] !== expected) {
+            return fail(count, i, 'hash_mismatch', `seq ${i}: hash does not match the event content: the event was edited`);
+        }
+        if (i === 0 && parsed['type'] !== 'run_start') {
+            return fail(count, 0, 'bad_first_event', `seq 0 must be run_start, found ${String(parsed['type'])}`);
+        }
+        prev = parsed['hash'];
+        count++;
+        if (parsed['type'] === 'run_end')
+            runEnd = parsed;
+    }
+    if (!runEnd) {
+        return fail(count, count, 'truncated', `No run_end event after seq ${count - 1}: the receipt is truncated or the run did not finish`, {
+            lastHash: prev,
+        });
+    }
+    return checkSignature(runEnd, count, prev, options);
+}
+function checkSignature(runEnd, count, lastHash, options) {
+    const seq = count - 1;
+    const sig = runEnd['signature'];
+    const wantSigned = options.requireSignature === true || options.expectedPublicKey !== undefined;
+    if (sig === undefined) {
+        if (wantSigned) {
+            return fail(count, seq, 'unsigned', 'Receipt has no signature but one is required', { lastHash });
+        }
+        return { ok: true, eventCount: count, message: `Chain intact, ${count} events, run complete (unsigned)`, signature: { present: false }, lastHash };
+    }
+    if (!isRecord(sig) || sig['alg'] !== 'ed25519' || typeof sig['publicKey'] !== 'string' || typeof sig['sig'] !== 'string') {
+        return fail(count, seq, 'bad_signature', 'run_end signature block is malformed', { lastHash, signature: { present: true, valid: false } });
+    }
+    const publicKey = sig['publicKey'];
+    let valid = false;
+    try {
+        const key = createPublicKey({ key: Buffer.from(publicKey, 'base64'), format: 'der', type: 'spki' });
+        valid = edVerify(null, Buffer.from(lastHash, 'utf-8'), key, Buffer.from(sig['sig'], 'base64'));
+    }
+    catch {
+        valid = false;
+    }
+    if (!valid) {
+        return fail(count, seq, 'bad_signature', 'Signature does not verify against the last hash', {
+            lastHash,
+            signature: { present: true, valid: false, publicKey },
+        });
+    }
+    if (options.expectedPublicKey !== undefined) {
+        let trusted;
+        try {
+            trusted = normalizePublicKey(options.expectedPublicKey);
+        }
+        catch {
+            return fail(count, seq, 'untrusted_key', 'The expected public key could not be parsed', { lastHash, signature: { present: true, valid: true, publicKey } });
+        }
+        if (trusted !== publicKey) {
+            return fail(count, seq, 'untrusted_key', 'Signature is valid but the signing key is not the expected key', {
+                lastHash,
+                signature: { present: true, valid: true, publicKey },
+            });
+        }
+    }
+    return {
+        ok: true,
+        eventCount: count,
+        message: `Chain intact, ${count} events, run complete, signature valid`,
+        signature: { present: true, valid: true, publicKey },
+        lastHash,
+    };
+}
+export function verifyReceiptFile(path, options = {}) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf-8');
+    }
+    catch (error) {
+        return fail(0, 0, 'unreadable', `Cannot read ${path}: ${error instanceof Error ? error.message : 'unknown error'}`);
+    }
+    return verifyReceiptText(text, options);
+}
+/** Parse events without verifying. For viewers; callers should verify separately. */
+export function parseReceiptText(text) {
+    const events = [];
+    for (const line of text.split('\n')) {
+        if (line.trim() === '')
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (isRecord(parsed) && shapeProblem(parsed) === null && isKnownType(parsed['type'])) {
+            events.push(parsed);
+        }
+    }
+    return events;
+}
+function isKnownType(t) {
+    return typeof t === 'string' && RECEIPT_EVENT_TYPES.includes(t);
+}
+//# sourceMappingURL=receipt-verify.js.map

package/dist/agents/receipt/receipt-view.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Receipt viewer: a terminal summary and a self-contained single-file HTML page
+ * (inline CSS and JS, no external assets). Every piece of receipt data is
+ * HTML-escaped, and a CSP meta tag blocks anything not inline.
+ */
+import type { AttemptEndData, FileChangeData, ReceiptEvent, RollbackData, RunEndData, RunStartData, ToolCallData, UsageData, VerifierResultData, VerifyResult } from './receipt-types.js';
+export interface AttemptView {
+    attempt: number;
+    model?: string;
+    toolCalls: ToolCallData[];
+    verifier?: VerifierResultData;
+    usage?: UsageData;
+    rollbacks: RollbackData[];
+    end?: AttemptEndData;
+}
+export interface ReceiptModel {
+    start?: RunStartData;
+    baseline?: VerifierResultData;
+    attempts: AttemptView[];
+    files: FileChangeData[];
+    end?: RunEndData;
+    startedAt?: string;
+    endedAt?: string;
+}
+export declare function buildReceiptModel(events: ReceiptEvent[]): ReceiptModel;
+export declare function renderTerminalSummary(events: ReceiptEvent[], verify?: VerifyResult): string;
+export declare function escapeHtml(input: string): string;
+export declare function renderHtml(events: ReceiptEvent[], verify?: VerifyResult): string;
+//# sourceMappingURL=receipt-view.d.ts.map

package/dist/agents/receipt/receipt-view.js

@@ -0,0 +1,227 @@
+/**
+ * Receipt viewer: a terminal summary and a self-contained single-file HTML page
+ * (inline CSS and JS, no external assets). Every piece of receipt data is
+ * HTML-escaped, and a CSP meta tag blocks anything not inline.
+ */
+import { createHash } from 'node:crypto';
+export function buildReceiptModel(events) {
+    const model = { attempts: [], files: [] };
+    const byAttempt = new Map();
+    const view = (n) => {
+        let a = byAttempt.get(n);
+        if (!a) {
+            a = { attempt: n, toolCalls: [], rollbacks: [] };
+            byAttempt.set(n, a);
+            model.attempts.push(a);
+        }
+        return a;
+    };
+    for (const e of events) {
+        switch (e.type) {
+            case 'run_start':
+                model.start = e.data;
+                model.startedAt = e.ts;
+                break;
+            case 'attempt_start':
+                view(e.data.attempt).model = e.data.model;
+                break;
+            case 'tool_call':
+                view(e.data.attempt).toolCalls.push(e.data);
+                break;
+            case 'file_change':
+                model.files.push(e.data);
+                break;
+            case 'verifier_result':
+                if (e.data.attempt === 0)
+                    model.baseline = e.data;
+                else
+                    view(e.data.attempt).verifier = e.data;
+                break;
+            case 'usage': {
+                const a = view(e.data.attempt);
+                a.usage = e.data;
+                if (!a.model && e.data.model)
+                    a.model = e.data.model;
+                break;
+            }
+            case 'rollback':
+                view(e.data.attempt).rollbacks.push(e.data);
+                break;
+            case 'attempt_end':
+                view(e.data.attempt).end = e.data;
+                break;
+            case 'run_end':
+                model.end = e.data;
+                model.endedAt = e.ts;
+                break;
+        }
+    }
+    return model;
+}
+const usd = (n) => `$${n.toFixed(4)}`;
+// Terminal
+export function renderTerminalSummary(events, verify) {
+    const m = buildReceiptModel(events);
+    const out = [];
+    if (verify)
+        out.push(`Integrity: ${verify.ok ? 'OK' : 'FAILED'}. ${verify.message}`, '');
+    if (m.start) {
+        out.push(`Goal:     ${m.start.goal}`);
+        out.push(`Verifier: ${m.start.verifyCommand}`);
+        out.push(`Branch:   ${m.start.branch}${m.start.repoHead ? ` (from ${m.start.repoHead.slice(0, 12)})` : ''}`);
+        out.push(`Tool:     ${m.start.tool.name} ${m.start.tool.version}`);
+    }
+    if (m.end) {
+        out.push(`Result:   ${m.end.verified ? 'VERIFIED' : 'NOT VERIFIED'} (${m.end.stopReason}), ${m.end.totals.attempts} attempt(s), ${m.end.totals.totalTokens} tokens, ${usd(m.end.totals.costUsd)}`);
+    }
+    else {
+        out.push('Result:   incomplete (no run_end)');
+    }
+    if (m.baseline)
+        out.push(`Baseline: ${m.baseline.passed ? 'pass' : `fail (score ${m.baseline.failureScore})`}`);
+    out.push('');
+    for (const a of m.attempts) {
+        const bits = [`Attempt ${a.attempt}: ${a.end?.outcome ?? 'unfinished'}`];
+        if (a.model)
+            bits.push(a.model);
+        if (a.verifier)
+            bits.push(`verifier ${a.verifier.passed ? 'pass' : `fail (score ${a.verifier.failureScore})`}`);
+        if (a.toolCalls.length)
+            bits.push(`${a.toolCalls.length} tool call(s)`);
+        if (a.usage)
+            bits.push(`${a.usage.totalTokens} tokens, ${usd(a.usage.costUsd)}`);
+        for (const r of a.rollbacks)
+            bits.push(`rolled back: ${r.reason}`);
+        out.push(bits.join(', '));
+    }
+    if (m.files.length) {
+        out.push('', 'Files changed:');
+        for (const f of m.files)
+            out.push(`  ${f.status} ${f.path}`);
+    }
+    return out.join('\n') + '\n';
+}
+// HTML
+export function escapeHtml(input) {
+    return input
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+const CSS = `
+:root{color-scheme:light dark;--bg:#fff;--fg:#1a1a1a;--mut:#666;--line:#ddd;--ok:#127a3a;--bad:#b3261e;--warn:#8a5a00;--code:#f5f5f5}
+@media(prefers-color-scheme:dark){:root{--bg:#141414;--fg:#e8e8e8;--mut:#9a9a9a;--line:#333;--ok:#5fd08a;--bad:#ff8a80;--warn:#e0b050;--code:#1e1e1e}}
+body{font:14px/1.5 system-ui,sans-serif;background:var(--bg);color:var(--fg);margin:0 auto;padding:16px;max-width:960px}
+h1{font-size:20px;margin:0 0 4px}h2{font-size:16px;margin:24px 0 8px}
+.mut{color:var(--mut)}.ok{color:var(--ok)}.bad{color:var(--bad)}.warn{color:var(--warn)}
+.card{border:1px solid var(--line);border-radius:6px;padding:10px 12px;margin:8px 0}
+.row{display:flex;flex-wrap:wrap;gap:4px 16px}
+pre{background:var(--code);padding:8px;overflow:auto;border-radius:4px;margin:6px 0;font:12px/1.4 ui-monospace,monospace;white-space:pre-wrap;word-break:break-word}
+.add{color:var(--ok)}.del{color:var(--bad)}.hunk{color:var(--mut)}
+details>summary{cursor:pointer}
+table{border-collapse:collapse;width:100%}td,th{text-align:left;padding:2px 8px 2px 0;border-bottom:1px solid var(--line);font-size:13px}
+button{font:inherit;padding:2px 8px}
+`;
+const JS = `
+document.getElementById('expand').addEventListener('click',function(){
+  var open=this.getAttribute('data-open')!=='1';
+  document.querySelectorAll('details').forEach(function(d){d.open=open});
+  this.setAttribute('data-open',open?'1':'0');
+  this.textContent=open?'Collapse all':'Expand all';
+});
+`;
+const cspHash = (s) => `'sha256-${createHash('sha256').update(s, 'utf-8').digest('base64')}'`;
+function diffHtml(diff) {
+    return diff
+        .split('\n')
+        .map((line) => {
+        const cls = line.startsWith('+') && !line.startsWith('+++')
+            ? 'add'
+            : line.startsWith('-') && !line.startsWith('---')
+                ? 'del'
+                : line.startsWith('@@')
+                    ? 'hunk'
+                    : '';
+        const text = escapeHtml(line);
+        return cls ? `<span class="${cls}">${text}</span>` : text;
+    })
+        .join('\n');
+}
+function verifierHtml(v, label) {
+    const cls = v.passed ? 'ok' : 'bad';
+    return `<details><summary>${escapeHtml(label)}: <span class="${cls}">${v.passed ? 'PASS' : 'FAIL'}</span>, exit ${v.exitCode === null ? 'n/a' : escapeHtml(String(v.exitCode))}, score ${escapeHtml(String(v.failureScore))}${v.timedOut ? ', timed out' : ''}</summary><pre>${escapeHtml(v.output)}</pre></details>`;
+}
+export function renderHtml(events, verify) {
+    const m = buildReceiptModel(events);
+    const p = [];
+    const title = m.start ? `Run receipt: ${m.start.goal}` : 'Run receipt';
+    p.push(`<h1>${escapeHtml(title.length > 120 ? `${title.slice(0, 117)}...` : title)}</h1>`);
+    if (verify) {
+        p.push(`<div class="card"><strong class="${verify.ok ? 'ok' : 'bad'}">Integrity: ${verify.ok ? 'OK' : 'FAILED'}</strong> <span class="mut">${escapeHtml(verify.message)}</span>${verify.signature.present ? ` <span class="${verify.signature.valid ? 'ok' : 'bad'}">signature ${verify.signature.valid ? 'valid' : 'invalid'}</span>` : ' <span class="mut">unsigned</span>'}${verify.signature.publicKey ? `<div class="mut">key ${escapeHtml(verify.signature.publicKey.slice(-24))}</div>` : ''}${verify.lastHash ? `<div class="mut">last hash ${escapeHtml(verify.lastHash)}</div>` : ''}</div>`);
+    }
+    else {
+        p.push('<div class="card mut">Integrity was not checked for this view.</div>');
+    }
+    if (m.start) {
+        p.push(`<div class="card"><div class="row"><span>Verifier <code>${escapeHtml(m.start.verifyCommand)}</code></span><span>Branch <code>${escapeHtml(m.start.branch)}</code></span>` +
+            `<span>Head <code>${escapeHtml(m.start.repoHead ?? 'unknown')}</code></span><span>${escapeHtml(m.start.tool.name)} ${escapeHtml(m.start.tool.version)}</span></div></div>`);
+    }
+    if (m.end) {
+        p.push(`<div class="card"><strong class="${m.end.verified ? 'ok' : 'bad'}">${m.end.verified ? 'VERIFIED' : 'NOT VERIFIED'}</strong> (${escapeHtml(m.end.stopReason)})` +
+            `<div class="row mut"><span>${escapeHtml(String(m.end.totals.attempts))} attempt(s)</span><span>${escapeHtml(String(m.end.totals.totalTokens))} tokens</span>` +
+            `<span>cost ${escapeHtml(usd(m.end.totals.costUsd))}</span><span>${escapeHtml(String(m.end.totals.filesChanged))} file(s) changed</span></div></div>`);
+    }
+    else {
+        p.push('<div class="card warn">Incomplete: no run_end event.</div>');
+    }
+    p.push('<h2>Timeline</h2><button id="expand" type="button" data-open="0">Expand all</button>');
+    if (m.baseline)
+        p.push(`<div class="card">${verifierHtml(m.baseline, 'Baseline (before any attempt)')}</div>`);
+    for (const a of m.attempts) {
+        const outcome = a.end?.outcome ?? 'unfinished';
+        const cls = outcome === 'verified' ? 'ok' : outcome === 'improved' || outcome === 'unchanged' ? 'warn' : 'bad';
+        const head = [`<strong>Attempt ${escapeHtml(String(a.attempt))}</strong>`, `<span class="${cls}">${escapeHtml(outcome)}</span>`];
+        if (a.model)
+            head.push(`<span class="mut">${escapeHtml(a.model)}</span>`);
+        if (a.usage)
+            head.push(`<span class="mut">${escapeHtml(String(a.usage.totalTokens))} tokens, ${escapeHtml(usd(a.usage.costUsd))}</span>`);
+        const body = [];
+        if (a.toolCalls.length) {
+            body.push(`<details><summary>${escapeHtml(String(a.toolCalls.length))} tool call(s)</summary><table><tr><th>Tool</th><th>Args</th><th>ms</th><th>ok</th></tr>` +
+                a.toolCalls
+                    .map((t) => `<tr><td>${escapeHtml(t.name)}</td><td>${escapeHtml(t.argsSummary)}${t.redacted ? ' <span class="warn">(redacted)</span>' : ''}</td><td>${escapeHtml(String(Math.round(t.durationMs)))}</td><td class="${t.ok ? 'ok' : 'bad'}">${t.ok ? 'yes' : 'no'}</td></tr>`)
+                    .join('') +
+                '</table></details>');
+        }
+        if (a.verifier)
+            body.push(verifierHtml(a.verifier, 'Verifier'));
+        for (const r of a.rollbacks)
+            body.push(`<div class="bad">Rolled back: ${escapeHtml(r.reason)}</div>`);
+        p.push(`<div class="card"><div class="row">${head.join('')}</div>${body.join('')}</div>`);
+    }
+    p.push('<h2>Diff</h2>');
+    if (m.files.length === 0)
+        p.push('<div class="mut">No files changed.</div>');
+    for (const f of m.files) {
+        const label = `${escapeHtml(f.status)} <code>${escapeHtml(f.path)}</code>`;
+        const detail = f.diff !== undefined
+            ? `<pre>${diffHtml(f.diff)}</pre>`
+            : `<div class="mut">Diff omitted. sha256 ${escapeHtml(f.diffSha256)}</div>`;
+        p.push(`<div class="card"><details open><summary>${label}${f.diffTruncated ? ' <span class="warn">(truncated)</span>' : ''}</summary>${detail}</details></div>`);
+    }
+    const csp = `default-src 'none'; style-src ${cspHash(CSS)}; script-src ${cspHash(JS)}; base-uri 'none'; form-action 'none'`;
+    return [
+        '<!doctype html>',
+        '<html lang="en"><head><meta charset="utf-8">',
+        `<meta http-equiv="Content-Security-Policy" content="${escapeHtml(csp)}">`,
+        '<meta name="viewport" content="width=device-width,initial-scale=1">',
+        `<title>${escapeHtml(title.slice(0, 120))}</title>`,
+        `<style>${CSS}</style></head><body>`,
+        p.join('\n'),
+        `<script>${JS}</script></body></html>`,
+        '',
+    ].join('\n');
+}
+//# sourceMappingURL=receipt-view.js.map

package/dist/agents/receipt/receipt-writer.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Receipt writer: append-only JSONL, canonical JSON, SHA-256 hash chaining,
+ * secret redaction before hashing, optional Ed25519 signature on run_end.
+ * Spec: docs/specs/run-receipt-v0.md
+ */
+import type { ReceiptDataMap, ReceiptEvent, ReceiptEventType, ReceiptSink } from './receipt-types.js';
+/** Sorted keys, no whitespace, `undefined` members dropped, non-finite numbers rejected. */
+export declare function canonicalJson(value: unknown): string;
+export declare function sha256Hex(input: string | Uint8Array): string;
+/** Hash of an event: canonical JSON without `hash` and `signature`. */
+export declare function computeEventHash(event: Record<string, unknown>): string;
+export declare const REDACTED = "[REDACTED]";
+export declare function redactString(input: string): string;
+/** Deep-redacts strings and values under secret-looking object keys. Returns the changed flag. */
+export declare function redactValue(value: unknown): {
+    value: unknown;
+    changed: boolean;
+};
+export interface ReceiptSigner {
+    publicKey: string;
+    sign(hash: string): string;
+}
+/** Signer from a PKCS8 PEM Ed25519 private key. */
+export declare function createSigner(privateKeyPem: string): ReceiptSigner;
+export declare function loadSignerFromFile(path: string): ReceiptSigner;
+export interface ReceiptWriterOptions {
+    path: string;
+    signer?: ReceiptSigner;
+    /** Default true. Only disable for tests of the raw chain. */
+    redact?: boolean;
+    now?: () => Date;
+}
+/** Default location: <projectRoot>/.profclaw/runs/<runId>/receipt.jsonl (env PROFCLAW_RECEIPT_PATH overrides). */
+export declare function defaultReceiptPath(projectRoot: string, runId: string, env?: NodeJS.ProcessEnv): string;
+export declare class ReceiptWriter implements ReceiptSink {
+    readonly path: string;
+    private seq;
+    private prev;
+    private ended;
+    private readonly signer?;
+    private readonly redact;
+    private readonly now;
+    constructor(options: ReceiptWriterOptions);
+    get lastHash(): string;
+    append<K extends ReceiptEventType>(type: K, data: ReceiptDataMap[K]): ReceiptEvent;
+}
+//# sourceMappingURL=receipt-writer.d.ts.map