@north-light/crouter 0.3.311 → 0.3.313

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

@@ -4,7 +4,11 @@ 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 { closeDb, migrate, openDb } from '../../canvas/db.js';
+import { resetSession } from '../../canvas/sessions.js';
+import { resetScopeCache } from '../../scope.js';
+import { closeScopedStores } from '../../scoped-state/db.js';
+import { initializeFreshScopedStore } from '../../scoped-state/migrate.js';
 import { SessionManager } from '../../runtime/broker-sdk.js';
 import { captureOrigin } from '../companion.js';
 import { stageReview } from '../stage.js';
@@ -20,6 +24,7 @@ const previousHome = process.env['HOME'];
 const previousCrtrHome = process.env['CRTR_HOME'];
 afterEach(() => {
     closeDb();
+    closeScopedStores();
     for (const home of homes.splice(0))
         rmSync(home, { recursive: true, force: true });
     if (previousHome === undefined)
@@ -30,12 +35,17 @@ afterEach(() => {
         delete process.env['CRTR_HOME'];
     else
         process.env['CRTR_HOME'] = previousCrtrHome;
+    resetScopeCache();
 });
 function home() {
     const value = mkdtempSync(join(tmpdir(), 'crtr-review-capture-'));
     homes.push(value);
     process.env['HOME'] = value;
-    process.env['CRTR_HOME'] = value;
+    process.env['CRTR_HOME'] = join(value, 'canvas');
+    resetScopeCache();
+    initializeFreshScopedStore({ kind: 'user', root: join(value, '.crouter') });
+    initializeFreshScopedStore({ kind: 'provider', root: join(value, '.pi', 'agent') });
+    migrate(openDb());
     return value;
 }
 function node(id, cwd, sourceFile, launchModel) {
@@ -70,6 +80,7 @@ function seededOrigin(options = {}) {
     });
     const sourceFile = options.sourceFile ?? session.getSessionFile();
     createNode(node('origin', cwd, sourceFile, options.launchModel));
+    resetSession('origin', { sessionId: session.getSessionId(), transcriptPath: sourceFile });
     return { cwd, session, sourceFile };
 }
 async function capture(options) {

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

@@ -3,23 +3,41 @@ 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 { closeDb, migrate, openDb } from '../../canvas/db.js';
+import { commitBindingRequest, openRequest } from '../../human/requests.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');
+    const created = '2026-01-01T00:00:00.000Z';
+    commitBindingRequest({
+        request_id: reviewId,
+        idempotency_key: `idempotency-${reviewId}`,
+        requester_node_id: 'origin',
+        companion_node_id: 'companion',
+        request_dir: '/tmp/review',
+        file: '/tmp/source.md',
+        specification: {
+            origin_kind: 'inline',
+            origin_session_file: '/tmp/session.jsonl',
+            origin_session_id: 'session',
+            origin_leaf_id: 'leaf',
+            model_spec: 'anthropic/claude',
+            branch_file: '/tmp/branch.jsonl',
+            baseline_sha256: 'baseline',
+            baseline_bytes: 4,
+            captured_at: created,
+        },
+        anchor_base_sha256: 'baseline',
+        anchor_base_bytes: Buffer.from('base'),
+        created_at: created,
+        inbox_listed: false,
+    });
+    assert.equal(openRequest(reviewId, created), true);
 }
 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;
+    migrate(openDb());
     try {
         const reviewId = 'review-comments-test';
         seedReview(reviewId);

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

@@ -3,22 +3,39 @@ 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 { closeDb, migrate, openDb, withCanvasWrite } from '../../canvas/db.js';
+import { commitBindingRequest, openRequest } from '../../human/requests.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');
+    const created = '2026-01-01T00:00:00.000Z';
+    commitBindingRequest({
+        request_id: reviewId,
+        idempotency_key: `idempotency-${reviewId}`,
+        requester_node_id: 'origin',
+        companion_node_id: 'companion',
+        request_dir: '/tmp/review',
+        file,
+        specification: {
+            origin_kind: 'inline',
+            origin_session_file: '/tmp/session.jsonl',
+            origin_session_id: 'session',
+            origin_leaf_id: 'leaf',
+            model_spec: 'openai/gpt',
+            branch_file: '/tmp/branch.jsonl',
+            baseline_sha256: hash,
+            baseline_bytes: bytes.length,
+            captured_at: created,
+        },
+        anchor_base_sha256: hash,
+        anchor_base_bytes: bytes,
+        created_at: created,
+        inbox_listed: false,
+    });
+    assert.equal(openRequest(reviewId, created), true);
 }
 function expectReviewError(action, code) {
     let caught;
@@ -58,6 +75,7 @@ test('document preconditions and a full range batch preserve comment identity an
     const home = mkdtempSync(join(tmpdir(), 'crtr-review-remap-'));
     const previousHome = process.env['CRTR_HOME'];
     process.env['CRTR_HOME'] = home;
+    migrate(openDb());
     try {
         const file = join(home, 'review.md');
         writeFileSync(file, 'one\ntwo\nthree\n');

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

@@ -1,10 +1,14 @@
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdtempSync, mkdirSync, readdirSync, realpathSync, 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 { closeDb, migrate, openDb } from '../../canvas/db.js';
+import { resetSession } from '../../canvas/sessions.js';
+import { resetScopeCache } from '../../scope.js';
+import { closeScopedStores } from '../../scoped-state/db.js';
+import { initializeFreshScopedStore } from '../../scoped-state/migrate.js';
 import { SessionManager } from '../../runtime/broker-sdk.js';
 import { stageReview } from '../stage.js';
 import { ReviewOperationError } from '../types.js';
@@ -14,6 +18,7 @@ const previousAgentDir = process.env['PI_CODING_AGENT_DIR'];
 const homes = [];
 afterEach(() => {
     closeDb();
+    closeScopedStores();
     for (const home of homes.splice(0))
         rmSync(home, { recursive: true, force: true });
     if (previousHome === undefined)
@@ -28,6 +33,7 @@ afterEach(() => {
         delete process.env['PI_CODING_AGENT_DIR'];
     else
         process.env['PI_CODING_AGENT_DIR'] = previousAgentDir;
+    resetScopeCache();
 });
 function assistant(model) {
     return {
@@ -45,9 +51,13 @@ function setup() {
     const home = mkdtempSync(join(tmpdir(), 'crtr-review-identity-'));
     homes.push(home);
     process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = home;
+    process.env['CRTR_HOME'] = join(home, 'canvas');
+    resetScopeCache();
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    migrate(openDb());
     const agentDir = join(home, 'agent');
     mkdirSync(agentDir);
+    initializeFreshScopedStore({ kind: 'provider', root: agentDir });
     process.env['PI_CODING_AGENT_DIR'] = agentDir;
     writeFileSync(join(agentDir, 'models.json'), JSON.stringify({
         providers: {
@@ -73,9 +83,9 @@ function setup() {
         mode: 'base',
         lifecycle: 'terminal',
         status: 'idle',
-        pi_session_file: sourceFile,
         launch: { extensions: [], env: {}, model: 'lm-studio/m:high' },
     });
+    resetSession('origin', { sessionId: original.getSessionId(), transcriptPath: sourceFile });
     const target = join(home, 'target.md');
     writeFileSync(target, '# target\n');
     return { home, sessions, sourceFile, target };
@@ -87,7 +97,7 @@ function replacement(sessions, thinking) {
     return next.getSessionFile();
 }
 function reviewCount() {
-    return openDb().prepare('SELECT COUNT(*) AS count FROM reviews').get().count;
+    return openDb().prepare("SELECT COUNT(*) AS count FROM human_requests WHERE kind = 'review'").get().count;
 }
 async function stageWithCapturedFileReplacements(fixture, replacements) {
     const originalOpen = SessionManager.open;
@@ -134,7 +144,7 @@ test('stageReview rejects a source file that loses identity twice', async () =>
         assert.equal(error.code, 'review_origin_unstable');
         return true;
     });
-    const reviews = join(fixture.home, 'reviews');
-    assert.equal(readdirSync(reviews).length, 0);
+    const reviews = join(fixture.home, 'canvas', 'reviews');
+    assert.equal(existsSync(reviews) ? readdirSync(reviews).length : 0, 0);
     assert.equal(reviewCount(), 0);
 });

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

@@ -1,5 +1,5 @@
-import { type StageReviewArgs } from './stage.js';
 import type { ReviewRecord } from './types.js';
+import { type StageReviewArgs } from './stage.js';
 /**
  * Stage filesystem-only fork state, atomically select the canonical binding,
  * then realize that committed winner. Staging is never visible by itself.

package/dist/core/review/birth.js

@@ -1,4 +1,5 @@
-import { commitBindingReview } from './store.js';
+import { commitBindingRequest } from '../human/requests.js';
+import { getReview } from './store.js';
 import { discardStaging, stageReview } from './stage.js';
 import { realizeReview } from './realize.js';
 /**
@@ -7,11 +8,35 @@ import { realizeReview } from './realize.js';
  */
 export async function createReview(args) {
     const staged = await stageReview(args);
-    if (staged.existing !== undefined)
-        return realizeReview(staged.existing.review_id);
+    if (staged.existing !== undefined) {
+        await realizeReview(staged.existing.request_id);
+        const review = getReview(staged.existing.request_id);
+        if (review === null)
+            throw new Error(`realized review disappeared: ${staged.existing.request_id}`);
+        return review;
+    }
     let committed;
     try {
-        committed = commitBindingReview(staged.row);
+        committed = commitBindingRequest({
+            request_id: staged.row.review_id,
+            idempotency_key: staged.row.idempotency_key,
+            requester_node_id: staged.row.origin_node_id,
+            companion_node_id: staged.row.companion_node_id,
+            request_dir: staged.row.review_dir,
+            file: staged.row.file,
+            specification: {
+                origin_kind: staged.row.origin_kind,
+                origin_session_file: staged.row.origin_session_file, origin_session_id: staged.row.origin_session_id,
+                origin_leaf_id: staged.row.origin_leaf_id, model_spec: staged.row.model_spec, branch_file: staged.row.branch_file,
+                baseline_sha256: staged.row.baseline_sha256, baseline_bytes: staged.row.baseline_bytes,
+                captured_at: staged.row.captured_at, output_path: staged.row.output_path,
+            },
+            anchor_base_sha256: staged.row.anchor_base_sha256,
+            anchor_base_bytes: staged.row.anchor_base_bytes,
+            created_at: staged.row.created,
+            subtitle: staged.row.subtitle,
+            inbox_listed: staged.row.origin_kind === 'ticket',
+        });
     }
     catch (error) {
         discardStaging(staged.row.review_id);
@@ -19,5 +44,9 @@ export async function createReview(args) {
     }
     if (!committed.won)
         discardStaging(staged.row.review_id);
-    return realizeReview(committed.review_id);
+    await realizeReview(committed.request_id);
+    const review = getReview(committed.request_id);
+    if (review === null)
+        throw new Error(`realized review disappeared: ${committed.request_id}`);
+    return review;
 }

package/dist/core/review/comments.js

@@ -88,7 +88,7 @@ function requireStoredComment(db, commentIdValue) {
     return row;
 }
 function assertReviewExists(db, reviewId) {
-    const row = db.prepare('SELECT review_id FROM reviews WHERE review_id = ?').get(reviewId);
+    const row = db.prepare("SELECT request_id FROM human_requests WHERE request_id = ? AND kind = 'review' AND state = 'open'").get(reviewId);
     if (row === undefined) {
         throw new ReviewOperationError('unknown_review', 'review was not found', { received: reviewId });
     }

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

@@ -27,7 +27,7 @@ export declare function captureOrigin(originNodeId: string, deps?: {
 /** Materialize the immutable review fork, reusing only an already-valid branch. */
 export declare function materializeReviewBranch(reviewId: string, capture: OriginCapture): string;
 /** Create the ordinary, promptless companion node. Realization owns its launch. */
-export declare function spawnReviewCompanion(spec: ReviewCompanionSpec): void;
+export declare function spawnReviewCompanion(spec: ReviewCompanionSpec): Promise<void>;
 /** A companion is bound only when its session coordinates and visible boundary are durable. */
 export declare function isReviewCompanionBound(nodeId: string): boolean;
 /** Wait for the durable companion bind without owning companion liveness. */

package/dist/core/review/companion.js

@@ -141,7 +141,7 @@ export function materializeReviewBranch(reviewId, capture) {
     return branchFile;
 }
 /** Create the ordinary, promptless companion node. Realization owns its launch. */
-export function spawnReviewCompanion(spec) {
+export async function spawnReviewCompanion(spec) {
     if (!isAbsolute(spec.branchFile) || !isAbsolute(spec.targetFile)) {
         throw new Error('review companion requires absolute branch and target paths');
     }
@@ -156,7 +156,7 @@ export function spawnReviewCompanion(spec) {
         cwd: spec.cwd,
         profileId: spec.profileId,
     });
-    const node = spawnNode({
+    const node = await spawnNode({
         nodeId: spec.nodeId,
         kind: 'review/companion',
         mode: 'base',

package/dist/core/review/document.js

@@ -68,7 +68,7 @@ export function requireCurrentDocument(review, expected_doc_hash) {
 }
 /** Verify a create-time source precondition from the review row held by the caller's canvas write transaction. */
 export function requireCurrentDocumentLocked(db, review_id, expected_doc_hash) {
-    const review = db.prepare('SELECT file, anchor_base_sha256 FROM reviews WHERE review_id = ?').get(review_id);
+    const review = db.prepare("SELECT file, anchor_base_sha256 FROM human_requests WHERE request_id = ? AND kind = 'review' AND state = 'open'").get(review_id);
     if (review === undefined) {
         throw new ReviewOperationError('unknown_review', 'review was not found', { received: review_id });
     }

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

@@ -7,7 +7,11 @@ export interface ReviewCommentSnapshot {
 }
 /** Build the immutable approval result from the review row and one comment snapshot. */
 export declare function buildReviewResult(review: ReviewRecord, snapshot: ReviewCommentSnapshot, approvedSha256: string, at: string): ReviewResult;
-/** Project one immutable result to ticket/output or inline result surfaces. */
+/** Project every terminal review from its SQL row; no ticket bridge participates. */
 export declare function projectReviewResult(review: ReviewRecord, result: ReviewResult): {
     destinations: string[];
 };
+/** Cancellation has no review approval payload but still receives a durable projection. */
+export declare function projectReviewCancellation(review: ReviewRecord, result: unknown): {
+    destinations: string[];
+};

package/dist/core/review/project.js

@@ -1,7 +1,5 @@
 import { join } from 'node:path';
-import { atomicWriteJson, publishJsonExclusive, responsePath } from '../human/convention.js';
-import { ticketDir } from '../human/root.js';
-import { reviewResultPath } from '../canvas/paths.js';
+import { atomicWriteJson } from '../human/convention.js';
 /** Build the immutable approval result from the review row and one comment snapshot. */
 export function buildReviewResult(review, snapshot, approvedSha256, at) {
     return {
@@ -21,38 +19,18 @@ export function buildReviewResult(review, snapshot, approvedSha256, at) {
         savedAt: at,
     };
 }
-/** Project one immutable result to ticket/output or inline result surfaces. */
+/** Project every terminal review from its SQL row; no ticket bridge participates. */
 export function projectReviewResult(review, result) {
-    const destinations = [];
-    if (review.origin_kind === 'ticket') {
-        if (review.bridge_node_id === null)
-            throw new Error(`ticket review has no bridge node: ${review.review_id}`);
-        const dir = ticketDir(review.bridge_node_id);
-        const feedback = {
-            file: result.file,
-            submitted: result.submitted,
-            approved: result.approved,
-            comments: result.comments,
-            submittedAt: result.submittedAt,
-            savedAt: result.savedAt,
-            reviewId: result.review_id,
-            changed: result.changed,
-            baselineSha256: result.baseline_sha256,
-            approvedSha256: result.approved_sha256,
-            companionNodeId: result.companion_node_id,
-            commentsTotal: result.comments_total,
-            commentsUnresolved: result.comments_unresolved,
-        };
-        const response = responsePath(dir);
-        publishJsonExclusive(response, { schema: 'humanloop.review-response/v1', kind: 'review', result: feedback, completedAt: result.submittedAt });
-        destinations.push(response);
-        const output = review.output_path ?? join(dir, 'feedback.json');
-        atomicWriteJson(output, feedback);
-        destinations.push(output);
-        return { destinations };
-    }
-    const output = reviewResultPath(review.review_id);
-    atomicWriteJson(output, result);
-    destinations.push(output);
-    return { destinations };
+    const resultPath = join(review.review_dir, 'result.json');
+    atomicWriteJson(resultPath, result);
+    const output = review.output_path ?? join(review.review_dir, 'feedback.json');
+    if (output !== resultPath)
+        atomicWriteJson(output, result);
+    return { destinations: output === resultPath ? [resultPath] : [resultPath, output] };
+}
+/** Cancellation has no review approval payload but still receives a durable projection. */
+export function projectReviewCancellation(review, result) {
+    const resultPath = join(review.review_dir, 'result.json');
+    atomicWriteJson(resultPath, result);
+    return { destinations: [resultPath] };
 }

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

@@ -1,6 +1,3 @@
-import { type ReviewRecord } from './types.js';
-/**
- * Finish a committed binding without ever recapturing its origin. Each step is
- * safe to repeat after a crash; review.json is the final visibility switch.
- */
-export declare function realizeReview(reviewId: string): Promise<ReviewRecord>;
+import { type HumanRequestRecord } from '../human/requests.js';
+/** Finish a committed binding without bridge creation or directory descriptor publication. */
+export declare function realizeReview(reviewId: string): Promise<HumanRequestRecord>;