@dsh-enhanced/assistant-skills 0.1.31 → 0.1.34

package/lib/service.js

@@ -5,7 +5,7 @@ import { acceptanceDigest } from '@dsh-enhanced/task-acceptance-contract';
 import Schema from '@deepseek-ai/schemastery';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { createDefinition, fileObservationSteps, instantiate } from './definition.js';
+import { compensationDirective, createDefinition, evaluatePreconditions, fileObservationSteps, instantiate } from './definition.js';
 import { captureFailureCandidateProvenance, captureRunExpansions } from './capture-expansion.js';
 import { validateComparisonProfiles, SkillComparator } from './comparison.js';
 import { watchBindingCurrent, watchObservation, watchObservationResult, watchObservationRevision } from './watch-proof.js';
@@ -18,6 +18,7 @@ import { RepairContinuationRuntime } from './repair-runtime.js';
 import { OwnerRepairAgentRuntime } from './repair-agent.js';
 import { enqueueRepairFeedback } from './repair-feedback.js';
 import { SkillStore } from './store.js';
+import { awaitBenchmarkSignal, benchmarkArmDefinition, sameBenchmarkArm } from './delegated-arm.js';
 export const Config = Schema.object({
     databasePath: Schema.string().default(join(homedir(), '.dsh', 'assistant-skills.sqlite')),
     allowedTools: Schema.array(Schema.string()).default(['read', 'write', 'edit']),
@@ -53,6 +54,14 @@ function exactArguments(value, allowed) {
         return undefined;
     return args;
 }
+function repairModelRoute(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const route = value;
+    return typeof route.provider === 'string' && route.provider.length > 0 && route.provider.length <= 256 && !route.provider.includes('\0')
+        && typeof route.model === 'string' && route.model.length > 0 && route.model.length <= 256 && !route.model.includes('\0')
+        && (route.reasoningEffort === undefined || typeof route.reasoningEffort === 'string' && route.reasoningEffort.length > 0 && route.reasoningEffort.length <= 256 && !route.reasoningEffort.includes('\0'));
+}
 function failureLocator(value) {
     const locator = plainArguments(value);
     return locator !== undefined && Object.keys(locator).length === 2 && Object.hasOwn(locator, 'sessionId') && Object.hasOwn(locator, 'goalId')
@@ -91,6 +100,37 @@ function failureWindow(input) {
         .sort((left, right) => compare(left.sessionId, right.sessionId) || compare(left.goalId, right.goalId));
     return { failures: Object.freeze(canonical.map(locator => Object.freeze(locator))), minimumOccurrences: minimumOccurrences };
 }
+/**
+ * Bounded window of model-suggested owner-root success locators for one
+ * autonomous growth deposit.  The locator shape ({sessionId,goalId}) is
+ * identical to a failure locator; only its meaning differs.  Discovery only —
+ * every locator still has to pass an independent owner verified source read.
+ */
+function successWindow(input) {
+    const raw = input.successLocators;
+    const minimumOccurrences = input.minimumOccurrences ?? 1;
+    if (!Array.isArray(raw) || Object.getPrototypeOf(raw) !== Array.prototype || raw.length < 1 || raw.length > 32
+        || Object.getOwnPropertySymbols(raw).length !== 0 || Reflect.ownKeys(raw).length !== raw.length + 1
+        || !Number.isSafeInteger(minimumOccurrences) || minimumOccurrences < 1 || minimumOccurrences > 32
+        || minimumOccurrences > raw.length) {
+        throw new Error('assistant-skills: invalid bounded success locator window');
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(raw), successes = [];
+    for (let index = 0; index < raw.length; index++) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === undefined || !descriptor.enumerable || !('value' in descriptor) || !failureLocator(descriptor.value)) {
+            throw new Error('assistant-skills: invalid bounded success locator window');
+        }
+        successes.push(descriptor.value);
+    }
+    const identities = successes.map(locator => acceptanceDigest(locator));
+    if (new Set(identities).size !== identities.length)
+        throw new Error('assistant-skills: duplicate success locator');
+    const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+    const canonical = successes.map(locator => ({ sessionId: locator.sessionId, goalId: locator.goalId }))
+        .sort((left, right) => compare(left.sessionId, right.sessionId) || compare(left.goalId, right.goalId));
+    return { successes: Object.freeze(canonical.map(locator => Object.freeze(locator))), minimumOccurrences: minimumOccurrences };
+}
 function publicDefinition(definition) {
     const source = { digest: acceptanceDigest(definition.source), goalDefinitionDigest: definition.source.goal.definition.digest, stepCount: definition.source.steps.length,
         failedObservationCount: definition.source.failedObservations?.length ?? 0, segmentCount: definition.source.segments?.length ?? 0 };
@@ -188,6 +228,17 @@ function trialProofSteps(steps, candidateId, trialRunId, goalId, invocationId, i
 /** Fixed tool compositions run in the original native Goal; no new AgentLoop or scheduler. */
 export class AssistantSkillsService extends Service {
     static Config = Config;
+    static { Object.defineProperty(this, 'name', { value: 'dsh-enhanced-assistant-skills' }); }
+    static #benchmarkCapabilities = new WeakMap();
+    static #benchmarkRecipients = new WeakMap();
+    #benchmarkIdentity = Object.freeze({});
+    /** A Host identity only; it carries no permission and survives fresh Cordis trace proxies. */
+    benchmarkRecipientIdentity = () => this.#benchmarkIdentity;
+    #issuedBenchmarkArms = new Set();
+    #issuedBenchmarkCells = new Set();
+    #mountedBenchmarkArms = new Map();
+    #benchmarkRuns = new Set();
+    #benchmarkGeneration = 0;
     #store;
     #allowed;
     #duration;
@@ -226,18 +277,37 @@ export class AssistantSkillsService extends Service {
         this.#externalHoldouts = validateExternalHoldoutProfiles(config.externalHoldouts ?? []);
         this.#repairProfiles = validateRepairProfiles(config.repairProfiles ?? [], this.#externalHoldouts);
         this.#store = new SkillStore(config.databasePath ?? join(homedir(), '.dsh', 'assistant-skills.sqlite'));
-        ctx.effect(() => async () => { this.#active = false; this.#lifecycle.abort(); await Promise.all([...this.#repairStops].map(stop => stop())); await Promise.allSettled(this.#comparing); await Promise.allSettled(this.#captureTasks); await Promise.allSettled([...this.#comparators.values()].map(async (value) => (await value).close())); this.#store.close(); }, 'assistant-skills.store');
+        AssistantSkillsService.#benchmarkRecipients.set(this.#benchmarkIdentity, this);
+        ctx.effect(() => async () => { this.#active = false; this.#lifecycle.abort(); this.#mountedBenchmarkArms.clear(); await Promise.allSettled(this.#benchmarkRuns); await Promise.all([...this.#repairStops].map(stop => stop())); await Promise.allSettled(this.#comparing); await Promise.allSettled(this.#captureTasks); await Promise.allSettled([...this.#comparators.values()].map(async (value) => (await value).close())); this.#store.close(); }, 'assistant-skills.store');
+        ctx.inject(['assistantGoals', 'assistantPolicy', 'assistantDelivery'], runtime => {
+            this.#benchmarkGeneration++;
+            runtime.effect(() => () => {
+                this.#benchmarkGeneration++;
+                for (const controller of this.#issuedBenchmarkArms)
+                    controller.abort();
+                this.#issuedBenchmarkArms.clear();
+                for (const arm of this.#mountedBenchmarkArms.values())
+                    arm.revoke();
+                this.#mountedBenchmarkArms.clear();
+            }, 'assistant-skills.benchmark-service-generation');
+        });
         if (this.#repairProfiles.length > 0)
             this.#installRepairRuntime(ctx);
         ctx.inject(['tools', 'agents', 'assistantGoals', 'assistantPolicy', 'assistantDelivery'], runtime => {
             runtime.tools.register(defineTool({ name: 'skill_save', description: 'Save the exact successful tool trace of this owner session’s independently achieved Goal as a private versioned skill. Requires the current human request. Historical acceptance is provenance, never permission or acceptance for a future run.',
                 parameters: { goal_id: { type: 'string', required: true, description: businessGoalId }, name: { type: 'string', required: true }, description: { type: 'string', required: true }, bindings_json: { type: 'string', description: 'JSON array of {name,stepId,path}; path is a scalar argument JSON pointer. Empty array keeps the original arguments.' }, expected_version: { type: 'integer' } }, output,
                 execute: async (args, exec) => ({ context: JSON.stringify(this.save(exec.agent, args.goal_id, { name: args.name, description: args.description, bindings: parse(args.bindings_json ?? '[]', true) }, args.expected_version ?? 0)) }) }));
-            runtime.tools.register(defineTool({ name: 'skill_run', description: 'Replay a saved skill’s fixed tool steps in a fresh native Goal. If the current owner Goal is active but has no admitted native round, this returns awaiting-native-round with no steps or durable run, ends the turn, and the next native round must repeat the same invocation_id. Every nested call retains native permissions, approvals, cancellation and budgets. Tool success still requires fresh independent Goal acceptance.',
+            const delegatedRun = defineTool({ name: 'skill_run', description: 'Replay a saved skill’s fixed tool steps in a fresh native Goal. If the current owner Goal is active but has no admitted native round, this returns awaiting-native-round with no steps or durable run, ends the turn, and the next native round must repeat the same invocation_id. Every nested call retains native permissions, approvals, cancellation and budgets. Tool success still requires fresh independent Goal acceptance.',
                 parameters: { goal_id: { type: 'string', required: true, description: businessGoalId }, name: { type: 'string', required: true }, version: { type: 'integer', required: true }, inputs_json: { type: 'string', description: 'JSON object with only declared typed input parameters.' }, invocation_id: { type: 'string', required: true } }, output,
-                execute: async (args, exec) => ({ context: JSON.stringify(await this.run(exec, args.goal_id, args.name, args.version, parse(args.inputs_json ?? '{}'), args.invocation_id)) }) }));
-            runtime.tools.register(defineTool({ name: 'skill_status', description: 'Read this owner’s active saved skill definitions, typed inputs and source acceptance, or inspect a specific durable invocation. Success means steps executed, not Goal achievement.', parameters: { run_id: { type: 'string' } }, output,
-                execute: async (args, exec) => ({ context: JSON.stringify(this.inspect(exec.agent, args.run_id)) }) }));
+                execute: async (args, exec) => ({ context: JSON.stringify(await this.run(exec, args.goal_id, args.name, args.version, parse(args.inputs_json ?? '{}'), args.invocation_id)) }) });
+            runtime.tools.register(delegatedRun);
+            if (runtime.assistantPolicy.delegatedSkillToolPreauthorizationVersion?.() === 1)
+                runtime.assistantPolicy.registerPreauthorizedTool(runtime, delegatedRun, execution => this.#preauthorizeBenchmarkTool(execution));
+            const delegatedStatus = defineTool({ name: 'skill_status', description: 'Read this owner’s active saved skill definitions, typed inputs and source acceptance, or inspect a specific durable invocation. Success means steps executed, not Goal achievement.', parameters: { run_id: { type: 'string' } }, output,
+                execute: async (args, exec) => ({ context: JSON.stringify(this.inspect(exec.agent, args.run_id)) }) });
+            runtime.tools.register(delegatedStatus);
+            if (runtime.assistantPolicy.delegatedSkillToolPreauthorizationVersion?.() === 1)
+                runtime.assistantPolicy.registerPreauthorizedTool(runtime, delegatedStatus, execution => this.#preauthorizeBenchmarkTool(execution));
             runtime.tools.register(defineTool({ name: 'skill_retire', description: 'Retire the current saved skill version following the current authenticated owner request. Pending steps recheck retirement; past effects remain and require explicit repair.', parameters: { name: { type: 'string', required: true }, expected_version: { type: 'integer', required: true } }, output,
                 execute: async (args, exec) => ({ context: JSON.stringify(this.retire(exec.agent, args.name, args.expected_version)) }) }));
         });
@@ -515,9 +585,39 @@ export class AssistantSkillsService extends Service {
     #capturedDefinition(source, options, scope) {
         return createDefinition(source, options, this.#allowed, captureRunExpansions(source, scope, this.#store));
     }
+    /** Only a live delegated, isolation-only workflow may cross Isolation's tool gate. */
+    #preauthorizeBenchmarkTool(execution) {
+        try {
+            if (execution.signal.aborted || !['skill_run', 'skill_status'].includes(execution.name))
+                return false;
+            const scope = this.#scope(execution.agent, execution.name === 'skill_run' ? 'run' : 'inspect');
+            const mounted = this.#mountedBenchmarkArms.get(acceptanceDigest(scope));
+            if (!mounted || mounted.skill.steps.some(step => step.toolName !== 'isolation_run'))
+                return false;
+            mounted.assertCurrent();
+            const args = plainArguments(execution.arguments);
+            if (!args)
+                return false;
+            if (execution.name === 'skill_status')
+                return Object.keys(args).every(key => key === 'run_id') && (args.run_id === undefined
+                    || typeof args.run_id === 'string' && this.#store.getRun(scope, args.run_id)?.delegationDigest === mounted.bindingDigest);
+            return Object.keys(args).length === 5 && typeof args.goal_id === 'string' && typeof args.inputs_json === 'string' && typeof args.invocation_id === 'string'
+                && args.name === mounted.skill.name && args.version === mounted.skill.version;
+        }
+        catch {
+            return false;
+        }
+    }
     inspect(agent, runId) {
         const scope = this.#scope(agent, 'inspect');
-        return runId ? this.#store.getRun(scope, runId) : this.#store.list(scope);
+        if (runId)
+            return this.#store.getRun(scope, runId);
+        const mounted = this.#mountedBenchmarkArms.get(acceptanceDigest(scope));
+        if (mounted) {
+            mounted.assertCurrent();
+            return [{ ...structuredClone(mounted.skill), delegation: structuredClone(mounted.binding), delegationDigest: mounted.bindingDigest }];
+        }
+        return this.#store.list(scope);
     }
     retire(agent, name, expectedVersion) {
         const scope = this.#scope(agent, 'retire');
@@ -938,6 +1038,107 @@ export class AssistantSkillsService extends Service {
     stageOwnerAuthorizedFailureCandidate = (exec, input, authority) => {
         return this.stageFailureCandidate(exec, input, authority);
     };
+    /**
+     * Host-only autonomous SUCCESS deposit for the growth driver.  Unlike the
+     * repair/failure path it is deliberately NOT anchored to a durable repair
+     * continuation: a successful goal creates none.  Instead the caller supplies
+     * a narrow, short-lived OwnerSuccessCandidateAuthority minted from a frozen
+     * configured owner scope, and this method:
+     *   1. validates the authority (live background agent, exact scope, unexpired,
+     *      caller assertCurrent lease) and re-anchors the authenticated owner route
+     *      through delivery.validateOwnerRoute — never trusting a model-supplied id;
+     *   2. independently re-reads EVERY model-suggested locator through
+     *      goals.inspectOwnerVerifiedWorkflowSource (owner-root, succeeded,
+     *      quiescent, double-read), counting DISTINCT (sessionId,goalId);
+     *   3. stages one PENDING candidate only when the distinct verified-success
+     *      count meets minimumOccurrences.  It never writes a current version, so
+     *      skill_run cannot reach it; activation stays behind the existing owner
+     *      gates.  A retired same-name skill or any version conflict fails closed.
+     */
+    async stageOwnerVerifiedSuccessCandidate(exec, rawInput, authority) {
+        // --- authority + exact owner scope (no repair continuation is consulted) ---
+        exec.signal.throwIfAborted();
+        this.#lifecycle.signal.throwIfAborted();
+        if (!this.#active || !exec.agent || this.ctx.get('agents')?.get(exec.agent.id) !== exec.agent
+            || !Number.isSafeInteger(authority.expiresAt) || authority.expiresAt <= Date.now()
+            || exec.agent.session.header.cwd !== authority.scope.workspace
+            || exec.agent.session.header.agentPreset !== authority.scope.preset) {
+            throw new Error('assistant-skills: growth success authority unavailable');
+        }
+        authority.assertCurrent();
+        const scope = { principalId: authority.scope.principalId, principalRecordId: authority.scope.principalRecordId,
+            principalVersion: authority.scope.principalVersion, workspace: authority.scope.workspace, preset: authority.scope.preset };
+        const route = this.#watchRoute(scope, authority.ownerRouteId);
+        if (rawInput === null || typeof rawInput !== 'object' || rawInput.ownerRouteId !== authority.ownerRouteId) {
+            throw new Error('assistant-skills: growth success input does not match authority');
+        }
+        const window = successWindow(rawInput);
+        const goalsApi = this.#goals();
+        if (typeof goalsApi.inspectOwnerVerifiedWorkflowSource !== 'function') {
+            throw new Error('assistant-skills: upgrade assistant-goals to use growth success deposit');
+        }
+        const signal = AbortSignal.any([exec.signal, this.#lifecycle.signal]);
+        // --- independent Host re-read of every model-suggested locator ---
+        const sources = await Promise.all(window.successes.map(async (locator) => {
+            const source = await goalsApi.inspectOwnerVerifiedWorkflowSource({ ownerRouteId: authority.ownerRouteId, principalId: scope.principalId, workspace: scope.workspace, preset: scope.preset,
+                sessionId: locator.sessionId, goalId: locator.goalId }, signal);
+            // The attestation must be for THIS exact owner scope, not a sibling route.
+            if (acceptanceDigest(source.scope) !== acceptanceDigest(scope)) {
+                throw new Error('assistant-skills: verified success source owner mismatch');
+            }
+            return { locator, source };
+        }));
+        // Distinct owner-root successes: different native Session AND business goal.
+        // The embedded source carries no cross-goal signature, so the repeat gate is
+        // a count of independently verified locators, never a model claim.
+        const distinct = new Map();
+        for (const item of sources) {
+            const sessionId = item.source.goal.sessionId;
+            if (sessionId !== item.locator.sessionId || item.source.goal.id !== item.locator.goalId) {
+                throw new Error('assistant-skills: verified success locator mismatch');
+            }
+            distinct.set(`${sessionId}
${item.locator.goalId}`, { sessionId, goalId: item.locator.goalId, source: item.source });
+        }
+        if (distinct.size < window.minimumOccurrences) {
+            throw new Error(`assistant-skills: only ${distinct.size} distinct verified successes; ${window.minimumOccurrences} required`);
+        }
+        // --- resolve the current parent; a retired name blocks any new deposit ---
+        const options = { name: rawInput.name, description: rawInput.description, ...(rawInput.bindings === undefined ? {} : { bindings: rawInput.bindings }) };
+        const activeParent = this.#store.get(scope, options.name);
+        const parentVersion = activeParent?.version ?? 0;
+        // Build the definition from ONE representative verified source; provenance
+        // below binds the full distinct-success set so the repeat evidence is durable.
+        const representative = [...distinct.values()].sort((left, right) => left.sessionId < right.sessionId ? -1 : left.sessionId > right.sessionId ? 1
+            : left.goalId < right.goalId ? -1 : left.goalId > right.goalId ? 1 : 0)[0];
+        const definition = this.#capturedDefinition(representative.source, options, scope);
+        // --- re-validate authority/route right before the write ---
+        authority.assertCurrent();
+        this.#watchRoute(scope, authority.ownerRouteId, route);
+        const provenance = Object.freeze({
+            protocol: 'assistant-skills/growth-success-provenance/v1',
+            ownerRouteId: authority.ownerRouteId,
+            distinctSuccessCount: distinct.size,
+            requiredCount: window.minimumOccurrences,
+            successes: [...distinct.values()]
+                .map(value => ({ sessionId: value.sessionId, goalId: value.goalId,
+                sourceDigest: acceptanceDigest(value.source), goalDefinitionDigest: value.source.goal.definition.digest,
+                runId: value.source.runId, acceptanceContractId: value.source.acceptance.contractId }))
+                .sort((left, right) => left.sourceDigest < right.sourceDigest ? -1 : left.sourceDigest > right.sourceDigest ? 1 : 0),
+        });
+        this.#authorize(exec.agent, 'draft', [scope, definition, parentVersion, acceptanceDigest(provenance)]);
+        // stageCandidate enforces retired/version conflict and pending idempotency.
+        // The distinct-success set is not stored in the failure-provenance slot
+        // (that shape is repair-specific); its digest is folded into trigger, which
+        // is part of the durable candidate identity formula, making the repeat
+        // evidence tamper-evident without a schema migration.
+        const provenanceDigest = acceptanceDigest(provenance);
+        const reason = `Host-verified autonomous growth deposit after ${distinct.size} independently owner-verified repeated successes.`;
+        const trigger = `growth-success:${distinct.size}:${provenanceDigest}`;
+        const candidate = this.#store.stageCandidate(scope, definition, {
+            expectedVersion: parentVersion, reason, trigger, expiresAt: Date.now() + this.#candidateTtl,
+        });
+        return this.#preview(scope, candidate);
+    }
     #preview(scope, candidate) {
         const parent = candidate.parentVersion ? this.#store.get(scope, candidate.definition.name, candidate.parentVersion) : undefined;
         return publicCandidate(candidate, parent);
@@ -949,6 +1150,142 @@ export class AssistantSkillsService extends Service {
         const candidate = this.#store.getCandidate(scope, id);
         return candidate ? this.#preview(scope, candidate) : null;
     }
+    /**
+     * Host-only read of the active current skills of a delivery-anchored owner
+     * scope.  The caller MUST first establish the scope through
+     * delivery.validateOwnerRoute (exact owner route); this enumeration consumes
+     * no live owner turn and exists for bounded background growth agents.  It is
+     * discovery-only and cannot write.
+     */
+    inspectOwnerActiveSkills(scope) {
+        if (!this.#active)
+            throw new Error('assistant-skills: inactive');
+        return this.#store.list(scope).map(publicDefinition);
+    }
+    /** Host-only read of every skill candidate of a delivery-anchored owner scope. */
+    inspectOwnerSkillCandidates(scope) {
+        if (!this.#active)
+            throw new Error('assistant-skills: inactive');
+        return this.#store.listCandidates(scope).map(candidate => this.#preview(scope, candidate));
+    }
+    #benchmarkSource(selection) {
+        if (!this.#active)
+            throw new Error('assistant-skills: benchmark source inactive');
+        this.#watchRoute(selection.scope, selection.ownerRouteId);
+        const policy = this.ctx.get('assistantPolicy', false);
+        if (policy?.evaluate({ ...this.#watchPolicy(selection.scope, 'watch'), action: 'compare' }).effect !== 'allow')
+            throw new Error('assistant-skills: benchmark comparison policy denied');
+        const candidate = selection.candidateId === undefined ? undefined : this.#pending(selection.scope, selection.candidateId);
+        const selected = candidate?.definition ?? this.#store.get(selection.scope, selection.skillName);
+        const version = candidate ? candidate.parentVersion + 1 : selected?.version;
+        if (!selected || selected.name !== selection.skillName || version !== selection.version
+            || acceptanceDigest(selected.source.scope) !== acceptanceDigest(selection.scope))
+            throw new Error('assistant-skills: exact benchmark source required');
+        const definition = benchmarkArmDefinition(selected);
+        const expiresAt = Math.min(definition.source.acceptance.validUntil, candidate?.expiresAt ?? Number.MAX_SAFE_INTEGER);
+        if (!Number.isSafeInteger(expiresAt) || expiresAt <= Date.now())
+            throw new Error('assistant-skills: benchmark source expired');
+        return { definition, definitionDigest: acceptanceDigest(definition), sourceDigest: acceptanceDigest(definition.source), version, expiresAt };
+    }
+    /** Re-read original Goals provenance before freezing an arm. This grants no execution authority. */
+    inspectOwnerBenchmarkArm = async (selection, signal) => {
+        selection = structuredClone(selection);
+        const combined = AbortSignal.any([this.#lifecycle.signal, AbortSignal.timeout(10000), ...(signal ? [signal] : [])]);
+        combined.throwIfAborted();
+        const before = this.#benchmarkSource(selection), goals = this.#goals(), generation = this.#benchmarkGeneration;
+        const route = this.#watchRoute(selection.scope, selection.ownerRouteId);
+        const source = await awaitBenchmarkSignal(goals.inspectOwnerVerifiedWorkflowSource({ ownerRouteId: selection.ownerRouteId,
+            principalId: selection.scope.principalId, workspace: selection.scope.workspace, preset: selection.scope.preset,
+            sessionId: before.definition.source.goal.sessionId, goalId: before.definition.source.goal.id }, combined), combined);
+        combined.throwIfAborted();
+        this.#watchRoute(selection.scope, selection.ownerRouteId, route);
+        if (this.#benchmarkGeneration !== generation || !sameBenchmarkArm(before, this.#benchmarkSource(selection))
+            || acceptanceDigest(source) !== before.sourceDigest)
+            throw new Error('assistant-skills: benchmark provenance changed');
+        return structuredClone(before);
+    };
+    /** Host-only, single-use delegation to one exact live recipient service and frozen cell. */
+    mintBenchmarkArm = async (input, signal) => {
+        const recipient = AssistantSkillsService.#benchmarkRecipients.get(input.recipient.benchmarkRecipientIdentity());
+        if (!recipient)
+            throw new Error('assistant-skills: unrecognized benchmark recipient');
+        const selection = structuredClone(input.selection), scope = structuredClone(input.recipientScope), binding = structuredClone(input.binding);
+        const recipientOwnerRouteId = input.recipientOwnerRouteId;
+        const snapshot = await this.inspectOwnerBenchmarkArm(selection, signal);
+        const route = this.#watchRoute(selection.scope, selection.ownerRouteId);
+        const recipientRoute = recipient.#watchRoute(scope, recipientOwnerRouteId);
+        if (recipient.#benchmarkIdentity === this.#benchmarkIdentity || !recipient.#active || binding.protocol !== 'assistant-skills/delegated-arm/v1'
+            || binding.definitionDigest !== snapshot.definitionDigest || binding.sourceDigest !== snapshot.sourceDigest
+            || binding.recipientScopeDigest !== acceptanceDigest(scope) || binding.skillName !== snapshot.definition.name || binding.version !== snapshot.version
+            || !Number.isSafeInteger(binding.expiresAt) || binding.expiresAt <= Date.now() || binding.expiresAt > snapshot.expiresAt
+            || binding.expiresAt - Date.now() > 300000)
+            throw new Error('assistant-skills: invalid benchmark delegation');
+        if (!/^[a-f0-9]{64}$/u.test(binding.planDigest) || !binding.cellId || !binding.variantId)
+            throw new Error('assistant-skills: invalid benchmark cell');
+        const cellKey = acceptanceDigest([binding.planDigest, binding.cellId]);
+        if (this.#issuedBenchmarkCells.has(cellKey))
+            throw new Error('assistant-skills: benchmark cell already delegated');
+        const authorization = { idempotencyKey: `skill-benchmark-${acceptanceDigest(binding)}` };
+        if (this.ctx.get('assistantPolicy', false)?.authorize({ ...this.#watchPolicy(selection.scope, 'watch'), action: 'compare' }, authorization).effect !== 'allow'
+            || recipient.ctx.get('assistantPolicy', false)?.authorize({ ...recipient.#watchPolicy(scope, 'watch'), action: 'compare' }, authorization).effect !== 'allow')
+            throw new Error('assistant-skills: benchmark comparison authorization denied');
+        const controller = new AbortController();
+        const combined = AbortSignal.any([controller.signal, this.#lifecycle.signal, recipient.#lifecycle.signal, ...(signal ? [signal] : [])]);
+        const assertCurrent = () => {
+            combined.throwIfAborted();
+            if (!recipient.#active || Date.now() >= binding.expiresAt || !sameBenchmarkArm(snapshot, this.#benchmarkSource(selection)))
+                throw new Error('assistant-skills: benchmark delegation unavailable');
+            this.#watchRoute(selection.scope, selection.ownerRouteId, route);
+            recipient.#watchRoute(scope, recipientOwnerRouteId, recipientRoute);
+            if (recipient.ctx.get('assistantPolicy', false)?.evaluate({ ...recipient.#watchPolicy(scope, 'watch'), action: 'compare' }).effect !== 'allow')
+                throw new Error('assistant-skills: recipient comparison policy denied');
+        };
+        assertCurrent();
+        const capability = Object.freeze({ protocol: 'assistant-skills/benchmark-capability/v1' });
+        AssistantSkillsService.#benchmarkCapabilities.set(capability, { recipient: recipient.#benchmarkIdentity, scope, binding, snapshot, controller, signal: combined, assertCurrent,
+            refresh: async (runSignal) => {
+                assertCurrent();
+                const current = await this.inspectOwnerBenchmarkArm(selection, AbortSignal.any([combined, runSignal]));
+                assertCurrent();
+                if (!sameBenchmarkArm(snapshot, current))
+                    throw new Error('assistant-skills: benchmark source changed');
+            }, consumed: false });
+        this.#issuedBenchmarkCells.add(cellKey);
+        this.#issuedBenchmarkArms.add(controller);
+        this.ctx.effect(() => {
+            const timer = setTimeout(() => controller.abort(), Math.max(1, binding.expiresAt - Date.now()));
+            timer.unref?.();
+            const stop = () => { clearTimeout(timer); this.#issuedBenchmarkArms.delete(controller); };
+            combined.addEventListener('abort', stop, { once: true });
+            return () => { combined.removeEventListener('abort', stop); stop(); controller.abort(); };
+        }, 'assistant-skills.benchmark-grant');
+        combined.addEventListener('abort', () => this.#issuedBenchmarkArms.delete(controller), { once: true });
+        return capability;
+    };
+    /** No definition is imported into the active/candidate tables; a restart cannot restore the authority. */
+    mountBenchmarkArm = async (capability, expected) => {
+        const grant = AssistantSkillsService.#benchmarkCapabilities.get(capability);
+        if (!grant || grant.consumed || grant.recipient !== this.#benchmarkIdentity || acceptanceDigest(expected) !== acceptanceDigest(grant.binding))
+            throw new Error('assistant-skills: unrecognized benchmark capability');
+        grant.consumed = true;
+        await grant.refresh(this.#lifecycle.signal);
+        grant.assertCurrent();
+        const scopeKey = acceptanceDigest(grant.scope);
+        if (this.#mountedBenchmarkArms.has(scopeKey))
+            throw new Error('assistant-skills: benchmark recipient already mounted');
+        this.#store.reserveDelegatedArm(grant.scope, grant.binding);
+        const bindingDigest = acceptanceDigest(grant.binding), now = Date.now();
+        const skill = { ...structuredClone(grant.snapshot.definition), version: grant.snapshot.version, parentVersion: null, retired: false, createdAt: now, updatedAt: now };
+        const arm = { binding: grant.binding, bindingDigest, skill, scope: grant.scope, signal: grant.signal, revoke: () => grant.controller.abort(), assertCurrent: grant.assertCurrent, refresh: grant.refresh };
+        this.#mountedBenchmarkArms.set(scopeKey, arm);
+        const dispose = this.ctx.effect(() => {
+            const timer = setTimeout(() => grant.controller.abort(), Math.max(1, grant.binding.expiresAt - Date.now()));
+            timer.unref?.();
+            return () => { clearTimeout(timer); grant.controller.abort(); if (this.#mountedBenchmarkArms.get(scopeKey) === arm)
+                this.#mountedBenchmarkArms.delete(scopeKey); };
+        }, 'assistant-skills.benchmark-arm');
+        return { binding: structuredClone(grant.binding), bindingDigest, skill: { name: skill.name, version: skill.version, inputs: structuredClone(skill.inputs) }, dispose };
+    };
     #pending(scope, id) {
         const candidate = this.#store.getCandidate(scope, id);
         if (!candidate || candidate.state !== 'pending' || candidate.expiresAt <= Date.now())
@@ -1034,6 +1371,15 @@ export class AssistantSkillsService extends Service {
             return false;
         }
     };
+    ownsOwnerAuthorizedRepairResume = (input, callback) => {
+        if (!this.ownsOwnerAuthorizedRepair(input, callback))
+            return false;
+        const record = this.#store.getRepairContinuation(input.scope, input.authorizationId);
+        const repair = record?.checkpoint.repair;
+        return !!record && ['repairing', 'repair-achieved', 'capturing', 'candidate-staged', 'comparing', 'watching'].includes(record.state)
+            && repair?.sessionId === input.repair.sessionId && repair.goalId === input.repair.goalId
+            && this.#repairAgents?.ownsResume(input, callback) === true;
+    };
     #repairProfileAt(record, iteration) {
         const entry = record.authorization.profileSequence?.[iteration - 1]
             ?? (iteration === 1 ? { id: record.authorization.profileId, digest: record.authorization.profileDigest } : undefined);
@@ -1044,6 +1390,20 @@ export class AssistantSkillsService extends Service {
         return profile;
     }
     #repairProfile(record) { return this.#repairProfileAt(record, record.iteration); }
+    /**
+     * New authorizations persist this exact route.  Legacy records predate the
+     * field, so they may run only when their still-digest-bound profile supplied
+     * an explicit pair; inherited routes must never be selected again on resume.
+     */
+    #repairModelSelection(record) {
+        const frozen = record.authorization.modelSelection;
+        if (frozen)
+            return frozen;
+        const primary = this.#repairProfileAt(record, 1);
+        if (primary.provider !== undefined && primary.model !== undefined)
+            return { provider: primary.provider, model: primary.model };
+        throw new Error('assistant-skills: legacy inherited repair model selection unavailable');
+    }
     #repairSource(record) {
         if (record.iteration === 1)
             return record.authorization.source;
@@ -1144,6 +1504,14 @@ export class AssistantSkillsService extends Service {
         if (!this.#repairRuntime || !profile || !holdout?.profile.canaryAdmissionTemplate || !Number.isSafeInteger(input.expiresAt)
             || input.expiresAt <= Date.now() || input.expiresAt > Math.min(holdout.profile.execution.expiresAt, Date.now() + 604800000))
             throw new Error('assistant-skills: finite current repair profile required');
+        const selected = profile.provider === undefined
+            ? this.ctx.get('assistantDelivery', false)?.inspectOwnerModelSelection({ authorityId: input.ownerRouteId, principalId: scope.principalId,
+                workspace: scope.workspace, agentPreset: scope.preset, sourceAgent: agent })
+            : { provider: profile.provider, model: profile.model };
+        if (!repairModelRoute(selected))
+            throw new Error('assistant-skills: exact current repair model selection required');
+        const modelSelection = { provider: selected.provider, model: selected.model,
+            ...(selected.reasoningEffort === undefined ? {} : { reasoningEffort: selected.reasoningEffort }) };
         const parent = this.#store.get(scope, profile.skillName);
         const sessionId = input.sessionId ?? String(agent.session.id);
         const snapshot = this.#goals().inspectOwnerGoalExecution({ ownerRouteId: input.ownerRouteId, principalId: scope.principalId, workspace: scope.workspace, preset: scope.preset, sessionId, goalId: input.goalId });
@@ -1155,7 +1523,8 @@ export class AssistantSkillsService extends Service {
         const profileSequence = sequenceIds.map(id => {
             const next = this.#repairProfiles.find(value => value.id === id && acceptanceDigest(value.scope) === acceptanceDigest(scope));
             const nextHoldout = next && this.inspectRepairProfile(next.externalHoldoutProfileId, scope);
-            if (!next || !nextHoldout || next.skillName !== profile.skillName || next.provider !== profile.provider || next.model !== profile.model
+            if (!next || !nextHoldout || next.skillName !== profile.skillName
+                || next.provider !== undefined && (next.provider !== modelSelection.provider || next.model !== modelSelection.model)
                 || next.allowedTools.some(tool => !profile.allowedTools.includes(tool)) || next.maxOutputTokens > profile.maxOutputTokens || next.maxGoalRounds > profile.maxGoalRounds || next.maxDurationMs > profile.maxDurationMs
                 || input.expiresAt > nextHoldout.profile.execution.expiresAt)
                 throw new Error('assistant-skills: followup profile exceeds the frozen repair authority');
@@ -1176,7 +1545,7 @@ export class AssistantSkillsService extends Service {
         const authorization = { invocationId: input.invocationId, ownerRouteId: input.ownerRouteId,
             source: { goalId: input.goalId, sessionId, nativeGoalId: snapshot.storedGoal.nativeAtLastObservation.goalId, definitionDigest: snapshot.storedGoal.definition.digest },
             profileId: profile.id, profileDigest: acceptanceDigest([profile, holdout.digest]), skillName: profile.skillName,
-            parentVersion: parent.version, parentDigest: acceptanceDigest(parent), maxIterations: profile.maxIterations ?? 1, expiresAt: input.expiresAt,
+            parentVersion: parent.version, parentDigest: acceptanceDigest(parent), maxIterations: profile.maxIterations ?? 1, expiresAt: input.expiresAt, modelSelection,
             ...(profileSequence.length > 1 ? { profileSequence } : {}), ...(feedbackAuthority ? { feedbackAuthority } : {}) };
         for (const action of ['draft', 'compare', 'canary', 'watch']) {
             this.#scope(agent, action);
@@ -1268,9 +1637,21 @@ export class AssistantSkillsService extends Service {
             }
         }).catch(() => undefined).finally(() => { this.#repairTask = undefined; });
     }
+    #repairAgentInput(record, trigger) {
+        const profile = this.#repairProfile(record), primary = this.#repairProfileAt(record, 1);
+        const modelSelection = this.#repairModelSelection(record);
+        const usage = this.#store.repairUsage(record.scope, record.id);
+        const callback = () => this.#assertRepair(record);
+        this.#repairAssertions.set(record.id, { callback, triggerDigest: acceptanceDigest(trigger) });
+        return { ...profile, ...modelSelection, id: record.id, iteration: record.iteration, maxModelCalls: primary.maxModelCalls, maxToolCalls: primary.maxToolCalls,
+            initialModelCalls: usage.modelCalls, initialToolCalls: usage.toolCalls,
+            recordUsage: kind => { this.#store.chargeRepairUsage(record.scope, record.id, kind, kind === 'model' ? primary.maxModelCalls : primary.maxToolCalls); },
+            authorizationDigest: record.authorizationDigest, ownerRouteId: record.authorization.ownerRouteId,
+            trigger, objective: trigger.taskFamily.objective, expiresAt: record.authorization.expiresAt, assertCurrent: callback };
+    }
     #installRepairRuntime(ctx) {
         ctx.inject(['tools', 'agents', 'sessions', 'llm', 'systemPrompt', 'assistantGoals', 'assistantPolicy', 'assistantDelivery', 'assistantVerifier'], runtime => {
-            const agents = new OwnerRepairAgentRuntime(runtime);
+            const agents = new OwnerRepairAgentRuntime(runtime, this.#store);
             const driver = new RepairContinuationRuntime(this.#store, {
                 assertCurrent: record => this.#assertRepair(record),
                 inspectTrigger: async (record, signal) => {
@@ -1281,14 +1662,18 @@ export class AssistantSkillsService extends Service {
                     return this.#goals().inspectOwnerFailureTrigger({ ownerRouteId: locator.ownerRouteId, principalId: locator.principalId, workspace: locator.workspace, preset: locator.preset, taskFamilyId: profile.taskFamilyId, failures: [{ goalId: locator.goalId, sessionId: locator.sessionId }], minimumOccurrences: 1 }, signal);
                 },
                 createRepair: async (record, evidence, signal) => {
-                    const profile = this.#repairProfile(record), primary = this.#repairProfileAt(record, 1), trigger = evidence;
-                    const usage = this.#store.repairUsage(record.scope, record.id);
-                    const callback = () => this.#assertRepair(record);
-                    this.#repairAssertions.set(record.id, { callback, triggerDigest: acceptanceDigest(trigger) });
-                    return agents.create({ ...profile, id: record.id, iteration: record.iteration, maxModelCalls: primary.maxModelCalls, maxToolCalls: primary.maxToolCalls,
-                        initialModelCalls: usage.modelCalls, initialToolCalls: usage.toolCalls,
-                        recordUsage: kind => { this.#store.chargeRepairUsage(record.scope, record.id, kind, kind === 'model' ? primary.maxModelCalls : primary.maxToolCalls); }, authorizationDigest: record.authorizationDigest, ownerRouteId: record.authorization.ownerRouteId,
-                        trigger, objective: trigger.taskFamily.objective, expiresAt: record.authorization.expiresAt, assertCurrent: callback }, signal);
+                    return agents.create(this.#repairAgentInput(record, evidence), signal);
+                },
+                ensureRepair: async (record, signal) => {
+                    const locator = this.#repairLocator(record, true);
+                    if (agents.get(locator.sessionId))
+                        return;
+                    const snapshot = this.#goals().inspectOwnerGoalExecution(locator);
+                    const stored = snapshot.storedGoal;
+                    await agents.resume(this.#repairAgentInput(record, record.checkpoint.trigger), {
+                        sessionId: locator.sessionId, goalId: locator.goalId, nativeGoalId: stored.nativeAtLastObservation.goalId,
+                        definitionDigest: stored.definition.digest,
+                    }, signal);
                 },
                 inspectRepair: async (record, signal) => {
                     const locator = this.#repairLocator(record, true), snapshot = this.#goals().inspectOwnerGoalExecution(locator);
@@ -1361,14 +1746,9 @@ export class AssistantSkillsService extends Service {
             this.#repairAgents = agents;
             this.#repairRuntime = driver;
             for (const record of this.#store.listRepairContinuations()) {
-                // An in-flight native repair cannot be recreated from a cached transcript.
-                // Until its Agent can be reacquired with verified quiescence, surface the
-                // interruption immediately rather than leaving it "running" until expiry.
-                if (['repairing', 'repair-achieved', 'candidate-staged'].includes(record.state)) {
-                    this.#store.transitionRepairContinuation(record.scope, record.id, record.revision, 'unknown', { ...record.checkpoint, failure: 'repair-agent-interrupted' });
-                }
-                else
-                    driver.recover(record.scope, record.id);
+                // Dispatches without a durable result are not replayable. Existing
+                // repair Sessions are reattached by ensureRepair under their fence.
+                driver.recover(record.scope, record.id);
             }
             runtime.tools.register(defineTool({ name: 'skill_repair_arm', description: 'Authorize a bounded autonomous repair sequence starting from an exact owner Goal using configured profiles. After independent failure evidence, a separate native Goal synthesizes a repair; only independent acceptance and prospective comparison can deploy a finite canary. Requires the current human request. Followups require the frozen profile sequence and a new independently failed task after promotion; budgets and expiry cannot be renewed.',
                 parameters: { goal_id: { type: 'string', required: true, description: businessGoalId }, source_session_id: { type: 'string' }, profile_id: { type: 'string', required: true }, owner_route_id: { type: 'string', required: true }, invocation_id: { type: 'string', required: true }, expires_at: { type: 'integer', required: true }, notify: { type: 'boolean', description: 'Send finite repair results to this exact current owner route Session.' } }, output,
@@ -1721,14 +2101,41 @@ export class AssistantSkillsService extends Service {
     }
     async run(exec, goalId, name, version, inputs, invocationId) {
         const scope = this.#scope(exec.agent, 'run');
+        const delegated = this.#mountedBenchmarkArms.get(acceptanceDigest(scope));
+        if (delegated) {
+            delegated.assertCurrent();
+            if (delegated.skill.name !== name || delegated.skill.version !== version)
+                throw new Error('assistant-skills: exact delegated arm required');
+            const task = this.#run(exec, goalId, delegated.skill, inputs, invocationId, undefined, delegated);
+            this.#benchmarkRuns.add(task);
+            try {
+                return await task;
+            }
+            finally {
+                this.#benchmarkRuns.delete(task);
+            }
+        }
         const skill = this.#store.get(scope, name);
         if (!skill || skill.retired || skill.version !== version)
             throw new Error('assistant-skills: active skill version required');
         return this.#run(exec, goalId, skill, inputs, invocationId);
     }
-    async #run(exec, goalId, skill, inputs, invocationId, candidateId) {
+    async #run(exec, goalId, skill, inputs, invocationId, candidateId, delegated) {
         const action = candidateId ? 'trial' : 'run';
         const scope = this.#scope(exec.agent, action), { name, version } = skill;
+        const assertDelegated = () => {
+            if (!delegated)
+                return;
+            delegated.assertCurrent();
+            if (this.#mountedBenchmarkArms.get(acceptanceDigest(scope)) !== delegated
+                || acceptanceDigest(benchmarkArmDefinition(skill)) !== delegated.binding.definitionDigest)
+                throw new Error('assistant-skills: delegated arm changed');
+        };
+        assertDelegated();
+        if (delegated) {
+            await delegated.refresh(exec.signal);
+            assertDelegated();
+        }
         const definition = instantiate(skill, inputs);
         const steps = definition.steps;
         // These declarations are part of the immutable saved definition, rather
@@ -1766,8 +2173,9 @@ export class AssistantSkillsService extends Service {
             const tool = candidateId ? 'skill_trial' : 'skill_run';
             return { state: 'awaiting-native-round', performed: false, context: 'No skill step or durable invocation has been claimed or executed; this is not a queued background task.', next: `After the Host starts this Goal's native round, call ${tool} again with this same goal, skill or candidate, inputs, and invocation_id.`, goalId, ...(candidateId ? { candidateId } : {}), skillName: name, version, invocationId, inputs };
         }
-        if (acceptanceDigest(scope) !== acceptanceDigest(current.scope) || goalId === skill.source.goal.id)
-            throw new Error('assistant-skills: fresh owner Goal required');
+        // Consume the typed precondition family rather than an ad-hoc condition so
+        // an unknown/tampered declaration fails closed before a run is claimed.
+        evaluatePreconditions(skill.preconditions, { ownerScopeDigest: acceptanceDigest(scope), currentScopeDigest: acceptanceDigest(current.scope), goalId, sourceGoalId: skill.source.goal.id });
         const identity = acceptanceDigest(current);
         const goalContext = current;
         // claim() reconciles a deployed version while holding its transaction.  Do
@@ -1793,7 +2201,9 @@ export class AssistantSkillsService extends Service {
                 throw new Error('assistant-skills: deployment authority ended');
             }
         }
-        const claim = this.#store.claim(scope, { invocationId, goalId, sessionId: current.sessionId, skillName: name, version, inputs, goalExecutionRunId: current.goalExecutionRunId, goalDefinitionDigest: current.definition.digest, ...(typeof goalContext.nativeGoalId === 'string' ? { nativeGoalId: goalContext.nativeGoalId } : {}), ...(candidateId ? { candidateId } : {}) });
+        assertDelegated();
+        const claimInput = { invocationId, goalId, sessionId: current.sessionId, skillName: name, version, inputs, goalExecutionRunId: current.goalExecutionRunId, goalDefinitionDigest: current.definition.digest, ...(typeof goalContext.nativeGoalId === 'string' ? { nativeGoalId: goalContext.nativeGoalId } : {}), ...(candidateId ? { candidateId } : {}) };
+        const claim = delegated ? this.#store.claimDelegated(scope, claimInput, delegated.bindingDigest) : this.#store.claim(scope, claimInput);
         if (!claim.claimed) {
             if (claim.run.state !== 'succeeded')
                 throw new Error(`assistant-skills: invocation ${claim.run.id} is ${claim.run.state}; inspect skill_status, do not replay`);
@@ -1819,18 +2229,25 @@ export class AssistantSkillsService extends Service {
         const timeout = new AbortController();
         const timer = setTimeout(() => timeout.abort(), this.#duration);
         timer.unref?.();
-        const signal = AbortSignal.any([exec.signal, timeout.signal, this.#lifecycle.signal, ...(deploymentRevision ? [deploymentRevision.signal] : [])]);
+        const signal = AbortSignal.any([exec.signal, timeout.signal, this.#lifecycle.signal, ...(delegated ? [delegated.signal] : []), ...(deploymentRevision ? [deploymentRevision.signal] : [])]);
+        const settle = (work) => delegated ? awaitBenchmarkSignal(work, signal) : work;
         const completed = [];
         let state = 'unknown';
         let dispatched = false;
+        // Resolve the compensation family up front; an unsupported/tampered value
+        // fails closed before any step is dispatched.
+        const compensation = compensationDirective(definition.compensation);
         const revalidate = () => {
             signal.throwIfAborted();
+            assertDelegated();
             if (acceptanceDigest(this.#scope(exec.agent, action)) !== acceptanceDigest(scope)
                 || acceptanceDigest(this.#goals().inspectWorkflowRunContext(exec.agent, goalId)) !== identity)
                 throw new Error('assistant-skills: current authority changed');
             if (this.#store.getRun(scope, claim.run.id)?.state !== 'running')
                 throw new Error('assistant-skills: invocation no longer owns dispatch');
-            if (candidateId)
+            if (delegated)
+                assertDelegated();
+            else if (candidateId)
                 this.#pending(scope, candidateId);
             else {
                 const live = this.#store.get(scope, name);
@@ -1849,11 +2266,13 @@ export class AssistantSkillsService extends Service {
                 for (const observation of observations) {
                     if (observation.beforeStepId !== step.id)
                         continue;
+                    if (delegated)
+                        await delegated.refresh(signal);
                     revalidate();
                     if (!this.#allowed.includes('read'))
                         throw new Error('assistant-skills: current tool allowlist denied required file observation');
                     dispatched = true;
-                    const observed = await exec.agent.ctx.get('tools').execute({
+                    const observed = await settle(exec.agent.ctx.get('tools').execute({
                         callId: ToolCallId(`${exec.callId}:skill-observation:${index + 1}`),
                         rootCallId: exec.rootCallId,
                         parent: exec.token,
@@ -1861,7 +2280,9 @@ export class AssistantSkillsService extends Service {
                         name: 'read',
                         arguments: { file_path: observation.filePath, limit: 1 },
                         signal,
-                    });
+                    }));
+                    if (delegated)
+                        await delegated.refresh(signal);
                     revalidate();
                     for (const context of observed.additionalContexts ?? [])
                         exec.deferContext(context);
@@ -1883,14 +2304,29 @@ export class AssistantSkillsService extends Service {
                         state = 'failed';
                         break stepsLoop;
                     }
+                    if (delegated)
+                        await delegated.refresh(signal);
                     revalidate();
                     dispatched = false;
                 }
+                if (delegated)
+                    await delegated.refresh(signal);
                 revalidate();
+                // Dependency DAG gate: every declared predecessor must have completed
+                // successfully. Topological storage means a missing predecessor can only
+                // result from an earlier failure, at which point the resolved compensation
+                // family stops the remaining steps (the v1 family always does).
+                const succeededById = new Set(completed.filter(entry => entry.state === 'succeeded').map(entry => entry.id));
+                if (compensation.stopRemainingSteps && step.dependsOn.some(dependency => !succeededById.has(dependency))) {
+                    state = 'failed';
+                    break stepsLoop;
+                }
                 if (!this.#allowed.includes(step.toolName))
                     throw new Error('assistant-skills: current tool allowlist denied');
                 dispatched = true;
-                const result = await exec.agent.ctx.get('tools').execute({ callId: ToolCallId(`${exec.callId}:skill:${index + 1}`), rootCallId: exec.rootCallId, parent: exec.token, agent: exec.agent, name: step.toolName, arguments: step.arguments, signal });
+                const result = await settle(exec.agent.ctx.get('tools').execute({ callId: ToolCallId(`${exec.callId}:skill:${index + 1}`), rootCallId: exec.rootCallId, parent: exec.token, agent: exec.agent, name: step.toolName, arguments: step.arguments, signal }));
+                if (delegated)
+                    await delegated.refresh(signal);
                 revalidate();
                 for (const context of result.additionalContexts ?? [])
                     exec.deferContext(context);
@@ -1903,6 +2339,8 @@ export class AssistantSkillsService extends Service {
                 }
                 if (result.concludesTurn)
                     exec.concludeTurn();
+                if (delegated)
+                    await delegated.refresh(signal);
                 revalidate();
                 dispatched = false;
                 if (index === steps.length - 1)