@north-light/crouter 0.3.170 → 0.3.172

package/dist/core/review/__tests__/capture-origin.test.js

@@ -0,0 +1,139 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, test } from 'node:test';
+import { createNode } from '../../canvas/canvas.js';
+import { closeDb } from '../../canvas/db.js';
+import { SessionManager } from '../../runtime/broker-sdk.js';
+import { captureOrigin } from '../companion.js';
+import { stageReview } from '../stage.js';
+import { getReviewByIdempotencyKey } from '../store.js';
+import { ReviewOperationError } from '../types.js';
+const registry = (models = [{ provider: 'p', id: 'm' }, { provider: 'q', id: 'n' }]) => ({
+    find: (provider, id) => models.find((model) => model.provider === provider && model.id === id),
+    getAll: () => models,
+    hasConfiguredAuth: () => true,
+});
+const homes = [];
+const previousHome = process.env['HOME'];
+const previousCrtrHome = process.env['CRTR_HOME'];
+afterEach(() => {
+    closeDb();
+    for (const home of homes.splice(0))
+        rmSync(home, { recursive: true, force: true });
+    if (previousHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = previousHome;
+    if (previousCrtrHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = previousCrtrHome;
+});
+function home() {
+    const value = mkdtempSync(join(tmpdir(), 'crtr-review-capture-'));
+    homes.push(value);
+    process.env['HOME'] = value;
+    process.env['CRTR_HOME'] = value;
+    return value;
+}
+function node(id, cwd, sourceFile, launchModel) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd,
+        kind: 'developer',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'idle',
+        pi_session_file: sourceFile,
+        launch: { extensions: [], env: {}, ...(launchModel === undefined ? {} : { model: launchModel }) },
+    };
+}
+function seededOrigin(options = {}) {
+    const cwd = home();
+    const session = SessionManager.create(join(cwd, 'sessions'));
+    if (options.sessionModel !== undefined)
+        session.appendModelChange(options.sessionModel.provider, options.sessionModel.id);
+    session.appendThinkingLevelChange(options.thinking ?? 'low');
+    session.appendMessage({
+        role: 'assistant',
+        content: [{ type: 'text', text: 'persisted' }],
+        api: 'openai-completions',
+        provider: options.sessionModel?.provider ?? 'p',
+        model: options.sessionModel?.id ?? 'm',
+        usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+        stopReason: 'stop',
+        timestamp: Date.now(),
+    });
+    const sourceFile = options.sourceFile ?? session.getSessionFile();
+    createNode(node('origin', cwd, sourceFile, options.launchModel));
+    return { cwd, session, sourceFile };
+}
+async function capture(options) {
+    return captureOrigin('origin', { registry: registry() });
+}
+async function expectOriginError(action, reason) {
+    let caught;
+    try {
+        await action();
+    }
+    catch (error) {
+        caught = error;
+    }
+    assert.ok(caught instanceof ReviewOperationError);
+    assert.equal(caught.code, 'review_origin_unforkable');
+    assert.equal(caught.detail.reason, reason);
+    return caught;
+}
+test('detached capture takes provider/id and explicit thinking from the launch recipe', async () => {
+    const { session, sourceFile } = seededOrigin({ launchModel: 'p/m:high', thinking: 'low' });
+    const captured = await capture({ launchModel: 'p/m:high', thinking: 'low' });
+    assert.deepEqual(captured, {
+        sourceFile,
+        sourceSessionId: session.getSessionId(),
+        leafId: session.getLeafId(),
+        modelSpec: 'p/m:high',
+    });
+});
+test('detached capture takes an absent thinking suffix from the persisted branch', async () => {
+    seededOrigin({ launchModel: 'p/m', thinking: 'low' });
+    assert.equal((await capture({ launchModel: 'p/m', thinking: 'low' })).modelSpec, 'p/m:low');
+});
+test('detached capture records off explicitly and does not let :off override the session', async () => {
+    seededOrigin({ launchModel: 'p/m', thinking: 'off' });
+    assert.equal((await capture({ launchModel: 'p/m', thinking: 'off' })).modelSpec, 'p/m:off');
+    closeDb();
+    for (const value of homes.splice(0))
+        rmSync(value, { recursive: true, force: true });
+    seededOrigin({ launchModel: 'p/m:off', thinking: 'high' });
+    assert.equal((await capture({ launchModel: 'p/m:off', thinking: 'high' })).modelSpec, 'p/m:high');
+});
+test('detached capture honors a dormant launch-model swap over the session model', async () => {
+    seededOrigin({ launchModel: 'q/n:high', thinking: 'low', sessionModel: { provider: 'p', id: 'm' } });
+    assert.equal((await capture({ launchModel: 'q/n:high', thinking: 'low' })).modelSpec, 'q/n:high');
+});
+test('detached capture refuses no recorded model and an unregistered launch model', async () => {
+    seededOrigin({ thinking: 'low' });
+    await expectOriginError(() => capture({ thinking: 'low' }), 'model_unresolvable');
+    closeDb();
+    for (const value of homes.splice(0))
+        rmSync(value, { recursive: true, force: true });
+    seededOrigin({ launchModel: 'p/definitely-not-a-model:high', thinking: 'low' });
+    const error = await expectOriginError(() => captureOrigin('origin', { registry: registry() }), 'model_unresolvable');
+    assert.equal(error.detail.model_reason, 'unregistered');
+});
+test('missing source sessions refuse capture and discard review staging', async () => {
+    const cwd = home();
+    const missing = join(cwd, 'sessions', 'missing.jsonl');
+    createNode(node('origin', cwd, missing, 'p/m:high'));
+    await expectOriginError(() => captureOrigin('origin', { registry: registry() }), 'no_forkable_session');
+    const target = join(cwd, 'target.md');
+    writeFileSync(target, '# target\n');
+    await expectOriginError(() => stageReview({ origin_kind: 'inline', origin_node_id: 'origin', file: target, idempotency_key: 'missing-source' }), 'no_forkable_session');
+    const reviews = join(cwd, 'reviews');
+    assert.equal(existsSync(reviews) ? readdirSync(reviews).length : 0, 0);
+    assert.equal(getReviewByIdempotencyKey('missing-source'), null);
+});

package/dist/core/review/__tests__/comments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/review/__tests__/comments.test.js

@@ -0,0 +1,98 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { test } from 'node:test';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb, openDb } from '../../canvas/db.js';
+import { createComment, deleteComment, editComment, getComment, listCommentEvents, listComments, listReviewEvents, reopenComment, resolveComment, } from '../comments.js';
+function seedReview(reviewId) {
+    openDb().prepare(`
+    INSERT INTO reviews
+      (review_id, idempotency_key, origin_kind, origin_node_id, companion_node_id, review_dir,
+       file, origin_session_file, origin_session_id, origin_leaf_id, model_spec, branch_file,
+       baseline_sha256, baseline_bytes, anchor_base_sha256, anchor_base_bytes, state, created, captured_at)
+    VALUES (?, ?, 'inline', 'origin', 'companion', '/tmp/review', '/tmp/source.md',
+            '/tmp/session.jsonl', 'session', 'leaf', 'anthropic/claude', '/tmp/branch.jsonl',
+            'baseline', 4, 'baseline', ?, 'open', ?, ?)
+  `).run(reviewId, `idempotency-${reviewId}`, Buffer.from('base'), '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z');
+}
+test('comment projection and audit are durable, idempotent, and terminally tombstoned', () => {
+    const home = mkdtempSync(join(tmpdir(), 'crtr-comments-store-'));
+    const previousHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+    try {
+        const reviewId = 'review-comments-test';
+        seedReview(reviewId);
+        const created = createComment({
+            review_id: reviewId,
+            text: 'first finding',
+            anchor: { line: 2, end_line: 2, quote: 'source' },
+            line_text: 'the source line',
+            doc_hash: 'document-a',
+            actor: { kind: 'human', node_id: null },
+            operation_id: 'create',
+        });
+        assert.equal(created.changed, true);
+        assert.equal(created.comment.revision, 1);
+        assert.equal(created.comment.created_seq, 1);
+        assert.equal(created.comment.anchor_state, 'live');
+        openDb().prepare("UPDATE review_comments SET anchor_state = 'detached' WHERE comment_id = ?").run(created.comment.comment_id);
+        assert.equal(getComment(created.comment.comment_id)?.anchor_state, 'detached');
+        assert.equal(listComments(reviewId)[0]?.anchor_state, 'detached');
+        const edited = editComment(created.comment.comment_id, {
+            text: 'edited finding',
+            actor: { kind: 'node', node_id: 'companion' },
+            operation_id: 'edit',
+        });
+        assert.equal(edited.changed, true);
+        assert.equal(edited.comment.revision, 2);
+        assert.throws(() => editComment(created.comment.comment_id, {
+            text: 'stale edit',
+            if_revision: 1,
+            actor: { kind: 'human', node_id: null },
+            operation_id: 'stale',
+        }), (error) => error instanceof Error && error.message === 'comment revision is stale');
+        assert.equal(resolveComment(created.comment.comment_id, {
+            actor: { kind: 'node', node_id: 'companion' }, operation_id: 'resolve',
+        }).comment.revision, 3);
+        assert.equal(resolveComment(created.comment.comment_id, {
+            actor: { kind: 'node', node_id: 'companion' }, operation_id: 'resolve-repeat',
+        }).changed, false);
+        assert.equal(reopenComment(created.comment.comment_id, {
+            actor: { kind: 'node', node_id: 'companion' }, operation_id: 'reopen',
+        }).comment.revision, 4);
+        assert.equal(deleteComment(created.comment.comment_id, {
+            actor: { kind: 'human', node_id: null }, operation_id: 'delete',
+        }).comment.revision, 5);
+        assert.equal(deleteComment(created.comment.comment_id, {
+            actor: { kind: 'human', node_id: null }, operation_id: 'delete-repeat',
+        }).changed, false);
+        assert.throws(() => editComment(created.comment.comment_id, {
+            text: 'resurrection', actor: { kind: 'human', node_id: null }, operation_id: 'resurrect',
+        }), (error) => error instanceof Error && error.message === 'comment is a deleted tombstone');
+        assert.deepEqual(listComments(reviewId), []);
+        assert.equal(listComments(reviewId, { status: 'all' }).length, 1);
+        assert.equal(getComment(created.comment.comment_id)?.status, 'deleted');
+        const events = listCommentEvents(created.comment.comment_id);
+        assert.deepEqual(events.map((event) => event.kind), [
+            'created', 'edited', 'resolved', 'reopened', 'deleted',
+        ]);
+        assert.deepEqual(events[1].payload.previous_anchor, {
+            line: 2, end_line: 2, quote: 'source',
+        });
+        assert.equal(events[4].payload.previous_text, 'edited finding');
+        assert.equal(events.every((event) => event.state_change === 1), true);
+        const firstPage = listReviewEvents(reviewId, { limit: 2 });
+        assert.equal(firstPage.events.length, 2);
+        const secondPage = listReviewEvents(reviewId, { since_seq: firstPage.next_since_seq });
+        assert.deepEqual(secondPage.events.map((event) => event.kind), ['resolved', 'reopened', 'deleted']);
+    }
+    finally {
+        closeDb();
+        rmSync(home, { recursive: true, force: true });
+        if (previousHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = previousHome;
+    }
+});

package/dist/core/review/__tests__/project.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/review/__tests__/project.test.js

@@ -0,0 +1,71 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { test } from 'node:test';
+import { join } from 'node:path';
+import { projectReviewResult, buildReviewResult } from '../project.js';
+import { ticketDir } from '../../human/root.js';
+import { readTicketResult, submitReview } from '../../human/tickets.js';
+test('approved review results with unresolved comments round-trip and project idempotently', () => {
+    const home = mkdtempSync(join('/tmp', 'crtr-review-project-'));
+    const previousHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+    try {
+        const source = join(home, 'source.md');
+        writeFileSync(source, '# Source\nsecond\nthird\n');
+        const bridge = submitReview({
+            dir: ticketDir('review-bridge'),
+            review: { file: source, title: 'Review source', subtitle: 'Review source.', source: {} },
+        });
+        const review = {
+            review_id: 'review-result-test',
+            origin_kind: 'ticket',
+            origin_node_id: 'origin-node',
+            bridge_node_id: 'review-bridge',
+            companion_node_id: 'companion-node',
+            baseline_sha256: 'baseline',
+            output_path: null,
+            file: source,
+        };
+        const at = '2025-01-04T00:00:00.000Z';
+        const result = buildReviewResult(review, {
+            comments: [
+                { id: 'c1', line: 1, endLine: 1, lineText: '# Source', comment: 'first', createdAt: at },
+                { id: 'c2', line: 2, endLine: 2, lineText: 'second', comment: 'second', createdAt: at },
+                { id: 'c3', line: 3, endLine: 3, lineText: 'third', comment: 'third', createdAt: at },
+            ],
+            total: 3,
+            unresolved: 2,
+        }, 'approved', at);
+        projectReviewResult(review, result);
+        const responsePath = join(bridge.dir, 'response.json');
+        const firstResponse = readFileSync(responsePath);
+        const decoded = readTicketResult(bridge.dir);
+        assert.equal(decoded?.kind, 'review');
+        assert.equal(decoded?.kind === 'review' ? decoded.result.approved : false, true);
+        assert.equal(decoded?.kind === 'review' ? decoded.result.comments.length : 0, 3);
+        assert.deepEqual(decoded?.kind === 'review' ? decoded.result : undefined, {
+            file: source,
+            submitted: true,
+            approved: true,
+            comments: result.comments,
+            submittedAt: at,
+            savedAt: at,
+            reviewId: 'review-result-test',
+            changed: true,
+            baselineSha256: 'baseline',
+            approvedSha256: 'approved',
+            companionNodeId: 'companion-node',
+            commentsTotal: 3,
+            commentsUnresolved: 2,
+        });
+        projectReviewResult(review, result);
+        assert.deepEqual(readFileSync(responsePath), firstResponse);
+    }
+    finally {
+        if (previousHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = previousHome;
+        rmSync(home, { recursive: true, force: true });
+    }
+});

package/dist/core/review/__tests__/remap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/review/__tests__/remap.test.js

@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import { closeDb, openDb, withCanvasWrite } from '../../canvas/db.js';
+import { createComment, getComment, listCommentEvents } from '../comments.js';
+import { captureAnchorText, requireCurrentDocument, requireCurrentDocumentLocked, readReviewSource } from '../document.js';
+import { applyRangeBatch } from '../remap.js';
+import { readAnchorBase, getReview } from '../store.js';
+import { ReviewOperationError } from '../types.js';
+function seedReview(reviewId, file, hash, bytes) {
+    openDb().prepare(`
+    INSERT INTO reviews
+      (review_id, idempotency_key, origin_kind, origin_node_id, companion_node_id, review_dir,
+       file, origin_session_file, origin_session_id, origin_leaf_id, model_spec, branch_file,
+       baseline_sha256, baseline_bytes, anchor_base_sha256, anchor_base_bytes, state, created, captured_at)
+    VALUES (?, ?, 'inline', 'origin', 'companion', '/tmp/review', ?,
+            '/tmp/session.jsonl', 'session', 'leaf', 'openai/gpt', '/tmp/branch.jsonl',
+            ?, ?, ?, ?, 'open', ?, ?)
+  `).run(reviewId, `idempotency-${reviewId}`, file, hash, bytes.length, hash, bytes, '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z');
+}
+function expectReviewError(action, code) {
+    let caught;
+    try {
+        action();
+    }
+    catch (error) {
+        caught = error;
+    }
+    assert.ok(caught instanceof ReviewOperationError);
+    assert.equal(caught.code, code);
+    return caught;
+}
+test('document lines use editor coordinates for terminated, empty, and unterminated files', () => {
+    const home = mkdtempSync(join(tmpdir(), 'crtr-review-document-lines-'));
+    try {
+        const terminated = join(home, 'terminated.md');
+        writeFileSync(terminated, 'one\ntwo\nthree\n');
+        const terminatedLines = readReviewSource(terminated).lines;
+        assert.equal(terminatedLines.length, 3);
+        const outOfRange = expectReviewError(() => captureAnchorText(terminatedLines, { line: 4, end_line: 4 }), 'anchor_out_of_range');
+        assert.equal(outOfRange.detail.line_count, 3);
+        const empty = join(home, 'empty.md');
+        writeFileSync(empty, '');
+        const emptyLines = readReviewSource(empty).lines;
+        assert.equal(emptyLines.length, 1);
+        assert.equal(captureAnchorText(emptyLines, { line: 1, end_line: 1 }), '');
+        const unterminated = join(home, 'unterminated.md');
+        writeFileSync(unterminated, 'a\nb');
+        assert.equal(readReviewSource(unterminated).lines.length, 2);
+    }
+    finally {
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test('document preconditions and a full range batch preserve comment identity and audit atomically', () => {
+    const home = mkdtempSync(join(tmpdir(), 'crtr-review-remap-'));
+    const previousHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+    try {
+        const file = join(home, 'review.md');
+        writeFileSync(file, 'one\ntwo\nthree\n');
+        const before = readReviewSource(file);
+        const reviewId = 'review-remap-test';
+        seedReview(reviewId, file, before.sha256, before.bytes);
+        const first = createComment({
+            review_id: reviewId,
+            text: 'first finding',
+            anchor: { line: 1, end_line: 1 },
+            line_text: 'one',
+            doc_hash: before.sha256,
+            actor: { kind: 'human', node_id: null },
+            operation_id: 'create-first',
+        }).comment;
+        const second = createComment({
+            review_id: reviewId,
+            text: 'second finding',
+            anchor: { line: 2, end_line: 2 },
+            line_text: 'two',
+            doc_hash: before.sha256,
+            actor: { kind: 'node', node_id: 'companion' },
+            operation_id: 'create-second',
+        }).comment;
+        writeFileSync(file, 'zero\none\ntwo\nthree\n');
+        const after = readReviewSource(file);
+        const review = getReview(reviewId);
+        const changed = expectReviewError(() => requireCurrentDocument(review, before.sha256), 'stale_document');
+        assert.equal(changed.detail.reason, 'document_changed');
+        const baseStale = expectReviewError(() => withCanvasWrite((db) => requireCurrentDocumentLocked(db, reviewId, after.sha256)), 'stale_document');
+        assert.equal(baseStale.detail.reason, 'anchor_base_stale');
+        const columnOutOfRange = expectReviewError(() => captureAnchorText(['one'], {
+            line: 1, end_line: 1, col_start: 999, col_end: 1_000,
+        }), 'anchor_out_of_range');
+        assert.deepEqual(columnOutOfRange.detail.requested, { line: 1, end_line: 1 });
+        const missing = expectReviewError(() => applyRangeBatch({
+            review_id: reviewId,
+            from_doc_hash: before.sha256,
+            to_doc_hash: after.sha256,
+            entries: [{ comment_id: first.comment_id, anchor: { line: 2, end_line: 2 } }],
+            actor: { kind: 'human', node_id: null },
+            operation_id: 'missing',
+        }), 'range_batch_incomplete');
+        assert.deepEqual(missing.detail.missing, [second.comment_id]);
+        assert.equal(readAnchorBase(reviewId)?.sha256, before.sha256);
+        assert.equal(getComment(first.comment_id)?.anchor_doc_hash, before.sha256);
+        assert.deepEqual(listCommentEvents(first.comment_id).map((event) => event.kind), ['created']);
+        const stale = expectReviewError(() => applyRangeBatch({
+            review_id: reviewId,
+            from_doc_hash: 'stale-base',
+            to_doc_hash: after.sha256,
+            entries: [
+                { comment_id: first.comment_id, anchor: { line: 2, end_line: 2 } },
+                { comment_id: second.comment_id, detached: true },
+            ],
+            actor: { kind: 'human', node_id: null },
+            operation_id: 'stale',
+        }), 'range_batch_stale');
+        assert.equal(stale.detail.reason, 'from_doc_hash');
+        assert.equal(readAnchorBase(reviewId)?.sha256, before.sha256);
+        const applied = applyRangeBatch({
+            review_id: reviewId,
+            from_doc_hash: before.sha256,
+            to_doc_hash: after.sha256,
+            entries: [
+                { comment_id: first.comment_id, anchor: { line: 2, end_line: 2 } },
+                { comment_id: second.comment_id, detached: true },
+            ],
+            actor: { kind: 'human', node_id: null },
+            operation_id: 'apply',
+        });
+        assert.deepEqual(applied, { updated: 2, detached: 1, anchor_base_sha256: after.sha256 });
+        assert.deepEqual(readAnchorBase(reviewId), { bytes: after.bytes, sha256: after.sha256 });
+        const remappedFirst = getComment(first.comment_id);
+        const detachedSecond = getComment(second.comment_id);
+        assert.equal(remappedFirst.comment_id, first.comment_id);
+        assert.deepEqual(remappedFirst.author, first.author);
+        assert.equal(remappedFirst.status, first.status);
+        assert.equal(remappedFirst.anchor_state, 'live');
+        assert.deepEqual(remappedFirst.anchor, { line: 2, end_line: 2 });
+        assert.equal(remappedFirst.anchor_line_text, 'one');
+        assert.equal(remappedFirst.anchor_doc_hash, after.sha256);
+        assert.equal(detachedSecond.comment_id, second.comment_id);
+        assert.deepEqual(detachedSecond.author, second.author);
+        assert.equal(detachedSecond.status, second.status);
+        assert.equal(detachedSecond.anchor_state, 'detached');
+        assert.equal(detachedSecond.anchor_doc_hash, after.sha256);
+        assert.deepEqual(listCommentEvents(first.comment_id).map((event) => event.kind), ['created', 'reanchored']);
+        assert.deepEqual(listCommentEvents(second.comment_id).map((event) => event.kind), ['created', 'reanchored']);
+    }
+    finally {
+        closeDb();
+        rmSync(home, { recursive: true, force: true });
+        if (previousHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = previousHome;
+    }
+});

package/dist/core/review/__tests__/stage-identity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/review/__tests__/stage-identity.test.js

@@ -0,0 +1,140 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, test } from 'node:test';
+import { createNode } from '../../canvas/canvas.js';
+import { closeDb, openDb } from '../../canvas/db.js';
+import { SessionManager } from '../../runtime/broker-sdk.js';
+import { stageReview } from '../stage.js';
+import { ReviewOperationError } from '../types.js';
+const previousHome = process.env['HOME'];
+const previousCrtrHome = process.env['CRTR_HOME'];
+const previousAgentDir = process.env['PI_CODING_AGENT_DIR'];
+const homes = [];
+afterEach(() => {
+    closeDb();
+    for (const home of homes.splice(0))
+        rmSync(home, { recursive: true, force: true });
+    if (previousHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = previousHome;
+    if (previousCrtrHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = previousCrtrHome;
+    if (previousAgentDir === undefined)
+        delete process.env['PI_CODING_AGENT_DIR'];
+    else
+        process.env['PI_CODING_AGENT_DIR'] = previousAgentDir;
+});
+function assistant(model) {
+    return {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'persisted' }],
+        api: 'openai-completions',
+        provider: 'lm-studio',
+        model,
+        usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+        stopReason: 'stop',
+        timestamp: Date.now(),
+    };
+}
+function setup() {
+    const home = mkdtempSync(join(tmpdir(), 'crtr-review-identity-'));
+    homes.push(home);
+    process.env['HOME'] = home;
+    process.env['CRTR_HOME'] = home;
+    const agentDir = join(home, 'agent');
+    mkdirSync(agentDir);
+    process.env['PI_CODING_AGENT_DIR'] = agentDir;
+    writeFileSync(join(agentDir, 'models.json'), JSON.stringify({
+        providers: {
+            'lm-studio': {
+                baseUrl: 'http://127.0.0.1:1234/v1',
+                api: 'openai-completions',
+                apiKey: 'test-key',
+                models: [{ id: 'm', name: 'fixture' }],
+            },
+        },
+    }));
+    const sessions = join(home, 'sessions');
+    const original = SessionManager.create(sessions);
+    original.appendThinkingLevelChange('low');
+    original.appendMessage(assistant('m'));
+    const sourceFile = original.getSessionFile();
+    createNode({
+        node_id: 'origin',
+        name: 'origin',
+        created: new Date().toISOString(),
+        cwd: home,
+        kind: 'developer',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'idle',
+        pi_session_file: sourceFile,
+        launch: { extensions: [], env: {}, model: 'lm-studio/m:high' },
+    });
+    const target = join(home, 'target.md');
+    writeFileSync(target, '# target\n');
+    return { home, sessions, sourceFile, target };
+}
+function replacement(sessions, thinking) {
+    const next = SessionManager.create(sessions);
+    next.appendThinkingLevelChange(thinking);
+    next.appendMessage(assistant('m'));
+    return next.getSessionFile();
+}
+function reviewCount() {
+    return openDb().prepare('SELECT COUNT(*) AS count FROM reviews').get().count;
+}
+async function stageWithCapturedFileReplacements(fixture, replacements) {
+    const originalOpen = SessionManager.open;
+    let sourceOpens = 0;
+    SessionManager.open = ((...args) => {
+        const [path] = args;
+        if (path === fixture.sourceFile) {
+            sourceOpens++;
+            const replacement = replacements.find((entry) => entry.onSourceOpen === sourceOpens);
+            if (replacement !== undefined)
+                renameSync(replacement.file, fixture.sourceFile);
+        }
+        return originalOpen(...args);
+    });
+    try {
+        return await stageReview({
+            origin_kind: 'inline', origin_node_id: 'origin', file: fixture.target,
+            idempotency_key: replacements.length === 1 ? 'one-replacement' : 'two-replacements',
+        });
+    }
+    finally {
+        SessionManager.open = originalOpen;
+    }
+}
+test('stageReview recaptures when the captured file rotates once', async () => {
+    const fixture = setup();
+    const next = replacement(fixture.sessions, 'medium');
+    const result = await stageWithCapturedFileReplacements(fixture, [{ onSourceOpen: 2, file: next }]);
+    assert.ok('row' in result && result.row !== undefined);
+    const row = result.row;
+    assert.equal(row.origin_session_id, SessionManager.open(fixture.sourceFile).getSessionId());
+    assert.equal(row.model_spec, 'lm-studio/m:high');
+    assert.equal(reviewCount(), 0, 'staging does not commit a review row');
+});
+test('stageReview rejects a source file that loses identity twice', async () => {
+    const fixture = setup();
+    const first = replacement(fixture.sessions, 'medium');
+    const second = replacement(fixture.sessions, 'high');
+    await assert.rejects(() => stageWithCapturedFileReplacements(fixture, [
+        { onSourceOpen: 2, file: first },
+        { onSourceOpen: 4, file: second },
+    ]), (error) => {
+        assert.ok(error instanceof ReviewOperationError);
+        assert.equal(error.code, 'review_origin_unstable');
+        return true;
+    });
+    const reviews = join(fixture.home, 'reviews');
+    assert.equal(readdirSync(reviews).length, 0);
+    assert.equal(reviewCount(), 0);
+});

package/dist/core/review/birth.d.ts

@@ -0,0 +1,7 @@
+import { type StageReviewArgs } from './stage.js';
+import type { ReviewRecord } from './types.js';
+/**
+ * Stage filesystem-only fork state, atomically select the canonical binding,
+ * then realize that committed winner. Staging is never visible by itself.
+ */
+export declare function createReview(args: StageReviewArgs): Promise<ReviewRecord>;

package/dist/core/review/birth.js

@@ -0,0 +1,23 @@
+import { commitBindingReview } from './store.js';
+import { discardStaging, stageReview } from './stage.js';
+import { realizeReview } from './realize.js';
+/**
+ * Stage filesystem-only fork state, atomically select the canonical binding,
+ * then realize that committed winner. Staging is never visible by itself.
+ */
+export async function createReview(args) {
+    const staged = await stageReview(args);
+    if (staged.existing !== undefined)
+        return realizeReview(staged.existing.review_id);
+    let committed;
+    try {
+        committed = commitBindingReview(staged.row);
+    }
+    catch (error) {
+        discardStaging(staged.row.review_id);
+        throw error;
+    }
+    if (!committed.won)
+        discardStaging(staged.row.review_id);
+    return realizeReview(committed.review_id);
+}