@crouton-kit/crouter 0.3.32 → 0.3.33

package/dist/pi-extensions/canvas-stophook.js

@@ -31,6 +31,8 @@ import { join } from 'node:path';
 import { getNode, jobDir, updateNode, recordPid, setPresence } from '../core/canvas/index.js';
 import { transition } from '../core/runtime/lifecycle.js';
 import { markBusy, clearBusy } from '../core/runtime/busy.js';
+import { recordFault, clearFault } from '../core/runtime/fault.js';
+import { classify } from '../core/fault-classifier.js';
 import { evaluateStop } from '../core/runtime/stop-guard.js';
 import { personaDrift, commitPersonaAck } from '../core/runtime/persona.js';
 import { handleNewSession, relaunchRoot, markCleanExitDone } from '../core/runtime/reset.js';
@@ -277,8 +279,10 @@ export function registerCanvasStophook(pi) {
             if (event?.reason === 'new') {
                 try {
                     const m = getNode(nodeId);
+                    // relaunchRoot is async now; the enclosing sync catch can't catch its
+                    // rejection, so swallow it here to keep `/new` best-effort.
                     if (m?.parent == null)
-                        relaunchRoot(nodeId);
+                        void relaunchRoot(nodeId).catch(() => { });
                     else
                         handleNewSession(nodeId, id, sessionFile);
                 }
@@ -316,6 +320,8 @@ export function registerCanvasStophook(pi) {
     // rather than reaping it. Cleared at the top of agent_end (turn over).
     // ---------------------------------------------------------------------------
     pi.on('agent_start', () => {
+        // A fresh turn started. Keep any active fault marker in place so the daemon's
+        // retry accounting survives a failed retry cycle; just mark the turn busy.
         try {
             markBusy(nodeId);
         }
@@ -334,6 +340,30 @@ export function registerCanvasStophook(pi) {
         catch { /* best-effort */ }
     });
     // ---------------------------------------------------------------------------
+    // tool_execution_end — IMMEDIATE refresh-yield. When a tool this turn set
+    // intent='refresh' (the node ran `crtr node yield`), shut the broker down NOW
+    // instead of letting the model keep burning its bloated context to the turn's
+    // natural end (agent_end branch (b') would only catch it there). The yield
+    // command persists the yield-message + any roadmap checkpoint BEFORE it
+    // returns, so by the time this fires nothing is lost. ctx.shutdown() disposes
+    // the session (aborting the live turn) and exits 0; the daemon then sees the
+    // dead pid + intent='refresh' and revives the node FRESH against its roadmap.
+    // intent only flips to 'refresh' via `node yield`, so this can't false-fire.
+    // (A node that somehow boots already carrying intent='refresh' correctly
+    // refreshes on its first tool — the desired outcome.)
+    pi.on('tool_execution_end', (_event, ctx) => {
+        try {
+            if (getNode(nodeId)?.intent === 'refresh') {
+                clearBusy(nodeId); // agent_end won't run to clear it; harmless if it lingers
+                try {
+                    ctx?.shutdown?.();
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* best-effort */ }
+    });
+    // ---------------------------------------------------------------------------
     // session_shutdown — clean exit → done.
     //
     // pi hands us a reason as a session tears down. Only 'quit' is a node-ending
@@ -349,6 +379,7 @@ export function registerCanvasStophook(pi) {
     pi.on('session_shutdown', (event, _ctx) => {
         try {
             clearBusy(nodeId); // turn marker is meaningless once pi is exiting
+            clearFault(nodeId); // ditto the active fault marker
             // Clean /quit (reason='quit') resolves the node to done; if it held the
             // user's viewport, Q1-close it (tearDownNode kills the frozen focus pane +
             // closes the focus row → returns the user to a shell, §1.5/flow (e)). pi is
@@ -453,8 +484,28 @@ export function registerCanvasStophook(pi) {
             const last = lastAssistantMessage(messages);
             const stopReason = last?.stopReason ?? '';
             // (a) Interrupted or errored — stay alive so the user can re-steer.
-            if (stopReason !== 'stop' && stopReason !== 'length')
+            //     When the engine EXHAUSTED its retry budget (stopReason 'error', NOT
+            //     a human Esc 'aborted'), record an active fault BEFORE the return so
+            //     the canvas graph views can surface the parked window.
+            if (stopReason !== 'stop' && stopReason !== 'length') {
+                if (stopReason === 'error') {
+                    try {
+                        const raw = last?.errorMessage ?? 'engine error (no errorMessage recorded)';
+                        const classified = classify('pi→provider', raw);
+                        recordFault(nodeId, {
+                            link: 'pi→provider',
+                            op: 'generation turn',
+                            kind: classified.kind,
+                            retry: classified.disposition === 'auto' ? { disposition: 'auto', by: 'daemon' } : { disposition: classified.disposition },
+                            message: raw,
+                            logPath: join(jobDirPath, 'broker.log'),
+                            anchorEntryId: ctx.sessionManager.getLeafId?.() ?? undefined,
+                        });
+                    }
+                    catch { /* best-effort */ }
+                }
                 return;
+            }
             // (b) Already done: `crtr push --final` was called this turn, which
             //     transitions node.status → 'done' synchronously. Shut down cleanly.
             const node = getNode(nodeId);
@@ -464,6 +515,10 @@ export function registerCanvasStophook(pi) {
                 // this node's VIEWER pane (if any) and shut the broker down. The daemon
                 // won't revive a done node. tearDownNode closes the viewer focus row +
                 // pane; ctx.shutdown() exits the broker process.
+                try {
+                    clearFault(nodeId);
+                }
+                catch { /* best-effort */ }
                 if (focusOf(nodeId) !== null) {
                     try {
                         tearDownNode(nodeId);
@@ -477,12 +532,16 @@ export function registerCanvasStophook(pi) {
                 catch { /* ignore */ }
                 return;
             }
-            // (b') Refresh-yield: the node ran `crtr node yield` this turn, setting
-            //     intent='refresh'. Just shut the broker down — the daemon sees the
-            //     dead pid + intent='refresh' and reviveNode's relaunches the broker
-            //     FRESH (no resume) so the node re-reads its roadmap. (The daemon
-            //     also force-recycles a stuck refresh whose engine never exits, so a
-            //     stale in-process stophook can't strand the yield — see crtrd.)
+            // (b') Refresh-yield BACKSTOP: the node ran `crtr node yield` this turn,
+            //     setting intent='refresh'. The primary exit is the tool_execution_end
+            //     handler above, which shuts down the instant the yield tool returns
+            //     (so the model never burns more context finishing the turn); this
+            //     branch only fires if that shutdown was missed. Either way: shut the
+            //     broker down — the daemon sees the dead pid + intent='refresh' and
+            //     reviveNode relaunches the broker FRESH (no resume) so the node
+            //     re-reads its roadmap. (The daemon also force-recycles a stuck
+            //     refresh whose engine never exits, so a stale in-process stophook
+            //     can't strand the yield — see crtrd.)
             if (node?.intent === 'refresh') {
                 // A yield is SILENT to subscribers: the node keeps its identity and
                 // subscription edges across the revive and reports only through its own
@@ -505,11 +564,19 @@ export function registerCanvasStophook(pi) {
                 // followUp: the turn just ended but pi may still be flushing, so an
                 // unqualified sendUserMessage races with 'already processing'.
                 pi.sendUserMessage(decision.message, { deliverAs: 'followUp' });
+                try {
+                    clearFault(nodeId);
+                }
+                catch { /* best-effort */ }
                 return;
             }
-            // 'allow' — the node legitimately stopped. Nothing is pushed here; any
-            // report it owed its subscribers was sent by an explicit `crtr push`
-            // during the turn.
+            // 'allow' — the node legitimately stopped. The active-fault marker can
+            // clear now; any report it owed its subscribers was sent by an explicit
+            // `crtr push` during the turn.
+            try {
+                clearFault(nodeId);
+            }
+            catch { /* best-effort */ }
             //
             // Idle-release: a node awaiting its workers (reason 'awaiting') is holding
             // a tmux window for nothing. Free it — mark it idle-released and shut pi

package/dist/types.d.ts

@@ -8,7 +8,7 @@ export declare const ExitCode: {
     readonly NETWORK: 5;
 };
 export type ExitCodeValue = (typeof ExitCode)[keyof typeof ExitCode];
-export declare const SCHEMA_VERSION = 2;
+export declare const SCHEMA_VERSION = 4;
 export interface OwnerRef {
     name?: string;
     email?: string;
@@ -50,10 +50,27 @@ export interface AutoUpdateConfig {
     content: AutoUpdateMode;
     interval_hours: number;
 }
-/** One canvas-nav action binding: a `crtr` argv string (templated with
- *  {id|self|name|manager|subtree}) plus optional confirm gate + menu label.
- *  `run` of the sentinel `__graph__` toggles the in-pi GRAPH modal instead of
- *  shelling a command. */
+export type CanvasAction = {
+    kind?: 'crtr';
+    run: string;
+    confirm?: boolean;
+} | {
+    kind: 'keys';
+    keys: string;
+} | {
+    kind: 'menu';
+    items: CanvasMenuItem[];
+} | {
+    kind: 'popup';
+    run: string;
+};
+export interface CanvasMenuItem {
+    key: string;
+    desc: string;
+    action: CanvasAction;
+    confirm?: boolean;
+}
+/** Legacy GRAPH bind shape; retained for graphBinds only. */
 export interface CanvasBind {
     run: string;
     confirm?: boolean;
@@ -68,10 +85,21 @@ export interface CanvasNavConfig {
     /** Fallback pi shortcut for GRAPH toggle when NOT in tmux. Default 'alt+g'. */
     prefixKey?: string;
     /** chord key (after alt+c) → action; tmux-menu layer. */
-    prefixBinds: Record<string, CanvasBind>;
+    prefixBinds: Record<string, CanvasAction & {
+        desc?: string;
+    }>;
     /** extra raw key in GRAPH → action; pi-extension layer (additive only). */
     graphBinds: Record<string, CanvasBind>;
 }
+export type ModelStrength = 'ultra' | 'strong' | 'medium' | 'light';
+export type ModelProvider = 'anthropic' | 'openai';
+export interface ModelLaddersConfig {
+    /** Optional default provider for bare strengths. If unset, runtime falls back
+     *  to CRTR_MODEL_PROVIDER, then anthropic. */
+    defaultProvider?: ModelProvider;
+    anthropic: Record<ModelStrength, string>;
+    openai: Record<ModelStrength, string>;
+}
 export interface ScopeConfig {
     schema_version: number;
     marketplaces: Record<string, ConfigMarketplaceEntry>;
@@ -79,6 +107,8 @@ export interface ScopeConfig {
     auto_update: AutoUpdateConfig;
     max_panes_per_window: number;
     canvasNav: CanvasNavConfig;
+    modelLadders: ModelLaddersConfig;
+    personaStrengths: Record<string, ModelStrength>;
 }
 export interface ScopeState {
     marketplaces: Record<string, {
@@ -90,15 +120,6 @@ export interface ScopeState {
     last_self_check?: string;
     bootstrap_done?: boolean;
 }
-export declare const SKILL_TYPES: readonly ["playbook", "primer", "reference", "runbook", "freeform"];
-export type SkillType = (typeof SKILL_TYPES)[number];
-export declare function isSkillType(v: unknown): v is SkillType;
-export interface SkillFrontmatter {
-    name: string;
-    description?: string;
-    keywords?: string[];
-    type?: SkillType;
-}
 export interface SubagentFrontmatter {
     name: string;
     description?: string;
@@ -144,14 +165,12 @@ export declare const MARKETPLACE_MANIFEST_FILE = "marketplace.json";
 export declare const CRTR_DIR_NAME = ".crouter";
 export declare const CONFIG_FILE = "config.json";
 export declare const STATE_FILE = "state.json";
-export declare const SKILL_ENTRY_FILE = "SKILL.md";
-export declare const SKILLS_DIR = "skills";
 export declare const AGENTS_DIR = "agents";
 export declare const DEFAULT_MAX_PANES_PER_WINDOW = 3;
 export declare function defaultScopeConfig(): ScopeConfig;
 /** Built-in canvas-nav binds so an absent config still gives the intended UX.
- *  prefixBinds: g→GRAPH toggle (sentinel), m→focus manager.
- *  1..9 (focus report N) are generated by the menu layer, not literal entries.
- *  graphBinds: empty — built-in GRAPH keys are reserved, custom keys add on. */
+ *  prefixBinds restate the current menu defaults; graphBinds stay empty.
+ */
 export declare function defaultCanvasNavConfig(): CanvasNavConfig;
+export declare function defaultModelLaddersConfig(): ModelLaddersConfig;
 export declare function defaultScopeState(): ScopeState;

package/dist/types.js

@@ -6,11 +6,7 @@ export const ExitCode = {
     AMBIGUOUS: 4,
     NETWORK: 5,
 };
-export const SCHEMA_VERSION = 2;
-export const SKILL_TYPES = ['playbook', 'primer', 'reference', 'runbook', 'freeform'];
-export function isSkillType(v) {
-    return typeof v === 'string' && SKILL_TYPES.includes(v);
-}
+export const SCHEMA_VERSION = 4;
 export const PLUGIN_MANIFEST_DIR = '.crouter-plugin';
 export const PLUGIN_MANIFEST_FILE = 'plugin.json';
 export const MARKETPLACE_MANIFEST_DIR = '.crouter-marketplace';
@@ -18,10 +14,8 @@ export const MARKETPLACE_MANIFEST_FILE = 'marketplace.json';
 export const CRTR_DIR_NAME = '.crouter';
 export const CONFIG_FILE = 'config.json';
 export const STATE_FILE = 'state.json';
-export const SKILL_ENTRY_FILE = 'SKILL.md';
-export const SKILLS_DIR = 'skills';
 // Subagent definitions live as flat `<name>.md` files under `<root>/agents/`,
-// for both scope roots and plugins. Mirrors SKILLS_DIR.
+// for both scope roots and plugins.
 export const AGENTS_DIR = 'agents';
 export const DEFAULT_MAX_PANES_PER_WINDOW = 3;
 export function defaultScopeConfig() {
@@ -32,22 +26,53 @@ export function defaultScopeConfig() {
         auto_update: { crtr: 'notify', content: 'notify', interval_hours: 24 },
         max_panes_per_window: DEFAULT_MAX_PANES_PER_WINDOW,
         canvasNav: defaultCanvasNavConfig(),
+        modelLadders: defaultModelLaddersConfig(),
+        personaStrengths: {},
     };
 }
 /** Built-in canvas-nav binds so an absent config still gives the intended UX.
- *  prefixBinds: g→GRAPH toggle (sentinel), m→focus manager.
- *  1..9 (focus report N) are generated by the menu layer, not literal entries.
- *  graphBinds: empty — built-in GRAPH keys are reserved, custom keys add on. */
+ *  prefixBinds restate the current menu defaults; graphBinds stay empty.
+ */
 export function defaultCanvasNavConfig() {
     return {
         prefixKey: 'alt+g',
         prefixBinds: {
-            g: { run: '__graph__', desc: 'graph view' },
-            m: { run: 'node focus {manager}', desc: 'focus manager' },
+            o: { kind: 'keys', keys: '/promote', desc: 'promote to orchestrator' },
+            r: { kind: 'keys', keys: '/resume-node', desc: 'resume node' },
+            d: { kind: 'crtr', run: 'node demote --pane {pane}', desc: 'demote to terminal' },
+            D: { kind: 'crtr', run: 'node demote --pane {pane} --detach', desc: 'detach to background' },
+            x: { kind: 'crtr', run: 'node close --pane {pane}', desc: 'close agent + subtree' },
+            c: { kind: 'keys', keys: '/context', desc: 'browse context dirs' },
+            g: { kind: 'keys', keys: '/graph', desc: 'graph view' },
+            m: { kind: 'crtr', run: 'node focus {manager}', desc: 'focus manager' },
+            i: {
+                kind: 'menu',
+                desc: 'new issue / todo',
+                items: [
+                    { key: 'i', desc: 'idea', action: { kind: 'popup', run: 'canvas issue new --type idea' } },
+                    { key: 'b', desc: 'bug', action: { kind: 'popup', run: 'canvas issue new --type bug' } },
+                ],
+            },
         },
         graphBinds: {},
     };
 }
+export function defaultModelLaddersConfig() {
+    return {
+        anthropic: {
+            ultra: 'anthropic/claude-fable-5:high',
+            strong: 'anthropic/claude-opus-4-8:high',
+            medium: 'anthropic/claude-sonnet-4-6:high',
+            light: 'anthropic/claude-haiku-4-5:high',
+        },
+        openai: {
+            ultra: 'openai-codex/gpt-5.5:xhigh',
+            strong: 'openai-codex/gpt-5.5:high',
+            medium: 'openai-codex/gpt-5.5:medium',
+            light: 'openai-codex/gpt-5.3-codex-spark',
+        },
+    };
+}
 export function defaultScopeState() {
     return { marketplaces: {}, plugins: {} };
 }

package/dist/web/runtime.js

@@ -2,22 +2,11 @@
 // view. It is what <ViewPane>/useViewCore (ViewPane.tsx) are built from.
 //
 // createViewStore() seeds state from core.init, builds the IntentCtx
-// (set/resolve/execute/signal/dispatch) over the HTTP transport (→ the local
-// bridge), runs the dispatch loop with the busy-guarded refreshMs auto-poll, and
-// exposes a tiny external-store surface (subscribe/getVersion) the React layer
-// binds via useSyncExternalStore. The core it drives is byte-identical to the
-// TUI's; only the injected Transport differs.
-//
-// THE TAP: dispatch calls `onIntent(name, payload, state)` BEFORE delegating to
-// core.intents[name]. This is the host-level pre-dispatch hook the shell uses to
-// observe/intercept semantic intents (e.g. canvas `activate` → open a
-// conversation). When onIntent is undefined the loop is byte-identical to the
-// pre-shell behavior — a view in a ViewPane is unaware it is in a shell.
-//
-// THE SEAM (Wave 3): store.refresh() forces an immediate, busy-guarded refresh.
-// It is both the auto-poll callback AND the entry point the shell calls when an
-// SSE `/__crtr/events` invalidation arrives — event-driven refresh with no
-// contract change (the view still just runs its `refresh` intent).
+// (set/resolve/execute/signal/dispatch/connect) over the HTTP transport, runs
+// the dispatch loop with the busy-guarded refreshMs auto-poll, and exposes a
+// tiny external-store surface (subscribe/getVersion) the React layer binds via
+// useSyncExternalStore. The core it drives is byte-identical to the TUI's; only
+// the injected Transport differs.
 import { initialChrome } from '../core/view/chrome.js';
 import { createHttpTransport } from './transport-http.js';
 /** Build the running store for one view (its core + the HTTP transport). The
@@ -25,7 +14,8 @@ import { createHttpTransport } from './transport-http.js';
  *  and re-renders off subscribe/getVersion; this factory is React-free. */
 export function createViewStore(core, opts = {}) {
     const transport = createHttpTransport(opts.endpoint);
-    let state = core.init(Object.freeze({ ...(opts.options ?? {}) }));
+    const initOptions = Object.freeze({ ...(opts.options ?? {}) });
+    let state = core.init(initOptions);
     let chrome = initialChrome();
     let onIntentTap = opts.onIntent;
     // External store: a version counter the React tree subscribes to. state and
@@ -45,6 +35,13 @@ export function createViewStore(core, opts = {}) {
         // Web has no pane to leave; closing the tab is up to the user. No-op.
         quit: () => { },
     };
+    const streams = new Set();
+    let generation = 0;
+    let started = false;
+    let timer = null;
+    let busyDepth = 0;
+    let drainingQueue = false;
+    let dispatchQueue = [];
     const makeCtx = () => ({
         get state() { return state; },
         set(next) {
@@ -59,20 +56,87 @@ export function createViewStore(core, opts = {}) {
             const raw = await transport.send(command.request(args));
             return command.parse(raw);
         },
+        connect(source, args) {
+            const capturedGeneration = generation;
+            let channel;
+            channel = transport.open(source.request(args), {
+                onFrame(frame) {
+                    if (capturedGeneration !== generation)
+                        return;
+                    void enqueueDispatch(source.onFrame, frame);
+                },
+                onClose(reason) {
+                    if (capturedGeneration !== generation)
+                        return;
+                    streams.delete(channel);
+                    if (source.onClose)
+                        void enqueueDispatch(source.onClose, { reason, channelId: channel.id });
+                },
+                onError(err) {
+                    if (capturedGeneration !== generation)
+                        return;
+                    setChrome({ banner: { msg: err.display.headline, level: err.display.level } });
+                },
+            });
+            streams.add(channel);
+            if (source.onOpen)
+                void enqueueDispatch(source.onOpen, channel);
+            return channel;
+        },
         signal,
-        dispatch,
+        dispatch(intent, payload) {
+            return runIntent(intent, payload);
+        },
     });
-    // busyDepth counts in-flight async intents — it drives the "working" chip /
-    // spinner. It is NOT itself the single-flight lane; the auto-poll guards on it
-    // (refresh() below) so a bridge slower than refreshMs can never stack
-    // overlapping refreshes that race on ctx.set. The first completed *refresh*
-    // marks the view loaded (ready vs idle in deriveState) — a non-refresh async
-    // intent before that must not flip the chip to ready.
-    let busyDepth = 0;
-    async function dispatch(intent, payload) {
-        // THE TAP — the shell observes (and may act on) every intent against a
-        // snapshot of state BEFORE the view's own handler runs. Standalone (no tap)
-        // this is a no-op and the loop is byte-identical to the pre-shell behavior.
+    function scheduleDrain() {
+        if (drainingQueue)
+            return;
+        drainingQueue = true;
+        void drainQueue();
+    }
+    async function drainQueue() {
+        try {
+            while (started && dispatchQueue.length > 0) {
+                if (busyDepth > 0)
+                    return;
+                const job = dispatchQueue.shift();
+                try {
+                    await runIntent(job.intent, job.payload);
+                    job.resolve();
+                }
+                catch (err) {
+                    job.reject(err);
+                }
+            }
+        }
+        finally {
+            drainingQueue = false;
+            if (started && dispatchQueue.length > 0 && busyDepth === 0)
+                scheduleDrain();
+        }
+    }
+    function enqueueDispatch(intent, payload) {
+        if (!started)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            dispatchQueue.push({ intent, payload, resolve, reject });
+            scheduleDrain();
+        });
+    }
+    function settleAfterIntent(intentName) {
+        if (intentName === 'refresh') {
+            chrome = { ...chrome, busy: busyDepth > 0, loaded: true, lastRefresh: Date.now() };
+            emit();
+            return;
+        }
+        chrome = { ...chrome, busy: busyDepth > 0 };
+        emit();
+    }
+    async function runIntent(intent, payload) {
+        if (!started) {
+            // The store is stopped; ignore stray external work.
+            return;
+        }
         onIntentTap?.(intent, payload, state);
         const fn = core.intents[intent];
         if (!fn) {
@@ -80,48 +144,83 @@ export function createViewStore(core, opts = {}) {
             console.warn(`[crtr view] unknown intent: ${intent}`);
             return;
         }
-        const result = fn(makeCtx(), payload);
+        let result;
+        try {
+            result = fn(makeCtx(), payload);
+        }
+        catch (e) {
+            // eslint-disable-next-line no-console
+            console.warn(`[crtr view] intent ${intent} threw:`, e);
+            throw e;
+        }
         if (result instanceof Promise) {
+            const wasBusy = busyDepth > 0;
             busyDepth += 1;
-            setChrome({ busy: true });
+            if (!wasBusy)
+                setChrome({ busy: true });
             try {
                 await result;
             }
             finally {
                 busyDepth -= 1;
-                const loaded = chrome.loaded || intent === 'refresh';
-                chrome = { ...chrome, busy: busyDepth > 0, loaded, lastRefresh: Date.now() };
+                chrome = { ...chrome, busy: busyDepth > 0, loaded: chrome.loaded || intent === 'refresh', lastRefresh: Date.now() };
                 emit();
+                if (busyDepth === 0 && started && dispatchQueue.length > 0)
+                    scheduleDrain();
             }
+            return;
         }
+        settleAfterIntent(intent);
     }
-    // Auto-poll cadence guard AND the shell's invalidate seam: skip while any
-    // async intent is still in flight so refreshes never stack.
-    const refresh = () => { if (busyDepth === 0)
-        void dispatch('refresh'); };
-    let started = false;
-    let timer = null;
+    const refresh = () => {
+        if (busyDepth === 0)
+            void enqueueDispatch('refresh');
+    };
     function start() {
         if (started)
             return;
         started = true;
-        // init → render (the React layer) → first refresh, then optional auto-poll.
-        void dispatch('refresh');
+        generation += 1;
+        state = core.init(initOptions);
+        chrome = initialChrome();
+        dispatchQueue = [];
+        drainingQueue = false;
+        void enqueueDispatch('refresh');
         const cadence = core.manifest.refreshMs;
         if (typeof cadence === 'number' && cadence > 0)
             timer = setInterval(refresh, cadence);
     }
     function stop() {
+        if (!started)
+            return;
         started = false;
+        generation += 1;
+        const openChannels = Array.from(streams);
+        for (const channel of openChannels) {
+            try {
+                channel.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        streams.clear();
         if (timer) {
             clearInterval(timer);
             timer = null;
         }
+        if (dispatchQueue.length > 0) {
+            const err = new Error('view stopped');
+            for (const job of dispatchQueue)
+                job.reject(err);
+            dispatchQueue = [];
+        }
+        drainingQueue = false;
     }
     return {
         getState: () => state,
         getChrome: () => chrome,
-        dispatch,
+        dispatch: enqueueDispatch,
         refresh,
         subscribe,
         getVersion: () => version,

package/dist/web/transport-http.js

@@ -1,8 +1,7 @@
-// transport-http.ts — the browser-side Transport. Posts a view's declarative
-// SourceRequest to the local bridge server (`crtr view serve`'s /__crtr/source)
-// and returns the RawResponse the bridge ran on its behalf. This is the ONE
-// seam a cloud deploy swaps: point the endpoint at a real backend and the same
-// browser bundle resolves sources against it, no core change.
+// transport-http.ts — the browser-side Transport. send() posts declarative
+// SourceRequests to the local bridge server (`crtr view serve`'s /__crtr/source)
+// and open() connects browser stream requests to the same-origin WS relay.
+import { openBrowserStream } from './transport-stream.js';
 /** Browser Transport → POST <endpoint> {SourceRequest} → RawResponse. Never
  *  throws: a network/bridge failure becomes a transport-level RawResponse
  *  (ok:false + stderr), exactly like the local transport's spawn failures. */
@@ -24,5 +23,8 @@ export function createHttpTransport(endpoint = '/__crtr/source') {
                 return { ok: false, stdout: '', stderr: e instanceof Error ? e.message : String(e) };
             }
         },
+        open(req, handlers) {
+            return openBrowserStream(req, handlers);
+        },
     };
 }

package/dist/web/transport-stream.d.ts

@@ -0,0 +1,3 @@
+import type { StreamRequest, StreamChannel } from '../core/view/contract.js';
+import type { StreamHandlers } from '../core/view/transport.js';
+export declare function openBrowserStream(req: StreamRequest, handlers: StreamHandlers): StreamChannel;