@north-light/crouter 0.3.184 → 0.3.186

package/dist/core/command-manifests/registry.js

@@ -2,26 +2,35 @@
 // contributor attribution. This module takes raw candidates (from plugins,
 // HTTP-transport plugins, or any external source) and runs one unified pass that:
 //
-// 1. Detects collisions by resolved path (shortest collision wins).
-// 2. Drops all claimants at each collided path.
-// 3. Records issues on every claimant at each collision.
-// 4. Gives core absolute precedence.
+// 1. Detects top-level collisions between plugins.
+// 2. Keeps every plugin claimant by mounting it at <origin>:<command>.
+// 3. Records an informational issue on every qualified claimant.
+// 4. Gives core absolute precedence and drops core-name claimants.
 // 5. Returns a deterministically ordered, collision-resolved snapshot.
 //
 // The registry itself is transport-neutral: it knows nothing about plugin
 // executables or HTTP invokers. Each contribution carries its own adapter
 // callback, which the tree composer invokes to turn a leaf into a real crtr
 // LeafDef.
+/** The stable source name used to qualify a colliding plugin command. */
+export function commandContributorOrigin(contributor) {
+    return contributor.sourceMarketplace ?? contributor.name;
+}
+/** The top-level name assigned to a plugin command that collides with another
+ * plugin command. */
+export function qualifiedTopLevelCommandName(contributor, commandName) {
+    return `${commandContributorOrigin(contributor)}:${commandName}`;
+}
 /** Resolve a flat list of candidate contributions into a collision-resolved
- *  snapshot. Every contribution at a collided path is dropped (all claimants),
- *  an issue is recorded on each claimant, core names take precedence, and
- *  results are deterministically ordered by contributor name. */
+ *  snapshot. Plugin claimants at a collided path are qualified by origin and
+ *  kept; core names take precedence and are dropped. An issue is recorded on
+ *  every claimant, and results are deterministically ordered by contributor
+ *  name. */
 export function resolveCommandRegistry(candidates, reservedCoreNames) {
     const collisions = new Map();
     const contributionsByPath = new Map();
-    // Phase 1: Detect collisions. Collect every top-level path (and implicitly,
-    // every ancestor path that the top-level node reaches), detect duplicates.
-    // A collision drops ALL claimants at that path.
+    // Phase 1: Detect collisions. A core collision drops the plugin claimant;
+    // a cross-plugin collision qualifies every claimant in phase 2.
     for (const contrib of candidates) {
         const { node, contributor } = contrib;
         const path = [node.name];
@@ -54,8 +63,8 @@ export function resolveCommandRegistry(candidates, reservedCoreNames) {
             contributionsByPath.set(pathKey, contrib);
         }
     }
-    // Phase 2: Build the final snapshot. Include only non-collided contributions
-    // and record issues on all collided claimants.
+    // Phase 2: Build the final snapshot. Core collisions are dropped; plugin
+    // collisions keep every claimant under its origin-qualified command name.
     const accepted = [];
     const issues = [];
     for (const contrib of candidates) {
@@ -63,11 +72,11 @@ export function resolveCommandRegistry(candidates, reservedCoreNames) {
         if (collisions.has(pathKey)) {
             const collision = collisions.get(pathKey);
             const claimantNames = collision.claimants.map((c) => c.contributor.name).join(', ');
-            const claimantKinds = collision.claimants.map((c) => c.contributor.name).join(', ');
-            // Record an issue on this claimant. A core collision has exactly one
-            // claimant contesting a reserved built-in name, not "multiple contributors".
-            issues.push(collision.isCoreCollision
-                ? {
+            // A core collision has exactly one claimant contesting a reserved
+            // built-in name. Plugin collisions are informative: every claimant is
+            // retained under the source-qualified name reported here.
+            if (collision.isCoreCollision) {
+                issues.push({
                     code: 'command_collision',
                     contributor: contrib.contributor,
                     path: contrib.node.name,
@@ -75,16 +84,21 @@ export function resolveCommandRegistry(candidates, reservedCoreNames) {
                     received: claimantNames,
                     expected: 'no top-level command name matching a reserved core command',
                     next: `Rename "${contrib.node.name}" to a name that does not collide with core.`,
-                }
-                : {
+                });
+            }
+            else {
+                const qualifiedName = qualifiedTopLevelCommandName(contrib.contributor, contrib.node.name);
+                accepted.push({ ...contrib, node: { ...contrib.node, name: qualifiedName } });
+                issues.push({
                     code: 'command_collision',
                     contributor: contrib.contributor,
                     path: contrib.node.name,
-                    message: `top-level command "${contrib.node.name}" is claimed by multiple contributors: ${claimantKinds}`,
+                    message: `top-level command "${contrib.node.name}" is claimed by ${claimantNames} — mounted as "${qualifiedName}"`,
                     received: claimantNames,
-                    expected: 'exactly one contributor per top-level command',
-                    next: `Remove or disable all but one of: ${claimantNames}.`,
+                    expected: 'an origin-qualified top-level command for each claimant',
+                    next: `Invoke "${qualifiedName}" to use this plugin command.`,
                 });
+            }
         }
         else {
             // Not collided — accept it.

package/dist/core/command-plugins/compose.js

@@ -4,7 +4,7 @@ import { invokeHttpLeaf } from './transport/http-invoke.js';
 export function adaptPluginContributions(contributions) {
     return {
         contributions: contributions.map((contribution) => ({
-            contributor: { name: contribution.plugin.name, scope: contribution.plugin.scope },
+            contributor: { name: contribution.plugin.name, scope: contribution.plugin.scope, sourceMarketplace: contribution.plugin.sourceMarketplace },
             node: contribution.node,
             adaptLeaf: (leaf, commandPath) => {
                 const transport = contribution.transport;

package/dist/core/command-plugins/discovery.js

@@ -3,7 +3,7 @@ import { resolve, sep } from 'node:path';
 import { listInstalledPlugins, listInstalledPluginsInRoot } from '../resolver.js';
 import { projectScopeRoots } from '../scope.js';
 import { validateCommandManifest } from '../command-manifests/manifest.js';
-import { resolveCommandRegistry } from '../command-manifests/registry.js';
+import { qualifiedTopLevelCommandName, resolveCommandRegistry } from '../command-manifests/registry.js';
 import { adaptPluginContributions } from './compose.js';
 import { validateHttpPluginTransport } from './endpoint.js';
 export function effectiveCommandPlugins(startDir = process.cwd(), profileId) {
@@ -139,18 +139,26 @@ export function validateEffectiveCommandPlugins(reservedNames, startDir = proces
     const validations = effectiveCommandPlugins(startDir, profileId).map((plugin) => validatePluginCommands(plugin, reservedNames, coreCommandPaths));
     const claims = new Map();
     for (const validation of validations)
-        for (const contribution of validation.contributions)
-            (claims.get(contribution.node.name) ?? (claims.set(contribution.node.name, []), claims.get(contribution.node.name))).push(validation);
+        for (const contribution of validation.contributions) {
+            const claimants = claims.get(contribution.node.name);
+            if (claimants === undefined)
+                claims.set(contribution.node.name, [contribution]);
+            else
+                claimants.push(contribution);
+        }
     for (const [name, claimants] of claims)
         if (claimants.length > 1)
-            for (const validation of claimants) {
-                validation.contributions = validation.contributions.filter((contribution) => contribution.node.name !== name);
-                validation.issues.push({ code: 'command_collision', plugin: validation.plugin.name, path: name, message: `top-level command "${name}" is claimed by multiple plugins`, received: claimants.map((claimant) => claimant.plugin.name).join(', '), expected: 'exactly one plugin per top-level command name', next: 'Disable or remove all but one claimant.' });
+            for (const claimant of claimants) {
+                const { plugin } = claimant;
+                const qualifiedName = qualifiedTopLevelCommandName({ name: plugin.name, sourceMarketplace: plugin.sourceMarketplace }, name);
+                const validation = validations.find((candidate) => candidate.plugin.root === plugin.root);
+                validation.contributions = validation.contributions.map((contribution) => contribution === claimant ? { ...contribution, node: { ...contribution.node, name: qualifiedName } } : contribution);
+                validation.issues.push({ code: 'command_collision', plugin: plugin.name, path: name, message: `top-level command "${name}" is claimed by ${claimants.map((entry) => entry.plugin.name).join(', ')} — mounted as "${qualifiedName}"`, received: claimants.map((entry) => entry.plugin.name).join(', '), expected: 'an origin-qualified top-level command for each claimant', next: `Invoke "${qualifiedName}" to use this plugin command.` });
             }
     return validations;
 }
 function contributorIssue(plugin, issue) {
-    return { ...issue, contributor: { name: plugin.name, scope: plugin.scope } };
+    return { ...issue, contributor: { name: plugin.name, scope: plugin.scope, sourceMarketplace: plugin.sourceMarketplace } };
 }
 export function discoverCommandContributions(reservedNames, startDir = process.cwd(), profileId) {
     const validations = validateEffectiveCommandPlugins(reservedNames, startDir, profileId);

package/dist/core/keybindings/catalog.d.ts

@@ -1,6 +1,6 @@
 import type { BindingDefinition, SafetyRequirement } from './types.js';
 import type { AttachBindingId, AttachMenuBindingId } from './attach-control.js';
-type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'fold-tools' | 'metadata' | 'promote' | 'resume' | 'fork' | 'demote' | 'detach' | 'close-subtree' | 'background-bash' | 'file-review' | 'pin' | 'reload-viewer' | 'recap' | 'context' | 'providers' | 'graph' | 'focus-manager' | 'copy-id' | 'issues';
+type TmuxMenuAction = 'open' | 'attach' | 'show' | 'view-settings' | 'fold-tools' | 'metadata' | 'promote' | 'resume' | 'fork' | 'demote' | 'detach' | 'close-subtree' | 'background-bash' | 'file-review' | 'pin' | 'reload-viewer' | 'recap' | 'context' | 'providers' | 'plugins' | 'graph' | 'focus-manager' | 'copy-id' | 'issues';
 type TmuxMenuEntryAction = Exclude<TmuxMenuAction, 'open' | 'attach'> | `issue.${'idea' | 'bug'}`;
 type GraphAction = 'down' | 'up' | 'first' | 'last' | 'collapse-or-manager' | 'expand-or-child' | 'focus' | 'revive' | 'focus-manager' | 'close-subtree' | 'dismiss';
 type BrowseAction = 'quit' | 'down' | 'up' | 'first' | 'last' | 'expand-or-child' | 'collapse-or-parent' | 'toggle-fold' | 'tab-next' | 'tab-previous' | `tab.${1 | 2 | 3 | 4 | 5}` | 'close-subtree' | 'confirm-close' | 'sort' | 'scope' | 'profile' | 'residents' | 'preview' | 'search' | 'revive-now' | 'focus' | 'focus-background';

package/dist/core/keybindings/catalog.js

@@ -53,6 +53,7 @@ export const BINDING_CATALOG = Object.freeze([
     ...menuEntry('metadata', 'Show metadata', 'Show the focused node’s metadata dossier.', ['m'], ['tmux.menu.show']),
     ...menuEntry('context', 'Browse context', 'Browse the focused node context.', ['c'], ['tmux.menu.show']),
     ...menuEntry('providers', 'Open settings', 'Open the crouter settings panel.', [','], ['tmux.menu']),
+    ...menuEntry('plugins', 'Browse plugins', 'Open the crouter plugin browser.', ['k'], ['tmux.menu']),
     ...menuEntry('graph', 'Canvas graph', 'Open the canvas graph.', ['g'], ['tmux.menu']),
     ...menuEntry('focus-manager', 'Go to manager', 'Focus this node’s manager.', ['h'], ['tmux.menu']),
     ...menuEntry('copy-id', 'Copy node id', 'Copy the focused node id to the system clipboard.', ['y'], ['tmux.menu']),

package/dist/core/resolver.d.ts

@@ -8,7 +8,7 @@ export interface ParsedSkillQualifier {
     segments: string[];
 }
 export declare function parseSkillQualifier(raw: string): ParsedSkillQualifier;
-export declare function listInstalledMarketplaces(scope: Scope): InstalledMarketplace[];
+export declare function listInstalledMarketplaces(scope: Exclude<Scope, 'builtin'>): InstalledMarketplace[];
 export declare function listAllMarketplaces(): InstalledMarketplace[];
-export declare function findMarketplaceByName(name: string, scope?: Scope): InstalledMarketplace | null;
+export declare function findMarketplaceByName(name: string, scope?: Exclude<Scope, 'builtin'>): InstalledMarketplace | null;
 export declare function scopeRootsLabel(): string;

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/runtime/tmux-bindings.js

@@ -33,6 +33,7 @@ const LEAF_MENU_ACTIONS = {
     // The settings page lays out a grouped rail beside a content panel; the
     // default dialog-sized popup clipped both the rail and the models matrix.
     'crtr.tmux.menu.providers': { description: 'settings', action: { kind: 'popup', run: 'sys settings', size: { w: '90%', h: '85%' } } },
+    'crtr.tmux.menu.plugins': { description: 'plugins', action: { kind: 'popup', run: 'pkg browse', size: { w: '90%', h: '85%' } } },
     'crtr.tmux.menu.graph': { description: 'canvas graph', action: { kind: 'keys', keys: '/graph' } },
     'crtr.tmux.menu.focus-manager': { description: 'go to manager', action: { kind: 'command', run: 'surface node focus {manager}' } },
     'crtr.tmux.menu.copy-id': { description: 'copy node id', action: { kind: 'command', run: 'surface node id --pane {pane}' } },
@@ -301,6 +302,7 @@ function menuItems(bindings, entries) {
     ]));
     addGroup('System', boundItems([
         'crtr.tmux.menu.providers',
+        'crtr.tmux.menu.plugins',
         'crtr.tmux.menu.issues',
     ]));
     const prefixGestures = bindings.gestures('crtr.tmux.menu.open');

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 };
         }