@qvac/harness 0.7.0 → 1.0.0-rc.0

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

@@ -1,1303 +1,22 @@
-import process from 'process';
-import { contextCandidates } from '../context-window.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';
-import { INTENT_PARAM, INTENT_PARAM_DESCRIPTION, takeToolIntent } from '../helpers/tool-intent.js';
-import { HookPipeline } from '../hooks/pipeline.js';
-import { fallbackToolLabel } from '../helpers/tool-label.js';
-import { hlog } from '../log.js';
-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/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';
-import { promptUsageParts, usageBreakdown } from './usage-breakdown.js';
-import { collectToolGrants, enabledTools, isSelected, skillIsActive, skillsAreSelected } from './tool-selection.js';
-import { guardToolCall } from '../tools/outbound-guard.js';
-import { isAvailableState } from '../tools/skills/skill-state-constants.js';
-import { resolveImplicitSkill, resolveSkillMention, skillPreloadMessage } from '../tools/skills/mention.js';
-import { NETWORK_TOOLSETS, permittedTools } from '../tools/toolsets.js';
-import { promptPrefixHash } from './prompt-prefix.js';
-import { logToolPrompt } from './tool-prompt-log.js';
-import { DIRECT_CALL_ID, loadedSkillFilesFrom, loadedSkillsFrom, TOOL_CONTINUATION_NUDGE, toolResultTurn, withoutSkillLoadTurns } from './tool-turns.js';
-export function imageSettingsFrom(agent) {
-    if (!agent)
-        return undefined;
-    const settings = {};
-    if (agent.imageModelChoice) {
-        settings.modelChoice = agent.imageModelChoice;
-    }
-    if (agent.imageSteps) {
-        settings.steps = agent.imageSteps;
-    }
-    if (agent.imageWidth) {
-        settings.width = agent.imageWidth;
-    }
-    if (agent.imageHeight) {
-        settings.height = agent.imageHeight;
-    }
-    return Object.keys(settings).length ? settings : undefined;
-}
-const BURST_WINDOW_MS = 100;
-const MAX_TOOL_ROUNDS = 10;
-const RUN_WALL_CLOCK_BUDGET_MS = 30 * 60_000;
-function runWallClockBudgetMs() {
-    const ms = Number(process.env.QVAC_RUN_BUDGET_MS);
-    return ms > 0 ? ms : RUN_WALL_CLOCK_BUDGET_MS;
-}
-export const CONTEXT_OVERFLOW_MESSAGE = 'This message is too large for the model context window.';
-const MAX_MUTE_ROUNDS = 1;
-const NARRATED_INTENT = /\b(I['’]ll|I will|Now I|Let me(?! know)|Next,? I)\b[^.!?]*[.!?]?\s*$/i;
-const MAX_WEB_SEARCHES_PER_TURN = 3;
-const MAX_CAPPED_ROUNDS = 1;
-const WEB_SEARCH_LIMIT_MESSAGE = 'Web search limit reached for this question. Answer now from the results already gathered. ' +
-    'If something was not found, say so plainly and mention the most relevant sources. ' +
-    'Do not call web_search again.';
-export function trustedSourcesFrom(history) {
-    const sources = [];
-    for (const entry of history) {
-        const text = String(entry.content ?? '');
-        if (entry.role === 'user') {
-            sources.push({ origin: 'user', text });
-        }
-        else if (entry.role === 'tool') {
-            sources.push({ origin: originOfToolTurn(text), text });
-        }
-    }
-    return sources;
-}
-function originOfToolTurn(text) {
-    return text.startsWith(`[Tool: ${SKILL_TOOL_NAME} (`) ? 'skill' : 'tool-result';
-}
-const noop = () => { };
-function intentParameters(tool, params) {
-    if (tool.autoApprove === true || INTENT_PARAM in params.properties) {
-        return params;
-    }
-    return {
-        ...params,
-        properties: {
-            [INTENT_PARAM]: { type: 'string', description: INTENT_PARAM_DESCRIPTION },
-            ...params.properties
-        },
-        required: [INTENT_PARAM, ...(params.required ?? [])]
-    };
-}
-export function toSdkTool(tool) {
-    return {
-        type: 'function',
-        name: tool.name,
-        description: tool.prompt?.description ?? tool.description,
-        parameters: intentParameters(tool, tool.prompt?.parameters ?? tool.parameters)
-    };
-}
-function sanitizeTurn(turn) {
-    const stripped = stripControlTokens(turn.content);
-    const content = turn.role === 'assistant' ? stripToolCallMarkup(stripped) : stripped;
-    return content === turn.content ? turn : { ...turn, content };
-}
-function lastUserContent(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const turn = messages[i];
-        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') {
-            return turn.attachments ?? [];
-        }
-    }
-    return [];
-}
-function explicitWebSearchQuery(text, tools, { skillPreloaded }) {
-    if (!tools.some((tool) => tool.name === WEB_SEARCH_TOOL_NAME))
-        return null;
-    if (explicitlyDisablesWebSearch(text))
-        return null;
-    const named = /\b(?:search|browse|look\s+up|find)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text);
-    const freshness = /\b(?:latest|current|recent)\s+(?:news|events)\b/i.test(text) ||
-        /\bwhat(?:'s|\s+is)\s+(?:the\s+)?(?:latest|current|recent)\b/i.test(text);
-    const explicit = named || (freshness && !skillPreloaded);
-    return explicit && text.trim() ? text.trim() : null;
-}
-function explicitlyDisablesWebSearch(text) {
-    return (/\b(?:do\s+not|don't|dont|never)\s+(?:search|browse|look\s+up|find|use)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text) ||
-        /\b(?:avoid|without)\s+(?:searching|browsing|using)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text));
-}
-function directToolHistory(history, args, output) {
-    return [
-        ...history,
-        {
-            role: 'assistant',
-            content: toolCallMarkup([{ name: WEB_SEARCH_TOOL_NAME, arguments: args }])
-        },
-        { role: 'tool', content: toolResultTurn(WEB_SEARCH_TOOL_NAME, DIRECT_CALL_ID, output) }
-    ];
-}
-function assistantToolTurn(contentText, calls) {
-    if (!calls.length || contentText.includes('<function='))
-        return contentText;
-    const markup = toolCallMarkup(calls);
-    return contentText ? `${contentText}\n${markup}` : markup;
-}
-function preloadLastUser(messages, name, body) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const turn = messages[i];
-        if (turn?.role !== 'user') {
-            continue;
-        }
-        const next = [...messages];
-        next[i] = { ...turn, content: skillPreloadMessage(turn.content, name, body) };
-        return next;
-    }
-    return messages;
-}
-function collectStats(state, stats, stopReason) {
-    state.stopReason = stopReason;
-    if (!stats) {
-        return;
-    }
-    if (state.ttft === undefined && stats.timeToFirstToken) {
-        state.ttft = stats.timeToFirstToken;
-    }
-    if (state.promptTokensPerSecond === undefined && stats.promptTokensPerSecond) {
-        state.promptTokensPerSecond = stats.promptTokensPerSecond;
-    }
-    if (stats.generatedTokens) {
-        state.tokens += stats.generatedTokens;
-        if (stats.tokensPerSecond) {
-            state.durationMs += (stats.generatedTokens / stats.tokensPerSecond) * 1000;
-            state.timedTokens += stats.generatedTokens;
-        }
-    }
-    if (stats.promptTokens) {
-        state.promptTokens = stats.promptTokens;
-    }
-    if (stats.cacheTokens) {
-        state.cacheTokens = stats.cacheTokens;
-    }
-}
-function metricsEvent(state, usage) {
-    if (!state.tokens)
-        return null;
-    return {
-        type: 'metrics',
-        totalTokens: state.tokens,
-        durationMs: Math.round(state.durationMs),
-        timeToFirstToken: state.ttft,
-        promptTokensPerSecond: state.promptTokensPerSecond,
-        tokensPerSecond: state.durationMs > 0 ? (state.timedTokens / state.durationMs) * 1000 : undefined,
-        promptTokens: state.promptTokens,
-        cacheTokens: state.cacheTokens,
-        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 ' +
-    'around the refusal. Tell the user plainly what you could not do, and never present a ' +
-    'result you did not obtain.';
-function deniedResult() {
-    return { error: TOOL_DENIED_MESSAGE, denied: true };
-}
-function callKey(name, args) {
-    try {
-        return `${name}:${JSON.stringify(args)}`;
-    }
-    catch {
-        return name;
-    }
-}
-const RETRYABLE_STATUS = new Set([408, 429]);
-const RETRYABLE_CODE = new Set(['timeout', 'transport', 'busy']);
-function callSucceeded(result, outcome) {
-    if (outcome.kind !== 'success')
-        return false;
-    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 status = 'status' in result ? result.status : undefined;
-    const code = 'code' in result ? result.code : undefined;
-    return {
-        status: typeof status === 'number' ? status : undefined,
-        code: typeof code === 'string' ? code : undefined
-    };
-}
-function settledFailure(result, outcome) {
-    if (outcome.kind === 'denied' || callSucceeded(result, outcome))
-        return false;
-    if (outcome.kind === 'error' && outcome.error !== undefined)
-        return false;
-    const { code, status } = retryHints(result);
-    if (code !== undefined && RETRYABLE_CODE.has(code)) {
-        return false;
-    }
-    return status === undefined || (status < 500 && !RETRYABLE_STATUS.has(status));
-}
-const MAX_BLOCKED_REPEATS = 3;
-function terminalCall(result, outcome, options) {
-    return { result, outcome, executed: options.executed };
-}
-function executedCall(result, outcome) {
-    return terminalCall(result, outcome, { executed: true });
-}
-function guidanceResult(message) {
-    return terminalCall({ error: message, guidance: true }, { kind: 'guidance', message }, {
-        executed: false
-    });
-}
-function blockedResult(result, reason) {
-    return terminalCall(result, { kind: 'blocked', reason }, { executed: false });
-}
-function deniedCall() {
-    return terminalCall(deniedResult(), { kind: 'denied', reason: TOOL_DENIED_MESSAGE }, {
-        executed: false
-    });
-}
-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,
-        externalWrite: tool.externalWrite === true
-    });
-    if (refusal) {
-        hlog('tool refused: unverifiable value in payload', { tool: tool.name });
-        onToolActivity?.({
-            type: 'tool-activity',
-            name: tool.name,
-            args,
-            resource: tool.resource?.(args, ctx) ?? null,
-            effect: tool.effect(args, ctx),
-            decision: 'blocked'
-        });
-        return blockedResult({ error: refusal, guidance: true }, refusal);
-    }
-    const key = callKey(tool.name, args);
-    if (denied?.has(key)) {
-        hlog('tool denied already, not asking again', { tool: tool.name });
-        return deniedCall();
-    }
-    const effect = classified ?? tool.effect(args, ctx);
-    const resource = tool.resource?.(args, ctx) ?? null;
-    const autoRun = effect === 'read' || tool.autoApprove === true || skipApprovals === true;
-    hlog('tool decision', {
-        tool: tool.name,
-        effect,
-        auto: autoRun,
-        asks: Boolean(approve)
-    });
-    const approved = autoRun ||
-        (approve
-            ? await raceAbort(approve({
-                name: tool.name,
-                arguments: args,
-                resource,
-                effect,
-                intent: intent ?? null,
-                display: display ?? null
-            }), signal)
-            : false);
-    hlog(`tool ${approved ? 'approved' : 'denied'}`, { tool: tool.name });
-    const decision = toolDecision({
-        auto: tool.autoApprove === true || effect === 'read',
-        skipAll: skipApprovals === true,
-        approved
-    });
-    onToolActivity?.({
-        type: 'tool-activity',
-        name: tool.name,
-        args,
-        resource,
-        effect,
-        decision
-    });
-    if (!approved) {
-        denied?.add(key);
-        return deniedCall();
-    }
-    let output;
-    let outcome = { kind: 'success' };
-    try {
-        output = await tool.execute(args, { ...ctx, signal, approval: decision });
-        hlog('tool done', { tool: tool.name });
-    }
-    catch (err) {
-        const message = errorMessage(err);
-        hlog('tool failed', { tool: tool.name, err: message });
-        output = { error: message, code: errorCode(err) };
-        outcome = { kind: 'error', message, error: err };
-    }
-    return executedCall(output, outcome);
-}
-function runToolContext(scope) {
-    const { agent, attach, fetchAttachment, ragSearch, progress, askUser, signal, runBudget } = scope;
-    const image = imageSettingsFrom(agent);
-    return (turnImages = [], ctxSize) => ({
-        agentId: agent?.id ?? null,
-        ctxSize,
-        image,
-        turnImages: turnImages.length ? turnImages : undefined,
-        attach,
-        fetchAttachment,
-        ragSearch,
-        progress,
-        askUser,
-        signal,
-        runBudget
-    });
-}
-function labelOf(name, args, emoji) {
-    const display = { label: fallbackToolLabel(name, args) };
-    return emoji ? { ...display, iconEmoji: emoji } : display;
-}
-async function settleToolCall(pipeline, execution, call) {
-    const folded = await pipeline.runPostToolFold({
-        toolName: call.name,
-        agentId: call.agentId,
-        args: call.args,
-        effect: call.effect ?? 'write',
-        resource: call.resource,
-        toolset: call.tool?.toolset,
-        result: execution.result,
-        outcome: execution.outcome,
-        executed: execution.executed
-    });
-    return {
-        result: folded.result,
-        outcome: folded.outcome ?? execution.outcome
+import { trackCompletion } from '../completion-lifecycle.js';
+import { driveCompletion } from './completion-engine/driver.js';
+import { createRunLogRedactor } from '../run-log-redact.js';
+export * from './types.js';
+export { CONTEXT_OVERFLOW_MESSAGE, imageSettingsFrom, loadedSkillsFrom, skillInContext, skillLoadedTurn, toSdkTool, trustedSourcesFrom, unreadySkillState } from './completion-loop/index.js';
+export function completion(sdk, args, options = {}) {
+    const redactor = createRunLogRedactor();
+    redactor.registerTools(args.tools ?? []);
+    const runtime = typeof sdk === 'function' ? sdk : async () => ({ sdk });
+    const loadRuntime = async (request) => {
+        const loaded = await runtime(request);
+        redactor.registerTools(loaded.args?.tools ?? args.tools ?? []);
+        return loaded;
     };
-}
-function skillInContext(entry) {
-    return entry.status === undefined || isAvailableState(entry.status);
-}
-function unreadySkillState(name, catalog) {
-    const status = catalog.find((entry) => entry.name === name)?.status;
-    return status !== undefined && !isAvailableState(status) ? status : null;
-}
-function blockedSkillMessage(name, catalog, listShown) {
-    if (catalog.some((entry) => entry.name === name)) {
-        return (`skill "${name}" is not enabled for this agent. Do not rebuild what it does with another ` +
-            `tool — answer from what you already have, or tell the user to enable it in Skills.`);
-    }
-    return listShown
-        ? `there is no skill named "${name}". Load one from the skills list you were shown, or ` +
-            `answer from what you already have — do not guess another name.`
-        : `there is no skill named "${name}". You were not shown a skills list, which means no ` +
-            `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 }) {
-    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, rawCall });
-            continue;
-        }
-        const taken = takeToolIntent(call.arguments);
-        const args = normalizeToolArgs(taken.args, Object.keys(tool.parameters.properties));
-        const intent = taken.intent || undefined;
-        const fold = await pipeline.runPreToolFold({
-            toolName: tool.name,
-            args,
-            agentId,
-            skillNames,
-            parameters: tool.parameters,
-            sandboxMode,
-            signal
-        });
-        resolved.push(fold.ok
-            ? { 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) {
-        return endsTurn(state.stopToken) ? state.unproven : null;
-    }
-    if (final.stopReason === 'length' || final.stopReason === 'cancelled') {
-        return null;
-    }
-    return state.unproven;
-}
-async function* runRoundTokens(result, state, { sdk, signal, startInThink = false }) {
-    const cancelThisRound = () => {
-        if (result.requestId) {
-            sdk.cancel?.({ requestId: result.requestId });
-        }
-    };
-    signal?.addEventListener('abort', cancelThisRound, { once: true });
-    const tokens = stopAtControlToken(result.tokenStream, (token) => {
-        state.stopToken = token;
-    });
-    let tokenEvents = 0;
-    const events = splitThinking(bufferBurst(tokens, BURST_WINDOW_MS), { startInThink });
-    const thinkingFilter = createMarkupStreamFilter();
-    const contentFilter = createMarkupStreamFilter();
-    try {
-        while (true) {
-            const next = await events.next();
-            if (next.done) {
-                state.unproven = next.value;
-                break;
-            }
-            if (signal?.aborted) {
-                throw new AbortedError();
-            }
-            tokenEvents++;
-            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) {
-                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) {
-            cancelThisRound();
-        }
-    }
-    finally {
-        signal?.removeEventListener('abort', cancelThisRound);
-        await events.return(null);
-    }
-}
-function sentMessages(stats) {
-    const sent = stats?.sentMessages;
-    return Array.isArray(sent) ? sent : null;
-}
-function roundTokens(stats) {
-    if (!stats)
-        return undefined;
-    const tokens = {
-        prompt: stats.promptTokens,
-        generated: stats.generatedTokens,
-        cached: stats.cacheTokens,
-        timeToFirstToken: stats.timeToFirstToken
-    };
-    return Object.values(tokens).some((value) => value !== undefined) ? tokens : undefined;
-}
-const TRUNCATED_FINAL_MS = 2000;
-function truncatedFinal(final, contentText) {
-    const accepted = { contentText, toolCalls: [], raw: { fullText: contentText } };
-    const guarded = final.catch((err) => {
-        if (isSdkModelWedgedError(err))
-            throw err;
-        return accepted;
-    });
-    guarded.catch(noop);
-    return raceTimeout(guarded, { ms: TRUNCATED_FINAL_MS, fallback: accepted });
-}
-async function* runRecoveredRound(sdk, args) {
-    const lease = args.acquireRound ? await args.acquireRound() : null;
-    try {
-        return yield* runRecoveredRoundWith(sdk, args, lease?.modelId ?? args.modelId);
-    }
-    finally {
-        lease?.release();
-    }
-}
-async function* runRecoveredRoundWith(sdk, args, modelId) {
-    let lastOverflow = null;
-    for (const candidate of contextCandidates(args.history)) {
-        if (args.signal?.aborted)
-            throw new AbortedError();
-        let contentText = '';
-        let emitted = false;
-        const state = { stopToken: null, unproven: null, rawContentText: '' };
-        const cacheable = candidate.history === args.history;
-        const params = {
-            modelId,
-            history: candidate.history,
-            stream: true,
-            tools: args.tools,
-            generationParams: args.generationParams,
-            responseFormat: args.responseFormat,
-            toolDialect: args.toolDialect,
-            kvCache: cacheable ? args.cacheKey : undefined
-        };
-        if (args.capture) {
-            yield {
-                type: 'inference-call',
-                call: {
-                    round: args.round,
-                    droppedTurns: candidate.droppedTurns,
-                    modelId,
-                    messages: params.history,
-                    tools: params.tools,
-                    generationParams: params.generationParams,
-                    responseFormat: params.responseFormat,
-                    toolDialect: params.toolDialect,
-                    cacheKey: params.kvCache,
-                    promptPrefix: args.promptPrefix
-                }
-            };
-        }
-        try {
-            const result = sdk.completion(params);
-            result.final.catch(noop);
-            const startInThink = args.generationParams?.reasoning_budget === -1;
-            for await (const event of runRoundTokens(result, state, {
-                sdk,
-                signal: args.signal,
-                startInThink
-            })) {
-                contentText += event.type === 'content' ? event.text : '';
-                emitted = true;
-                yield event;
-            }
-            const final = state.stopToken
-                ? await truncatedFinal(result.final, state.rawContentText)
-                : await raceAbort(result.final, args.signal);
-            if (args.capture) {
-                yield {
-                    type: 'inference-sent',
-                    round: args.round,
-                    droppedTurns: candidate.droppedTurns,
-                    messages: sentMessages(final.stats) ?? undefined,
-                    tokens: roundTokens(final.stats),
-                    outcome: 'completed',
-                    reason: undefined
-                };
-            }
-            const replay = unprovenReplay(state, final);
-            hlog('final', {
-                stopReason: final.stopReason,
-                toolCalls: final.toolCalls?.length ?? 0,
-                stopToken: state.stopToken,
-                replay: replay !== null
-            });
-            return {
-                contentText,
-                final,
-                history: candidate.history,
-                cacheable,
-                unproven: state.unproven,
-                replay
-            };
-        }
-        catch (err) {
-            if (args.capture) {
-                yield {
-                    type: 'inference-sent',
-                    round: args.round,
-                    droppedTurns: candidate.droppedTurns,
-                    messages: undefined,
-                    tokens: undefined,
-                    outcome: isContextOverflowError(err) ? 'overflowed' : 'failed',
-                    reason: errorMessage(err)
-                };
-            }
-            if (!isContextOverflowError(err)) {
-                throw err;
-            }
-            if (emitted) {
-                throw new Error(CONTEXT_OVERFLOW_MESSAGE, { cause: err });
-            }
-            lastOverflow = err;
-        }
-    }
-    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) {
-        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();
-    const agentId = agent?.id ?? null;
-    const disabledToolsets = agent?.sandboxMode
-        ? [...(agent.disabledToolsets ?? []), ...NETWORK_TOOLSETS]
-        : agent?.disabledToolsets;
-    const tools = permittedTools(allTools, disabledToolsets);
-    const writableRoots = [
-        ...fsWriteRoots,
-        ...fsRoots.filter((root) => root.kind === 'hyper' && root.writable && !fsWriteRoots.includes(root))
-    ];
-    const messages = storedMessages.map(sanitizeTurn);
-    const stats = { tokens: 0, timedTokens: 0, durationMs: 0, ctxSize, backends: [] };
-    let runOutcome = 'abandoned';
-    let runError;
-    const runOutcomes = createRunOutcomeTracker();
-    const landed = runOutcomes.confirmedWrites;
-    async function* runTurn() {
-        if (signal?.aborted)
-            throw new AbortedError();
-        await pipeline.onRunStart({ agentId, messages });
-        const runBudget = {
-            deadlineMs: Date.now() + runWallClockBudgetMs(),
-            outputBytesUsed: 0
-        };
-        const toolContext = runToolContext({
-            agent,
-            attach,
-            fetchAttachment,
-            ragSearch,
-            progress,
-            askUser,
-            signal,
-            runBudget
-        });
-        const turnImages = lastUserImages(messages);
-        const toolsSelected = isSelected(agent?.toolsScope, agent?.enabledTools);
-        const skillsSelected = skillsAreSelected(agent?.skillsScope, Boolean(agent));
-        const inContextSkills = skillCatalog.filter(skillInContext);
-        const mention = resolveSkillMention(lastUserContent(messages), inContextSkills);
-        const loadedSkills = loadedSkillsFrom(messages);
-        const loadedSkillFiles = loadedSkillFilesFrom(messages);
-        const activation = {
-            skillsSelected,
-            enabledSkills: agent?.enabledSkills ?? [],
-            mention: mention?.name ?? null,
-            loadedSkills
-        };
-        const activeSkills = inContextSkills.filter((skill) => skillIsActive(skill.name, activation));
-        const { grantedNames, grantedOwners, grantedOps } = collectToolGrants(activeSkills);
-        function selectEnabled() {
-            if (responseFormat)
-                return [];
-            const loaded = activeSkills.filter((skill) => loadedSkills.has(skill.name));
-            return enabledTools(tools, {
-                toolsSelected,
-                allowlist: agent?.enabledTools ?? [],
-                grantedNames,
-                grantedOwners,
-                loadedGrantedNames: collectToolGrants(loaded).grantedNames,
-                hasRoots: fsRoots.length > 0,
-                hasWriteRoots: writableRoots.length > 0,
-                hasActiveSkills: activeSkills.length > 0
-            });
-        }
-        const reasoningEnabled = reasoningFlag(agent?.reasoning);
-        const deviceReasoning = reasoningFlag(thinkingDefault);
-        const resolvedGenerationParams = resolveLlmGenerationParams(model, reasoningEnabled, deviceReasoning);
-        const generationParams = generationParamsOverride
-            ? { ...resolvedGenerationParams, ...generationParamsOverride }
-            : resolvedGenerationParams;
-        const loadedThisTurn = new Set();
-        const loadedFilesThisTurn = new Set();
-        const fileKey = (skill, file) => `${skill}\0${skillFileStem(file)}`;
-        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;
-        const preload = mention ?? resolveImplicitSkill(lastUserContent(messages), activeSkills);
-        if (preload) {
-            const loader = tools.find((tool) => tool.name === SKILL_TOOL_NAME);
-            const loaded = loader ? await loader.execute({ name: preload.name }, toolContext()) : null;
-            if (loaded && typeof loaded === 'object' && 'content' in loaded) {
-                preloadedSkill = String(loaded.content);
-                const inlined = preloadLastUser(messages, preload.name, preloadedSkill);
-                turns = withoutSkillLoadTurns(inlined, preload.name);
-                if (!loadedSkills.has(preload.name)) {
-                    const preloadArgs = { name: preload.name };
-                    const preloadEffect = 'read';
-                    const preloadResource = loader?.resource?.(preloadArgs) ?? null;
-                    yield {
-                        type: 'tool-call',
-                        name: SKILL_TOOL_NAME,
-                        args: preloadArgs,
-                        effect: preloadEffect,
-                        display: labelOf(SKILL_TOOL_NAME, preloadArgs, skillEmoji(preload.name))
-                    };
-                    yield {
-                        type: 'tool-activity',
-                        name: SKILL_TOOL_NAME,
-                        args: { name: preload.name },
-                        resource: null,
-                        effect: 'read',
-                        decision: 'auto'
-                    };
-                    const settled = await settleToolCall(pipeline, executedCall(loaded, { kind: 'success' }), {
-                        agentId,
-                        tool: loader,
-                        name: SKILL_TOOL_NAME,
-                        args: preloadArgs,
-                        effect: preloadEffect,
-                        resource: preloadResource
-                    });
-                    yield {
-                        type: 'tool-result',
-                        name: SKILL_TOOL_NAME,
-                        result: settled.result
-                    };
-                }
-            }
-        }
-        if (preload && preloadedSkill) {
-            loadedSkills.add(preload.name);
-            loadedThisTurn.add(preload.name);
-            skillIcon = skillEmoji(preload.name) ?? skillIcon;
-        }
-        let enabled = selectEnabled();
-        let sdkTools = enabled.length ? enabled.map((tool) => toSdkTool(tool)) : undefined;
-        const system = systemPromptParts({
-            bio: agent?.bio,
-            toolNames: enabled.map((tool) => tool.name),
-            skillsSection: skillsPromptSection(activeSkills)
-        });
-        const systemContent = system.text;
-        let promptPrefix = promptPrefixHash({ system: systemContent, tools: sdkTools });
-        let promptParts = promptUsageParts({ system, toolSchemas: sdkTools });
-        function logSelection() {
-            logToolPrompt({
-                promptPrefix,
-                modelId,
-                cacheKey,
-                agentId: agent?.id,
-                messageCount: messages.length,
-                responseFormat: responseFormat?.type,
-                tools: sdkTools,
-                definitions: enabled,
-                activeSkills: activeSkills.map((skill) => skill.name),
-                skillsSelected,
-                enabledSkills: agent?.enabledSkills ?? [],
-                mentionedSkill: mention?.name ?? null,
-                loadedSkills,
-                toolOps: grantedOps
-            });
-        }
-        logSelection();
-        let history = annotateLastUserTime(systemContent ? [{ role: 'system', content: systemContent }, ...turns] : turns);
-        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) {
-            sources.push({ origin: 'skill', text: preloadedSkill });
-        }
-        const query = explicitWebSearchQuery(lastUserContent(messages), enabled, {
-            skillPreloaded: preloadedSkill !== null
-        });
-        const webSearch = enabled.find((tool) => tool.name === WEB_SEARCH_TOOL_NAME);
-        if (query && webSearch) {
-            runOutcomes.beginRound();
-            const fold = await pipeline.runPreToolFold({
-                toolName: webSearch.name,
-                args: { query },
-                agentId: agent?.id ?? null,
-                signal
-            });
-            const args = fold.ok ? fold.args : { query };
-            const searchEffect = webSearch.effect(args);
-            const searchResource = webSearch.resource?.(args) ?? null;
-            const searchCallDisplay = labelOf(webSearch.name, args, null);
-            if (signal?.aborted) {
-                throw new AbortedError();
-            }
-            yield {
-                type: 'tool-call',
-                name: webSearch.name,
-                args,
-                effect: searchEffect,
-                display: searchCallDisplay
-            };
-            let activity = null;
-            const execution = fold.ok
-                ? await executeCall(webSearch, args, {
-                    ctx: toolContext(turnImages, ctxSize),
-                    approve,
-                    signal,
-                    denied,
-                    skipApprovals: agent?.approvalMode === 'skip-all',
-                    display: searchCallDisplay,
-                    onToolActivity: (a) => (activity = a)
-                })
-                : terminalCall(fold.rejection, { kind: 'guidance', message: fold.rejection.error }, {
-                    executed: false
-                });
-            const settled = await settleToolCall(pipeline, execution, {
-                agentId,
-                tool: webSearch,
-                name: webSearch.name,
-                args,
-                effect: searchEffect,
-                resource: searchResource
-            });
-            const output = settled.result;
-            const executionOutcome = settled.outcome;
-            runOutcomes.record(output, executionOutcome);
-            runOutcomes.finishRound();
-            if (fold.ok) {
-                webSearches++;
-            }
-            if (!activity && !fold.ok) {
-                activity = {
-                    type: 'tool-activity',
-                    name: webSearch.name,
-                    args,
-                    resource: searchResource,
-                    effect: searchEffect,
-                    decision: 'blocked'
-                };
-            }
-            if (activity) {
-                yield activity;
-            }
-            yield {
-                type: 'tool-result',
-                name: webSearch.name,
-                result: output
-            };
-            history = directToolHistory(history, args, output);
-        }
-        let outcome = 'exhausted';
-        let said = '';
-        let mute = 0;
-        let narrated = false;
-        let cappedRounds = 0;
-        let roundsSent = 0;
-        let round = 0;
-        for (; round < MAX_TOOL_ROUNDS; round++) {
-            if (signal?.aborted)
-                throw new AbortedError();
-            if (Date.now() >= runBudget.deadlineMs) {
-                outcome = 'time-capped';
-                break;
-            }
-            const reselected = selectEnabled();
-            if (reselected.map((tool) => tool.name).join() !== enabled.map((tool) => tool.name).join()) {
-                enabled = reselected;
-                sdkTools = enabled.length ? enabled.map((tool) => toSdkTool(tool)) : undefined;
-                promptPrefix = promptPrefixHash({ system: systemContent, tools: sdkTools });
-                promptParts = promptUsageParts({ system, toolSchemas: sdkTools });
-                logSelection();
-            }
-            hlog('round start', {
-                round,
-                turns: history.length,
-                tools: sdkTools?.length ?? 0,
-                promptPrefix
-            });
-            const roundStarted = Date.now();
-            const recovered = yield* runRecoveredRound(sdk, {
-                modelId,
-                acquireRound,
-                history,
-                tools: sdkTools,
-                generationParams,
-                responseFormat,
-                toolDialect,
-                cacheKey: roundCacheKey,
-                signal,
-                round,
-                promptPrefix,
-                capture: captureInferenceCalls
-            });
-            roundsSent = round + 1;
-            const final = recovered.final;
-            if (!recovered.cacheable) {
-                roundCacheKey = undefined;
-            }
-            history = recovered.history;
-            collectStats(stats, final.stats, final.stopReason);
-            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
-                : recoverMarkupToolCalls(markup, enabled);
-            if (!toolCalls.length && enabled.some((tool) => tool.name === SKILL_TOOL_NAME)) {
-                const rescued = recoverPrintedSkillLoad(markup, SKILL_TOOL_NAME);
-                const rescuedArgs = rescued[0]?.arguments;
-                const alreadyLoaded = rescuedArgs !== undefined &&
-                    (loadedSkillFiles.get(unquoteArg(rescuedArgs.name))?.has(unquoteArg(rescuedArgs.file)) ??
-                        false);
-                if (!alreadyLoaded) {
-                    toolCalls = rescued;
-                }
-                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) {
-                    nudgedSkills.add(unquoteArg(call.arguments.name));
-                }
-                if (toolCalls.length) {
-                    hlog('recovered skill-named call', { round });
-                }
-            }
-            if (!toolCalls.length) {
-                const replay = recovered.replay ? stripToolCallMarkup(recovered.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 });
-                    narrated = true;
-                    history = [
-                        ...history,
-                        { role: 'assistant', content: spoken },
-                        { role: 'user', content: TOOL_CONTINUATION_NUDGE }
-                    ];
-                    continue;
-                }
-                if (replay || spoken) {
-                    said = `${recovered.contentText}\n${replay}`;
-                    outcome = 'answered';
-                    break;
-                }
-                hlog('round produced no answer', { round, mute });
-                if (mute++ < MAX_MUTE_ROUNDS) {
-                    continue;
-                }
-                outcome = 'mute';
-                break;
-            }
-            mute = 0;
-            narrated = false;
-            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,
-                {
-                    role: 'assistant',
-                    content: assistantToolTurn(recovered.contentText, resolved.map(({ call, args }) => ({ name: call.name, arguments: args })))
-                }
-            ];
-            let cappedCalls = 0;
-            let progressed = false;
-            runOutcomes.beginRound();
-            for (const { call, tool, args, rawCall, rejection, intent } of resolved) {
-                if (signal?.aborted)
-                    throw new AbortedError();
-                const priorFailure = failed.get(callKey(call.name, args));
-                const searchCapped = tool?.name === WEB_SEARCH_TOOL_NAME && webSearches >= MAX_WEB_SEARCHES_PER_TURN;
-                const callCtx = {
-                    ...toolContext(turnImages, ctxSize),
-                    skills: [...loadedSkills].filter((name) => !skillsSelected ||
-                        (agent?.enabledSkills ?? []).includes(name) ||
-                        name === mention?.name),
-                    settings: toolConfigs?.[call.name],
-                    toolOps: grantedOps,
-                    fsRoots,
-                    fsWriteRoots: writableRoots,
-                    reportBackend: (use) => stats.backends.push(use),
-                    sandboxMode: agent?.sandboxMode === true,
-                    toolNames: enabled.map((tool) => tool.name)
-                };
-                const skillCall = call.name === SKILL_TOOL_NAME;
-                const effect = tool?.effect(args, callCtx) ?? (skillCall ? 'read' : undefined);
-                const resource = tool?.resource?.(args) ?? null;
-                const skillName = unquoteArg(args?.name ?? args?.skill_name ?? args?.skill);
-                const askedFile = skillFileArg(args);
-                const mainRequested = mainFileRequested(skillName, askedFile);
-                const skillReloaded = tool?.name === SKILL_TOOL_NAME &&
-                    (mainRequested
-                        ? loadedThisTurn.has(skillName)
-                        : loadedFilesThisTurn.has(fileKey(skillName, unquoteArg(askedFile))));
-                const silent = searchCapped || skillReloaded || priorFailure !== undefined;
-                const display = silent
-                    ? undefined
-                    : labelOf(call.name, args, skillCall ? skillEmoji(skillName) : skillIcon);
-                if (!silent) {
-                    yield { type: 'tool-call', name: call.name, args, rawCall, effect, display };
-                }
-                const unreadyState = skillCall ? unreadySkillState(skillName, skillCatalog) : null;
-                const skillBlocked = skillCall && !unreadyState && (!tool || !skillIsActive(skillName, activation));
-                let activity = null;
-                const blockedReason = blockedSkillMessage(skillName, skillCatalog, activeSkills.length > 0);
-                const unreadyReason = `skill "${skillName}" is ${unreadyState ?? 'unavailable'} and cannot be used yet. ` +
-                    `Tell the user to open it in Skills and finish its setup; do not retry.`;
-                let execution;
-                if (priorFailure) {
-                    blockedRepeats++;
-                    hlog('repeat of a call that already failed; answered without running it', {
-                        tool: call.name,
-                        blockedRepeats
-                    });
-                    execution = terminalCall(priorFailure.result, priorFailure.outcome, { executed: false });
-                }
-                else if (skillReloaded) {
-                    const loadedWhat = mainRequested ? skillName : `${skillName} ${unquoteArg(askedFile)}`;
-                    execution = terminalCall({
-                        name: skillName,
-                        content: `${loadedWhat} is already loaded. Follow the instructions you were given and do not load it again.`
-                    }, { kind: 'guidance', message: `${skillName} is already loaded.` }, { executed: false });
-                }
-                else if (skillBlocked) {
-                    execution = blockedResult({ error: blockedReason }, blockedReason);
-                }
-                else if (unreadyState) {
-                    execution = blockedResult({ error: unreadyReason }, unreadyReason);
-                }
-                else if (searchCapped) {
-                    execution = terminalCall({ content: WEB_SEARCH_LIMIT_MESSAGE }, { kind: 'success' }, { executed: false });
-                }
-                else if (rejection) {
-                    execution = terminalCall(rejection, { kind: 'guidance', message: rejection.error }, {
-                        executed: false
-                    });
-                }
-                else if (tool) {
-                    execution = await executeCall(tool, args, {
-                        ctx: callCtx,
-                        approve,
-                        signal,
-                        denied,
-                        sources,
-                        effect,
-                        skipApprovals: agent?.approvalMode === 'skip-all',
-                        intent,
-                        display,
-                        onToolActivity: (event) => {
-                            activity = event;
-                        }
-                    });
-                }
-                else {
-                    execution = blockedResult({ error: `unknown tool: ${call.name}` }, `unknown tool: ${call.name}`);
-                }
-                const settled = await settleToolCall(pipeline, execution, {
-                    agentId,
-                    tool,
-                    name: call.name,
-                    args,
-                    effect,
-                    resource
-                });
-                const output = settled.result;
-                const executionOutcome = settled.outcome;
-                if (!priorFailure && settledFailure(output, executionOutcome)) {
-                    failed.set(callKey(call.name, args), settled);
-                }
-                else if (execution.executed && callSucceeded(output, executionOutcome)) {
-                    progressed = true;
-                }
-                runOutcomes.record(output, executionOutcome);
-                if (searchCapped) {
-                    cappedCalls++;
-                    hlog('web_search capped', { searches: webSearches });
-                }
-                else if (tool?.name === WEB_SEARCH_TOOL_NAME && !rejection && !priorFailure) {
-                    webSearches++;
-                }
-                if (call.name === SKILL_TOOL_NAME) {
-                    recordSkillLoad(skillName, output, { mainRequested, askedFile });
-                }
-                if (!activity &&
-                    !silent &&
-                    (skillBlocked || Boolean(unreadyState) || Boolean(rejection) || !tool)) {
-                    activity = {
-                        type: 'tool-activity',
-                        name: call.name,
-                        args,
-                        resource,
-                        effect: effect ?? 'write',
-                        decision: 'blocked'
-                    };
-                }
-                if (activity) {
-                    yield activity;
-                }
-                if (!silent) {
-                    yield {
-                        type: 'tool-result',
-                        name: call.name,
-                        result: output
-                    };
-                }
-                const isCompiledOperation = tool?.compiled === true;
-                const isMutation = effect === 'write' &&
-                    ((tool?.toolset === 'mcp-call' && !isMetadataMethod(args.method)) ||
-                        (isCompiledOperation && tool?.toolset === 'http-request'));
-                if (isMutation && executionOutcome.kind === 'success') {
-                    runOutcomes.confirmWrite(output);
-                }
-                const turn = toolResultTurn(call.name, call.id, output);
-                sources.push({
-                    origin: call.name === SKILL_TOOL_NAME ? 'skill' : 'tool-result',
-                    text: turn
-                });
-                history.push({ role: 'tool', content: turn });
-            }
-            runOutcomes.finishRound();
-            if (progressed) {
-                failed.clear();
-                blockedRepeats = 0;
-            }
-            history.push({ role: 'user', content: TOOL_CONTINUATION_NUDGE });
-            if (blockedRepeats >= MAX_BLOCKED_REPEATS) {
-                break;
-            }
-            if (cappedCalls === resolved.length) {
-                if (cappedRounds++ >= MAX_CAPPED_ROUNDS) {
-                    outcome = 'search-capped';
-                    break;
-                }
-            }
-            else {
-                cappedRounds = 0;
-            }
-        }
-        if (outcome === 'answered') {
-            yield* reportUnnamedWrites(said, landed);
-            const answered = metricsEvent(stats, runUsage());
-            runOutcome = 'done';
-            if (answered) {
-                yield answered;
-            }
-            return;
-        }
-        if (signal?.aborted) {
-            throw new AbortedError();
-        }
-        const recovered = yield* runRecoveredRound(sdk, {
-            modelId,
-            acquireRound,
-            history,
-            tools: undefined,
-            generationParams,
-            cacheKey: roundCacheKey,
-            signal,
-            round: roundsSent,
-            promptPrefix: promptPrefixHash({ system: systemContent, tools: undefined }),
-            capture: captureInferenceCalls
-        });
-        collectStats(stats, recovered.final.stats, recovered.final.stopReason);
-        const answer = recovered.replay ? stripToolCallMarkup(recovered.replay) : '';
-        if (answer) {
-            yield { type: 'content', text: answer };
-        }
-        said = `${recovered.contentText}\n${answer}`;
-        if (!said.trim()) {
-            hlog('degenerate wrap-up', { outcome });
-            yield {
-                type: 'content',
-                text: degenerateAnswer(outcome, history, runOutcomes.facts())
-            };
-        }
-        else {
-            yield* reportUnnamedWrites(said, landed);
-        }
-        const metrics = metricsEvent(stats, runUsage());
-        runOutcome = 'done';
-        if (metrics) {
-            yield metrics;
-        }
-    }
-    try {
-        yield* runTurn();
-    }
-    catch (err) {
-        const written = writeReport(landed);
-        if (written) {
-            yield { type: 'content', text: written };
-        }
-        if (err instanceof AbortedError) {
-            runOutcome = 'aborted';
-            yield { type: 'aborted' };
-            return;
-        }
-        runOutcome = 'error';
-        runError = err;
-        throw err;
-    }
-    finally {
-        await pipeline.onRunEnd({
-            agentId: agent?.id ?? null,
-            stats: {
-                totalTokens: stats.tokens,
-                durationMs: Math.round(stats.durationMs),
-                timeToFirstToken: stats.ttft
-            },
-            outcome: runOutcome,
-            error: runError
-        });
-    }
-}
-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;
+    return trackCompletion((signal) => driveCompletion({ ...args, signal }, loadRuntime, {
+        ...options,
+        redact: redactor,
+        redactShared: redactor.redactShared,
+        redactOperationResult: redactor.redactOperationResult,
+        redactRecord: redactor.redactRecord
+    }), args.signal, () => { }).iterator;
 }