@itookit/dsht 0.3.7 → 0.5.1

package/dist/session/navigation.js

@@ -1,25 +1,5 @@
-/** Shared display names and unambiguous slash-command target resolution. */
-import { safeText, string } from "../transport/wire.js";
-/** Parse workspace and resume navigation, including their long aliases. */
-export function navigationCommand(value) {
-    const match = /^\/(ws|workspace|workspaces|resume|session|sessions)(?:\s+(.+))?$/.exec(value);
-    if (!match)
-        return undefined;
-    return { kind: match[1] === 'ws' || match[1].startsWith('workspace') ? 'workspace' : 'session', query: match[2] };
-}
-/** Resolve the host's title projection, falling back to the session ID. */
-export function sessionLabel(session) {
-    const projections = session.projections;
-    if (projections && typeof projections === 'object' && !Array.isArray(projections)) {
-        const values = projections.values;
-        const title = values && typeof values === 'object' && !Array.isArray(values) ? values.title : undefined;
-        if (typeof title === 'string' && safeText(title).trim())
-            return safeText(title).trim();
-        if (title && typeof title === 'object' && !Array.isArray(title) && typeof title.title === 'string' && safeText(title.title).trim())
-            return safeText(title.title).trim();
-    }
-    return string(session.sessionId);
-}
+/** Unambiguous slash-command target resolution and host title projection. */
+import { string } from "../json.js";
 /** Match an exact ID or name before a unique ID prefix; never choose an ambiguous target. */
 export function resolveTarget(items, query, id, names) {
     const target = query.replace(/^(["'])(.*)\1$/, '$2');
@@ -34,110 +14,3 @@ export function resolveTarget(items, query, id, names) {
         throw new Error(`Ambiguous target: ${target}. Use a full ID.`);
     throw new Error(`Target not found: ${target}`);
 }
-/** Classify one session from the host's list summary; nothing is inferred from silence.
- * @param session - Session summary from `session/list`.
- * @param pending - Whether this client holds an unanswered interaction for that session.
- * @returns Needs-you while an answer is owed, running while its agent works, otherwise idle or blank.
- */
-export function sessionState(session, pending = false) {
-    if (pending)
-        return 'needs';
-    if (session.running === true)
-        return 'running';
-    return session.blank === true ? 'blank' : 'idle';
-}
-/** Leading marker per state: a question mark, a working clock, a filled dot, and an unused circle. */
-export const SESSION_MARKERS = { needs: '?', running: '◐', idle: '●', blank: '○' };
-/** One word per state, so every screen names the same state the same way. */
-export const STATE_LABELS = { needs: 'needs you', running: 'working', idle: 'ready', blank: 'empty' };
-/** Coarse age of a session's last activity, so the column stays steady between list refreshes.
- * @param time - Epoch milliseconds of the last activity, when the summary reported one.
- * @param now - Current epoch milliseconds.
- * @returns `now`, minutes, hours or days.
- */
-export function activityAge(time, now) {
-    if (time === undefined || !Number.isFinite(time))
-        return '';
-    const seconds = Math.max(0, Math.floor((now - time) / 1000));
-    if (seconds < 60)
-        return 'now';
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}m`;
-    const hours = Math.floor(minutes / 60);
-    return hours < 24 ? `${hours}h` : `${Math.floor(hours / 24)}d`;
-}
-/** Status cell for one session row: its state marker and the age of its last activity.
- * @param session - Session summary from `session/list`.
- * @param now - Current epoch milliseconds.
- * @param pending - Whether this client holds an unanswered interaction for that session.
- * @returns Marker with an optional age, without a trailing space when unknown.
- */
-export function sessionStatus(session, now, pending = false) {
-    const age = activityAge(typeof session.updatedAt === 'number' ? session.updatedAt : undefined, now);
-    return `${SESSION_MARKERS[sessionState(session, pending)]}${age === '' ? '' : ` ${age}`}`;
-}
-/** States a workspace rollup reports, most actionable first. */
-export const ROLLUP_STATES = ['needs', 'running', 'idle'];
-/** Count the sessions of one workspace by the state each reports.
- *
- * Blank sessions are counted by neither a badge nor a word: a session that never sent a turn is the
- * absence of activity, and listing it beside real work only makes the rollup harder to read.
- * @param sessions - Sessions whose `sessionIds` belong to the workspace.
- * @param pending - Session IDs this client holds an unanswered interaction for.
- * @returns One count per state that occurs, most actionable first, or an empty list.
- */
-export function workspaceCounts(sessions, pending = new Set()) {
-    const counts = { needs: 0, running: 0, idle: 0 };
-    for (const session of sessions) {
-        const id = session.sessionId;
-        const state = sessionState(session, typeof id === 'string' && pending.has(id));
-        if (state !== 'blank')
-            counts[state] += 1;
-    }
-    return ROLLUP_STATES.filter(state => counts[state] > 0).map(state => ({ state, count: counts[state] }));
-}
-/** Render one rollup as separately coloured cells.
- *
- * Each cell after the first carries the separator that joins it to the previous one, so a caller can
- * colour the cells independently without losing the text {@link workspaceStatus} would produce.
- * @param counts - Counts from {@link workspaceCounts}.
- * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
- * @returns The cells in the order given, with their separators.
- */
-export function workspaceSegments(counts, style = 'words') {
-    const separator = style === 'words' ? ' · ' : ' ';
-    return counts.map(({ state, count }, index) => ({ state,
-        text: `${index === 0 ? '' : separator}${style === 'words' ? `${SESSION_MARKERS[state]} ${count} ${STATE_LABELS[state]}` : `${SESSION_MARKERS[state]}${count}`}` }));
-}
-/** Render one rollup as plain text, the same way every screen and test reads it.
- * @param counts - Counts from {@link workspaceCounts}.
- * @param style - `words` spells each state out; `badges` keeps only the marker and the count.
- * @returns The joined cell text, empty when nothing was counted.
- */
-export function workspaceStatus(counts, style = 'words') {
-    return workspaceSegments(counts, style).map(segment => segment.text).join('');
-}
-/** Marker key for the compact rollup, which has no room for the words. */
-export const ROLLUP_LEGEND = `${SESSION_MARKERS.idle} ${STATE_LABELS.idle} · ${SESSION_MARKERS.running} ${STATE_LABELS.running} · ${SESSION_MARKERS.needs} ${STATE_LABELS.needs}`;
-/** Secondary path text for one workspace row.
- *
- * The title is usually the last path segment, so repeating it wastes the row; the parent directory
- * is what distinguishes two checkouts. A title that does not name the last segment keeps the full
- * path, because dropping it would hide where the workspace actually lives.
- * @param path - Registered host directory.
- * @param title - Workspace title as the row already shows it.
- * @returns The path to show beside the row, or an empty string when nothing is left.
- */
-export function workspaceDetail(path, title) {
-    if (!path)
-        return '';
-    const trimmed = path.replace(/\/+$/u, '');
-    const cut = trimmed.lastIndexOf('/');
-    const base = cut < 0 ? trimmed : trimmed.slice(cut + 1);
-    if (base !== title)
-        return path;
-    if (cut > 0)
-        return trimmed.slice(0, cut);
-    return cut === 0 ? '/' : '';
-}

package/dist/session/peek.d.ts

@@ -0,0 +1,38 @@
+import type { HostAccess } from '../transport/host.ts';
+import type { ObjectValue } from '../transport/wire.ts';
+import { Transcript } from './transcript.ts';
+/** One followed session's read-only state. */
+export interface PeekState {
+    /** The transcript as the host has streamed it. */
+    readonly transcript: Transcript;
+    /** True once the stream ended, so a view stops calling it live. */
+    readonly ended: boolean;
+    /** Set when no address form could be followed. */
+    readonly error?: string;
+}
+/** Follows one session address form at a time, read-only. */
+export declare class SessionPeek {
+    private readonly host;
+    private subscription;
+    private state;
+    /** Address forms left to try, in order; a host may refuse the child form for one delivery mode. */
+    private pending;
+    /** Bumped on every open and close, so a cancelled stream's late frame cannot revive the state. */
+    private generation;
+    /** @param host - Transport access this client already holds; the peek borrows it, never owns it. */
+    constructor(host: HostAccess);
+    /** Start following the first address that answers, releasing whatever was followed before.
+     * @param addresses - Address forms to try in order.
+     * @param onChange - Called when the transcript or the state moves.
+     */
+    open(addresses: readonly ObjectValue[], onChange: () => void): void;
+    /** Stop following and release the transcript; safe to call when nothing is open. */
+    close(): void;
+    /** @returns What a view renders, or undefined when nothing is followed. */
+    get snapshot(): PeekState | undefined;
+    /** Follow the next address form, or report that none worked.
+     * @param generation - The open this attempt belongs to; a superseded one stops silently.
+     * @param onChange - Called when the transcript or the state moves.
+     */
+    private next;
+}

package/dist/session/peek.js

@@ -0,0 +1,103 @@
+import { releaseHistoryLayout } from "./history.js";
+import { Transcript } from "./transcript.js";
+/** How much of a followed session the first snapshot asks for; the live tail appends after it. */
+const PEEK_MESSAGES = 120;
+/** Follows one session address form at a time, read-only. */
+export class SessionPeek {
+    host;
+    subscription;
+    state;
+    /** Address forms left to try, in order; a host may refuse the child form for one delivery mode. */
+    pending = [];
+    /** Bumped on every open and close, so a cancelled stream's late frame cannot revive the state. */
+    generation = 0;
+    /** @param host - Transport access this client already holds; the peek borrows it, never owns it. */
+    constructor(host) {
+        this.host = host;
+    }
+    /** Start following the first address that answers, releasing whatever was followed before.
+     * @param addresses - Address forms to try in order.
+     * @param onChange - Called when the transcript or the state moves.
+     */
+    open(addresses, onChange) {
+        this.close();
+        // `close` bumped the generation; this open owns the next one and every callback checks it.
+        const generation = ++this.generation;
+        this.pending = [...addresses];
+        this.next(generation, onChange);
+    }
+    /** Stop following and release the transcript; safe to call when nothing is open. */
+    close() {
+        this.generation += 1;
+        this.subscription?.cancel();
+        this.subscription = undefined;
+        this.pending = [];
+        if (this.state === undefined)
+            return;
+        releaseHistoryLayout(this.state.transcript);
+        this.state.transcript.dispose();
+        this.state = undefined;
+    }
+    /** @returns What a view renders, or undefined when nothing is followed. */
+    get snapshot() { return this.state; }
+    /** Follow the next address form, or report that none worked.
+     * @param generation - The open this attempt belongs to; a superseded one stops silently.
+     * @param onChange - Called when the transcript or the state moves.
+     */
+    next(generation, onChange) {
+        if (generation !== this.generation)
+            return;
+        const address = this.pending.shift();
+        if (address === undefined) {
+            this.state = { transcript: new Transcript(), ended: true, error: 'the host refused every address form' };
+            onChange();
+            return;
+        }
+        const transcript = new Transcript();
+        this.state = { transcript, ended: false };
+        let attempted = false;
+        let subscription;
+        try {
+            subscription = this.host.require().subscribe('session/follow', {
+                request: { address, maxMessages: PEEK_MESSAGES, assistantStream: true },
+            }, {
+                item: value => {
+                    if (generation !== this.generation)
+                        return;
+                    // A peek is a diagnostic surface: a malformed frame ends it with a reason rather than taking
+                    // the whole client down the way a selected session's stream would.
+                    try {
+                        transcript.accept(value);
+                    }
+                    catch {
+                        this.state = { transcript, ended: true, error: 'the session stream sent a frame this client cannot read' };
+                    }
+                    onChange();
+                },
+                end: error => {
+                    // A cancelled stream still reports its end; only the live attempt may act on it.
+                    if (attempted || generation !== this.generation)
+                        return;
+                    attempted = true;
+                    if (error !== undefined && this.pending.length > 0) {
+                        this.next(generation, onChange);
+                        return;
+                    }
+                    this.state = { transcript, ended: true, ...(error === undefined ? {} : { error: errorTextOf(error) }) };
+                    onChange();
+                },
+            });
+        }
+        catch (error) {
+            // Offline, or between connection generations: the view says so instead of failing the caller.
+            this.state = { transcript, ended: true, error: errorTextOf(error) };
+            onChange();
+            return;
+        }
+        this.subscription = subscription;
+    }
+}
+/** One error as displayable text, without importing the whole wire module. */
+function errorTextOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/session/references.d.ts

@@ -1,23 +1,5 @@
-/** A path relative to the remote session's working directory. */
-export interface FileReference {
-    path: string;
-    kind: 'file' | 'directory';
-}
-/** Find the unfinished reference at the end of the draft; email addresses do not trigger it.
- * @param text - Complete composer draft.
- * @returns The replaceable token and host query, or undefined outside a reference.
- */
-export declare function activeReference(text: string): {
-    prefix: string;
-    query: string;
-    quoted: boolean;
-} | undefined;
-/** Encode a candidate in Harness prompt syntax; directories keep completion open.
- * @param candidate - Remote path and entry kind.
- * @param quoted - Preserve an explicitly opened quote.
- * @returns Mention text, or undefined for paths the mention grammar cannot encode.
- */
-export declare function fileMention(candidate: FileReference, quoted?: boolean): string | undefined;
+import { type FileReference } from '../references.ts';
+export type { FileReference } from '../references.ts';
 /** Validate remote candidates and omit paths that cannot be inserted safely.
  * @param value - Decoded fileReferences/list result.
  * @returns Ordered file and directory candidates.

package/dist/session/references.js

@@ -1,31 +1,6 @@
 /** Independent adapter for Harness path-only @ references; no file bytes are read. */
 import { array, object, string } from "../transport/wire.js";
-/** Find the unfinished reference at the end of the draft; email addresses do not trigger it.
- * @param text - Complete composer draft.
- * @returns The replaceable token and host query, or undefined outside a reference.
- */
-export function activeReference(text) {
-    const quoted = /(?:^|\s)(@"([^"]*))$/u.exec(text);
-    if (quoted)
-        return { prefix: quoted[1], query: quoted[2], quoted: true };
-    const plain = /(?:^|\s)(@([^\s"]*))$/u.exec(text);
-    if (plain)
-        return { prefix: plain[1], query: plain[2], quoted: false };
-    return undefined;
-}
-/** Encode a candidate in Harness prompt syntax; directories keep completion open.
- * @param candidate - Remote path and entry kind.
- * @param quoted - Preserve an explicitly opened quote.
- * @returns Mention text, or undefined for paths the mention grammar cannot encode.
- */
-export function fileMention(candidate, quoted = false) {
-    const path = candidate.path + (candidate.kind === 'directory' ? '/' : '');
-    if (/[\u0000-\u001f\u007f-\u009f"]/u.test(path))
-        return undefined;
-    if (!quoted && !/\s/u.test(path))
-        return `@${path}`;
-    return `@"${path}${candidate.kind === 'file' ? '"' : ''}`;
-}
+import { fileMention } from "../references.js";
 /** Validate remote candidates and omit paths that cannot be inserted safely.
  * @param value - Decoded fileReferences/list result.
  * @returns Ordered file and directory candidates.

package/dist/session/runtime.d.ts

@@ -0,0 +1,26 @@
+/** Per-session host runtime mirrors that are not connection state.
+ *
+ * `running` and the observation start change while the network stays perfectly healthy
+ * (`ready → running → waiting → running`), so they belong to the session runtime rather than to the
+ * connection. Both maps are keyed by `sessionId` and cleared at each connection generation.
+ */
+import type { ControlFrame } from '../transport/events.ts';
+import { Telemetry } from './telemetry.ts';
+export declare class SessionRuntime {
+    /** Host projection values for every session of the current generation. */
+    telemetry: Telemetry;
+    private readonly running;
+    private readonly observed;
+    /** Cached host running flag for one session, or undefined when never reported. */
+    runningFor(sessionId: string): boolean | undefined;
+    /** When this client first observed the session running, for the elapsed-time fallback. */
+    observedAt(sessionId: string): number | undefined;
+    /** Remember when a session this client just opened was first seen. */
+    observe(sessionId: string): void;
+    /** Apply one host running-state notification for a session. */
+    accept(sessionId: string, running: boolean): void;
+    /** Apply one normalized projection/queue/job frame. */
+    acceptControl(frame: ControlFrame): void;
+    /** Drop every generation-scoped mirror, including the projection store. */
+    reset(): void;
+}

package/dist/session/runtime.js

@@ -0,0 +1,28 @@
+import { Telemetry } from "./telemetry.js";
+/** Projection capabilities this client consumes; the host retains every other key. */
+const RETAINED_PROJECTIONS = new Set(['title', 'modelSelection', 'contextPressure', 'tokenUsage', 'sessionStats', 'agentPreset']);
+export class SessionRuntime {
+    /** Host projection values for every session of the current generation. */
+    telemetry = new Telemetry(RETAINED_PROJECTIONS);
+    running = new Map();
+    observed = new Map();
+    /** Cached host running flag for one session, or undefined when never reported. */
+    runningFor(sessionId) { return this.running.get(sessionId); }
+    /** When this client first observed the session running, for the elapsed-time fallback. */
+    observedAt(sessionId) { return this.observed.get(sessionId); }
+    /** Remember when a session this client just opened was first seen. */
+    observe(sessionId) { if (!this.observed.has(sessionId))
+        this.observed.set(sessionId, Date.now()); }
+    /** Apply one host running-state notification for a session. */
+    accept(sessionId, running) {
+        if (running && !this.running.get(sessionId))
+            this.observed.set(sessionId, Date.now());
+        if (!running)
+            this.observed.delete(sessionId);
+        this.running.set(sessionId, running);
+    }
+    /** Apply one normalized projection/queue/job frame. */
+    acceptControl(frame) { this.telemetry.accept(frame); }
+    /** Drop every generation-scoped mirror, including the projection store. */
+    reset() { this.running.clear(); this.observed.clear(); this.telemetry = new Telemetry(RETAINED_PROJECTIONS); }
+}

package/dist/session/telemetry.d.ts

@@ -1,11 +1,10 @@
-/** Host projection values with per-key watermarks; snapshots never roll back newer updates. */
-import { type ObjectValue } from '../transport/wire.ts';
-/** One host-owned pending input, removable only while its occurrence remains queued. */
-export interface QueuedInput {
-    id: string;
-    placement: 'queued' | 'steering' | 'context';
-    text: string;
-}
+/** Host projection values with per-key watermarks; snapshots never roll back newer updates.
+ *
+ * The wire shape is decoded by `transport/events.ts`; this class only applies semantic control frames
+ * to its own maps, so a host field rename never reaches the session domain.
+ */
+import type { ControlFrame, ProjectionSnapshot, ProjectionValue, QueuedInput } from '../transport/events.ts';
+export type { QueuedInput } from '../transport/events.ts';
 /** Generation-local projection, inbox and background-job data for every session. */
 export declare class Telemetry {
     private readonly retainedKeys?;
@@ -16,20 +15,20 @@ export declare class Telemetry {
     /** Optionally retain only projection capabilities consumed by this client. */
     constructor(retainedKeys?: ReadonlySet<string> | undefined);
     /** Replace all control state on a new stream baseline, then accept replacement frames.
-     * @param value - One decoded session/control frame.
+     * @param frame - One normalized session/control frame.
      */
-    accept(value: unknown): void;
+    accept(frame: ControlFrame): void;
     /** Merge a complete follow snapshot without restoring absent or older projection values.
      * @param id - Session identity.
-     * @param value - Projection baseline, when supplied by the host.
+     * @param baseline - Projection baseline, when supplied by the host.
      */
-    snapshot(id: string, value: unknown): void;
+    snapshot(id: string, baseline: ProjectionSnapshot | undefined): void;
     /** Read current values for one session; missing capabilities remain absent.
      * @param id - Selected session identity, if any.
      * @returns Projection values and known queue/job counts.
      */
     view(id?: string): {
-        values: ObjectValue;
+        values: Readonly<Record<string, ProjectionValue>>;
         queued?: number;
         jobs?: number;
     };

package/dist/session/telemetry.js

@@ -1,14 +1,3 @@
-/** Host projection values with per-key watermarks; snapshots never roll back newer updates. */
-import { array, object, string } from "../transport/wire.js";
-function queuedInputs(value) {
-    return array(value).map(value => {
-        const item = object(value);
-        if (!['queued', 'steering', 'context'].includes(string(item.placement)))
-            throw new Error('Invalid queue placement');
-        return { id: string(item.id), placement: item.placement,
-            text: array(object(item.message).content).map(object).map(block => block.type === 'text' ? string(block.text) : `[${string(block.type)}]`).join(' ') };
-    });
-}
 /** Generation-local projection, inbox and background-job data for every session. */
 export class Telemetry {
     retainedKeys;
@@ -21,72 +10,60 @@ export class Telemetry {
         this.retainedKeys = retainedKeys;
     }
     /** Replace all control state on a new stream baseline, then accept replacement frames.
-     * @param value - One decoded session/control frame.
+     * @param frame - One normalized session/control frame.
      */
-    accept(value) {
-        const frame = object(value);
-        if (frame.type === 'baseline') {
-            const baseline = object(frame.value);
+    accept(frame) {
+        if (frame.kind === 'baseline') {
             this.entries.clear();
             this.queues.clear();
             this.jobs.clear();
-            for (const [id, projection] of Object.entries(object(baseline.projections)))
-                this.snapshot(id, projection);
-            for (const [id, items] of Object.entries(object(baseline.queues)))
-                this.queues.set(id, queuedInputs(items));
-            for (const [id, items] of Object.entries(object(baseline.jobs)))
-                this.jobs.set(id, activeJobs(items));
+            for (const [id, snapshot] of frame.projections)
+                this.snapshot(id, snapshot);
+            for (const [id, items] of frame.queues)
+                this.queues.set(id, [...items]);
+            for (const [id, count] of frame.jobs)
+                this.jobs.set(id, count);
             this.ready = true;
             return;
         }
         if (!this.ready)
             throw new Error('Session control update before baseline');
-        const id = string(frame.sessionId);
-        if (frame.type === 'projection') {
-            const entry = this.entry(id);
-            const key = string(frame.key);
-            const seq = sequence(frame.seq);
-            if (seq < (entry.revisions.get(key) ?? entry.baseline))
+        if (frame.kind === 'projection') {
+            const entry = this.entry(frame.sessionId);
+            if (frame.seq < (entry.revisions.get(frame.key) ?? entry.baseline))
                 return;
-            if (frame.value === undefined)
-                throw new Error('Missing projection value');
-            if (this.retainedKeys && !this.retainedKeys.has(key))
+            if (this.retainedKeys && !this.retainedKeys.has(frame.key))
                 return;
-            entry.values[key] = frame.value;
-            entry.revisions.set(key, seq);
+            entry.values[frame.key] = frame.value;
+            entry.revisions.set(frame.key, frame.seq);
         }
-        else if (frame.type === 'queue')
-            this.queues.set(id, queuedInputs(frame.items));
-        else if (frame.type === 'jobs')
-            this.jobs.set(id, activeJobs(frame.items));
+        else if (frame.kind === 'queue')
+            this.queues.set(frame.sessionId, [...frame.items]);
         else
-            throw new Error('Unknown session control frame');
+            this.jobs.set(frame.sessionId, frame.count);
     }
     /** Merge a complete follow snapshot without restoring absent or older projection values.
      * @param id - Session identity.
-     * @param value - Projection baseline, when supplied by the host.
+     * @param baseline - Projection baseline, when supplied by the host.
      */
-    snapshot(id, value) {
-        if (value === undefined)
+    snapshot(id, baseline) {
+        if (baseline === undefined)
             return;
-        const baseline = object(value);
-        const seq = sequence(baseline.asOfSeq);
-        const values = object(baseline.values);
         const entry = this.entry(id);
-        if (seq < entry.baseline)
+        if (baseline.asOfSeq < entry.baseline)
             return;
-        for (const key of new Set([...Object.keys(entry.values), ...Object.keys(values)])) {
+        for (const key of new Set([...Object.keys(entry.values), ...Object.keys(baseline.values)])) {
             if (this.retainedKeys && !this.retainedKeys.has(key))
                 continue;
-            if ((entry.revisions.get(key) ?? -1) > seq)
+            if ((entry.revisions.get(key) ?? -1) > baseline.asOfSeq)
                 continue;
-            if (Object.hasOwn(values, key))
-                entry.values[key] = values[key];
+            if (Object.hasOwn(baseline.values, key))
+                entry.values[key] = baseline.values[key];
             else
                 delete entry.values[key];
             entry.revisions.delete(key);
         }
-        entry.baseline = seq;
+        entry.baseline = baseline.asOfSeq;
     }
     /** Read current values for one session; missing capabilities remain absent.
      * @param id - Selected session identity, if any.
@@ -110,11 +87,3 @@ export class Telemetry {
         return entry;
     }
 }
-function sequence(value) {
-    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < -1)
-        throw new Error('Invalid projection watermark');
-    return value;
-}
-function activeJobs(value) {
-    return array(value).filter(item => ['running', 'stopping'].includes(string(object(item).status))).length;
-}

package/dist/session/transcript.d.ts

@@ -6,12 +6,6 @@ interface ToolSummary {
     operation?: string;
     command?: string;
 }
-/** Fit a tool operation to one terminal row without exposing the result body.
- * @param text - Tool name, status icon and optional operation.
- * @param width - Available terminal columns.
- * @returns A single line with an ellipsis when shortened.
- */
-export declare function toolLine(text: string, width: number): string;
 /** Render known content blocks and preserve unknown plugin blocks as JSON.
  * @param content - Message content blocks.
  * @param tools - Tool summaries by call ID, when retained history provides them.

package/dist/session/transcript.js

@@ -1,6 +1,5 @@
-/** Human transcript projection from durable events and ephemeral assistant chunks. */
-import sliceAnsi from 'slice-ansi';
-import { array, object, safeText, string } from "../transport/wire.js";
+import { array, object, string } from "../transport/wire.js";
+import { safeText, toolLine } from "../text.js";
 function toolSummary(block) {
     let args = {};
     if (typeof block.arguments === 'string' && block.arguments.trimStart().startsWith('{')) {
@@ -19,18 +18,6 @@ function toolSummary(block) {
     return { name: string(block.name), ...(typeof operation === 'string' ? { operation } : {}),
         ...(typeof command === 'string' && command !== operation ? { command: command.split(/\r?\n/)[0] } : {}) };
 }
-/** Fit a tool operation to one terminal row without exposing the result body.
- * @param text - Tool name, status icon and optional operation.
- * @param width - Available terminal columns.
- * @returns A single line with an ellipsis when shortened.
- */
-export function toolLine(text, width) {
-    const clean = safeText(text).replace(/\s+/gu, ' ').trim();
-    if (width < 2)
-        return width === 1 ? '…' : '';
-    const clipped = sliceAnsi(clean, 0, width);
-    return clipped.length < clean.length ? sliceAnsi(clean, 0, width - 1) + '…' : clean;
-}
 /** Render known content blocks and preserve unknown plugin blocks as JSON.
  * @param content - Message content blocks.
  * @param tools - Tool summaries by call ID, when retained history provides them.

package/dist/session/types.d.ts

@@ -1,4 +1,5 @@
 /** Session-domain result types shared by the controller facade and the terminal UI. */
+import type { QuestionItem } from '../transport/events.ts';
 /** Resolved navigation-removal identity; empty marks a fresh blank, idle session eligible for immediate archival. */
 export interface RemovalTarget {
     kind: 'workspace' | 'session';
@@ -16,3 +17,27 @@ export interface HistorySearch {
     }[];
     truncated: boolean;
 }
+/** A structured question answer as the UI collects it; the host receives it inside an outcome. */
+export type AnswerValue = {
+    answers: {
+        id: string;
+        selected: string[];
+        custom?: string;
+    }[];
+};
+/** One unanswered host interaction of the selected session.
+ *
+ * A discriminated union rather than the raw waterfall: the UI switches on `kind` and reads named
+ * fields, so it never needs to know how the host shaped its request.
+ */
+export type PendingInteraction = {
+    kind: 'approval';
+    eventId: string;
+    sessionId: string;
+    description: string;
+} | {
+    kind: 'question';
+    eventId: string;
+    sessionId: string;
+    questions: readonly QuestionItem[];
+};

package/dist/session/types.js

@@ -1,2 +1 @@
-/** Session-domain result types shared by the controller facade and the terminal UI. */
 export {};