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

package/dist-lib/lib/machine/completion/actions/tools.js

@@ -1,4 +1,5 @@
-import { applyHistorySplice, applySplice, failureResultRef, retainFailureResults, storeFailureResult, TOOL_DENIED_MESSAGE, toolDeniedResult } from '../rules.js';
+import { activate, applyHistorySplice, applySplice, recordTool, retainFailureResults } from '../rules.js';
+import { failureResultRef, storeFailureResult, toolDeniedResult } from '../../../helpers/failure-result.js';
 import { applyPreparation } from './completion.js';
 export function resolveTools({ context, params }) {
     return {
@@ -40,7 +41,7 @@ export function rejectTool({ context, params }) {
 export function rejectDeniedApproval({ context, params }) {
     const { call, execution } = params;
     const facts = execution.gate.facts;
-    const result = toolDeniedResult();
+    const result = toolDeniedResult(context.policy.deniedMessage);
     return {
         pendingCall: null,
         approval: { status: 'denied', key: context.approval.key },
@@ -56,12 +57,12 @@ export function rejectDeniedApproval({ context, params }) {
                 decision: 'denied'
             },
             effect: facts.effect,
-            outcome: { kind: 'denied', reason: TOOL_DENIED_MESSAGE },
+            outcome: { kind: 'denied', reason: result.error },
             deniedKey: facts.key,
             emitCall: false,
             emitResult: true,
             capped: false,
-            source: execution.kind === 'skill' ? 'skill' : 'tool-result'
+            source: execution.origin
         }
     };
 }
@@ -114,12 +115,39 @@ export function startTool({ params }) {
     return { execution: params, pendingCall: null };
 }
 export function finishTool({ context, params }) {
-    return { ...applyToolResult(context, params), toolQueue: context.toolQueue.slice(1) };
+    return {
+        ...applyToolResult(context, params, context.currentCall),
+        ...roundResult(context, params),
+        toolQueue: context.toolQueue.slice(1)
+    };
+}
+export function finishBatch({ context, params }) {
+    let settled = {
+        ...context,
+        history: applySplice(context.history, params.history)
+    };
+    params.results.forEach((result, at) => {
+        settled = {
+            ...settled,
+            ...applyToolResult(settled, result, context.toolQueue[at]),
+            ...roundResult(settled, result)
+        };
+    });
+    return { ...settled, toolQueue: context.toolQueue.slice(params.results.length) };
+}
+export function endRunOnTool(args) {
+    return { ...finishTool(args), outcome: 'tool-ended' };
 }
 export function finishDirectTool({ context, params }) {
-    return { ...applyToolResult(context, params), directSearchDone: true };
+    return { ...applyToolResult(context, params, context.currentCall), directSearchDone: true };
+}
+function roundResult(context, payload) {
+    return {
+        answer: context.answer ?? payload.answer ?? null,
+        deliveredThisRound: context.deliveredThisRound || payload.delivered === true
+    };
 }
-function applyToolResult(context, payload) {
+function applyToolResult(context, payload, call) {
     const failedCalls = payload.failed
         ? {
             ...context.failedCalls,
@@ -148,6 +176,10 @@ function applyToolResult(context, payload) {
         roundProgressed: context.roundProgressed || payload.progressed === true,
         webSearches: context.webSearches + (payload.webSearch ? 1 : 0),
         cappedCalls: context.cappedCalls + (payload.searchCapped ? 1 : 0),
+        metrics: recordTool(context, call, payload.durationMs),
+        activated: activate(context.activated, payload.activate ? [payload.activate] : []),
+        plan: payload.plan ?? context.plan,
+        planMode: context.planMode && payload.leftPlanMode !== true,
         pendingCall: null,
         approval: { status: 'idle', key: null },
         currentCall: null,
@@ -171,3 +203,43 @@ export function rejectRepeatedTool({ params }) {
         }
     };
 }
+export function rejectCutOffTool({ context, params }) {
+    return {
+        currentCall: params,
+        rejectedCall: {
+            call: params,
+            result: { error: context.policy.cutOffMessage, guidance: true },
+            activity: null,
+            emitCall: true,
+            emitResult: true,
+            capped: false,
+            source: 'tool-result'
+        }
+    };
+}
+export const PLAN_MODE_REFUSAL = 'Plan mode: this write was not run. Call update_plan with your steps and submit true to ask ' +
+    'the user to approve the plan; writes run once they do.';
+export function rejectPlanModeWrite({ params }) {
+    const { call, execution } = params;
+    return {
+        currentCall: call,
+        execution,
+        rejectedCall: {
+            call,
+            result: { error: PLAN_MODE_REFUSAL, guidance: true },
+            activity: {
+                type: 'tool-activity',
+                name: call.name,
+                args: call.args,
+                resource: execution.gate.facts.resource,
+                effect: 'write',
+                decision: 'blocked'
+            },
+            effect: 'write',
+            emitCall: true,
+            emitResult: true,
+            capped: false,
+            source: execution.origin
+        }
+    };
+}

package/dist-lib/lib/machine/completion/context.d.ts

@@ -1,9 +1,14 @@
-import type { CompletionContext, CompletionHistoryEntry } from './types.ts';
+import type { CompletionHistoryEntry, PlanStep, RunGoal } from '../../contract/run.ts';
+import type { CompletionContext, RunPolicy } from './types.ts';
 export interface EmptyCompletionContextOptions {
+    policy: RunPolicy;
     runId?: string;
     history?: CompletionHistoryEntry[];
     agentId?: string | null;
     ctxSize?: number;
     cacheKey?: string | null;
+    planMode?: boolean;
+    plan?: PlanStep[];
+    goal?: RunGoal;
 }
-export declare function emptyCompletionContext(opts?: EmptyCompletionContextOptions): CompletionContext;
+export declare function emptyCompletionContext(opts: EmptyCompletionContextOptions): CompletionContext;

package/dist-lib/lib/machine/completion/context.js

@@ -1,6 +1,7 @@
-export function emptyCompletionContext(opts = {}) {
+export function emptyCompletionContext(opts) {
     return {
         runId: opts.runId ?? '',
+        policy: opts.policy,
         timeUp: false,
         pauseCount: 0,
         durable: null,
@@ -15,6 +16,7 @@ export function emptyCompletionContext(opts = {}) {
         roundsSent: 0,
         mute: 0,
         narrated: false,
+        malformed: false,
         webSearches: 0,
         directSearchDone: false,
         pendingSearch: null,
@@ -23,13 +25,23 @@ export function emptyCompletionContext(opts = {}) {
         failedCalls: {},
         blockedRepeats: 0,
         roundProgressed: false,
-        skills: { snapshot: null, loads: {}, pending: [] },
+        answer: null,
+        delivered: false,
+        deliveredThisRound: false,
+        activated: [],
         outcome: null,
-        metrics: { tokens: 0, timedTokens: 0, durationMs: 0, ctxSize: opts.ctxSize },
+        metrics: {
+            tokens: 0,
+            timedTokens: 0,
+            decodeMs: 0,
+            ctxSize: opts.ctxSize,
+            rounds: [],
+            tools: []
+        },
         agentId: opts.agentId ?? null,
         cacheKey: opts.cacheKey ?? null,
         lastRound: null,
-        skillPreload: null,
+        prepareStep: null,
         pendingCall: null,
         approval: { status: 'idle', key: null },
         currentCall: null,
@@ -39,6 +51,18 @@ export function emptyCompletionContext(opts = {}) {
         cappedCalls: 0,
         resolvedCount: 0,
         failure: null,
-        failMessage: null
+        failMessage: null,
+        steering: [],
+        followUps: [],
+        plan: opts.plan ?? [],
+        planMode: opts.planMode ?? false,
+        goal: opts.goal
+            ? {
+                objective: opts.goal.objective,
+                tokens: opts.goal.tokens ?? null,
+                turns: 0,
+                status: 'open'
+            }
+            : null
     };
 }

package/dist-lib/lib/machine/completion/guards/retry.d.ts

@@ -4,6 +4,7 @@ export declare function canRetrySearchCap(ctx: CompletionContext): boolean;
 export declare function repeatsBlocked(ctx: CompletionContext): boolean;
 export declare function hasRoundsLeft(ctx: CompletionContext): boolean;
 export declare function canRetryNarrated(ctx: CompletionContext): boolean;
+export declare function canRetryMalformed(ctx: CompletionContext): boolean;
 export declare function hasQueuedTool(ctx: CompletionContext): boolean;
 export declare function allResolvedToolsCapped(ctx: CompletionContext): boolean;
 export declare function searchPending(ctx: CompletionContext): boolean;

package/dist-lib/lib/machine/completion/guards/retry.js

@@ -1,6 +1,6 @@
-import { MAX_BLOCKED_REPEATS, MAX_CAPPED_ROUNDS, MAX_MUTE_ROUNDS, MAX_TOOL_ROUNDS } from '../rules.js';
+import { MAX_BLOCKED_REPEATS, MAX_CAPPED_ROUNDS, MAX_MUTE_ROUNDS } from '../rules.js';
 export function canMuteRetry(ctx) {
-    return ctx.mute < MAX_MUTE_ROUNDS;
+    return ctx.mute < MAX_MUTE_ROUNDS && hasRoundsLeft(ctx);
 }
 export function canRetrySearchCap(ctx) {
     return ctx.cappedRounds < MAX_CAPPED_ROUNDS;
@@ -9,11 +9,14 @@ export function repeatsBlocked(ctx) {
     return !ctx.roundProgressed && ctx.blockedRepeats >= MAX_BLOCKED_REPEATS;
 }
 export function hasRoundsLeft(ctx) {
-    return ctx.round + 1 < MAX_TOOL_ROUNDS;
+    return ctx.round + 1 < ctx.policy.maxToolRounds;
 }
 export function canRetryNarrated(ctx) {
     return !ctx.narrated && hasRoundsLeft(ctx);
 }
+export function canRetryMalformed(ctx) {
+    return !ctx.malformed && hasRoundsLeft(ctx);
+}
 export function hasQueuedTool(ctx) {
     return ctx.toolQueue.length > 0;
 }

package/dist-lib/lib/machine/completion/implementations.d.ts

@@ -1,11 +1,11 @@
-import type { CompletionContext, CompletionMachineEvent, SkillLoadOutput, ToolExecutionSnapshot } from './types.ts';
+import type { CompletionContext, CompletionMachineEvent, EngineEvent, ToolExecutionSnapshot } from './types.ts';
 interface Args {
     context: CompletionContext;
     event: CompletionMachineEvent;
 }
 export declare const completionGuards: {
-    preloadNeeded: ({ event }: Args) => boolean;
-    preloadFailed: ({ event }: Args) => boolean;
+    prepareNeeded: ({ event }: Args) => boolean;
+    prepareFailed: ({ event }: Args) => boolean;
     directSearchNeeded: ({ event }: Args) => boolean;
     directRejected: ({ event }: Args) => boolean;
     directNeedsApproval: ({ context, event }: Args) => boolean;
@@ -13,55 +13,75 @@ export declare const completionGuards: {
     noDirectTool: ({ event }: Args) => boolean;
     searchPending: ({ context }: Args) => boolean;
     roundHasToolCalls: ({ event }: Args) => boolean;
+    malformedToolCall: ({ context, event }: Args) => boolean;
     narratedIntent: ({ context, event }: Args) => boolean;
     hasAnswer: ({ event }: Args) => boolean;
     canMuteRetry: ({ context }: Args) => boolean;
     hasRoundsLeft: ({ context }: Args) => boolean;
     hasQueuedTool: ({ context }: Args) => boolean;
     repeatOfFailed: ({ context }: Args) => boolean;
+    roundCutOff: ({ context }: Args) => boolean;
+    readBatchQueued: ({ context }: Args) => boolean;
+    batchRan: ({ event }: Args) => boolean;
+    toolAnswered: ({ context }: Args) => boolean;
+    deliveredBefore: ({ context }: Args) => boolean;
     repeatsBlocked: ({ context }: Args) => boolean;
     allResolvedToolsCapped: ({ context }: Args) => boolean;
     canRetrySearchCap: ({ context }: Args) => boolean;
     toolRejected: ({ event }: Args) => boolean;
-    skillLoadAllowed: ({ event }: Args) => boolean;
+    planModeWrite: ({ context, event }: Args) => boolean;
     approved: ({ event }: Args) => boolean;
     needsApproval: ({ context }: Args, execution: ToolExecutionSnapshot | null | undefined) => boolean;
     toolAutoRuns: ({ event }: Args) => boolean;
     directExecution: ({ context }: Args) => boolean;
+    toolEndedRun: ({ event }: Args) => boolean;
     timeUp: ({ context }: Args) => boolean;
     failedOutcome: ({ context }: Args) => boolean;
+    hasInput: ({ context }: Args) => boolean;
+    stopContinues: ({ event }: Args) => boolean;
+    goalUnmet: ({ context }: Args) => boolean;
+    goalTokensLeft: ({ context }: Args) => boolean;
     needsRecovery: ({ event }: Args) => boolean;
     interrupted: ({ event }: Args) => boolean;
 };
 export declare const completionActions: {
-    requestPreload: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").SkillPreloadPayload, never, never, never, never, never>;
-    authorizePreload: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PreloadInspectionOutput, never, never, never, never, never>;
-    settlePreloadFailure: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PreloadInspectionOutput | SkillLoadOutput, never, never, never, never, never>;
+    requestPrepare: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./actions/prepare.ts").RequestPrepareParams, never, never, never, never, never>;
+    authorizePrepare: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PrepareInspectionOutput, never, never, never, never, never>;
+    settlePrepareFailure: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PrepareInspectionOutput | import("./types.ts").PrepareRunOutput, never, never, never, never, never>;
+    settlePrepare: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PrepareResult, never, never, never, never, never>;
     startDirectTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").DirectToolOutput, never, never, never, never, never>;
     queueDirectSearch: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PreparingOutput, never, never, never, never, never>;
     rejectDeniedApproval: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RejectDeniedApprovalParams, never, never, never, never, never>;
     startInitialRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").PreparingPayload, never, never, never, never, never>;
-    settleSkill: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, SkillLoadOutput, never, never, never, never, never>;
     finishRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RoundDonePayload, never, never, never, never, never>;
     finishWrapRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RoundDonePayload, never, never, never, never, never>;
-    wrapCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RunOutcome, never, never, never, never, never>;
+    wrapCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("../../contract/run.ts").RunOutcome, never, never, never, never, never>;
     resolveTools: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ToolsResolvedPayload, never, never, never, never, never>;
     answerCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").AnsweredPayload, never, never, never, never, never>;
+    continueWithInput: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    addKnowledge: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RetrievingOutput, never, never, never, never, never>;
+    continueStop: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").AnsweredPayload, never, never, never, never, never>;
+    continueGoal: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, EngineEvent>;
+    settleGoal: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, EngineEvent>;
+    retryMalformedRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").AnsweredPayload, never, never, never, never, never>;
     retryMuteRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     retryNarratedRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").AnsweredPayload, never, never, never, never, never>;
     wrapMuteCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     selectNextTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ResolvedCallSnapshot, never, never, never, never, never>;
     rejectRepeatedTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").RepeatOfFailedCallParams, never, never, never, never, never>;
+    rejectCutOffTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ResolvedCallSnapshot, never, never, never, never, never>;
     retryCappedSearch: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     wrapSearchCappedCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     startNextRound: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    wrapDeliveredCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     wrapExhaustedCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
-    startSkillTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").SkillToolExecutionSnapshot, never, never, never, never, never>;
     startTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").GatedToolExecutionSnapshot, never, never, never, never, never>;
     rejectTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./actions/tools.ts").RejectToolParams, never, never, never, never, never>;
+    rejectPlanModeWrite: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./actions/tools.ts").RejectPlanModeWriteParams, never, never, never, never, never>;
     finishDirectTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ToolDonePayload, never, never, never, never, never>;
     finishTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ToolDonePayload, never, never, never, never, never>;
-    settleToolSkill: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, SkillLoadOutput, never, never, never, never, never>;
+    finishBatch: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").BatchDonePayload, never, never, never, never, never>;
+    endRunOnTool: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ToolDonePayload, never, never, never, never, never>;
     approveCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     requestApproval: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./types.ts").ApprovalCall, never, never, never, never, never>;
     failCompletion: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, import("./actions/completion.ts").CompletionFailureMessage | {
@@ -70,12 +90,18 @@ export declare const completionActions: {
         name: string;
         code?: string;
         stack?: string;
-        cause?: import("../errors.ts").ErrorCause;
+        cause?: import("../../helpers/engine-error.ts").ErrorCause;
     }, never, never, never, never, never>;
     markTimeUp: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     recordPause: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     recordRecovery: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     resumeRun: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
+    ackSteering: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, RoundParams, never, never, never, never, EngineEvent>;
+    ackInput: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, EngineEvent>;
+    queueInput: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
     recordFacts: import("xstate").ActionFunction<CompletionContext, CompletionMachineEvent, CompletionMachineEvent, undefined, never, never, never, never, never>;
 };
+export interface RoundParams {
+    round: number;
+}
 export {};

package/dist-lib/lib/machine/completion/implementations.js

@@ -1,9 +1,10 @@
-import { assign } from 'xstate';
+import { assign, enqueueActions } from 'xstate';
 import { approveCompletion, requestApproval } from './actions/approval.js';
-import { answerCompletion, failCompletion, finishWrapRound, finishRound, retryCappedSearch, retryMuteRound, retryNarratedRound, startInitialRound, startNextRound, wrapCompletion, wrapExhaustedCompletion, wrapMuteCompletion, wrapSearchCappedCompletion } from './actions/completion.js';
-import { failSkill, failToolSkill, finishSkill, finishToolSkill, requestPreload, authorizePreload, settlePreloadFailure, startSkillTool } from './actions/skills.js';
-import { finishDirectTool, finishTool, queueDirectSearch, rejectDeniedApproval, rejectRepeatedTool, rejectTool, resolveTools, selectNextTool, startDirectTool, startTool } from './actions/tools.js';
-import { allResolvedToolsCapped, canMuteRetry, canRetryNarrated, canRetrySearchCap, hasQueuedTool, hasRoundsLeft, repeatsBlocked, searchPending } from './guards/retry.js';
+import { addKnowledge, answerCompletion, continueGoal, continueStop, continueWithInput, failCompletion, finishWrapRound, finishRound, goalTurn, retryCappedSearch, retryMalformedRound, retryMuteRound, retryNarratedRound, settleGoal, startInitialRound, startNextRound, wrapCompletion, wrapDeliveredCompletion, wrapExhaustedCompletion, wrapMuteCompletion, wrapSearchCappedCompletion } from './actions/completion.js';
+import { authorizePrepare, requestPrepare, settlePrepare, settlePrepareFailure } from './actions/prepare.js';
+import { finishBatch, finishDirectTool, finishTool, endRunOnTool, queueDirectSearch, rejectCutOffTool, rejectDeniedApproval, rejectPlanModeWrite, rejectRepeatedTool, rejectTool, resolveTools, selectNextTool, startDirectTool, startTool } from './actions/tools.js';
+import { allResolvedToolsCapped, canMuteRetry, canRetryMalformed, canRetryNarrated, canRetrySearchCap, hasQueuedTool, hasRoundsLeft, repeatsBlocked, searchPending } from './guards/retry.js';
+import { goalTokensLeft, leadingReads, planDone, runsUnasked } from './rules.js';
 function output(event) {
     return ('output' in event ? event.output : {});
 }
@@ -19,7 +20,7 @@ function preflightReady(execution) {
 }
 function autoRuns(execution) {
     const facts = preflightFacts(execution);
-    return Boolean(facts && (facts.effect === 'read' || facts.autoApprove || facts.skipApprovals));
+    return Boolean(facts && runsUnasked(facts));
 }
 function needsApproval(context, execution) {
     return Boolean(preflightReady(execution) &&
@@ -28,14 +29,11 @@ function needsApproval(context, execution) {
         execution?.gate?.approver);
 }
 export const completionGuards = {
-    preloadNeeded: ({ event }) => {
-        const facts = output(event);
-        return (facts.skillCandidate !== null &&
-            facts.skillLoaderAvailable === true &&
-            facts.skillLoaderEffect === 'read' &&
-            facts.skillAlreadyLoaded === false);
+    prepareNeeded: ({ event }) => {
+        const step = output(event).step;
+        return Boolean(step && step.available && step.effect === 'read' && !step.done);
     },
-    preloadFailed: ({ event }) => Boolean(output(event).failure),
+    prepareFailed: ({ event }) => Boolean(output(event).failure),
     directSearchNeeded: ({ event }) => Boolean(output(event).searchQuery),
     directRejected: ({ event }) => Boolean(output(event).directTool?.rejection),
     directNeedsApproval: ({ context, event }) => needsApproval(context, output(event).directTool?.execution),
@@ -44,6 +42,7 @@ export const completionGuards = {
     noDirectTool: ({ event }) => !output(event).directTool,
     searchPending: ({ context }) => searchPending(context),
     roundHasToolCalls: ({ event }) => (output(event).calls?.length ?? 0) > 0,
+    malformedToolCall: ({ context, event }) => canRetryMalformed(context) && Boolean(output(event).malformed),
     narratedIntent: ({ context, event }) => canRetryNarrated(context) && Boolean(output(event).narrated),
     hasAnswer: ({ event }) => Boolean(output(event).response?.trim()),
     canMuteRetry: ({ context }) => canMuteRetry(context),
@@ -53,62 +52,72 @@ export const completionGuards = {
         const next = context.toolQueue[0];
         return Boolean(next && context.failedCalls[next.key]);
     },
+    roundCutOff: ({ context }) => context.lastRound?.stopReason === 'length',
+    readBatchQueued: ({ context }) => leadingReads(context) >= 2,
+    batchRan: ({ event }) => (output(event).results?.length ?? 0) > 0,
+    toolAnswered: ({ context }) => context.answer !== null,
+    deliveredBefore: ({ context }) => context.delivered,
     repeatsBlocked: ({ context }) => repeatsBlocked(context),
     allResolvedToolsCapped: ({ context }) => allResolvedToolsCapped(context),
     canRetrySearchCap: ({ context }) => canRetrySearchCap(context),
     toolRejected: ({ event }) => Boolean(output(event).rejection),
-    skillLoadAllowed: ({ event }) => {
-        const facts = output(event);
-        return Boolean(facts.skillCall &&
-            facts.toolAvailable &&
-            facts.skillActive &&
-            facts.effect === 'read' &&
-            preflightReady(facts.execution) &&
-            autoRuns(facts.execution));
+    planModeWrite: ({ context, event }) => {
+        const { call, execution } = output(event);
+        return context.planMode && preflightFacts(execution)?.effect === 'write' && !call?.leavesPlan;
     },
     approved: ({ event }) => output(event).approved === true,
     needsApproval: ({ context }, execution) => needsApproval(context, execution),
     toolAutoRuns: ({ event }) => preflightReady(output(event).execution) &&
         autoRuns(output(event).execution),
     directExecution: ({ context }) => context.execution?.kind === 'direct',
+    toolEndedRun: ({ event }) => output(event).endedRun === true,
     timeUp: ({ context }) => context.timeUp,
     failedOutcome: ({ context }) => context.outcome === 'failed',
+    hasInput: ({ context }) => context.steering.length + context.followUps.length > 0,
+    stopContinues: ({ event }) => Boolean(output(event).continue),
+    goalUnmet: ({ context }) => context.goal !== null && !planDone(context.plan),
+    goalTokensLeft: ({ context }) => goalTokensLeft(context),
     needsRecovery: ({ event }) => errorOf(event)?.tag === 'recovery',
     interrupted: ({ event }) => errorOf(event)?.tag === 'aborted'
 };
 export const completionActions = {
-    requestPreload: assignAction(requestPreload),
-    authorizePreload: assignAction(authorizePreload),
-    settlePreloadFailure: assignAction(settlePreloadFailure),
+    requestPrepare: assignAction(requestPrepare),
+    authorizePrepare: assignAction(authorizePrepare),
+    settlePrepareFailure: assignAction(settlePrepareFailure),
+    settlePrepare: assignAction(settlePrepare),
     startDirectTool: assignAction(startDirectTool),
     queueDirectSearch: assignAction(queueDirectSearch),
     rejectDeniedApproval: assignAction(rejectDeniedApproval),
     startInitialRound: assignAction(startInitialRound),
-    settleSkill: assignAction((args) => 'failure' in args.params
-        ? failSkill({ ...args, params: args.params.failure })
-        : finishSkill({ ...args, params: args.params })),
     finishRound: assignAction(finishRound),
     finishWrapRound: assignAction(finishWrapRound),
     wrapCompletion: assignAction(wrapCompletion),
     resolveTools: assignAction(resolveTools),
     answerCompletion: assignAction(answerCompletion),
+    continueWithInput: assignAction(continueWithInput),
+    addKnowledge: assignAction(addKnowledge),
+    continueStop: assignAction(continueStop),
+    continueGoal: goalAction(continueGoal),
+    settleGoal: goalAction(settleGoal),
+    retryMalformedRound: assignAction(retryMalformedRound),
     retryMuteRound: assignAction(retryMuteRound),
     retryNarratedRound: assignAction(retryNarratedRound),
     wrapMuteCompletion: assignAction(wrapMuteCompletion),
     selectNextTool: assignAction(selectNextTool),
     rejectRepeatedTool: assignAction(rejectRepeatedTool),
+    rejectCutOffTool: assignAction(rejectCutOffTool),
     retryCappedSearch: assignAction(retryCappedSearch),
     wrapSearchCappedCompletion: assignAction(wrapSearchCappedCompletion),
     startNextRound: assignAction(startNextRound),
+    wrapDeliveredCompletion: assignAction(wrapDeliveredCompletion),
     wrapExhaustedCompletion: assignAction(wrapExhaustedCompletion),
-    startSkillTool: assignAction(startSkillTool),
     startTool: assignAction(startTool),
     rejectTool: assignAction(rejectTool),
+    rejectPlanModeWrite: assignAction(rejectPlanModeWrite),
     finishDirectTool: assignAction(finishDirectTool),
     finishTool: assignAction(finishTool),
-    settleToolSkill: assignAction((args) => 'failure' in args.params
-        ? failToolSkill({ ...args, params: args.params.failure })
-        : finishToolSkill({ ...args, params: args.params })),
+    finishBatch: assignAction(finishBatch),
+    endRunOnTool: assignAction(endRunOnTool),
     approveCompletion: assignAction(approveCompletion),
     requestApproval: assignAction(requestApproval),
     failCompletion: assignAction(failCompletion),
@@ -145,8 +154,49 @@ export const completionActions = {
                 : durable
         };
     }),
+    ackSteering: ackAction(({ context }, params) => context.steering.map((queued) => inputEvent(context.runId, queued, params.round))),
+    ackInput: ackAction(({ context }) => [...context.steering, ...context.followUps].map((queued) => inputEvent(context.runId, queued, context.round + 1))),
+    queueInput: assign(({ context, event }) => {
+        if (event.type !== 'INPUT')
+            return {};
+        const queued = event.id === undefined ? { text: event.text } : { id: event.id, text: event.text };
+        return event.mode === 'steer'
+            ? { steering: [...context.steering, queued] }
+            : { followUps: [...context.followUps, queued] };
+    }),
     recordFacts: assign(({ event }) => (event.type === 'FACTS' ? { durable: event.value } : {}))
 };
 function assignAction(action) {
     return assign(({ context }, params) => action({ context, params }));
 }
+function ackAction(events) {
+    return enqueueActions(({ context, enqueue }, params) => {
+        for (const event of events({ context }, params)) {
+            enqueue.emit(event);
+        }
+    });
+}
+function goalAction(action) {
+    return enqueueActions(({ context, enqueue }) => {
+        const update = action({ context, params: undefined });
+        const { goal } = update;
+        if (!goal) {
+            return;
+        }
+        enqueue.assign(update);
+        const event = {
+            type: 'goal',
+            runId: context.runId,
+            status: goal.status,
+            turn: goal.turns,
+            round: update.round ?? context.round
+        };
+        if (goal.status === 'open') {
+            event.text = goalTurn(context);
+        }
+        enqueue.emit(event);
+    });
+}
+function inputEvent(runId, queued, round) {
+    return { type: 'input', runId, ...queued, round };
+}