@qvac/harness 0.7.0 → 1.0.0-rc.0

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

@@ -0,0 +1,150 @@
+import { createHash } from 'crypto';
+import { isRecord } from '../../guards.js';
+import { copy, stableStringify } from '../../machine/index.js';
+import { createRunOutcomeTracker } from '../../helpers/run-outcome.js';
+import { runToolContext } from '../completion-loop/index.js';
+function rootIdentity(root) {
+    return root.kind === 'local'
+        ? `local:${root.root}`
+        : `hyper:${root.key}:${root.prefix}:${root.writable}`;
+}
+export function capabilityPolicy(session) {
+    const context = session.toolContext();
+    return {
+        behaviorDigest: session.behaviorDigest,
+        roots: (context.fsRoots ?? []).map(rootIdentity).sort(),
+        writeRoots: session.writableRoots.map(rootIdentity).sort(),
+        skills: [...session.activation.enabledSkills].sort(),
+        skillContent: session.inContextSkills
+            .map((skill) => [skill.name, skill.contentDigest ?? null])
+            .sort(([left], [right]) => left.localeCompare(right)),
+        grantedOps: [...session.grantedOps.entries()]
+            .map(([bin, validators]) => [bin, validators.map((validator) => validator.fingerprint).sort()])
+            .sort(([left], [right]) => left.localeCompare(right))
+    };
+}
+const schemaDigests = new WeakMap();
+export function schemaDigest(parameters) {
+    const serialized = stableStringify(parameters);
+    const cached = schemaDigests.get(parameters);
+    if (cached?.serialized === serialized) {
+        return cached.digest;
+    }
+    const digest = createHash('sha256').update(serialized).digest('hex');
+    schemaDigests.set(parameters, { serialized, digest });
+    return digest;
+}
+const durableFactsCache = new WeakMap();
+function toolFacts(tools) {
+    return tools.map(mapToolFacts);
+}
+function mapToolFacts({ name, description, prompt, policyVersion, parameters, toolset, autoApprove, externalWrite, owningSkill, skillGated, rootsRequired, writeRootsRequired, compiled }) {
+    return {
+        name,
+        description,
+        prompt: prompt ?? null,
+        policyVersion: policyVersion ?? null,
+        parametersDigest: schemaDigest(parameters),
+        toolset,
+        autoApprove: autoApprove === true,
+        externalWrite: externalWrite === true,
+        owningSkill: owningSkill ?? null,
+        skillGated: skillGated === true,
+        rootsRequired: rootsRequired === true,
+        writeRootsRequired: writeRootsRequired === true,
+        compiled: compiled === true
+    };
+}
+function makeDurableFactsSource(session) {
+    return {
+        bindings: [...session.bindings],
+        runId: session.runId,
+        tools: toolFacts(session.enabled),
+        policy: capabilityPolicy(session),
+        loadedThisTurn: [...session.loadedThisTurn],
+        loadedFilesThisTurn: [...session.loadedFilesThisTurn],
+        loadedSkillFiles: [...session.loadedSkillFiles].map(([name, files]) => [
+            name,
+            [...files]
+        ]),
+        nudgedSkills: [...session.nudgedSkills],
+        backends: [...session.backends],
+        outcome: session.runOutcomes.snapshot(),
+        skillIcon: session.skillIcon,
+        runBudget: { ...session.runBudget },
+        startedAt: session.startedAt,
+        runStarted: session.runStarted,
+        promptParts: session.promptParts,
+        activation: {
+            ...session.activation,
+            enabledSkills: [...session.activation.enabledSkills],
+            loadedSkills: [...session.activation.loadedSkills]
+        }
+    };
+}
+export function captureFacts(session) {
+    const source = makeDurableFactsSource(session);
+    const serialized = JSON.stringify(source);
+    if (serialized === undefined) {
+        return copy(source);
+    }
+    const cached = durableFactsCache.get(session);
+    if (cached?.serialized === serialized) {
+        return cached.snapshot;
+    }
+    const snapshot = JSON.parse(serialized);
+    freezeJsonTree(snapshot);
+    durableFactsCache.set(session, { serialized, snapshot });
+    return snapshot;
+}
+export function captureToolOperationFacts(session) {
+    return copy({
+        backends: [...session.backends],
+        runBudget: { outputBytesUsed: session.runBudget.outputBytesUsed },
+        outcome: { confirmedWrites: session.runOutcomes.snapshot().confirmedWrites }
+    });
+}
+export function restoreFacts(deps, facts) {
+    facts = copy(facts);
+    const session = deps.session;
+    session.bindings = [...facts.bindings];
+    session.runId = facts.runId;
+    session.loadedThisTurn = new Set(facts.loadedThisTurn);
+    session.loadedFilesThisTurn = new Set(facts.loadedFilesThisTurn);
+    session.loadedSkillFiles = new Map(facts.loadedSkillFiles.map(([name, files]) => [name, new Set(files)]));
+    session.nudgedSkills = new Set(facts.nudgedSkills);
+    session.backends = [...facts.backends];
+    session.runOutcomes = createRunOutcomeTracker(facts.outcome);
+    session.landed = session.runOutcomes.confirmedWrites;
+    session.skillIcon = facts.skillIcon;
+    session.runBudget = { ...facts.runBudget };
+    session.toolContext = runToolContext(deps.args, session.runBudget);
+    session.startedAt = facts.startedAt ?? session.startedAt;
+    session.runStarted = facts.runStarted;
+    session.promptParts = facts.promptParts;
+    session.activation = { ...facts.activation, loadedSkills: new Set(facts.activation.loadedSkills) };
+}
+function freezeJsonTree(root) {
+    if (!isRecord(root)) {
+        return;
+    }
+    const pending = [root];
+    const visited = new WeakSet();
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined || visited.has(current)) {
+            continue;
+        }
+        visited.add(current);
+        enqueueJsonChildren(current, pending);
+        Object.freeze(current);
+    }
+}
+function enqueueJsonChildren(current, pending) {
+    for (const key of Reflect.ownKeys(current)) {
+        const child = Reflect.get(current, key);
+        if (isRecord(child)) {
+            pending.push(child);
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { CompletionArgs } from '../completion-loop/index.ts';
+import type { CompletionDeps } from './session.ts';
+import { type ToolOperationFacts } from './durable.ts';
+import type { CompletionMachineContext as CompletionContext } from '../../machine/index.ts';
+export declare function toolOperationFacts(value: unknown): ToolOperationFacts;
+export declare function bindOperations(deps: CompletionDeps, context: CompletionContext, stage: string): CompletionArgs;

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

@@ -0,0 +1,239 @@
+import { createHash } from 'crypto';
+import { normalizeToolExecutionOutcome, writeResult } from '../../helpers/run-outcome.js';
+import { isMetadataMethod } from '../../tools/mcp/protocol.js';
+import { captureFacts, captureToolOperationFacts, restoreFacts } from './durable.js';
+import { AbortedError } from '../../helpers/race-abort.js';
+import { ToolPolicyChanged } from '../../machine/index.js';
+import { isRecord } from '../../guards.js';
+import { detachJson } from '../../helpers/detach-json.js';
+const basePipelines = new WeakMap();
+function digestArgs(payload) {
+    const entries = Object.entries(payload);
+    const messages = entries.find(([key]) => key === 'messages')?.[1];
+    if (!Array.isArray(messages)) {
+        return Object.fromEntries(entries);
+    }
+    const rest = Object.fromEntries(entries.filter(([key]) => key !== 'messages'));
+    return {
+        ...rest,
+        messages: {
+            count: messages.length,
+            sha256: createHash('sha256').update(JSON.stringify(messages)).digest('hex')
+        }
+    };
+}
+function isBackendUse(value) {
+    return (isRecord(value) &&
+        typeof value.tool === 'string' &&
+        typeof value.requestedGpu === 'boolean' &&
+        (value.device === 'gpu' || value.device === 'cpu' || value.device === 'unknown') &&
+        typeof value.backend === 'string');
+}
+export function toolOperationFacts(value) {
+    if (!isRecord(value) || !Array.isArray(value.backends) || !isRecord(value.runBudget)) {
+        throw new TypeError('Malformed tool operation facts');
+    }
+    const backends = value.backends.filter(isBackendUse);
+    const runBudget = value.runBudget.outputBytesUsed;
+    const outcome = value.outcome;
+    if (backends.length !== value.backends.length ||
+        typeof runBudget !== 'number' ||
+        !Number.isSafeInteger(runBudget) ||
+        runBudget < 0 ||
+        !isRecord(outcome) ||
+        !Array.isArray(outcome.confirmedWrites)) {
+        throw new TypeError('Malformed tool operation facts');
+    }
+    const confirmedWrites = outcome.confirmedWrites.filter((entry) => typeof entry === 'string');
+    if (confirmedWrites.length !== outcome.confirmedWrites.length) {
+        throw new TypeError('Malformed tool operation facts');
+    }
+    return { backends, runBudget: { outputBytesUsed: runBudget }, outcome: { confirmedWrites } };
+}
+function runHookOperation({ deps, base, phase, id, name, payload, check, run }) {
+    check();
+    if (!base.hasPhase(phase)) {
+        return run();
+    }
+    return deps.operations.operation({ id, name, args: digestArgs(payload), effect: 'read' }, run, undefined, deps.args.signal);
+}
+function wrapHostCallback({ deps, check, prefix, stage, callId, name, effect, callback }) {
+    let count = 0;
+    return async (input) => {
+        const release = deps.session.trackInvoke();
+        try {
+            check();
+            const journalInput = detachHostCallbackInput(input);
+            const callbackInput = detachHostCallbackInput(journalInput);
+            return await deps.operations.operation({
+                id: `${prefix}:${stage}:${callId}:host-${name}-${count++}`,
+                name: `host:${name}`,
+                args: [journalInput],
+                effect
+            }, () => callback(callbackInput).then((result) => detachJson(result)), undefined, deps.args.signal);
+        }
+        finally {
+            release();
+        }
+    };
+}
+function detachHostCallbackInput(input) {
+    const detached = detachJson(input);
+    if (isRecord(input) && input.bytes instanceof Uint8Array) {
+        Reflect.set(detached, 'bytes', Uint8Array.from(input.bytes));
+    }
+    return detached;
+}
+export function bindOperations(deps, context, stage) {
+    const args = { ...deps.args };
+    const prefix = `${context.runId}:round-${context.round}`;
+    const check = () => {
+        if (args.signal?.aborted)
+            throw new AbortedError();
+    };
+    args.tools = args.tools?.map((tool) => ({
+        ...tool,
+        execute: async (resolved, runtime) => {
+            const call = runtime?.callId ??
+                context.currentCall?.id ??
+                `preload-${context.skillPreload?.name ?? tool.name}`;
+            const id = `${prefix}:${call}:execute`;
+            const effect = tool.effect(detachJson(resolved), runtime);
+            if (stage === 'preloading' &&
+                context.skillPreload &&
+                tool.name === 'skill' &&
+                (context.skillPreload.facts?.effect !== 'read' || effect !== 'read')) {
+                throw new ToolPolicyChanged(tool.name);
+            }
+            if (context.execution &&
+                context.currentCall?.name === tool.name &&
+                effect !== context.execution.effect) {
+                throw new ToolPolicyChanged(tool.name);
+            }
+            check();
+            const result = await deps.operations.operation({
+                id,
+                name: tool.name,
+                args: resolved,
+                effect
+            }, async () => {
+                const result = await tool.execute(resolved, runtime);
+                confirm(result);
+                return result;
+            }, {
+                capture: () => captureToolOperationFacts(deps.session),
+                restore: (facts) => {
+                    const recorded = toolOperationFacts(facts);
+                    const current = captureFacts(deps.session);
+                    restoreFacts(deps, {
+                        ...current,
+                        backends: recorded.backends.length > current.backends.length
+                            ? recorded.backends
+                            : current.backends,
+                        runBudget: {
+                            deadlineMs: current.runBudget.deadlineMs,
+                            outputBytesUsed: Math.max(current.runBudget.outputBytesUsed, recorded.runBudget.outputBytesUsed)
+                        },
+                        outcome: {
+                            ...current.outcome,
+                            confirmedWrites: recorded.outcome.confirmedWrites.length > current.outcome.confirmedWrites.length
+                                ? recorded.outcome.confirmedWrites
+                                : current.outcome.confirmedWrites
+                        }
+                    });
+                }
+            }, args.signal);
+            const receipt = deps.operations.getReceipt(id);
+            if (receipt?.status === 'result' && receipt.facts === undefined) {
+                confirm(result);
+                await deps.operations.commitResultFacts(id, captureToolOperationFacts(deps.session));
+            }
+            if (args.signal?.aborted && deps.operations.getReceipt(id)?.status === 'result') {
+                deps.commitSettledFacts?.(id);
+            }
+            return result;
+            function confirm(result) {
+                if (effect === 'write' &&
+                    normalizeToolExecutionOutcome(result, { kind: 'success' }).kind === 'success') {
+                    const written = tool.landedWrite?.(detachJson(resolved), detachJson(result)) ??
+                        ((tool.toolset === 'mcp-call' && !isMetadataMethod(resolved.method)) ||
+                            (tool.compiled === true && tool.toolset === 'http-request')
+                            ? writeResult(result)
+                            : null);
+                    if (written) {
+                        deps.session.landed.push(written);
+                    }
+                }
+            }
+        }
+    }));
+    if (args.attach) {
+        args.attach = wrapHostCallback({
+            deps,
+            check,
+            prefix,
+            stage,
+            callId: context.currentCall?.id ?? 'prepare',
+            name: 'attach',
+            effect: 'write',
+            callback: args.attach
+        });
+    }
+    if (args.askUser) {
+        args.askUser = wrapHostCallback({
+            deps,
+            check,
+            prefix,
+            stage,
+            callId: context.currentCall?.id ?? 'prepare',
+            name: 'askUser',
+            effect: 'read',
+            callback: args.askUser
+        });
+    }
+    const base = basePipelines.get(deps.session) ?? deps.session.pipeline;
+    basePipelines.set(deps.session, base);
+    const pipeline = Object.create(base);
+    deps.session.pipeline = pipeline;
+    let startCount = 0;
+    pipeline.onRunStart = async (payload) => {
+        await runHookOperation({
+            deps,
+            base,
+            phase: 'runStart',
+            id: `${prefix}:${stage}:run:hook-onRunStart-${startCount++}`,
+            name: 'hook:onRunStart',
+            payload,
+            check,
+            run: () => base.onRunStart(payload)
+        });
+    };
+    let preToolCount = 0;
+    pipeline.runPreToolFold = async (payload) => {
+        const { signal: _signal, ...durable } = payload;
+        return runHookOperation({
+            deps,
+            base,
+            phase: 'preToolCall',
+            id: `${prefix}:${stage}:${payload.callId}:hook-runPreToolFold-${preToolCount++}`,
+            name: 'hook:runPreToolFold',
+            payload: durable,
+            check,
+            run: () => base.runPreToolFold(payload)
+        });
+    };
+    let postToolCount = 0;
+    pipeline.runPostToolFold = async (payload) => {
+        return runHookOperation({
+            deps,
+            base,
+            phase: 'postToolCall',
+            id: `${prefix}:${stage}:${payload.callId}:hook-runPostToolFold-${postToolCount++}`,
+            name: 'hook:runPostToolFold',
+            payload,
+            check,
+            run: () => base.runPostToolFold(payload)
+        });
+    };
+    return args;
+}

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

@@ -0,0 +1,3 @@
+import type { EnginePorts } from '../../machine/index.ts';
+import type { CompletionDeps } from './session.ts';
+export declare function completionPorts(deps: CompletionDeps): EnginePorts;

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

@@ -0,0 +1,267 @@
+import { runToolContext } from '../completion-loop/index.js';
+import { AbortedError } from '../../helpers/race-abort.js';
+import { RecoveryRequired } from '../../helpers/recovery-required.js';
+import { stableStringify } from '../../machine/index.js';
+import { approval } from './actors/approval.js';
+import { answering } from './actors/answering.js';
+import { directSearch } from './actors/direct-search.js';
+import { executing } from './actors/executing.js';
+import { finishing } from './actors/finishing.js';
+import { inspecting } from './actors/inspecting.js';
+import { inspectPreload } from './actors/inspect-preload.js';
+import { loadingSkill } from './actors/loading-skill.js';
+import { preloading } from './actors/preloading.js';
+import { preparing } from './actors/preparing.js';
+import { rejecting } from './actors/rejecting.js';
+import { resolving } from './actors/resolving.js';
+import { streaming } from './actors/streaming.js';
+import { wrapUp } from './actors/wrap-up.js';
+import { toolContext } from './actors/execution-plan.js';
+import { capabilityPolicy, captureFacts, restoreFacts, schemaDigest } from './durable.js';
+import { bindOperations, toolOperationFacts } from './operations.js';
+import { errorMessage, isRecord } from '../../guards.js';
+import { detachJson } from '../../helpers/detach-json.js';
+export function completionPorts(deps) {
+    return {
+        stages: {
+            preparing: stage(deps, preparing),
+            inspectPreload: stage(deps, inspectPreload),
+            preloading: stage(deps, preloading),
+            searching: stage(deps, directSearch),
+            generating: stage(deps, streaming),
+            resolving: stage(deps, resolving),
+            answering: stage(deps, answering),
+            inspecting: stage(deps, inspecting),
+            rejecting: stage(deps, rejecting),
+            loadingSkill: stage(deps, loadingSkill),
+            approving: stage(deps, approval),
+            executing: stage(deps, executing),
+            wrapping: stage(deps, wrapUp),
+            finishing: stage(deps, finishing)
+        },
+        rebuild: (cx) => rebuildSession(deps, cx),
+        lifecycle: (phase, context) => deps.session.pipeline.onRunLifecycle({
+            phase,
+            runId: context.runId,
+            agentId: context.agentId
+        }),
+        settledResultFacts: (operationId, current) => {
+            const receipt = deps.operations.getReceipt(operationId);
+            if (receipt?.status !== 'result' || receipt.facts === undefined) {
+                return undefined;
+            }
+            const recorded = toolOperationFacts(receipt.facts);
+            const fallback = current ? undefined : captureFacts(deps.session);
+            const baseline = current ?? fallback;
+            if (!baseline) {
+                return undefined;
+            }
+            const currentBackends = Array.isArray(baseline.backends) ? baseline.backends : [];
+            const currentBudget = isRecord(baseline.runBudget)
+                ? baseline.runBudget
+                : captureFacts(deps.session).runBudget;
+            const currentOutcome = isRecord(baseline.outcome) ? baseline.outcome : {};
+            const currentWrites = [];
+            if (Array.isArray(currentOutcome.confirmedWrites)) {
+                for (const entry of currentOutcome.confirmedWrites) {
+                    if (typeof entry === 'string') {
+                        currentWrites.push(entry);
+                    }
+                }
+            }
+            return {
+                ...baseline,
+                backends: recorded.backends.length > currentBackends.length ? recorded.backends : currentBackends,
+                runBudget: {
+                    ...currentBudget,
+                    outputBytesUsed: Math.max(typeof currentBudget.outputBytesUsed === 'number' ? currentBudget.outputBytesUsed : 0, recorded.runBudget.outputBytesUsed)
+                },
+                outcome: {
+                    ...currentOutcome,
+                    confirmedWrites: recorded.outcome.confirmedWrites.length > currentWrites.length
+                        ? recorded.outcome.confirmedWrites
+                        : currentWrites
+                }
+            };
+        },
+        now: deps.session.now
+    };
+}
+function stage(deps, run) {
+    return async (cx) => {
+        const invocation = bind(deps, cx);
+        try {
+            return await run(invocation);
+        }
+        finally {
+            invocation.input.commitFacts?.();
+        }
+    };
+}
+function bind(deps, cx) {
+    const { context, signal, stage } = cx;
+    const session = deps.session;
+    const local = {
+        ...deps,
+        args: { ...deps.args, signal: signal }
+    };
+    local.commitFacts = () => cx.commit(captureFacts(session));
+    local.commitSettledFacts = (operationId) => cx.commitSettledResult(operationId);
+    local.args = bindOperations(local, context, stage);
+    const bound = new Map(local.args.tools?.map((tool) => [tool.name, tool]));
+    session.enabled = session.enabled.map((tool) => bound.get(tool.name) ?? tool);
+    const acquireRound = local.args.acquireRound;
+    if (acquireRound) {
+        local.args.acquireRound = async (roundSignal) => {
+            try {
+                return await acquireRound(roundSignal);
+            }
+            catch (error) {
+                if (signal.aborted || roundSignal?.aborted) {
+                    throw new AbortedError();
+                }
+                throw new RecoveryRequired({
+                    id: `${context.runId}:runtime:model`,
+                    name: `Model runtime unavailable: ${errorMessage(error)}`,
+                    args: { model: local.args.model ?? local.args.modelId },
+                    effect: 'read'
+                });
+            }
+        };
+    }
+    session.toolContext = runToolContext(local.args, session.runBudget);
+    return {
+        input: local,
+        context,
+        signal,
+        emit: (event) => {
+            if (signal.aborted)
+                return;
+            if (event.type === 'tool-result') {
+                local.commitFacts?.();
+            }
+            const output = {
+                ...detachEventPayload(event),
+                runId: context.runId,
+                round: eventRound(event, context)
+            };
+            if (context.currentCall) {
+                output.callId = context.currentCall.id;
+            }
+            else if (stage === 'preloading' && context.skillPreload) {
+                output.callId = `preload-${context.skillPreload.name}`;
+            }
+            cx.emit(output);
+        }
+    };
+}
+function detachEventPayload(event) {
+    switch (event.type) {
+        case 'inference-call':
+            return { ...event, call: detachJson(event.call) };
+        case 'inference-sent':
+            return {
+                ...event,
+                messages: detachJson(event.messages),
+                tokens: detachJson(event.tokens)
+            };
+        case 'metrics':
+            return {
+                ...event,
+                backends: detachJson(event.backends),
+                usage: detachJson(event.usage)
+            };
+        case 'tool-call': {
+            const payload = {
+                ...event,
+                args: detachJson(event.args),
+                display: detachJson(event.display)
+            };
+            if (payload.rawCall === undefined) {
+                delete payload.rawCall;
+            }
+            return payload;
+        }
+        case 'tool-activity':
+            return {
+                ...event,
+                args: detachJson(event.args),
+                resource: detachJson(event.resource)
+            };
+        case 'tool-result':
+            return { ...event, result: detachJson(event.result) };
+        default:
+            return event;
+    }
+}
+function eventRound(event, context) {
+    if (event.type === 'inference-sent')
+        return event.round;
+    if (event.type === 'inference-call')
+        return event.call.round;
+    return context.round;
+}
+async function rebuildSession(deps, cx) {
+    const { context } = cx;
+    const durable = context.durable;
+    if (durable) {
+        restoreFacts(deps, durable);
+    }
+    const missingBindings = durable?.bindings.filter((name) => typeof deps.args[name] !== 'function') ?? [];
+    if (missingBindings.length) {
+        throw new RecoveryRequired({
+            id: `${context.runId}:runtime:callbacks`,
+            name: `Supply runtime callbacks: ${missingBindings.join(', ')}`,
+            args: { callbacks: missingBindings },
+            effect: 'read'
+        });
+    }
+    const invocation = bind(deps, cx);
+    await preparing({ ...invocation, reconstruct: true });
+    if (durable) {
+        restoreFacts(invocation.input, durable);
+    }
+    const session = deps.session;
+    session.reselectTools?.(new Set([...(context.skills.snapshot?.loaded ?? []), ...session.loadedThisTurn]));
+    const missing = context.availableTools.filter((name) => !session.enabled.some((tool) => tool.name === name));
+    const changed = durable?.tools
+        .filter((saved) => {
+        const tool = session.enabled.find((tool) => tool.name === saved.name);
+        return (!tool ||
+            saved.description !== tool.description ||
+            stableStringify(saved.prompt) !== stableStringify(tool.prompt ?? null) ||
+            saved.policyVersion !== (tool.policyVersion ?? null) ||
+            saved.parametersDigest !== schemaDigest(tool.parameters) ||
+            saved.toolset !== tool.toolset ||
+            saved.autoApprove !== (tool.autoApprove === true) ||
+            saved.externalWrite !== (tool.externalWrite === true) ||
+            saved.owningSkill !== (tool.owningSkill ?? null) ||
+            saved.skillGated !== (tool.skillGated === true) ||
+            saved.rootsRequired !== (tool.rootsRequired === true) ||
+            saved.writeRootsRequired !== (tool.writeRootsRequired === true) ||
+            saved.compiled !== (tool.compiled === true));
+    })
+        .map((tool) => tool.name) ?? [];
+    const added = durable?.runStarted
+        ? session.enabled
+            .filter((tool) => !durable.tools.some((saved) => saved.name === tool.name))
+            .map((tool) => tool.name)
+        : [];
+    const policyChanged = durable?.runStarted &&
+        stableStringify(durable.policy) !== stableStringify(capabilityPolicy(session));
+    const call = context.currentCall;
+    const inFlight = call && session.enabled.find((tool) => tool.name === call.name);
+    const effectChanged = call &&
+        inFlight &&
+        context.execution &&
+        inFlight.effect(detachJson(call.args), toolContext({ deps: invocation.input, context, name: call.name })) !== context.execution.effect
+        ? [call.name]
+        : [];
+    const drifted = [...new Set([...missing, ...changed, ...added, ...effectChanged])];
+    if (drifted.length) {
+        throw new Error(`Tools changed since this run paused: ${drifted.join(', ')}`);
+    }
+    if (policyChanged) {
+        throw new Error('Capabilities changed since this run paused');
+    }
+}