@kilnai/cli 1.0.7 → 2.1.0

package/dist/commands/tui.js

@@ -1,17 +1,236 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { loadResumeSidebarInfo, } from "../application/resume-sidebar-info.js";
 import { inferResumeStrategyFeedback } from "../application/resume-strategy-feedback.js";
 import { collectResumeSignals, decideResumeStrategy } from "../application/resume-strategy-policy.js";
+import { deriveSessionMetadata, shouldPromoteLatestPromptToSessionTitle, } from "../application/session-metadata.js";
 import { buildCliPlanSummaryArtifactKeyFromShape, buildCliProjectSummaryArtifactKey, buildCliSessionSummaryArtifactKey, } from "../application/context-artifact-keys.js";
-import { readGlobalConfig } from "../config/global-config.js";
+import { readGlobalConfig, resolveGlobalDefaultModel, resolveGlobalDefaultProvider, resolveGlobalUiTheme, } from "../config/global-config.js";
+import { withGlobalIdentityContext } from "../config/operator-identity-context.js";
+import { withContextCandidates } from "../application/agent-skill-context.js";
+import { resolveInstructionProfileContextCandidates } from "../application/instruction-profile-context.js";
+import { withWorkGovernanceContext } from "../application/work-governance-context.js";
+import { createTranscriptRuntimeSessionHydrator } from "../application/runtime-session-rehydration.js";
+import { readConfigStatusSnapshot } from "../application/config-status.js";
+import { readKilnYaml } from "../kiln-yaml.js";
+import { loadKilnConfig } from "../config/config-merger.js";
 import { resolveEffectiveProvider } from "../config/env-config.js";
-import { createDefaultRegistry, getProviderDisplayInfo } from "../wrapper/session-registry.js";
+import { resolveOperatorVoiceRuntime } from "../config/operator-voice.js";
+import { createManagedDirectProviderAdapterFactory } from "../config/managed-agent-direct-adapters.js";
+import { createKilnConfigTools } from "../application/config-tools.js";
+import { createWorkGovernanceTools } from "../application/work-governance-tool.js";
+import { discoverManagedAgentProviderModels } from "../config/managed-agent-provider-models.js";
+import { resolveManagedInvocationToolOptions } from "../config/managed-agent-routes.js";
+import { loadConfiguredBuiltinToolSurfaceOptions } from "../config/builtin-tool-surface-config.js";
+import { resolveEngineAvailabilityMap } from "../engines/engine-registry.js";
+import { createDefaultRegistry, getProviderDisplayInfo, getRuntimeProviderAvailability, } from "../wrapper/session-registry.js";
 import { SessionStore, TranscriptStore } from "../wrapper/session-store.js";
 import { GatewaySession, waitForGateway, themes, kilnDark } from "@kilnai/tui";
+import { GUI_PROVIDER_DISPLAY_ORDER, formatPresentationIntentAsText, getGuiProviderMetadata, isGuiProviderModeless, presentOperatorEventPayload, } from "@kilnai/gateway-contracts";
+import { GoalRunStore, WorkItemStore, createSessionBuiltinToolOptions, extractText, } from "@kilnai/core";
 import { getProjectContextArtifactCache } from "@kilnai/runtime";
+import { createProviderCatalogService, projectGuiOperatorModels, providerRequiresSelectedModelMessage, resolveGuiOperatorDiscoveryResults, resolveGuiProviderSwitch, } from "@kilnai/runtime";
+import { persistTuiThemePreference } from "../application/operator-theme-preferences.js";
+function writeTuiBootstrapStatus(message) {
+    if (!process.stderr.isTTY) {
+        return;
+    }
+    process.stderr.write(`${message}\n`);
+}
+function normalizeProviderModels(models) {
+    const unique = new Set();
+    for (const model of models ?? []) {
+        const trimmed = model.trim();
+        if (trimmed.length > 0) {
+            unique.add(trimmed);
+        }
+    }
+    return [...unique];
+}
+function buildTuiStartupProviderDisplayInfo(input) {
+    const providerById = new Map();
+    for (const provider of input.providerDisplayInfo) {
+        providerById.set(provider.id, provider);
+    }
+    const orderedProviderIds = [];
+    const seen = new Set();
+    const addOrderedProviderId = (providerId) => {
+        if (seen.has(providerId) || !providerById.has(providerId)) {
+            return;
+        }
+        seen.add(providerId);
+        orderedProviderIds.push(providerId);
+    };
+    for (const provider of input.providerDisplayInfo) {
+        addOrderedProviderId(provider.id);
+    }
+    for (const providerId of GUI_PROVIDER_DISPLAY_ORDER) {
+        addOrderedProviderId(providerId);
+    }
+    return orderedProviderIds.flatMap((providerId) => {
+        const provider = providerById.get(providerId);
+        if (!provider) {
+            return [];
+        }
+        const runtimeModels = normalizeProviderModels(input.runtimeModels[providerId]);
+        const models = runtimeModels;
+        const runtimeCatalogContainsProvider = Object.prototype.hasOwnProperty.call(input.runtimeModels, providerId);
+        const discovery = input.runtimeDiscovery?.find((entry) => entry.provider === providerId);
+        const metadata = getGuiProviderMetadata(providerId);
+        const includeAuthProvider = Boolean(metadata?.authMethod
+            && discovery
+            && !discovery.available
+            && (discovery.authState === "missing" || discovery.authState === "expired"));
+        if (models.length === 0) {
+            const includeModelessProvider = input.includeModelessProviders === true
+                && runtimeCatalogContainsProvider
+                && isGuiProviderModeless(providerId);
+            if (!includeModelessProvider && !includeAuthProvider && !input.includePendingProviders) {
+                return [];
+            }
+        }
+        return [{
+                ...provider,
+                models,
+                available: discovery?.available,
+                reason: discovery?.reason,
+            }];
+    });
+}
+function assertTuiProviderAvailableInStartupCatalog(provider, startupProviderDisplayInfo) {
+    const startupProvider = startupProviderDisplayInfo.find((entry) => entry.id === provider);
+    if (startupProvider && (startupProvider.models.length > 0 || isGuiProviderModeless(provider))) {
+        return;
+    }
+    const metadata = getGuiProviderMetadata(provider);
+    const startupAvailability = startupProvider;
+    if (metadata?.authMethod && startupAvailability?.available === false) {
+        return;
+    }
+    const runtimeProviderIds = startupProviderDisplayInfo
+        .filter((entry) => entry.models.length > 0 || isGuiProviderModeless(entry.id))
+        .map((entry) => entry.id);
+    const availableProviders = runtimeProviderIds.length > 0 ? runtimeProviderIds.join(", ") : "none";
+    throw new Error(`Provider '${provider}' is not available in the runtime TUI model catalog. Available providers: ${availableProviders}`);
+}
+function latestUserText(messages) {
+    if (!messages) {
+        return undefined;
+    }
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role !== "user") {
+            continue;
+        }
+        const text = extractText(message.parts).trim();
+        return text.length > 0 ? text : undefined;
+    }
+    return undefined;
+}
 function parseProvider(p, providerIds) {
-    if (p && providerIds.includes(p)) {
-        return p;
+    const requestedProvider = p?.trim() ?? "";
+    if (requestedProvider.length === 0) {
+        throw new Error("No provider configured. Set --provider, KILN_PROVIDER, or global provider.");
+    }
+    if (providerIds.includes(requestedProvider)) {
+        return requestedProvider;
     }
-    return providerIds.includes("claude") ? "claude" : providerIds[0] ?? "claude";
+    throw new Error(`Unknown provider: ${requestedProvider}`);
+}
+function mapTranscriptTypeToKind(type) {
+    switch (type) {
+        case "user":
+            return "user_message";
+        case "text_delta":
+            return "assistant_delta";
+        case "tool_use":
+            return "tool_call_started";
+        case "tool_result":
+            return "tool_call_completed";
+        case "error":
+            return "error_recorded";
+        default:
+            return "assistant_message";
+    }
+}
+function mapTranscriptTypeToSource(type, surface) {
+    const component = surface === "gui" ? "gui-command" : "tui-command";
+    switch (type) {
+        case "user":
+            return { actor: "user", surface, component };
+        case "text_delta":
+            return { actor: "assistant", surface, component };
+        case "tool_use":
+        case "tool_result":
+            return { actor: "tool", surface, component };
+        case "error":
+            return { actor: "runtime", surface, component };
+        default:
+            return { actor: "system", surface, component };
+    }
+}
+function toPersistedTranscriptEvent(sessionId, sequence, type, payload, surface, turnId) {
+    return {
+        eventId: randomUUID(),
+        kilnSessionId: sessionId,
+        sequence,
+        timestamp: new Date().toISOString(),
+        kind: mapTranscriptTypeToKind(type),
+        source: mapTranscriptTypeToSource(type, surface),
+        ...(turnId ? { turnId } : {}),
+        payload,
+    };
+}
+function persistedEvent(sessionId, sequence, kind, source, payload, turnId) {
+    return {
+        eventId: randomUUID(),
+        kilnSessionId: sessionId,
+        sequence,
+        timestamp: new Date().toISOString(),
+        kind,
+        source,
+        ...(turnId ? { turnId } : {}),
+        payload,
+    };
+}
+function parseToolResultEnvelope(value) {
+    if (!value)
+        return { output: "" };
+    try {
+        const parsed = JSON.parse(value);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { output: value };
+        }
+        const record = parsed;
+        const output = typeof record.output === "string" ? record.output : value;
+        const metadata = record.metadata && typeof record.metadata === "object" && !Array.isArray(record.metadata)
+            ? record.metadata
+            : undefined;
+        return {
+            output,
+            ...(typeof record.isError === "boolean" ? { isError: record.isError } : {}),
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+    catch {
+        return { output: value };
+    }
+}
+function buildToolResultPayload(input) {
+    const full = parseToolResultEnvelope(input.output);
+    const summary = parseToolResultEnvelope(input.outputSummary);
+    const outputSummary = summary.output || full.output.slice(0, 200);
+    const isError = full.isError ?? input.isError ?? false;
+    return {
+        toolCallId: input.toolCallId,
+        toolName: input.toolName,
+        output: full.output,
+        outputSummary,
+        ...(full.metadata ? { metadata: full.metadata } : {}),
+        status: {
+            state: isError ? "failed" : "succeeded",
+        },
+    };
 }
 function resolveTuiStartupTransport(_flags) {
     if (process.env.KILN_TUI_TRANSPORT?.toLowerCase() === "direct") {
@@ -23,24 +242,14 @@ function resolveTuiStartupTransport(_flags) {
  * Dynamic session factory that supports cross-provider session management.
  * Each provider maintains independent session state, allowing seamless switching.
  */
-export async function makeMultiProviderSessionFactory(initialProvider, providerIds, cwd, registry, sessionStore, transcriptStore, contextArtifactCache) {
+export async function makeMultiProviderSessionFactory(initialProvider, providerIds, cwd, registry, sessionStore, transcriptStore, contextArtifactCache, builtinToolOptions, transcriptSurface = "tui", managedInvocation) {
     const providers = providerIds;
     // Per-provider session state
     const providerState = new Map(providers.map((provider) => [provider, {}]));
+    const providerModelState = new Map(providers.map((provider) => [provider, ""]));
+    const sessionBuiltinToolOptions = createSessionBuiltinToolOptions(builtinToolOptions);
     let currentProvider = initialProvider;
-    let currentModel = "";
-    // Load last session for each provider
-    for (const p of providers) {
-        const lastRecord = await sessionStore.last(p);
-        if (lastRecord) {
-            const state = providerState.get(p);
-            if (!state)
-                continue;
-            state.resumeSessionId = lastRecord.sessionId;
-            state.providerSessionId = lastRecord.providerSessionId;
-        }
-    }
-    const policyAwareFactory = (systemPrompt, sessionCwd) => {
+    const policyAwareFactory = (systemPrompt, sessionCwd, context) => {
         let activeSession = null;
         return {
             get capabilities() {
@@ -65,7 +274,10 @@ export async function makeMultiProviderSessionFactory(initialProvider, providerI
             },
             run: async function* (options) {
                 const providerForTurn = currentProvider;
-                const modelForTurn = currentModel || undefined;
+                if (!providerForTurn) {
+                    throw new Error("No provider selected for this turn.");
+                }
+                const modelForTurn = providerModelState.get(providerForTurn) || undefined;
                 const state = providerState.get(providerForTurn) ?? {};
                 const resumedFrom = state.resumeSessionId;
                 const projectArtifactKey = buildCliProjectSummaryArtifactKey(cwd);
@@ -94,16 +306,47 @@ export async function makeMultiProviderSessionFactory(initialProvider, providerI
                     cwd: sessionCwd || cwd,
                     permissionPolicy: { approval: "never", sandbox: "workspace-write" },
                     resumeSessionId: decision.shouldUseProviderNativeResume ? resumedFrom : undefined,
+                    sessionLedgerOwner: "host",
                     model: modelForTurn,
+                    reasoningEffort: options.reasoningEffort,
+                    ...(context?.operatorSurface ? { operatorSurface: context.operatorSurface } : {}),
+                    builtinToolOptions: sessionBuiltinToolOptions,
+                    ...(managedInvocation ? { managedInvocation } : {}),
                 });
                 activeSession = resumedSession;
-                const capturedId = resumedSession.sessionId;
+                const capturedId = options.kilnSessionId ?? context?.kilnSessionId ?? resumedFrom ?? resumedSession.sessionId;
+                const [existingRecord, existingMeta] = await Promise.all([
+                    sessionStore.find(capturedId),
+                    transcriptStore.readMeta(capturedId),
+                ]);
+                const task = existingMeta?.task ?? existingRecord?.task ?? "interactive";
+                const shouldPromoteLatestPrompt = shouldPromoteLatestPromptToSessionTitle({
+                    existingTitle: existingMeta?.canonicalTitle ?? existingRecord?.canonicalTitle ?? existingMeta?.title ?? existingRecord?.title,
+                    latestPrompt: options.prompt,
+                });
+                const metadata = deriveSessionMetadata({
+                    task,
+                    prompt: options.prompt,
+                    provider: providerForTurn,
+                    model: modelForTurn,
+                    canonicalTitle: shouldPromoteLatestPrompt ? undefined : existingMeta?.canonicalTitle ?? existingRecord?.canonicalTitle,
+                    title: shouldPromoteLatestPrompt ? undefined : existingMeta?.title ?? existingRecord?.title,
+                    summary: shouldPromoteLatestPrompt ? undefined : existingMeta?.summary ?? existingRecord?.summary,
+                    tags: existingMeta?.tags ?? existingRecord?.tags,
+                    providersUsed: existingMeta?.providersUsed ?? existingRecord?.providersUsed,
+                });
+                const startedAt = existingMeta?.startedAt ?? new Date().toISOString();
                 if (typeof transcriptStore.init === "function") {
                     await transcriptStore.init(capturedId, {
                         kilnSessionId: capturedId,
                         provider: providerForTurn,
-                        task: "interactive",
-                        startedAt: new Date().toISOString(),
+                        canonicalTitle: metadata.canonicalTitle,
+                        title: metadata.title,
+                        summary: metadata.summary,
+                        tags: metadata.tags,
+                        providersUsed: metadata.providersUsed,
+                        task,
+                        startedAt,
                         resumeStrategy,
                         resumeFeedback,
                         sessionLedger: {
@@ -114,28 +357,138 @@ export async function makeMultiProviderSessionFactory(initialProvider, providerI
                     });
                 }
                 let turnCostUsd = 0;
+                let turnIsError = false;
+                let assistantContent = "";
+                let assistantDeltaIndex = 0;
+                const pendingToolCallIds = new Map();
+                let syntheticToolOrdinal = 0;
+                const priorTranscript = await transcriptStore.readTranscript(capturedId);
+                let transcriptSeq = priorTranscript.length;
+                const turnOrdinal = priorTranscript.filter((event) => event.kind === "turn_started").length + 1;
+                const turnId = `${capturedId}:turn:${turnOrdinal}`;
+                const assistantMessageId = `${turnId}:assistant`;
+                const source = (actor) => ({
+                    actor,
+                    surface: transcriptSurface,
+                    component: transcriptSurface === "gui" ? "gui-command" : "tui-command",
+                });
+                await transcriptStore.append(capturedId, persistedEvent(capturedId, ++transcriptSeq, "turn_started", source("runtime"), {
+                    turnId,
+                    turnOrdinal,
+                    trigger: "user_message",
+                }, turnId));
+                const userText = latestUserText(options.messages) ?? options.prompt.trim();
+                if (userText) {
+                    await transcriptStore.append(capturedId, toPersistedTranscriptEvent(capturedId, ++transcriptSeq, "user", {
+                        messageId: `${turnId}:user`,
+                        content: userText,
+                    }, transcriptSurface, turnId));
+                }
                 try {
                     for await (const event of resumedSession.run(options)) {
-                        if (event
-                            && typeof event === "object"
-                            && "type" in event
-                            && event.type === "completed") {
+                        if (!event || typeof event !== "object" || !("type" in event)) {
+                            yield event;
+                            continue;
+                        }
+                        if (event.type === "text_delta" && !event.isThinking) {
+                            assistantContent += event.content;
+                            await transcriptStore.append(capturedId, toPersistedTranscriptEvent(capturedId, ++transcriptSeq, "text_delta", {
+                                messageId: assistantMessageId,
+                                delta: event.content,
+                                deltaIndex: assistantDeltaIndex++,
+                            }, transcriptSurface, turnId));
+                        }
+                        else if (event.type === "tool_use") {
+                            const toolCallId = event.toolCallId ?? `${turnId}:tool:${++syntheticToolOrdinal}`;
+                            const pending = pendingToolCallIds.get(event.toolName) ?? [];
+                            pending.push(toolCallId);
+                            pendingToolCallIds.set(event.toolName, pending);
+                            await transcriptStore.append(capturedId, toPersistedTranscriptEvent(capturedId, ++transcriptSeq, "tool_use", {
+                                toolCallId,
+                                toolName: event.toolName,
+                                input: event.input,
+                            }, transcriptSurface, turnId));
+                        }
+                        else if (event.type === "tool_result") {
+                            const pending = pendingToolCallIds.get(event.toolName);
+                            let toolCallId;
+                            if (event.toolCallId) {
+                                toolCallId = event.toolCallId;
+                                const pendingIndex = pending?.indexOf(event.toolCallId) ?? -1;
+                                if (pending && pendingIndex >= 0) {
+                                    pending.splice(pendingIndex, 1);
+                                }
+                            }
+                            else {
+                                toolCallId = pending?.shift();
+                            }
+                            if (pending && pending.length === 0) {
+                                pendingToolCallIds.delete(event.toolName);
+                            }
+                            if (!toolCallId) {
+                                toolCallId = `${turnId}:tool:${++syntheticToolOrdinal}`;
+                                await transcriptStore.append(capturedId, toPersistedTranscriptEvent(capturedId, ++transcriptSeq, "tool_use", {
+                                    toolCallId,
+                                    toolName: event.toolName,
+                                }, transcriptSurface, turnId));
+                            }
+                            await transcriptStore.append(capturedId, toPersistedTranscriptEvent(capturedId, ++transcriptSeq, "tool_result", buildToolResultPayload({
+                                toolCallId,
+                                toolName: event.toolName,
+                                output: event.output,
+                                ...(event.outputSummary !== undefined ? { outputSummary: event.outputSummary } : {}),
+                                ...(event.isError !== undefined ? { isError: event.isError } : {}),
+                            }), transcriptSurface, turnId));
+                        }
+                        else if (event.type === "error") {
+                            turnIsError = true;
+                            await transcriptStore.append(capturedId, toPersistedTranscriptEvent(capturedId, ++transcriptSeq, "error", {
+                                message: event.message,
+                                code: event.code,
+                                retriable: event.isRetryable,
+                            }, transcriptSurface, turnId));
+                        }
+                        if (event.type === "completed") {
                             turnCostUsd = event.totalUsd;
+                            turnIsError = event.isError;
                         }
                         yield event;
                     }
                 }
                 finally {
+                    if (assistantContent.trim().length > 0) {
+                        await transcriptStore.append(capturedId, persistedEvent(capturedId, ++transcriptSeq, "assistant_message", source("assistant"), {
+                            messageId: assistantMessageId,
+                            content: assistantContent,
+                            provider: {
+                                provider: providerForTurn,
+                                ...(modelForTurn ? { model: modelForTurn } : { model: providerForTurn }),
+                            },
+                        }, turnId));
+                    }
+                    await transcriptStore.append(capturedId, persistedEvent(capturedId, ++transcriptSeq, "turn_completed", source("runtime"), {
+                        turnId,
+                        outcome: turnIsError ? "failed" : "completed",
+                        ...(assistantContent.trim().length > 0 ? { outputMessageId: assistantMessageId } : {}),
+                    }, turnId));
                     await resumedSession.dispose();
-                    const currentState = providerState.get(providerForTurn);
-                    if (currentState) {
-                        currentState.resumeSessionId = capturedId;
-                        currentState.providerSessionId = resumedSession.providerSessionId;
+                    for (const [providerId, providerRuntimeState] of providerState) {
+                        providerRuntimeState.resumeSessionId = capturedId;
+                        if (providerId === providerForTurn) {
+                            providerRuntimeState.providerSessionId = resumedSession.providerSessionId;
+                        }
                     }
                     if (typeof transcriptStore.finalize === "function") {
                         await transcriptStore.finalize(capturedId, {
                             completedAt: new Date().toISOString(),
-                            providerSessionId: resumedSession.providerSessionId,
+                            canonicalTitle: metadata.canonicalTitle,
+                            title: metadata.title,
+                            summary: metadata.summary,
+                            tags: metadata.tags,
+                            providersUsed: metadata.providersUsed,
+                            providerThread: resumedSession.providerSessionId
+                                ? { provider: providerForTurn, nativeSessionId: resumedSession.providerSessionId }
+                                : undefined,
                             resumeStrategy,
                             resumeFeedback,
                             sessionLedger: {
@@ -149,11 +502,18 @@ export async function makeMultiProviderSessionFactory(initialProvider, providerI
                     await sessionStore.append({
                         sessionId: capturedId,
                         provider: providerForTurn,
-                        task: "interactive",
+                        task,
+                        canonicalTitle: metadata.canonicalTitle,
+                        title: metadata.title,
+                        summary: metadata.summary,
+                        tags: metadata.tags,
+                        providersUsed: metadata.providersUsed,
                         completedAt: new Date().toISOString(),
                         cost: turnCostUsd,
                         projectPath: cwd,
-                        providerSessionId: resumedSession.providerSessionId,
+                        providerThread: resumedSession.providerSessionId
+                            ? { provider: providerForTurn, nativeSessionId: resumedSession.providerSessionId }
+                            : undefined,
                         resumeStrategy,
                     });
                     if (activeSession === resumedSession) {
@@ -171,86 +531,75 @@ export async function makeMultiProviderSessionFactory(initialProvider, providerI
     };
     return {
         factory: policyAwareFactory,
-        getProvider: () => currentProvider,
+        getProvider: () => currentProvider ?? "",
         setProvider: (newProvider) => {
             if (providers.includes(newProvider)) {
                 currentProvider = newProvider;
             }
         },
-        getModel: () => currentModel,
+        getModel: () => currentProvider ? providerModelState.get(currentProvider) ?? "" : "",
         setModel: (model) => {
-            currentModel = model;
+            if (currentProvider) {
+                providerModelState.set(currentProvider, model);
+            }
         },
         onClear: async (provider) => {
-            const p = (provider && providers.includes(provider))
-                ? provider
-                : currentProvider;
-            const state = providerState.get(p);
-            if (state) {
+            for (const state of providerState.values()) {
                 state.resumeSessionId = undefined;
                 state.providerSessionId = undefined;
             }
-            await sessionStore.clearLast(p);
+            await sessionStore.clearResumeTarget(provider);
         },
         setResumeSession: (sessionId, provider) => {
-            if (providers.includes(provider)) {
-                const p = provider;
-                const state = providerState.get(p);
-                if (state) {
-                    currentProvider = p;
-                    state.resumeSessionId = sessionId;
-                }
+            const targetProvider = provider && providers.includes(provider)
+                ? provider
+                : currentProvider;
+            if (!targetProvider) {
+                return;
+            }
+            const state = providerState.get(targetProvider);
+            if (state) {
+                currentProvider = targetProvider;
+                state.resumeSessionId = sessionId;
             }
         },
     };
 }
-function formatResumeFeedback(feedback) {
-    if (!feedback) {
-        return undefined;
-    }
-    const source = feedback.influencedChoice ? "applied" : "observed";
-    const preferred = feedback.preferredStrategy ? ` ${feedback.preferredStrategy}` : "";
-    return `${source}${preferred} · ${feedback.sampleSize}`;
-}
-async function loadInitialResumeInfo(cwd, sessionStore, providerIds) {
-    const transcriptStore = new TranscriptStore(cwd);
-    const info = {};
-    for (const provider of providerIds) {
-        const lastRecord = await sessionStore.last(provider);
-        if (!lastRecord) {
-            continue;
-        }
-        const meta = await transcriptStore.readMeta(lastRecord.sessionId);
-        if (!meta?.resumeStrategy || meta.resumeStrategy === "none") {
-            continue;
-        }
-        info[provider] = {
-            strategy: meta.resumeStrategy,
-            feedbackLabel: formatResumeFeedback(meta.resumeFeedback),
-        };
-    }
-    return info;
-}
 async function bootstrapGatewaySession(options) {
     const { startTuiGateway } = await import("@kilnai/runtime");
     const { flags, sessionManager, contextArtifactCache, systemPrompt } = options;
+    writeTuiBootstrapStatus("Starting Kiln TUI runtime...");
     const gateway = await startTuiGateway({
         sessionManager,
         port: flags.port,
         systemPrompt,
         onClear: sessionManager.onClear,
+        getProviderAvailability: () => getRuntimeProviderAvailability(options.registry),
         contextArtifactCache,
-        planMode: flags.plan ?? false,
+        artifactStore: options.builtinToolOptions?.artifactResources?.store,
+        voiceConfig: options.operatorVoice?.voiceConfig,
+        sttAdapter: options.operatorVoice?.sttAdapter,
+        ttsAdapter: options.operatorVoice?.ttsAdapter,
+        executionMode: flags.plan ? "plan" : "execute",
+        builtinToolOptions: options.builtinToolOptions,
+        managedInvocation: options.managedInvocation,
+        resumeSessionHydrator: options.resumeSessionHydrator,
     });
+    writeTuiBootstrapStatus("Connecting to local gateway...");
     await waitForGateway(`http://localhost:${gateway.port}/health`);
+    writeTuiBootstrapStatus("Loading provider and model discovery...");
     const providerModelsRef = {
         current: gateway.models,
     };
+    const providerDiscoveryRef = {
+        current: gateway.providerDiscovery ?? [],
+    };
     let session = null;
     const createSession = async () => {
         if (!session) {
-            session = new GatewaySession(gateway.url, (models) => {
+            session = new GatewaySession(gateway.url, (models, discovery) => {
                 providerModelsRef.current = models;
+                providerDiscoveryRef.current = discovery ?? [];
             });
         }
         return session;
@@ -258,6 +607,7 @@ async function bootstrapGatewaySession(options) {
     return {
         createSession,
         providerModelsRef,
+        providerDiscoveryRef,
         shutdown: () => {
             void session?.dispose();
             gateway.shutdown();
@@ -266,11 +616,16 @@ async function bootstrapGatewaySession(options) {
 }
 function mapSessionEventToTui(event, route) {
     const candidate = event;
+    const scoped = {
+        ...(typeof candidate?.sessionId === "string" ? { sessionId: candidate.sessionId } : {}),
+        ...(typeof candidate?.turnId === "string" ? { turnId: candidate.turnId } : {}),
+    };
     switch (candidate?.type) {
         case "text_delta":
             return {
                 type: "text_delta",
                 content: String(candidate.content ?? ""),
+                ...scoped,
             };
         case "file_changed":
             return {
@@ -279,11 +634,13 @@ function mapSessionEventToTui(event, route) {
                 changeType: candidate.changeType ?? "modified",
                 linesAdded: typeof candidate.linesAdded === "number" ? candidate.linesAdded : undefined,
                 linesRemoved: typeof candidate.linesRemoved === "number" ? candidate.linesRemoved : undefined,
+                ...scoped,
             };
         case "cost_update":
             return {
                 type: "cost_update",
                 usd: typeof candidate.usd === "number" ? candidate.usd : 0,
+                ...scoped,
             };
         case "completed":
             return {
@@ -303,14 +660,32 @@ function mapSessionEventToTui(event, route) {
                 activity: "tool_use",
                 toolName: typeof candidate.toolName === "string" ? candidate.toolName : undefined,
                 input: candidate.input,
+                ...scoped,
             };
-        case "tool_result":
+        case "tool_result": {
+            const toolName = typeof candidate.toolName === "string" ? candidate.toolName : undefined;
+            const presentation = toolName && typeof candidate.output === "string"
+                ? presentOperatorEventPayload("tool_call_completed", buildToolResultPayload({
+                    toolCallId: typeof candidate.toolCallId === "string" ? candidate.toolCallId : "tool-result",
+                    toolName,
+                    output: candidate.output,
+                    ...(typeof candidate.outputSummary === "string" ? { outputSummary: candidate.outputSummary } : {}),
+                    ...(typeof candidate.isError === "boolean" ? { isError: candidate.isError } : {}),
+                }))
+                : undefined;
+            const output = presentation?.toolPresentation?.presentationIntent
+                ? formatPresentationIntentAsText(presentation.toolPresentation.presentationIntent)
+                : typeof candidate.output === "string"
+                    ? parseToolResultEnvelope(candidate.output).output
+                    : undefined;
             return {
                 type: "activity",
                 activity: "tool_result",
-                toolName: typeof candidate.toolName === "string" ? candidate.toolName : undefined,
-                output: typeof candidate.output === "string" ? candidate.output : undefined,
+                toolName,
+                output,
+                ...scoped,
             };
+        }
         default:
             return {
                 type: "activity",
@@ -322,6 +697,21 @@ async function bootstrapDirectSession(options) {
     const { flags, sessionManager, systemPrompt } = options;
     const sessionCwd = flags.cwd ?? process.cwd();
     let session = null;
+    const providerModelsRef = { current: {} };
+    const providerDiscoveryRef = { current: [] };
+    const providerCatalog = createProviderCatalogService(() => resolveGuiOperatorDiscoveryResults(getRuntimeProviderAvailability(options.registry)), []);
+    const applyProviderDiscovery = (discovery) => {
+        providerDiscoveryRef.current = discovery;
+        providerModelsRef.current = projectGuiOperatorModels(providerDiscoveryRef.current);
+        return providerModelsRef.current;
+    };
+    const refreshProviderModels = async (refreshOptions) => applyProviderDiscovery((await providerCatalog.refresh(refreshOptions)).discovery);
+    const ensureProviderModels = async () => applyProviderDiscovery((await providerCatalog.ensureReady()).discovery);
+    providerCatalog.subscribe((snapshot) => {
+        applyProviderDiscovery(snapshot.discovery);
+    });
+    writeTuiBootstrapStatus("Loading provider and model discovery...");
+    providerCatalog.startBackgroundRefresh({ force: true });
     const createSession = async () => {
         if (session) {
             return session;
@@ -330,7 +720,36 @@ async function bootstrapDirectSession(options) {
         session = {
             async *run(opts) {
                 const providerForTurn = sessionManager.getProvider();
-                const modelForTurn = sessionManager.getModel();
+                let modelForTurn = sessionManager.getModel();
+                const providerModels = await ensureProviderModels();
+                const advertisedModels = providerModels[providerForTurn];
+                if (!advertisedModels || (advertisedModels.length === 0 && !isGuiProviderModeless(providerForTurn))) {
+                    yield {
+                        type: "error",
+                        message: `Provider '${providerForTurn}' is unavailable`,
+                    };
+                    return;
+                }
+                if (advertisedModels.length === 0 && isGuiProviderModeless(providerForTurn)) {
+                    if (modelForTurn.trim().length > 0) {
+                        sessionManager.setModel("");
+                    }
+                    modelForTurn = "";
+                }
+                if (advertisedModels?.length && modelForTurn.trim().length === 0) {
+                    yield {
+                        type: "error",
+                        message: providerRequiresSelectedModelMessage(providerForTurn),
+                    };
+                    return;
+                }
+                if (advertisedModels?.length && !advertisedModels.includes(modelForTurn)) {
+                    yield {
+                        type: "error",
+                        message: `Provider '${providerForTurn}' does not advertise model '${modelForTurn}'`,
+                    };
+                    return;
+                }
                 for await (const event of inner.run(opts)) {
                     yield mapSessionEventToTui(event, {
                         provider: providerForTurn,
@@ -344,17 +763,31 @@ async function bootstrapDirectSession(options) {
             async clear() {
                 await sessionManager.onClear(sessionManager.getProvider());
             },
+            async refreshProviders() {
+                await refreshProviderModels({ force: true });
+            },
             async switchProvider(providerName, modelName) {
-                sessionManager.setProvider(providerName);
-                sessionManager.setModel(modelName ?? "");
-                return providerName;
+                const provider = providerName.trim();
+                const requestedModel = typeof modelName === "string" ? modelName.trim() : "";
+                const resolution = resolveGuiProviderSwitch({
+                    provider,
+                    model: requestedModel,
+                    models: await ensureProviderModels(),
+                });
+                if (!resolution.ok) {
+                    throw new Error(resolution.error);
+                }
+                sessionManager.setProvider(resolution.provider);
+                sessionManager.setModel(resolution.modelForSessionManager);
+                return resolution.provider;
             },
         };
         return session;
     };
     return {
         createSession,
-        providerModelsRef: { current: {} },
+        providerModelsRef,
+        providerDiscoveryRef,
         shutdown: () => { },
     };
 }
@@ -372,15 +805,60 @@ export async function tuiCommand(appConfig, flags = {}) {
     const providerIds = providerDisplayInfo.map((entry) => entry.id);
     const cwd = flags.cwd ?? process.cwd();
     const globalConfig = readGlobalConfig();
-    const provider = parseProvider(resolveEffectiveProvider(flags.provider, globalConfig?.provider), providerIds);
+    const projectConfig = readKilnYaml(join(cwd, ".kiln"));
+    const resolvedKilnConfig = await loadKilnConfig(cwd);
+    const runtimeAppConfig = withContextCandidates(withWorkGovernanceContext(withGlobalIdentityContext(appConfig, globalConfig), resolvedKilnConfig?.workGovernance), resolveInstructionProfileContextCandidates({
+        projectPath: cwd,
+        globalConfig,
+        projectConfig,
+    }));
+    const startupTransport = resolveTuiStartupTransport(flags);
+    const provider = parseProvider(resolveEffectiveProvider(flags.provider, resolveGlobalDefaultProvider(globalConfig)), providerIds);
+    const startupModel = resolveGlobalDefaultModel(globalConfig);
+    const workItemStore = new WorkItemStore();
+    const goalRunStore = new GoalRunStore();
+    const startupProviderIds = providerIds;
     const contextArtifactCache = await getProjectContextArtifactCache(cwd);
+    const configuredBuiltinToolOptions = await loadConfiguredBuiltinToolSurfaceOptions(runtimeAppConfig, cwd, {
+        memoryAuthority: {
+            modelFacingSession: true,
+            permissionAgent: "tui",
+            caller: { kind: "operator_surface", id: "tui" },
+        },
+    });
+    const builtinToolOptions = createSessionBuiltinToolOptions({
+        ...configuredBuiltinToolOptions,
+        workItemStore,
+        goalRunStore,
+        additionalTools: [
+            ...(configuredBuiltinToolOptions.additionalTools ?? []),
+            ...createKilnConfigTools(cwd),
+            ...createWorkGovernanceTools(resolvedKilnConfig?.workGovernance, { workItemStore, goalRunStore }),
+        ],
+    });
+    const engineAvailability = resolveEngineAvailabilityMap(globalConfig);
+    const managedAgentProviderModels = await discoverManagedAgentProviderModels();
+    const managedInvocationResolution = await resolveManagedInvocationToolOptions(globalConfig, {
+        cwd,
+        registry,
+        surface: "tui",
+        isProviderAvailable: (providerId) => engineAvailability.get(providerId),
+        providerModels: managedAgentProviderModels,
+        directAdapterFactory: createManagedDirectProviderAdapterFactory({ builtinToolOptions }),
+        artifactStore: builtinToolOptions.artifactResources?.store,
+    });
+    const managedInvocation = appConfig.managedInvocation ?? managedInvocationResolution.managedInvocation;
+    const operatorVoice = await resolveOperatorVoiceRuntime(globalConfig);
+    for (const warning of operatorVoice.warnings) {
+        console.warn(warning);
+    }
     // Resolve domain display name from app config if available
     let domain = "kiln";
     let systemPrompt = "You are a helpful assistant.";
     try {
         const { SessionManager } = await import("../wrapper/session-manager.js");
         const wrapperConfig = { mode: "cli-wrapper", permissionPolicy: { approval: "never", sandbox: "workspace-write" } };
-        const manager = new SessionManager(wrapperConfig, appConfig, contextArtifactCache);
+        const manager = new SessionManager(wrapperConfig, runtimeAppConfig, contextArtifactCache);
         const context = await manager.prepare("interactive", cwd, undefined, undefined, undefined);
         domain = context.domain.displayName;
         systemPrompt = context.systemPrompt;
@@ -391,14 +869,22 @@ export async function tuiCommand(appConfig, flags = {}) {
     // Inject CLI session factory into the gateway (dependency inversion)
     const sessionStore = new SessionStore(cwd);
     const transcriptStore = new TranscriptStore(cwd);
-    const initialResumeInfo = await loadInitialResumeInfo(cwd, sessionStore, providerIds);
-    const startupTransport = resolveTuiStartupTransport(flags);
-    const sessionManager = await makeMultiProviderSessionFactory(provider, providerIds, cwd, registry, sessionStore, transcriptStore, contextArtifactCache);
+    const resumeSessionHydrator = createTranscriptRuntimeSessionHydrator({ transcriptStore });
+    const initialResumeInfo = await loadResumeSidebarInfo(sessionStore, transcriptStore, startupProviderIds);
+    const sessionManager = await makeMultiProviderSessionFactory(provider, startupProviderIds, cwd, registry, sessionStore, transcriptStore, contextArtifactCache, builtinToolOptions, "tui", managedInvocation);
+    if (startupModel) {
+        sessionManager.setModel(startupModel);
+    }
     const bootstrap = await bootstrapTuiSession({
         flags,
         sessionManager,
+        registry,
         contextArtifactCache,
         systemPrompt,
+        builtinToolOptions,
+        managedInvocation,
+        resumeSessionHydrator,
+        operatorVoice,
     });
     const shutdown = (code = 0, error) => {
         bootstrap.shutdown();
@@ -420,7 +906,7 @@ export async function tuiCommand(appConfig, flags = {}) {
     ];
     for (const [ev, handler] of handlers)
         process.on(ev, handler);
-    const resolvedTheme = themes[flags.theme ?? globalConfig?.tui?.theme ?? "kiln-dark"] ?? kilnDark;
+    const resolvedTheme = themes[flags.theme ?? resolveGlobalUiTheme(globalConfig) ?? "kiln-dark"] ?? kilnDark;
     // Session list loader for sidebar browser
     async function loadSessionList() {
         try {
@@ -436,7 +922,21 @@ export async function tuiCommand(appConfig, flags = {}) {
         sessionManager.setProvider(session.provider);
         sessionManager.setResumeSession(session.sessionId, session.provider);
     };
-    await startTui(bootstrap.createSession, providerDisplayInfo, provider, domain, resolvedTheme, startupTransport === "direct" ? initialResumeInfo : {}, () => loadInitialResumeInfo(cwd, sessionStore, providerIds), bootstrap.providerModelsRef, startupTransport === "direct" ? loadSessionList : undefined, startupTransport === "direct" ? handleResumeSession : undefined);
+    const startupProviderDisplayInfo = buildTuiStartupProviderDisplayInfo({
+        providerDisplayInfo,
+        runtimeModels: bootstrap.providerModelsRef.current,
+        runtimeDiscovery: bootstrap.providerDiscoveryRef.current,
+        includeModelessProviders: true,
+        includePendingProviders: bootstrap.providerDiscoveryRef.current.length === 0,
+    });
+    if (bootstrap.providerDiscoveryRef.current.length > 0) {
+        assertTuiProviderAvailableInStartupCatalog(provider, startupProviderDisplayInfo);
+    }
+    const startupProvider = startupProviderDisplayInfo.find((entry) => entry.id === provider);
+    if (startupProvider?.models[0] && sessionManager.getModel().trim().length === 0) {
+        sessionManager.setModel(startupProvider.models[0]);
+    }
+    await startTui(bootstrap.createSession, startupProviderDisplayInfo, provider, domain, resolvedTheme, startupTransport === "direct" ? initialResumeInfo : {}, () => loadResumeSidebarInfo(sessionStore, transcriptStore, startupProviderIds), bootstrap.providerModelsRef, bootstrap.providerDiscoveryRef, startupTransport === "direct" ? loadSessionList : undefined, startupTransport === "direct" ? handleResumeSession : undefined, () => bootstrap.createSession().then((session) => session.refreshProviders?.()), (themeName) => persistTuiThemePreference(themeName, globalConfig), async () => (await readConfigStatusSnapshot({ projectPath: cwd })).setup);
     bootstrap.shutdown();
     for (const [ev, handler] of handlers)
         process.off(ev, handler);