@qvac/harness 0.3.3 → 0.5.0

package/dist-lib/lib/capabilities/completion.js

@@ -1,10 +1,11 @@
 import process from 'process';
 import { contextCandidates } from '../context-window.js';
-import { errorCode, errorMessage } from '../error-fields.js';
+import { errorCode, errorMessage, isRecord } from '../guards.js';
 import { bufferBurst } from '../helpers/buffer-burst.js';
 import { endsTurn, stopAtControlToken, stripControlTokens, truncateAtControlToken } from '../helpers/control-tokens.js';
 import { createMarkupStreamFilter } from '../helpers/markup-stream-filter.js';
 import { AbortedError, raceAbort } from '../helpers/race-abort.js';
+import { raceTimeout } from '../helpers/race-timeout.js';
 import { createRunOutcomeTracker, degenerateAnswer, unnamedWrites, writeReport } from '../helpers/run-outcome.js';
 import { splitThinking } from '../helpers/thinking.js';
 import { clipRawCall, normalizeToolArgs, recoverMarkupToolCalls, recoverPrintedSkillLoad, recoverSkillNamedCall, stripToolCallMarkup, stripToolResponseBlocks, toolCallMarkup } from '../helpers/tool-call-markup.js';
@@ -16,7 +17,7 @@ import { resolveLlmGenerationParams } from '../models/llm-presets.js';
 import { customToolDialect } from '../models/model-catalog.js';
 import { isContextOverflowError, isSdkModelWedgedError } from '../models/sdk-faults.js';
 import { annotateLastUserTime, skillsPromptSection, systemPromptParts } from '../prompt.js';
-import { isMetadataMethod } from '../tools/mcp/utils.js';
+import { isMetadataMethod } from '../tools/mcp/protocol.js';
 import { unquoteArg } from '../tools/model-args.js';
 import { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from './tool-names.js';
 import { mainFileRequested, skillFileArg, skillFileStem } from '../tools/skill.js';
@@ -33,14 +34,18 @@ export function imageSettingsFrom(agent) {
     if (!agent)
         return undefined;
     const settings = {};
-    if (agent.imageModelChoice)
+    if (agent.imageModelChoice) {
         settings.modelChoice = agent.imageModelChoice;
-    if (agent.imageSteps)
+    }
+    if (agent.imageSteps) {
         settings.steps = agent.imageSteps;
-    if (agent.imageWidth)
+    }
+    if (agent.imageWidth) {
         settings.width = agent.imageWidth;
-    if (agent.imageHeight)
+    }
+    if (agent.imageHeight) {
         settings.height = agent.imageHeight;
+    }
     return Object.keys(settings).length ? settings : undefined;
 }
 const BURST_WINDOW_MS = 100;
@@ -62,10 +67,12 @@ export function trustedSourcesFrom(history) {
     const sources = [];
     for (const entry of history) {
         const text = String(entry.content ?? '');
-        if (entry.role === 'user')
+        if (entry.role === 'user') {
             sources.push({ origin: 'user', text });
-        else if (entry.role === 'tool')
+        }
+        else if (entry.role === 'tool') {
             sources.push({ origin: originOfToolTurn(text), text });
+        }
     }
     return sources;
 }
@@ -102,16 +109,18 @@ function sanitizeTurn(turn) {
 function lastUserContent(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const turn = messages[i];
-        if (turn?.role === 'user')
+        if (turn?.role === 'user') {
             return turn.content;
+        }
     }
     return '';
 }
 function lastUserImages(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const turn = messages[i];
-        if (turn?.role === 'user')
+        if (turn?.role === 'user') {
             return turn.attachments ?? [];
+        }
     }
     return [];
 }
@@ -149,8 +158,9 @@ function assistantToolTurn(contentText, calls) {
 function preloadLastUser(messages, name, body) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const turn = messages[i];
-        if (turn?.role !== 'user')
+        if (turn?.role !== 'user') {
             continue;
+        }
         const next = [...messages];
         next[i] = { ...turn, content: skillPreloadMessage(turn.content, name, body) };
         return next;
@@ -159,10 +169,12 @@ function preloadLastUser(messages, name, body) {
 }
 function collectStats(state, stats, stopReason) {
     state.stopReason = stopReason;
-    if (!stats)
+    if (!stats) {
         return;
-    if (state.ttft === undefined && stats.timeToFirstToken)
+    }
+    if (state.ttft === undefined && stats.timeToFirstToken) {
         state.ttft = stats.timeToFirstToken;
+    }
     if (state.promptTokensPerSecond === undefined && stats.promptTokensPerSecond) {
         state.promptTokensPerSecond = stats.promptTokensPerSecond;
     }
@@ -173,10 +185,12 @@ function collectStats(state, stats, stopReason) {
             state.timedTokens += stats.generatedTokens;
         }
     }
-    if (stats.promptTokens)
+    if (stats.promptTokens) {
         state.promptTokens = stats.promptTokens;
-    if (stats.cacheTokens)
+    }
+    if (stats.cacheTokens) {
         state.cacheTokens = stats.cacheTokens;
+    }
 }
 function metricsEvent(state, usage) {
     if (!state.tokens)
@@ -190,10 +204,10 @@ function metricsEvent(state, usage) {
         tokensPerSecond: state.durationMs > 0 ? (state.timedTokens / state.durationMs) * 1000 : undefined,
         promptTokens: state.promptTokens,
         cacheTokens: state.cacheTokens,
-        ...(state.ctxSize ? { ctxSize: state.ctxSize } : {}),
-        ...(state.backends.length ? { backends: state.backends } : {}),
-        ...(usage ? { usage } : {}),
-        ...(state.stopReason ? { stopReason: state.stopReason } : {})
+        ctxSize: state.ctxSize || undefined,
+        backends: state.backends.length ? state.backends : undefined,
+        usage: usage ?? undefined,
+        stopReason: state.stopReason || undefined
     };
 }
 const TOOL_DENIED_MESSAGE = 'The user declined this call. Do not retry it or call it with different arguments to get ' +
@@ -215,16 +229,17 @@ const RETRYABLE_CODE = new Set(['timeout', 'transport', 'busy']);
 function callSucceeded(result, outcome) {
     if (outcome.kind !== 'success')
         return false;
-    const exitCode = result?.exitCode;
+    const exitCode = isRecord(result) ? result.exitCode : undefined;
     return typeof exitCode !== 'number' || exitCode === 0;
 }
 function retryHints(result) {
     if (!result || typeof result !== 'object' || Array.isArray(result))
         return {};
-    const record = result;
+    const status = 'status' in result ? result.status : undefined;
+    const code = 'code' in result ? result.code : undefined;
     return {
-        ...(typeof record.status === 'number' ? { status: record.status } : {}),
-        ...(typeof record.code === 'string' ? { code: record.code } : {})
+        status: typeof status === 'number' ? status : undefined,
+        code: typeof code === 'string' ? code : undefined
     };
 }
 function settledFailure(result, outcome) {
@@ -233,8 +248,9 @@ function settledFailure(result, outcome) {
     if (outcome.kind === 'error' && outcome.error !== undefined)
         return false;
     const { code, status } = retryHints(result);
-    if (code !== undefined && RETRYABLE_CODE.has(code))
+    if (code !== undefined && RETRYABLE_CODE.has(code)) {
         return false;
+    }
     return status === undefined || (status < 500 && !RETRYABLE_STATUS.has(status));
 }
 const MAX_BLOCKED_REPEATS = 3;
@@ -257,13 +273,14 @@ function deniedCall() {
         executed: false
     });
 }
-async function executeCall(tool, args, ctx, { approve, signal, denied, sources = [], effect: classified, skipApprovals, onToolActivity, intent, display }) {
+async function executeCall(tool, args, { ctx, approve, signal, denied, sources = [], effect: classified, skipApprovals, onToolActivity, intent, display }) {
     const validationError = tool.validate?.(args, ctx);
     if (validationError) {
         hlog('tool rejected: arguments failed validation', { tool: tool.name });
         return guidanceResult(validationError);
     }
-    const refusal = guardToolCall(tool.name, args, sources, {
+    const refusal = guardToolCall(tool.name, args, {
+        sources,
         externalWrite: tool.externalWrite === true
     });
     if (refusal) {
@@ -304,13 +321,11 @@ async function executeCall(tool, args, ctx, { approve, signal, denied, sources =
             }), signal)
             : false);
     hlog(`tool ${approved ? 'approved' : 'denied'}`, { tool: tool.name });
-    const decision = tool.autoApprove === true || effect === 'read'
-        ? 'auto'
-        : skipApprovals === true
-            ? 'skip-all'
-            : approved
-                ? 'allowed'
-                : 'denied';
+    const decision = toolDecision({
+        auto: tool.autoApprove === true || effect === 'read',
+        skipAll: skipApprovals === true,
+        approved
+    });
     onToolActivity?.({
         type: 'tool-activity',
         name: tool.name,
@@ -343,15 +358,15 @@ function runToolContext(scope) {
     return (turnImages = [], ctxSize) => ({
         agentId: agent?.id ?? null,
         ctxSize,
-        ...(image ? { image } : {}),
-        ...(turnImages.length ? { turnImages } : {}),
-        ...(attach ? { attach } : {}),
-        ...(fetchAttachment ? { fetchAttachment } : {}),
-        ...(ragSearch ? { ragSearch } : {}),
-        ...(progress ? { progress } : {}),
-        ...(askUser ? { askUser } : {}),
-        ...(signal ? { signal } : {}),
-        ...(runBudget ? { runBudget } : {})
+        image,
+        turnImages: turnImages.length ? turnImages : undefined,
+        attach,
+        fetchAttachment,
+        ragSearch,
+        progress,
+        askUser,
+        signal,
+        runBudget
     });
 }
 function labelOf(name, args, emoji) {
@@ -394,24 +409,21 @@ function blockedSkillMessage(name, catalog, listShown) {
             `skill is available this turn — do not guess another name, and answer from what you ` +
             `already have.`;
 }
-async function resolveToolCalls(toolCalls, enabled, agentId, pipeline, skillNames, { sandboxMode, signal }) {
+async function resolveToolCalls(toolCalls, { enabled, agentId, pipeline, skillNames, sandboxMode, signal }) {
     const resolved = [];
     for (const call of toolCalls) {
         if (signal?.aborted)
             throw new AbortedError();
         const tool = enabled.find((t) => t.name === call.name);
+        const rawCall = call.raw === undefined ? undefined : clipRawCall(call.raw);
         if (!tool) {
             const { args } = takeToolIntent(call.arguments);
-            resolved.push({
-                call,
-                args,
-                ...(call.raw === undefined ? {} : { rawCall: clipRawCall(call.raw) })
-            });
+            resolved.push({ call, args, rawCall });
             continue;
         }
         const taken = takeToolIntent(call.arguments);
         const args = normalizeToolArgs(taken.args, Object.keys(tool.parameters.properties));
-        const { intent } = taken;
+        const intent = taken.intent || undefined;
         const fold = await pipeline.runPreToolFold({
             toolName: tool.name,
             args,
@@ -422,37 +434,27 @@ async function resolveToolCalls(toolCalls, enabled, agentId, pipeline, skillName
             signal
         });
         resolved.push(fold.ok
-            ? {
-                call,
-                tool,
-                args: fold.args,
-                ...(call.raw === undefined ? {} : { rawCall: clipRawCall(call.raw) }),
-                ...(intent ? { intent } : {})
-            }
-            : {
-                call,
-                tool,
-                args,
-                rejection: fold.rejection,
-                ...(call.raw === undefined ? {} : { rawCall: clipRawCall(call.raw) }),
-                ...(intent ? { intent } : {})
-            });
+            ? { call, tool, args: fold.args, rawCall, intent }
+            : { call, tool, args, rejection: fold.rejection, rawCall, intent });
     }
     return resolved;
 }
 function unprovenReplay(state, final) {
     if (!state.unproven)
         return null;
-    if (state.stopToken)
+    if (state.stopToken) {
         return endsTurn(state.stopToken) ? state.unproven : null;
-    if (final.stopReason === 'length' || final.stopReason === 'cancelled')
+    }
+    if (final.stopReason === 'length' || final.stopReason === 'cancelled') {
         return null;
+    }
     return state.unproven;
 }
-async function* runRoundTokens(sdk, result, state, signal, startInThink = false) {
+async function* runRoundTokens(result, state, { sdk, signal, startInThink = false }) {
     const cancelThisRound = () => {
-        if (result.requestId)
+        if (result.requestId) {
             sdk.cancel?.({ requestId: result.requestId });
+        }
     };
     signal?.addEventListener('abort', cancelThisRound, { once: true });
     const tokens = stopAtControlToken(result.tokenStream, (token) => {
@@ -467,27 +469,33 @@ async function* runRoundTokens(sdk, result, state, signal, startInThink = false)
             const next = await events.next();
             if (next.done) {
                 state.unproven = next.value;
-                const thinkingTail = thinkingFilter.flush();
-                if (thinkingTail)
-                    yield { type: 'thinking', text: thinkingTail };
-                const contentTail = contentFilter.flush();
-                if (contentTail)
-                    yield { type: 'content', text: contentTail };
                 break;
             }
-            if (signal?.aborted)
+            if (signal?.aborted) {
                 throw new AbortedError();
+            }
             tokenEvents++;
-            if (next.value.type === 'content')
+            if (next.value.type === 'content') {
                 state.rawContentText += next.value.text;
+            }
             const filter = next.value.type === 'thinking' ? thinkingFilter : contentFilter;
             const text = filter.push(next.value.text);
-            if (text)
+            if (text) {
                 yield { type: next.value.type, text };
+            }
+        }
+        const thinkingTail = thinkingFilter.flush();
+        if (thinkingTail) {
+            yield { type: 'thinking', text: thinkingTail };
+        }
+        const contentTail = contentFilter.flush();
+        if (contentTail) {
+            yield { type: 'content', text: contentTail };
         }
         hlog('stream ended', { events: tokenEvents, stopToken: state.stopToken });
-        if (state.stopToken)
+        if (state.stopToken) {
             cancelThisRound();
+        }
     }
     finally {
         signal?.removeEventListener('abort', cancelThisRound);
@@ -512,17 +520,13 @@ function roundTokens(stats) {
 const TRUNCATED_FINAL_MS = 2000;
 function truncatedFinal(final, contentText) {
     const accepted = { contentText, toolCalls: [], raw: { fullText: contentText } };
-    let timer;
-    const expired = new Promise((resolve) => {
-        timer = setTimeout(() => resolve(accepted), TRUNCATED_FINAL_MS);
-    });
     const guarded = final.catch((err) => {
         if (isSdkModelWedgedError(err))
             throw err;
         return accepted;
     });
     guarded.catch(noop);
-    return Promise.race([guarded, expired]).finally(() => clearTimeout(timer));
+    return raceTimeout(guarded, { ms: TRUNCATED_FINAL_MS, fallback: accepted });
 }
 async function* runRecoveredRound(sdk, args) {
     const lease = args.acquireRound ? await args.acquireRound() : null;
@@ -573,9 +577,12 @@ async function* runRecoveredRoundWith(sdk, args, modelId) {
             const result = sdk.completion(params);
             result.final.catch(noop);
             const startInThink = args.generationParams?.reasoning_budget === -1;
-            for await (const event of runRoundTokens(sdk, result, state, args.signal, startInThink)) {
-                if (event.type === 'content')
-                    contentText += event.text;
+            for await (const event of runRoundTokens(result, state, {
+                sdk,
+                signal: args.signal,
+                startInThink
+            })) {
+                contentText += event.type === 'content' ? event.text : '';
                 emitted = true;
                 yield event;
             }
@@ -618,24 +625,28 @@ async function* runRecoveredRoundWith(sdk, args, modelId) {
                     messages: undefined,
                     tokens: undefined,
                     outcome: isContextOverflowError(err) ? 'overflowed' : 'failed',
-                    reason: err instanceof Error ? err.message : String(err)
+                    reason: errorMessage(err)
                 };
             }
-            if (!isContextOverflowError(err))
+            if (!isContextOverflowError(err)) {
                 throw err;
-            if (emitted)
+            }
+            if (emitted) {
                 throw new Error(CONTEXT_OVERFLOW_MESSAGE, { cause: err });
+            }
             lastOverflow = err;
         }
     }
-    if (lastOverflow)
+    if (lastOverflow) {
         throw new Error(CONTEXT_OVERFLOW_MESSAGE, { cause: lastOverflow });
+    }
     throw new Error('context recovery produced no completion candidate');
 }
 function* reportUnnamedWrites(said, landed) {
     const unreported = writeReport(unnamedWrites(said, landed));
-    if (unreported)
+    if (unreported) {
         yield { type: 'content', text: unreported };
+    }
 }
 export async function* completion(sdk, { modelId, acquireRound, model, agent, ctxSize, cacheKey, thinkingDefault, generationParams: generationParamsOverride, responseFormat, messages: storedMessages, tools: allTools = [], skillCatalog = [], approve, attach, fetchAttachment, ragSearch, progress, askUser, signal, toolConfigs, fsRoots = [], fsWriteRoots = [], captureInferenceCalls = false }) {
     const pipeline = new HookPipeline();
@@ -654,7 +665,7 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
     let runError;
     const runOutcomes = createRunOutcomeTracker();
     const landed = runOutcomes.confirmedWrites;
-    try {
+    async function* runTurn() {
         if (signal?.aborted)
             throw new AbortedError();
         await pipeline.onRunStart({ agentId, messages });
@@ -702,8 +713,8 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 hasActiveSkills: activeSkills.length > 0
             });
         }
-        const reasoningEnabled = agent?.reasoning === 'enabled' ? true : agent?.reasoning === 'disabled' ? false : undefined;
-        const deviceReasoning = thinkingDefault === 'enabled' ? true : thinkingDefault === 'disabled' ? false : undefined;
+        const reasoningEnabled = reasoningFlag(agent?.reasoning);
+        const deviceReasoning = reasoningFlag(thinkingDefault);
         const resolvedGenerationParams = resolveLlmGenerationParams(model, reasoningEnabled, deviceReasoning);
         const generationParams = generationParamsOverride
             ? { ...resolvedGenerationParams, ...generationParamsOverride }
@@ -714,10 +725,27 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         let skillIcon = null;
         const skillEmoji = (name) => skillCatalog.find((entry) => entry.name === name)?.emoji ?? null;
         const nudgedSkills = new Set();
+        function recordSkillLoad(skillName, output, { mainRequested, askedFile }) {
+            if (!output || typeof output !== 'object' || !('content' in output)) {
+                return;
+            }
+            loadedSkills.add(skillName);
+            if ('file' in output && typeof output.file === 'string') {
+                const files = loadedSkillFiles.get(skillName) ?? new Set();
+                files.add(output.file);
+                loadedSkillFiles.set(skillName, files);
+            }
+            if (mainRequested) {
+                loadedThisTurn.add(skillName);
+            }
+            else {
+                loadedFilesThisTurn.add(fileKey(skillName, unquoteArg(askedFile)));
+            }
+            skillIcon = skillEmoji(skillName) ?? skillIcon;
+        }
         const toolDialect = model ? customToolDialect(model) : undefined;
         let turns = messages;
         let preloadedSkill = null;
-        let stubDropped = false;
         const preload = mention ?? resolveImplicitSkill(lastUserContent(messages), activeSkills);
         if (preload) {
             const loader = tools.find((tool) => tool.name === SKILL_TOOL_NAME);
@@ -726,7 +754,6 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 preloadedSkill = String(loaded.content);
                 const inlined = preloadLastUser(messages, preload.name, preloadedSkill);
                 turns = withoutSkillLoadTurns(inlined, preload.name);
-                stubDropped = turns.length < inlined.length;
                 if (!loadedSkills.has(preload.name)) {
                     const preloadArgs = { name: preload.name };
                     const preloadEffect = 'read';
@@ -797,15 +824,16 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         }
         logSelection();
         let history = annotateLastUserTime(systemContent ? [{ role: 'system', content: systemContent }, ...turns] : turns);
-        let roundCacheKey = stubDropped ? undefined : cacheKey;
+        let roundCacheKey = preloadedSkill === null ? cacheKey : undefined;
         const runUsage = () => usageBreakdown(promptParts, stats.cacheTokens, model);
         const denied = new Set();
         const failed = new Map();
         let blockedRepeats = 0;
         let webSearches = 0;
         const sources = trustedSourcesFrom(messages);
-        if (preloadedSkill)
+        if (preloadedSkill) {
             sources.push({ origin: 'skill', text: preloadedSkill });
+        }
         const query = explicitWebSearchQuery(lastUserContent(messages), enabled, {
             skillPreloaded: preloadedSkill !== null
         });
@@ -822,8 +850,9 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             const searchEffect = webSearch.effect(args);
             const searchResource = webSearch.resource?.(args) ?? null;
             const searchCallDisplay = labelOf(webSearch.name, args, null);
-            if (signal?.aborted)
+            if (signal?.aborted) {
                 throw new AbortedError();
+            }
             yield {
                 type: 'tool-call',
                 name: webSearch.name,
@@ -833,7 +862,8 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             };
             let activity = null;
             const execution = fold.ok
-                ? await executeCall(webSearch, args, toolContext(turnImages, ctxSize), {
+                ? await executeCall(webSearch, args, {
+                    ctx: toolContext(turnImages, ctxSize),
                     approve,
                     signal,
                     denied,
@@ -856,8 +886,9 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             const executionOutcome = settled.outcome;
             runOutcomes.record(output, executionOutcome);
             runOutcomes.finishRound();
-            if (fold.ok)
+            if (fold.ok) {
                 webSearches++;
+            }
             if (!activity && !fold.ok) {
                 activity = {
                     type: 'tool-activity',
@@ -868,8 +899,9 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     decision: 'blocked'
                 };
             }
-            if (activity)
+            if (activity) {
                 yield activity;
+            }
             yield {
                 type: 'tool-result',
                 name: webSearch.name,
@@ -922,11 +954,12 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             });
             roundsSent = round + 1;
             const final = recovered.final;
-            if (!recovered.cacheable)
+            if (!recovered.cacheable) {
                 roundCacheKey = undefined;
+            }
             history = recovered.history;
             collectStats(stats, final.stats, final.stopReason);
-            hlog('round stats', { round, wallMs: Date.now() - roundStarted, ...(final.stats ?? {}) });
+            hlog('round stats', { round, wallMs: Date.now() - roundStarted, ...final.stats });
             const markup = stripToolResponseBlocks(truncateAtControlToken(final.raw.fullText) || recovered.unproven || '');
             let toolCalls = final.toolCalls?.length
                 ? final.toolCalls
@@ -937,24 +970,29 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 const alreadyLoaded = rescuedArgs !== undefined &&
                     (loadedSkillFiles.get(unquoteArg(rescuedArgs.name))?.has(unquoteArg(rescuedArgs.file)) ??
                         false);
-                if (!alreadyLoaded)
+                if (!alreadyLoaded) {
                     toolCalls = rescued;
-                if (toolCalls.length)
+                }
+                if (toolCalls.length) {
                     hlog('recovered printed skill load', { round });
+                }
             }
             if (!toolCalls.length && enabled.some((tool) => tool.name === SKILL_TOOL_NAME)) {
                 toolCalls = recoverSkillNamedCall(markup, inContextSkills
                     .filter((skill) => !nudgedSkills.has(skill.name))
                     .map((skill) => skill.name), SKILL_TOOL_NAME);
-                for (const call of toolCalls)
+                for (const call of toolCalls) {
                     nudgedSkills.add(unquoteArg(call.arguments.name));
-                if (toolCalls.length)
+                }
+                if (toolCalls.length) {
                     hlog('recovered skill-named call', { round });
+                }
             }
             if (!toolCalls.length) {
                 const replay = recovered.replay ? stripToolCallMarkup(recovered.replay) : '';
-                if (replay)
+                if (replay) {
                     yield { type: 'content', text: replay };
+                }
                 const spoken = recovered.contentText.trim();
                 if (enabled.length && !narrated && !replay && NARRATED_INTENT.test(spoken)) {
                     hlog('round narrated a tool call instead of making it', { round });
@@ -972,16 +1010,25 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     break;
                 }
                 hlog('round produced no answer', { round, mute });
-                if (mute++ < MAX_MUTE_ROUNDS)
+                if (mute++ < MAX_MUTE_ROUNDS) {
                     continue;
+                }
                 outcome = 'mute';
                 break;
             }
             mute = 0;
             narrated = false;
-            const resolved = await resolveToolCalls(toolCalls, enabled, agent?.id ?? null, pipeline, inContextSkills.map((skill) => skill.name), { sandboxMode: agent?.sandboxMode === true, signal });
-            if (signal?.aborted)
+            const resolved = await resolveToolCalls(toolCalls, {
+                enabled,
+                agentId: agent?.id ?? null,
+                pipeline,
+                skillNames: inContextSkills.map((skill) => skill.name),
+                sandboxMode: agent?.sandboxMode === true,
+                signal
+            });
+            if (signal?.aborted) {
                 throw new AbortedError();
+            }
             history = [
                 ...history,
                 {
@@ -1064,7 +1111,8 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                     });
                 }
                 else if (tool) {
-                    execution = await executeCall(tool, args, callCtx, {
+                    execution = await executeCall(tool, args, {
+                        ctx: callCtx,
                         approve,
                         signal,
                         denied,
@@ -1105,21 +1153,8 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 else if (tool?.name === WEB_SEARCH_TOOL_NAME && !rejection && !priorFailure) {
                     webSearches++;
                 }
-                if (call.name === SKILL_TOOL_NAME &&
-                    output &&
-                    typeof output === 'object' &&
-                    'content' in output) {
-                    loadedSkills.add(skillName);
-                    if ('file' in output && typeof output.file === 'string') {
-                        const files = loadedSkillFiles.get(skillName) ?? new Set();
-                        files.add(output.file);
-                        loadedSkillFiles.set(skillName, files);
-                    }
-                    if (mainRequested)
-                        loadedThisTurn.add(skillName);
-                    else
-                        loadedFilesThisTurn.add(fileKey(skillName, unquoteArg(askedFile)));
-                    skillIcon = skillEmoji(skillName) ?? skillIcon;
+                if (call.name === SKILL_TOOL_NAME) {
+                    recordSkillLoad(skillName, output, { mainRequested, askedFile });
                 }
                 if (!activity &&
                     !silent &&
@@ -1133,8 +1168,9 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                         decision: 'blocked'
                     };
                 }
-                if (activity)
+                if (activity) {
                     yield activity;
+                }
                 if (!silent) {
                     yield {
                         type: 'tool-result',
@@ -1162,8 +1198,9 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
                 blockedRepeats = 0;
             }
             history.push({ role: 'user', content: TOOL_CONTINUATION_NUDGE });
-            if (blockedRepeats >= MAX_BLOCKED_REPEATS)
+            if (blockedRepeats >= MAX_BLOCKED_REPEATS) {
                 break;
+            }
             if (cappedCalls === resolved.length) {
                 if (cappedRounds++ >= MAX_CAPPED_ROUNDS) {
                     outcome = 'search-capped';
@@ -1178,12 +1215,14 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
             yield* reportUnnamedWrites(said, landed);
             const answered = metricsEvent(stats, runUsage());
             runOutcome = 'done';
-            if (answered)
+            if (answered) {
                 yield answered;
+            }
             return;
         }
-        if (signal?.aborted)
+        if (signal?.aborted) {
             throw new AbortedError();
+        }
         const recovered = yield* runRecoveredRound(sdk, {
             modelId,
             acquireRound,
@@ -1198,8 +1237,9 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         });
         collectStats(stats, recovered.final.stats, recovered.final.stopReason);
         const answer = recovered.replay ? stripToolCallMarkup(recovered.replay) : '';
-        if (answer)
+        if (answer) {
             yield { type: 'content', text: answer };
+        }
         said = `${recovered.contentText}\n${answer}`;
         if (!said.trim()) {
             hlog('degenerate wrap-up', { outcome });
@@ -1213,13 +1253,18 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         }
         const metrics = metricsEvent(stats, runUsage());
         runOutcome = 'done';
-        if (metrics)
+        if (metrics) {
             yield metrics;
+        }
+    }
+    try {
+        yield* runTurn();
     }
     catch (err) {
         const written = writeReport(landed);
-        if (written)
+        if (written) {
             yield { type: 'content', text: written };
+        }
         if (err instanceof AbortedError) {
             runOutcome = 'aborted';
             yield { type: 'aborted' };
@@ -1242,3 +1287,17 @@ export async function* completion(sdk, { modelId, acquireRound, model, agent, ct
         });
     }
 }
+function toolDecision({ auto, skipAll, approved }) {
+    if (auto)
+        return 'auto';
+    if (skipAll)
+        return 'skip-all';
+    return approved ? 'allowed' : 'denied';
+}
+function reasoningFlag(setting) {
+    if (setting === 'enabled')
+        return true;
+    if (setting === 'disabled')
+        return false;
+    return undefined;
+}