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

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

@@ -0,0 +1,74 @@
+import { AbortedError } from '../../../helpers/race-abort.js';
+import { executeCall, readyPreflightFromFacts } from '../tool-execution.js';
+import { errorMessage } from '../../../guards.js';
+import { toolContext } from './execution-plan.js';
+import { detachJson } from '../../../helpers/detach-json.js';
+import { RecoveryRequired } from '../../../helpers/engine-error.js';
+import { ToolPolicyChanged } from '../operations.js';
+export function runPrepare(source) {
+    return async function runPrepare({ emit, input: deps, context }) {
+        const { args, session } = deps;
+        const step = context.prepareStep;
+        if (!step) {
+            throw new Error('prepare execution requires an authorized step');
+        }
+        const tool = session.enabled.find((tool) => tool.name === step.tool);
+        if (!tool) {
+            throw new Error(`prepare step requires the ${step.tool} tool`);
+        }
+        const facts = step.facts;
+        if (!facts) {
+            throw new Error('prepare step has no authorized facts');
+        }
+        if (args.signal?.aborted) {
+            throw new AbortedError();
+        }
+        const fail = (error) => ({
+            failure: source.fail({ deps, context, step, error })
+        });
+        const executeContext = toolContext({ deps, context, name: tool.name });
+        const effect = tool.effect(detachJson(step.args), executeContext);
+        if (effect !== facts.effect || effect !== 'read') {
+            return fail(`${source.label} is no longer classified as a read-only operation.`);
+        }
+        const display = source.display(deps, step);
+        let activity = null;
+        let result;
+        try {
+            const executed = await executeCall(tool, step.args, executeContext, {
+                runId: session.runId,
+                deniedMessage: context.policy.deniedMessage,
+                signal: args.signal,
+                sources: [],
+                outbound: session.outbound,
+                pipeline: session.pipeline,
+                callId: step.id,
+                effect,
+                preflight: readyPreflightFromFacts(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();
+            }
+            return fail(errorMessage(error));
+        }
+        if (args.signal?.aborted) {
+            throw new AbortedError();
+        }
+        const announce = () => {
+            emit({ type: 'tool-call', name: tool.name, args: step.args, effect: 'read', display });
+            if (activity) {
+                emit(activity);
+            }
+            emit({ type: 'tool-result', name: tool.name, result });
+        };
+        return source.settle({ deps, context, step, result, announce });
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { PrepareStepSource } from '../prepare-step.ts';
+export declare const skillStep: PrepareStepSource;

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

@@ -0,0 +1,76 @@
+import { spliceFrom } from '../splice.js';
+import { annotateCompletionHistoryLastUserTime, preloadLastUser } from '../turns.js';
+import { labelOf, skillEmojiFrom } from '../loop.js';
+import { withoutSkillLoadTurns } from '../../tool-turns.js';
+import { Agent } from '../../../agent/index.js';
+import { errorMessage, isRecord } from '../../../guards.js';
+const ID_PREFIX = 'preload-';
+export const skillStep = {
+    label: 'Skill loading',
+    propose({ session }, { preload }) {
+        if (!preload) {
+            return null;
+        }
+        return {
+            id: `${ID_PREFIX}${preload.name}`,
+            tool: Agent.SKILL_TOOL_NAME,
+            args: { name: preload.name },
+            done: session.loadedThisTurn.has(preload.name)
+        };
+    },
+    display({ session }, step) {
+        return labelOf(step.tool, step.args, skillEmojiFrom(session.inContextSkills, skillOf(step)));
+    },
+    settle({ deps, context, step, result, announce }) {
+        const { session } = deps;
+        const name = skillOf(step);
+        if (!context.activated.includes(name)) {
+            announce();
+        }
+        if (!hasContent(result)) {
+            return {
+                failure: fail({
+                    deps,
+                    context,
+                    step,
+                    error: errorFrom(result) ?? 'skill did not return content'
+                })
+            };
+        }
+        const content = String(result.content);
+        session.loadedThisTurn.add(name);
+        session.skillIcon = skillEmojiFrom(session.inContextSkills, name) ?? session.skillIcon;
+        const inlined = preloadLastUser(context.history, name, content);
+        const turns = withoutSkillLoadTurns(inlined, name);
+        const history = annotateCompletionHistoryLastUserTime(turns, new Date(session.startedAt));
+        return {
+            history: spliceFrom(context.history, history),
+            source: session.outbound.facts('skill', content),
+            cacheable: false,
+            activate: name
+        };
+    },
+    fail
+};
+function fail({ deps, context, step, error }) {
+    const { history } = context;
+    const message = `Skill "${skillOf(step)}" could not be loaded: ${error}`;
+    const guided = preloadLastUser(history, skillOf(step), message);
+    const startedAt = new Date(deps.session.startedAt);
+    return {
+        error: message,
+        history: spliceFrom(history, annotateCompletionHistoryLastUserTime(guided, startedAt))
+    };
+}
+function skillOf(step) {
+    return step.id.slice(ID_PREFIX.length);
+}
+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/stream.d.ts

@@ -1,5 +1,5 @@
-import type { CompletionEvent, CompletionSdk } from '../../completion.ts';
-import { type RecoveredRound, type RoundArgs } from '../../completion-loop/index.ts';
+import type { CompletionEvent, CompletionSdk } from '../../../contract/index.ts';
+import { type RecoveredRound, type RoundArgs } from '../round.ts';
 interface ForwardStreamOptions<Result> {
     stream: AsyncGenerator<CompletionEvent, Result> | Generator<CompletionEvent, Result>;
     emit: (event: CompletionEvent) => void;

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

@@ -1,4 +1,5 @@
-import { reportUnnamedWrites, runRecoveredRound } from '../../completion-loop/index.js';
+import { reportUnnamedWrites } from '../loop.js';
+import { runRecoveredRound } from '../round.js';
 import { AbortedError } from '../../../helpers/race-abort.js';
 export async function forwardStream({ stream, emit }) {
     try {

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

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

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

@@ -1,21 +1,23 @@
-import { spliceFrom } from '../../../machine/index.js';
+import { spliceFrom } from '../splice.js';
+import { carriesRunOnlyText } from '../turns.js';
 import { runRound } from './stream.js';
 import { truncateAtControlToken } from '../../../helpers/control-tokens.js';
-import { recoverMarkupToolCalls, recoverPrintedSkillLoad, recoverSkillNamedCall, stripToolResponseBlocks } from '../../../helpers/tool-call-markup.js';
-import { unquoteArg } from '../../../tools/model-args.js';
-import { SKILL_TOOL_NAME } from '../../tool-names.js';
+import { clipRawCall, recoverMarkupToolCalls, recoverPrintedSkillLoad, recoverSkillNamedCall, stripToolResponseBlocks } from '../../../helpers/tool-call-markup.js';
+import { unquoteArg } from '../../../helpers/model-args.js';
+import { Agent } from '../../../agent/index.js';
+import { loadedTools, unloadedTools } from '../../sdk-tool.js';
 import { hlog } from '../../../log.js';
-import { customToolDialect } from '../../../models/model-catalog.js';
-export const streaming = async function streaming({ emit, input: { sdk, args, session }, context }) {
-    const { recovered, promptPrefix, thinkingText } = await generateStreamingRound({
+import { toolDialectFor } from '../../../models/model-catalog.js';
+export const streaming = async function streaming({ emit, input: { sdk, args, session, operations }, context }) {
+    const { recovered, promptPrefix, thinkingText, durationMs } = await generateStreamingRound({
         sdk,
         args,
         session,
+        operations,
         context,
         emit
     });
-    const rawToolCalls = recoverToolCalls({ recovered, session, round: context.round });
-    const toolCalls = identifyToolCalls(rawToolCalls, session.runId, context.round);
+    const { toolCalls, toolErrors } = roundCalls({ recovered, session, context });
     session.runOutcomes.finishRound();
     session.runOutcomes.beginRound();
     return {
@@ -27,16 +29,43 @@ export const streaming = async function streaming({ emit, input: { sdk, args, se
             arguments: call.arguments,
             raw: call.raw
         })),
+        toolErrors,
         stats: recovered.final.stats,
         stopReason: recovered.final.stopReason,
+        durationMs,
+        ctxSize: recovered.ctxSize,
         promptPrefix,
         replay: recovered.replay,
         history: recovered.history ? spliceFrom(context.history, recovered.history) : undefined,
         cacheable: recovered.cacheable
     };
 };
-async function generateStreamingRound({ sdk, args, session, context, emit }) {
-    const prepared = prepareStreamingRound({ args, session, context });
+function roundCalls({ recovered, session, context }) {
+    const unloaded = unloadedTools(session.enabled, recovered.history ?? context.history);
+    const calls = recoverToolCalls({ recovered, session, round: context.round });
+    const callable = calls.filter((call) => !unloaded.has(call.name));
+    const refused = calls.filter((call) => unloaded.has(call.name)).map(notLoaded);
+    return {
+        toolCalls: identifyToolCalls(callable, session.runId, context.round),
+        toolErrors: callable.length
+            ? undefined
+            : roundToolErrors([...(recovered.final.toolErrors ?? []), ...refused])
+    };
+}
+function notLoaded(call) {
+    return { code: 'UNKNOWN_TOOL', message: `Tool "${call.name}" is not loaded`, raw: call.raw };
+}
+function roundToolErrors(errors) {
+    if (!errors.length)
+        return undefined;
+    return errors.map(({ code, message, raw }) => ({
+        code,
+        message,
+        raw: raw === undefined ? undefined : clipRawCall(raw)
+    }));
+}
+async function generateStreamingRound({ sdk, args, session, operations, context, emit }) {
+    const prepared = prepareStreamingRound({ args, session, operations, context });
     let thinkingText = '';
     const recovered = await runRound({
         sdk,
@@ -45,23 +74,27 @@ async function generateStreamingRound({ sdk, args, session, context, emit }) {
             if (event.type === 'thinking') {
                 thinkingText += event.text;
             }
+            else if (event.type === 'round-reset') {
+                thinkingText = '';
+            }
             emit(event);
         }
     });
-    logRoundStats({ session, round: context.round, startedAt: prepared.startedAt, recovered });
-    return { recovered, promptPrefix: prepared.promptPrefix, thinkingText };
+    const durationMs = Date.now() - prepared.startedAt;
+    logRoundStats({ round: context.round, durationMs, recovered });
+    return { recovered, promptPrefix: prepared.promptPrefix, thinkingText, durationMs };
 }
-function logRoundStats({ session, round, startedAt, recovered }) {
-    hlog('round stats', Object.assign({ round, wallMs: session.now() - startedAt }, recovered.final.stats));
+function logRoundStats({ round, durationMs, recovered }) {
+    hlog('round stats', Object.assign({ round, wallMs: durationMs }, recovered.final.stats));
 }
 function roundLoadedSkills(context, session) {
-    return new Set([...(context.skills.snapshot?.loaded ?? []), ...session.loadedThisTurn]);
+    return new Set([...context.activated, ...session.loadedThisTurn]);
 }
-function prepareStreamingRound({ args, session, context }) {
+function prepareStreamingRound({ args, session, operations, context }) {
     const { modelId, acquireRound, responseFormat, signal } = args;
-    const cacheKey = context.cacheKey ?? undefined;
+    const cacheKey = carriesRunOnlyText(context.history) ? undefined : (context.cacheKey ?? undefined);
     const model = args.model;
-    const toolDialect = model ? customToolDialect(model) : undefined;
+    const toolDialect = model ? toolDialectFor(model) : undefined;
     const loadedSkills = roundLoadedSkills(context, session);
     const promptPrefix = session.reselectTools?.(loadedSkills) ?? context.promptPrefix;
     hlog('round start', {
@@ -70,27 +103,50 @@ function prepareStreamingRound({ args, session, context }) {
         tools: session.sdkTools?.length ?? 0,
         promptPrefix
     });
-    const startedAt = session.now();
+    const startedAt = Date.now();
     return {
         args: {
             modelId,
             acquireRound,
             history: context.history,
             failureResults: context.failureResults,
+            continuationNudge: context.policy.continuationNudge,
+            deliveredNudge: context.policy.deliveredNudge,
             tools: session.sdkTools,
-            generationParams: session.generationParams,
+            ...roundGenerationParams(context, session, responseFormat),
             responseFormat,
             toolDialect,
             cacheKey,
             signal,
             round: context.round,
+            runId: session.runId,
             promptPrefix,
-            capture: args.captureInferenceCalls === true
+            capture: args.captureInferenceCalls === true,
+            recordRequest: operations.recordRequest,
+            fold: {
+                messages: args.messages,
+                nudge: context.policy.continuationNudge,
+                ctxSize: args.ctxSize,
+                instructions: (messages) => session.pipeline.preFold({ runId: session.runId, agentId: context.agentId, messages })
+            }
         },
         promptPrefix,
         startedAt
     };
 }
+function roundGenerationParams(context, session, responseFormat) {
+    const owesCall = context.narrated || (context.malformed && context.lastRound?.stopReason !== 'length');
+    if (!owesCall ||
+        !session.sdkTools?.length ||
+        responseFormat ||
+        loadedTools(context.history).size > 0) {
+        return { generationParams: session.generationParams };
+    }
+    return {
+        generationParams: { ...session.generationParams, reasoning_budget: 0, tool_choice: 'required' },
+        unforced: { generationParams: session.generationParams }
+    };
+}
 function recoverToolCalls({ recovered, session, round }) {
     const markup = stripToolResponseBlocks(truncateAtControlToken(recovered.final.raw.fullText) || recovered.unproven || '');
     let calls = recovered.final.toolCalls?.length
@@ -105,9 +161,10 @@ function recoverToolCalls({ recovered, session, round }) {
     return calls;
 }
 function recoverPrintedSkill(markup, session, round) {
-    if (!session.enabled.some((tool) => tool.name === SKILL_TOOL_NAME))
+    if (!session.enabled.some((tool) => tool.name === Agent.SKILL_TOOL_NAME)) {
         return [];
-    const rescued = recoverPrintedSkillLoad(markup, SKILL_TOOL_NAME);
+    }
+    const rescued = recoverPrintedSkillLoad(markup, Agent.SKILL_TOOL_NAME);
     const rescuedArgs = rescued[0]?.arguments;
     const alreadyLoaded = rescuedArgs !== undefined &&
         (session.loadedSkillFiles
@@ -123,11 +180,12 @@ function recoverPrintedSkill(markup, session, round) {
     return rescued;
 }
 function recoverNamedSkill(markup, session, round) {
-    if (!session.enabled.some((tool) => tool.name === SKILL_TOOL_NAME))
+    if (!session.enabled.some((tool) => tool.name === Agent.SKILL_TOOL_NAME)) {
         return [];
+    }
     const calls = recoverSkillNamedCall(markup, session.inContextSkills
         .filter((skill) => !session.nudgedSkills.has(skill.name))
-        .map((skill) => skill.name), SKILL_TOOL_NAME);
+        .map((skill) => skill.name), Agent.SKILL_TOOL_NAME);
     for (const call of calls) {
         session.nudgedSkills.add(unquoteArg(call.arguments.name));
     }

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

@@ -1,5 +1,5 @@
-import { type RoundDonePayload } from '../../../machine/index.ts';
 import type { CompletionActor } from '../session.ts';
+import type { RoundDonePayload } from '../stages.ts';
 interface WrapUpOutput extends RoundDonePayload {
     response: string;
 }

package/dist-lib/lib/capabilities/completion-engine/actors/wrap-up.js

@@ -1,13 +1,16 @@
-import { isFailureResultReference, spliceFrom } from '../../../machine/index.js';
+import { spliceFrom } from '../splice.js';
+import { carriesRunOnlyText } from '../turns.js';
 import { runRound } from './stream.js';
 import { degenerateAnswer } from '../../../helpers/run-outcome.js';
 import { stripToolCallMarkup } from '../../../helpers/tool-call-markup.js';
 import { promptPrefixHash } from '../../prompt-prefix.js';
 import { materializeCompletionHistory } from '../../tool-turns.js';
-export const wrapUp = async function wrapUp({ emit, input: { sdk, args, session }, context }) {
+import { isFailureResultReference } from '../../../helpers/failure-result.js';
+export const wrapUp = async function wrapUp({ emit, input: { sdk, args, session, operations }, context }) {
     const { modelId, acquireRound, signal } = args;
-    const cacheKey = context.cacheKey ?? undefined;
+    const cacheKey = carriesRunOnlyText(context.history) ? undefined : (context.cacheKey ?? undefined);
     const promptPrefix = promptPrefixHash({ system: systemMessage(context), tools: undefined });
+    const startedAt = Date.now();
     const recovered = await runRound({
         sdk,
         args: {
@@ -15,18 +18,22 @@ export const wrapUp = async function wrapUp({ emit, input: { sdk, args, session
             acquireRound,
             history: context.history,
             failureResults: context.failureResults,
+            continuationNudge: context.policy.continuationNudge,
+            deliveredNudge: context.policy.deliveredNudge,
             tools: undefined,
             generationParams: session.generationParams,
             cacheKey,
             signal,
             round: context.roundsSent,
             promptPrefix,
-            capture: args.captureInferenceCalls === true
+            capture: args.captureInferenceCalls === true,
+            recordRequest: operations.recordRequest
         },
         emit
     });
+    const durationMs = Date.now() - startedAt;
     const replay = recovered.replay ? stripToolCallMarkup(recovered.replay) : '';
-    const fallbackResponse = degenerateAnswer(wrapOutcome(context), materializeCompletionHistory(context.history, context.failureResults), previewFinishedRound(session.runOutcomes.snapshot()));
+    const fallbackResponse = degenerateAnswer(wrapOutcome(context), materializeCompletionHistory(context.history, context.failureResults), { ...previewFinishedRound(session.runOutcomes.snapshot()), delivered: context.delivered });
     return {
         contentText: recovered.contentText,
         thinkingText: '',
@@ -34,6 +41,8 @@ export const wrapUp = async function wrapUp({ emit, input: { sdk, args, session
         toolCalls: [],
         stats: recovered.final.stats,
         stopReason: recovered.final.stopReason,
+        durationMs,
+        ctxSize: recovered.ctxSize,
         replay,
         history: recovered.history ? spliceFrom(context.history, recovered.history) : undefined,
         cacheable: recovered.cacheable,
@@ -54,7 +63,8 @@ function wrapOutcome(ctx) {
     if (ctx.outcome === 'mute' ||
         ctx.outcome === 'exhausted' ||
         ctx.outcome === 'search-capped' ||
-        ctx.outcome === 'time-capped') {
+        ctx.outcome === 'time-capped' ||
+        ctx.outcome === 'delivered') {
         return ctx.outcome;
     }
     return 'exhausted';

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

@@ -0,0 +1,11 @@
+import type { RunLog } from '../../run-log/index.ts';
+import type { EnginePorts, InvokeTracker } from './ports.ts';
+import type { CompletionActorLogic, EngineEvent } from '../../machine/index.ts';
+export interface EngineDeps {
+    ports: EnginePorts;
+    journal: RunLog;
+    invokes: InvokeTracker;
+    emitContent?(event: EngineEvent): void;
+}
+export declare function createInvokeTracker(): InvokeTracker;
+export declare function createCompletionActors(deps: EngineDeps): CompletionActorLogic;

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

@@ -0,0 +1,216 @@
+import { fromPromise } from 'xstate';
+import { didDrainTimeOut, raceDrain } from '../../helpers/drain.js';
+import { AbortedError, RecoveryRequired, tagError } from '../../helpers/engine-error.js';
+export function createInvokeTracker() {
+    let active = 0;
+    let idle = Promise.resolve();
+    let settleIdle = () => { };
+    let stuck = null;
+    return {
+        trackInvoke() {
+            if (active === 0) {
+                idle = new Promise((resolve) => {
+                    settleIdle = resolve;
+                });
+            }
+            active++;
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                active--;
+                if (active === 0) {
+                    settleIdle();
+                }
+            };
+        },
+        waitForInvokes() {
+            return idle;
+        },
+        async drainTimedOut() {
+            const waiting = idle;
+            if (stuck === waiting) {
+                return true;
+            }
+            if (!didDrainTimeOut(await raceDrain(waiting))) {
+                return false;
+            }
+            stuck = waiting;
+            return true;
+        }
+    };
+}
+export function createCompletionActors(deps) {
+    return {
+        preparing: worker('preparing', deps),
+        inspectPrepare: worker('inspectPrepare', deps),
+        runPrepare: worker('runPrepare', deps),
+        searching: worker('searching', deps),
+        generating: worker('generating', deps),
+        resolving: worker('resolving', deps),
+        inspecting: worker('inspecting', deps),
+        rejecting: worker('rejecting', deps),
+        approving: worker('approving', deps),
+        executing: worker('executing', deps),
+        batching: worker('batching', deps),
+        wrapping: worker('wrapping', deps),
+        answering: worker('answering', deps),
+        retrieving: worker('retrieving', deps),
+        finishing: worker('finishing', deps),
+        cleanup: fromPromise(async ({ input }) => {
+            try {
+                if (await deps.invokes.drainTimedOut()) {
+                    throw new AbortedError();
+                }
+                const release = deps.invokes.trackInvoke();
+                try {
+                    await lifecycle({ deps, phase: 'runPause', context: contextOf(input.parent) });
+                }
+                finally {
+                    release();
+                }
+            }
+            catch (error) {
+                throw tagError(error);
+            }
+        }),
+        resume: fromPromise(async ({ input, signal }) => {
+            const release = deps.invokes.trackInvoke();
+            const context = contextOf(input.parent);
+            try {
+                await deps.ports.rebuild(invocation({
+                    parent: input.parent,
+                    context,
+                    stage: 'resume',
+                    signal,
+                    isLive: () => !signal.aborted,
+                    journal: deps.journal,
+                    canCommitSettledResult: () => !signal.aborted,
+                    settledResultFacts: deps.ports.settledResultFacts
+                }));
+                for (const receipt of deps.journal.receipts.values()) {
+                    if (receipt.status === 'retry' &&
+                        (receipt.name === 'hook:runPause' || receipt.name === 'hook:runResume')) {
+                        const phase = receipt.name === 'hook:runPause' ? 'runPause' : 'runResume';
+                        await lifecycle({ deps, phase, context, signal, operationId: receipt.id });
+                    }
+                }
+                await lifecycle({ deps, phase: 'runResume', context, signal });
+            }
+            catch (error) {
+                throw tagError(error);
+            }
+            finally {
+                release();
+            }
+        })
+    };
+}
+function worker(stage, deps) {
+    return fromPromise(async ({ input, signal }) => {
+        const { journal, ports } = deps;
+        const context = contextOf(input.parent);
+        const release = deps.invokes.trackInvoke();
+        let acceptingOutput = true;
+        const isLive = () => acceptingOutput && !signal.aborted;
+        try {
+            await journal.flush();
+            if (signal.aborted) {
+                throw new AbortedError();
+            }
+            const emitContent = deps.emitContent
+                ? (event) => {
+                    if (isLive()) {
+                        deps.emitContent?.(event);
+                    }
+                }
+                : undefined;
+            const output = await ports.stages[stage](invocation({
+                parent: input.parent,
+                context,
+                stage,
+                signal,
+                emitContent,
+                isLive,
+                journal,
+                canCommitSettledResult: () => acceptingOutput,
+                settledResultFacts: ports.settledResultFacts
+            }));
+            acceptingOutput = false;
+            await journal.flush();
+            if (signal.aborted) {
+                throw new AbortedError();
+            }
+            const uncertain = journal.uncertainWrite();
+            if (uncertain) {
+                throw new RecoveryRequired(uncertain);
+            }
+            return output;
+        }
+        catch (error) {
+            acceptingOutput = false;
+            throw tagError(error);
+        }
+        finally {
+            acceptingOutput = false;
+            release();
+        }
+    });
+}
+function invocation({ parent, context, stage, signal, emitContent, isLive, journal, canCommitSettledResult, settledResultFacts }) {
+    const committedReceipts = new Set();
+    return {
+        context,
+        signal,
+        stage,
+        emit: (event) => {
+            if (!isLive())
+                return;
+            if ((event.type === 'content' || event.type === 'thinking') && emitContent) {
+                emitContent(event);
+            }
+            else {
+                parent.send({ type: 'OUTPUT', event });
+            }
+        },
+        commit: (facts) => {
+            if (!isLive() || contextOf(parent).durable === facts) {
+                return;
+            }
+            parent.send({ type: 'FACTS', value: facts });
+        },
+        commitSettledResult: (operationId) => {
+            if (!canCommitSettledResult() || journal.sealed || journal.failure) {
+                return;
+            }
+            if (committedReceipts.has(operationId)) {
+                return;
+            }
+            const receipt = journal.getReceipt(operationId);
+            if (receipt?.status !== 'result') {
+                return;
+            }
+            const projected = settledResultFacts?.(operationId, contextOf(parent).durable);
+            if (!projected) {
+                return;
+            }
+            committedReceipts.add(operationId);
+            parent.send({ type: 'FACTS', value: projected });
+        }
+    };
+}
+function contextOf(parent) {
+    return parent.getSnapshot().context;
+}
+async function lifecycle({ deps, phase, context, signal, operationId = `${context.runId}:${phase}-${context.pauseCount}` }) {
+    await deps.journal.flush();
+    if (signal?.aborted) {
+        throw new AbortedError();
+    }
+    await deps.journal.operation({ id: operationId, name: `hook:${phase}`, args: {}, effect: 'write' }, async () => {
+        if (signal?.aborted)
+            throw new AbortedError();
+        await deps.ports.lifecycle(phase, context);
+    });
+}