@caupulican/pi-adaptative 0.81.41 → 0.81.43

package/dist/core/delegation/worker-delegation-controller.js

@@ -1,45 +1,60 @@
-import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { getPrivateLaneDeniedPaths } from "../autonomy/lane-private-paths.js";
 import { createLaneToolSurface } from "../autonomy/lane-tool-surface.js";
-import { safeRealpathSync } from "../autonomy/path-scope.js";
 import { appendLaneRecordSnapshot } from "../autonomy/session-lane-record.js";
-import { composeSubagentSystemPrompt } from "../autonomy/subagent-prompt.js";
 import { AUTONOMY_TELEMETRY_EVENT_TYPES } from "../autonomy/telemetry-events.js";
 import { deriveModelCapabilityProfile } from "../model-capability.js";
+import { isLoopbackModelEndpoint } from "../models/model-endpoint.js";
+import { providerUsageFromAttemptUsage } from "../orchestration/attempt-usage.js";
 import { createWorkerExecutionContract, verifierWorkerExecutionContract, } from "../orchestration/worker-execution-contract.js";
-import { createWorkerResultContract } from "../orchestration/worker-result-adapter.js";
 import { registerInFlightWork } from "../reload-blockers.js";
 import { applyWorkerActions } from "./worker-actions.js";
+import { WorkerAgentControlCoordinator } from "./worker-agent-control-coordinator.js";
+import { createWorkerAttemptExecutor } from "./worker-attempt-executor.js";
+import { WorkerConversationStore, } from "./worker-conversation-store.js";
 import { WorkerDispatchScheduler } from "./worker-dispatch-scheduler.js";
 import { buildWorkerExecutionPlan, compileWorkerExecutionGrant, narrowWorkerExecutionPlan, workerExecutionAuthorityFromPlan, } from "./worker-execution-policy.js";
+import { createLocalWorkerProcessOwnerId } from "./worker-process-owner.js";
 import { WorkerProfileResolver } from "./worker-profile-resolver.js";
-import { runWorker } from "./worker-runner.js";
+import { WorkerRecoveryCoordinator } from "./worker-recovery-coordinator.js";
+import { selectWorkerResourcePointers } from "./worker-resource-catalog.js";
+import { materializeWorkerResourceBundle } from "./worker-resource-materializer.js";
+import { finalizeWorkerClaim } from "./worker-terminal-finalizer.js";
+import { WorkerWriteReservationCoordinator } from "./worker-write-reservation-coordinator.js";
 export function isLocalExecutionModel(model) {
     if (model.provider === "ollama" || model.provider === "transformers" || model.provider === "llama-cpp") {
         return true;
     }
-    try {
-        const hostname = new URL(model.baseUrl).hostname.toLowerCase();
-        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
-    }
-    catch {
-        return false;
-    }
+    return isLoopbackModelEndpoint(model.baseUrl);
+}
+function workerConversationRetentionPolicy(model, settingsManager) {
+    const settings = settingsManager.getCompactionSettings();
+    const contextWindow = Math.floor(model.contextWindow ?? 0);
+    if (!settings.enabled || contextWindow < 4)
+        return undefined;
+    const reserveTokens = Math.min(settings.reserveTokens, Math.floor(contextWindow * 0.25));
+    const reserveTrigger = contextWindow - reserveTokens;
+    const fractionalTrigger = settings.triggerPercent > 0 && settings.triggerPercent < 1
+        ? Math.floor(contextWindow * settings.triggerPercent)
+        : reserveTrigger;
+    const modelTrigger = model.autoCompactionTriggerTokens && model.autoCompactionTriggerTokens > 0
+        ? Math.floor(model.autoCompactionTriggerTokens)
+        : reserveTrigger;
+    const maxContextTokens = Math.min(reserveTrigger, fractionalTrigger, modelTrigger);
+    if (maxContextTokens < 2)
+        return undefined;
+    return {
+        maxContextTokens,
+        keepRecentTokens: Math.max(1, Math.min(settings.keepRecentTokens, Math.floor(contextWindow * 0.5), maxContextTokens - 1)),
+    };
 }
 export class WorkerDelegationController {
-    deps;
-    workerAbort = new AbortController();
-    lifecycle;
-    profileResolver;
-    queueRecovered = false;
-    recoveringDurableState = false;
-    verificationRecoveryFailures = new Map();
-    notifications;
-    scheduler;
-    laneAbortControllers = new Map();
-    publishedTerminalAttemptIds = new Set();
-    inFlightLedgers = new Map();
     constructor(deps, notifications, lifecycle) {
+        this.workerAbort = new AbortController();
+        this.laneAbortControllers = new Map();
+        this.publishedTerminalAttemptIds = new Set();
+        this.conversations = new WorkerConversationStore();
+        this.inFlightLedgers = new Map();
         this.deps = deps;
         this.notifications = notifications;
         this.lifecycle = lifecycle;
@@ -51,6 +66,7 @@ export class WorkerDelegationController {
             run: (request, record) => this.runOnce(request, undefined, record),
             cancel: (laneId, reasonCode) => {
                 try {
+                    this.writeReservations.release(laneId);
                     const terminal = this.getWorkerLifecycle().cancel(laneId, reasonCode);
                     if (terminal)
                         this.publishTerminalRecord(terminal);
@@ -61,6 +77,45 @@ export class WorkerDelegationController {
             },
             warn: (message) => this.safeWarn(message),
         });
+        this.recovery = new WorkerRecoveryCoordinator({
+            lifecycle: this.lifecycle,
+            scheduler: this.scheduler,
+            recoverWriteReservations: () => this.writeReservations.recoverProvenStale(),
+            publishTerminalRecord: (record) => this.publishTerminalRecord(record),
+            dispatchVerification: (recovery) => this.dispatchRecoveredVerification(recovery),
+            warn: (message) => this.safeWarn(message),
+        });
+        this.agentControl = new WorkerAgentControlCoordinator({
+            agentDir: this.deps.getAgentDir(),
+            parentSessionId: this.deps.getSessionId(),
+            processOwnerId: createLocalWorkerProcessOwnerId(process.pid, randomUUID()),
+            isControlAvailable: () => this.deps.isDelegateToolActive(),
+            getLifecycle: () => this.getWorkerLifecycle(),
+            recoveredRequest: (attempt) => this.recovery.recoveredRequest(attempt),
+            run: (request, record) => this.runOnce(request, undefined, record),
+            scheduler: this.scheduler,
+            statusChanged: () => this.notifications.statusChanged(),
+            abortLane: (laneId, reasonCode) => this.laneAbortControllers.get(laneId)?.abort(reasonCode),
+            cancelLane: (laneId, reasonCode) => {
+                this.scheduler.dropQueued(laneId);
+                this.writeReservations.release(laneId);
+                const terminal = this.getWorkerLifecycle().cancel(laneId, reasonCode);
+                if (terminal)
+                    this.publishTerminalRecord(terminal);
+                return terminal;
+            },
+        });
+        this.writeReservations = new WorkerWriteReservationCoordinator({
+            agentDir: this.deps.getAgentDir(),
+            getCwd: () => this.deps.getCwd(),
+            getParentSessionId: () => this.deps.getSessionId(),
+            ownerId: this.agentControl.getProcessOwnerId(),
+            drainQueuedWorkers: () => {
+                if (!this.deps.isDisposed())
+                    this.scheduler.drain(true);
+            },
+            warn: (message) => this.safeWarn(message),
+        });
     }
     safeWarn(message) {
         try {
@@ -70,6 +125,14 @@ export class WorkerDelegationController {
             // Disposal and recovery diagnostics must never throw.
         }
     }
+    /** Narrow model-facing control port. It owns control state; this controller only composes it. */
+    getAgentControl() {
+        return this.agentControl;
+    }
+    /** The coordinator's process identity is also the durable execution lease owner. */
+    getAgentControlProcessOwnerId() {
+        return this.agentControl.getProcessOwnerId();
+    }
     recordTerminal(record) {
         if (record.status === "queued" || record.status === "running")
             return;
@@ -86,7 +149,7 @@ export class WorkerDelegationController {
     }
     getRecords() {
         if (this.deps.isDelegateToolActive?.())
-            this.recoverDurableQueue();
+            this.recovery.recover();
         return this.lifecycle.getRecords();
     }
     /** Process-local worker records for the shared terminal notifier; never triggers durable recovery. */
@@ -98,10 +161,18 @@ export class WorkerDelegationController {
     }
     abort() {
         this.workerAbort.abort();
+        // Bound attempts have an authoritative transcript and agent identity. A normal owner-session
+        // shutdown is an execution interruption, not an explicit worker cancellation: fence it into
+        // suspended state before the abort continuation can observe the signal.
+        const suspendedAttemptIds = new Set(this.lifecycle.suspendBoundInProcessAttemptsForRestart(this.agentControl.getProcessOwnerId()));
         for (const record of this.lifecycle.getRecords()) {
             if (record.status !== "queued" && record.status !== "running")
                 continue;
             const ledger = this.inFlightLedgers.get(record.laneId);
+            if (ledger && suspendedAttemptIds.has(ledger.handle.attemptId)) {
+                this.inFlightLedgers.delete(record.laneId);
+                continue;
+            }
             if (!ledger) {
                 try {
                     const canceled = this.lifecycle.cancel(record.laneId, "session_disposed");
@@ -116,7 +187,8 @@ export class WorkerDelegationController {
             }
             this.inFlightLedgers.delete(record.laneId);
             try {
-                const spend = ledger.getSpend();
+                const usage = ledger.getUsage();
+                const reportedUsage = providerUsageFromAttemptUsage(usage);
                 const reportId = `worker:${this.deps.getSessionId()}:${record.laneId}`;
                 const claim = {
                     requestId: ledger.request.id,
@@ -126,31 +198,24 @@ export class WorkerDelegationController {
                     usageReportId: reportId,
                     createdAt: new Date().toISOString(),
                 };
-                const canceled = this.getWorkerLifecycle().finish(createWorkerResultContract({
+                const canceled = finalizeWorkerClaim(this.getWorkerLifecycle(), {
                     handle: ledger.handle,
                     claim,
                     accepted: false,
-                    costUsd: spend?.cost.total ?? 0,
+                    costUsd: usage.costUsd,
                     cwd: this.deps.getCwd(),
-                    ...(spend
-                        ? {
-                            inputTokens: spend.input,
-                            outputTokens: spend.output,
-                            totalTokens: spend.totalTokens,
-                        }
-                        : {}),
-                    wallClockMs: Date.now() - ledger.startedAt,
-                    toolCalls: ledger.getToolCalls(),
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    totalTokens: reportedUsage.totalTokens,
+                    wallClockMs: usage.activeWallClockMs,
+                    toolCalls: usage.toolCalls,
                     reasonCode: "session_disposed",
-                }));
+                }).record;
                 this.publishTerminalRecord(canceled);
-                // Bounded honesty: spend may be incomplete (it lands only when the isolated completion
-                // returns, which a mid-flight abort preempts) — record what `getSpend()` knows. Same
-                // deterministic reportId scheme as the normal path, so a later duplicate report (there
-                // is none in practice here, since the lane is now terminal) stays idempotent.
+                // The terminal result and owner usage report share the same fenced cumulative snapshot.
                 this.deps.saveWorkerClaimSnapshot(claim, ledger.request);
-                if (spend && (spend.cost.total > 0 || spend.totalTokens > 0)) {
-                    this.deps.addSpawnedUsage(spend, { label: "worker-delegation", reportId });
+                if (reportedUsage.cost.total > 0 || reportedUsage.totalTokens > 0) {
+                    this.deps.addSpawnedUsage(reportedUsage, { label: "worker-delegation", reportId });
                 }
             }
             catch (error) {
@@ -158,6 +223,7 @@ export class WorkerDelegationController {
             }
         }
         this.scheduler.cancelQueued();
+        this.writeReservations.dispose();
     }
     getWorkerLifecycle() {
         return this.lifecycle;
@@ -169,6 +235,7 @@ export class WorkerDelegationController {
             agentDir: this.deps.getAgentDir(),
             cwd: this.deps.getCwd(),
             getSettingsManager: () => this.deps.getSettingsManager(),
+            getResourceLoader: () => this.deps.getResourceLoader(),
             getModelRegistry: () => this.deps.getModelRegistry(),
             isModelExhausted: (model) => this.deps.isModelExhausted(model),
             getActiveOrchestrationProfile: () => this.deps.getActiveOrchestrationProfile?.(),
@@ -191,66 +258,23 @@ export class WorkerDelegationController {
             this.publishTerminalRecord(record);
         }
     }
-    recoverDurableQueue() {
-        if (this.recoveringDurableState)
-            return;
-        this.recoveringDurableState = true;
-        const lifecycle = this.getWorkerLifecycle();
-        try {
-            if (!this.queueRecovered) {
-                for (const { attempt, record, verificationOfTaskId } of lifecycle.recoverQueued()) {
-                    const request = {
-                        instructions: attempt.dispatch.instructions,
-                        profileId: attempt.dispatch.profileId,
-                        ...(verificationOfTaskId ? { verificationOfTaskId } : {}),
-                    };
-                    this.scheduler.enqueue(record, request, true, verificationOfTaskId !== undefined);
-                }
-                this.queueRecovered = true;
-            }
-            for (const recovery of lifecycle.getPendingVerificationRecoveries()) {
-                if (recovery.action === "reconcile") {
-                    try {
-                        this.publishTerminalRecord(lifecycle.reconcileVerification(recovery));
-                        this.verificationRecoveryFailures.delete(recovery.subjectTaskId);
-                    }
-                    catch (error) {
-                        this.safeWarn(`Failed to reconcile recovered verification for ${recovery.subjectTaskId}: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                    continue;
-                }
-                const legacyImplementation = recovery.verifierExecutionContract
-                    ? undefined
-                    : this.resolveWorkerAdmission({
-                        instructions: recovery.summary,
-                        profileId: recovery.implementationProfileId,
-                    });
-                const verifierProfileId = recovery.verifierExecutionContract?.worker.profile.profileId ??
-                    (legacyImplementation?.ok ? legacyImplementation.verifierShipment?.profile.profileId : undefined);
-                const started = verifierProfileId
-                    ? this.startInternal(this.buildVerifierRequest({
-                        subjectTaskId: recovery.subjectTaskId,
-                        verifierProfileId,
-                        summary: recovery.summary,
-                        artifactUris: recovery.artifactUris,
-                    }), recovery.verifierExecutionContract)
-                    : { started: false, skipReason: "independent_verifier_unavailable" };
-                if (started.started) {
-                    this.verificationRecoveryFailures.delete(recovery.subjectTaskId);
-                    continue;
-                }
-                if (this.verificationRecoveryFailures.get(recovery.subjectTaskId) !== started.skipReason) {
-                    this.verificationRecoveryFailures.set(recovery.subjectTaskId, started.skipReason);
-                    this.safeWarn(`Recovered verification for ${recovery.subjectTaskId} did not start: ${started.skipReason}`);
-                }
-            }
-            for (const notification of lifecycle.getPendingTerminalNotifications()) {
-                this.notifications.recordTerminal(notification.record, notification.notificationId);
-            }
-        }
-        finally {
-            this.recoveringDurableState = false;
-        }
+    dispatchRecoveredVerification(recovery) {
+        const legacyImplementation = recovery.verifierExecutionContract
+            ? undefined
+            : this.resolveWorkerAdmission({
+                instructions: recovery.summary,
+                profileId: recovery.implementationProfileId,
+            });
+        const verifierProfileId = recovery.verifierExecutionContract?.worker.profile.profileId ??
+            (legacyImplementation?.ok ? legacyImplementation.verifierShipment?.profile.profileId : undefined);
+        return verifierProfileId
+            ? this.startInternal(this.buildVerifierRequest({
+                subjectTaskId: recovery.subjectTaskId,
+                verifierProfileId,
+                summary: recovery.summary,
+                artifactUris: recovery.artifactUris,
+            }), recovery.verifierExecutionContract)
+            : { started: false, skipReason: "independent_verifier_unavailable" };
     }
     laneCapabilityProfile(model) {
         return deriveModelCapabilityProfile({
@@ -318,6 +342,16 @@ export class WorkerDelegationController {
         if (!this.laneCapabilityProfile(shipment.model).backgroundLanesEnabled) {
             return { ok: false, skipReason: "model_delegation_unsupported" };
         }
+        // The model-facing delegate surface cannot name profile resources. An absent or empty
+        // runtime selection therefore means "use the owner-admitted profile set", not "drop it".
+        // Non-empty task metadata is an exact narrowing and remains fail-closed for unknown or
+        // duplicate ids before any durable task or provider request is created.
+        const requestedResourcePointerIds = request.taskContext?.resourcePointerIds ?? [];
+        const selectedResources = selectWorkerResourcePointers(shipment.resourcePointers, requestedResourcePointerIds.length > 0
+            ? requestedResourcePointerIds
+            : shipment.resourcePointers.map((pointer) => pointer.id));
+        if (!selectedResources.ok)
+            return { ok: false, skipReason: selectedResources.reason };
         const currentExecutionPlan = this.buildWorkerExecutionPlan(shipment.profile, settings);
         const executionPlan = pinnedContract
             ? narrowWorkerExecutionPlan(pinnedContract.worker.authority, currentExecutionPlan)
@@ -343,6 +377,7 @@ export class WorkerDelegationController {
             settings,
             shipment,
             ...(verifierShipment ? { verifierShipment } : {}),
+            resourcePointerIds: selectedResources.pointers.map((pointer) => pointer.id),
             executionContract,
             executionPlan,
         };
@@ -384,6 +419,18 @@ export class WorkerDelegationController {
         if (attemptId)
             this.publishedTerminalAttemptIds.add(attemptId);
     }
+    /**
+     * A pre-execution denial still owns a prepared durable lane. Publish its terminal projection at
+     * this boundary: immediate callers have no scheduler promise to observe and must not wait for a
+     * future recovery read to receive the handoff. Repeated late cancellation paths are inert via
+     * the attempt-id publication fence above.
+     */
+    cancelAndPublish(lifecycle, laneId, reasonCode) {
+        const record = lifecycle.cancel(laneId, reasonCode);
+        if (record)
+            this.publishTerminalRecord(record);
+        return record;
+    }
     hasWorkerCapacity(settings, profile) {
         const lifecycle = this.getWorkerLifecycle();
         if (lifecycle.getRunningCount() >= settings.maxConcurrent)
@@ -395,9 +442,15 @@ export class WorkerDelegationController {
         const admission = this.resolveWorkerAdmission(request, contract);
         if (!admission.ok)
             return { action: "cancel", reasonCode: admission.skipReason };
-        return this.hasWorkerCapacity(admission.settings, admission.shipment.profile)
-            ? { action: "start" }
-            : { action: "wait" };
+        if (!this.hasWorkerCapacity(admission.settings, admission.shipment.profile))
+            return { action: "wait", reason: "capacity" };
+        const attempt = this.getWorkerLifecycle().getActiveAttempt(record.laneId);
+        if (!attempt)
+            return { action: "cancel", reasonCode: "orchestration_attempt_missing" };
+        const reservation = this.writeReservations.acquire(record.laneId, attempt, admission.executionPlan);
+        if (reservation.kind === "denied")
+            return { action: "cancel", reasonCode: reservation.reasonCode };
+        return reservation.kind === "granted" ? { action: "start" } : { action: "wait", reason: "write_reservation" };
     }
     buildWorkerExecutionPlan(profile, settings) {
         return buildWorkerExecutionPlan({
@@ -426,6 +479,12 @@ export class WorkerDelegationController {
             executionContract: admission.executionContract,
             requiredCapabilities: admission.executionPlan.requiredCapabilities,
             ...(request.verificationOfTaskId ? { verificationOfTaskId: request.verificationOfTaskId } : {}),
+            taskContext: {
+                requirementIds: request.taskContext?.requirementIds ?? [],
+                dependsOnTaskIds: request.taskContext?.dependsOnTaskIds ?? [],
+                acceptanceCriterionIds: request.taskContext?.acceptanceCriterionIds ?? [],
+                resourcePointerIds: admission.resourcePointerIds,
+            },
             ...(goal ? { goal } : {}),
         });
         return { executionPlan: admission.executionPlan, lifecycle, ...prepared };
@@ -438,7 +497,7 @@ export class WorkerDelegationController {
         if (!admission.ok)
             return { started: false, skipReason: admission.skipReason };
         if (!request.verificationOfTaskId)
-            this.recoverDurableQueue();
+            this.recovery.recover();
         const { settings, shipment } = admission;
         const foreground = this.deps.getModel();
         const contendsWithLocalForeground = foreground !== undefined && isLocalExecutionModel(foreground) && isLocalExecutionModel(shipment.model);
@@ -485,13 +544,14 @@ export class WorkerDelegationController {
         if (!admission.ok)
             return { started: false, skipReason: admission.skipReason };
         if (!request.verificationOfTaskId)
-            this.recoverDurableQueue();
+            this.recovery.recover();
         const { instructions, settings, verifierShipment } = admission;
         const { model, modelBinding, profile: orchestrationProfile, soul } = admission.shipment;
         if (!this.hasWorkerCapacity(settings, orchestrationProfile)) {
             return { started: false, skipReason: "worker_delegation_already_running" };
         }
         const laneCapability = this.laneCapabilityProfile(model);
+        const retentionPolicy = workerConversationRetentionPolicy(model, this.deps.getSettingsManager());
         const prepared = this.prepareWorkerAttempt(request, admission, existingRecord);
         const { executionPlan, lifecycle } = prepared;
         if (!prepared.attempt)
@@ -499,26 +559,145 @@ export class WorkerDelegationController {
         const durableTask = lifecycle.getTask(prepared.record.laneId);
         if (!durableTask)
             return { started: false, skipReason: "orchestration_task_missing" };
-        const compiled = compileWorkerExecutionGrant({
-            target: {
-                objectiveId: durableTask.task.objectiveId,
-                taskId: prepared.attempt.taskId,
-                attemptId: prepared.attempt.attemptId,
-            },
-            profile: orchestrationProfile,
-            plan: executionPlan,
-        });
-        if (!compiled.ok) {
-            lifecycle.cancel(prepared.record.laneId, compiled.reasonCodes.join(","));
-            return { started: false, skipReason: `execution_policy_denied:${compiled.reasonCodes.join(",")}` };
+        const immutableWorker = prepared.attempt.dispatch.executionContract?.worker;
+        if (!immutableWorker)
+            return { started: false, skipReason: "orchestration_execution_contract_missing" };
+        const selectedResources = selectWorkerResourcePointers(immutableWorker.resourcePointers, prepared.attempt.dispatch.resourcePointerIds.length > 0
+            ? prepared.attempt.dispatch.resourcePointerIds
+            : admission.resourcePointerIds);
+        if (!selectedResources.ok) {
+            this.cancelAndPublish(lifecycle, prepared.record.laneId, selectedResources.reason);
+            return { started: false, skipReason: selectedResources.reason };
+        }
+        let grant;
+        let workerResourceSystemPrompt;
+        if (prepared.attempt.grant) {
+            if (!this.recovery.durableGrantIsStillPermitted(prepared.attempt.grant, executionPlan, selectedResources.pointers)) {
+                this.cancelAndPublish(lifecycle, prepared.record.laneId, "recovered_grant_revoked");
+                return { started: false, skipReason: "recovered_grant_revoked" };
+            }
+            grant = prepared.attempt.grant;
+            const materialized = materializeWorkerResourceBundle(grant.resources);
+            if (!materialized.ok) {
+                const reason = `worker_resource_materialization_${materialized.code}`;
+                this.cancelAndPublish(lifecycle, prepared.record.laneId, reason);
+                return { started: false, skipReason: reason };
+            }
+            workerResourceSystemPrompt = materialized.systemPrompt;
+        }
+        else {
+            const materialized = materializeWorkerResourceBundle(selectedResources.pointers);
+            if (!materialized.ok) {
+                const reason = `worker_resource_materialization_${materialized.code}`;
+                this.cancelAndPublish(lifecycle, prepared.record.laneId, reason);
+                return { started: false, skipReason: reason };
+            }
+            const compiled = compileWorkerExecutionGrant({
+                target: {
+                    objectiveId: durableTask.task.objectiveId,
+                    taskId: prepared.attempt.taskId,
+                    attemptId: prepared.attempt.attemptId,
+                },
+                profile: orchestrationProfile,
+                plan: executionPlan,
+                resources: materialized.pointers,
+            });
+            if (!compiled.ok) {
+                this.cancelAndPublish(lifecycle, prepared.record.laneId, compiled.reasonCodes.join(","));
+                return { started: false, skipReason: `execution_policy_denied:${compiled.reasonCodes.join(",")}` };
+            }
+            lifecycle.bindGrant(prepared.attempt.attemptId, compiled.grant);
+            grant = compiled.grant;
+            workerResourceSystemPrompt = materialized.systemPrompt;
+        }
+        const immutableProfile = immutableWorker.profile;
+        // Follow-up tasks deliberately receive unique task ids while retaining the original logical
+        // agent id in dispatch metadata. Never derive a new agent identity from a follow-up task id.
+        const agentId = prepared.attempt.agentId ?? prepared.attempt.dispatch.logicalLaneId ?? prepared.record.laneId;
+        const registeredAgent = lifecycle.getAgent(agentId);
+        if (prepared.attempt.agentId && !registeredAgent) {
+            this.cancelAndPublish(lifecycle, prepared.record.laneId, "orchestration_agent_missing");
+            return { started: false, skipReason: "orchestration_agent_missing" };
+        }
+        let conversation;
+        try {
+            if (registeredAgent) {
+                // Recovery must trust only the registered resume context; reconstructing one here could
+                // silently redirect a logical worker to a different transcript or resource scope.
+                conversation = this.conversations.open({
+                    agentDir: this.deps.getAgentDir(),
+                    resumeContext: registeredAgent.resumeContext,
+                    expectedLogicalAgentId: registeredAgent.agentId,
+                });
+                if (prepared.attempt.status === "suspended")
+                    this.recovery.repairInterruptedToolResults(conversation);
+            }
+            else {
+                conversation = this.conversations.ensure({
+                    agentDir: this.deps.getAgentDir(),
+                    parentSessionId: this.deps.getSessionId(),
+                    logicalAgentId: agentId,
+                    cwd: this.deps.getCwd(),
+                    orchestrationProfileId: immutableProfile.profileId,
+                    modelRef: `${prepared.attempt.dispatch.executionContract.worker.modelBinding.provider}/${prepared.attempt.dispatch.executionContract.worker.modelBinding.modelId}`,
+                    resourceProfileNames: immutableProfile.resourceProfileNames,
+                    contextPointers: grant.resources,
+                });
+                lifecycle.ensureAgent({
+                    agentId,
+                    role: immutableProfile.role,
+                    resumeContext: conversation.getResumeContext(),
+                });
+            }
+        }
+        catch (error) {
+            if (prepared.attempt.status !== "suspended") {
+                this.cancelAndPublish(lifecycle, prepared.record.laneId, "worker_conversation_unavailable");
+            }
+            this.safeWarn(`Worker conversation setup failed: ${error instanceof Error ? error.message : String(error)}`);
+            return { started: false, skipReason: "worker_conversation_unavailable" };
+        }
+        const reservation = this.writeReservations.acquire(prepared.record.laneId, prepared.attempt, executionPlan);
+        if (reservation.kind === "denied") {
+            this.cancelAndPublish(lifecycle, prepared.record.laneId, reservation.reasonCode);
+            return { started: false, skipReason: reservation.reasonCode };
+        }
+        if (reservation.kind === "blocked") {
+            this.scheduler.enqueue(prepared.record, { ...request, profileId: admission.shipment.profile.profileId });
+            this.notifications.statusChanged();
+            onStarted?.(prepared.record);
+            return { started: true, record: prepared.record };
+        }
+        let durableHandle;
+        try {
+            durableHandle =
+                registeredAgent && prepared.attempt.status === "suspended"
+                    ? lifecycle.resumeAgent(prepared.record.laneId, registeredAgent.agentId, immutableProfile.leaseTtlMs, this.agentControl.getProcessOwnerId())
+                    : lifecycle.startAgent(prepared.record.laneId, agentId, immutableProfile.leaseTtlMs, this.agentControl.getProcessOwnerId());
+        }
+        catch (error) {
+            this.writeReservations.release(prepared.record.laneId);
+            if (prepared.attempt.status !== "suspended")
+                this.cancelAndPublish(lifecycle, prepared.record.laneId, "worker_start_unavailable");
+            this.safeWarn(`Worker start failed: ${error instanceof Error ? error.message : String(error)}`);
+            return { started: false, skipReason: "worker_start_unavailable" };
         }
-        lifecycle.bindGrant(prepared.attempt.attemptId, compiled.grant);
-        const durableHandle = lifecycle.start(prepared.record.laneId, orchestrationProfile.leaseTtlMs);
         const startedRecord = lifecycle.getRecord(prepared.record.laneId);
-        if (!startedRecord)
+        if (!startedRecord) {
+            this.writeReservations.release(prepared.record.laneId);
             return { started: false, skipReason: "orchestration_projection_missing" };
+        }
+        if (this.writeReservations.hasFenceMismatch(startedRecord.laneId, durableHandle.attemptId, durableHandle.fencingToken)) {
+            this.writeReservations.release(startedRecord.laneId);
+            const record = this.cancelAndPublish(lifecycle, startedRecord.laneId, "write_reservation_fence_mismatch");
+            this.safeWarn("Worker write reservation fence did not match the durable attempt lease.");
+            return { started: false, skipReason: record?.reasonCode ?? "write_reservation_fence_mismatch" };
+        }
+        const recoveredTerminal = prepared.attempt.status === "suspended" ? this.recovery.recoveredTerminalCompletion(conversation) : undefined;
+        const checkpointUsage = lifecycle.getAttemptUsage(startedRecord.laneId);
+        const initialUsage = this.recovery.initialUsage(conversation, checkpointUsage);
         onStarted?.(startedRecord);
-        const maxUsd = compiled.grant.budget.maxCostUsd;
+        const maxUsd = grant.budget.maxCostUsd;
         const executionPolicy = orchestrationProfile.executionPolicy;
         const toolSurface = createLaneToolSurface({
             cwd: this.deps.getCwd(),
@@ -526,9 +705,10 @@ export class WorkerDelegationController {
             writeEnabled: executionPlan.writeEnabled,
             writePaths: executionPlan.writePaths,
             ...(executionPlan.processEnabled && executionPolicy ? { executionPolicy } : {}),
-            processMaxWallClockMs: compiled.grant.budget.maxWallClockMs ?? 0,
-            grant: compiled.grant,
+            processMaxWallClockMs: grant.budget.maxWallClockMs ?? 0,
+            grant,
             toolManifests: executionPlan.toolManifests,
+            initialUsage,
         });
         const writeGranted = executionPlan.writeEnabled &&
             toolSurface.gateway !== undefined &&
@@ -548,9 +728,9 @@ export class WorkerDelegationController {
                 profileId: orchestrationProfile.profileId,
                 // filesystem.write requires BOTH the opt-in AND an explicit non-empty path scope —
                 // an unscoped write grant is refused here, not discovered at validation time.
-                capabilities: [...compiled.grant.capabilities],
-                ...(writeGranted ? { allowedPaths: [...compiled.grant.writePaths] } : {}),
-                deniedPaths: [...compiled.grant.deniedPaths],
+                capabilities: [...grant.capabilities],
+                ...(writeGranted ? { allowedPaths: [...grant.writePaths] } : {}),
+                deniedPaths: [...grant.deniedPaths],
                 allowedTools: [...toolSurface.allowedTools],
                 deniedTools: [...toolSurface.deniedTools],
                 ...(maxUsd !== undefined ? { maxEstimatedUsd: maxUsd } : {}),
@@ -579,120 +759,55 @@ export class WorkerDelegationController {
         // registerInFlightWork is a pure sync map op (cannot throw), so placing it as the last
         // statement before `try` still guarantees the matching finally always runs.
         const deregisterInFlight = registerInFlightWork(this.deps.getAgentDir(), "lane", `worker:${startedRecord.laneId}`);
-        const durableStartedAt = Date.now();
+        const executor = createWorkerAttemptExecutor({
+            request: workerRequest,
+            grant,
+            executionPlan,
+            toolSurface,
+            conversation,
+            lifecycle,
+            laneId: startedRecord.laneId,
+            agentId,
+            durableHandle,
+            parentSessionId: this.deps.getSessionId(),
+            agentDir: this.deps.getAgentDir(),
+            cwd: this.deps.getCwd(),
+            model,
+            thinkingLevel: modelBinding.thinkingLevel,
+            laneCapability,
+            ...(soul ? { soul } : {}),
+            workerResourceSystemPrompt,
+            initialUsage,
+            hasPersistedUsageCheckpoint: checkpointUsage !== undefined,
+            usageReportId,
+            processCapable: executionPlan.processEnabled,
+            ...(request.verificationOfTaskId ? { verificationSubjectTaskId: request.verificationOfTaskId } : {}),
+            ...(recoveredTerminal ? { recoveredTerminal } : {}),
+            ...(retentionPolicy ? { retentionPolicy } : {}),
+            signal: workerSignal,
+            runIsolatedCompletion: (options) => this.deps.runIsolatedCompletion(options),
+            agentControl: this.agentControl,
+            applyActions: workerRequest.envelope.capabilities.includes("filesystem.write")
+                ? (actions, actionJournal) => applyWorkerActions({
+                    actions,
+                    gateway: toolSurface.gateway,
+                    toolManifests: executionPlan.toolManifests,
+                    cwd: this.deps.getCwd(),
+                    ...(actionJournal ? { actionJournal } : {}),
+                })
+                : undefined,
+            warn: (message) => this.safeWarn(message),
+        });
         try {
-            let spentUsage;
-            const toolChangedFiles = new Set();
-            const toolIssues = new Set();
-            // Register the live mutation ledger BEFORE the suspend point below so a synchronous
-            // disposal cutoff (`abortInFlightLanes`) can read a race-free snapshot of whatever this
-            // worker has already applied — the worker is suspended at the `await runWorker(...)` below
-            // whenever abort runs, and the abort signal stops further tool calls. Deleted in the
-            // `finally` on every exit path (normal completion, throw, or already consumed by abort).
+            // Register before the first execution await: disposal sees the live mutable ledger.
             this.inFlightLedgers.set(startedRecord.laneId, {
-                changedFiles: toolChangedFiles,
-                getSpend: () => spentUsage,
-                getToolCalls: () => toolSurface.gateway?.getUsage().toolCalls ?? 0,
+                changedFiles: executor.ledger.changedFiles,
+                getUsage: executor.ledger.getUsage,
                 request: workerRequest,
                 handle: durableHandle,
-                startedAt: durableStartedAt,
-            });
-            const maxToolCalls = compiled.grant.budget.maxToolCalls ?? 0;
-            const rawOutcome = await runWorker({
-                request: workerRequest,
-                maxUsd,
-                maxWallClockMs: compiled.grant.budget.maxWallClockMs ?? 0,
-                usageReportId,
-                getChangedFiles: () => [...toolChangedFiles],
-                signal: workerSignal,
-                // Parent validation must use the same relative-path baseline the runner reports in.
-                cwd: this.deps.getCwd(),
-                processCapable: executionPlan.processEnabled,
-                ...(request.verificationOfTaskId ? { verificationSubjectTaskId: request.verificationOfTaskId } : {}),
-                // Write lane: runner-side action application through the envelope path scope.
-                applyActions: workerRequest.envelope.capabilities.includes("filesystem.write")
-                    ? (actions) => {
-                        return applyWorkerActions({
-                            actions,
-                            gateway: toolSurface.gateway,
-                            toolManifests: executionPlan.toolManifests,
-                            cwd: this.deps.getCwd(),
-                        });
-                    }
-                    : undefined,
-                complete: async ({ systemPrompt, userPrompt, signal }) => {
-                    const completion = await this.deps.runIsolatedCompletion({
-                        // Level-0 core and owner-authored profile remain authoritative. The delegating
-                        // model supplies task instructions only; it cannot replace the worker role prompt.
-                        systemPrompt: composeSubagentSystemPrompt({
-                            soul,
-                            rolePrompt: systemPrompt,
-                        }),
-                        messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
-                        model,
-                        thinkingLevel: modelBinding.thinkingLevel,
-                        maxTokens: Math.min(laneCapability.laneMaxOutputTokens, compiled.grant.budget.maxTokens ?? Number.POSITIVE_INFINITY),
-                        tools: toolSurface.tools,
-                        maxTurns: Math.max(1, Math.min(6, maxToolCalls + 1)),
-                        finalTextPrompt: "The tool-turn budget is exhausted. Do not call more tools. Return the required worker-claim JSON envelope now using only evidence already gathered. If the investigation is incomplete, say so in the summary or blockers instead of omitting the envelope.",
-                        beforeToolCall: async (context, toolSignal) => {
-                            const decision = await toolSurface.beforeToolCall(context, toolSignal);
-                            if (decision?.block) {
-                                toolIssues.add(`${context.toolCall.name} blocked: ${decision.reason ?? "capability denied"}`);
-                            }
-                            return decision;
-                        },
-                        afterToolCall: async ({ toolCall, args, isError }) => {
-                            // This hook runs only for a validated, gate-approved tool that actually entered
-                            // execution. Record a direct mutation target before inspecting `isError`: write/edit
-                            // may have changed disk and then observed cancellation, timeout, or a late I/O error.
-                            // Pre-gate/profile/path refusals never reach afterToolCall, so they remain unreported.
-                            if (toolCall.name === "write" || toolCall.name === "edit") {
-                                if (args && typeof args === "object" && !Array.isArray(args)) {
-                                    const rawPath = args.path;
-                                    if (typeof rawPath === "string" && rawPath.length > 0) {
-                                        const absolutePath = path.isAbsolute(rawPath)
-                                            ? path.resolve(rawPath)
-                                            : path.resolve(this.deps.getCwd(), rawPath);
-                                        let canonicalPath = absolutePath;
-                                        try {
-                                            canonicalPath = safeRealpathSync(absolutePath);
-                                        }
-                                        catch {
-                                            // Execution was attempted; preserve conservative accounting with the lexical path.
-                                        }
-                                        toolChangedFiles.add(path.relative(this.deps.getCwd(), canonicalPath).split(path.sep).join("/"));
-                                    }
-                                }
-                            }
-                            if (isError) {
-                                toolIssues.add(`${toolCall.name} failed during isolated execution`);
-                                return undefined;
-                            }
-                            return undefined;
-                        },
-                        signal,
-                        // Core/soul/role are all static per configuration — the provider can cache the prefix.
-                        cacheRetention: "short",
-                        // Stable per-lane synthetic affinity key so repeat worker-delegation calls route to
-                        // the same cache-warm backend without carrying the real session id.
-                        laneKind: "worker",
-                    });
-                    spentUsage = completion.usage;
-                    toolSurface.gateway?.recordUsage({
-                        inputTokens: completion.usage.input,
-                        outputTokens: completion.usage.output,
-                        costUsd: completion.usage.cost.total,
-                    });
-                    return {
-                        text: completion.text,
-                        costUsd: completion.usage.cost.total,
-                        stopReason: String(completion.stopReason),
-                        changedFiles: [...toolChangedFiles],
-                        blockers: [...toolIssues],
-                    };
-                },
             });
+            const executionResult = await executor.run();
+            const rawOutcome = executionResult.rawOutcome;
             const verificationRequired = orchestrationProfile.requireIndependentVerification &&
                 orchestrationProfile.role !== "verifier" &&
                 rawOutcome.claim.status === "completed";
@@ -729,33 +844,32 @@ export class WorkerDelegationController {
             const verificationSubject = request.verificationOfTaskId
                 ? lifecycle.getTask(request.verificationOfTaskId)
                 : undefined;
-            let record = lifecycle.finish(createWorkerResultContract({
+            const finalUsage = executionResult.usage;
+            const reportedUsage = providerUsageFromAttemptUsage(finalUsage);
+            let record = finalizeWorkerClaim(lifecycle, {
                 handle: durableHandle,
                 claim: outcome.claim,
                 accepted: outcome.accepted,
-                costUsd: outcome.costUsd,
+                costUsd: finalUsage.costUsd,
                 reasonCode: outcome.reasonCode,
                 cwd: this.deps.getCwd(),
-                ...(spentUsage
-                    ? {
-                        inputTokens: spentUsage.input,
-                        outputTokens: spentUsage.output,
-                        totalTokens: spentUsage.totalTokens,
-                    }
-                    : {}),
-                wallClockMs: Date.now() - durableStartedAt,
-                toolCalls: toolSurface.gateway?.getUsage().toolCalls ?? 0,
+                inputTokens: finalUsage.inputTokens,
+                outputTokens: finalUsage.outputTokens,
+                totalTokens: reportedUsage.totalTokens,
+                wallClockMs: finalUsage.activeWallClockMs,
+                toolCalls: finalUsage.toolCalls,
                 verificationRequired,
                 verificationCriterionIds: verificationSubject?.task.acceptanceCriterionIds,
-            }), { notify: !verificationRequired });
+                notify: !verificationRequired,
+            }).record;
             try {
                 this.deps.saveWorkerClaimSnapshot(outcome.claim, workerRequest);
             }
             catch (error) {
                 this.safeWarn(`Failed to persist worker claim ${startedRecord.laneId}: ${error instanceof Error ? error.message : String(error)}`);
             }
-            if (spentUsage && (spentUsage.cost.total > 0 || spentUsage.totalTokens > 0)) {
-                this.deps.addSpawnedUsage(spentUsage, { label: "worker-delegation", reportId: usageReportId });
+            if (reportedUsage.cost.total > 0 || reportedUsage.totalTokens > 0) {
+                this.deps.addSpawnedUsage(reportedUsage, { label: "worker-delegation", reportId: usageReportId });
             }
             const terminalRecords = [record];
             if (request.verificationOfTaskId) {
@@ -809,6 +923,11 @@ export class WorkerDelegationController {
         }
         catch (error) {
             const durableState = lifecycle.ledger.runtime.getSnapshot().attempts[durableHandle.attemptId];
+            if (durableState?.status === "suspended") {
+                // Disposal/reload fences agent-bound work before its aborted completion unwinds. Do not
+                // convert that resumable interruption into a terminal claim or cancellation.
+                return { started: true, record: lifecycle.getRecord(startedRecord.laneId) };
+            }
             if (durableState?.status === "cancelled" && (laneAbortController.signal.aborted || this.deps.isDisposed())) {
                 return { started: true, record: lifecycle.getRecord(startedRecord.laneId) };
             }
@@ -821,16 +940,21 @@ export class WorkerDelegationController {
                     createdAt: new Date().toISOString(),
                 };
                 try {
-                    lifecycle.finish(createWorkerResultContract({
+                    const failureUsage = executor.checkpointUsage("Persisted cumulative usage while recording worker failure.");
+                    const reportedUsage = providerUsageFromAttemptUsage(failureUsage);
+                    finalizeWorkerClaim(lifecycle, {
                         handle: durableHandle,
                         claim: failureClaim,
                         accepted: false,
-                        costUsd: 0,
+                        costUsd: failureUsage.costUsd,
                         cwd: this.deps.getCwd(),
-                        wallClockMs: Date.now() - durableStartedAt,
-                        toolCalls: toolSurface.gateway?.getUsage().toolCalls ?? 0,
+                        inputTokens: failureUsage.inputTokens,
+                        outputTokens: failureUsage.outputTokens,
+                        totalTokens: reportedUsage.totalTokens,
+                        wallClockMs: failureUsage.activeWallClockMs,
+                        toolCalls: failureUsage.toolCalls,
                         reasonCode: "worker_delegation_error",
-                    }));
+                    });
                 }
                 catch (persistError) {
                     this.safeWarn(`Failed to persist durable worker failure ${startedRecord.laneId}: ${persistError instanceof Error ? persistError.message : String(persistError)}`);
@@ -838,7 +962,7 @@ export class WorkerDelegationController {
             }
             let record = lifecycle.getRecord(startedRecord.laneId);
             if (record?.status === "queued" || record?.status === "running") {
-                record = lifecycle.cancel(startedRecord.laneId, "worker_delegation_error");
+                record = this.cancelAndPublish(lifecycle, startedRecord.laneId, "worker_delegation_error");
             }
             if (record && !this.deps.isDisposed())
                 this.publishTerminalRecord(record);
@@ -847,14 +971,16 @@ export class WorkerDelegationController {
             return { started: true, record };
         }
         finally {
+            this.writeReservations.release(startedRecord.laneId, durableHandle.attemptId, durableHandle.fencingToken);
             this.inFlightLedgers.delete(startedRecord.laneId);
             this.laneAbortControllers.delete(startedRecord.laneId);
+            this.agentControl.signalStateChanged();
             deregisterInFlight();
         }
     }
     /** Start every capacity-eligible queued worker at the owner session's foreground-idle boundary. */
     drain() {
-        this.recoverDurableQueue();
+        this.recovery.recover();
         this.scheduler.drain();
     }
 }