@qvac/harness 0.7.0 → 1.0.0-rc.0

package/dist-lib/lib/capabilities/completion-engine/actors/inspecting.js

@@ -0,0 +1,152 @@
+import { AbortedError } from '../../../helpers/race-abort.js';
+import { hlog } from '../../../log.js';
+import { skillIsActive } from '../../tool-selection.js';
+import { WEB_SEARCH_TOOL_NAME } from '../../tool-names.js';
+import { planToolCall } from '../../tool-plan.js';
+import { approvalGate, resolvedCall, toolContext, trustedSources } from './execution-plan.js';
+import { detachJson } from '../../../helpers/detach-json.js';
+import { deniedWithoutApprover, gateRejection, policyActivity } from './rejection.js';
+export const inspecting = async function inspecting({ input: deps, context }) {
+    const { args, session } = deps;
+    const snapshot = context.currentCall;
+    if (!snapshot) {
+        throw new Error('completion graph selected inspection without a current call');
+    }
+    const resolved = resolvedCall({ session, context });
+    if (args.signal?.aborted) {
+        throw new AbortedError();
+    }
+    const activation = {
+        ...session.activation,
+        loadedSkills: new Set(context.skills.snapshot?.loaded ?? [])
+    };
+    const executeContext = toolContext({ deps, context, name: resolved.call.name });
+    const plan = planToolCall(resolved, {
+        activation,
+        skillCatalog: args.skillCatalog ?? [],
+        loadedThisTurn: session.loadedThisTurn,
+        loadedFilesThisTurn: session.loadedFilesThisTurn,
+        webSearches: context.webSearches,
+        context: executeContext,
+        listShown: session.inContextSkills.some((skill) => skillIsActive(skill.name, session.activation))
+    });
+    if (plan.searchCapReached) {
+        hlog('tool capped', {
+            tool: resolved.call.name,
+            count: context.webSearches
+        });
+    }
+    const unavailableSkill = plan.skillCall && (!plan.toolAvailable || !plan.skillActive);
+    const hasEarlierRejection = plan.skillAlreadyLoaded ||
+        Boolean(plan.skillStatus) ||
+        unavailableSkill ||
+        plan.searchCapReached ||
+        Boolean(plan.hookRejection);
+    let resource = null;
+    if (!plan.skillAlreadyLoaded && !plan.searchCapReached && plan.toolAvailable) {
+        if (plan.skillStatus || unavailableSkill || plan.hookRejection) {
+            resource = detachJson(resolved.tool?.resource?.(detachJson(resolved.args), executeContext) ?? null);
+        }
+    }
+    let execution = null;
+    if (!hasEarlierRejection && resolved.tool) {
+        const inspectedGate = approvalGate({
+            deps,
+            context,
+            call: snapshot,
+            tool: resolved.tool,
+            effect: plan.effect ?? 'write',
+            sources: trustedSources(deps, context)
+        });
+        const gate = plan.skillCall ? { ...inspectedGate, approver: false } : inspectedGate;
+        resource = gate.facts.resource;
+        execution = {
+            kind: plan.skillCall ? 'skill' : 'tool',
+            effect: plan.effect ?? 'write',
+            skillName: plan.skillCall ? plan.skillName : null,
+            webSearch: resolved.call.name === WEB_SEARCH_TOOL_NAME,
+            gate
+        };
+    }
+    const rejection = inspectRejection({ context, plan, execution, resource, call: snapshot });
+    return {
+        call: snapshot,
+        toolAvailable: plan.toolAvailable,
+        skillCall: plan.skillCall,
+        skillAlreadyLoaded: plan.skillAlreadyLoaded,
+        skillStatus: plan.skillStatus,
+        skillActive: plan.skillActive,
+        skillName: plan.skillName,
+        alreadyLoadedLabel: plan.alreadyLoadedLabel,
+        unavailableSkillMessage: plan.unavailableSkillMessage,
+        searchCapReached: plan.searchCapReached,
+        searchCapMessage: plan.searchCapMessage,
+        hookRejection: plan.hookRejection,
+        source: plan.source,
+        effect: plan.effect,
+        resource,
+        execution,
+        rejection
+    };
+};
+const SKILL_WRITE_DENIED = 'Skill loaders must be read-only; this operation was not run.';
+function inspectRejection({ context, plan, execution, resource, call }) {
+    const effect = plan.effect;
+    const source = plan.source;
+    const base = { activity: null, effect, source };
+    if (plan.skillAlreadyLoaded) {
+        const content = `${plan.alreadyLoadedLabel} is already loaded. Follow the instructions you were given and do not load it again.`;
+        return {
+            ...base,
+            result: { name: plan.skillName, content },
+            emitCall: false,
+            emitResult: false
+        };
+    }
+    if (plan.skillStatus) {
+        const error = `skill "${plan.skillName}" is ${plan.skillStatus} and cannot be used yet. Tell the user to open it in Skills and finish its setup; do not retry.`;
+        return { ...base, result: { error }, activity: policyActivity({ call, effect, resource }) };
+    }
+    if (plan.skillCall && (!plan.toolAvailable || !plan.skillActive)) {
+        return {
+            ...base,
+            result: { error: plan.unavailableSkillMessage },
+            activity: policyActivity({ call, effect, resource })
+        };
+    }
+    if (plan.searchCapReached) {
+        return {
+            ...base,
+            result: { content: plan.searchCapMessage },
+            emitCall: false,
+            emitResult: false,
+            capped: true
+        };
+    }
+    if (plan.hookRejection) {
+        return {
+            ...base,
+            result: plan.hookRejection,
+            activity: policyActivity({ call, effect, resource })
+        };
+    }
+    if (!plan.toolAvailable) {
+        return {
+            ...base,
+            result: { error: `unknown tool: ${call.name}` },
+            activity: policyActivity({ call, effect, resource: null })
+        };
+    }
+    const gated = gateRejection({ context, call, execution, resource, source });
+    if (gated) {
+        return gated;
+    }
+    if (plan.skillCall && plan.effect === 'write') {
+        return {
+            ...base,
+            result: { error: SKILL_WRITE_DENIED, guidance: true },
+            outcome: { kind: 'guidance', message: SKILL_WRITE_DENIED }
+        };
+    }
+    return deniedWithoutApprover({ context, call, execution, resource, source });
+}

package/dist-lib/lib/capabilities/completion-engine/actors/loading-skill.d.ts

@@ -0,0 +1,3 @@
+import { type SkillLoadOutput } from '../../../machine/index.ts';
+import type { CompletionActor } from '../session.ts';
+export declare const loadingSkill: CompletionActor<SkillLoadOutput>;

package/dist-lib/lib/capabilities/completion-engine/actors/loading-skill.js

@@ -0,0 +1,94 @@
+import { AbortedError } from '../../../helpers/race-abort.js';
+import { RecoveryRequired, ToolPolicyChanged, spliceFrom } from '../../../machine/index.js';
+import { labelOf, readyPreflightFromFacts, skillEmojiFrom } from '../../completion-loop/index.js';
+import { skillFileKey } from '../../tool-plan.js';
+import { toolResultTurn } from '../../tool-turns.js';
+import { trustedSourceFacts } from '../../../tools/outbound-guard.js';
+import { errorMessage, isRecord } from '../../../guards.js';
+import { executionPlan, trustedSources } from './execution-plan.js';
+import { runToolCall } from './execute.js';
+export const loadingSkill = async function loadingSkill({ emit, input: deps, context }) {
+    const { args, session } = deps;
+    const plan = executionPlan(deps, context);
+    const { call, args: callArgs } = plan.resolved;
+    const skillName = plan.skillName;
+    if (skillName === null) {
+        throw new Error('skill loading route has no selected skill name');
+    }
+    if (args.signal?.aborted) {
+        throw new AbortedError();
+    }
+    const display = labelOf(call.name, callArgs, skillEmojiFrom(session.inContextSkills, skillName));
+    emit({
+        type: 'tool-call',
+        name: call.name,
+        args: callArgs,
+        rawCall: plan.resolved.rawCall,
+        effect: plan.effect,
+        display
+    });
+    const denied = new Set(context.deniedKeys);
+    const facts = context.execution?.gate?.facts;
+    if (!facts) {
+        throw new Error('selected skill load has no inspected policy facts');
+    }
+    const executed = await runToolCall(plan, {
+        approve: undefined,
+        signal: args.signal,
+        denied,
+        sources: trustedSources(deps, context),
+        pipeline: session.pipeline,
+        runId: session.runId,
+        callId: call.id,
+        skipApprovals: args.agent?.approvalMode === 'skip-all',
+        preflight: readyPreflightFromFacts(facts),
+        display
+    });
+    const { output, outcome, activity } = executed;
+    session.runOutcomes.record(output, outcome);
+    if (activity) {
+        emit(activity);
+    }
+    emit({ type: 'tool-result', name: call.name, result: output });
+    const turn = toolResultTurn(call.name, call.id, output);
+    const history = [
+        ...context.history,
+        { role: 'tool', content: turn }
+    ];
+    session.skillIcon = skillEmojiFrom(session.inContextSkills, skillName) ?? session.skillIcon;
+    if (hasContent(output)) {
+        if (isRecord(output) && typeof output.file === 'string') {
+            const files = session.loadedSkillFiles.get(skillName) ?? new Set();
+            files.add(output.file);
+            session.loadedSkillFiles.set(skillName, files);
+        }
+        const fileKey = skillFileKey(skillName, callArgs);
+        if (fileKey === null) {
+            session.loadedThisTurn.add(skillName);
+        }
+        else {
+            session.loadedFilesThisTurn.add(fileKey);
+        }
+        return {
+            name: skillName,
+            history: spliceFrom(context.history, history),
+            source: trustedSourceFacts('skill', turn)
+        };
+    }
+    return {
+        failure: {
+            name: skillName,
+            error: errorFrom(output),
+            history: spliceFrom(context.history, history)
+        }
+    };
+};
+function hasContent(output) {
+    return isRecord(output) && 'content' in output;
+}
+function errorFrom(output) {
+    if (isRecord(output) && 'error' in output) {
+        return String(output.error);
+    }
+    return 'skill did not return content';
+}

package/dist-lib/lib/capabilities/completion-engine/actors/preload-failure.d.ts

@@ -0,0 +1,9 @@
+import { type CompletionMachineContext } from '../../../machine/index.ts';
+import type { SkillFailedPayload } from '../../../machine/index.ts';
+export interface PreloadFailureInput {
+    history: CompletionMachineContext['history'];
+    startedAt: number;
+    name: string;
+    error: string;
+}
+export declare function preloadFailure({ history, startedAt, name, error }: PreloadFailureInput): SkillFailedPayload;

package/dist-lib/lib/capabilities/completion-engine/actors/preload-failure.js

@@ -0,0 +1,11 @@
+import { spliceFrom } from '../../../machine/index.js';
+import { annotateCompletionHistoryLastUserTime, preloadLastUser } from '../../completion-loop/index.js';
+export function preloadFailure({ history, startedAt, name, error }) {
+    const message = `Skill "${name}" could not be loaded: ${error}`;
+    const guided = preloadLastUser(history, name, message);
+    return {
+        name,
+        error: message,
+        history: spliceFrom(history, annotateCompletionHistoryLastUserTime(guided, new Date(startedAt)))
+    };
+}

package/dist-lib/lib/capabilities/completion-engine/actors/preloading.d.ts

@@ -0,0 +1,3 @@
+import { type SkillLoadOutput } from '../../../machine/index.ts';
+import type { CompletionActor } from '../session.ts';
+export declare const preloading: CompletionActor<SkillLoadOutput>;

package/dist-lib/lib/capabilities/completion-engine/actors/preloading.js

@@ -0,0 +1,114 @@
+import { AbortedError } from '../../../helpers/race-abort.js';
+import { RecoveryRequired, ToolPolicyChanged, spliceFrom } from '../../../machine/index.js';
+import { executeCall, annotateCompletionHistoryLastUserTime, labelOf, preloadLastUser, readyPreflightFromFacts, skillEmojiFrom } from '../../completion-loop/index.js';
+import { withoutSkillLoadTurns } from '../../tool-turns.js';
+import { SKILL_TOOL_NAME } from '../../tool-names.js';
+import { trustedSourceFacts } from '../../../tools/outbound-guard.js';
+import { errorMessage, isRecord } from '../../../guards.js';
+import { toolContext } from './execution-plan.js';
+import { preloadFailure } from './preload-failure.js';
+import { detachJson } from '../../../helpers/detach-json.js';
+export const preloading = async function preloading({ emit, input: deps, context }) {
+    const { args, session } = deps;
+    const pending = context.skillPreload;
+    if (!pending) {
+        throw new Error('preload execution requires an authorized skill');
+    }
+    const loader = session.enabled.find((tool) => tool.name === SKILL_TOOL_NAME);
+    if (!loader) {
+        throw new Error('skill preload requires the skill tool');
+    }
+    if (!pending.args || !pending.facts) {
+        throw new Error('skill preload has no authorized facts');
+    }
+    if (args.signal?.aborted) {
+        throw new AbortedError();
+    }
+    const preloadArgs = pending.args;
+    const contextForLoader = toolContext({ deps, context, name: loader.name });
+    const currentEffect = loader.effect(detachJson(preloadArgs), contextForLoader);
+    if (currentEffect !== pending.facts.effect || currentEffect !== 'read') {
+        return failure({
+            context,
+            startedAt: session.startedAt,
+            name: pending.name,
+            error: 'Skill loading is no longer classified as a read-only operation.'
+        });
+    }
+    const display = labelOf(SKILL_TOOL_NAME, preloadArgs, skillEmojiFrom(session.inContextSkills, pending.name));
+    const callId = `preload-${pending.name}`;
+    let activity = null;
+    let result;
+    try {
+        const executed = await executeCall(loader, preloadArgs, contextForLoader, {
+            runId: session.runId,
+            signal: args.signal,
+            sources: [],
+            pipeline: session.pipeline,
+            callId,
+            effect: currentEffect,
+            preflight: readyPreflightFromFacts(pending.facts),
+            display,
+            onToolActivity: (event) => (activity = event)
+        });
+        result = executed.result;
+    }
+    catch (error) {
+        if (error instanceof RecoveryRequired || error instanceof ToolPolicyChanged) {
+            throw error;
+        }
+        if (error instanceof AbortedError || args.signal?.aborted) {
+            throw new AbortedError();
+        }
+        const message = errorMessage(error);
+        return failure({ context, startedAt: session.startedAt, name: pending.name, error: message });
+    }
+    if (args.signal?.aborted) {
+        throw new AbortedError();
+    }
+    if (!context.skills.snapshot?.loaded.includes(pending.name)) {
+        emit({
+            type: 'tool-call',
+            name: SKILL_TOOL_NAME,
+            args: preloadArgs,
+            effect: 'read',
+            display
+        });
+        if (activity) {
+            emit(activity);
+        }
+        emit({ type: 'tool-result', name: SKILL_TOOL_NAME, result });
+    }
+    if (!hasContent(result)) {
+        return failure({
+            context,
+            startedAt: session.startedAt,
+            name: pending.name,
+            error: errorFrom(result) ?? 'skill did not return content'
+        });
+    }
+    const content = String(result.content);
+    session.loadedThisTurn.add(pending.name);
+    session.skillIcon = skillEmojiFrom(session.inContextSkills, pending.name) ?? session.skillIcon;
+    const inlined = preloadLastUser(context.history, pending.name, content);
+    const turns = withoutSkillLoadTurns(inlined, pending.name);
+    const history = annotateCompletionHistoryLastUserTime(turns, new Date(session.startedAt));
+    return {
+        name: pending.name,
+        history: spliceFrom(context.history, history),
+        source: trustedSourceFacts('skill', content),
+        cacheable: false
+    };
+};
+function failure({ context, startedAt, name, error }) {
+    return { failure: preloadFailure({ history: context.history, startedAt, name, error }) };
+}
+function hasContent(value) {
+    return isRecord(value) && 'content' in value;
+}
+function errorFrom(value) {
+    if (isRecord(value) && 'error' in value) {
+        return errorMessage(value.error);
+    }
+    return null;
+}

package/dist-lib/lib/capabilities/completion-engine/actors/preparing.d.ts

@@ -0,0 +1,3 @@
+import type { PreparingOutput } from '../../../machine/index.ts';
+import type { CompletionActor } from '../session.ts';
+export declare const preparing: CompletionActor<PreparingOutput>;

package/dist-lib/lib/capabilities/completion-engine/actors/preparing.js

@@ -0,0 +1,198 @@
+import { spliceFrom } from '../../../machine/index.js';
+import { AbortedError } from '../../../helpers/race-abort.js';
+import { resolveLlmGenerationParams } from '../../../models/llm-presets.js';
+import { annotateLastUserTime, skillsPromptSection, systemPromptParts } from '../../../prompt.js';
+import { resolveImplicitSkill, resolveSkillMention } from '../../../tools/skills/mention.js';
+import { NETWORK_TOOLSETS, permittedTools } from '../../../tools/toolsets.js';
+import { explicitWebSearchQuery, lastUserContent, lastUserImages, sanitizeTurn, skillInContext, toSdkTool, selectEnabledTools } from '../../completion-loop/index.js';
+import { SKILL_TOOL_NAME } from '../../tool-names.js';
+import { collectToolGrants, isSelected, skillIsActive, skillsAreSelected } from '../../tool-selection.js';
+import { loadedSkillFilesFrom, loadedSkillsFrom } from '../../tool-turns.js';
+import { promptPrefixHash } from '../../prompt-prefix.js';
+import { promptUsageParts } from '../../usage-breakdown.js';
+import { logToolPrompt } from '../../tool-prompt-log.js';
+import { toolContext } from './execution-plan.js';
+import { detachJson } from '../../../helpers/detach-json.js';
+export const preparing = async function preparing({ input, context, reconstruct }) {
+    const { args, session } = input;
+    const { model, agent, thinkingDefault, generationParams: generationParamsOverride, responseFormat, messages: storedMessages, tools: allTools = [], skillCatalog = [], signal, fsRoots = [], fsWriteRoots = [] } = args;
+    if (signal?.aborted) {
+        throw new AbortedError();
+    }
+    const messages = storedMessages.map(sanitizeTurn);
+    if (!session.runStarted && !reconstruct) {
+        await session.pipeline.onRunStart({
+            runId: session.runId,
+            agentId: agent?.id ?? null,
+            messages
+        });
+        session.runStarted = true;
+    }
+    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 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 = new Set([
+        ...loadedSkillsFrom(messages),
+        ...(context.skills.snapshot?.loaded ?? [])
+    ]);
+    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);
+    const selection = {
+        responseFormat: Boolean(responseFormat),
+        tools,
+        toolsSelected,
+        allowlist: agent?.enabledTools ?? [],
+        activeSkills,
+        grantedNames,
+        grantedOwners,
+        hasRoots: fsRoots.length > 0,
+        hasWriteRoots: writableRoots.length > 0
+    };
+    const enabled = selectEnabledTools({ ...selection, loadedSkills });
+    const sdkTools = enabled.length ? enabled.map((tool) => toSdkTool(tool)) : undefined;
+    const reasoningEnabled = settingEnabled(agent?.reasoning);
+    const deviceReasoning = settingEnabled(thinkingDefault);
+    const resolvedGenerationParams = resolveLlmGenerationParams(model, reasoningEnabled, deviceReasoning);
+    const generationParams = generationParamsOverride
+        ? { ...resolvedGenerationParams, ...generationParamsOverride }
+        : resolvedGenerationParams;
+    const system = systemPromptParts({
+        bio: agent?.bio,
+        toolNames: enabled.map((tool) => tool.name),
+        skillsSection: skillsPromptSection(activeSkills)
+    });
+    const systemContent = system.text;
+    const promptPrefix = promptPrefixHash({ system: systemContent, tools: sdkTools });
+    const promptParts = promptUsageParts({ system, toolSchemas: sdkTools });
+    const logSelection = (prefix) => {
+        logToolPrompt({
+            promptPrefix: prefix,
+            modelId: args.modelId,
+            cacheKey: context.cacheKey ?? undefined,
+            agentId: agent?.id,
+            messageCount: messages.length,
+            responseFormat: responseFormat?.type,
+            tools: session.sdkTools,
+            definitions: session.enabled,
+            activeSkills: activeSkills.map((skill) => skill.name),
+            skillsSelected,
+            enabledSkills: agent?.enabledSkills ?? [],
+            mentionedSkill: mention?.name ?? null,
+            loadedSkills: session.activation.loadedSkills,
+            toolOps: session.grantedOps
+        });
+    };
+    session.reselectTools = (loaded) => {
+        const reselected = selectEnabledTools({ ...selection, loadedSkills: loaded });
+        const names = reselected.map((tool) => tool.name).join();
+        if (names === session.enabled.map((tool) => tool.name).join()) {
+            return null;
+        }
+        session.enabled = reselected;
+        session.sdkTools = reselected.length ? reselected.map((tool) => toSdkTool(tool)) : undefined;
+        const prefix = promptPrefixHash({ system: systemContent, tools: session.sdkTools });
+        session.promptParts = promptUsageParts({ system, toolSchemas: session.sdkTools });
+        logSelection(prefix);
+        return prefix;
+    };
+    const turns = messages;
+    const initialHistory = systemContent
+        ? [{ role: 'system', content: systemContent }, ...turns]
+        : turns;
+    const history = context.round > 0 || context.directSearchDone
+        ? [...context.history]
+        : annotateLastUserTime(initialHistory, new Date(session.startedAt));
+    const sources = context.round > 0 || context.directSearchDone ? [...context.sources] : [];
+    const preparation = {
+        history: spliceFrom(context.history, history),
+        loadedSkills: [...loadedSkills],
+        webSearches: context.webSearches,
+        deniedKeys: [...context.deniedKeys],
+        sources,
+        availableTools: enabled.map((tool) => tool.name),
+        promptPrefix
+    };
+    prepareSession(session, {
+        enabled,
+        sdkTools,
+        grantedOps,
+        activation,
+        inContextSkills,
+        loadedSkillFiles,
+        writableRoots,
+        turnImages,
+        generationParams,
+        promptParts
+    });
+    logSelection(promptPrefix);
+    const round = {
+        preparation,
+        skillCandidate: null,
+        skillLoaderAvailable: false,
+        skillLoaderEffect: null,
+        skillAlreadyLoaded: false,
+        preload: null,
+        searchQuery: null
+    };
+    if (reconstruct) {
+        return round;
+    }
+    const preload = mention ?? resolveImplicitSkill(lastUserContent(messages), activeSkills);
+    const loader = enabled.find((tool) => tool.name === SKILL_TOOL_NAME);
+    const skillAlreadyLoaded = preload ? session.loadedThisTurn.has(preload.name) : false;
+    const skillLoaderEffect = preload && loader
+        ? loader.effect(detachJson({ name: preload.name }), toolContext({
+            deps: input,
+            context,
+            name: loader.name
+        }))
+        : null;
+    const searchQuery = (skillPreloaded) => context.directSearchDone
+        ? null
+        : explicitWebSearchQuery(lastUserContent(messages), enabled, { skillPreloaded });
+    return {
+        ...round,
+        skillCandidate: preload?.name ?? null,
+        skillLoaderAvailable: Boolean(loader),
+        skillLoaderEffect,
+        skillAlreadyLoaded,
+        preload: preload
+            ? {
+                ...preparation,
+                history: spliceFrom(context.history, initialHistory),
+                name: preload.name,
+                pendingSearch: searchQuery(true)
+            }
+            : null,
+        searchQuery: searchQuery(false)
+    };
+};
+function settingEnabled(value) {
+    if (value === 'enabled') {
+        return true;
+    }
+    if (value === 'disabled') {
+        return false;
+    }
+    return undefined;
+}
+function prepareSession(session, prepared) {
+    Object.assign(session, prepared);
+}

package/dist-lib/lib/capabilities/completion-engine/actors/rejecting.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDonePayload } from '../../../machine/index.ts';
+import type { CompletionActor } from '../session.ts';
+export declare const rejecting: CompletionActor<ToolDonePayload>;

package/dist-lib/lib/capabilities/completion-engine/actors/rejecting.js

@@ -0,0 +1,71 @@
+import { readFailureResult, spliceFrom } from '../../../machine/index.js';
+import { directToolHistory, labelOf } from '../../completion-loop/index.js';
+import { toolResultHistoryEntry, toolResultTurn } from '../../tool-turns.js';
+import { trustedSourceFacts } from '../../../tools/outbound-guard.js';
+export const rejecting = async function rejecting({ emit, input: { session }, context }) {
+    const rejected = context.rejectedCall;
+    if (!rejected) {
+        throw new Error('completion graph selected rejection without a rejected call');
+    }
+    const { call } = rejected;
+    const result = rejected.resultRef
+        ? failureResult(context, rejected.resultRef, call.name)
+        : rejected.result;
+    session.runOutcomes.record(result, rejected.repeat ?? rejected.outcome ?? { kind: 'blocked', reason: 'Tool call was rejected' });
+    if (rejected.emitCall) {
+        emit({
+            type: 'tool-call',
+            name: call.name,
+            args: call.args,
+            rawCall: call.rawCall,
+            effect: rejected.effect,
+            display: labelOf(call.name, call.args, session.skillIcon)
+        });
+    }
+    if (rejected.activity) {
+        emit(rejected.activity);
+    }
+    if (rejected.emitResult) {
+        emit({ type: 'tool-result', name: call.name, result });
+    }
+    const turn = toolResultTurn(call.name, call.id, result);
+    const history = context.execution?.kind === 'direct'
+        ? directToolHistory(context.history, call.args, result, rejected.resultRef)
+        : [
+            ...context.history,
+            toolResultHistoryEntry({
+                name: call.name,
+                id: call.id,
+                output: result,
+                resultRef: rejected.resultRef
+            })
+        ];
+    const failed = rejected.outcome && rejected.outcome.kind !== 'denied' && !rejected.repeat
+        ? {
+            key: call.key,
+            resultRef: requiredFailureRef(rejected.resultRef),
+            outcome: rejected.outcome
+        }
+        : undefined;
+    return {
+        deniedKey: rejected.deniedKey,
+        failed,
+        searchCapped: rejected.capped,
+        blockedRepeat: rejected.repeat ? true : undefined,
+        history: spliceFrom(context.history, history),
+        source: trustedSourceFacts(rejected.source, turn)
+    };
+};
+function failureResult(context, ref, name) {
+    const stored = context.failureResults[ref];
+    if (!stored || stored.name !== name) {
+        throw new Error(`Rejected call references missing or mismatched failure result: ${ref}`);
+    }
+    return readFailureResult(stored.result);
+}
+function requiredFailureRef(ref) {
+    if (ref === undefined) {
+        throw new Error('Memoized rejected call has no failure result reference');
+    }
+    return ref;
+}