@north-light/crouter 0.3.312 → 0.3.313

package/dist/core/review/realize.js

@@ -1,188 +1,71 @@
 import { existsSync } from 'node:fs';
-import { basename } from 'node:path';
-import { getNode, subscribersOf, subscribe } from '../canvas/index.js';
-import { withCanvasWrite } from '../canvas/db.js';
-import { bindTicketReplyRoute } from '../human/convention.js';
-import { ticketDir } from '../human/root.js';
-import { submitReview } from '../human/tickets.js';
-import { NodeIdConflictError, spawnNode } from '../runtime/nodes.js';
-import { loadProfileManifest } from '../profiles/manifest.js';
-import { transition } from '../runtime/lifecycle.js';
+import { getNode } from '../canvas/index.js';
+import { openRequest, cancelBindingRequest, getRequest } from '../human/requests.js';
+import { NodeIdConflictError } from '../runtime/nodes.js';
 import { reviveNode } from '../runtime/revive.js';
 import { awaitCompanionBind, spawnReviewCompanion } from './companion.js';
 import { signalReviewActivity } from './signal.js';
-import { bindBridgeNode, getReview, openReviewRow } from './store.js';
 import { COMPANION_BIND_DEADLINE_MS, ReviewOperationError } from './types.js';
-function unknownReview(reviewId) {
-    return new ReviewOperationError('unknown_review', 'review was not found', { received: reviewId });
+function requireBinding(reviewId) {
+    const request = getRequest(reviewId);
+    if (request === null || request.kind !== 'review')
+        throw new ReviewOperationError('unknown_review', 'review was not found', { received: reviewId });
+    return request;
 }
-function originMissing(originNodeId) {
-    return new ReviewOperationError('review_origin_missing', 'review origin was not found', {
-        origin_node_id: originNodeId,
-        reason: 'origin_missing',
-    });
-}
-function companionUnbound(reviewId, waitedMs) {
-    return new ReviewOperationError('review_companion_unbound', 'review companion did not bind in time', {
-        review_id: reviewId,
-        waited_ms: waitedMs,
-    });
-}
-function bridgeUnsubscribed(review, bridgeNodeId) {
-    return new ReviewOperationError('review_bridge_unsubscribed', 'review bridge is not subscribed to its origin', {
-        review_id: review.review_id,
-        bridge_node_id: bridgeNodeId,
-        origin_node_id: review.origin_node_id,
-    });
-}
-/** Cancel only a binding whose immutable branch has disappeared. No later pass may recapture it. */
-function cancelLostBinding(review) {
-    const canceled = withCanvasWrite((db) => db.prepare(`
-    UPDATE reviews
-    SET state = 'canceled', canceled_at = ?, cancel_reason = 'branch_lost', cancel_actor = NULL
-    WHERE review_id = ? AND state = 'binding'
-  `).run(new Date().toISOString(), review.review_id).changes > 0);
-    if (canceled)
-        signalReviewActivity();
-}
-function requireReview(reviewId) {
-    const review = getReview(reviewId);
-    if (review === null)
-        throw unknownReview(reviewId);
-    return review;
-}
-function requireOrigin(review) {
-    const origin = getNode(review.origin_node_id);
-    if (origin === null)
-        throw originMissing(review.origin_node_id);
-    return origin;
-}
-async function spawnCompanion(review) {
-    if (getNode(review.companion_node_id) !== null)
-        return;
-    const origin = requireOrigin(review);
+function specification(request) {
     try {
-        await spawnReviewCompanion({
-            nodeId: review.companion_node_id,
-            reviewId: review.review_id,
-            originNodeId: review.origin_node_id,
-            branchFile: review.branch_file,
-            targetFile: review.file,
-            modelSpec: review.model_spec,
-            cwd: origin.cwd,
-            profileId: origin.profile_id ?? null,
-        });
+        const value = JSON.parse(request.specification_json);
+        if (typeof value !== 'object' || value === null)
+            throw new Error('not an object');
+        return value;
     }
     catch (error) {
-        if (!(error instanceof NodeIdConflictError))
-            throw error;
+        throw new Error(`corrupt review specification: ${request.request_id}`, { cause: error });
     }
 }
-function cancelInvisibleBridge(nodeId) {
-    // A bridge which lost bindBridgeNode() was never exposed, so canceling it
-    // cannot produce a final report or notify the origin.
-    const node = getNode(nodeId);
-    if (node !== null && node.status !== 'done' && node.status !== 'canceled')
-        transition(nodeId, 'cancel', { reason: 'retired' });
-}
-/** Assert the only route a bridge has back to its origin before ticket exposure. */
-function ensureBridgeSubscription(review, bridgeNodeId) {
-    const hasActiveOrigin = () => subscribersOf(bridgeNodeId).some((subscriber) => subscriber.node_id === review.origin_node_id && subscriber.active);
-    if (!hasActiveOrigin())
-        subscribe(review.origin_node_id, bridgeNodeId, true);
-    if (!hasActiveOrigin())
-        throw bridgeUnsubscribed(review, bridgeNodeId);
-}
-/** R2: create/bind the ticket bridge and prove its active origin subscription. */
-async function realizeBridge(review) {
-    if (review.origin_kind !== 'ticket')
-        return review;
-    let current = review;
-    if (current.bridge_node_id === null) {
-        const origin = requireOrigin(current);
-        const bridge = await spawnNode({
-            kind: 'human',
-            lifecycle: 'terminal',
-            parent: current.origin_node_id,
-            creator: current.origin_node_id,
-            cwd: origin.cwd,
-            profile_id: origin.profile_id ?? null,
-            name: 'human-review',
-        });
-        bindTicketReplyRoute(ticketDir(bridge.node_id), bridge.node_id);
-        if (!bindBridgeNode(current.review_id, bridge.node_id)) {
-            cancelInvisibleBridge(bridge.node_id);
-            current = requireReview(current.review_id);
+/** Finish a committed binding without bridge creation or directory descriptor publication. */
+export async function realizeReview(reviewId) {
+    let request = requireBinding(reviewId);
+    if (request.state !== 'binding')
+        return request;
+    const spec = specification(request);
+    const branchFile = spec['branch_file'];
+    if (typeof branchFile !== 'string' || !existsSync(branchFile)) {
+        if (cancelBindingRequest(request.request_id, new Date().toISOString(), 'branch_lost'))
+            signalReviewActivity();
+        throw new ReviewOperationError('branch_lost', 'review branch was lost before realization', { review_id: request.request_id });
+    }
+    if (request.file === null || request.requester_node_id === null || request.companion_node_id === null) {
+        throw new Error(`binding review has incomplete identity: ${request.request_id}`);
+    }
+    const origin = getNode(request.requester_node_id);
+    if (origin === null)
+        throw new ReviewOperationError('review_origin_missing', 'review origin was not found', { origin_node_id: request.requester_node_id });
+    if (getNode(request.companion_node_id) === null) {
+        const modelSpec = spec['model_spec'];
+        if (typeof modelSpec !== 'string')
+            throw new Error(`binding review has no model spec: ${request.request_id}`);
+        try {
+            await spawnReviewCompanion({
+                nodeId: request.companion_node_id, reviewId: request.request_id, originNodeId: request.requester_node_id,
+                branchFile, targetFile: request.file, modelSpec, cwd: origin.cwd, profileId: origin.profile_id ?? null,
+            });
         }
-        else {
-            current = requireReview(current.review_id);
+        catch (error) {
+            if (!(error instanceof NodeIdConflictError))
+                throw error;
         }
     }
-    if (current.bridge_node_id === null)
-        throw bridgeUnsubscribed(current, '');
-    ensureBridgeSubscription(current, current.bridge_node_id);
-    return current;
-}
-function publishTicket(review) {
-    if (review.bridge_node_id === null)
-        throw bridgeUnsubscribed(review, '');
-    if (review.subtitle === null)
-        throw new Error(`ticket review has no subtitle: ${review.review_id}`);
-    const origin = requireOrigin(review);
-    const profileName = origin.profile_id == null
-        ? undefined
-        : loadProfileManifest(origin.profile_id).manifest.name;
-    submitReview({
-        dir: ticketDir(review.bridge_node_id),
-        review: {
-            file: review.file,
-            ...(review.output_path !== null ? { output: review.output_path } : {}),
-            title: basename(review.file),
-            subtitle: review.subtitle,
-            source: {
-                nodeId: review.origin_node_id,
-                ...(profileName === undefined ? {} : { profileName }),
-            },
-            blockedSince: review.created,
-        },
-    });
-}
-/**
- * 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 async function realizeReview(reviewId) {
-    let review = requireReview(reviewId);
-    if (review.state !== 'binding')
-        return review;
-    if (!existsSync(review.branch_file)) {
-        cancelLostBinding(review);
-        throw new ReviewOperationError('branch_lost', 'review branch was lost before realization', { review_id: review.review_id });
-    }
-    // R1: creation consumes only the persisted coordinates and preallocated id.
-    await spawnCompanion(review);
-    // R2: ticket bridge birth and route assertion precede all public exposure.
-    review = await realizeBridge(requireReview(reviewId));
-    if (review.state !== 'binding')
-        return review;
-    // R3: only realization owns this initial launch/retry.
-    const companion = getNode(review.companion_node_id);
+    const companion = getNode(request.companion_node_id);
     if (companion === null)
-        throw companionUnbound(review.review_id, 0);
-    // Realization is bounded by the bind deadline below, which only a live broker
-    // can meet: refuse at the cap rather than freeze into a certain timeout.
+        throw new ReviewOperationError('review_companion_unbound', 'review companion was not created', { review_id: request.request_id });
     if (companion.pi_session_id === null)
         await reviveNode(companion.node_id, { resume: false, capacity: 'refuse' });
-    // R4: session_start is the durable bind boundary.
-    if (!await awaitCompanionBind(review.companion_node_id, COMPANION_BIND_DEADLINE_MS)) {
-        throw companionUnbound(review.review_id, COMPANION_BIND_DEADLINE_MS);
+    if (!await awaitCompanionBind(request.companion_node_id, COMPANION_BIND_DEADLINE_MS)) {
+        throw new ReviewOperationError('review_companion_unbound', 'review companion did not bind in time', { review_id: request.request_id, waited_ms: COMPANION_BIND_DEADLINE_MS });
     }
-    // R5: SQLite visibility commits before the ticket projection. A missing
-    // projection is deliberately under-exposed and retried by the review lane.
-    if (openReviewRow(review.review_id, new Date().toISOString())) {
+    if (openRequest(request.request_id, new Date().toISOString()))
         signalReviewActivity();
-        if (review.origin_kind === 'ticket')
-            publishTicket(review);
-    }
-    return requireReview(reviewId);
+    request = requireBinding(reviewId);
+    return request;
 }

package/dist/core/review/remap.js

@@ -56,7 +56,7 @@ function appendReanchorEvent(db, args) {
 /** Atomically replace every live review coordinate with ranges expressed against the current source. */
 export function applyRangeBatch(args) {
     const result = withCanvasWrite((db) => {
-        const review = db.prepare('SELECT file, anchor_base_sha256 FROM reviews WHERE review_id = ?').get(args.review_id);
+        const review = db.prepare("SELECT file, anchor_base_sha256 FROM human_requests WHERE request_id = ? AND kind = 'review' AND state = 'open'").get(args.review_id);
         if (review === undefined) {
             throw new ReviewOperationError('unknown_review', 'review was not found', { received: args.review_id });
         }

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

@@ -1,4 +1,5 @@
-import { type NewReviewRow, type ReviewOriginKind, type ReviewRecord } from './types.js';
+import { type HumanRequestRecord } from '../human/requests.js';
+import { type NewReviewRow, type ReviewOriginKind } from './types.js';
 export interface StageReviewArgs {
     origin_kind: ReviewOriginKind;
     origin_node_id: string;
@@ -9,7 +10,7 @@ export interface StageReviewArgs {
 }
 /** A persisted winner needs realization, while a new stage has unreferenced filesystem state to commit or discard. */
 export type StagedReview = {
-    existing: ReviewRecord;
+    existing: HumanRequestRecord;
     row?: never;
     review_dir?: never;
 } | {

package/dist/core/review/stage.js

@@ -6,7 +6,7 @@ import { ensureReviewDir, reviewBranchPath, reviewDir } from '../canvas/paths.js
 import { checkReviewableFile } from '../human/visible-paths.js';
 import { newNodeId } from '../runtime/nodes.js';
 import { captureOrigin, materializeReviewBranch } from './companion.js';
-import { getReviewByIdempotencyKey } from './store.js';
+import { getRequestByIdempotencyKey } from '../human/requests.js';
 import { ReviewOperationError, } from './types.js';
 function targetError(file, reason) {
     return new ReviewOperationError('review_target_unreviewable', 'review target cannot be staged', {
@@ -114,7 +114,7 @@ export function discardStaging(reviewId) {
  * canvas node or review row. The caller alone commits or discards this stage.
  */
 export async function stageReview(args) {
-    const existing = getReviewByIdempotencyKey(args.idempotency_key);
+    const existing = getRequestByIdempotencyKey(args.idempotency_key);
     if (existing !== null)
         return { existing };
     if (getNode(args.origin_node_id) === null) {
@@ -140,7 +140,6 @@ export async function stageReview(args) {
                 idempotency_key: args.idempotency_key,
                 origin_kind: args.origin_kind,
                 origin_node_id: args.origin_node_id,
-                bridge_node_id: null,
                 companion_node_id: companionNodeId,
                 review_dir: reviewDir(reviewId),
                 file,

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

@@ -1,6 +1,5 @@
 import type { DatabaseSync } from 'node:sqlite';
-import { type NewReviewRow, type ReviewRecord, type ReviewState } from './types.js';
-/** Fields written when an open review is conditionally approved. */
+import { type ReviewRecord, type ReviewState } from './types.js';
 export interface ApproveReviewArgs {
     review_id: string;
     approved_at: string;
@@ -10,38 +9,21 @@ export interface ApproveReviewArgs {
     comments_unresolved: number;
     result_json: string;
 }
-export declare function mintReviewId(): string;
-/** Atomically claim the idempotency key, without publishing any non-SQLite state. */
-export declare function commitBindingReview(row: NewReviewRow): {
-    review_id: string;
-    won: boolean;
-};
 export declare function getReview(reviewId: string): ReviewRecord | null;
-/** The review `reviewId` names, for a caller that cannot proceed without one.
- *  A `binding` row is still mid-creation and reads as absent. */
 export declare function requireVisibleReview(reviewId: string): ReviewRecord;
 export declare function getReviewByIdempotencyKey(key: string): ReviewRecord | null;
 export declare function getReviewByCompanion(nodeId: string): ReviewRecord | null;
-export declare function getReviewByBridge(nodeId: string): ReviewRecord | null;
 export declare function listReviews(filter: {
     state?: ReviewState;
     origin_node_id?: string;
     file?: string;
 }): ReviewRecord[];
-/** Review ids whose immutable origin is one of `nodeIds`, including binding
- *  rows that normal user-facing review listings intentionally hide. */
 export declare function reviewIdsByOriginNodes(nodeIds: readonly string[]): string[];
-/** Delete review audit state for the selected origins in dependency order.
- *  Filesystem cleanup is deliberately left to the daemon lifecycle owner. */
 export declare function deleteReviewsByOriginNodes(nodeIds: readonly string[]): string[];
 export declare function listBindingReviews(): ReviewRecord[];
-/** Open reviews the human has already submitted, still waiting on their companion. */
 export declare function listSubmitRequestedReviews(): ReviewRecord[];
 export declare function listUnprojectedTerminalReviews(): ReviewRecord[];
-export declare function bindBridgeNode(reviewId: string, bridgeNodeId: string): boolean;
 export declare function openReviewRow(reviewId: string, openedAt: string): boolean;
-/** Record the human's submit intent on a review that stays open meanwhile.
- *  False when the review already left `open` or already carries an intent. */
 export declare function requestReviewSubmit(reviewId: string, at: string): boolean;
 export declare function approveReviewLocked(db: DatabaseSync, args: ApproveReviewArgs): boolean;
 export declare function cancelReviewRow(reviewId: string, args: {
@@ -51,8 +33,8 @@ export declare function cancelReviewRow(reviewId: string, args: {
 }): boolean;
 export declare function markProjected(reviewId: string, at: string): void;
 export declare function markProjectionError(reviewId: string, error: string): void;
-export declare function markDelivered(reviewId: string, receipt: string | null, at: string): void;
-export declare function markDeliveryError(reviewId: string, error: string): void;
+export declare function markDelivered(_reviewId: string, _receipt: string | null, _at: string): void;
+export declare function markDeliveryError(_reviewId: string, _error: string): void;
 export declare function readAnchorBase(reviewId: string): {
     bytes: Buffer;
     sha256: string;