@itookit/dsht 0.3.8 → 0.5.2

package/dist/session/interactions.d.ts

@@ -0,0 +1,26 @@
+/** Retained host requests and one response owner per interaction instance. */
+import type { HostEvent } from '../transport/events.ts';
+import type { Json } from '../json.ts';
+import type { AnswerValue, PendingInteraction } from './types.ts';
+export interface InteractionHost {
+    focused(): PendingInteraction | undefined;
+    admit(sessionId: string, dispatch: () => Promise<void>): Promise<void>;
+    reply(eventId: string, outcome: Json): Promise<void>;
+    changed(): void;
+}
+export declare class SessionInteractions {
+    private readonly host;
+    private readonly entries;
+    private readonly responding;
+    constructor(host: InteractionHost);
+    clear(): void;
+    settle(): Promise<void>;
+    pendingFor(sessionId: string | undefined): PendingInteraction[];
+    counts(): ReadonlyMap<string, number>;
+    accept(event: HostEvent): boolean;
+    cancelled(eventId: string): void;
+    answer(value: AnswerValue): Promise<void>;
+    approve(allowed: boolean): Promise<void>;
+    dismissQuestion(): Promise<void>;
+    private respond;
+}

package/dist/session/interactions.js

@@ -0,0 +1,75 @@
+export class SessionInteractions {
+    host;
+    entries = new Map();
+    responding = new Map();
+    constructor(host) {
+        this.host = host;
+    }
+    clear() { this.entries.clear(); }
+    async settle() { await Promise.allSettled(this.responding.values()); }
+    pendingFor(sessionId) {
+        return [...this.entries.values()].filter(frame => frame.sessionId === sessionId);
+    }
+    counts() {
+        const counts = new Map();
+        for (const frame of this.entries.values()) {
+            if (frame.sessionId !== '')
+                counts.set(frame.sessionId, (counts.get(frame.sessionId) ?? 0) + 1);
+        }
+        return counts;
+    }
+    accept(event) {
+        if (event.kind === 'approval-request') {
+            this.entries.set(event.eventId, { kind: 'approval', eventId: event.eventId, sessionId: event.sessionId, description: event.description });
+        }
+        else if (event.kind === 'question-request') {
+            this.entries.set(event.eventId, { kind: 'question', eventId: event.eventId, sessionId: event.sessionId, questions: event.questions });
+        }
+        else
+            return false;
+        this.host.changed();
+        return true;
+    }
+    cancelled(eventId) { this.entries.delete(eventId); this.host.changed(); }
+    async answer(value) {
+        const pending = this.host.focused();
+        if (pending?.kind !== 'question')
+            throw new Error('No pending question');
+        await this.respond(pending, { kind: 'result', value });
+    }
+    async approve(allowed) {
+        const pending = this.host.focused();
+        if (pending?.kind !== 'approval')
+            throw new Error('No pending approval');
+        await this.respond(pending, { kind: 'result', value: allowed ? 'allowed-once' : 'rejected' });
+    }
+    async dismissQuestion() {
+        const pending = this.host.focused();
+        if (pending?.kind !== 'question')
+            throw new Error('No pending question');
+        await this.respond(pending, { kind: 'rejected', error: {
+                name: 'UserQuestionError', message: 'the user cancelled ask_user_question', code: 'ASK_CANCELLED',
+            } });
+    }
+    respond(pending, outcome) {
+        const existing = this.responding.get(pending);
+        if (existing)
+            return existing;
+        // Reserve synchronously; the next Enter joins this response instead of issuing a conflicting one.
+        const response = Promise.resolve().then(() => this.host.admit(pending.sessionId, () => {
+            // Admission may have waited. Cancellation or a replayed request invalidates the captured object.
+            if (this.entries.get(pending.eventId) !== pending)
+                throw new Error('Interaction is no longer pending');
+            return this.host.reply(pending.eventId, outcome);
+        })).then(() => {
+            if (this.entries.get(pending.eventId) === pending) {
+                this.entries.delete(pending.eventId);
+                this.host.changed();
+            }
+        });
+        this.responding.set(pending, response);
+        const release = () => { this.responding.delete(pending); };
+        void response.then(release, release);
+        return response;
+    }
+}

package/dist/session/markdown.js

@@ -5,7 +5,7 @@ import stringWidth from 'string-width';
 import wrapAnsi from 'wrap-ansi';
 import { stripVTControlCharacters } from 'node:util';
 import { decodeHTML } from 'entities';
-import { safeText } from "../transport/wire.js";
+import { safeText } from "../text.js";
 import { renderMath } from "./math.js";
 const parser = new Marked({ gfm: true });
 // Math is tokenized before Markdown escapes, but after fenced and inline code have claimed their source.

package/dist/session/math.js

@@ -8,7 +8,7 @@ import { TextNode } from '@mathjax/src/js/core/MmlTree/MmlNode.js';
 import { SerializedMmlVisitor } from '@mathjax/src/js/core/MmlTree/SerializedMmlVisitor.js';
 import '@mathjax/src/js/input/tex/base/BaseConfiguration.js';
 import '@mathjax/src/js/input/tex/ams/AmsConfiguration.js';
-import { safeText } from "../transport/wire.js";
+import { safeText } from "../text.js";
 RegisterHTMLHandler(liteAdaptor());
 const superscripts = Object.fromEntries([...('0123456789+-=()ni')].map((c, i) => [c, [...'⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾ⁿⁱ'][i]]));
 const subscripts = Object.fromEntries([...'0123456789+-=()aehijklmnoprstuvx'].map((c, i) => [c, [...'₀₁₂₃₄₅₆₇₈₉₊₋₌₍₎ₐₑₕᵢⱼₖₗₘₙₒₚᵣₛₜᵤᵥₓ'][i]]));

package/dist/session/mutation-gate.d.ts

@@ -0,0 +1,51 @@
+/** One session's mutation admission order, with a control lane that overtakes the normal waiters.
+ *
+ * The gate serializes the **admission** of a mutation — checking state, deciding, and issuing the
+ * request — not the remote mutation itself. A section therefore returns as soon as the request is
+ * issued, and the caller awaits the host's answer outside the gate: a `/compact` can take minutes, and
+ * holding the gate for it would make `cancel` wait for exactly the operation it exists to interrupt.
+ * The `return dispatch()` below is what enforces that: the gate releases when the section *returns*,
+ * so even an `async` section holds it only up to its first `await`.
+ *
+ * Two lanes:
+ *
+ * * `normal` — a prompt, steering, a host command, an answer, a queue removal: arrival order;
+ * * `control` — `cancelTurn`/`interrupt` and `/loop stop`: waits only for the section already running,
+ *   so it is admitted ahead of every normal admission that is still waiting.
+ *
+ * The key is the **target** session, not the selected one: cancelling a forked verifier addresses the
+ * verifier's own session, and that must not queue behind the reviewed session's writes.
+ */
+/** Which queue one mutation admission joins. */
+export type MutationLane = 'normal' | 'control';
+/** One admission, as the gate reports it so the trace can answer "who dispatched first". */
+export interface MutationAdmission {
+    /** Session the mutation targets; never inferred from the selection. */
+    readonly sessionId: string;
+    /** Lane the admission used. */
+    readonly lane: MutationLane;
+    /** Whether another admission already held this session's gate when this one arrived. */
+    readonly waited: boolean;
+}
+/** Serializes one session's mutation admissions. */
+export declare class SessionMutationGate {
+    private readonly report?;
+    private readonly lanes;
+    /** @param report - Optional observer, called once per admission in dispatch order. */
+    constructor(report?: ((admission: MutationAdmission) => void) | undefined);
+    /** Wait for this session's turn, then run one section inside the gate.
+     *
+     * `dispatch` must decide and **issue**: return the promise the caller will await, rather than
+     * awaiting it here, or the gate stays held for the whole remote mutation.
+     * @param sessionId - Target session the mutation belongs to.
+     * @param lane - `control` overtakes waiting normal admissions; `normal` keeps arrival order.
+     * @param dispatch - Synchronous decision plus request issue.
+     * @returns What `dispatch` returned; a returned promise is adopted, so the caller may await the
+     *   host's answer without holding the gate.
+     */
+    admit<T>(sessionId: string, lane: MutationLane, dispatch: () => T): Promise<T>;
+    /** Take the gate now, or queue for it behind the running section. */
+    private acquire;
+    /** Hand the gate to the next waiter, control first, or free it. */
+    private release;
+}

package/dist/session/mutation-gate.js

@@ -0,0 +1,73 @@
+/** One session's mutation admission order, with a control lane that overtakes the normal waiters.
+ *
+ * The gate serializes the **admission** of a mutation — checking state, deciding, and issuing the
+ * request — not the remote mutation itself. A section therefore returns as soon as the request is
+ * issued, and the caller awaits the host's answer outside the gate: a `/compact` can take minutes, and
+ * holding the gate for it would make `cancel` wait for exactly the operation it exists to interrupt.
+ * The `return dispatch()` below is what enforces that: the gate releases when the section *returns*,
+ * so even an `async` section holds it only up to its first `await`.
+ *
+ * Two lanes:
+ *
+ * * `normal` — a prompt, steering, a host command, an answer, a queue removal: arrival order;
+ * * `control` — `cancelTurn`/`interrupt` and `/loop stop`: waits only for the section already running,
+ *   so it is admitted ahead of every normal admission that is still waiting.
+ *
+ * The key is the **target** session, not the selected one: cancelling a forked verifier addresses the
+ * verifier's own session, and that must not queue behind the reviewed session's writes.
+ */
+/** Serializes one session's mutation admissions. */
+export class SessionMutationGate {
+    report;
+    lanes = new Map();
+    /** @param report - Optional observer, called once per admission in dispatch order. */
+    constructor(report) {
+        this.report = report;
+    }
+    /** Wait for this session's turn, then run one section inside the gate.
+     *
+     * `dispatch` must decide and **issue**: return the promise the caller will await, rather than
+     * awaiting it here, or the gate stays held for the whole remote mutation.
+     * @param sessionId - Target session the mutation belongs to.
+     * @param lane - `control` overtakes waiting normal admissions; `normal` keeps arrival order.
+     * @param dispatch - Synchronous decision plus request issue.
+     * @returns What `dispatch` returned; a returned promise is adopted, so the caller may await the
+     *   host's answer without holding the gate.
+     */
+    async admit(sessionId, lane, dispatch) {
+        const state = this.lanes.get(sessionId) ?? { busy: false, control: [], normal: [] };
+        this.lanes.set(sessionId, state);
+        const waited = state.busy;
+        await this.acquire(state, lane);
+        this.report?.({ sessionId, lane, waited });
+        try {
+            return dispatch();
+        }
+        finally {
+            this.release(sessionId, state);
+        }
+    }
+    /** Take the gate now, or queue for it behind the running section. */
+    async acquire(state, lane) {
+        if (!state.busy) {
+            state.busy = true;
+            return;
+        }
+        // The waiter that is woken inherits the gate: `busy` stays true across the handoff, so an
+        // admission arriving during it queues instead of overtaking the waiter already promised the turn.
+        await new Promise(resolve => (lane === 'control' ? state.control : state.normal).push(resolve));
+    }
+    /** Hand the gate to the next waiter, control first, or free it. */
+    release(sessionId, state) {
+        const next = state.control.shift() ?? state.normal.shift();
+        if (next !== undefined) {
+            next();
+            return;
+        }
+        state.busy = false;
+        // A lane nobody is waiting for would otherwise stay behind for the life of the process, and long
+        // runs create a session per verification.
+        if (this.lanes.get(sessionId) === state)
+            this.lanes.delete(sessionId);
+    }
+}

package/dist/session/navigation.d.ts

@@ -1,91 +1,4 @@
-/** Shared display names and unambiguous slash-command target resolution. */
-import { type ObjectValue } from '../transport/wire.ts';
-/** Parse workspace and resume navigation, including their long aliases. */
-export declare function navigationCommand(value: string): {
-    kind: 'workspace' | 'session';
-    query?: string;
-} | undefined;
-/** Resolve the host's title projection, falling back to the session ID. */
-export declare function sessionLabel(session: ObjectValue): string;
+/** Unambiguous slash-command target resolution and host title projection. */
+import { type ObjectValue } from '../json.ts';
 /** Match an exact ID or name before a unique ID prefix; never choose an ambiguous target. */
 export declare function resolveTarget(items: ObjectValue[], query: string, id: string, names: (item: ObjectValue) => string[]): ObjectValue;
-/** User-visible activity of one session, most actionable first.
- *
- * `needs` is the only state that asks the user to do something, and it outranks the host's running
- * flag because a turn waiting on an answer is running only in the mechanical sense. `blank` stays a
- * marker for a session that never sent a turn, but it is not a status and never enters a rollup.
- */
-export type SessionState = 'needs' | 'running' | 'idle' | 'blank';
-/** 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 declare function sessionState(session: ObjectValue, pending?: boolean): SessionState;
-/** Leading marker per state: a question mark, a working clock, a filled dot, and an unused circle. */
-export declare const SESSION_MARKERS: Record<SessionState, string>;
-/** One word per state, so every screen names the same state the same way. */
-export declare const STATE_LABELS: Record<SessionState, string>;
-/** 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 declare function activityAge(time: number | undefined, now: number): string;
-/** 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 declare function sessionStatus(session: ObjectValue, now: number, pending?: boolean): string;
-/** States a workspace rollup reports, most actionable first. */
-export declare const ROLLUP_STATES: readonly ["needs", "running", "idle"];
-/** One state a workspace rollup reports. */
-export type RollupState = (typeof ROLLUP_STATES)[number];
-/** One counted state of a workspace rollup. */
-export interface RollupCount {
-    state: RollupState;
-    count: number;
-}
-/** How much room a rollup has for words. */
-export type RollupStyle = 'words' | 'badges';
-/** 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 declare function workspaceCounts(sessions: readonly ObjectValue[], pending?: ReadonlySet<string>): RollupCount[];
-/** 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 declare function workspaceSegments(counts: readonly RollupCount[], style?: RollupStyle): {
-    state: RollupState;
-    text: string;
-}[];
-/** 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 declare function workspaceStatus(counts: readonly RollupCount[], style?: RollupStyle): string;
-/** Marker key for the compact rollup, which has no room for the words. */
-export declare const ROLLUP_LEGEND: string;
-/** 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 declare function workspaceDetail(path: string, title: string): string;

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/navigator.d.ts

@@ -0,0 +1,47 @@
+/** Workspace/session navigation owns view intent independently of background list refreshes. */
+import { type ObjectValue } from '../json.ts';
+import type { HostAccess } from '../transport/host.ts';
+export interface NavigationState {
+    screen: 'workspaces' | 'sessions' | 'chat' | 'path';
+    workspaces: ObjectValue[];
+    sessions: ObjectValue[];
+    showAllSessions: boolean;
+    workspaceId?: string;
+    sessionId?: string;
+}
+export interface NavigationHost extends HostAccess {
+    read(): Readonly<NavigationState>;
+    publish(patch: Partial<NavigationState>): void;
+    selection(): number;
+    leave(): void;
+    follow(sessionId: string): void;
+}
+export declare class SessionNavigator {
+    private readonly host;
+    private active?;
+    private readonly tasks;
+    private listsVersion;
+    private revision;
+    constructor(host: NavigationHost);
+    get intent(): number;
+    /** Leaving a view invalidates the request that intended to open it. */
+    cancel(): void;
+    reset(): void;
+    settle(): Promise<void>;
+    private run;
+    private load;
+    private publishLists;
+    refreshLists(): Promise<void>;
+    showPicker(screen: 'workspaces' | 'sessions', signal?: AbortSignal): Promise<void>;
+    showChat(): boolean;
+    enterPath(): void;
+    private commitWorkspace;
+    pickWorkspace(workspaceId?: string): void;
+    switchWorkspace(query?: string, signal?: AbortSignal): Promise<void>;
+    switchSession(query?: string, signal?: AbortSignal): Promise<void>;
+    createWorkspace(path: string, signal?: AbortSignal): Promise<void>;
+    createSession(signal?: AbortSignal): Promise<void>;
+    get visibleSessions(): ObjectValue[];
+    /** Longest registered path wins, with whole-segment matching for nested workspaces. */
+    adoptLocalWorkspace(directory: string): string | undefined;
+}