@north-light/crouter 0.3.173 → 0.3.175

package/dist/pi-extensions/canvas-inbox-watcher.js

@@ -5,8 +5,8 @@
 // return is only a handoff. Exact cursor persistence at agent_settled is the
 // durable boundary; an uncommitted process exit is recovered by rereading from
 // the unchanged cursor.
-import { coalesce, readCanceledEntryIds, readCursor, readInboxRange, readInboxSince, writeCursor, } from '../core/feed/inbox.js';
-import { getNode } from '../core/canvas/index.js';
+import { coalesceBrokerInbox, readBrokerCanceledEntryIds, readBrokerCursor, readBrokerInboxSince, } from '../core/runtime/broker/inbox.js';
+import { advanceBrokerInboxCursor, brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
 import { emitEvent } from '../core/events/emit.js';
 import { errorClassFromError } from '../core/events/errors.js';
 import { operationIdContext } from '../core/events/operation-id.js';
@@ -14,8 +14,6 @@ import { readSituationalContext, SITUATIONAL_CONTEXT_CUSTOM_TYPE } from '../core
 const DEFAULT_TICK_MS = 800;
 const DEFAULT_DEBOUNCE_MS = 1000;
 const MAX_PENDING_HANDOFFS = 64;
-const REPLAY_RESERVED_HANDOFFS = 2;
-const MAX_ORDINARY_HANDOFFS = MAX_PENDING_HANDOFFS - REPLAY_RESERVED_HANDOFFS;
 const MAX_SOURCE_OPERATION_IDS = 16;
 let currentWatcher;
 let nextGeneration = 0;
@@ -181,12 +179,13 @@ class CanvasInboxWatcher {
     buffer = [];
     lastArrival = 0;
     pendingHandoffs = [];
-    replay;
+    pendingCommit;
     seeded = false;
     disposed = false;
     disposalReason;
     fatalError;
     fatalEscaped = false;
+    reportNodes = new Map();
     constructor(pi, cadence, generation) {
         this.pi = pi;
         this.cadence = cadence;
@@ -212,6 +211,7 @@ class CanvasInboxWatcher {
                 return;
             this.captureCtx(event, ctx);
             this.arm();
+            void this.refreshReportNodes(currentNodeId());
         });
         this.pi.on('turn_end', capture);
         this.pi.on('agent_start', (event, ctx) => {
@@ -227,7 +227,7 @@ class CanvasInboxWatcher {
             this.streaming = false;
             // agent_end can precede retry, compaction, or queued continuation.
         });
-        this.pi.on('agent_settled', (event, ctx) => {
+        this.pi.on('agent_settled', async (event, ctx) => {
             if (!this.canMutate())
                 return;
             this.captureCtx(event, ctx);
@@ -236,22 +236,19 @@ class CanvasInboxWatcher {
                 return;
             try {
                 this.assertNodeOwnership(nodeId, 'settle');
-                const refreshHeld = this.readRefreshIntentOrFatal(nodeId, 'settle');
-                if (refreshHeld) {
-                    this.dispose('refresh', true, ctx);
-                }
-                else {
-                    // agent_settled is the authoritative durable boundary: pi guarantees
-                    // every queued continuation has drained, so hasPendingMessages() must
-                    // not veto the commit here.
-                    this.settle(nodeId, ctx, false, false);
-                }
+                // agent_settled is the authoritative durable boundary: Pi guarantees
+                // every queued continuation has drained, so hasPendingMessages() must
+                // not veto the commit here. Await crtrd before changing the in-memory
+                // durable cursor; a failed commit remains replayable after process exit.
+                const result = await this.settle(nodeId, ctx, false);
+                if (result === 'refresh_held')
+                    this.dispose('refresh', false);
             }
             catch (error) {
                 this.dispose('shutdown', false, undefined, { error, stage: 'settle' });
             }
         });
-        this.pi.on('session_shutdown', (event) => {
+        this.pi.on('session_shutdown', async (event) => {
             if (!this.canMutate())
                 return;
             let runtimeReason;
@@ -273,12 +270,10 @@ class CanvasInboxWatcher {
                 });
             }
             try {
-                const nodeId = currentNodeId();
-                const refreshHeld = nodeId !== undefined && this.readRefreshIntentOrFatal(nodeId, 'settle');
                 // This is the graceful fallback when no agent_settled fired before exit.
-                // It holds both an unconsumed queued handoff and every handoff made to a
-                // conversation being discarded by refresh.
-                this.dispose(reason, true, this.lastCtx, undefined, refreshHeld);
+                // crtrd rejects a cursor commit for a refresh, preserving every handoff
+                // that may have reached this discarded conversation for the next broker.
+                await this.disposeAtSettlement(reason, this.lastCtx);
             }
             catch (error) {
                 this.dispose(reason, false, undefined, { error, stage: 'settle' });
@@ -290,6 +285,19 @@ class CanvasInboxWatcher {
      *  or any other re-emission all land here). Called only from the
      *  `session_start` handler above, so it never runs before Pi's action
      *  methods are bound. */
+    async refreshReportNodes(nodeId) {
+        if (nodeId === undefined)
+            return;
+        try {
+            const state = await brokerExtensionState(nodeId);
+            if (!this.canMutate())
+                return;
+            this.reportNodes = new Map(state.report_nodes.map((node) => [node.node_id, node]));
+        }
+        catch {
+            // Report bodies remain canonical pointers until the daemon projection is available.
+        }
+    }
     arm() {
         if (this.armed)
             return;
@@ -301,31 +309,41 @@ class CanvasInboxWatcher {
         // the normal debounce owns delivery instead of waiting a full tick.
         this.runTick('schedule');
     }
-    dispose(reason, atSettleBoundary, settleCtx, fatalDisposal, refreshHeld = reason === 'refresh') {
-        if (this.disposed)
+    /** Settle the graceful-shutdown fallback before disposing its retry state.
+     * The daemon decides whether a refresh preserves the cursor, and this method
+     * awaits that decision so a process exit never outruns an accepted commit. */
+    async disposeAtSettlement(reason, ctx) {
+        const nodeId = currentNodeId();
+        if (nodeId === undefined) {
+            this.dispose(reason, false);
             return;
-        this.disposed = true;
-        this.disposalReason = reason;
-        this.clearTimer();
-        let fatal = fatalDisposal;
+        }
         try {
-            if (atSettleBoundary) {
-                const nodeId = currentNodeId();
-                if (nodeId !== undefined) {
-                    this.assertNodeOwnership(nodeId, 'settle');
-                    this.settle(nodeId, settleCtx, refreshHeld, reason !== 'refresh');
-                }
-            }
+            this.assertNodeOwnership(nodeId, 'settle');
+            const result = await this.settle(nodeId, ctx, reason !== 'refresh');
+            this.dispose(result === 'refresh_held' ? 'refresh' : reason, false);
         }
         catch (error) {
-            fatal = { error, stage: 'settle' };
+            this.dispose(reason, false, undefined, { error, stage: 'settle' });
         }
-        finally {
-            const abandoned = this.pendingHandoffs.splice(0);
+    }
+    dispose(reason, _atSettleBoundary, _settleCtx, fatalDisposal) {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.disposalReason = reason;
+        this.clearTimer();
+        const fatal = fatalDisposal;
+        {
+            const abandoned = [
+                ...(this.pendingCommit?.handoffs ?? []),
+                ...this.pendingHandoffs.splice(0),
+            ];
             this.buffer.length = 0;
             this.cursor = undefined;
             this.durableCursor = undefined;
-            this.replay = undefined;
+            this.reportNodes.clear();
+            this.pendingCommit = undefined;
             this.nodeId = undefined;
             this.lastCtx = undefined;
             this.lastArrival = 0;
@@ -367,14 +385,6 @@ class CanvasInboxWatcher {
         }
         return !this.streaming;
     }
-    readRefreshIntentOrFatal(nodeId, stage) {
-        try {
-            return getNode(nodeId)?.intent === 'refresh';
-        }
-        catch (error) {
-            this.raiseReadFatal(stage, error);
-        }
-    }
     assertNodeOwnership(nodeId, stage) {
         if (!this.seeded || this.nodeId === undefined || this.nodeId === nodeId)
             return;
@@ -398,12 +408,6 @@ class CanvasInboxWatcher {
     raiseReadFatal(stage, error) {
         return this.raiseFatal('inbox.read.failed', `inbox ${stage} state is corrupt`, error, { stage });
     }
-    raiseReplayFatal(gate, error) {
-        return this.raiseFatal('inbox.replay.load_failed', 'inbox replay range could not be loaded', error, {
-            after_entry_id: gate.afterEntryId ?? null,
-            through_entry_id: gate.throughEntryId,
-        });
-    }
     raiseSituationalFatal(markerEntryId, error) {
         return this.raiseFatal('inbox.situational_context.missing', 'situational context marker has no readable sidecar', error, {
             entry_id: markerEntryId,
@@ -471,7 +475,7 @@ class CanvasInboxWatcher {
         this.assertNodeOwnership(nodeId, 'poll');
         if (this.seeded)
             return true;
-        const initial = this.pollRead(() => readCursor(nodeId));
+        const initial = this.pollRead(() => readBrokerCursor(nodeId));
         if (!initial.ok)
             return false;
         this.nodeId = nodeId;
@@ -484,25 +488,21 @@ class CanvasInboxWatcher {
         const nodeId = currentNodeId();
         if (nodeId === undefined || !this.seed(nodeId))
             return;
-        if ((this.replay !== undefined || this.buffer.length > 0) && this.readRefreshIntentOrFatal(nodeId, 'poll'))
-            return;
-        if (this.replay !== undefined) {
-            this.processReplay(nodeId);
+        if (this.pendingCommit !== undefined) {
+            this.retryPendingCommitOnTick(nodeId);
             return;
         }
-        if (this.buffer.length === 0 && this.pendingHandoffs.length >= MAX_ORDINARY_HANDOFFS)
+        if (this.buffer.length === 0 && this.pendingHandoffs.length >= MAX_PENDING_HANDOFFS)
             return;
         if (this.buffer.length > 0) {
             const plan = this.ordinaryPlan();
-            if (plan.sendCount > 0 && this.pendingHandoffs.length + plan.sendCount > MAX_ORDINARY_HANDOFFS)
+            if (plan.sendCount > 0 && this.pendingHandoffs.length + plan.sendCount > MAX_PENDING_HANDOFFS)
                 return;
         }
-        const read = this.pollRead(() => readInboxSince(nodeId, this.cursor));
+        const read = this.pollRead(() => readBrokerInboxSince(nodeId, this.cursor));
         if (!read.ok)
             return;
         const newEntries = read.value;
-        if ((newEntries.length > 0 || this.buffer.length > 0) && this.readRefreshIntentOrFatal(nodeId, 'poll'))
-            return;
         if (newEntries.length > 0) {
             this.cursor = newEntries.at(-1).entry_id;
             this.buffer.push(...newEntries);
@@ -516,11 +516,10 @@ class CanvasInboxWatcher {
         // Interrupt-canceled entries (a human Esc racing a not-yet-injected send —
         // `POST /v1/nodes/{id}/interrupt`) are excluded from BOTH channels. Read
         // fresh each plan build: the cancel can land AFTER the entry was buffered.
-        // Filtering here keeps buildPlan and replayCoverageComplete in agreement,
-        // so a fully-canceled replay range still completes. Skipped entries are
-        // never handed off; the durable cursor covers them positionally when a
-        // later entry settles (or they are simply re-filtered after a restart).
-        const canceled = this.nodeId === undefined ? undefined : readCanceledEntryIds(this.nodeId);
+        // Skipped entries are never handed off; the durable cursor covers them
+        // positionally when a later entry settles (or they are re-filtered after a
+        // restart).
+        const canceled = this.nodeId === undefined ? undefined : readBrokerCanceledEntryIds(this.nodeId);
         const live = canceled === undefined || canceled.size === 0
             ? entries
             : entries.filter((entry) => !canceled.has(entry.entry_id));
@@ -580,7 +579,7 @@ class CanvasInboxWatcher {
     }
     digest(entries, stage) {
         try {
-            return coalesce([...entries]);
+            return coalesceBrokerInbox(entries, this.reportNodes);
         }
         catch (error) {
             this.raiseReadFatal(stage, error);
@@ -715,7 +714,7 @@ class CanvasInboxWatcher {
         const plan = this.ordinaryPlan();
         if (plan.deferredHold)
             return 'held';
-        if (this.pendingHandoffs.length + plan.sendCount > MAX_ORDINARY_HANDOFFS)
+        if (this.pendingHandoffs.length + plan.sendCount > MAX_PENDING_HANDOFFS)
             return 'capacity-blocked';
         const batch = [...this.buffer];
         const execution = this.executePlan(nodeId, plan, 'poll');
@@ -725,45 +724,6 @@ class CanvasInboxWatcher {
         this.requeueFromBatch(batch, execution.retryEntryIds);
         return 'attempted';
     }
-    processReplay(nodeId) {
-        const gate = this.replay;
-        if (gate === undefined)
-            return;
-        if (gate.entries === undefined) {
-            if (gate.attempted) {
-                this.raiseReplayFatal(gate, new Error('replay range was already attempted without retained entries'));
-            }
-            gate.attempted = true;
-            let entries;
-            try {
-                entries = readInboxRange(nodeId, gate.afterEntryId, gate.throughEntryId);
-            }
-            catch (error) {
-                this.raiseReplayFatal(gate, error);
-            }
-            if (entries.length === 0 || entries.at(-1).entry_id !== gate.throughEntryId) {
-                this.raiseReplayFatal(gate, new Error('replay range did not retain its inclusive target'));
-            }
-            gate.entries = entries;
-        }
-        const entries = gate.entries;
-        const plan = this.buildPlan(entries);
-        if (plan.hiddenEntries.length === 0 && plan.visibleEntries.length === 0) {
-            if (this.replay === gate)
-                this.replay = undefined;
-            return;
-        }
-        if (plan.deferredHold)
-            return;
-        if (this.pendingHandoffs.length + plan.sendCount > MAX_PENDING_HANDOFFS)
-            return;
-        const execution = this.executePlan(nodeId, plan, 'poll');
-        if (execution.inactive)
-            return;
-        if (this.canMutate() && this.replay === gate && this.replayCoverageComplete(entries)) {
-            this.replay = undefined;
-        }
-    }
     coveredEntryIds(channel) {
         const covered = new Set();
         for (const handoff of this.pendingHandoffs) {
@@ -774,13 +734,54 @@ class CanvasInboxWatcher {
         }
         return covered;
     }
-    replayCoverageComplete(entries) {
-        const missing = this.missingChannelEntries(entries);
-        return missing.hiddenEntries.length === 0 && missing.visibleEntries.length === 0;
+    retryPendingCommitOnTick(nodeId) {
+        void this.retryPendingCommit(nodeId).then((result) => {
+            if (result === 'refresh_held' && this.canMutate())
+                this.dispose('refresh', false);
+        }).catch((error) => {
+            if (this.canMutate())
+                this.dispose('shutdown', false, undefined, { error, stage: 'settle' });
+        });
+    }
+    retryPendingCommit(nodeId) {
+        const pending = this.pendingCommit;
+        if (pending === undefined)
+            return Promise.resolve('settled');
+        if (pending.attempt !== undefined)
+            return pending.attempt;
+        const attempt = this.attemptPendingCommit(nodeId, pending).finally(() => {
+            if (pending.attempt === attempt)
+                pending.attempt = undefined;
+        });
+        pending.attempt = attempt;
+        return attempt;
     }
-    settle(nodeId, ctx, refreshHeld, holdPendingMessages) {
-        if (refreshHeld)
+    async attemptPendingCommit(nodeId, pending) {
+        try {
+            const directive = await advanceBrokerInboxCursor(nodeId, {
+                throughEntryId: pending.throughEntryId,
+                brokerPid: process.pid,
+            });
+            if (directive.action === 'hold_refresh')
+                return 'refresh_held';
+        }
+        catch (error) {
+            if (this.pendingCommit === pending) {
+                for (const handoff of pending.handoffs) {
+                    emitDeliveryFailure(handoff.operationId, handoff, 'cursor_commit', error);
+                }
+            }
             return 'held';
+        }
+        if (this.pendingCommit !== pending)
+            return 'settled';
+        this.durableCursor = pending.throughEntryId;
+        this.pendingCommit = undefined;
+        for (const handoff of pending.handoffs)
+            emitDeliveryCompleted(handoff);
+        return 'settled';
+    }
+    async settle(nodeId, ctx, holdPendingMessages) {
         if (holdPendingMessages) {
             try {
                 if (ctx?.hasPendingMessages?.() === true)
@@ -790,8 +791,8 @@ class CanvasInboxWatcher {
                 // A missing context signal does not invent a pending-message hold.
             }
         }
-        if (this.replay !== undefined)
-            return 'held';
+        if (this.pendingCommit !== undefined)
+            return this.retryPendingCommit(nodeId);
         if (this.pendingHandoffs.length === 0)
             return 'settled';
         const physical = this.readPhysicalSettlementState(nodeId);
@@ -811,33 +812,17 @@ class CanvasInboxWatcher {
             if (physical.throughIndexes.get(handoff) > physical.throughIndexes.get(target))
                 target = handoff;
         }
-        const targetIndex = physical.throughIndexes.get(target);
-        try {
-            writeCursor(nodeId, target.throughEntryId);
-        }
-        catch (error) {
-            const eligibleSet = new Set(eligible);
-            const failed = this.detachPending((handoff) => eligibleSet.has(handoff));
-            this.replay = {
-                afterEntryId: this.durableCursor,
-                throughEntryId: target.throughEntryId,
-                attempted: false,
-            };
-            for (const handoff of failed) {
-                emitDeliveryFailure(handoff.operationId, handoff, 'cursor_commit', error);
-            }
-            return 'settled';
-        }
-        this.durableCursor = target.throughEntryId;
-        const completed = this.detachPending((handoff) => physical.throughIndexes.get(handoff) <= targetIndex);
-        for (const handoff of completed)
-            emitDeliveryCompleted(handoff);
-        return 'settled';
+        const committing = new Set(eligible);
+        this.pendingCommit = {
+            handoffs: this.detachPending((handoff) => committing.has(handoff)),
+            throughEntryId: target.throughEntryId,
+        };
+        return this.retryPendingCommit(nodeId);
     }
     readPhysicalSettlementState(nodeId) {
         let entries;
         try {
-            entries = readInboxSince(nodeId);
+            entries = readBrokerInboxSince(nodeId);
         }
         catch (error) {
             this.raiseReadFatal('settle', error);

package/dist/pi-extensions/canvas-passive-context.d.ts

@@ -1,4 +1,4 @@
-import type { InboxEntry } from '../core/feed/inbox.js';
+import { type BrokerPassiveEntry } from '../core/runtime/broker/passive.js';
 interface InputEventLike {
     type: 'input';
     text: string;
@@ -15,13 +15,13 @@ type InputEventResultLike = {
     action: 'handled';
 };
 interface PiLike {
-    on: (event: 'input', handler: (event: InputEventLike, ctx: any) => InputEventResultLike | void) => void;
+    on: (event: 'input', handler: (event: InputEventLike, ctx: any) => InputEventResultLike | void | Promise<InputEventResultLike | void>) => void;
 }
 /**
  * Render drained passive entries (oldest first) into one XML pre-text block.
  * Each accumulated message is its own timestamped `<update>` element.
  */
-export declare function formatPassive(entries: InboxEntry[]): string;
+export declare function formatPassive(entries: BrokerPassiveEntry[], reportNodes?: ReadonlyMap<string, unknown>): string;
 /**
  * Register the passive-context drain on `pi`.
  *

package/dist/pi-extensions/canvas-passive-context.js

@@ -19,8 +19,9 @@
 // Plain TS-with-types — no imports from @earendil-works/* so this compiles inside
 // crouter's own tsc build without a dep on the pi packages.
 import { existsSync, readFileSync } from 'node:fs';
-import { resolveRef } from '../core/canvas/history.js';
-import { drainPassive } from '../core/feed/passive.js';
+import { brokerExtensionState } from '../core/runtime/broker/daemon-ops.js';
+import { reportPathFromRef } from '../core/runtime/broker-extension-render.js';
+import { drainBrokerPassive } from '../core/runtime/broker/passive.js';
 // Per-entry body cap so a single fat report can't blow the context budget. The
 // full report stays on disk at `ref` if the agent needs more.
 const BODY_CAP = 4_000;
@@ -37,24 +38,25 @@ function stripFrontmatter(raw) {
 }
 /** The content for one accumulated entry: the dereferenced report body when the
  *  pointer carries a `ref`, else the entry's own label/data. Capped + trimmed. */
-function entryContent(e) {
+function entryContent(e, reportNodes) {
     if (e.ref !== undefined && e.ref !== '') {
-        // Push entries carry a canonical history handle; resolve it through the
-        // same path as `canvas history read`. Direct-message spill refs remain
-        // absolute filesystem paths and keep their existing dereference behavior.
-        try {
-            const resolved = resolveRef(e.ref);
-            if (resolved?.source === 'report') {
-                const body = resolved.body.trim();
+        // Push entries carry a canonical history handle. crtrd has already
+        // projected the sender set; use that metadata to validate the local path
+        // without importing the canvas history resolver. Direct-message spill refs
+        // remain absolute filesystem paths and keep their existing behavior.
+        const reportPath = reportPathFromRef(e.ref, reportNodes);
+        if (reportPath !== null) {
+            try {
+                const body = stripFrontmatter(readFileSync(reportPath, 'utf8')).trim();
                 if (body !== '') {
                     return body.length > BODY_CAP
                         ? `${body.slice(0, BODY_CAP)}\n… (truncated; read the full report with \`crtr canvas history read ${e.ref}\`)`
                         : body;
                 }
             }
-        }
-        catch {
-            /* fall through to the absolute spill-file path */
+            catch {
+                /* fall through to the absolute spill-file path */
+            }
         }
         if (existsSync(e.ref)) {
             try {
@@ -87,13 +89,13 @@ function attr(s) {
  * Render drained passive entries (oldest first) into one XML pre-text block.
  * Each accumulated message is its own timestamped `<update>` element.
  */
-export function formatPassive(entries) {
+export function formatPassive(entries, reportNodes = new Map()) {
     const blocks = entries
         .map((e) => {
         const from = attr(e.from ?? 'system');
         const refAttr = e.ref !== undefined && e.ref !== '' ? ` ref="${attr(e.ref)}"` : '';
         return (`<update from="${from}" kind="${attr(e.kind)}" at="${attr(e.ts)}"${refAttr}>\n` +
-            `${entryContent(e)}\n` +
+            `${entryContent(e, reportNodes)}\n` +
             `</update>`);
     })
         .join('\n');
@@ -113,15 +115,17 @@ export function formatPassive(entries) {
  * is the whole extension: drain on every message, prepend when non-empty.
  */
 export function registerCanvasPassiveContext(pi) {
-    pi.on('input', (event) => {
+    pi.on('input', async (event) => {
         try {
             const nodeId = process.env['CRTR_NODE_ID'];
             if (nodeId === undefined || nodeId.trim() === '')
                 return; // not a canvas node
-            const drained = drainPassive(nodeId);
+            const drained = drainBrokerPassive(nodeId);
             if (drained.length === 0)
                 return; // nothing accumulated → leave the message as-is
-            const preText = formatPassive(drained);
+            const state = await brokerExtensionState(nodeId);
+            const reportNodes = new Map(state.report_nodes.map((node) => [node.node_id, node]));
+            const preText = formatPassive(drained, reportNodes);
             const text = event.text.trim() === '' ? preText : `${preText}\n\n${event.text}`;
             return { action: 'transform', text, images: event.images };
         }

package/dist/pi-extensions/canvas-recap.d.ts

@@ -1,4 +1,3 @@
-import { regenerateAndPersistName } from '../core/runtime/naming-persist.js';
 import { generateRecap } from '../core/runtime/recap.js';
 interface TextContentLike {
     type: string;
@@ -44,11 +43,12 @@ interface PiLike {
     getSessionName?(): string | undefined;
     setSessionName?(name: string): void;
 }
+type NameRegenerator = (nodeId: string, conversation: string, isStillAutomatic: () => boolean, onNamed?: (editorLabel: string) => void) => void;
 /**
  * Register the inactivity-recap chrome on `pi`.
  *
  * Returns immediately (inert) when CRTR_NODE_ID is absent — a plain pi session
  * or legacy job agent loads it as a no-op.
  */
-export declare function registerCanvasRecap(pi: PiLike, recapGenerator?: typeof generateRecap, nameRegenerator?: typeof regenerateAndPersistName): void;
+export declare function registerCanvasRecap(pi: PiLike, recapGenerator?: typeof generateRecap, nameRegenerator?: NameRegenerator): void;
 export default registerCanvasRecap;