@north-light/crouter 0.3.185 → 0.3.187

package/dist/core/resolver.js

@@ -1,39 +1,14 @@
 import { join } from 'node:path';
-import { CONFIG_FILE } from '../types.js';
 import { readConfig } from './config.js';
-import { listDirs, pathExists, readJsonIfExists } from './fs-utils.js';
-import { readMarketplaceManifest, readPluginManifest } from './manifest.js';
+import { listDirs, pathExists } from './fs-utils.js';
+import { readMarketplaceManifest } from './manifest.js';
 import { InputError } from './io.js';
 import { marketplacesDir, projectScopeRoot, scopeRoot, userScopeRoot, } from './scope.js';
-function pluginConfigForRoot(root) {
-    const cfg = readJsonIfExists(join(root, CONFIG_FILE));
-    return cfg && cfg.plugins && typeof cfg.plugins === 'object' ? cfg.plugins : {};
-}
-export function listInstalledPluginsInRoot(scope, scopeRootPath) {
-    const dir = join(scopeRootPath, 'plugins');
-    if (!pathExists(dir))
-        return [];
-    const cfg = pluginConfigForRoot(scopeRootPath);
-    const out = [];
-    for (const name of listDirs(dir)) {
-        const root = join(dir, name);
-        const manifest = readPluginManifest(root);
-        if (!manifest)
-            continue;
-        const entry = cfg[name];
-        const version = typeof entry?.version === 'string' ? entry.version : manifest.version;
-        out.push({
-            name,
-            scope,
-            root,
-            manifest,
-            enabled: typeof entry?.enabled === 'boolean' ? entry.enabled : true,
-            sourceMarketplace: typeof entry?.source_marketplace === 'string' ? entry.source_marketplace : undefined,
-            version,
-        });
-    }
-    return out;
-}
+// Moved to installed-plugins.ts (a leaf module below config.ts) so
+// `readMergedLaunchConfig` can layer plugin-declared kinds without an import
+// cycle; re-exported here for this module's existing callers.
+export { listInstalledPluginsInRoot } from './installed-plugins.js';
+import { listInstalledPluginsInRoot } from './installed-plugins.js';
 export function listInstalledPlugins(scope) {
     // The builtin scope has no scopeRoot, so this returns [] — builtin content is
     // the memory substrate, not plugins.

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/dist/types.d.ts

@@ -33,7 +33,18 @@ export interface PluginManifest {
     description?: string;
     source?: string;
     owner?: OwnerRef;
-    kinds?: string[];
+    /** Kind-registry contributions, keyed by full kind string (top-level e.g.
+     *  `applet-builder`, or sub-kind e.g. `plan/reviewers/security`). Each entry
+     *  is either a FULL `KindConfig` (has `whenToUse`: defines or wholly shadows
+     *  the kind) or a sparse PATCH over a kind a lower layer already defines —
+     *  the same two shapes a scope `config.json` `kinds` block accepts.
+     *  `readMergedLaunchConfig` layers an enabled plugin's entries directly
+     *  above the builtin registry and below its host scope's own `config.json`,
+     *  so a plugin can ship a persona kind (registry entry here + gated persona
+     *  memory docs in its `memory/` tree) and the user still overrides it.
+     *  Archive plugins declare this in `bundle.json`; the installer copies the
+     *  validated block into this synthesized manifest. */
+    kinds?: Record<string, Partial<KindConfig>>;
     /** Plugin-root-relative path to one declarative command manifest
      *  (`commands.json`). When present on an installed, enabled plugin, that
      *  manifest contributes top-level command branches to the `crtr` tree —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.185",
+  "version": "0.3.187",
   "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.187",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.185",
+      "version": "0.3.187",
       "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;
-}