@itookit/dsht 0.3.8 → 0.5.2

package/dist/controller/commands.js

@@ -0,0 +1,322 @@
+import { LOOP_USAGE } from "../slash/index.js";
+import { errorText } from "../transport/wire.js";
+import { loopProtocolFor, loopProtocolNames, loopRecordVars } from "./loop-protocols.js";
+import { resolveLoop } from "./loop.js";
+/** An accepted line: apply these effects in order, then clear the draft. */
+function ok(effects) {
+    return { disposition: 'consume', outcome: 'ok', effects };
+}
+/** A refusal the operator can read; the draft — and any form on screen — stays where it is.
+ *
+ * A line that never ran does not rearrange the screen: closing panels is a view transition belonging
+ * to a command that executed, and doing it here would throw away a form the reader is still editing
+ * (the `/loop` parameter form is the case that found this).
+ * @param text - Failure line, applied last so the other effects cannot replace it.
+ * @param effects - What else to do first, when a caller really does want a surface closed.
+ */
+function refused(text, effects = []) {
+    return { disposition: 'retain', outcome: 'rejected', effects: [...effects, { kind: 'error', text }] };
+}
+/** An operation the caller aborted (Esc): nothing to show, and nothing to clear. */
+function cancelled() {
+    return { disposition: 'retain', outcome: 'cancelled', effects: [] };
+}
+/** One cancellable port call, reporting whether the caller aborted it.
+ *
+ * `undefined` from the port means "no value" for two different reasons, and the result type must not
+ * confuse them: a refusal to start is not an interruption the operator caused.
+ */
+async function runCancellable(port, label, operation) {
+    let signal;
+    const value = await port.run(label, inner => { signal = inner; return operation(inner); });
+    return { value, cancelled: value === undefined && signal?.aborted === true };
+}
+/** Resolve a removal into either a finished removal or the confirmation the UI must show.
+ *
+ * Shared by the `/ws --delete`/`/resume --delete` commands and the pickers' `d` key, so the
+ * empty-session rule has one implementation.
+ * @param controller - Application facade the removal acts on.
+ * @param kind - Workspace registration or session archival.
+ * @param query - Exact name, ID, or unambiguous ID prefix.
+ * @returns The effects to apply, or undefined when the target could not be resolved.
+ */
+export async function removalIntent(controller, kind, query) {
+    const target = await controller.actions.removalTarget(kind, query);
+    if (target === undefined)
+        return undefined;
+    // An empty session carries no history, so it is archived without a review step.
+    if (target.kind === 'session' && target.empty) {
+        if (!await controller.actions.removeTarget(target))
+            return undefined;
+        return [{ kind: 'closePanels' }];
+    }
+    return [{ kind: 'closePanels' }, { kind: 'open', panel: 'removal' }, { kind: 'removal', removal: target }];
+}
+/** Run one submitted line and describe what it did and what the front end must show.
+ *
+ * This is the single entry point every front end uses — the composer and the scripted startup runner
+ * alike — so one line has one effect and one trace span wherever it came from.
+ * @param controller - Application facade the command acts on.
+ * @param command - Executable line; the front-end modes (`ignore`, `reference`) never reach here.
+ * @param port - Cancellable-operation port supplied by the caller.
+ * @returns The result, or undefined when the application did not accept the line.
+ */
+export async function runCommand(controller, command, port) {
+    // A finished run's progress line is a result the reader may still be reading; running this line means
+    // they are done with it. A run that is still active is never dropped here, so `/loop answer` and
+    // `/loop stop` keep their target — and this runs before the line's own effects, so the line that
+    // ends a run still leaves its terminal progress on screen to be read.
+    controller.actions.clearLoopResult();
+    // One span per executed line, with the id every other event of this line can name. The begin is
+    // written before any effect, so a crash mid-command still shows that the executor was entered.
+    const commandId = controller.nextCommandId();
+    controller.traceNote('command', { phase: 'begin', commandId, kind: command.kind });
+    // What the action envelope said before this line ran: a failure it records during the line is this
+    // line's own, and the result below is where the operator reads it.
+    const envelopeBefore = controller.state.lastFailure;
+    let result;
+    try {
+        result = await execute(controller, command, port);
+    }
+    catch (error) {
+        // The end must be written whatever happened, or one begin would never have its end.
+        controller.traceNote('command', { phase: 'end', commandId, kind: command.kind, outcome: 'failed',
+            disposition: 'retain', error: errorText(error).slice(0, 200) });
+        throw error;
+    }
+    // The end is the one place that answers "how did this line end", whatever the command, so no command
+    // has to invent its own outcome name — and the outcome here is the same fact the reader is shown.
+    const failure = result?.effects.find(effect => effect.kind === 'error');
+    controller.traceNote('command', { phase: 'end', commandId, kind: command.kind,
+        outcome: result?.outcome ?? 'refused', disposition: result?.disposition ?? 'retain',
+        ...(failure?.kind === 'error' ? { error: failure.text.slice(0, 200) } : {}) });
+    // One fact, one channel (13.2-D2): a failure this line already reported in its result must not stay
+    // in the action envelope and be shown a second time in the status bar. An unaccepted line keeps it —
+    // there the envelope is the only explanation the operator has.
+    if (result !== undefined && result.outcome !== 'ok' && controller.state.lastFailure !== envelopeBefore) {
+        controller.actions.clearFailure();
+    }
+    return result;
+}
+/** Dispatch one executable line to its application policy.
+ *
+ * Every branch is application policy: which action to call, which notice to show, and which panel the
+ * result belongs to. The `ui` layer only applies the returned effects to component state.
+ * @param controller - Application facade the command acts on.
+ * @param command - Executable line.
+ * @param port - Cancellable-operation port supplied by the caller.
+ * @returns The result, or undefined when the application did not accept the line.
+ */
+async function execute(controller, command, port) {
+    switch (command.kind) {
+        case 'quit': return ok([{ kind: 'quit' }]);
+        // Copy mode freezes the display, so panels are deliberately left as they are.
+        case 'copy': return ok([{ kind: 'copy' }]);
+        case 'panel': {
+            // The cost panel is the one panel whose rows are a host request. Opening it starts that request
+            // here, where the effect lives, rather than in the front end: the UI only shows its loading label.
+            if (command.panel === 'cost') {
+                void port.run('Refreshing costs…', signal => controller.actions.refreshCosts(signal)).catch(() => undefined);
+            }
+            return ok([{ kind: 'closePanels' }, { kind: 'toggle', panel: command.panel }]);
+        }
+        case 'remove': {
+            const effects = await removalIntent(controller, command.target, command.query);
+            return effects === undefined ? undefined : ok(effects);
+        }
+        case 'navigate': {
+            const accepted = command.target === 'workspace'
+                ? await controller.actions.switchWorkspace(command.query)
+                : await controller.actions.switchSession(command.query);
+            return accepted ? ok([{ kind: 'closePanels' }, { kind: 'scroll', position: 0 }]) : undefined;
+        }
+        case 'path':
+            return await controller.actions.createWorkspace(command.value) ? ok([{ kind: 'closePanels' }]) : undefined;
+        case 'latest':
+            return ok([{ kind: 'closePanels' }, { kind: 'live' }, { kind: 'pinLive' }, { kind: 'resetFolds' }, { kind: 'scroll', position: 0 }]);
+        case 'models': {
+            if (!command.args.length) {
+                const catalog = await controller.actions.modelCatalog();
+                return catalog === undefined ? undefined : ok([{ kind: 'closePanels' }, { kind: 'model', model: { catalog } }]);
+            }
+            const accepted = await controller.actions.selectModel(command.args[0], command.args[1], command.args[2]);
+            return accepted ? ok([{ kind: 'closePanels' }, { kind: 'close', panel: 'model' }]) : undefined;
+        }
+        case 'queue': return ok([{ kind: 'closePanels' }, { kind: 'open', panel: 'queue' }]);
+        case 'prompts': return ok([{ kind: 'closePanels' }, { kind: 'open', panel: 'prompts' }]);
+        case 'savePrompt':
+            return await controller.actions.savePrompt(command.text)
+                ? ok([{ kind: 'closePanels' }, { kind: 'notice', text: 'Saved prompt' }]) : undefined;
+        case 'shell':
+            controller.shell.start(command.command);
+            return ok([{ kind: 'closePanels' }, { kind: 'scroll', position: 0 }]);
+        case 'newSession':
+            return await controller.actions.createSession() ? ok([{ kind: 'closePanels' }]) : undefined;
+        case 'history':
+            return ok([{ kind: 'closePanels' }, { kind: 'history', history: { query: command.query, contentSearch: false } }]);
+        case 'sessionSearch': {
+            const { value: result, cancelled: aborted } = await runCancellable(port, 'Searching sessions…', signal => controller.actions.searchSessions(command.query, command.command === '/ssearch', signal));
+            if (result === undefined)
+                return aborted ? cancelled() : undefined;
+            return ok([{ kind: 'closePanels' }, { kind: 'search', search: { query: command.query, ...result } }]);
+        }
+        case 'historySearch': {
+            const { value: matches, cancelled: aborted } = await runCancellable(port, 'Searching history…', signal => controller.actions.searchHistory(command.query, signal));
+            if (matches === undefined)
+                return aborted ? cancelled() : undefined;
+            return ok([{ kind: 'closePanels' }, { kind: 'history', history: { query: command.query, contentSearch: true, matches } }]);
+        }
+        case 'think': {
+            if (command.target === 'live') {
+                return ok([{ kind: 'closePanels' }, { kind: 'toggleLiveReasoning' }, { kind: 'scroll', position: 0 }]);
+            }
+            if (!command.target)
+                return ok([{ kind: 'closePanels' }, { kind: 'open', panel: 'thoughts' }]);
+            const seq = Number(command.target);
+            const transcript = controller.queries.window ?? controller.queries.record;
+            if (!Number.isSafeInteger(seq) || !transcript.thoughts.some(entry => entry.seq === seq)) {
+                throw new Error('Use /think <message sequence> for a loaded reasoning block');
+            }
+            return ok([{ kind: 'closePanels' }, { kind: 'toggleFold', seq }]);
+        }
+        case 'older': {
+            const accepted = await controller.actions.older(undefined, controller.queries.window ?? controller.queries.record);
+            return accepted ? ok([{ kind: 'closePanels' }, { kind: 'scrollBy', delta: 10 }]) : undefined;
+        }
+        case 'compact': {
+            const { value: text, cancelled: aborted } = await runCancellable(port, 'Compacting history…', signal => controller.actions.command('/compact', signal));
+            if (text === undefined)
+                return aborted ? cancelled() : undefined;
+            return ok([{ kind: 'closePanels' }, { kind: 'notice', text }]);
+        }
+        case 'cancel':
+            return await controller.actions.cancelTurn() ? ok([{ kind: 'closePanels' }]) : undefined;
+        case 'approval':
+            return await controller.actions.approve(command.allowed) ? ok([{ kind: 'closePanels' }]) : undefined;
+        case 'hostCommand': {
+            const { value: text, cancelled: aborted } = await runCancellable(port, 'Running command…', signal => controller.actions.command(command.line, signal));
+            if (text === undefined)
+                return aborted ? cancelled() : undefined;
+            return ok([{ kind: 'closePanels' }, { kind: 'notice', text }]);
+        }
+        case 'export': {
+            const { value: saved, cancelled: aborted } = await runCancellable(port, 'Exporting session log…', signal => controller.actions.exportLog(command.destination, signal));
+            if (saved === undefined)
+                return aborted ? cancelled() : undefined;
+            return ok([{ kind: 'closePanels' }, { kind: 'notice', text: `Saved session log: ${saved}` }]);
+        }
+        case 'exportHtml': {
+            const { value: saved, cancelled: aborted } = await runCancellable(port, 'Exporting loaded conversation…', signal => controller.actions.exportHtml(command.destination, signal));
+            if (saved === undefined)
+                return aborted ? cancelled() : undefined;
+            return ok([{ kind: 'closePanels' }, { kind: 'notice', text: `Saved loaded conversation: ${saved}` }]);
+        }
+        case 'coredump': {
+            // V8 serializes the heap synchronously, so the client stalls until the file is written.
+            let saved = '';
+            await port.run('Writing heap snapshot…', async () => { saved = controller.actions.heapSnapshot(command.tag); });
+            return ok([{ kind: 'closePanels' }, { kind: 'notice', text: `Heap snapshot saved: ${saved}` }]);
+        }
+        case 'answer': {
+            // The application completes the question waterfall itself, so a line that answers one never
+            // leaves the front end to call `answer` on its own.
+            const accepted = await controller.actions.answerQuestion({ custom: command.text });
+            return accepted ? ok([{ kind: 'closePanels' }]) : undefined;
+        }
+        case 'error': return refused(command.message);
+        case 'prompt': {
+            const accepted = await controller.actions.prompt(command.text);
+            return accepted ? ok([{ kind: 'closePanels' }, { kind: 'live' }, { kind: 'scroll', position: 0 }]) : undefined;
+        }
+        case 'handoff': {
+            if (!await controller.actions.handoff())
+                return undefined;
+            return ok([{ kind: 'closePanels' }, { kind: 'live' }, { kind: 'scroll', position: 0 },
+                { kind: 'notice', text: 'Handoff requested · local HANDOFF.md cleared' }]);
+        }
+        case 'loops':
+            // The record list is a composer surface the UI offers while the name is typed; a line that
+            // still reaches here has nobody to choose for it, so it is told to name one.
+            return refused(`Use /loop <name> · available: ${loopProtocolNames().join(', ')}`);
+        case 'loopAnswer': {
+            const progress = controller.queries.loop;
+            const interaction = progress?.interaction;
+            // The answer only means something to a judgment that asked for one; a host question is answered
+            // in its own dialog, and a rejected send retries on its own. Saying which is which beats a
+            // command that appears to do nothing.
+            if (progress === undefined || !progress.active || progress.phase !== 'needs-human' || interaction?.kind !== 'verdict') {
+                return refused(interaction === undefined
+                    ? 'No loop is waiting for an answer'
+                    : `This run is waiting for a ${interaction.kind}: ${interaction.text} · answer it, or /loop abort`);
+            }
+            const accepted = await controller.actions.answerLoop(command.text);
+            return accepted
+                ? ok([{ kind: 'closePanels' }, { kind: 'live' }, { kind: 'scroll', position: 0 },
+                    { kind: 'notice', text: `Answer added · re-judging step ${progress.step}` }])
+                : undefined;
+        }
+        case 'loopStop': {
+            // Stopping is a control command, so it is answered from the application's own view of the run
+            // rather than refused when nothing runs; a no-op that says so beats silence.
+            const progress = controller.queries.loop;
+            if (progress === undefined || !progress.active)
+                return ok([{ kind: 'closePanels' }, { kind: 'notice', text: 'No loop is running' }]);
+            controller.actions.stopLoop();
+            return ok([{ kind: 'closePanels' }, { kind: 'live' }, { kind: 'scroll', position: 0 },
+                { kind: 'notice', text: `Loop stopped · ${progress.title}` }]);
+        }
+        case 'loop': {
+            // One command for every record: the name is looked up here, where the records are known, so
+            // the syntax layer never needs a table of protocols and a new record needs no code at all.
+            controller.traceNote('loop', { phase: 'command', name: command.name, interactive: port.interactive === true,
+                flags: Object.keys(command.options).filter(key => key !== 'vars'), vars: Object.keys(command.options.vars ?? {}) });
+            const declared = loopRecordVars(command.name);
+            if (declared === undefined) {
+                controller.traceNote('loop', { phase: 'rejected', name: command.name, reason: 'unknown-record' });
+                return refused(`Unknown loop record: ${command.name} · available: ${loopProtocolNames().join(', ')}`);
+            }
+            // A record variable only exists if the record declares it; retargeting is not a place to guess.
+            const vars = command.options.vars ?? {};
+            const unknown = Object.keys(vars).filter(name => !(name in declared));
+            if (unknown.length) {
+                const names = Object.keys(declared);
+                controller.traceNote('loop', { phase: 'rejected', name: command.name, reason: 'unknown-vars', vars: unknown });
+                return refused(`Unknown loop variable: ${unknown.join(', ')}`
+                    + ` · ${command.name} accepts: ${names.length ? names.join(', ') : 'none'}`);
+            }
+            // Any value the operator already chose — a flag, or a variable the form confirmed — means the
+            // decision is made; only a bare known record leaves every default open for the form.
+            const decided = command.options.from !== undefined || command.options.to !== undefined
+                || command.options.score !== undefined || command.options.tries !== undefined
+                || Object.keys(vars).length > 0;
+            if (port.interactive === true && !decided) {
+                controller.traceNote('loop', { phase: 'form', name: command.name });
+                return ok([{ kind: 'closePanels' }, { kind: 'loop', loop: { name: command.name } }]);
+            }
+            const protocol = loopProtocolFor(command.name, controller.queries.forkedVerification, vars, controller.queries.selfScoring);
+            if (protocol === undefined)
+                return refused(LOOP_USAGE);
+            const limits = resolveLoop(protocol, command.options);
+            if (limits === undefined)
+                return refused(LOOP_USAGE);
+            if (!await controller.actions.startLoop(protocol, limits)) {
+                // `startLoop` already traced its own refusal; this turns the same fact into something the
+                // operator can read, instead of a form that appears to ignore Start. The form stays on screen
+                // so the values can be retried.
+                const why = controller.state.lastFailure
+                    || (controller.state.online ? 'the host did not accept the request' : 'the client is offline');
+                controller.traceNote('loop', { phase: 'not-started', name: command.name, why: why.slice(0, 200) });
+                return refused(`Loop did not start: ${why}`);
+            }
+            // The run leaves a bar in the transcript where it started, so the loop is readable in place and
+            // the bar can open the verification session this run is using (`Controller.createVerifierSession`).
+            // A record that starts by verifying (`starts: verify`) already created that session inside
+            // `startLoop`, so the bar takes the newest one now and later checks re-point it through `link`.
+            const checking = controller.queries.sources.find(source => source.createdBy === 'verifier' && source.state === 'running');
+            controller.shell.note(`/loop ${command.name} ${limits.from}–${limits.to} · pass ${limits.score} · ≤${limits.tries} tries`, checking?.id);
+            return ok([{ kind: 'closePanels' }, { kind: 'live' }, { kind: 'scroll', position: 0 },
+                { kind: 'notice', text: `${protocol.title} started · steps ${limits.from}–${limits.to} · pass ${limits.score} · ≤${limits.tries} tries` }]);
+        }
+        default: return undefined;
+    }
+}

package/dist/controller/connection-streams.d.ts

@@ -0,0 +1,22 @@
+/** Event/control subscriptions and their startup deadlines belong to one connection generation. */
+import { Client } from '../transport/client.ts';
+import { type HostEvent } from '../transport/events.ts';
+export interface StreamHost {
+    identified(clientId: string): void;
+    event(event: HostEvent): boolean;
+    changed(): void;
+    degraded(message: string): void;
+    fail(error: Error): void;
+}
+export declare class ConnectionStreams {
+    private readonly client;
+    private readonly host;
+    private readonly subscriptions;
+    private readonly abort;
+    private readonly signal;
+    constructor(client: Client, host: StreamHost, signal: AbortSignal);
+    start(): Promise<void>;
+    close(): void;
+    /** Resolve the first usable frame while retaining the stream until this generation ends. */
+    private follow;
+}

package/dist/controller/connection-streams.js

@@ -0,0 +1,105 @@
+/** Event/control subscriptions and their startup deadlines belong to one connection generation. */
+import { RemoteError } from "../transport/client.js";
+import { controlFrame, hostEvent } from "../transport/events.js";
+import { errorText, object, string } from "../transport/wire.js";
+export class ConnectionStreams {
+    client;
+    host;
+    subscriptions = new Set();
+    abort = new AbortController();
+    signal;
+    constructor(client, host, signal) {
+        this.client = client;
+        this.host = host;
+        this.signal = AbortSignal.any([signal, this.abort.signal]);
+    }
+    async start() {
+        let clientId = '';
+        await this.follow('$events', 'Host ready timed out', value => {
+            const frame = object(value);
+            if (frame.type === 'ready') {
+                clientId = string(frame.clientId);
+                this.host.identified(clientId);
+                return true;
+            }
+            const event = hostEvent(frame);
+            if (event && !this.host.event(event) && 'eventId' in event) {
+                // Unknown waterfalls still need a result so the host's event chain can continue.
+                void this.client.call('$events/result', { clientId, eventId: event.eventId, outcome: { kind: 'next' } })
+                    .catch(error => this.host.fail(new Error(errorText(error))));
+            }
+            return false;
+        });
+        await this.follow('session/control', 'Session control baseline timed out', value => {
+            try {
+                this.host.event({ kind: 'control', frame: controlFrame(value) });
+                this.host.changed();
+            }
+            catch (error) {
+                // Missing live metrics must not blind a running conversation.
+                this.host.degraded(`Live metrics degraded: ${errorText(error)}`);
+            }
+            return true;
+        }, error => {
+            if (!(error instanceof RemoteError) || error.code !== 'gateway/method-unavailable')
+                return false;
+            this.host.degraded('Live metrics unavailable on this host');
+            return true;
+        });
+    }
+    close() {
+        this.abort.abort();
+        for (const subscription of this.subscriptions)
+            subscription.cancel();
+        this.subscriptions.clear();
+    }
+    /** Resolve the first usable frame while retaining the stream until this generation ends. */
+    follow(endpoint, timeout, item, unavailable) {
+        this.signal.throwIfAborted();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.signal.removeEventListener('abort', cancelled);
+                if (error === undefined)
+                    resolve();
+                else
+                    reject(error);
+            };
+            const cancelled = () => finish(this.signal.reason);
+            const timer = setTimeout(() => finish(new Error(timeout)), this.client.timeoutMs);
+            this.signal.addEventListener('abort', cancelled, { once: true });
+            try {
+                const subscription = this.client.subscribe(endpoint, {}, {
+                    item: value => {
+                        if (this.signal.aborted)
+                            return;
+                        if (item(value))
+                            finish();
+                    },
+                    end: error => {
+                        if (this.signal.aborted)
+                            return;
+                        if (unavailable?.(error)) {
+                            finish();
+                            return;
+                        }
+                        const reason = error ?? new Error(`${endpoint} stream ended`);
+                        finish(reason);
+                        this.host.fail(reason);
+                    },
+                });
+                if (this.signal.aborted)
+                    subscription.cancel();
+                else
+                    this.subscriptions.add(subscription);
+            }
+            catch (error) {
+                finish(error);
+            }
+        });
+    }
+}

package/dist/controller/connection.d.ts

@@ -1,9 +1,20 @@
 import { Client } from '../transport/client.ts';
-import { type ObjectValue } from '../transport/wire.ts';
+import { type Json } from '../transport/wire.ts';
+import type { HostEvent } from '../transport/events.ts';
 import type { HostAccess } from '../transport/host.ts';
-import { Telemetry } from '../session/telemetry.ts';
 import type { ConnectionView } from '../session/connection-view.ts';
-import type { ControllerStore } from '../state.ts';
+/** Connection publication cannot replace session, navigation, catalog or shell state. */
+export interface ConnectionStore {
+    readonly state: {
+        readonly online: boolean;
+    };
+    update(patch: Partial<{
+        online: boolean;
+        status: string;
+        lastFailure: string;
+        controlError: string | undefined;
+    }>): void;
+}
 /** Connection inputs resolved by the CLI or a library consumer. */
 export interface ConnectionOptions {
     base: string;
@@ -22,33 +33,25 @@ export interface ConnectionListener {
     ready(): Promise<void>;
     /** The generation ended and its socket is closed. */
     ended(): Promise<void>;
-    /** Deliver a host waterfall; return true when a domain retained it for an answer. */
-    waterfall(frame: ObjectValue): boolean;
-    /** The host cancelled a waterfall a domain retained. */
-    cancelled(eventId: string): void;
-    /** The host reported one session's running state. */
-    status(sessionId: string, running: boolean): void;
-    /** The host reported one session's error. */
-    error(sessionId: unknown, error: unknown): void;
-    /** Model catalogs may have changed. */
-    invalidated(): void;
-    /** A turn finished, so billing may refresh. */
-    idle(): void;
+    /** Route one normalized host event, so a feature never calls another feature directly. */
+    event(event: HostEvent): boolean;
 }
-/** Owns reconnects, subscriptions and the telemetry generation. User commands remain single-attempt operations. */
+/** Owns the physical connection: reconnects, subscriptions and generation lifecycle.
+ *
+ * Host running state, projections and interactions belong to the session domain; this class only
+ * decodes wire frames into `HostEvent` and hands them to the application, which routes them on.
+ * User commands remain single-attempt operations.
+ */
 export declare class ConnectionController implements HostAccess, ConnectionView {
     private readonly store;
     private readonly options;
     private readonly listener;
-    telemetry: Telemetry;
     clientId: string;
-    private readonly runningUpdates;
-    private readonly observedRunningAt;
     private current;
     private readonly abort;
     private runTask;
     private generationFailed;
-    constructor(store: ControllerStore, options: ConnectionOptions, listener: ConnectionListener);
+    constructor(store: ConnectionStore, options: ConnectionOptions, listener: ConnectionListener);
     /** Start one retry loop, with a fresh snapshot generation after every disconnect. */
     start(): void;
     /** Cancel retries and HTTP, close the socket, and wait for the loop to settle. */
@@ -61,20 +64,10 @@ export declare class ConnectionController implements HostAccess, ConnectionView
     online(): boolean;
     /** @returns The client lifetime signal. */
     signal(): AbortSignal;
-    /** @returns The projection store of the current generation. */
-    telemetryView(): Telemetry;
-    /** @returns Cached host running state, or undefined when never reported. */
-    runningFor(sessionId: string): boolean | undefined;
-    /** @returns When this client first observed the session, for the elapsed-time fallback. */
-    observedAt(sessionId: string): number | undefined;
-    /** Record an observation start for a session this client just opened. */
-    observe(sessionId: string): void;
     /** Fail the current generation, so the controller reopens a snapshot. */
     fail(error: Error): void;
     /** Answer one retained host waterfall through the event-result endpoint. */
-    reply(frame: ObjectValue, outcome: ObjectValue): Promise<void>;
+    reply(eventId: string, outcome: Json): Promise<void>;
     /** Run one generation, then retry with bounded jittered backoff until stopped. */
     private run;
-    /** Apply one `api-session/status` notification to the running maps and the session view. */
-    private acceptStatus;
 }