@north-light/crouter 0.3.180 → 0.3.181

package/dist/daemon/api/handlers/messages.js

@@ -59,6 +59,12 @@ function parseSendBody(body) {
     if (delivery !== undefined && delivery !== 'interactive') {
         throw usage(`invalid delivery: ${String(delivery)} (expected interactive)`);
     }
+    const messageId = b['message_id'];
+    if (messageId !== undefined && typeof messageId !== 'string') {
+        throw usage('message_id must be a string');
+    }
+    if (typeof messageId === 'string' && messageId.trim() !== '')
+        out.message_id = messageId;
     if (delivery === 'interactive') {
         // Interactive delivery is a live-conversation send: a plain immediate body,
         // nothing that only makes sense on the durable path.
@@ -158,7 +164,7 @@ async function handleMessage(ctx) {
     //     straight there (append + revive, watcher delivers post-boot). ---
     if (req.delivery === 'interactive' && isBrokerLive(meta)) {
         try {
-            await deliverLive(id, req.body);
+            await deliverLive(id, req.body, req.message_id);
             const body = {
                 node_id: id,
                 delivered: true,

package/dist/daemon/api/handlers/reviews.js

@@ -172,11 +172,13 @@ async function handleSubmit(ctx) {
     if (violations.length > 0 || reviewId === undefined)
         invalidRequest(violations);
     const finished = await submitReviewApproval(reviewId);
-    const body = {
-        review: toReviewResponseDTO(finished.record),
-        result: toFeedbackResultDTO(finished.result),
-        outcome: finished.outcome,
-    };
+    const body = finished.outcome === 'awaiting_companion'
+        ? { review: toReviewResponseDTO(finished.record), outcome: finished.outcome }
+        : {
+            review: toReviewResponseDTO(finished.record),
+            result: toFeedbackResultDTO(finished.result),
+            outcome: finished.outcome,
+        };
     return { status: 200, body };
 }
 async function handleCancel(ctx) {

package/dist/daemon/api/map.js

@@ -228,6 +228,7 @@ export function toCronDTO(c, lastRun) {
         sink: sinkDisplay(c.sink),
         tier: c.tier,
         state: c.state,
+        held: c.held,
         run_state: c.run_state,
         last_run: lastRun === undefined || lastRun === null
             ? null
@@ -279,6 +280,8 @@ export function toReviewDTO(row, extras = {}) {
     };
     if (row.opened_at !== null)
         dto.opened_at = row.opened_at;
+    if (row.submit_requested_at !== null)
+        dto.submit_requested_at = row.submit_requested_at;
     if (row.approved_at !== null)
         dto.approved_at = row.approved_at;
     if (row.changed !== null)

package/dist/daemon/api/server.js

@@ -27,6 +27,7 @@ import { focusRoutes } from './handlers/focus.js';
 import { healthRoutes } from './handlers/health.js';
 import { humanRoutes } from './handlers/human.js';
 import { inboxRoutes } from './handlers/inbox.js';
+import { memoryRoutes } from './handlers/memory.js';
 import { messageRoutes } from './handlers/messages.js';
 import { modelAuthRoutes } from './handlers/modelauth.js';
 import { nodeRoutes } from './handlers/nodes.js';
@@ -52,6 +53,7 @@ function buildRouter() {
         .registerAll(attachRoutes)
         .registerAll(canvasRoutes)
         .registerAll(fileRoutes)
+        .registerAll(memoryRoutes)
         .registerAll(focusRoutes)
         .registerAll(subscriptionRoutes)
         .registerAll(cronRoutes)

package/dist/daemon/cron-run.js

@@ -95,6 +95,21 @@ const EMPTY_STDOUT_SHA256 = createHash('sha256').update('').digest('hex');
 /** Lead of a `cron_runs.delivered` string written by the overlap=skip pass.
  *  Matched (not just written) — see `latestRunIsSkip`. */
 const SKIP_MARKER = 'skipped (overlap=skip)';
+/** EX_TEMPFAIL — the owed-gate disposition. A scheduled run exiting 75
+ *  declares "this occurrence is owed but not currently eligible": the row is
+ *  PARKED (held=1, occurrence not spent) instead of disposed — no failure, no
+ *  escalation, no delivery, no on-change hash, no one-shot consumption. A poke
+ *  (`POST /v1/crons/poke`) re-dues it now; otherwise a recurring row re-checks
+ *  at its already-advanced natural slot and a held one-shot waits at its
+ *  backstop (`expires_at`, else far future — poke-only). The gate itself stays
+ *  in bash; the daemon only honors the exit code. */
+const EXIT_HELD = 75;
+/** `cron_runs.delivered` string for a held (exit-75) settlement. */
+const HELD_DELIVERED = 'deferred (exit 75) — held for poke';
+/** Backstop `fire_at` for a held one-shot without `--expires`: never due on
+ *  the clock — the row fires only on a poke. Without this, a past-due parked
+ *  one-shot would re-fire every tick forever. */
+const HELD_ONE_SHOT_FAR_FUTURE = '9999-12-31T23:59:59.999Z';
 /** One id per daemon process instance — distinguishes THIS process's own
  *  in-flight run leases from a stale 'running' row a prior (crashed/restarted)
  *  daemon left behind. */
@@ -451,7 +466,9 @@ export function recoverStaleCronLeases(now, options = {}) {
                 stderr_head: ctx.stderrHead,
                 delivered: disposition.delivered,
             });
-            releaseCronRunLease(c.cron_id);
+            // A recovered-timeout settlement took the ordinary disposition path
+            // (pause + escalation unless silent) — the gate is resolved, clear held.
+            releaseCronRunLease(c.cron_id, { kind: 'clear' });
             if (c.recur == null && !disposition.paused)
                 consumeCron(c.cron_id);
         })();
@@ -720,6 +737,16 @@ export function executeCron(c, opts) {
                     return;
                 }
                 const finishedAtMs = Date.now();
+                // The owed-gate branch (exit 75): a peer of the wasReplaced
+                // short-circuit — skip disposition entirely (no delivery, no
+                // escalation, no pause, no on-change hash, no one-shot consumption)
+                // and settle the row's held state with the lease release instead. The
+                // exclusions are deliberate: a manual `cron run` must not change
+                // scheduling state; a timeout-killed or launch-failed run is a real
+                // failure even if a stray 75 surfaces; a replaced or self-canceled
+                // run's existing short-circuits win.
+                const heldDeferred = !outOfBand && !timedOut && processError == null && code === EXIT_HELD && !wasReplaced && !wasSelfCanceled;
+                let heldSettle;
                 let delivered;
                 let paused = false;
                 if (wasReplaced) {
@@ -727,6 +754,38 @@ export function executeCron(c, opts) {
                     // fresh: record it, no disposition, no escalation.
                     delivered = 'replaced (overlap=replace)';
                 }
+                else if (heldDeferred) {
+                    delivered = HELD_DELIVERED;
+                    // Re-read the row: `last_poke_at` must be CURRENT — a poke landing
+                    // while this gate check was in flight is exactly the race this
+                    // check closes. (A row canceled mid-run is gone; recordCronRun and
+                    // the lease release below both no-op.)
+                    const fresh = getCron(c.cron_id);
+                    if (fresh !== null) {
+                        if (fresh.state === 'active' && fresh.last_poke_at !== null && startedAtIso < fresh.last_poke_at) {
+                            // A poke arrived mid-run — its unpark statement deliberately
+                            // skips leased rows — so re-due instead of park: the gate
+                            // re-checks next tick instead of stalling until the backstop
+                            // while the very eligibility it waits for is present. Only for
+                            // a row still ACTIVE: a row paused mid-run parks below instead —
+                            // the poke skips paused rows on purpose while its stamp lands on
+                            // every row, and a re-due would leave a past-due UNHELD row that
+                            // `cron resume` fires blind even though its gate never passed.
+                            heldSettle = { kind: 'redue', nowIso: new Date(finishedAtMs).toISOString() };
+                        }
+                        else if (c.recur != null) {
+                            // Recurring: the pre-run advance already wrote the natural next
+                            // slot, which IS the backstop — park and touch nothing else.
+                            heldSettle = { kind: 'park' };
+                        }
+                        else {
+                            // One-shot: park at its backstop. With --expires, expiry deletes
+                            // the row unfired at that instant (bounded wait); without, the
+                            // far-future fire_at means poke-only.
+                            heldSettle = { kind: 'park', fireAt: fresh.expires_at ?? HELD_ONE_SHOT_FAR_FUTURE };
+                        }
+                    }
+                }
                 else {
                     const disposition = await disposeSettledRun(c, {
                         runId,
@@ -758,7 +817,13 @@ export function executeCron(c, opts) {
                     delivered,
                 };
                 recordCronRun(record);
-                if (!outOfBand && c.recur == null && !paused) {
+                if (heldDeferred) {
+                    // Held: the occurrence is NOT spent — even a one-shot is retained
+                    // (like a paused escalated one-shot is). Park/re-due and the lease
+                    // release are one write.
+                    releaseCronRunLease(c.cron_id, heldSettle);
+                }
+                else if (!outOfBand && c.recur == null && !paused) {
                     // One-shot: the run is done, delete the row (its history cascades
                     // with it — matching one-shot consumption). A failing
                     // one-shot that PAUSED for escalation is kept, so `cron resume` can
@@ -767,7 +832,10 @@ export function executeCron(c, opts) {
                     consumeCron(c.cron_id);
                 }
                 else {
-                    releaseCronRunLease(c.cron_id);
+                    // An ordinary scheduled disposition settlement resolves the gate,
+                    // so it unparks a held row; a replaced or out-of-band run leaves
+                    // `held` untouched (the gate is still unresolved).
+                    releaseCronRunLease(c.cron_id, wasReplaced || outOfBand ? undefined : { kind: 'clear' });
                 }
                 resolve(record);
             })().catch(reject);

package/dist/daemon/crtrd.js

@@ -57,6 +57,7 @@ import { DEFAULT_INTERVAL_MS } from './supervise-cadence.js';
 import { BrokerSupervisionReconciler } from './reconcilers/broker-supervision.js';
 import { ControllerDeathReconciler, DormantInboxReconciler } from './reconcilers/dormant-inbox.js';
 import { CronLaneReconciler } from './reconcilers/cron-lane.js';
+import { PendingReviewSubmitReconciler } from './reconcilers/pending-review-submit.js';
 import { StorageMaintenanceReconciler } from './reconcilers/storage-maintenance.js';
 import { captureLivenessSnapshot, capturePidCommand, captureTeardownSnapshot, isPidAlive, killProcessTreePids, } from '../core/canvas/pid.js';
 import { bindFleet, boundFleet } from '../core/runtime/fleet.js';
@@ -311,6 +312,7 @@ const brokerSupervision = new BrokerSupervisionReconciler();
 const controllerDeath = new ControllerDeathReconciler();
 const dormantInbox = new DormantInboxReconciler();
 const cronLane = new CronLaneReconciler();
+const pendingReviewSubmit = new PendingReviewSubmitReconciler();
 const storageMaintenance = new StorageMaintenanceReconciler();
 /** Supervision tick over the daemon's current live set. */
 export async function superviseTick(now = Date.now(), lifecycle = directTickLifecycle) {
@@ -334,6 +336,7 @@ export async function superviseTick(now = Date.now(), lifecycle = directTickLife
     controllerDeath.run(now, { rows });
     dormantInbox.run(now, { rows, fleet, hasBrokerCapacity });
     cronLane.run(now, { lifecycle, hasBrokerCapacity });
+    pendingReviewSubmit.run({ lifecycle });
     storageMaintenance.run(now);
 }
 /** Start the supervisor loop after winning the authoritative canvas claim.

package/dist/daemon/reconcilers/pending-review-submit.d.ts

@@ -0,0 +1,7 @@
+import type { DetachedWorkLifecycle } from './broker-supervision.js';
+export interface PendingReviewSubmitContext {
+    lifecycle: DetachedWorkLifecycle;
+}
+export declare class PendingReviewSubmitReconciler {
+    run(ctx: PendingReviewSubmitContext): void;
+}

package/dist/daemon/reconcilers/pending-review-submit.js

@@ -0,0 +1,35 @@
+// The safety net under a deferred review submit.
+//
+// The companion's turn end is what normally completes a submit the human left
+// waiting (`daemon/api/handlers/broker-ops.ts`). A companion that crashed, was
+// torn down, or ended its turn while this daemon was starting never delivers
+// that settlement, so this pass completes any review whose companion is no
+// longer working. Without it a review could wait forever on a turn end that is
+// never coming.
+import { emitEvent } from '../../core/events/emit.js';
+import { operationIdContext } from '../../core/events/operation-id.js';
+import { listSubmitRequestedReviews } from '../../core/review/store.js';
+import { completeRequestedSubmit } from '../review/finish.js';
+export class PendingReviewSubmitReconciler {
+    run(ctx) {
+        if (!ctx.lifecycle.acceptsDetachedWork())
+            return;
+        let pending;
+        try {
+            pending = listSubmitRequestedReviews();
+        }
+        catch (error) {
+            operationIdContext.fresh(() => {
+                emitEvent({ level: 'error', event: 'review.deferred_submit.scan_failed', error });
+            });
+            return;
+        }
+        for (const review of pending) {
+            ctx.lifecycle.registerDetached(completeRequestedSubmit(review.review_id, { atCompanionTurnEnd: false }).then(() => { }, (error) => {
+                operationIdContext.fresh(() => {
+                    emitEvent({ level: 'error', event: 'review.deferred_submit.failed', error });
+                });
+            }));
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+/** Is the companion inside a turn right now? */
+export declare function companionMidTurn(nodeId: string): boolean;
+/** Does the companion hold work it has not yet consumed? A deferred entry is
+ *  excluded for the same reason the settlement policy excludes it: it never
+ *  starts a turn of its own. */
+export declare function companionHasQueuedWork(nodeId: string): boolean;
+/** Would submitting right now step on the companion's work? */
+export declare function companionStillWorking(nodeId: string): boolean;

package/dist/daemon/review/companion.js

@@ -0,0 +1,35 @@
+// Is a review companion still working? This is what a deferred submit waits on.
+//
+// Two facts, both already maintained by the runtime, and neither one enough
+// alone:
+//
+//  - MID-TURN — the `<jobDir>/busy` marker AND-ed with a live broker pid, the
+//    canonical "pi is inside a turn" signal (`core/runtime/busy.ts`). A stale
+//    marker from a crashed broker reads false through the AND.
+//  - QUEUED — an undelivered non-deferred inbox entry. Comments are pushed to
+//    the companion as inbox messages, so the ordinary rhythm is: the human
+//    comments, the entry lands, the companion's turn starts a moment later.
+//    Between those two moments the busy marker is cold while the companion is
+//    unmistakably about to work, and submitting into that gap kills the edit
+//    the wait exists to protect.
+import { getNode } from '../../core/canvas/canvas.js';
+import { isPidAlive } from '../../core/canvas/pid.js';
+import { readCursor, readInboxSince } from '../../core/feed/inbox.js';
+import { isBusy } from '../../core/runtime/busy.js';
+/** Is the companion inside a turn right now? */
+export function companionMidTurn(nodeId) {
+    const node = getNode(nodeId);
+    if (node === null || !isPidAlive(node.pi_pid))
+        return false;
+    return isBusy(nodeId);
+}
+/** Does the companion hold work it has not yet consumed? A deferred entry is
+ *  excluded for the same reason the settlement policy excludes it: it never
+ *  starts a turn of its own. */
+export function companionHasQueuedWork(nodeId) {
+    return readInboxSince(nodeId, readCursor(nodeId)).some((entry) => entry.tier !== 'deferred');
+}
+/** Would submitting right now step on the companion's work? */
+export function companionStillWorking(nodeId) {
+    return companionMidTurn(nodeId) || companionHasQueuedWork(nodeId);
+}

package/dist/daemon/review/deliver.js

@@ -1,4 +1,5 @@
 import { FinalizationError, pushFinal, redeliverFinalReport } from '../../core/feed/feed.js';
+import { formatReviewApproval } from '../../shared/generated-context.js';
 import { deliverNodeMessage } from '../messaging/node-message.js';
 function approvalBody(review, resultPath) {
     const summary = review.changed
@@ -8,7 +9,7 @@ function approvalBody(review, resultPath) {
 }
 /** Render the immutable approval fact without replaying comment text. */
 export function renderApprovalMessage(review, resultPath) {
-    return approvalBody(review, resultPath);
+    return formatReviewApproval(approvalBody(review, resultPath));
 }
 function recordedFailedFanout(review, reportBasename) {
     const error = review.delivery_error;

package/dist/daemon/review/finish.d.ts

@@ -5,6 +5,13 @@ export interface ReviewApprovalFinishOutcome {
     record: ReviewRecord;
     result: ReviewResult;
 }
+/** The human submitted while the companion was still working. The review stays
+ *  open and the daemon completes the approval once the companion goes quiet. */
+export interface ReviewSubmitDeferredOutcome {
+    outcome: 'awaiting_companion';
+    record: ReviewRecord;
+}
+export type ReviewSubmitOutcome = ReviewApprovalFinishOutcome | ReviewSubmitDeferredOutcome;
 export interface ReviewCancellationFinishOutcome {
     outcome: 'settled' | 'already_settled';
     record: ReviewRecord;
@@ -13,8 +20,28 @@ export interface ReviewCancellationFinishOutcome {
 export type ReviewFinishOutcome = ReviewApprovalFinishOutcome | ReviewCancellationFinishOutcome;
 /** Retire a companion only through a lifecycle transition legal for its current status. */
 export declare function retireCompanion(nodeId: string, outcome: 'approved' | 'canceled'): 'retired' | 'already' | 'missing';
-/** Commit approval once, then independently finish its projection, delivery, and companion retirement ledgers. */
-export declare function submitReviewApproval(reviewId: string): Promise<ReviewApprovalFinishOutcome>;
+/** Approve on the human's behalf, waiting first when the companion is still
+ *  working. Waiting is the only new outcome: an idle companion approves in the
+ *  same pass it always did, and the wait never freezes the review — comments
+ *  added during it are in the snapshot, because the snapshot happens at
+ *  completion and the review is still open. */
+export declare function submitReviewApproval(reviewId: string): Promise<ReviewSubmitOutcome>;
+/** Complete a submit the human already pressed, once its companion is quiet.
+ *  Returns null when there is nothing to complete — no pending intent, the
+ *  review moved on, or the companion is still working. Idempotent: concurrent
+ *  callers race on the same conditional `state = 'open'` approval write, so
+ *  only one can win and the loser reports what the winner committed.
+ *
+ *  `atCompanionTurnEnd` marks the one caller that IS the companion's turn end.
+ *  There the mid-turn marker may not be cleared yet, so it is not consulted;
+ *  queued work still defers, because an inbox entry means another turn is
+ *  coming and the wait should outlast it. */
+export declare function completeRequestedSubmit(reviewId: string, opts: {
+    atCompanionTurnEnd: boolean;
+}): Promise<ReviewApprovalFinishOutcome | null>;
+/** The companion's turn ended: complete any submit the human left waiting on
+ *  it. Never throws — a settlement directive must not depend on delivery. */
+export declare function completeCompanionRequestedSubmit(companionNodeId: string): Promise<void>;
 /** Cancel an open review once; ticket cancellation remains owned by the retained human-ticket finisher. */
 export declare function cancelReview(reviewId: string, args: {
     reason?: string;

package/dist/daemon/review/finish.js

@@ -8,11 +8,14 @@ import { reviewResultPath } from '../../core/canvas/paths.js';
 import { snapshotCommentsLocked } from '../../core/review/comments.js';
 import { readReviewSource } from '../../core/review/document.js';
 import { signalReviewActivity } from '../../core/review/signal.js';
-import { approveReviewLocked, cancelReviewRow, markDelivered, markDeliveryError, markProjected, markProjectionError, requireVisibleReview, } from '../../core/review/store.js';
+import { approveReviewLocked, cancelReviewRow, getReview, getReviewByCompanion, markDelivered, markDeliveryError, markProjected, markProjectionError, requestReviewSubmit, requireVisibleReview, } from '../../core/review/store.js';
 import { ReviewOperationError } from '../../core/review/types.js';
 import { transition } from '../../core/runtime/lifecycle.js';
 import { headlessBrokerHost } from '../../core/runtime/host.js';
+import { emitEvent } from '../../core/events/emit.js';
+import { deliverNodeMessage } from '../messaging/node-message.js';
 import { cancelHumanTicket, deliverTerminalResult } from '../human/finish.js';
+import { companionHasQueuedWork, companionMidTurn, companionStillWorking } from './companion.js';
 import { deliverApproval } from './deliver.js';
 /** One daemon serializes terminal side effects for each immutable review row. */
 const finishChains = new Map();
@@ -178,9 +181,46 @@ async function finishCanceled(review, winningWrite, args) {
     retireCompanion(current.companion_node_id, 'canceled');
     return { record: requireVisibleReview(review.review_id), ...(canceledTicket === undefined ? {} : { ticket_result: canceledTicket }) };
 }
-/** Commit approval once, then independently finish its projection, delivery, and companion retirement ledgers. */
+/** Tell the origin its review was submitted but is finishing behind the
+ *  companion. Deliberately deferred: the origin is told nothing is needed of
+ *  it, so waking it to say so would be noise. The approval itself wakes it. */
+async function noteSubmitQueued(review) {
+    try {
+        await deliverNodeMessage({
+            node_id: review.origin_node_id,
+            from: 'crtrd',
+            mode: 'quiet',
+            label: 'human review submitted — result to follow',
+            data: { review_id: review.review_id },
+            body: `The human submitted their review of \`${review.file}\`; the document is still being edited. `
+                + "You'll be notified with the result once the review completes. Nothing is needed from you now.",
+        });
+    }
+    catch (error) {
+        emitEvent({ level: 'warn', event: 'review.submit_queued_note.failed', error });
+    }
+}
+/** Approve on the human's behalf, waiting first when the companion is still
+ *  working. Waiting is the only new outcome: an idle companion approves in the
+ *  same pass it always did, and the wait never freezes the review — comments
+ *  added during it are in the snapshot, because the snapshot happens at
+ *  completion and the review is still open. */
 export async function submitReviewApproval(reviewId) {
     const initial = requireVisibleReview(reviewId);
+    if (initial.state === 'canceled')
+        return terminalConflict(initial, 'submit');
+    if (initial.state === 'open' && companionStillWorking(initial.companion_node_id)) {
+        if (requestReviewSubmit(reviewId, now())) {
+            signalReviewActivity();
+            await noteSubmitQueued(initial);
+        }
+        return { outcome: 'awaiting_companion', record: requireVisibleReview(reviewId) };
+    }
+    return await approveReview(initial);
+}
+/** Commit approval once, then independently finish its projection, delivery, and companion retirement ledgers. */
+async function approveReview(initial) {
+    const reviewId = initial.review_id;
     if (initial.state === 'canceled')
         return terminalConflict(initial, 'submit');
     if (initial.state === 'approved') {
@@ -219,6 +259,39 @@ export async function submitReviewApproval(reviewId) {
     const record = await serializedFinish(reviewId, () => finishApproved(committed.review, committed.result));
     return { outcome: committed.outcome, record, result: committed.result };
 }
+/** Complete a submit the human already pressed, once its companion is quiet.
+ *  Returns null when there is nothing to complete — no pending intent, the
+ *  review moved on, or the companion is still working. Idempotent: concurrent
+ *  callers race on the same conditional `state = 'open'` approval write, so
+ *  only one can win and the loser reports what the winner committed.
+ *
+ *  `atCompanionTurnEnd` marks the one caller that IS the companion's turn end.
+ *  There the mid-turn marker may not be cleared yet, so it is not consulted;
+ *  queued work still defers, because an inbox entry means another turn is
+ *  coming and the wait should outlast it. */
+export async function completeRequestedSubmit(reviewId, opts) {
+    const review = getReview(reviewId);
+    if (review === null || review.state !== 'open' || review.submit_requested_at === null)
+        return null;
+    if (companionHasQueuedWork(review.companion_node_id))
+        return null;
+    if (!opts.atCompanionTurnEnd && companionMidTurn(review.companion_node_id))
+        return null;
+    return await approveReview(review);
+}
+/** The companion's turn ended: complete any submit the human left waiting on
+ *  it. Never throws — a settlement directive must not depend on delivery. */
+export async function completeCompanionRequestedSubmit(companionNodeId) {
+    try {
+        const review = getReviewByCompanion(companionNodeId);
+        if (review === null || review.state !== 'open' || review.submit_requested_at === null)
+            return;
+        await completeRequestedSubmit(review.review_id, { atCompanionTurnEnd: true });
+    }
+    catch (error) {
+        emitEvent({ level: 'error', event: 'review.deferred_submit.failed', error });
+    }
+}
 /** Cancel an open review once; ticket cancellation remains owned by the retained human-ticket finisher. */
 export async function cancelReview(reviewId, args) {
     const initial = requireVisibleReview(reviewId);

package/dist/shared/generated-context.d.ts

@@ -20,6 +20,8 @@ export declare const CONNECTION_FAULT_RECOVERY_BODY = "The network connection is
 export declare const PROVIDER_FAULT_RECOVERY_BODY = "Your previous turn stopped on a provider fault. Continue from where you left off and retry the work that failed.";
 /** Mark an active persona transition without changing the guidance inside it. */
 export declare function formatPersonaTransition(guidance: string): string;
+/** Mark a daemon-delivered review approval for compact viewer presentation. */
+export declare function formatReviewApproval(body: string): string;
 /** Format the stop guard's dynamic structured-output mandate. */
 export declare function formatStructuredOutputReprompt(schema: string): string;
 export type ModelFallbackRecoveryReason = 'credential' | 'not-found';
@@ -31,15 +33,12 @@ export interface GeneratedContextMessageLike {
     content?: unknown;
 }
 export interface GeneratedContextPresentation {
-    kind: 'bearings' | 'situational' | 'revive' | 'context-nudge' | 'inbox' | 'persona-transition' | 'stop-guard' | 'recovery';
+    kind: 'bearings' | 'situational' | 'revive' | 'context-nudge' | 'inbox' | 'review-approval' | 'persona-transition' | 'stop-guard' | 'recovery';
     label: string;
     summary: string;
     /** The unmodified, model-visible message content. */
     body: string;
 }
-/** The display-only disclosure body for a generated context card. The full
- * message remains in `body` for the model and transcript bookkeeping; the two
- * prompt-sized cards expose the one piece a person needs to inspect. */
 export declare function generatedContextExpandedBody(presentation: GeneratedContextPresentation): string;
 /** Plain text from a generated message's string or text-block content. */
 export declare function generatedContextText(message: GeneratedContextMessageLike): string;

package/dist/shared/generated-context.js

@@ -31,6 +31,8 @@ export const CONNECTION_FAULT_RECOVERY_BODY = 'The network connection is back on
 export const PROVIDER_FAULT_RECOVERY_BODY = 'Your previous turn stopped on a provider fault. Continue from where you left off and retry the work that failed.';
 const PERSONA_TRANSITION_OPEN = '<persona-transition>';
 const PERSONA_TRANSITION_CLOSE = '</persona-transition>';
+const REVIEW_APPROVAL_OPEN = '<crtr-review-approval>';
+const REVIEW_APPROVAL_CLOSE = '</crtr-review-approval>';
 const MODEL_FALLBACK_RECOVERY_OPEN = '<model-fallback-recovery>';
 const MODEL_FALLBACK_RECOVERY_CLOSE = '</model-fallback-recovery>';
 const STRUCTURED_OUTPUT_REPROMPT_PREFIX = 'You must call the `submit` tool with a result matching the required schema before you can stop. You cannot finish or go dormant any other way while this request is pending.\n\nRequired schema:\n\n```json\n';
@@ -39,6 +41,10 @@ const STRUCTURED_OUTPUT_REPROMPT_SUFFIX = '\n```';
 export function formatPersonaTransition(guidance) {
     return `${PERSONA_TRANSITION_OPEN}\n${guidance}\n${PERSONA_TRANSITION_CLOSE}`;
 }
+/** Mark a daemon-delivered review approval for compact viewer presentation. */
+export function formatReviewApproval(body) {
+    return `${REVIEW_APPROVAL_OPEN}\n${body}\n${REVIEW_APPROVAL_CLOSE}`;
+}
 /** Format the stop guard's dynamic structured-output mandate. */
 export function formatStructuredOutputReprompt(schema) {
     return `${STRUCTURED_OUTPUT_REPROMPT_PREFIX}${schema}${STRUCTURED_OUTPUT_REPROMPT_SUFFIX}`;
@@ -55,14 +61,18 @@ const YIELD_MESSAGE_BLOCK = /<yield-message>([\s\S]*?)<\/yield-message>/;
 /** The display-only disclosure body for a generated context card. The full
  * message remains in `body` for the model and transcript bookkeeping; the two
  * prompt-sized cards expose the one piece a person needs to inspect. */
+function unmarkReviewApprovals(body) {
+    return body.replaceAll(`${REVIEW_APPROVAL_OPEN}\n`, '').replaceAll(`\n${REVIEW_APPROVAL_CLOSE}`, '');
+}
 export function generatedContextExpandedBody(presentation) {
+    let body = presentation.body;
     if (presentation.label === 'crtr context') {
-        return AUTO_LOADED_CONTEXT_BLOCK.exec(presentation.body)?.[1]?.trim() ?? '';
+        body = AUTO_LOADED_CONTEXT_BLOCK.exec(body)?.[1]?.trim() ?? '';
     }
-    if (presentation.kind === 'revive') {
-        return YIELD_MESSAGE_BLOCK.exec(presentation.body)?.[1]?.trim() ?? '';
+    else if (presentation.kind === 'revive') {
+        body = YIELD_MESSAGE_BLOCK.exec(body)?.[1]?.trim() ?? '';
     }
-    return presentation.body;
+    return unmarkReviewApprovals(body);
 }
 /** Plain text from a generated message's string or text-block content. */
 export function generatedContextText(message) {
@@ -88,7 +98,9 @@ function nudgeSummary(body) {
 }
 // Stable header emitted by core/feed/inbox.ts coalesce(). Human-authored inbox
 // messages are deliberately delivered verbatim and never carry this header.
-const INBOX_HEADER_RE = /^From ([a-z0-9]+(?:-[a-z0-9]+)+|system|human) — (\d+) update/m;
+// Senders are node ids, the two reserved words, or the daemon itself (crtrd —
+// review notes and other daemon-originated node messages).
+const INBOX_HEADER_RE = /^From ([a-z0-9]+(?:-[a-z0-9]+)+|system|human|crtrd) — (\d+) update/m;
 export function isInboxDigest(text) {
     return INBOX_HEADER_RE.test(text);
 }
@@ -96,7 +108,7 @@ export function extractInboxSender(text) {
     return INBOX_HEADER_RE.exec(text)?.[1] ?? null;
 }
 function inboxSummary(body) {
-    const headers = [...body.matchAll(/^From ([a-z0-9]+(?:-[a-z0-9]+)+|system|human) — (\d+) update/gm)];
+    const headers = [...body.matchAll(/^From ([a-z0-9]+(?:-[a-z0-9]+)+|system|human|crtrd) — (\d+) update/gm)];
     if (headers.length === 0)
         return 'node update';
     const updates = headers.reduce((total, match) => total + Number(match[2] ?? 0), 0);
@@ -109,6 +121,9 @@ function inboxSummary(body) {
 function isPersonaTransition(body) {
     return body.startsWith(`${PERSONA_TRANSITION_OPEN}\n`) && body.endsWith(`\n${PERSONA_TRANSITION_CLOSE}`);
 }
+function isReviewApproval(body) {
+    return body.startsWith(`${REVIEW_APPROVAL_OPEN}\n`) && body.endsWith(`\n${REVIEW_APPROVAL_CLOSE}`);
+}
 function isStructuredOutputReprompt(body) {
     if (!body.startsWith(STRUCTURED_OUTPUT_REPROMPT_PREFIX) || !body.endsWith(STRUCTURED_OUTPUT_REPROMPT_SUFFIX)) {
         return false;
@@ -189,6 +204,9 @@ export function generatedContextPresentation(message) {
     if (isInboxDigest(body)) {
         return { kind: 'inbox', label: 'crtr inbox', summary: inboxSummary(body), body };
     }
+    if (isReviewApproval(body)) {
+        return { kind: 'review-approval', label: 'crtr review', summary: 'human review approved', body };
+    }
     if (isPersonaTransition(body)) {
         return {
             kind: 'persona-transition',

package/dist/types.d.ts

@@ -263,7 +263,6 @@ export interface ScopeState {
         last_updated?: string;
     }>;
     last_self_check?: string;
-    bootstrap_done?: boolean;
     /** The name of the remote canvas target `crtr canvas use` last selected
      *  (see `RemoteCanvasConfig`), or `null`/omitted for local. Read by
      *  `resolveCanvasSource` (`core/canvas/source.ts`) as the durable fallback

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.180",
+  "version": "0.3.181",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.180",
+  "version": "0.3.181",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.180",
+      "version": "0.3.181",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {