@north-light/crouter 0.3.185 → 0.3.186

package/dist/commands/memory/list.js

@@ -22,9 +22,13 @@ export function listMemoryDocs(kindFilter, scopeFilter, quiet = false, docs = li
         if (kindFilter !== undefined && sub.kind !== kindFilter)
             continue;
         // A directory INDEX surfaces as a dir entry: its dir path with a trailing
-        // slash, flagged is_dir, so the inventory distinguishes it from a doc.
+        // slash, flagged is_dir, so the inventory distinguishes it from a doc. A
+        // store-root INDEX has no dir path, so it keeps its canonical `INDEX`
+        // name — every name in this column must be one `crtr memory read` and a
+        // `[[link]]` accept, and a bare `/` is neither.
         const isDir = isIndexName(sub.name);
-        const name = isDir ? indexDirOf(sub.name) + '/' : sub.name;
+        const dirPath = isDir ? indexDirOf(sub.name) : '';
+        const name = dirPath === '' ? sub.name : dirPath + '/';
         addItem({ name, kind: sub.kind, scope: sub.scope, path: sub.path, shortForm: sub.shortForm, isDir, slash: sub.slash });
     }
     items.sort((a, b) => {
@@ -53,7 +57,7 @@ export const listLeaf = defineLeaf({
             { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: 'Opaque token from next_cursor. Omit on first call.' },
         ],
         output: [
-            { name: 'items', type: 'object[]', required: true, constraint: 'One row per document: {name, short_form, kind, scope, is_dir}. path is included only with --paths. A directory INDEX.md surfaces as a dir entry (is_dir true, name = the directory path with a trailing slash); is_dir is false for an ordinary doc. short_form is the abbreviated hook — shown here and nowhere else. Sorted by scope then kind then name ascending.' },
+            { name: 'items', type: 'object[]', required: true, constraint: 'One row per document: {name, short_form, kind, scope, is_dir}. path is included only with --paths. A directory INDEX.md surfaces as a dir entry (is_dir true, name = the directory path with a trailing slash, or `INDEX` for a store-root INDEX that has no directory path); is_dir is false for an ordinary doc. Every name is readable as-is with `crtr memory read`. short_form is the abbreviated hook — shown here and nowhere else. Sorted by scope then kind then name ascending.' },
             { name: 'next_cursor', type: 'string | null', required: true, constraint: 'Opaque token for the next page; null means no more items.' },
             { name: 'total', type: 'integer | null', required: true, constraint: 'Exact total across all pages when cheap to compute (always cheap here); never null in practice for this leaf.' },
             { name: 'follow_up', type: 'string', required: true, constraint: 'Concrete next commands — read a document in full or narrow the inventory.' },

package/dist/core/__tests__/session-model.test.js

@@ -98,12 +98,10 @@ test('a welcome is a COMPLETE catch-up: a re-welcome drops a dead broker s level
     const s0 = fold(initialSessionState(), [
         welcome(),
         { type: 'extension_ui_request', id: 'u1', method: 'setStatus', statusKey: 'gone', statusText: 'stale' },
-        { type: 'queue_update', steering: ['one', 'two'], followUp: [], steeringIds: ['id-1'] },
+        { type: 'queue_update', steering: ['one', 'two'], followUp: [] },
     ]);
     assert.equal(s0.display.statuses['gone'], 'stale');
-    // Broker-enriched ids zip positionally; a position without one (older broker,
-    // short array) still renders as a bare-text entry.
-    assert.deepEqual(s0.queued, [{ id: 'id-1', text: 'one' }, { text: 'two' }]);
+    assert.deepEqual(s0.queued, [{ text: 'one' }, { text: 'two' }]);
     assert.equal(s0.engine?.pendingMessageCount, 2);
     // A fresh broker (post-revive) welcomes with its OWN levels and an empty queue,
     // and emits no queue_update to overwrite the panel — so the welcome must.

package/dist/core/runtime/broker/event-projection.d.ts

@@ -1,13 +1,11 @@
 import type { BrokerToClient } from '../broker-protocol.js';
 import type { BrokerSession } from './read-ops.js';
 import type { BrokerClientRegistry } from './client-registry.js';
-import type { MessageIdLedger } from './message-ledger.js';
 import type { SubscriptionGeneration } from './rebind.js';
 import type { FaultRetry } from './fault-retry.js';
 type EventProjectionDeps = {
     registry: BrokerClientRegistry;
     faultRetry: FaultRetry;
-    ledger: MessageIdLedger;
     installedGeneration: () => SubscriptionGeneration | undefined;
     currentSession: () => BrokerSession;
     notifyTurnAccepted: () => void;
@@ -33,12 +31,7 @@ export declare class EventProjection {
     reset(): void;
     dispose(): void;
     knownStreamWait(deadlineMs: number): () => void;
-    /** Message-identity enrichment (see MessageIdLedger): fold pi's queue state
-     *  into the ledger and relay id arrays parallel to the texts; attach the
-     *  retired/dispatched id to the user message that carries it. Both are
-     *  additive fields on the verbatim pi event — consumers read or ignore them. */
-    private withMessageIdentity;
-    relayEvent(rawEvent: BrokerToClient, generation: SubscriptionGeneration): void;
+    relayEvent(event: BrokerToClient, generation: SubscriptionGeneration): void;
     private clearPendingUpdate;
     private flushPendingUpdate;
     private invalidatePendingBroadcasts;

package/dist/core/runtime/broker/event-projection.js

@@ -1,4 +1,3 @@
-import { contentText } from '@earendil-works/pi-ai';
 import { readConfig } from '../../config.js';
 import { emitEvent } from '../../events/emit.js';
 import { releaseKnownStreamWait, resolveStreamWatchdogMs, StreamWatchdog } from '../stream-watchdog.js';
@@ -65,30 +64,7 @@ export class EventProjection {
             releaseKnownStreamWait(this.streamWatchdog, generation.id, waitingSession.isStreaming, generation.executingTools.size > 0);
         };
     }
-    /** Message-identity enrichment (see MessageIdLedger): fold pi's queue state
-     *  into the ledger and relay id arrays parallel to the texts; attach the
-     *  retired/dispatched id to the user message that carries it. Both are
-     *  additive fields on the verbatim pi event — consumers read or ignore them. */
-    withMessageIdentity(event) {
-        if (event.type === 'queue_update') {
-            const ids = this.deps.ledger.reconcileQueueUpdate(event.steering, event.followUp);
-            const enriched = { ...event, steeringIds: ids.steeringIds, followUpIds: ids.followUpIds };
-            return enriched;
-        }
-        if (event.type === 'message_start' && event.message.role === 'user') {
-            // contentText(content, '') is pi's OWN retirement text extraction
-            // (agent-session.js _handleAgentEvent) — the same function, so the
-            // ledger's text matching cannot diverge from pi's queue splice.
-            const crtrMessageId = this.deps.ledger.takeUserMessageId(contentText(event.message.content, ''));
-            if (crtrMessageId === undefined)
-                return event;
-            const enriched = { ...event, crtrMessageId };
-            return enriched;
-        }
-        return event;
-    }
-    relayEvent(rawEvent, generation) {
-        const event = this.withMessageIdentity(rawEvent);
+    relayEvent(event, generation) {
         this.deps.faultRetry.onEvent(event);
         const type = event.type;
         if (type === 'message_start' && event.message.role === 'user') {

package/dist/core/runtime/broker/frame-dispatch.d.ts

@@ -6,7 +6,6 @@ import type { BrokerClient, BrokerClientRegistry } from './client-registry.js';
 import { type BrokerSession } from './read-ops.js';
 import type { ToolGroupTracker } from './tool-groups.js';
 import type { EventProjection } from './event-projection.js';
-import type { MessageIdLedger } from './message-ledger.js';
 import type { RebindDriver } from './rebind.js';
 export declare const REVIEW_BOUNDARY_NAVIGATION_CODE = "review_boundary_navigation";
 export declare class ReviewBoundaryNavigationError extends Error {
@@ -181,7 +180,6 @@ export type FrameDispatchDeps = {
     registry: BrokerClientRegistry;
     toolGroups: ToolGroupTracker;
     projection: EventProjection;
-    ledger: MessageIdLedger;
     rebind: RebindDriver;
     reviewCompanion: boolean;
     pendingDialogs: Map<string, PendingDialog>;

package/dist/core/runtime/broker/frame-dispatch.js

@@ -279,7 +279,7 @@ export function stripHiddenEntriesFromJsonlExport(filePath) {
 }
 /** Owns frame-local input state while dispatching through explicit broker collaborators. */
 export function createFrameDispatchContext(deps) {
-    const { nodeId, cfg, registry, toolGroups, projection, ledger, rebind, reviewCompanion, pendingDialogs, sendWelcome, replayExtraPendingDialogsTo, reWelcomeAll, disposeAndExit, persistModelChoice, broadcastModelChanged, registryOf, formatModelSpec, formatExactModelSpec, resolveLaunchModel, } = deps;
+    const { nodeId, cfg, registry, toolGroups, projection, rebind, reviewCompanion, pendingDialogs, sendWelcome, replayExtraPendingDialogsTo, reWelcomeAll, disposeAndExit, persistModelChoice, broadcastModelChanged, registryOf, formatModelSpec, formatExactModelSpec, resolveLaunchModel, } = deps;
     const currentSession = () => rebind.session();
     const currentServices = () => rebind.services();
     let kickoffPending;
@@ -301,14 +301,9 @@ export function createFrameDispatchContext(deps) {
         const prompt = kickoffPending;
         kickoffPending = undefined;
         kickoffInFlight = true;
-        // The kickoff prompt is a broker-originated dispatch — mint its identity
-        // here so its relayed user message_start carries an id like any other.
-        const kickoffMessageId = randomUUID();
-        ledger.noteDispatch(kickoffMessageId, prompt);
         trackPromptDispatch(operationIdContext.fresh(() => currentSession()
             .prompt(prompt)
             .catch((err) => {
-            ledger.dropIntent(kickoffMessageId);
             emitEvent({
                 level: 'error',
                 event: 'broker.prompt.first_failed',
@@ -397,7 +392,6 @@ export function createFrameDispatchContext(deps) {
         // is producing now, then start this as a new turn. A normal mid-stream
         // prompt deliberately steers into pi's queue; the whip must not.
         if (frame.type === 'prompt' && frame.interrupt === true) {
-            const whipMessageId = frame.message_id;
             return (async () => {
                 if (currentSession().isBashRunning) {
                     currentSession().abortBash();
@@ -420,7 +414,6 @@ export function createFrameDispatchContext(deps) {
                     type: 'prompt',
                     text: frame.text,
                     ...(frame.images !== undefined ? { images: frame.images } : {}),
-                    ...(whipMessageId !== undefined ? { message_id: whipMessageId } : {}),
                 });
             })().catch((err) => {
                 relayError(err);
@@ -451,19 +444,6 @@ export function createFrameDispatchContext(deps) {
                 const dispatch = () => {
                     const route = resolveEngineRoute(frame, currentSession().isStreaming);
                     const guidance = resolveFrameGuidance(frame.text);
-                    // Message identity (see MessageIdLedger): note the dispatch intent
-                    // before the engine call so pi's synchronous queue_update/message_start
-                    // can adopt it. A leading engine command never produces a matching
-                    // user message — no intent. On rejection the intent is dropped.
-                    let noteFailure = relayError;
-                    if (!isLeadingEngineCommand(frame.text, currentSession())) {
-                        const messageId = frame.message_id ?? randomUUID();
-                        ledger.noteDispatch(messageId, frame.text);
-                        noteFailure = (err) => {
-                            ledger.dropIntent(messageId);
-                            relayError(err);
-                        };
-                    }
                     if (guidance === null) {
                         if (route.call === 'prompt') {
                             // A routed prompt STARTS a turn — including an idle follow_up
@@ -472,12 +452,12 @@ export function createFrameDispatchContext(deps) {
                             // steer.
                             return settle(trackPromptDispatch(operationIdContext.fresh(() => currentSession()
                                 .prompt(frame.text, route.options)
-                                .catch(noteFailure))));
+                                .catch(relayError))));
                         }
                         // C1: pi's followUp() takes images as a POSITIONAL 2nd arg (`followUp(text, images?)`).
                         return settle(currentSession()
                             .followUp(frame.text, frame.images)
-                            .catch(noteFailure));
+                            .catch(relayError));
                     }
                     const deliverAs = chooseGuidanceDeliveryMode(frame.type, route.call, currentSession().isStreaming);
                     if (route.call === 'prompt') {
@@ -489,18 +469,18 @@ export function createFrameDispatchContext(deps) {
                             // ATOMICALLY clears its own pending entry if prompt() settles
                             // without ever reaching that drain (an early throw/return leaves
                             // nothing stranded to leak into a later, unrelated turn).
-                            return settle(trackPromptDispatch(promptWithNextTurnGuidance(currentSession(), guidance, () => operationIdContext.fresh(() => currentSession().prompt(frame.text, route.options))).catch(noteFailure)));
+                            return settle(trackPromptDispatch(promptWithNextTurnGuidance(currentSession(), guidance, () => operationIdContext.fresh(() => currentSession().prompt(frame.text, route.options))).catch(relayError)));
                         }
                         return settle(trackPromptDispatch(operationIdContext.fresh(() => currentSession()
                             .prompt(frame.text, route.options)
-                            .catch(noteFailure)
+                            .catch(relayError)
                             .then(() => sendGuidance(guidance, deliverAs)))));
                     }
                     // deliverAs is always 'followUp' here per chooseGuidanceDeliveryMode's
                     // contract (a followUp routeCall never yields 'nextTurn').
                     return settle(currentSession()
                         .followUp(frame.text, frame.images)
-                        .catch(noteFailure)
+                        .catch(relayError)
                         .then(() => sendGuidance(guidance, deliverAs)));
                 };
                 // /login acknowledges before its asynchronous local refresh completes.
@@ -530,8 +510,6 @@ export function createFrameDispatchContext(deps) {
                 // and executes it immediately even while streaming. It also expands a
                 // matching skill/template before applying the same steer behavior.
                 if (resolveSteerCall(frame.text, currentSession()) === 'prompt') {
-                    // The steer→prompt leading-command path never yields a matching user
-                    // message — no ledger intent (see MessageIdLedger).
                     void currentSession()
                         .prompt(frame.text, {
                         images: frame.images,
@@ -540,25 +518,17 @@ export function createFrameDispatchContext(deps) {
                         .catch(relayError);
                     break;
                 }
-                // Message identity: note the intent before steer() so pi's synchronous
-                // enqueue queue_update can adopt it; drop it if the call rejects.
-                const steerMessageId = frame.message_id ?? randomUUID();
-                ledger.noteDispatch(steerMessageId, frame.text);
-                const steerFailure = (err) => {
-                    ledger.dropIntent(steerMessageId);
-                    relayError(err);
-                };
                 const guidance = resolveFrameGuidance(frame.text);
                 // C1: pi's steer() takes images as a POSITIONAL 2nd arg (`steer(text, images?)`).
                 if (guidance === null) {
                     void currentSession()
                         .steer(frame.text, frame.images)
-                        .catch(steerFailure);
+                        .catch(relayError);
                     break;
                 }
                 void currentSession()
                     .steer(frame.text, frame.images)
-                    .catch(steerFailure)
+                    .catch(relayError)
                     .then(() => sendGuidance(guidance, 'steer'));
                 break;
             }
@@ -836,9 +806,6 @@ export function createFrameDispatchContext(deps) {
             type: 'prompt',
             text: frame.text,
             ...(frame.images !== undefined ? { images: frame.images } : {}),
-            // Carry the sender-minted message identity onto the synthesized prompt
-            // frame so a gateway/Core deliver retires its optimistic entry by id.
-            ...(frame.message_id !== undefined ? { message_id: frame.message_id } : {}),
         });
         if (via === 'steer' || outcome === undefined) {
             turnAcceptedWaiters.delete(ackAccepted);

package/dist/core/runtime/broker-protocol.d.ts

@@ -78,27 +78,16 @@ export interface PromptFrame {
     images?: ImageContent[];
     /** Abort the active turn before starting this prompt. Used by the attach viewer's whip action so its command replaces, rather than joins, in-flight work. */
     interrupt?: true;
-    /** Sender-minted message identity (see MessageIdLedger). The broker mirrors
-     *  it through pi's id-less queues and echoes it back on the relayed user
-     *  `message_start` (`crtrMessageId`) and enriched `queue_update`
-     *  (`steeringIds`/`followUpIds`), so an optimistic sender retires its
-     *  pending entry by exact id instead of text/order guessing. Absent (a
-     *  legacy client, kickoff, inbox): the broker mints one itself. */
-    message_id?: string;
 }
 export interface SteerFrame {
     type: 'steer';
     text: string;
     images?: ImageContent[];
-    /** Sender-minted message identity — see {@link PromptFrame.message_id}. */
-    message_id?: string;
 }
 export interface FollowUpFrame {
     type: 'follow_up';
     text: string;
     images?: ImageContent[];
-    /** Sender-minted message identity — see {@link PromptFrame.message_id}. */
-    message_id?: string;
 }
 export interface AbortFrame {
     type: 'abort';
@@ -122,9 +111,6 @@ export interface DeliverFrame {
     id: string;
     text: string;
     images?: ImageContent[];
-    /** Sender-minted message identity — see {@link PromptFrame.message_id}.
-     *  Distinct from `id`, the one-shot ack-correlation token. */
-    message_id?: string;
 }
 /** Run a `!` bash command — writable clients only. Maps to `session.executeBash()`,
  *  which runs the command, records a `bashExecution` message in context, and
@@ -365,38 +351,7 @@ export interface WelcomeFrame {
      *  can construct an AuthStorage/ModelRegistry pointing at the SAME auth.json.
      *  crtr surface attach is tmux-local only: broker + viewer share a filesystem. */
     agentDir?: string;
-    /** The last few id-bearing user-message dispatches from the broker's message
-     *  ledger, oldest first — so a reattaching follower (Core's snapshot wake
-     *  replay) can key the snapshot's trailing user wakes by id instead of
-     *  discarding them heuristically. Live-process memory only: a broker restart
-     *  loses it (accepted — optimistic pending sends don't survive that either).
-     *  Absent on a broker pinned to an older runtime generation. */
-    recentUserMessages?: Array<{
-        id: string;
-        text: string;
-    }>;
-}
-/** A relayed pi `queue_update`, enriched by the broker with id arrays PARALLEL
- *  to pi's text arrays (`steeringIds[i]` identifies `steering[i]`). The ids are
- *  the broker's message ledger mirror of pi's queues — sender-minted when the
- *  frame carried `message_id`, broker-minted otherwise. Absent on a broker
- *  pinned to an older runtime generation; consumers fall back to bare texts. */
-export type RelayedQueueUpdate = Extract<AgentSessionEvent, {
-    type: 'queue_update';
-}> & {
-    steeringIds?: string[];
-    followUpIds?: string[];
-};
-/** A relayed user `message_start`, enriched by the broker with the message's
- *  crouter identity — the id staged by the retirement `queue_update` pi emits
- *  synchronously before it, or the matching dispatch intent for an idle
- *  prompt. Absent when the message carries none (an engine-command expansion,
- *  a pre-ledger replay, an older broker). */
-export type RelayedUserMessageStart = Extract<AgentSessionEvent, {
-    type: 'message_start';
-}> & {
-    crtrMessageId?: string;
-};
+}
 /** Broadcast to EVERY client after a successful `set_model`/`cycle_model`. pi
  *  emits no AgentSessionEvent for a model switch, so without this the new model
  *  reaches no viewer at all (the requester gets only a bare ack) and footers

package/dist/core/runtime/broker.js

@@ -44,7 +44,6 @@ import { BrokerClientRegistry } from './broker/client-registry.js';
 import { ToolGroupTracker } from './broker/tool-groups.js';
 import { FaultRetry } from './broker/fault-retry.js';
 import { EventProjection } from './broker/event-projection.js';
-import { MessageIdLedger } from './broker/message-ledger.js';
 import { createFrameDispatchContext, handleFrame } from './broker/frame-dispatch.js';
 import { RebindDriver } from './broker/rebind.js';
 import { brokerExtensionState, commitBrokerModel } from './broker/daemon-ops.js';
@@ -285,9 +284,6 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
     let projection;
     let notifyTurnAccepted = () => { };
     let resetFrameState = () => { };
-    // Broker-owned message identity (see MessageIdLedger): mirrors pi's id-less
-    // queues so relayed queue_update/user message_start frames carry ids.
-    const messageLedger = new MessageIdLedger();
     rebind = new RebindDriver({
         nodeId, cfg, session, services, runtime, registry, toolGroups,
         uiContext: () => uiContext,
@@ -297,7 +293,6 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
         disposeAndExit: (reason, status) => disposeAndExit(reason, status),
         onSessionRebind: () => {
             resetFrameState();
-            messageLedger.reset();
         },
         reWelcomeAll: () => reWelcomeAll(),
     });
@@ -339,7 +334,6 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
     projection = new EventProjection({
         registry,
         faultRetry,
-        ledger: messageLedger,
         installedGeneration: () => rebind.installedGeneration(),
         currentSession: () => rebind.session(),
         notifyTurnAccepted: () => notifyTurnAccepted(),
@@ -396,7 +390,6 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
             role: client.role,
             pending_dialog: first !== undefined ? first.request : null,
             agentDir: getAgentDir(),
-            recentUserMessages: messageLedger.recentUserMessages(),
         }, true);
         // No display_* replay: the retained extension state rides IN the snapshot
         // (`snapshot.display`), so catch-up is one atomic frame. A viewer attaching
@@ -509,7 +502,7 @@ export async function runBroker(nodeId, startupAt = process.hrtime.bigint(), sta
     rebind.setRebindSession();
     await rebind.enqueueRebind(session, services);
     const frameDispatch = createFrameDispatchContext({
-        nodeId, cfg, registry, toolGroups, projection, ledger: messageLedger, rebind, reviewCompanion,
+        nodeId, cfg, registry, toolGroups, projection, rebind, reviewCompanion,
         pendingDialogs, sendWelcome, replayExtraPendingDialogsTo, reWelcomeAll, disposeAndExit,
         persistModelChoice, broadcastModelChanged, registryOf, formatModelSpec,
         formatExactModelSpec, resolveLaunchModel,

package/dist/core/runtime/interactive-deliver.d.ts

@@ -6,11 +6,8 @@ export type LiveDeliverRoute = 'prompt' | 'steer';
 export type LiveInterruptOutcome = 'turn' | 'bash' | 'idle';
 /** Deliver `text` to a LIVE node's engine on its serialized frame loop. The
  *  broker routes it itself (idle → prompt, streaming → steer) and acks once
- *  routed; resolves with the route taken. `messageId` is the sender-minted
- *  message identity (`SendMessageRequest.message_id`), carried on the deliver
- *  frame so the broker's ledger echoes it back on the relayed user
- *  `message_start` — distinct from the one-shot ack-correlation id. */
-export declare function deliverLive(nodeId: string, text: string, messageId?: string): Promise<LiveDeliverRoute>;
+ *  routed; resolves with the route taken. */
+export declare function deliverLive(nodeId: string, text: string): Promise<LiveDeliverRoute>;
 /** Abort whatever a LIVE node's engine is doing (turn or `!` bash). Resolves
  *  once the broker has PROCESSED the abort — which, on the single frame loop,
  *  also implies every earlier-accepted deliver was already routed (so a

package/dist/core/runtime/interactive-deliver.js

@@ -14,17 +14,14 @@
 import { oneShotControllerRequest } from './broker-request.js';
 /** Deliver `text` to a LIVE node's engine on its serialized frame loop. The
  *  broker routes it itself (idle → prompt, streaming → steer) and acks once
- *  routed; resolves with the route taken. `messageId` is the sender-minted
- *  message identity (`SendMessageRequest.message_id`), carried on the deliver
- *  frame so the broker's ledger echoes it back on the relayed user
- *  `message_start` — distinct from the one-shot ack-correlation id. */
-export function deliverLive(nodeId, text, messageId) {
+ *  routed; resolves with the route taken. */
+export function deliverLive(nodeId, text) {
     return oneShotControllerRequest({
         nodeId,
         what: 'the interactive delivery',
         ackFor: 'deliver',
         correlated: true,
-        frame: (id) => ({ type: 'deliver', id, text, ...(messageId !== undefined ? { message_id: messageId } : {}) }),
+        frame: (id) => ({ type: 'deliver', id, text }),
         result: (detail) => (detail === 'steer' ? 'steer' : 'prompt'),
     });
 }

package/dist/core/session-model/session-state.d.ts

@@ -24,13 +24,10 @@ export interface SessionState {
     /** Live context occupancy in prompt tokens: seeded from the snapshot's
      *  contextUsage, then tracked off each assistant `message_end`. */
     contextTokens: number | undefined;
-    /** Queued steering + follow-up messages, from `queue_update`. `id` is the
-     *  broker's message-ledger identity for the entry (`steeringIds`/
-     *  `followUpIds`), absent on a broker pinned to an older runtime generation.
-     *  A fresh broker with an empty queue emits no `queue_update`, so every
-     *  welcome resets this rather than leaving a dead broker's rows on screen. */
+    /** Queued steering + follow-up messages, from `queue_update`. A fresh broker
+     *  with an empty queue emits no `queue_update`, so every welcome resets this
+     *  rather than leaving a dead broker's rows on screen. */
     queued: Array<{
-        id?: string;
         text: string;
     }>;
     display: DisplayState;

package/dist/core/session-model/session-state.js

@@ -132,11 +132,7 @@ export function reduce(state, frame) {
         case 'thinking_level_changed':
             return patchEngine(state, { thinkingLevel: frame.level });
         case 'queue_update': {
-            // The broker enriches relayed queue_updates with id arrays parallel to
-            // pi's text arrays; zip them, tolerating their absence (older broker).
-            const { steeringIds, followUpIds } = frame;
-            const zip = (texts, ids) => texts.map((text, i) => (ids?.[i] !== undefined ? { id: ids[i], text } : { text }));
-            const queued = [...zip(frame.steering, steeringIds), ...zip(frame.followUp, followUpIds)];
+            const queued = [...frame.steering, ...frame.followUp].map((text) => ({ text }));
             const next = patchEngine(state, { pendingMessageCount: queued.length });
             return { ...next, queued };
         }

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

@@ -59,12 +59,6 @@ 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.
@@ -164,7 +158,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, req.message_id);
+            await deliverLive(id, req.body);
             const body = {
                 node_id: id,
                 delivered: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.185",
+  "version": "0.3.186",
   "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.185",
+  "version": "0.3.186",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.185",
+      "version": "0.3.186",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/dist/core/runtime/broker/message-ledger.d.ts

@@ -1,53 +0,0 @@
-/** One id-bearing message the ledger tracks. */
-export interface LedgerEntry {
-    id: string;
-    text: string;
-}
-export declare class MessageIdLedger {
-    private steering;
-    private followUp;
-    private pendingIntents;
-    private stagedRetirementId;
-    private recent;
-    /** Record an accepted client frame's identity before its engine call runs.
-     *  `id` is the sender's `message_id` when it minted one, else broker-minted. */
-    noteDispatch(id: string, text: string): void;
-    /** Remove a noted intent whose engine call rejected — the message will never
-     *  appear in a queue or as a user message. No-op if already adopted. */
-    dropIntent(id: string): void;
-    /**
-     * Fold one pi `queue_update` into the ledger and return the id arrays
-     * parallel to its text arrays (total: every position gets an id).
-     *
-     * Per-queue positional diff against the mirrored entries: a text matching an
-     * old entry at-or-after the cursor keeps its id (everything skipped is
-     * removed); an unmatched text ADOPTS the first pending intent with equal
-     * text, else mints a fresh id. Exactly ONE removal across both queues is
-     * pi's per-message retirement (its queue_update precedes the user
-     * `message_start` it belongs to) and is staged for `takeUserMessageId`;
-     * 0 or >1 removals (an enqueue, clearQueue/dequeue, abort) stage nothing.
-     */
-    reconcileQueueUpdate(steering: readonly string[], followUp: readonly string[]): {
-        steeringIds: string[];
-        followUpIds: string[];
-    };
-    /**
-     * The id for a relayed user `message_start`, or undefined when this message
-     * carries none (an engine-command expansion, a text pi transformed, or a
-     * pre-ledger replay). A staged retirement wins — pi emitted its queue_update
-     * synchronously right before this message; otherwise the first pending
-     * intent with equal text (the idle-prompt case, which never touches a
-     * queue). Id-bearing results are remembered for `recentUserMessages`.
-     */
-    takeUserMessageId(messageText: string): string | undefined;
-    /** The last {@link MAX_RECENT} id-bearing user-message dispatches, oldest
-     *  first — the `welcome.recentUserMessages` payload. */
-    recentUserMessages(): Array<{
-        id: string;
-        text: string;
-    }>;
-    /** Session rebind/replacement: the mirrored queues, staged retirement, and
-     *  recent list all described the OLD session — drop everything. */
-    reset(): void;
-    private remember;
-}