@north-light/crouter 0.3.173 → 0.3.175

package/dist/core/runtime/broker-extension-render.js

@@ -0,0 +1,181 @@
+// Pure broker-side render adapters. crtrd supplies the fixed extension-state
+// DTO; these functions only combine it with node-local/filesystem information.
+import { contextDir, nodeDir } from '../canvas/paths.js';
+import { execSync, spawnSync } from 'node:child_process';
+import { readdirSync } from 'node:fs';
+import { hostname } from 'node:os';
+import { interpolateNodePaths } from '../canvas/paths.js';
+import { fullName } from '../canvas/labels.js';
+import { renderKnowledgeForSubject, renderPreferencesForSubject } from '../substrate/render.js';
+import { renderWorkspaceOpenDocsForSubject } from '../substrate/on-read-pure.js';
+import { loadProfileManifest } from '../profiles/manifest.js';
+export function editorLabelForBrokerNode(node) {
+    const icon = (node.icon ?? '').trim();
+    const handle = node.name !== node.kind ? node.name.trim() : '';
+    const name = handle !== '' ? handle : (node.description ?? '').trim() || node.name;
+    return icon === '' ? name : `${icon} ${name}`;
+}
+function command(cwd, text) {
+    try {
+        return execSync(text, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** Same environment-only project context rendered at normal boot, without a
+ * canvas import. */
+export function buildProjectContextBlockForBroker(cwd) {
+    let listing;
+    try {
+        const entries = readdirSync(cwd, { withFileTypes: true }).sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || a.name.localeCompare(b.name));
+        const shown = entries.slice(0, 50).map((entry) => `${entry.name}${entry.isDirectory() ? '/' : ''}`);
+        listing = entries.length > shown.length ? [...shown, `[+${entries.length - shown.length} more]`] : shown;
+    }
+    catch {
+        listing = ['Directory listing: unavailable (cwd missing or unreadable).'];
+    }
+    const tmux = spawnSync('tmux', ['list-sessions'], { encoding: 'utf8', stdio: 'ignore' }).status === 0;
+    let git = 'Git: not a git repository.';
+    let worktrees = 'Worktrees: none.';
+    if (command(cwd, 'git rev-parse --is-inside-work-tree') !== '') {
+        const branch = command(cwd, 'git branch --show-current') || command(cwd, 'git rev-parse --abbrev-ref HEAD') || 'HEAD';
+        const sha = command(cwd, 'git rev-parse --short HEAD') || 'unknown';
+        const changes = command(cwd, 'git status --porcelain').split('\n').filter(Boolean).length;
+        const raw = command(cwd, 'git worktree list --porcelain').split('\n');
+        const found = [];
+        let path = '';
+        let wtBranch = 'detached HEAD';
+        for (const line of raw) {
+            if (line.startsWith('worktree ')) {
+                if (path !== '')
+                    found.push(`${path} (${wtBranch})`);
+                path = line.slice(9);
+                wtBranch = 'detached HEAD';
+            }
+            else if (line.startsWith('branch '))
+                wtBranch = line.slice(7).replace(/^refs\/heads\//, '');
+        }
+        if (path !== '')
+            found.push(`${path} (${wtBranch})`);
+        git = `Git: ${branch} @ ${sha}; ${changes === 0 ? 'clean' : `${changes} uncommitted change${changes === 1 ? '' : 's'}`}; ${found.length} worktree${found.length === 1 ? '' : 's'}.`;
+        worktrees = found.length === 0 ? 'Worktrees: none.' : `Worktrees: ${found.join(', ')}`;
+    }
+    return `<project_context>\n\n<environment cwd="${cwd.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;')}">\nHost: ${process.platform} ${process.arch} · ${hostname()} · node ${process.version} · tmux server: ${tmux ? 'reachable' : 'none'}\nDirectory:\n${listing.map((line) => `  ${line}`).join('\n')}\n${git}\n${worktrees}\n</environment>\n</project_context>`;
+}
+function contextDirNote(nodeId) {
+    return `Your context directory is \`${contextDir(nodeId)}\` (also in the env as \`$CRTR_CONTEXT_DIR\`) — durable scratch space on disk, and the one place the other nodes on the canvas can read from. Put documents here that you want to share by reference instead of re-explaining them in a prompt: specs, designs, findings, notes worth pointing a sibling, child, or parent at. It is a shared document store, not a task tracker. **Address it by absolute path** — write artifacts as \`$CRTR_CONTEXT_DIR/<name>.md\` (or the full path above). Your working dir is the project, NOT this directory, so a bare relative \`context/...\` lands in the repo, not here — and other nodes can only read what is actually here. When you report a file, report its absolute path.`;
+}
+function profileNote(node) {
+    if (node.profile_id === null || node.profile_id === '')
+        return '';
+    try {
+        const entry = loadProfileManifest(node.profile_id);
+        if (entry.manifest.projects.length === 0)
+            return '';
+        return `Your working dir is \`${node.cwd}\`. Your profile **${entry.manifest.name}** also has purview over: ${entry.manifest.projects.join(', ')}.`;
+    }
+    catch {
+        return '';
+    }
+}
+function relativeLabel(node) {
+    const desc = fullName(node);
+    const descPart = desc !== '' && desc !== node.kind && desc !== node.name ? ` — ${desc}` : '';
+    return `${node.node_id} (${node.kind} · ${node.status})${descPart}`;
+}
+function graphMap(state) {
+    const { ancestors, children, node } = state;
+    if (ancestors.length === 0 && children.length === 0)
+        return '';
+    const indent = (depth) => '  '.repeat(depth);
+    const lines = ['Your place in the canvas graph (ancestry above you, your direct children below):'];
+    ancestors.forEach((ancestor, index) => lines.push(`${indent(index)}${index === 0 ? '' : '└ '}${relativeLabel(ancestor)}`));
+    const depth = ancestors.length;
+    lines.push(`${indent(depth)}${depth === 0 ? '' : '└ '}● you: ${node.node_id} (${node.kind}, ${node.mode})`);
+    const shown = children.slice(0, 5);
+    shown.forEach((child, index) => lines.push(`${indent(depth + 1)}${index === shown.length - 1 && children.length === shown.length ? '└ ' : '├ '}${relativeLabel(child)}`));
+    if (children.length > shown.length)
+        lines.push(`${indent(depth + 1)}└ +${children.length - shown.length} more`);
+    return lines.join('\n');
+}
+function identity(state) {
+    const { node, fork_source: source } = state;
+    const lines = [`You are node ${node.node_id} — kind ${node.kind}, mode ${node.mode}.`];
+    if (node.fork_from !== null && node.fork_from !== '') {
+        const sourceLabel = source === null ? node.fork_from : `${node.fork_from} ("${fullName(source)}")`;
+        lines.push('', `You are a new FORK of ${sourceLabel}, not ${sourceLabel}. Pi copied the earlier conversation into this session. Treat that first-person history as reference material, not your own past.`);
+    }
+    return lines.join('\n');
+}
+function worktreeNote(node) {
+    const worktree = node.managed_worktree;
+    if (worktree === null || worktree === undefined || worktree.state !== 'open')
+        return '';
+    return `Branch: \`${worktree.branch}\`\nWorktree: \`${worktree.path}\`\nBase: \`${worktree.base_ref}\` @ \`${worktree.base_sha}\`\nCommit work here. Land it with \`crtr node worktree close\` before finishing. Auto-drop applies only when the worktree is clean (no uncommitted changes) and nothing remains to land (zero commits ahead of the base, or its commits are already contained in the base); unlanded commits (commits not already contained in the base) or uncommitted changes require an explicit close/landing decision.`;
+}
+function reviewNote(node) {
+    const review = node.review_binding;
+    if (review === null || review === undefined)
+        return '';
+    return `You exist for one human review of \`${review.target_file}\`. The inherited conversation belongs to the origin node, not you — carry only the context needed for this review. The person's visible transcript begins at the boundary marker above; everything earlier is context they cannot see.`;
+}
+export function buildContextBearingsFromState(state, projectContext, situational = '') {
+    const { node } = state;
+    const bearings = ['<crtr-bearings>', identity(state)];
+    const map = graphMap(state);
+    if (map !== '')
+        bearings.push('', '## Your place in the canvas', map);
+    bearings.push('', '## Your context directory', contextDirNote(node.node_id));
+    const profile = profileNote(node);
+    if (profile !== '')
+        bearings.push('', profile);
+    const worktree = worktreeNote(node);
+    if (worktree !== '')
+        bearings.push('', '## Your managed worktree', worktree);
+    if (node.mode === 'orchestrator')
+        bearings.push('', `Because you persist across refresh cycles, your context directory (${contextDir(node.node_id)}) is also where a future cycle of you resumes the work — keep the working notes and decisions a refreshed you would need there, alongside the docs you share with the nodes you spawn.`);
+    bearings.push('</crtr-bearings>');
+    const knowledge = renderKnowledgeForSubject(state.subject, node.node_id);
+    const workspace = renderWorkspaceOpenDocsForSubject(state.subject, node.cwd, node.profile_id);
+    return [bearings.join('\n'), knowledge, workspace, situational, projectContext].filter((part) => part !== '').join('\n');
+}
+export function buildForkBearingsFromState(state, situational = '') {
+    const { node, fork_source: source } = state;
+    const bearings = ['<crtr-bearings>', identity(state), '', 'The source node’s earlier task, graph position, lifecycle, children, schedules, worktree, situational context, and context-directory path do not carry over. Shared conversation, project, and operating context remain reference material.', '', '## Your node now', `Lifecycle: ${node.lifecycle}.`];
+    const map = graphMap(state);
+    bearings.push(...(map === '' ? ['Canvas: independent root with no parent or inherited graph edges.'] : ['', map]));
+    bearings.push(`Context directory: \`${contextDir(node.node_id)}\` (\`$CRTR_CONTEXT_DIR\`). Use this path in place of every source-node context path above.`);
+    if (source === null || source.cwd !== node.cwd)
+        bearings.push(`Working directory: \`${node.cwd}\`.`);
+    if (source === null || source.profile_id !== node.profile_id) {
+        const profile = profileNote(node);
+        if (profile !== '')
+            bearings.push(profile);
+    }
+    const worktree = worktreeNote(node);
+    if (worktree !== '')
+        bearings.push('', '## Your managed worktree', worktree);
+    if (node.mode === 'orchestrator')
+        bearings.push('', `Because you persist across refresh cycles, your context directory (${contextDir(node.node_id)}) is also where a future cycle of you resumes the work — keep the working notes and decisions a refreshed you would need there, alongside the docs you share with the nodes you spawn.`);
+    const review = reviewNote(node);
+    if (review !== '')
+        bearings.push('', review);
+    bearings.push('', 'The first real user message after these bearings is your mandate.', '</crtr-bearings>');
+    return [bearings.join('\n'), situational].filter((part) => part !== '').join('\n');
+}
+export function renderPreferencesFromState(state) {
+    return interpolateNodePaths(renderPreferencesForSubject(state.subject).block, state.node.node_id);
+}
+/** A canonical report ref has already been validated by crtrd in state. The
+ * broker reads only its local filesystem content; no canvas accessor is needed. */
+export function reportPathFromRef(ref, reportNodes) {
+    const separator = ref.indexOf(':');
+    if (separator <= 0)
+        return null;
+    const nodeId = ref.slice(0, separator);
+    const relpath = ref.slice(separator + 1);
+    if (!reportNodes.has(nodeId) || !relpath.startsWith('reports/') || relpath.includes('..') || relpath.startsWith('/'))
+        return null;
+    return `${nodeDir(nodeId)}/${relpath}`;
+}

package/dist/core/runtime/broker-persona-guidance.d.ts

@@ -0,0 +1,13 @@
+import type { BrokerExtensionNodeDTO } from '../../api/dto/broker-ops.js';
+export interface BrokerPersona {
+    mode: 'base' | 'orchestrator';
+    lifecycle: 'terminal' | 'resident';
+}
+export interface BrokerPersonaDrift {
+    from: BrokerPersona;
+    to: BrokerPersona;
+    guidance: string;
+}
+export declare function transitionGuidanceFromBrokerState(node: BrokerExtensionNodeDTO, from: BrokerPersona, to: BrokerPersona): string;
+/** Return an unacknowledged persona transition from crtrd's fixed extension state. */
+export declare function personaDriftFromBrokerState(node: BrokerExtensionNodeDTO): BrokerPersonaDrift | null;

package/dist/core/runtime/broker-persona-guidance.js

@@ -0,0 +1,58 @@
+// Broker-local persona transition guidance. Canvas state is supplied by crtrd;
+// this module reads only the node's own roadmap and durable memory files.
+import { resolveMemoryDoc } from '../memory-resolver.js';
+import { contextDir } from '../canvas/paths.js';
+import { readRoadmap, roadmapPath } from './roadmap.js';
+function loadMemoryBody(name) {
+    try {
+        return resolveMemoryDoc(name).body.trim();
+    }
+    catch {
+        return '';
+    }
+}
+function orchestratorContextNote(nodeId) {
+    return `Because you persist across refresh cycles, your context directory (${contextDir(nodeId)}) is also where a future cycle of you resumes the work — keep the working notes and decisions a refreshed you would need there, alongside the docs you share with the nodes you spawn.`;
+}
+function orchestrationGuidance(node) {
+    const kernel = loadMemoryBody('orchestration-kernel');
+    const roadmap = readRoadmap(node.node_id) ?? '(no roadmap yet)';
+    const rmPath = roadmapPath(node.node_id);
+    return [
+        `You are now a ${node.kind.toUpperCase()} ORCHESTRATOR. Your scarce resource is your own context window.`,
+        'Your job is to manage context and delegate — not to do the goal yourself.',
+        '',
+        kernel,
+        '',
+        `Your roadmap scaffold (\`${rmPath}\`) — author it now: state the goal, exit criteria, and the phase skeleton, using the approach above. Current contents:`,
+        '',
+        roadmap,
+        '',
+        orchestratorContextNote(node.node_id),
+        '',
+        'Your three long-term memory scopes (user-global, project, node-local) already surface in your bearings at boot. What promotion changes is USE, not access: you now persist across refresh cycles, so node-local carries what THIS goal needs between your refreshes, and durable facts you commit to user-global or project outlive this node. Use `crtr memory write` to save a document; `crtr memory list` to browse; `crtr memory find` to search (see "Your long-term memory" above for the full substrate flow).',
+        '',
+        'Then delegate each phase with `crtr node new --kind <kind>`. When your context fills, run `crtr node yield` to refresh against this roadmap.',
+    ].join('\n');
+}
+function baseModeGuidance() {
+    return 'You are HANDS-ON again — base mode. Do the work yourself in THIS window and finish it here; stop delegating by default. You no longer drive a roadmap, so `crtr node yield` is not your exit. Spawn a child only for a cleanly separable unit, never as your first move.';
+}
+export function transitionGuidanceFromBrokerState(node, from, to) {
+    const sections = [];
+    if (from.mode !== to.mode) {
+        sections.push(to.mode === 'orchestrator' ? orchestrationGuidance(node) : baseModeGuidance());
+    }
+    if (from.lifecycle !== to.lifecycle) {
+        sections.push(loadMemoryBody(to.lifecycle === 'resident' ? 'lifecycle/resident' : 'lifecycle/terminal'));
+    }
+    return sections.join('\n\n');
+}
+/** Return an unacknowledged persona transition from crtrd's fixed extension state. */
+export function personaDriftFromBrokerState(node) {
+    const to = { mode: node.mode, lifecycle: node.lifecycle };
+    const from = node.persona_ack ?? to;
+    if (from.mode === to.mode && from.lifecycle === to.lifecycle)
+        return null;
+    return { from, to, guidance: transitionGuidanceFromBrokerState(node, from, to) };
+}

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

@@ -61,7 +61,7 @@ export interface HelloFrame {
     type: 'hello';
     role: ClientRole;
     client_id: string;
-    /** Terminal geometry of a tmux-pane viewer; absent for a browser/headless. */
+    /** Terminal geometry of a tmux-pane viewer; absent for a headless client. */
     term?: {
         cols: number;
         rows: number;

package/dist/core/runtime/broker-protocol.js

@@ -1,7 +1,7 @@
 // broker-protocol.ts — the client↔broker wire protocol for the headless node
 // Surface (design §5.2). Pure types + a newline-delimited JSON codec; no I/O, no
 // SDK construction. Consumed by the broker (src/core/runtime/broker.ts) and, in
-// Phase 4, by the `crtr surface attach` terminal client and the surface web bridge.
+// Phase 4, by the `crtr surface attach` terminal client and crtrd's attach bridge.
 //
 // The transport is one unix socket per node (`nodeDir(id)/view.sock`) speaking
 // newline-delimited JSON frames. Live engine events are relayed VERBATIM — the

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

@@ -1,204 +1,14 @@
-import { type Socket } from 'node:net';
-import { type AgentSessionRuntime, type AgentSessionServices, type CreateAgentSessionResult, type ExtensionUIContext, type PromptOptions } from '@earendil-works/pi-coding-agent';
-import { type ImageContent } from '@earendil-works/pi-ai';
+import { type AgentSessionRuntime, type AgentSessionServices, type CreateAgentSessionResult, type ExtensionUIContext } from '@earendil-works/pi-coding-agent';
 import { type BrokerSdkConfig } from './launch.js';
 import { type BrokerEngine } from './broker-sdk.js';
 import { type KnownStreamWaitControl } from './stream-watchdog.js';
-import { FrameDecoder, type BrokerSnapshot, type BrokerToClient, type ClientRole, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from './broker-protocol.js';
+import { type BrokerClient } from './broker/client-registry.js';
+import { type BrokerSnapshot, type BrokerToClient, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from './broker-protocol.js';
 /** A review companion may only navigate or fork within a branch whose ancestry
  * has crossed its durable transcript boundary. The broker sends this typed local
  * failure as a dedicated error frame without invoking pi's tree mutation. */
-export declare const REVIEW_BOUNDARY_NAVIGATION_CODE = "review_boundary_navigation";
-export declare class ReviewBoundaryNavigationError extends Error {
-    readonly targetId: string;
-    readonly code = "review_boundary_navigation";
-    constructor(targetId: string);
-}
-/**
- * The pinned pi SDK never yields `session.model === undefined` for a model-less
- * boot: Agent.createMutableAgentState() falls back to a hardcoded
- * `{ provider:'unknown', id:'unknown', api:'unknown', … }` stub (DEFAULT_MODEL)
- * whenever no model is supplied at construction, and `session.model` returns it
- * verbatim. This mirrors the SDK's own (non-exported) interactive-mode.js
- * `isUnknownModel()` so the broker recognizes that stub as "no model" wherever it
- * guards the model-less launch path (kickoff deferral, reload_auth re-drive) and
- * refuses to record/broadcast it as a real `unknown/unknown` model.
- */
-export declare function isUnknownModel(model: {
-    provider?: string;
-    id?: string;
-    api?: string;
-} | null | undefined): boolean;
-/**
- * Route a writable client's `prompt`/`follow_up` frame against the LIVE session
- * state. The client picks its frame type off a possibly-STALE `isStreaming`
- * snapshot, so the broker is authoritative and the client's choice is a HINT:
- *
- *  - m-B (streaming-safe prompt): a `prompt` arriving mid-stream needs
- *    PromptOptions.streamingBehavior ("Required if streaming"; prompt() throws
- *    without it). "steer" mirrors pi interactive-mode's own
- *    Enter-while-streaming submit (`prompt(text, { streamingBehavior: "steer" })`).
- *  - m-C (idle-safe follow_up): pi's followUp() only enqueues into a RUNNING
- *    agent loop — on an idle session nothing ever drains the queue and the text
- *    is silently lost. An idle `follow_up` therefore runs as a prompt now.
- *
- * driveEngine calls this synchronously with `session.isStreaming`, so the
- * routed state cannot go stale between the check and the engine call.
- * C1: images ride as a field on PromptOptions (pi: `prompt(text, { images })`).
- */
-export declare function resolveEngineRoute(frame: {
-    type: 'prompt' | 'follow_up';
-    images?: ImageContent[];
-}, isStreaming: boolean): {
-    call: 'prompt';
-    options: PromptOptions;
-} | {
-    call: 'followUp';
-};
-/**
- * True iff `text` would be consumed by pi's OWN leading-name preflight before
- * `session.prompt/steer/followUp` ever sees it as prose — an extension command
- * (`session.extensionRunner.getCommand`), a `/skill:name` skill, or a `/name`
- * prompt template (mirrors `_tryExecuteExtensionCommand` / `_expandSkillCommand`
- * / `expandPromptTemplate` in the pinned SDK verbatim, including the exact
- * name-parsing substrings). Inline memory-reference guidance must NEVER fire
- * for these — the leading token routes to the engine's own command surface,
- * not prose referencing a memory doc. Each lookup is independently wrapped so
- * an engine missing one accessor (the fake, or a degraded session) degrades
- * that check to "not a match" rather than aborting the whole classification —
- * matching `buildCommandList`'s existing "no live extensionRunner" tolerance.
- */
-export declare function isLeadingEngineCommand(text: string, session: {
-    extensionRunner?: {
-        getCommand(name: string): unknown;
-    };
-    resourceLoader?: {
-        getSkills(): {
-            skills: Array<{
-                name: string;
-            }>;
-        };
-    };
-    promptTemplates?: ReadonlyArray<{
-        name: string;
-    }>;
-}): boolean;
-/** A `steer` frame normally maps directly to pi's steer queue. Engine commands,
- * skills, and templates must instead pass through prompt()'s leading-command
- * preflight; with streamingBehavior:'steer', ordinary expanded text still lands
- * in the same queue. */
-export declare function resolveSteerCall(text: string, session: Parameters<typeof isLeadingEngineCommand>[1]): 'prompt' | 'steer';
-/**
- * Enumerate every leading-token STRING this session's engine would
- * independently consume as a leading command/skill/template dispatch BEFORE
- * inline memory-reference guidance ever applies — the read-op sibling of
- * `isLeadingEngineCommand`'s point-lookup, gathered as a full enumeration for
- * viewer-side suppression instead of a per-submission membership check. Same
- * three sources, same shape of the leading match `isLeadingEngineCommand`
- * checks (bare extension-command invocation names and prompt-template names,
- * `skill:<name>` for skills), so `/${token}` round-trips through
- * `isLeadingEngineCommand(text, session)` for every emitted token (locked by
- * a test). Kept STRICTLY separate from `buildCommandList` (command
- * completion) and the ref inventory (`RefMeta` rows) — this is neither.
- */
-export declare function engineLeadingCommandTokens(session: {
-    extensionRunner?: {
-        getRegisteredCommands(): Array<{
-            invocationName: string;
-        }>;
-    };
-    resourceLoader?: {
-        getSkills(): {
-            skills: Array<{
-                name: string;
-            }>;
-        };
-    };
-    promptTemplates?: ReadonlyArray<{
-        name: string;
-    }>;
-}): string[];
-/**
- * Choose how the hidden `crtr-memory-refs` guidance custom message rides
- * alongside a human frame's own engine call (design Flow B). Pure over the
- * frame's routing outcome — never reads live session state itself, so a
- * caller can decide the delivery mode from the exact same `route`
- * `resolveEngineRoute` already computed for the human call.
- *
- *  - `steer` frame              -> 'steer' (always; no route call exists).
- *  - a TRUE mid-stream follow_up (`routeCall === 'followUp'`) -> 'followUp'.
- *  - every other `prompt`/`follow_up` routed as `routeCall === 'prompt'`:
- *    idle -> 'nextTurn' (the ONLY case guidance precedes the human call —
- *    pi's `prompt()` reads+clears its pending-nextTurn queue synchronously
- *    into the SAME turn as the new user message); streaming (m-B
- *    steer-while-streaming) -> 'steer', never 'nextTurn' (that would attach
- *    to a later, unrelated turn).
- */
-export declare function chooseGuidanceDeliveryMode(frameType: 'prompt' | 'follow_up' | 'steer', routeCall: 'prompt' | 'followUp' | undefined, isStreaming: boolean): 'steer' | 'followUp' | 'nextTurn';
-/**
- * Deliver a `nextTurn` guidance custom message ATOMICALLY around the idle-
- * prompt call it's meant to ride alongside. Pi's `_pendingNextTurnMessages`
- * queue (the only public seam for `deliverAs:'nextTurn'`) is drained ONLY deep
- * inside `session.prompt()`, well after several await points — extension-
- * command interception, the `input` extension transform, a streaming reroute,
- * model/auth validation, pre-turn compaction — that can return or throw BEFORE
- * the drain ever runs. `sendCustomMessage`'s nextTurn branch pushes
- * synchronously and unconditionally, so any of those early exits strands the
- * pushed guidance in the queue to attach itself to whichever LATER, unrelated
- * prompt happens to reach the drain first.
- *
- * There is no public SDK seam to observe or cancel a pending nextTurn message
- * (`_pendingNextTurnMessages` is TS-`private` only — a plain runtime field, not
- * `#private`), so this reaches into that one field and removes EXACTLY the
- * entry this call pushed, identified by object identity via a locally-
- * generated marker riding the message's own `details` field (never surfaced to
- * the model, and irrelevant if the message WAS consumed normally — `details`
- * is just carried through like any other field once folded into a real turn).
- * Runs UNCONDITIONALLY after the human call settles, success or failure/early-
- * return alike — a "successful" `prompt()` promise can just as easily be an
- * early return that skipped the drain (an intercepted extension command, an
- * `input` transform, a streaming reroute) as a genuine consumed turn, so only
- * checking `.catch` is not enough.
- */
-export declare function promptWithNextTurnGuidance(session: {
-    sendCustomMessage(message: {
-        customType: string;
-        content: unknown;
-        display?: boolean;
-        details?: unknown;
-    }, options?: {
-        deliverAs?: 'steer' | 'followUp' | 'nextTurn';
-    }): Promise<void>;
-}, guidance: string, runPrompt: () => Promise<void>): Promise<void>;
-/** True iff a parsed JSONL branch-entry line is a hidden (`display:false`)
- *  custom message — the general display boundary crossed if left in an
- *  exported branch (not just `crtr-memory-refs` guidance; any hidden custom
- *  content). Covers both persisted shapes a branch entry can take: a
- *  `type:'custom_message'` entry (display at the entry's own top level) and a
- *  `type:'message'` entry wrapping a `role:'custom'` message (display nested
- *  under `.message`). */
-export declare function isHiddenJsonlBranchEntry(entry: unknown): boolean;
-/** Rewrite an already-exported JSONL file in place, dropping every hidden
- *  (`display:false`) branch entry while re-chaining `parentId` so the
- *  remaining entries stay a single valid linear branch — applying the general
- *  display:false boundary to `session.exportToJsonl`'s own output, which
- *  serializes every entry verbatim regardless of display. The header line
- *  (line 1) is copied through untouched. */
-export declare function stripHiddenEntriesFromJsonlExport(filePath: string): void;
-interface BrokerClient {
-    id: string;
-    role: ClientRole;
-    socket: Socket;
-    decoder: FrameDecoder;
-    helloed: boolean;
-    /** Unflushed outbound bytes handed to `socket.write` but not yet flushed to the
-     *  OS (M1 backpressure accounting). Incremented before each write, decremented
-     *  in that write's completion callback. */
-    pendingBytes: number;
-    /** Outbound frames written but not yet flushed (the queue-depth half of the
-     *  high-water mark). */
-    queuedFrames: number;
-}
+export { ReviewBoundaryNavigationError, REVIEW_BOUNDARY_NAVIGATION_CODE } from './broker/frame-dispatch.js';
+export type { SubscriptionGeneration } from './broker/rebind.js';
 /** A blocking dialog awaiting a response from ANY writable client, the
  *  broker-side default timeout, or the engine's abort. The dialog is fanned out
  *  to every writable client at raise time; this entry is the single settlement
@@ -252,4 +62,3 @@ export interface BrokerDialogDeps {
     onKnownStreamWait?: KnownStreamWaitControl;
 }
 export declare function makeBrokerUiContext(deps: BrokerDialogDeps): ExtensionUIContext;
-export {};