@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/app/liveness.d.ts

@@ -11,11 +11,12 @@
  *                  shown only once it passes the stall threshold. Disappears the
  *                  moment an event lands, so it never lingers as noise.
  *
- * Tool phases are intentionally exempt from the quiet label: a long build or
- * test run is expected, and the tool verb already says what is happening.
+ * Owned tool observations have their own clock and a separate silence advisory.
+ * Silence is an observation: a long build may legitimately be waiting.
  */
-import type { AgentStatus } from '../types.js';
+import type { AgentStatus, AgentState } from '../types.js';
 export declare const DEFAULT_STALL_HINT_MS = 15000;
+export declare const TOOL_QUIET_HINT_MS = 30000;
 export interface LivenessInput {
     status: AgentStatus;
     /** Render-time clock in ms since epoch (injectable for deterministic tests). */
@@ -25,6 +26,7 @@ export interface LivenessInput {
     /** Timestamp of the most recent agent event (token deltas included). */
     lastEventAt?: Date | null;
     stallHintMs?: number;
+    toolProgress?: AgentState['toolProgress'];
 }
 export interface Liveness {
     elapsedLabel: string | null;
@@ -35,7 +37,7 @@ export interface Liveness {
  * (0s, 59s, 1m 00s, 59m 59s, 1h 00m 00s, 2h 03m 09s).
  */
 export declare function formatCompactElapsed(ms: number): string;
-export declare function describeLiveness({ status, now, turnStartedAt, lastEventAt, stallHintMs, }: LivenessInput): Liveness;
+export declare function describeLiveness({ status, now, turnStartedAt, lastEventAt, stallHintMs, toolProgress, }: LivenessInput): Liveness;
 /**
  * Resolve the stall threshold, honoring the `ZTC_STALL_HINT_MS` diagnostic
  * override (used by tests to observe the marker without waiting 15 seconds).

package/dist/app/liveness.js

@@ -11,10 +11,11 @@
  *                  shown only once it passes the stall threshold. Disappears the
  *                  moment an event lands, so it never lingers as noise.
  *
- * Tool phases are intentionally exempt from the quiet label: a long build or
- * test run is expected, and the tool verb already says what is happening.
+ * Owned tool observations have their own clock and a separate silence advisory.
+ * Silence is an observation: a long build may legitimately be waiting.
  */
 export const DEFAULT_STALL_HINT_MS = 15_000;
+export const TOOL_QUIET_HINT_MS = 30_000;
 const ACTIVE_STATUSES = new Set(['thinking', 'streaming', 'tool_use']);
 const MODEL_WAIT_STATUSES = new Set(['thinking', 'streaming']);
 /**
@@ -35,10 +36,19 @@ export function formatCompactElapsed(ms) {
     const minutes = Math.floor((totalSeconds % 3600) / 60);
     return `${hours}h ${String(minutes).padStart(2, '0')}m ${String(seconds).padStart(2, '0')}s`;
 }
-export function describeLiveness({ status, now, turnStartedAt, lastEventAt, stallHintMs = DEFAULT_STALL_HINT_MS, }) {
+export function describeLiveness({ status, now, turnStartedAt, lastEventAt, stallHintMs = DEFAULT_STALL_HINT_MS, toolProgress, }) {
     if (!ACTIVE_STATUSES.has(status)) {
         return { elapsedLabel: null, quietLabel: null };
     }
+    if (status === 'tool_use' && toolProgress) {
+        const progress = toolProgress.progress;
+        const quietMs = Math.max(0, now - (progress.lastOutputAt ?? progress.startedAt));
+        return {
+            elapsedLabel: `tool ${formatCompactElapsed(now - progress.startedAt)}`,
+            quietLabel: quietMs >= TOOL_QUIET_HINT_MS
+                ? `no tool output ${formatCompactElapsed(quietMs)} (may be waiting)` : null,
+        };
+    }
     const elapsedLabel = turnStartedAt
         ? formatCompactElapsed(now - turnStartedAt.getTime())
         : null;

package/dist/app/model_catalog_cache.d.ts

@@ -0,0 +1,5 @@
+import { listModels } from '../utils/models.js';
+type ListModelsOptions = Parameters<typeof listModels>[0];
+/** Shared discovery for all renderers. Disk rows are previews, not entitlements. */
+export declare function loadModelCatalog(options: ListModelsOptions, onVerified?: (models: string[]) => void): Promise<string[]>;
+export {};

package/dist/app/model_catalog_cache.js

@@ -0,0 +1,138 @@
+import { createHash } from 'node:crypto';
+import { profileConfigDir } from '../config/profiles.js';
+import { listModels } from '../utils/models.js';
+import { clearCachedModels, readCachedModels, readCachedModelsFetchedAt, writeCachedModels } from '../utils/model_cache.js';
+const FRESH_MS = 30_000;
+const OFFLINE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const MAX_SCOPES = 64;
+const MAX_CACHED_MODELS = 512;
+const catalogs = new Map();
+let writes = Promise.resolve();
+function scopeFor(options) {
+    // Never persist raw credentials. Profiles, endpoints and credential identities
+    // are separate catalogs; switching any of them must bypass the old entry.
+    const identity = [profileConfigDir(), options.provider, options.proxyUrl?.replace(/\/$/, ''),
+        options.authToken, options.workspaceId, options.baseUrl?.replace(/\/$/, ''), options.apiKey,
+        options.codexAppServerCommand, options.codexAppServerArgs, options.codexHome,
+        options.codexAuthFilePath, options.kimiCredsFilePath];
+    return `${options.provider}:${createHash('sha256').update(JSON.stringify(identity)).digest('hex')}`;
+}
+function persist(profile, action) {
+    writes = writes.then(async () => {
+        // A response can arrive after a profile switch. Do not write that response
+        // into the new profile's cache, even under an unreachable hashed scope.
+        if (profileConfigDir() === profile)
+            await action();
+    }).catch(() => { });
+}
+function joinRequest(entry, pending, signal) {
+    signal?.throwIfAborted();
+    entry.waiters++;
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        const finish = () => {
+            if (finished)
+                return false;
+            finished = true;
+            signal?.removeEventListener('abort', abort);
+            entry.waiters--;
+            if (!entry.waiters && !entry.background)
+                entry.controller?.abort();
+            return true;
+        };
+        const abort = () => { if (finish())
+            reject(signal.reason); };
+        signal?.addEventListener('abort', abort, { once: true });
+        pending.then(models => { if (finish())
+            resolve([...models]); }, error => { if (finish())
+            reject(error); });
+    });
+}
+function freshModels(entry) {
+    if (entry.models === undefined || entry.checkedAt === null)
+        return undefined;
+    const age = Date.now() - entry.checkedAt;
+    return age >= 0 && age < FRESH_MS ? [...entry.models] : undefined;
+}
+/** Shared discovery for all renderers. Disk rows are previews, not entitlements. */
+export async function loadModelCatalog(options, onVerified) {
+    options.signal?.throwIfAborted();
+    const profile = profileConfigDir();
+    const scope = scopeFor(options);
+    let entry = catalogs.get(scope);
+    if (entry?.controller?.signal.aborted) {
+        catalogs.delete(scope);
+        entry = undefined;
+    }
+    if (!entry) {
+        if (catalogs.size >= MAX_SCOPES) {
+            const oldest = catalogs.keys().next().value;
+            catalogs.get(oldest).controller?.abort();
+            catalogs.delete(oldest);
+        }
+        entry = { checkedAt: null, waiters: 0, background: false, diskChecked: false };
+        catalogs.set(scope, entry);
+    }
+    // Keep the map in access order for bounded eviction.
+    catalogs.delete(scope);
+    catalogs.set(scope, entry);
+    const fresh = freshModels(entry);
+    if (fresh !== undefined) {
+        onVerified?.([...fresh]);
+        return fresh;
+    }
+    if (entry.models === undefined && !entry.pending && !entry.diskChecked) {
+        entry.diskChecked = true;
+        const [cached, fetchedAt] = await Promise.all([readCachedModels(scope), readCachedModelsFetchedAt(scope)]);
+        options.signal?.throwIfAborted();
+        const age = fetchedAt === undefined ? Infinity : Date.now() - fetchedAt;
+        if (entry.models === undefined && cached.length && age >= 0 && age < OFFLINE_MAX_AGE_MS)
+            entry.models = cached;
+    }
+    if (catalogs.get(scope) !== entry)
+        throw new DOMException('Model discovery was superseded', 'AbortError');
+    const afterRead = freshModels(entry);
+    if (afterRead !== undefined) {
+        onVerified?.([...afterRead]);
+        return afterRead;
+    }
+    const current = entry;
+    const refresh = () => {
+        if (current.pending)
+            return current.pending;
+        const controller = new AbortController();
+        current.controller = controller;
+        const pending = listModels({ ...options, signal: controller.signal }).then(models => {
+            controller.signal.throwIfAborted();
+            const cacheable = models.length <= MAX_CACHED_MODELS
+                && models.every(id => id.length <= 256 && !/[\r\n\0]/.test(id));
+            current.models = cacheable ? [...models] : undefined;
+            current.checkedAt = Date.now();
+            persist(profile, () => models.length && cacheable ? writeCachedModels(scope, models) : clearCachedModels(scope));
+            return models;
+        }).catch(error => {
+            // A denial invalidates the preview. Temporary transport errors retain it.
+            if (error instanceof Error && /\((401|403)\)/.test(error.message)) {
+                current.models = undefined;
+                persist(profile, () => clearCachedModels(scope));
+            }
+            throw error;
+        }).finally(() => {
+            if (current.pending === pending) {
+                current.pending = undefined;
+                current.controller = undefined;
+                current.background = false;
+            }
+        });
+        current.pending = pending;
+        return pending;
+    };
+    if (current.models !== undefined) {
+        current.background = true;
+        void refresh().then(models => onVerified?.([...models])).catch(() => { });
+        return [...current.models];
+    }
+    const models = await joinRequest(current, refresh(), options.signal);
+    onVerified?.([...models]);
+    return models;
+}

package/dist/app/ordered_transcript.js

@@ -5,13 +5,34 @@ export function reconcileOrderedTranscript(options) {
     if (!iterations.length)
         return [...live];
     const byIteration = iterations.map(() => []);
+    const answerAnchors = new Map();
+    let answerSearchFrom = iterations[0].start;
     let current = 0;
     for (const message of ordered) {
         if (message.toolCalls?.length)
             current = toolIterations.get(message.toolCalls[0].id) ?? current;
+        else if (isPersistableAssistantMessage(message)) {
+            // A no-tool answer can also precede consumed steering. Its canonical
+            // checkpoint and streamed bubble have different IDs; match in arrival
+            // order so identical text in later iterations still has its own source.
+            let position = live.findIndex(candidate => candidate.id === message.id);
+            if (position < 0)
+                position = live.findIndex((candidate, index) => index >= answerSearchFrom
+                    && isPersistableAssistantMessage(candidate) && candidate.content === message.content);
+            if (position >= iterations[0].start) {
+                answerAnchors.set(message.id, live[position].id);
+                answerSearchFrom = position + 1;
+                current = 0;
+                for (const [index, frame] of iterations.entries())
+                    if (frame.start <= position)
+                        current = index;
+            }
+        }
         byIteration[current].push(message);
     }
     const consumed = new Set(ordered.filter(message => message.role === 'user').map(message => message.id));
+    const acceptedInput = new Map(live.filter(message => message.role === 'user'
+        && !message.metadata?.toolResult).map(message => [message.id, message]));
     const output = live.slice(0, iterations[0].start);
     for (let index = 0; index < iterations.length; index++) {
         const frame = iterations[index];
@@ -19,10 +40,14 @@ export function reconcileOrderedTranscript(options) {
         const segment = live.slice(frame.start, end).filter(message => !consumed.has(message.id));
         const canonical = byIteration[index].find(message => message.toolCalls?.length);
         if (canonical) {
-            const calls = canonical.toolCalls.map(({ result: _result, error: _error, ...call }) => call);
+            const calls = canonical.metadata?.toolCheckpoint === true
+                ? canonical.toolCalls.map(call => ({ ...call }))
+                : canonical.toolCalls.map(({ result: _result, error: _error, ...call }) => call);
             const beforeTools = live.slice(frame.start, frame.toolStart ?? end);
             const anchorId = beforeTools.filter(isPersistableAssistantMessage).at(-1)?.id;
-            const anchor = segment.findIndex(message => message.id === anchorId);
+            const recorded = segment.findIndex(message => message.id === canonical.id
+                || message.toolCalls?.some(call => canonical.toolCalls.some(source => source.id === call.id)));
+            const anchor = recorded >= 0 ? recorded : segment.findIndex(message => message.id === anchorId);
             if (anchor >= 0) {
                 segment[anchor] = { ...segment[anchor], toolCalls: calls,
                     metadata: { ...segment[anchor].metadata, ...canonical.metadata, toolCallsInTranscript: true } };
@@ -34,10 +59,24 @@ export function reconcileOrderedTranscript(options) {
                 const alreadyDisplayed = segment.filter(isPersistableAssistantMessage).map(message => message.content).join('') === canonical.content;
                 segment.splice(trace < 0 ? segment.length : trace, 0, { ...canonical,
                     content: alreadyDisplayed ? '[Using tools...]' : canonical.content,
-                    toolCalls: calls, metadata: { ...canonical.metadata, toolCallsInTranscript: true } });
+                    toolCalls: calls, metadata: { ...canonical.metadata, toolCallsInTranscript: true,
+                        toolUseOnly: !canonical.content.trim() || canonical.content === '[Using tools...]' } });
             }
         }
-        output.push(...segment, ...byIteration[index].filter(message => message !== canonical));
+        const additional = byIteration[index].filter(message => message !== canonical).flatMap(message => {
+            const anchorId = answerAnchors.get(message.id);
+            if (anchorId !== undefined) {
+                const anchor = segment.findIndex(candidate => candidate.id === anchorId);
+                if (anchor >= 0) {
+                    segment[anchor] = { ...segment[anchor], content: message.content,
+                        metadata: { ...segment[anchor].metadata, ...message.metadata } };
+                    return [];
+                }
+            }
+            const accepted = acceptedInput.get(message.id);
+            return [accepted ? { ...message, metadata: { ...message.metadata, ...accepted.metadata } } : message];
+        });
+        output.push(...segment, ...additional);
     }
     if (finalMessage) {
         const finalFrame = iterations.length - 1;

package/dist/app/prompt_turn.d.ts

@@ -0,0 +1,14 @@
+import type { ModelUsageObserver, PromptTurnMetadata } from '../types.js';
+/** One human prompt owns its main requests and workers across retries/continuations. */
+export declare class PromptTurn {
+    private readonly changed;
+    private metadata;
+    private mainRuns;
+    private workers;
+    readonly observe: ModelUsageObserver;
+    constructor(id: string, changed: () => void, startedAt?: number);
+    snapshot(): PromptTurnMetadata;
+    start(): void;
+    finish(): void;
+    private settle;
+}

package/dist/app/prompt_turn.js

@@ -0,0 +1,53 @@
+/** One human prompt owns its main requests and workers across retries/continuations. */
+export class PromptTurn {
+    changed;
+    metadata;
+    mainRuns = 0;
+    workers = 0;
+    observe;
+    constructor(id, changed, startedAt = Date.now()) {
+        this.changed = changed;
+        this.metadata = { id, startedAt, tokens: 0, estimated: false };
+        this.observe = Object.assign((usage) => {
+            const tokens = usage.totalTokens;
+            this.metadata = {
+                ...this.metadata,
+                tokens: this.metadata.tokens + (Number.isFinite(tokens) && tokens >= 0 ? tokens : 0),
+                estimated: this.metadata.estimated || usage.estimated === true || !Number.isFinite(tokens) || tokens < 0,
+                ...(usage.unreported === true ? { usageIncomplete: true } : {}),
+            };
+            this.changed();
+        }, {
+            getTurn: () => this.snapshot(),
+            workerStarted: () => {
+                this.workers++;
+                this.metadata = { ...this.metadata, finishedAt: undefined };
+                this.changed();
+                let finished = false;
+                return () => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    this.workers--;
+                    this.settle();
+                };
+            },
+        });
+    }
+    snapshot() { return { ...this.metadata }; }
+    start() {
+        this.mainRuns++;
+        this.metadata = { ...this.metadata, finishedAt: undefined };
+        this.changed();
+    }
+    finish() {
+        this.mainRuns = Math.max(0, this.mainRuns - 1);
+        this.settle();
+    }
+    settle() {
+        if (this.mainRuns === 0 && this.workers === 0) {
+            this.metadata = { ...this.metadata, finishedAt: this.metadata.finishedAt ?? Date.now() };
+        }
+        this.changed();
+    }
+}

package/dist/app/recap.d.ts

@@ -4,6 +4,7 @@
  * a back-to-back idle transition aborts the previous call.
  */
 import { Message } from '../types.js';
+import type { ModelUsageObserver } from '../types.js';
 export declare const RECAP_MIN_DURATION_MS = 60000;
 export declare const RECAP_MIN_TOOL_CALLS = 4;
 export declare const RECAP_MIN_OUTPUT_TOKENS = 600;
@@ -27,6 +28,7 @@ export interface RecapRequest {
     model: string;
     apiKey: string;
     onRecap: (content: string) => void;
+    onUsage?: ModelUsageObserver;
     /** Test seam — bypasses the real backend call. */
     llm?: (args: {
         provider: string;
@@ -35,6 +37,7 @@ export interface RecapRequest {
         system: string;
         prompt: string;
         signal: AbortSignal;
+        onUsage?: ModelUsageObserver;
     }) => Promise<string>;
 }
 export interface RecapController {

package/dist/app/recap.js

@@ -75,7 +75,11 @@ async function defaultLlm(args) {
             messages: [{ role: 'user', content: args.prompt }],
             tools: [],
             signal: args.signal,
+        }).catch(error => {
+            args.onUsage?.({ inputTokens: 0, outputTokens: 0, totalTokens: 0, estimated: true, unreported: true });
+            throw error;
         });
+        args.onUsage?.(response.usage ?? { inputTokens: 0, outputTokens: 0, totalTokens: 0, estimated: true, unreported: true });
         return response.content
             .filter((b) => b.type === 'text')
             .map(b => b.text)
@@ -102,14 +106,16 @@ class RecapControllerImpl {
         const aborter = new AbortController();
         this.aborter = aborter;
         const llm = args.llm ?? defaultLlm;
-        llm({
+        const workerFinished = args.onUsage?.workerStarted?.();
+        Promise.resolve().then(() => llm({
             provider: args.provider,
             model: args.model,
             apiKey: args.apiKey,
             system: RECAP_SYSTEM_PROMPT,
             prompt: `Recent turn:\n\n${conversationText}`,
             signal: aborter.signal,
-        })
+            onUsage: args.onUsage,
+        }))
             .then((text) => {
             if (aborter.signal.aborted)
                 return;
@@ -130,7 +136,7 @@ class RecapControllerImpl {
             }
             if (this.aborter === aborter)
                 this.aborter = null;
-        });
+        }).finally(() => workerFinished?.());
     }
     cancel() {
         if (this.aborter) {

package/dist/app/restart.d.ts

@@ -1,4 +1,5 @@
 import type { RustEvent } from '../ui/ratatui/protocol.js';
+import type { DesktopRuntime } from '../desktop/runtime.js';
 export interface HotRestartLaunch {
     command: string;
     args: string[];
@@ -69,7 +70,7 @@ export declare function reduceDesktopUpdateOwnerHandshake(phase: DesktopUpdateOw
  */
 export declare function prepareDesktopUpdateAuthorization(persistSession: (force: true) => Promise<void>, send: (command: DesktopUpdateRestartCommand) => boolean): Promise<DesktopUpdatePreparation>;
 export declare function buildHotRestartArgs(argv: readonly string[], sessionId: string): string[];
-export declare function buildHotRestartLaunch(argv: readonly string[], sessionId: string, execPath: string): HotRestartLaunch;
-export declare function buildDesktopUpdateRelaunchContext(argv: readonly string[], sessionId: string, execPath: string, cwd: string, ownerPid: number): string;
+export declare function buildHotRestartLaunch(argv: readonly string[], sessionId: string, execPath: string, cwd?: string, desktopRuntime?: DesktopRuntime | null): HotRestartLaunch;
+export declare function buildDesktopUpdateRelaunchContext(argv: readonly string[], sessionId: string, execPath: string, cwd: string, ownerPid: number, desktopRuntime?: DesktopRuntime | null): string;
 export declare function requestColonyCellRestart(env?: Record<string, string | undefined>, fetchImpl?: typeof fetch): Promise<void>;
 export {};

package/dist/app/restart.js

@@ -1,3 +1,6 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolveOwnedCliLaunch } from '../desktop/cli_launch.js';
 const RESTART_SESSION_FLAGS = new Set(['--resume', '--continue', '-c', '--session-id']);
 /**
  * Reduce native updater protocol events and local persistence outcomes into
@@ -113,18 +116,30 @@ export function buildHotRestartArgs(argv, sessionId) {
     }
     return [...next, '--resume', sessionId];
 }
-export function buildHotRestartLaunch(argv, sessionId, execPath) {
+export function buildHotRestartLaunch(argv, sessionId, execPath, cwd, desktopRuntime) {
     const relaunchArgs = buildHotRestartArgs(argv, sessionId);
+    // The picker can switch workspaces. Override a launcher's original --cwd;
+    // cli_main deliberately uses the last occurrence of that flag.
+    if (cwd)
+        relaunchArgs.push('--cwd', cwd);
+    const owned = resolveOwnedCliLaunch(relaunchArgs.slice(1), desktopRuntime);
+    if (owned)
+        return owned;
     const entryScript = relaunchArgs[0] || '';
-    const isTsEntry = entryScript.endsWith('.ts');
+    const isTsEntry = /\.[cm]?tsx?$/.test(entryScript);
+    // Resolve from this installation, not the selected session's working dir.
+    // Direct argv also preserves spaces/metacharacters without a shell or npx.
+    const loaderArgs = isTsEntry
+        ? ['--import', pathToFileURL(createRequire(import.meta.url).resolve('tsx')).href]
+        : [];
     return {
-        command: isTsEntry ? 'npx' : execPath,
-        args: isTsEntry ? ['tsx', ...relaunchArgs] : relaunchArgs,
-        shell: isTsEntry,
+        command: execPath,
+        args: [...loaderArgs, ...relaunchArgs],
+        shell: false,
     };
 }
-export function buildDesktopUpdateRelaunchContext(argv, sessionId, execPath, cwd, ownerPid) {
-    const launch = buildHotRestartLaunch(argv, sessionId, execPath);
+export function buildDesktopUpdateRelaunchContext(argv, sessionId, execPath, cwd, ownerPid, desktopRuntime) {
+    const launch = buildHotRestartLaunch(argv, sessionId, execPath, undefined, desktopRuntime);
     const command = launch.shell ? '/usr/bin/env' : launch.command;
     const args = launch.shell ? [launch.command, ...launch.args] : launch.args;
     return JSON.stringify({

package/dist/app/rewind.d.ts

@@ -1,8 +1,8 @@
 /**
- * Rewind — pure helpers behind the Esc-while-idle prompt picker.
+ * Rewind — pure helpers behind the explicit /rewind prompt picker.
  *
- * Esc during a run interrupts the agent but keeps the turn in the transcript.
- * Esc while idle is the explicit way back out: the picker lists the prompts the
+ * Confirmed Escape stops a run but keeps its turn in the transcript.
+ * /rewind is the explicit way back out: the picker lists the prompts the
  * user sent (newest first) and rewinding to one drops that prompt and
  * everything after it, then hands the prompt text and attachments back to the
  * composer so the user can edit and resend.

package/dist/app/rewind.js

@@ -1,8 +1,8 @@
 /**
- * Rewind — pure helpers behind the Esc-while-idle prompt picker.
+ * Rewind — pure helpers behind the explicit /rewind prompt picker.
  *
- * Esc during a run interrupts the agent but keeps the turn in the transcript.
- * Esc while idle is the explicit way back out: the picker lists the prompts the
+ * Confirmed Escape stops a run but keeps its turn in the transcript.
+ * /rewind is the explicit way back out: the picker lists the prompts the
  * user sent (newest first) and rewinding to one drops that prompt and
  * everything after it, then hands the prompt text and attachments back to the
  * composer so the user can edit and resend.

package/dist/app/selection_completion.d.ts

@@ -1,3 +1,6 @@
+import { type RouterCatalog } from '../utils/router_catalog.js';
+import { type ReasoningContract } from '../utils/reasoning.js';
+import type { CodexReasoningEffort } from '../config/types.js';
 import { type SlashCommandUsage } from '../agent/commands/usage_spec.js';
 export interface SelectionCandidate {
     value: string;
@@ -8,7 +11,9 @@ export interface SelectionCandidate {
     needsArgument?: boolean;
 }
 export interface SelectionCompletionView {
-    kind?: 'command' | 'provider' | 'model' | 'usage';
+    kind?: 'command' | 'provider' | 'model' | 'usage' | 'reasoning';
+    command?: 'effort' | 'thinking';
+    model?: string;
     query?: string;
     usage?: string;
     provider?: string;
@@ -22,6 +27,13 @@ export interface SelectionCompletionView {
     unavailable?: boolean;
     visibleRows?: number;
 }
+export interface ReasoningCompletionContext {
+    catalog?: RouterCatalog;
+    current?: CodexReasoningEffort;
+    contract?: ReasoningContract;
+    /** Opaque account/profile identity; invalidate definitions when it changes. */
+    scope?: string;
+}
 export declare function fuzzySelections(candidates: SelectionCandidate[], query: string): SelectionCandidate[];
 export declare function modelSelections(provider: string, discovered?: string[]): SelectionCandidate[];
 /** Static preview for renderers without a completion controller. Explicit null hides it. */
@@ -49,8 +61,10 @@ export declare class SelectionCompletion {
     private requestController;
     private commands;
     private currentModel?;
+    private routerCatalog?;
+    private reasoning;
     constructor(changed?: () => void);
-    update(text: string, provider: string, loadModels?: (signal: AbortSignal, provider: string, authMode?: 'direct' | 'zrouter') => Promise<string[]>, commands?: SlashCommandUsage[], currentModel?: string): void;
+    update(text: string, provider: string, loadModels?: (signal: AbortSignal, provider: string, authMode?: 'direct' | 'zrouter') => Promise<string[]>, commands?: SlashCommandUsage[], currentModel?: string, loadCatalog?: (signal: AbortSignal) => Promise<RouterCatalog>, activeRouted?: boolean, reasoning?: ReasoningCompletionContext): void;
     private filter;
     private revealSelection;
     setVisibleRows(rows: number): void;
@@ -73,6 +87,7 @@ export declare class SelectionCompletion {
     }): {
         handled: boolean;
         text?: string;
+        submit?: boolean;
     };
 }
 export declare const SELECTION_VISIBLE_ROWS = 4;