@namzu/cli 20.0.0 → 21.0.0

package/dist/tui/agent.js

@@ -20,7 +20,7 @@
  * `emptySession()` whose `send()` yields a single error event so the UI
  * renders an actionable hint rather than crashing.
  */
-import { BOOT_EVENT_NAMES, BackgroundJobRegistry, DefaultPathBuilder, DiskCheckpointStore, DiskMemoryStore, DiskTaskStore, EVENT_NAME_ATTRIBUTE, GuardedFetchProvider, PromptContributionRegistry, ProviderRegistry, SESSION_GOAL_TOOL_NAMES, SearchToolsTool, ToolRegistry, WebFetchTool, batchNeedsReview, buildAskUserQuestionTool, buildMemoryTools, buildSessionGoalTools, compactNow, createComputerUseTool, createMemoryPromoter, createReviewHandler, createToolPresenter, generateProjectId, generateRunId, generateSessionId, generateTenantId, generateTopicId, getBuiltinTools, isReviewExempt, query, resumeRun, webGuidanceContribution, withProviderFallback, } from '@namzu/sdk';
+import { BOOT_EVENT_NAMES, BackgroundJobRegistry, DefaultPathBuilder, DiskCheckpointStore, DiskMemoryStore, DiskTaskStore, EVENT_NAME_ATTRIBUTE, GuardedFetchProvider, PromptContributionRegistry, ProviderRegistry, SESSION_GOAL_TOOL_NAMES, ToolRegistry, WebFetchTool, batchNeedsReview, buildAskUserQuestionTool, buildMemoryTools, buildSessionGoalTools, compactNow, createComputerUseTool, createMemoryPromoter, createMemoryRecallStep, createReviewHandler, createToolPresenter, generateProjectId, generateRunId, generateSessionId, generateTenantId, generateTopicId, getBuiltinTools, isReviewExempt, query, resumeRun, webGuidanceContribution, withProviderFallback, } from '@namzu/sdk';
 import { SubprocessComputerUseHost } from '@namzu/computer-use';
 import { realpath, stat } from 'node:fs/promises';
 import { join, parse, resolve } from 'node:path';
@@ -34,15 +34,22 @@ import { resolveSandbox, sandboxResolvedSeverity, } from '../context/sandbox.js'
 import { composeTurnSnapshot, readTurnSnapshot } from '../context/turn-snapshot.js';
 import { connectMcpServers, } from '../integrations/mcp/servers.js';
 import { createCliPluginRuntime } from '../integrations/plugins/runtime.js';
+import { hasApiCredential, requiresCredentialForModel } from '../integrations/providers/access.js';
 import { CredentialRefreshRejectedError, CredentialWithdrawnError, PROVIDER_REGISTRY, chainCapabilityDisagreements, chainPositionName, describeAcceptedMismatch, describeCapabilityRefusal, discoverProviders, ensureFreshAnthropicToken, ensureFreshStoredCodexCredential, ensureRegistered, findDetected, isAnthropicOAuthToken, isRegistered, missingCredentialMessage, primaryProvider, readCodexCredentialFile, readPreferences, readSubscriptionCredential, resolveChainCapabilities, sameOAuthCredential, unresolvedMembers, unsupportedProviderMessage, } from '../integrations/providers/index.js';
+import { modelReasoningView } from '../integrations/providers/model-reasoning.js';
+import { createContextInventoryStep } from '../integrations/sessions/context-inventory.js';
+import { buildConversationReadTool, buildConversationSearchTool, } from '../integrations/sessions/conversation-search.js';
+import { createTaskContextStep } from '../integrations/sessions/task-context.js';
 import { ensurePrivateStateDirectory } from '../integrations/state/private-directory.js';
 import { discoverAgentDefinitions } from '../integrations/subagents/definitions.js';
 import { SubagentPathBuilder, resolveSubagentParent } from '../integrations/subagents/parent.js';
 import { CLI_INTERACTIVE_RUN_TIMEOUT_MS } from '../integrations/subagents/policy.js';
 import { createSubagentRuntime } from '../integrations/subagents/runtime.js';
 import { cliLogger } from '../logging.js';
+import { formatMemoryDiagnostics } from '../memory/presentation.js';
 import { composeMemoryPrompt, readMemory } from '../memory/store.js';
 import { projectRunConversation } from './conversation-history.js';
+import { buildSwitchModelTool } from './model-switch-tool.js';
 /**
  * Let one caller stop waiting without cutting a shared queue in the middle.
  *
@@ -303,10 +310,12 @@ function credentialGap(prefs, detected) {
     // one ever did, it is not a credential problem and must not be reported as
     // one — a wrong diagnosis sends the operator to paste a key that would not
     // have helped.
-    if (!entry || !entry.constructible || !entry.requiresApiKey)
+    if (!entry ||
+        !entry.constructible ||
+        !requiresCredentialForModel(entry, primary.model ?? entry.defaultModel))
         return null;
     const det = findDetected(detected, primary.id);
-    if (det?.apiKey)
+    if (hasApiCredential(entry, det?.apiKey))
         return null;
     return { providerId: primary.id, reason: missingCredentialMessage(entry) };
 }
@@ -363,9 +372,12 @@ function foregroundOnlyBash(tool) {
     };
 }
 function builtinTools(backgroundJobs) {
-    return getBuiltinTools().flatMap((tool) => {
-        if (EXCLUDED_BUILTINS.has(tool.name))
+    return getBuiltinTools().flatMap((source) => {
+        if (EXCLUDED_BUILTINS.has(source.name))
             return [];
+        const tool = ['bash', 'write', 'edit'].includes(source.name)
+            ? { ...source, executionBarrier: true }
+            : source;
         if (backgroundJobs)
             return [tool];
         if (tool.name === 'job')
@@ -399,14 +411,8 @@ function buildToolRegistry(cwd, projectStateRoot = join(cwd, '.namzu'), backgrou
     // handing `getIndex()` to the synchronous overload before the first store
     // read makes a new process report every persisted memory as absent.
     registry.register(buildMemoryTools(memoryStore));
-    // `search_tools` is deliberately NOT registered here. It is only useful
-    // where deferred tools exist, and that differs between this function's two
-    // callers: the session below passes a `taskStore`, so query() registers the
-    // task tools deferred and the search has a roster; a sub-agent is built with
-    // no task store, so its registry has nothing deferred and the tool could
-    // only ever answer "no deferred tools matching X" — a capability advertised
-    // every turn that costs a turn to discover is unusable. Mounting it is the
-    // caller's decision, made where the roster is known.
+    // query() mounts search_tools only if a deferred roster actually exists,
+    // after runtime tools are registered. Ordinary CLI task tools are active.
     return { registry, memoryStore };
 }
 /** Refresh plugin skill metadata before each provider operation. */
@@ -464,7 +470,8 @@ export async function createAgentSession(prefs, detected, options = {}) {
         return emptySession(`Unknown provider "${primary.id}" — pick another.`, 'invocation');
     }
     const det = findDetected(detected, primary.id);
-    if (entry.requiresApiKey && (!det || !det.apiKey)) {
+    if (requiresCredentialForModel(entry, primary.model ?? entry.defaultModel) &&
+        !hasApiCredential(entry, det?.apiKey)) {
         // The BACKSTOP, not the operator-facing answer. The TUI never reaches this
         // line any more: `probeAgentSession` reports the same gap as a
         // `credentialGap` and the App routes into the picker, where a credential
@@ -473,7 +480,7 @@ export async function createAgentSession(prefs, detected, options = {}) {
         // pieces of advice below are real: an environment variable, or
         // `--provider`. Keeping the refusal is what makes those runs fail rather
         // than quietly start on something else.
-        return emptySession(`No credential found for ${entry.label}. Set one of: ${entry.envVars.join(', ')} — or pass --provider with one that is configured.`);
+        return emptySession(`No credential found for ${entry.label}${entry.id === 'zen' ? ' with the selected model. Choose muse-spark-1.3-contributor-free for public access' : ''}. Set one of: ${entry.envVars.join(', ')} — or pass --provider with one that is configured.`);
     }
     try {
         await ensureRegistered(primary.id);
@@ -523,7 +530,9 @@ export async function createAgentSession(prefs, detected, options = {}) {
     }
     let provider;
     try {
-        provider = constructProvider(primary.id, det, model);
+        provider = constructProvider(primary.id, det, model, {
+            sessionId: scope.sessionId,
+        });
     }
     catch (err) {
         return emptySession(`Failed to construct ${entry.label}: ${err instanceof Error ? err.message : String(err)}`);
@@ -597,7 +606,7 @@ export async function createAgentSession(prefs, detected, options = {}) {
         if (fresh === currentToken)
             return;
         try {
-            const refreshedProvider = constructProvider('anthropic', { ...det, apiKey: fresh }, model);
+            const refreshedProvider = constructProvider('anthropic', { ...det, apiKey: fresh }, model, { sessionId: scope.sessionId });
             // Publish the pair together. If construction fails, both old values
             // remain live and the next operation can retry against the stored token.
             provider = refreshedProvider;
@@ -634,7 +643,7 @@ export async function createAgentSession(prefs, detected, options = {}) {
                 expiresAt: credential.expiresAt,
                 origin: 'codex-file',
             },
-        }, model);
+        }, model, { sessionId: scope.sessionId });
         provider = refreshedProvider;
         currentToken = credential.accessToken;
         currentCodexAccount = credential.accountId;
@@ -652,7 +661,7 @@ export async function createAgentSession(prefs, detected, options = {}) {
         }
         if (credential.accessToken === currentToken)
             return;
-        provider = constructProvider('anthropic', { ...det, apiKey: credential.accessToken }, model);
+        provider = constructProvider('anthropic', { ...det, apiKey: credential.accessToken }, model, { sessionId: scope.sessionId });
         currentToken = credential.accessToken;
     };
     const refreshStoredCodex = async (signal) => {
@@ -668,7 +677,7 @@ export async function createAgentSession(prefs, detected, options = {}) {
                 expiresAt: credential.expiresAt,
                 origin: 'stored',
             },
-        }, model);
+        }, model, { sessionId: scope.sessionId });
         provider = refreshedProvider;
         currentToken = credential.accessToken;
         currentCodexAccount = credential.accountId;
@@ -695,6 +704,12 @@ export async function createAgentSession(prefs, detected, options = {}) {
         credentialTail = queued.catch(() => { });
         return signal ? observeWithSignal(queued, signal) : queued;
     };
+    // The TUI can replace its conversation without replacing this session object.
+    // Bind each admitted run to its captured conversation, including durable resumes;
+    // a Zen client must never generate a fresh Go session for each model call.
+    const providerForSession = (sessionId) => primary.id === 'zen' || primary.id === 'zen-go'
+        ? constructProvider(primary.id, det, model, { sessionId })
+        : provider;
     // Session-owned discovery with one drain cursor per run. A child shares the
     // discovered scopes without being able to consume the parent's update, and
     // an edit takes effect in this session rather than only after reconnecting.
@@ -874,9 +889,6 @@ export async function createAgentSession(prefs, detected, options = {}) {
         computerUseReady: computerUseHost !== undefined,
         ...(computerUseError ? { computerUseError } : {}),
     });
-    // This session passes a `taskStore` to query() below, which registers the
-    // task tools deferred — so `search_tools` has something to find here.
-    registry.register([SearchToolsTool]);
     // Web reach, opted into in the config file and nowhere else. The parent's
     // registry only: a child's config carries no provider, and a tool whose
     // provider is missing is a tool that reports itself unwired — truthful,
@@ -891,6 +903,18 @@ export async function createAgentSession(prefs, detected, options = {}) {
     // Best-effort — if the runtime can't stand up, the chat still works.
     const delegationScopes = new Map();
     const delegatedInputWaiters = new Map();
+    if (options.conversationSessions) {
+        const sessions = options.conversationSessions;
+        for (const build of [buildConversationSearchTool, buildConversationReadTool])
+            registry.register(build((context) => {
+                const owner = delegationScopes.get(context.runId);
+                if (!owner ||
+                    owner.projectId !== sessions.projectId ||
+                    owner.tenantId !== sessions.tenantId)
+                    throw new Error('The requesting run does not own this conversation.');
+                return { sessions, sessionId: owner.sessionId };
+            }));
+    }
     let subagentRuntime;
     // Stays empty when the runtime below throws, which is the honest answer: the
     // catch is non-fatal and the session then genuinely has no delegate to
@@ -950,7 +974,12 @@ export async function createAgentSession(prefs, detected, options = {}) {
             // child announcing a swap the parent never made, inside a tool result,
             // is a worse surface than the child simply failing and the parent
             // reporting it.
-            buildProvider: () => constructProvider(primary.id, det ? { ...det, apiKey: currentToken ?? det.apiKey } : det, model),
+            buildProvider: (sessionId) => {
+                if (!sessionId && (primary.id === 'zen' || primary.id === 'zen-go')) {
+                    throw new Error('A delegated provider requires its invoking conversation.');
+                }
+                return constructProvider(primary.id, det ? { ...det, apiKey: currentToken ?? det.apiKey } : det, model, { sessionId });
+            },
             buildTools: () => {
                 // Sub-agents get the parent's working set minus `search_tools`:
                 // they run without a task store, so nothing in their registry is
@@ -967,6 +996,8 @@ export async function createAgentSession(prefs, detected, options = {}) {
         });
         subagentRuntime = sub;
         registry.register([sub.agentTool, sub.waitForTaskTool]);
+        if (sub.sendMessageTool)
+            registry.register(sub.sendMessageTool);
         allowedAgentIds = sub.allowedAgentIds;
     }
     catch (err) {
@@ -980,6 +1011,20 @@ export async function createAgentSession(prefs, detected, options = {}) {
         // and got none had nothing on stderr to say why.
         cliLogger().warn('sub-agent runtime unavailable this session', exceptionAttributes(err));
     }
+    // This capability belongs to the active main turn, never the child roster.
+    const modelSwitchHandlers = new Map();
+    if (options.allowModelSwitch) {
+        registry.register(buildSwitchModelTool(async (request, context) => {
+            const handler = modelSwitchHandlers.get(context.runId);
+            if (!handler || context.abortSignal?.aborted) {
+                return {
+                    kind: 'rejected',
+                    reason: 'This turn no longer owns model selection.',
+                };
+            }
+            return handler(request, context.abortSignal);
+        }));
+    }
     // `ask_user_question`, where somebody can answer. The SDK tool parks the
     // run through the handler it was BUILT with, so that handler reads the
     // turn's answerer through a holder the prelude fills: the tool is per
@@ -1021,8 +1066,8 @@ export async function createAgentSession(prefs, detected, options = {}) {
     // query call, because the doctrine tells the model to plan with them and a
     // tool it must search for first is a tool it skips.
     //
-    // `search_tools` stays mounted above even so: a tool server or plugin can
-    // still register a deferred roster, and that is what the search is for. The
+    // A tool server or plugin can still register a deferred roster; query()
+    // mounts search_tools when one exists. Do not advertise an empty search. The
     // task tools are registered inside query(), after this function returns,
     // which is why the connect line reports no count of them — counting here
     // would mean restating query's registration order in the CLI.
@@ -1067,16 +1112,9 @@ export async function createAgentSession(prefs, detected, options = {}) {
     // Persists across turns: once the user picks "approve all", later tool
     // batches in this session run without prompting.
     const approval = { all: false };
-    // What a settled run leaves behind, over the SAME store `search_memory`
-    // reads on the next run. Built once per session rather than per turn: it
-    // holds no per-run state, and a per-turn construction would re-open the
-    // index for every message.
-    //
-    // Unconditional, unlike the answer gate. A gate changes what a run may do
-    // and so must be asked for; promotion changes only what survives it, and
-    // the alternative — the run's own extracted knowledge being discarded at
-    // settle — is what this repository has been doing all along by accident.
-    // A run that learned nothing still writes nothing.
+    // Share the project store with tools and recall. Each run selects either
+    // this extracted-claim promoter or explicit consolidation, never both.
+    // Candidates without useful claims write nothing.
     const promoteMemory = createMemoryPromoter({ store: memoryStore });
     // Plugins are the last fallible startup resource. The ordering is ownership:
     // a malformed MCP entry cannot strand imported plugin hooks, and a plugin
@@ -1155,10 +1193,25 @@ export async function createAgentSession(prefs, detected, options = {}) {
     let reasoningEffortDefault;
     let effortNotice;
     try {
-        const capabilityView = withProviderFallback([
+        const capabilityMembers = [
             { provider, model },
-            ...fallbackPlan.build(currentToken),
-        ]);
+            ...fallbackPlan.build(currentToken, scope.sessionId),
+        ];
+        const capabilityView = withProviderFallback(await Promise.all(capabilityMembers.map(async (member) => {
+            const memberModel = member.model ?? model;
+            const known = member.provider.reasoningEffortLevelsFor
+                ? member.provider.reasoningEffortLevelsFor(memberModel)
+                : member.provider.effortLevelsFor?.(memberModel);
+            // A model-owned answer (including []) needs no extra catalogue
+            // request. Discover only missing capability information.
+            const catalogue = known === undefined && member.provider.listModels
+                ? await runPickerProviderOperation(undefined, (signal) => member.provider.listModels?.(signal) ?? Promise.resolve([])).catch(() => [])
+                : [];
+            return {
+                ...member,
+                provider: modelReasoningView(member.provider, memberModel, catalogue),
+            };
+        })));
         const offered = capabilityView.reasoningEffortLevelsFor
             ? capabilityView.reasoningEffortLevelsFor(model)
             : capabilityView.effortLevelsFor?.(model);
@@ -1199,7 +1252,10 @@ export async function createAgentSession(prefs, detected, options = {}) {
         const pluginSkills = pluginRuntime
             ? await currentPluginSkills(pluginRuntime.skills)
             : undefined;
-        const memoryPrompt = composeMemoryPrompt(readMemory(undefined, cwd));
+        const curatedMemory = readMemory(undefined, cwd);
+        for (const notice of formatMemoryDiagnostics(curatedMemory))
+            cliLogger().warn(notice);
+        const memoryPrompt = composeMemoryPrompt(curatedMemory);
         const environmentPrompt = composeEnvironmentPrompt({
             ...(await readEnvironmentFacts(cwd)),
             additionalDirectories: [...directories],
@@ -1219,15 +1275,16 @@ export async function createAgentSession(prefs, detected, options = {}) {
         }
         delegatedResumeHandlers.set(entry.runId, resumeHandler);
         delegationScopes.set(entry.runId, { ...entry, topicId: scope.topicId });
+        const runTaskStore = selectTaskStore(entry.runId, { ...entry, topicId: scope.topicId });
         try {
             return await resumeRun({
-                provider,
-                fallbackProviders: fallbackPlan.build(currentToken),
+                provider: providerForSession(entry.sessionId),
+                fallbackProviders: fallbackPlan.build(currentToken, entry.sessionId),
                 tools: registry,
                 pluginManager: pluginRuntime?.manager,
                 skillRegistry: pluginRuntime?.skills,
                 skills: pluginSkills,
-                taskStore: selectTaskStore(entry.runId, { ...entry, topicId: scope.topicId }),
+                taskStore: runTaskStore,
                 // The same availability the original run registered under.
                 // A resumed run re-registers the task tools; leaving them at
                 // the kernel's `deferred` default would hand the model a plan
@@ -1244,6 +1301,21 @@ export async function createAgentSession(prefs, detected, options = {}) {
                     : {}),
                 authorizationGate: gateFor(options.rules),
                 compactionConfig: compactionConfigFor(options.compaction),
+                prepareStep: [
+                    createTaskContextStep(runTaskStore, entry.tenantId),
+                    ...(options.memory?.recall === false
+                        ? []
+                        : [
+                            createMemoryRecallStep({
+                                store: memoryStore,
+                                identifierGrounding: options.memory?.identifierGrounding,
+                            }),
+                        ]),
+                    ...(options.conversationSessions ? [createContextInventoryStep()] : []),
+                ],
+                ...(options.compaction?.consolidate
+                    ? { consolidateInto: memoryStore }
+                    : { promoteMemory }),
                 projectInstructionContext: projectInstructions.createRunContext(),
                 pathBuilder,
                 ...(sandbox.provider ? { sandboxProvider: sandbox.provider } : {}),
@@ -1391,11 +1463,12 @@ export async function createAgentSession(prefs, detected, options = {}) {
         reasoningEffortLevels,
         reasoningEffortDefault,
         compact: (messages) => operations.promise(undefined, async (signal) => {
+            const sessionId = scope.sessionId;
             await prepareProviderCredential(signal);
             return compactNow({
                 messages,
                 config: compactionConfigFor(options.compaction),
-                provider,
+                provider: providerForSession(sessionId),
                 model,
                 signal,
             });
@@ -1459,6 +1532,8 @@ export async function createAgentSession(prefs, detected, options = {}) {
                 throw new Error(`Run ${runId} already owns a delegated review channel.`);
             }
             delegatedResumeHandlers.set(runId, resumeHandler);
+            if (opts?.onModelSwitch)
+                modelSwitchHandlers.set(runId, opts.onModelSwitch);
             if (opts?.waitForInbound)
                 delegatedInputWaiters.set(runId, opts.waitForInbound);
             const turnScope = { ...scope };
@@ -1481,7 +1556,11 @@ export async function createAgentSession(prefs, detected, options = {}) {
                 const pluginSkills = pluginRuntime
                     ? await currentPluginSkills(pluginRuntime.skills)
                     : undefined;
-                const memoryPrompt = composeMemoryPrompt(readMemory(undefined, cwd));
+                const curatedMemory = readMemory(undefined, cwd);
+                for (const notice of formatMemoryDiagnostics(curatedMemory)) {
+                    yield { kind: 'context', text: notice, shed: false };
+                }
+                const memoryPrompt = composeMemoryPrompt(curatedMemory);
                 currentOnQuestion = opts?.onQuestion;
                 const [environmentFacts, turnSnapshot] = await Promise.all([
                     readEnvironmentFacts(cwd),
@@ -1553,9 +1632,10 @@ export async function createAgentSession(prefs, detected, options = {}) {
                     capturedAuthority = Object.freeze({ ...opts.goalRound });
                     goalAuthorities.set(opts.runId, capturedAuthority);
                 }
+                const runTaskStore = selectTaskStore(runId, turnScope);
                 try {
                     yield* runTurn({
-                        provider,
+                        provider: providerForSession(turnScope.sessionId),
                         compactionConfig: compactionConfigFor(options.compaction),
                         ...(options.compaction?.consolidate ? { consolidateInto: memoryStore } : {}),
                         ...(jobRegistry
@@ -1571,7 +1651,7 @@ export async function createAgentSession(prefs, detected, options = {}) {
                         // that expired hours ago — and a chain whose own members are stale
                         // is a fallback that fails for the reason the fallback exists to
                         // survive. Building a driver is a client object, not a request.
-                        fallbackProviders: fallbackPlan.build(currentToken),
+                        fallbackProviders: fallbackPlan.build(currentToken, turnScope.sessionId),
                         model,
                         tools: registry,
                         pluginManager: pluginRuntime?.manager,
@@ -1584,10 +1664,24 @@ export async function createAgentSession(prefs, detected, options = {}) {
                         ...(options.limits ? { limits: options.limits } : {}),
                         sandboxWorkspace,
                         rules: options.rules,
+                        structuredOutput: options.structuredOutput,
                         reviewAnswer: options.reviewAnswer,
                         maxAnswerReviews: options.maxAnswerReviews,
-                        promoteMemory,
-                        taskStore: selectTaskStore(runId, turnScope),
+                        promoteMemory: options.compaction?.consolidate ? undefined : promoteMemory,
+                        prepareStep: [
+                            createTaskContextStep(runTaskStore, turnScope.tenantId),
+                            ...(options.memory?.recall === false
+                                ? []
+                                : [
+                                    createMemoryRecallStep({
+                                        store: memoryStore,
+                                        query: lastUserText(messages),
+                                        identifierGrounding: options.memory?.identifierGrounding,
+                                    }),
+                                ]),
+                            ...(options.conversationSessions ? [createContextInventoryStep()] : []),
+                        ],
+                        taskStore: runTaskStore,
                         systemPrompt,
                         messages,
                         projectInstructionContext: projectInstructions.createRunContext(),
@@ -1625,6 +1719,7 @@ export async function createAgentSession(prefs, detected, options = {}) {
             finally {
                 if (delegatedResumeHandlers.get(runId) === resumeHandler) {
                     delegatedResumeHandlers.delete(runId);
+                    modelSwitchHandlers.delete(runId);
                     delegatedInputWaiters.delete(runId);
                     delegationScopes.delete(runId);
                     await subagentRuntime?.releaseRun(runId);
@@ -1656,7 +1751,8 @@ function planFallbacks(members, detected) {
             continue;
         }
         const det = findDetected(detected, member.id);
-        if (entry.requiresApiKey && !det?.apiKey) {
+        if (requiresCredentialForModel(entry, member.model ?? entry.defaultModel) &&
+            !hasApiCredential(entry, det?.apiKey)) {
             notices.push(`Provider chain: ${position} (${entry.label}) has no credential, so nothing will fall over to it. ` +
                 `Set one of: ${entry.envVars.join(', ')}.`);
             continue;
@@ -1671,7 +1767,7 @@ function planFallbacks(members, detected) {
     }
     return {
         notices,
-        build(headToken) {
+        build(headToken, sessionId) {
             const out = [];
             for (const { choice, det } of usable) {
                 const entry = PROVIDER_REGISTRY[choice.id];
@@ -1681,7 +1777,9 @@ function planFallbacks(members, detected) {
                 try {
                     const credential = headToken !== undefined && det?.oauth ? { ...det, apiKey: headToken } : det;
                     out.push({
-                        provider: constructProvider(choice.id, credential, memberModel),
+                        provider: constructProvider(choice.id, credential, memberModel, {
+                            sessionId,
+                        }),
                         model: memberModel,
                     });
                 }
@@ -1697,7 +1795,7 @@ function planFallbacks(members, detected) {
         },
     };
 }
-export function constructProvider(id, det, model) {
+export function constructProvider(id, det, model, context = {}) {
     switch (id) {
         case 'anthropic': {
             const token = det?.apiKey ?? '';
@@ -1749,6 +1847,24 @@ export function constructProvider(id, det, model) {
             });
             return provider;
         }
+        case 'zen':
+        case 'zen-go': {
+            const apiKey = hasApiCredential(PROVIDER_REGISTRY[id], det?.apiKey) ? det?.apiKey : undefined;
+            if (id === 'zen-go' && apiKey === undefined)
+                throw new Error('Zen Go requires an API key.');
+            const { provider } = ProviderRegistry.create({
+                ...(id === 'zen-go'
+                    ? { type: 'zen-go', apiKey: apiKey }
+                    : {
+                        type: 'zen',
+                        ...(apiKey === undefined ? {} : { apiKey }),
+                    }),
+                baseURL: det?.baseUrl,
+                model,
+                ...(context.sessionId ? { sessionId: context.sessionId } : {}),
+            });
+            return provider;
+        }
         case 'ollama': {
             const { provider } = ProviderRegistry.create({
                 type: 'ollama',
@@ -2013,7 +2129,7 @@ function compactionConfigFor(compaction) {
             : {}),
     };
 }
-async function* runTurn({ provider, compactionConfig, consolidateInto, backgroundJobs, backgroundJobOwner, fallbackProviders, model, tools, pluginManager, skillRegistry, skills, scope, pathBuilder, workingDirectory, limits, additionalDirectories, sandboxWorkspace, rules, reviewAnswer, maxAnswerReviews, promoteMemory, resumeHandler, taskStore, systemPrompt, messages, projectInstructionContext, opts, taskGateway, completionInbox, promptContributions, runtimeToolOverrides, web, sandboxProvider, sandboxTeardownTimeoutMs, onRunEvent, }) {
+async function* runTurn({ provider, compactionConfig, consolidateInto, backgroundJobs, backgroundJobOwner, fallbackProviders, model, tools, pluginManager, skillRegistry, skills, scope, pathBuilder, workingDirectory, limits, additionalDirectories, sandboxWorkspace, rules, structuredOutput, reviewAnswer, maxAnswerReviews, promoteMemory, prepareStep, resumeHandler, taskStore, systemPrompt, messages, projectInstructionContext, opts, taskGateway, completionInbox, promptContributions, runtimeToolOverrides, web, sandboxProvider, sandboxTeardownTimeoutMs, onRunEvent, }) {
     const signal = opts?.signal;
     // One presenter for the whole stream, built from the registry this scope
     // already holds. Its absence HERE is what forced presentation to be name
@@ -2022,6 +2138,7 @@ async function* runTurn({ provider, compactionConfig, consolidateInto, backgroun
     const presenter = createToolPresenter(tools);
     try {
         const events = query({
+            ...(structuredOutput ? { structuredOutput } : {}),
             provider,
             pathBuilder,
             ...(opts?.runId ? { runId: opts.runId } : {}),
@@ -2068,11 +2185,9 @@ async function* runTurn({ provider, compactionConfig, consolidateInto, backgroun
             // that shipped before gates existed.
             ...(reviewAnswer ? { reviewAnswer } : {}),
             ...(maxAnswerReviews !== undefined ? { maxAnswerReviews } : {}),
-            // Always present, unlike the gate: a gate changes what a run may
-            // do and so must be asked for; promotion changes only what
-            // survives it, and a run that learned nothing still writes
-            // nothing.
+            // Undefined when the host selected consolidation as its writer.
             promoteMemory,
+            ...(prepareStep ? { prepareStep } : {}),
             agentId: 'namzu',
             agentName: 'namzu',
             ...(systemPrompt ? { systemPrompt } : {}),
@@ -2347,6 +2462,7 @@ export function toAgentEvent(event, presenter) {
             // answer was refused.
             return {
                 kind: 'done',
+                text: event.result,
                 ...(event.budget ? { budget: event.budget } : {}),
                 ...(event.stopReason ? { stopReason: event.stopReason } : {}),
             };