@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

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

@@ -1,22 +1,62 @@
+import { Agent } from '../../../agent/index.js';
 import { AbortedError } from '../../../helpers/race-abort.js';
-import { failureResultRef, storeFailureResult, spliceFrom } from '../../../machine/index.js';
-import { callSucceeded, directToolHistory, labelOf, readyPreflightFromFacts, settledFailure } from '../../completion-loop/index.js';
-import { DIRECT_CALL_ID, toolResultHistoryEntry, toolResultTurn } from '../../tool-turns.js';
-import { trustedSourceFacts } from '../../../tools/outbound-guard.js';
+import { spliceFrom } from '../splice.js';
+import { answerOf, callSucceeded, readyPreflightFromFacts, reportFailure, settledFailure } from '../tool-execution.js';
+import { directToolHistory } from '../turns.js';
+import { labelOf } from '../loop.js';
+import { DIRECT_CALL_ID, deliversFile, materializeCompletionHistory, toolResultHistoryEntry, toolResultTurn } from '../../tool-turns.js';
+import { defers, TOOL_SEARCH_TOOL_NAME } from '../../sdk-tool.js';
 import { executionPlan, trustedSources } from './execution-plan.js';
 import { runToolCall } from './execute.js';
-export const executing = async function executing({ emit, input: deps, context }) {
+import { toolCaller } from '../tool-caller.js';
+import { loadSkill } from './loading-skill.js';
+import { failureResultRef, storeFailureResult } from '../../../helpers/failure-result.js';
+export const executing = async function executing(input) {
+    const { emit, input: deps, context } = input;
+    const call = context.currentCall;
+    const execution = context.execution;
+    if (!call || !execution) {
+        throw new Error('completion graph selected execution without execution facts');
+    }
+    const plan = executionPlan(deps, context, { call, execution });
+    const { skillName } = plan;
+    if (skillName !== null) {
+        return loadSkill(input, { ...plan, skillName });
+    }
+    const direct = execution.kind === 'direct';
+    const ran = await runCall(input, { plan, execution, emit });
+    const settled = settleCall(input, { ran, direct, emit });
+    const { args: callArgs } = plan.resolved;
+    const history = direct
+        ? directToolHistory(context.history, callArgs, ran.executed.output, settled.failed?.resultRef)
+        : [...context.history, settled.entry];
+    const planned = settled.progressed && plan.resolved.tool.name === Agent.PLAN_TOOL_NAME;
+    return {
+        deniedKey: settled.deniedKey,
+        webSearch: settled.webSearch,
+        history: spliceFrom(context.history, history),
+        source: settled.source,
+        failed: settled.failed,
+        progressed: settled.progressed,
+        answer: settled.answer,
+        delivered: settled.delivered,
+        endedRun: settled.progressed && plan.resolved.tool.endsRun === true ? true : undefined,
+        durationMs: settled.durationMs,
+        plan: planned ? Agent.planSteps(callArgs) : undefined,
+        leftPlanMode: planned && context.planMode && call.leavesPlan ? true : undefined
+    };
+};
+export async function runCall({ input: deps, context }, { plan: vetted, execution, emit }) {
     const { args, session } = deps;
-    const plan = executionPlan(deps, context);
-    const { call, args: callArgs, rawCall, intent } = plan.resolved;
-    const callKey = plan.resolved.key;
+    const { call, args: callArgs, rawCall, intent } = vetted.resolved;
     const display = labelOf(call.name, callArgs, session.skillIcon);
     if (args.signal?.aborted) {
         throw new AbortedError();
     }
     const denied = new Set(context.deniedKeys);
+    const plan = withRunPorts({ input: deps, context }, { plan: vetted, denied, emit });
     const sources = trustedSources(deps, context);
-    const facts = context.execution?.gate?.facts;
+    const facts = execution.gate?.facts;
     if (!facts) {
         throw new Error('selected tool has no inspected policy facts');
     }
@@ -31,11 +71,8 @@ export const executing = async function executing({ emit, input: deps, context }
             display
         });
     }
-    let output;
-    let outcome;
-    let ran = false;
-    let activity = null;
     const landedBefore = session.landed.length;
+    const startedAt = Date.now();
     const executed = await runToolCall(plan, {
         approve: context.approval.status === 'idle'
             ? undefined
@@ -44,17 +81,46 @@ export const executing = async function executing({ emit, input: deps, context }
         denied,
         preflight,
         sources,
+        outbound: session.outbound,
         pipeline: session.pipeline,
         runId: session.runId,
+        deniedMessage: context.policy.deniedMessage,
         callId: call.id,
-        skipApprovals: args.agent?.approvalMode === 'skip-all',
+        skipApprovals: session.policy.skipApprovals,
         intent,
         display
     });
-    output = executed.output;
-    outcome = executed.outcome;
-    ran = executed.executed;
-    activity = executed.activity;
+    const durationMs = Date.now() - startedAt;
+    const output = callSucceeded(executed.output, executed.outcome)
+        ? executed.output
+        : await reportFailure(session.pipeline, {
+            runId: session.runId,
+            callId: call.id,
+            toolName: call.name,
+            agentId: context.agentId,
+            args: callArgs,
+            executed: executed.executed,
+            outcome: executed.outcome,
+            result: executed.output
+        });
+    return { plan, denied, landedBefore, executed: { ...executed, output }, durationMs };
+}
+function withRunPorts({ input: deps, context }, { plan, denied, emit }) {
+    const { tool, call } = plan.resolved;
+    if (tool.callsTools) {
+        const callTool = toolCaller({ input: deps, context }, { callId: call.id, denied, emit });
+        return { ...plan, context: { ...plan.context, callTool } };
+    }
+    if (tool.name === TOOL_SEARCH_TOOL_NAME && deps.session.enabled.some(defers)) {
+        const history = materializeCompletionHistory(context.history, context.failureResults);
+        return { ...plan, context: { ...plan.context, history } };
+    }
+    return plan;
+}
+export function settleCall({ input: { session }, context }, { ran, direct, emit }) {
+    const { plan, denied, landedBefore, executed, durationMs } = ran;
+    const { call, key: callKey } = plan.resolved;
+    const { output, outcome, activity } = executed;
     if (outcome.kind !== 'success' && session.landed.length > landedBefore) {
         session.landed.length = landedBefore;
     }
@@ -63,10 +129,8 @@ export const executing = async function executing({ emit, input: deps, context }
         emit(activity);
     }
     emit({ type: 'tool-result', name: call.name, result: output });
-    const failed = settledFailure(output, outcome);
-    const direct = context.execution?.kind === 'direct';
     const resultTurnId = direct ? DIRECT_CALL_ID : call.id;
-    const failure = failed
+    const failed = settledFailure(output, outcome)
         ? {
             key: callKey,
             resultRef: failureResultRef(callKey, context.round, call.id),
@@ -78,25 +142,21 @@ export const executing = async function executing({ emit, input: deps, context }
         }
         : undefined;
     const turn = toolResultTurn(call.name, resultTurnId, output);
-    const history = direct
-        ? directToolHistory(context.history, callArgs, output, failure?.resultRef)
-        : [
-            ...context.history,
-            toolResultHistoryEntry({
-                name: call.name,
-                id: resultTurnId,
-                output,
-                resultRef: failure?.resultRef
-            })
-        ];
-    const deniedKey = [...denied].find((key) => !context.deniedKeys.includes(key));
-    const progressed = ran && callSucceeded(output, outcome) ? true : undefined;
+    const progressed = executed.executed && callSucceeded(output, outcome);
     return {
-        deniedKey,
+        deniedKey: [...denied].find((key) => !context.deniedKeys.includes(key)),
         webSearch: plan.webSearch,
-        history: spliceFrom(context.history, history),
-        source: trustedSourceFacts('tool-result', turn),
-        failed: failure,
-        progressed
+        source: session.outbound.facts('tool-result', turn),
+        failed,
+        progressed: progressed ? true : undefined,
+        answer: progressed ? answerOf(output) : undefined,
+        delivered: outcome.kind === 'success' && deliversFile(output) ? true : undefined,
+        durationMs: executed.executed ? durationMs : undefined,
+        entry: toolResultHistoryEntry({
+            name: call.name,
+            id: resultTurnId,
+            output,
+            resultRef: failed?.resultRef
+        })
     };
-};
+}

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

@@ -1,7 +1,8 @@
-import type { ToolDefinition, ToolExecuteContext } from '../../completion.ts';
-import { type ResolvedCall } from '../../completion-loop/index.ts';
+import type { ToolDefinition, ToolEffect, ToolExecuteContext, TrustedSource, TrustedSourceFacts } from '../../../contract/index.ts';
+import type { ResolvedCall } from '../../../contract/index.ts';
 import type { CompletionDeps } from '../session.ts';
-import type { ApprovalGate, CompletionMachineContext as CompletionContext, ResolvedCallSnapshot, ToolEffect, TrustedSource, TrustedSourceFacts } from '../../../machine/index.ts';
+import type { ApprovalGate, ResolvedCallSnapshot, ToolExecutionSnapshot } from '../stages.ts';
+import type { CompletionContext } from '../../../machine/index.ts';
 export interface ToolPolicySources {
     sources: TrustedSource[];
     sourceFacts: TrustedSourceFacts[];
@@ -22,19 +23,19 @@ export interface ToolExecutionPlan {
     skillName: string | null;
     webSearch: boolean;
 }
-interface ResolvedCallInput {
-    session: CompletionDeps['session'];
-    context: CompletionContext;
-}
-export declare function resolvedCall({ session, context }: ResolvedCallInput): OpaqueResolvedCall;
+export declare function resolvedCall(session: CompletionDeps['session'], call: ResolvedCallSnapshot): OpaqueResolvedCall;
 interface ToolContextInput {
     deps: CompletionDeps;
     context: CompletionContext;
     name: string;
 }
 export declare function toolContext({ deps, context, name }: ToolContextInput): ToolExecuteContext;
-export declare function executionPlan(deps: CompletionDeps, context: CompletionContext): ToolExecutionPlan;
-export declare function trustedSources({ args }: CompletionDeps, context: Pick<CompletionContext, 'sources'>): ToolPolicySources;
+export interface PlannedCall {
+    call: ResolvedCallSnapshot;
+    execution: ToolExecutionSnapshot;
+}
+export declare function executionPlan(deps: CompletionDeps, context: CompletionContext, { call, execution }: PlannedCall): ToolExecutionPlan;
+export declare function trustedSources({ args }: CompletionDeps, context: Pick<CompletionContext, 'sources' | 'policy'>): ToolPolicySources;
 interface ApprovalGateInput {
     deps: CompletionDeps;
     context: CompletionContext;

package/dist-lib/lib/capabilities/completion-engine/actors/execution-plan.js

@@ -1,9 +1,10 @@
-import { labelOf, inspectToolPolicy, sanitizeTurn, trustedSourcesFrom } from '../../completion-loop/index.js';
-export function resolvedCall({ session, context }) {
-    const call = context.currentCall;
-    if (!call) {
-        throw new Error('completion graph selected a tool without a current call');
-    }
+import { labelOf } from '../loop.js';
+import { detachJson } from '../../../helpers/detach-json.js';
+import { inspectToolPolicy } from '../tool-execution.js';
+import { modelTurns, trustedSourcesFrom } from '../turns.js';
+import { skillNameOf } from '../../tool-plan.js';
+import { runSpill } from '../../../spill.js';
+export function resolvedCall(session, call) {
     const tool = session.enabled.find((tool) => tool.name === call.name);
     return {
         key: call.key,
@@ -19,37 +20,39 @@ export function toolContext({ deps, context, name }) {
     const { args, session, commitFacts } = deps;
     const { skillsSelected, enabledSkills, mention } = session.activation;
     return {
-        ...session.toolContext(session.turnImages, args.ctxSize, args.signal),
-        skills: (context.skills.snapshot?.loaded ?? []).filter((skill) => !skillsSelected || enabledSkills.includes(skill) || skill === mention),
+        ...session.toolContext(session.turnImages, context.metrics.ctxSize ?? args.ctxSize, args.signal),
+        skills: context.activated.filter((skill) => !skillsSelected || enabledSkills.includes(skill) || skill === mention),
+        skillsLoadedThisTurn: [...session.loadedThisTurn],
         settings: args.toolConfigs?.[name],
         toolOps: session.grantedOps,
         fsRoots: args.fsRoots ?? [],
         fsWriteRoots: session.writableRoots,
-        sandboxMode: args.agent?.sandboxMode === true,
+        sandboxMode: session.policy.sandbox,
         toolNames: session.enabled.map((tool) => tool.name),
+        knowledge: args.knowledge,
+        planMode: context.planMode,
+        spill: session.enabled.some((tool) => tool.name === 'read_files')
+            ? runSpill(session.runId)
+            : undefined,
         reportBackend: (use) => {
             session.backends.push(use);
             commitFacts?.();
         }
     };
 }
-export function executionPlan(deps, context) {
-    const execution = context.execution;
-    if (!execution) {
-        throw new Error('completion graph selected execution without execution facts');
-    }
-    const resolved = resolvedCall({ session: deps.session, context });
+export function executionPlan(deps, context, { call, execution }) {
+    const resolved = resolvedCall(deps.session, call);
     if (!resolved.tool) {
         throw new Error(`tool implementation not found: ${resolved.call.name}`);
     }
     const resolvedWithTool = { ...resolved, tool: resolved.tool };
     return {
         type: 'execute',
-        route: execution.kind === 'skill' ? 'skill' : 'tool',
+        route: execution.origin === 'skill' ? 'skill' : 'tool',
         resolved: resolvedWithTool,
         context: toolContext({ deps, context, name: resolved.call.name }),
         effect: execution.effect,
-        skillName: execution.skillName,
+        skillName: execution.origin === 'skill' ? skillNameOf(resolved.args) : null,
         webSearch: execution.webSearch
     };
 }
@@ -57,20 +60,23 @@ const requestSources = new WeakMap();
 export function trustedSources({ args }, context) {
     let sources = requestSources.get(args.messages);
     if (!sources) {
-        sources = trustedSourcesFrom(args.messages.map(sanitizeTurn));
+        sources = trustedSourcesFrom(modelTurns(args.messages, context.policy.continuationNudge));
         requestSources.set(args.messages, sources);
     }
     return { sources, sourceFacts: context.sources };
 }
 export function approvalGate({ deps, context, call, tool, effect, sources }) {
     const { args, session } = deps;
-    const facts = inspectToolPolicy(tool, call.args, toolContext({ deps, context, name: call.name }), {
+    const ctx = toolContext({ deps, context, name: call.name });
+    const facts = inspectToolPolicy(tool, call.args, ctx, {
         sources: sources.sources,
         sourceFacts: sources.sourceFacts,
+        outbound: session.outbound,
         denied: new Set(context.deniedKeys),
         effect,
         key: call.key,
-        skipApprovals: args.agent?.approvalMode === 'skip-all'
+        skipApprovals: session.policy.skipApprovals,
+        permission: call.permission
     });
     return {
         facts,
@@ -81,7 +87,8 @@ export function approvalGate({ deps, context, call, tool, effect, sources }) {
             resource: facts.resource,
             effect: facts.effect,
             intent: call.intent ?? null,
-            display: labelOf(call.name, call.args, session.skillIcon)
+            display: labelOf(call.name, call.args, session.skillIcon),
+            quote: tool.quote?.(detachJson(call.args), ctx)
         }
     };
 }

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

@@ -1,5 +1,5 @@
 import { AbortedError } from '../../../helpers/race-abort.js';
-import { rehydrateError } from '../../../machine/index.js';
+import { rehydrateError } from '../../../helpers/engine-error.js';
 export const finishing = async ({ input: deps, context, signal }) => {
     if (signal.aborted)
         throw new AbortedError();
@@ -11,7 +11,7 @@ export const finishing = async ({ input: deps, context, signal }) => {
         agentId: context.agentId,
         stats: {
             totalTokens: context.metrics.tokens,
-            durationMs: Math.round(context.metrics.durationMs),
+            durationMs: Date.now() - deps.session.wallStart,
             timeToFirstToken: context.metrics.ttft
         },
         outcome: context.outcome === 'failed' ? 'error' : 'done',

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

@@ -0,0 +1,4 @@
+import type { PrepareStepSource } from '../prepare-step.ts';
+import type { CompletionActor } from '../session.ts';
+import type { PrepareInspectionOutput } from '../stages.ts';
+export declare function inspectPrepare(source: PrepareStepSource): CompletionActor<PrepareInspectionOutput>;

package/dist-lib/lib/capabilities/completion-engine/actors/inspect-prepare.js

@@ -0,0 +1,67 @@
+import { AbortedError } from '../../../helpers/race-abort.js';
+import { copy } from '../../../helpers/copy.js';
+import { inspectToolPolicy } from '../tool-execution.js';
+import { toolContext, trustedSources } from './execution-plan.js';
+export function inspectPrepare(source) {
+    return async function inspectPrepare({ input: deps, context }) {
+        const { args, session } = deps;
+        const step = context.prepareStep;
+        if (!step) {
+            throw new Error('prepare inspection requires a requested step');
+        }
+        const tool = session.enabled.find((tool) => tool.name === step.tool);
+        if (!tool) {
+            throw new Error(`prepare step requires the ${step.tool} tool`);
+        }
+        if (args.signal?.aborted) {
+            throw new AbortedError();
+        }
+        const stepArgs = copy(step.args);
+        const executeContext = toolContext({ deps, context, name: tool.name });
+        const fold = await session.pipeline.runPreToolFold({
+            runId: session.runId,
+            callId: step.id,
+            toolName: tool.name,
+            agentId: context.agentId,
+            effect: tool.effect(copy(stepArgs), executeContext),
+            resource: copy(tool.resource?.(copy(stepArgs), executeContext) ?? null),
+            args: stepArgs,
+            skillNames: session.inContextSkills.map((skill) => skill.name),
+            parameters: tool.parameters,
+            egress: tool.egress,
+            sandboxMode: session.policy.sandbox,
+            signal: args.signal
+        });
+        if (args.signal?.aborted) {
+            throw new AbortedError();
+        }
+        if (!fold.ok) {
+            return {
+                tool: step.tool,
+                args: stepArgs,
+                facts: null,
+                hookRejection: fold.rejection,
+                failure: source.fail({ deps, context, step, error: fold.rejection.error })
+            };
+        }
+        const facts = inspectToolPolicy(tool, fold.args, executeContext, {
+            ...trustedSources(deps, context),
+            outbound: session.outbound,
+            denied: new Set(context.deniedKeys),
+            key: session.callKey(tool.name, fold.args),
+            skipApprovals: false
+        });
+        const failureReason = facts.validationError ??
+            facts.refusal ??
+            (facts.deniedKey ? context.policy.deniedMessage : null) ??
+            (facts.effect !== 'read' ? `${source.label} requires a read-only tool.` : null) ??
+            (fold.permission === 'ask' ? `${source.label} requires a call that runs unasked.` : null);
+        return {
+            tool: step.tool,
+            args: copy(fold.args),
+            facts,
+            hookRejection: null,
+            failure: failureReason ? source.fail({ deps, context, step, error: failureReason }) : null
+        };
+    };
+}

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

@@ -1,3 +1,10 @@
-import type { CompletionActor } from '../session.ts';
-import type { InspectingOutput } from '../../../machine/index.ts';
-export declare const inspecting: CompletionActor<InspectingOutput>;
+import { type ToolPolicyFacts } from '../../tool-plan.ts';
+import type { CompletionActor, CompletionDeps } from '../session.ts';
+import type { CompletionContext } from '../../../machine/index.ts';
+import type { InspectingOutput, ResolvedCallSnapshot } from '../stages.ts';
+import type { ResourceDescriptor } from '../../../contract/index.ts';
+export type ToolInspection = InspectingOutput & Omit<ToolPolicyFacts, 'call'> & {
+    resource: ResourceDescriptor | null;
+};
+export declare const inspecting: CompletionActor<ToolInspection>;
+export declare function inspectCall(deps: CompletionDeps, context: CompletionContext, snapshot: ResolvedCallSnapshot): ToolInspection;

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

@@ -1,24 +1,27 @@
 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 { Agent } from '../../../agent/index.js';
 import { planToolCall } from '../../tool-plan.js';
 import { approvalGate, resolvedCall, toolContext, trustedSources } from './execution-plan.js';
 import { detachJson } from '../../../helpers/detach-json.js';
+import { unreadySkillMessage } from '../../skill-entry.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 });
+    return inspectCall(deps, context, snapshot);
+};
+export function inspectCall(deps, context, snapshot) {
+    const { args, session } = deps;
+    const resolved = resolvedCall(session, snapshot);
     if (args.signal?.aborted) {
         throw new AbortedError();
     }
     const activation = {
         ...session.activation,
-        loadedSkills: new Set(context.skills.snapshot?.loaded ?? [])
+        loadedSkills: new Set(context.activated)
     };
     const executeContext = toolContext({ deps, context, name: resolved.call.name });
     const plan = planToolCall(resolved, {
@@ -28,7 +31,7 @@ export const inspecting = async function inspecting({ input: deps, context }) {
         loadedFilesThisTurn: session.loadedFilesThisTurn,
         webSearches: context.webSearches,
         context: executeContext,
-        listShown: session.inContextSkills.some((skill) => skillIsActive(skill.name, session.activation))
+        listShown: session.inContextSkills.some((skill) => Agent.skillIsActive(skill.name, session.activation))
     });
     if (plan.searchCapReached) {
         hlog('tool capped', {
@@ -61,10 +64,10 @@ export const inspecting = async function inspecting({ input: deps, context }) {
         const gate = plan.skillCall ? { ...inspectedGate, approver: false } : inspectedGate;
         resource = gate.facts.resource;
         execution = {
-            kind: plan.skillCall ? 'skill' : 'tool',
+            kind: 'tool',
             effect: plan.effect ?? 'write',
-            skillName: plan.skillCall ? plan.skillName : null,
-            webSearch: resolved.call.name === WEB_SEARCH_TOOL_NAME,
+            origin: plan.source,
+            webSearch: resolved.call.name === Agent.WEB_SEARCH_TOOL_NAME,
             gate
         };
     }
@@ -88,7 +91,7 @@ export const inspecting = async function inspecting({ input: deps, context }) {
         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;
@@ -104,7 +107,7 @@ function inspectRejection({ context, plan, execution, resource, call }) {
         };
     }
     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.`;
+        const error = unreadySkillMessage(plan.skillName, plan.skillStatus);
         return { ...base, result: { error }, activity: policyActivity({ call, effect, resource }) };
     }
     if (plan.skillCall && (!plan.toolAvailable || !plan.skillActive)) {

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

@@ -1,3 +1,7 @@
-import { type SkillLoadOutput } from '../../../machine/index.ts';
-import type { CompletionActor } from '../session.ts';
-export declare const loadingSkill: CompletionActor<SkillLoadOutput>;
+import type { CompletionActorInput } from '../session.ts';
+import { type ToolExecutionPlan } from './execution-plan.ts';
+import type { ToolDonePayload } from '../stages.ts';
+export interface SkillCallPlan extends ToolExecutionPlan {
+    skillName: string;
+}
+export declare function loadSkill({ emit, input: deps, context }: CompletionActorInput, plan: SkillCallPlan): Promise<ToolDonePayload>;

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

@@ -1,20 +1,16 @@
 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 { spliceFrom } from '../splice.js';
+import { labelOf, skillEmojiFrom } from '../loop.js';
+import { readyPreflightFromFacts, reportFailure } from '../tool-execution.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 { isRecord } from '../../../guards.js';
+import { trustedSources } from './execution-plan.js';
 import { runToolCall } from './execute.js';
-export const loadingSkill = async function loadingSkill({ emit, input: deps, context }) {
+export async function loadSkill({ emit, input: deps, context }, plan) {
     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();
     }
@@ -37,14 +33,28 @@ export const loadingSkill = async function loadingSkill({ emit, input: deps, con
         signal: args.signal,
         denied,
         sources: trustedSources(deps, context),
+        outbound: session.outbound,
         pipeline: session.pipeline,
         runId: session.runId,
+        deniedMessage: context.policy.deniedMessage,
         callId: call.id,
-        skipApprovals: args.agent?.approvalMode === 'skip-all',
+        skipApprovals: session.policy.skipApprovals,
         preflight: readyPreflightFromFacts(facts),
         display
     });
-    const { output, outcome, activity } = executed;
+    const { outcome, activity } = executed;
+    const output = outcome.kind === 'success'
+        ? executed.output
+        : await reportFailure(session.pipeline, {
+            runId: session.runId,
+            callId: call.id,
+            toolName: call.name,
+            agentId: context.agentId,
+            args: callArgs,
+            executed: executed.executed,
+            outcome,
+            result: executed.output
+        });
     session.runOutcomes.record(output, outcome);
     if (activity) {
         emit(activity);
@@ -57,38 +67,27 @@ export const loadingSkill = async function loadingSkill({ emit, input: deps, con
     ];
     session.skillIcon = skillEmojiFrom(session.inContextSkills, skillName) ?? session.skillIcon;
     if (hasContent(output)) {
-        if (isRecord(output) && typeof output.file === 'string') {
+        const loadedFile = isRecord(output) && typeof output.file === 'string' ? output.file : null;
+        if (loadedFile !== null) {
             const files = session.loadedSkillFiles.get(skillName) ?? new Set();
-            files.add(output.file);
+            files.add(loadedFile);
             session.loadedSkillFiles.set(skillName, files);
         }
         const fileKey = skillFileKey(skillName, callArgs);
-        if (fileKey === null) {
+        if (fileKey === null || (executed.executed && loadedFile === null)) {
             session.loadedThisTurn.add(skillName);
         }
         else {
             session.loadedFilesThisTurn.add(fileKey);
         }
         return {
-            name: skillName,
             history: spliceFrom(context.history, history),
-            source: trustedSourceFacts('skill', turn)
+            source: session.outbound.facts('skill', turn),
+            activate: skillName
         };
     }
-    return {
-        failure: {
-            name: skillName,
-            error: errorFrom(output),
-            history: spliceFrom(context.history, history)
-        }
-    };
-};
+    return { 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/preparing.d.ts

@@ -1,3 +1,4 @@
-import type { PreparingOutput } from '../../../machine/index.ts';
+import type { PrepareStepSource } from '../prepare-step.ts';
 import type { CompletionActor } from '../session.ts';
-export declare const preparing: CompletionActor<PreparingOutput>;
+import type { PreparingOutput } from '../stages.ts';
+export declare function preparing(source: PrepareStepSource): CompletionActor<PreparingOutput>;