@caupulican/pi-adaptative 0.94.0 → 0.95.0

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

@@ -6,7 +6,8 @@ import { createLaneToolSurface } from "../autonomy/lane-tool-surface.js";
 import { isLaneTerminalStatus } from "../autonomy/lane-tracker.js";
 import { appendLaneRecordSnapshot } from "../autonomy/session-lane-record.js";
 import { AUTONOMY_TELEMETRY_EVENT_TYPES } from "../autonomy/telemetry-events.js";
-import { STABLE_SHELL_TOOL_NAME } from "../default-tool-surface.js";
+import { createWorkerToolAdapterRegistry, WORKER_TOOL_ADAPTER_NAMES, } from "../autonomy/worker-tool-adapter-registry.js";
+import { mapToolNamesForPlatform, STABLE_SHELL_TOOL_NAME } from "../default-tool-surface.js";
 import { isGoalExecutionActive } from "../goals/goal-state.js";
 import { deriveModelCapabilityProfile } from "../model-capability.js";
 import { isLoopbackModelEndpoint } from "../models/model-endpoint.js";
@@ -18,15 +19,14 @@ import { createWorkerExecutionContract, verifierWorkerExecutionContract, } from
 import { resolveWorkerModelPin } from "../orchestration/worker-model-pins.js";
 import { registerInFlightWork } from "../reload-blockers.js";
 import { getActiveSessionBranchEntries } from "../session-snapshot.js";
-import { createDelegateToolDefinition } from "../tools/delegate.js";
+import { executeToolkitScript } from "../toolkit/script-runner.js";
 import { disposePersistentShellSession } from "../tools/shell-session.js";
-import { wrapToolDefinition } from "../tools/tool-definition-wrapper.js";
 import { selectSanitizedContextFork } from "./sanitized-context-fork.js";
 import { getLatestWorkerClaimSnapshot } from "./session-worker-claim.js";
 import { applyWorkerActions } from "./worker-actions.js";
 import { WorkerAgentControlCoordinator } from "./worker-agent-control-coordinator.js";
 import { createWorkerAttemptExecutor } from "./worker-attempt-executor.js";
-import { resolveWorkerAuthority } from "./worker-authority-resolver.js";
+import { bindCompiledToolSurface, bindCompiledVerifierIdentity, resolveWorkerAuthority, } from "./worker-authority-resolver.js";
 import { WorkerContextForkStore, WorkerContextForkStoreError } from "./worker-context-fork-store.js";
 import { resolveWorkerContextInheritanceMode } from "./worker-context-inheritance-policy.js";
 import { WorkerConversationStore, } from "./worker-conversation-store.js";
@@ -312,7 +312,7 @@ export class WorkerDelegationController {
                     claim,
                     accepted: false,
                     costUsd: usage.costUsd,
-                    cwd: this.deps.getCwd(),
+                    cwd: ledger.cwd,
                     inputTokens: usage.inputTokens,
                     outputTokens: usage.outputTokens,
                     totalTokens: reportedUsage.totalTokens,
@@ -384,9 +384,32 @@ export class WorkerDelegationController {
                 return !model || this.deps.isModelExhausted(model);
             },
             getActiveOrchestrationProfile: () => this.deps.getActiveOrchestrationProfile?.(),
+            getInheritedBaseProfile: () => {
+                const foregroundModel = this.deps.getModel();
+                if (!foregroundModel)
+                    return undefined;
+                const inherited = this.resolveWorkerAuthority({ foregroundModel });
+                if (!inherited.ok)
+                    return undefined;
+                const plan = this.buildWorkerExecutionPlan(inherited.shipment.profile, this.deps.getSettingsManager().getWorkerDelegationSettings());
+                return bindCompiledToolSurface(inherited.shipment, plan.toolManifests.map((manifest) => manifest.toolName)).profile;
+            },
         });
         return this.taskProfileWriter;
     }
+    resolveWorkerAuthority(input) {
+        const foregroundModel = input.foregroundModel ?? this.deps.getModel();
+        return resolveWorkerAuthority({
+            ...input,
+            ...(foregroundModel ? { foregroundModel } : {}),
+            foregroundThinkingLevel: this.deps.getForegroundThinkingLevel?.(),
+            ...(this.deps.getForegroundToolNames ? { foregroundToolNames: this.deps.getForegroundToolNames() } : {}),
+            ...(this.deps.getCapabilityEnvelope() ? { foregroundEnvelope: this.deps.getCapabilityEnvelope() } : {}),
+            cwd: this.deps.getCwd(),
+            modelRegistry: this.deps.getModelRegistry(),
+            isModelExhausted: (model) => this.deps.isModelExhausted(model),
+        });
+    }
     /** Read-only durable worker projection. Undefined means the delegate capability never loaded. */
     getTaskRuntimeSnapshot() {
         return this.lifecycle.getTaskRuntimeSnapshot();
@@ -460,6 +483,7 @@ export class WorkerDelegationController {
         const admitted = resolveWorkerAuthority({
             base: resolved.resolved,
             ...(modelPin ? { modelPin: modelPin.binding } : {}),
+            cwd: this.deps.getCwd(),
             modelRegistry: this.deps.getModelRegistry(),
             isModelExhausted: (model) => this.deps.isModelExhausted(model),
         });
@@ -468,10 +492,10 @@ export class WorkerDelegationController {
             : { ok: false, skipReason: `independent_verifier_unavailable:${admitted.reason}` };
     }
     /**
-     * A descendant may select a different routing profile, but that preset cannot introduce context or
-     * recursive authority its ancestor never admitted. Pointer ids alone are insufficient authority:
-     * retain only pointers whose complete immutable metadata matches the ancestral contract, require
-     * exact soul text, and intersect durable delegation limits.
+     * A recovered legacy nested dispatch may retain a different routing profile, but it cannot widen
+     * the immutable ancestor contract. Pointer ids alone are insufficient authority: retain only
+     * pointers whose complete metadata matches, require exact soul text, and intersect the persisted
+     * lineage limits. Fresh native workers never enter this compatibility path.
      */
     narrowWorkerShipmentContext(shipment, boundary) {
         const boundaryPointers = new Map(boundary.resourcePointers.map((pointer) => [pointer.id, pointer]));
@@ -500,7 +524,7 @@ export class WorkerDelegationController {
             },
         };
     }
-    hasExactRecursiveCycle(parentAgentId, instructions, profileId) {
+    hasExactRecoveredLineageCycle(parentAgentId, instructions, profileId) {
         const normalizedInstructions = instructions.trim();
         const visited = new Set();
         let current = this.lifecycle.getAgent(parentAgentId);
@@ -594,7 +618,7 @@ export class WorkerDelegationController {
                 return configured;
             basePreset = configured.preset;
         }
-        const effectiveRole = authority?.role ?? baseShipment?.profile.role ?? basePreset?.profile.role ?? "orchestrator";
+        const effectiveRole = authority?.role ?? baseShipment?.profile.role ?? basePreset?.profile.role ?? "implementer";
         const modelPin = resolveWorkerModelPin(modelPinPolicy, effectiveRole);
         // The model itself is authority?.model, not `role` — role selects which pin applies, but a
         // roles-only policy (no `default`) leaves an unlisted role with no pin at all, so a caller
@@ -613,13 +637,10 @@ export class WorkerDelegationController {
         }
         const adaptive = pinnedContract
             ? { ok: true, shipment: baseShipment }
-            : resolveWorkerAuthority({
+            : this.resolveWorkerAuthority({
                 authority,
                 ...(baseShipment ? { base: baseShipment } : {}),
                 ...(modelPin ? { modelPin: modelPin.binding } : {}),
-                ...(this.deps.getModel() ? { foregroundModel: this.deps.getModel() } : {}),
-                modelRegistry: this.deps.getModelRegistry(),
-                isModelExhausted: (model) => this.deps.isModelExhausted(model),
             });
         if (!adaptive.ok) {
             return {
@@ -636,7 +657,8 @@ export class WorkerDelegationController {
                 return narrowed;
             shipment = narrowed.shipment;
         }
-        if (parentAgent && this.hasExactRecursiveCycle(parentAgent.agentId, instructions, shipment.profile.profileId)) {
+        if (parentAgent &&
+            this.hasExactRecoveredLineageCycle(parentAgent.agentId, instructions, shipment.profile.profileId)) {
             return { ok: false, skipReason: "recursive_delegation_cycle" };
         }
         if (request.verificationOfTaskId && shipment.profile.role !== "verifier") {
@@ -679,7 +701,29 @@ export class WorkerDelegationController {
             : shipment.resourcePointers.map((pointer) => pointer.id));
         if (!selectedResources.ok)
             return { ok: false, skipReason: selectedResources.reason };
-        const currentExecutionPlan = this.buildWorkerExecutionPlan(shipment.profile, settings, adaptive.requestedReadPaths, adaptive.requestedWritePaths);
+        const currentExecutionPlan = this.buildWorkerExecutionPlan(shipment.profile, settings);
+        const explicitlySelectedProfile = !pinnedContract &&
+            (request.profileId !== undefined || (!parentContract && settings.orchestrationProfile !== undefined));
+        if (explicitlySelectedProfile) {
+            const activeAdapterNames = new Set(this.workerToolAdapterNames());
+            const unavailableAdapters = mapToolNamesForPlatform(shipment.profile.toolNames).filter((toolName) => WORKER_TOOL_ADAPTER_NAMES.has(toolName) && !activeAdapterNames.has(toolName));
+            if (unavailableAdapters.length > 0) {
+                return {
+                    ok: false,
+                    skipReason: `orchestration_tool_unavailable:${[...new Set(unavailableAdapters)].join(",")}`,
+                };
+            }
+        }
+        if (!pinnedContract && authority?.toolNames) {
+            const materializedTools = new Set(currentExecutionPlan.toolManifests.map((manifest) => manifest.toolName));
+            const missingTools = mapToolNamesForPlatform(authority.toolNames).filter((toolName) => !materializedTools.has(toolName));
+            if (missingTools.length > 0) {
+                return { ok: false, skipReason: `orchestration_tool_unavailable:${[...new Set(missingTools)].join(",")}` };
+            }
+        }
+        if (!pinnedContract) {
+            shipment = bindCompiledToolSurface(shipment, currentExecutionPlan.toolManifests.map((manifest) => manifest.toolName));
+        }
         const inheritedAuthority = pinnedContract?.worker.authority ?? parentContract?.worker.authority;
         const executionPlan = inheritedAuthority
             ? narrowWorkerExecutionPlan(inheritedAuthority, currentExecutionPlan)
@@ -687,6 +731,12 @@ export class WorkerDelegationController {
         const verifierExecutionPlan = verifierShipment
             ? this.buildWorkerExecutionPlan(verifierShipment.profile, settings)
             : undefined;
+        if (!pinnedContract && verifierShipment && verifierExecutionPlan) {
+            verifierShipment = bindCompiledToolSurface(verifierShipment, verifierExecutionPlan.toolManifests.map((manifest) => manifest.toolName));
+        }
+        if (verifierShipment) {
+            shipment = bindCompiledVerifierIdentity(shipment, verifierShipment.profile.profileId);
+        }
         const inheritedVerifierAuthority = parentContract?.verifier?.authority ?? parentContract?.worker.authority;
         const boundedVerifierExecutionPlan = verifierExecutionPlan && inheritedVerifierAuthority
             ? narrowWorkerExecutionPlan(inheritedVerifierAuthority, verifierExecutionPlan)
@@ -1151,6 +1201,9 @@ export class WorkerDelegationController {
     }
     /** One admission owner for every newly generated logical worker identity. */
     admitNewWorkerRequest(request, pinnedContract) {
+        if (request.parentAgentId && !pinnedContract) {
+            return { ok: false, skipReason: "worker_leaf_delegation_forbidden" };
+        }
         const goalDependencySkipReason = this.workerGoalDependencySkipReason(request);
         if (goalDependencySkipReason)
             return { ok: false, skipReason: goalDependencySkipReason };
@@ -1186,7 +1239,7 @@ export class WorkerDelegationController {
         }
         return references;
     }
-    buildWorkerExecutionPlan(profile, settings, requestedReadPaths, requestedWritePaths) {
+    buildWorkerExecutionPlan(profile, settings) {
         return buildWorkerExecutionPlan({
             profile,
             settings,
@@ -1194,10 +1247,22 @@ export class WorkerDelegationController {
             deniedPaths: getPrivateLaneDeniedPaths(this.deps.getCwd(), this.deps.getAgentDir()),
             foregroundMaxCostUsd: this.deps.getCapabilityEnvelope()?.maxEstimatedUsd,
             memoryEnabled: this.deps.getSettingsManager().getMemoryRetrievalSettings().enabled,
-            ...(requestedReadPaths ? { requestedReadPaths } : {}),
-            ...(requestedWritePaths ? { requestedWritePaths } : {}),
+            workerToolAdapterNames: this.workerToolAdapterNames(),
         });
     }
+    workerToolAdapterNames() {
+        const active = new Set(this.deps.getForegroundToolNames?.() ?? this.deps.getCapabilityEnvelope()?.allowedTools ?? []);
+        const names = [];
+        if (active.has("artifact_retrieve") && this.deps.getArtifactStore)
+            names.push("artifact_retrieve");
+        if (active.has("skill") && this.deps.getSkillReadBroker)
+            names.push("skill");
+        if (active.has("skill_audit") && this.deps.getSkillAuditSource)
+            names.push("skill_audit");
+        if (active.has("run_toolkit_script"))
+            names.push("run_toolkit_script");
+        return names;
+    }
     /** One durable preparation path for queued, immediate, and recovered execution. */
     prepareWorkerAttempt(request, admission, existingRecord) {
         const lifecycle = this.getWorkerLifecycle();
@@ -1348,7 +1413,7 @@ export class WorkerDelegationController {
             agentDir: this.deps.getAgentDir(),
             parentSessionId: this.deps.getSessionId(),
             logicalAgentId: agentId,
-            cwd: this.deps.getCwd(),
+            cwd: prepared.executionPlan.cwd,
             orchestrationProfileId: immutableWorker.profile.profileId,
             modelRef: `${immutableWorker.modelBinding.provider}/${immutableWorker.modelBinding.modelId}`,
             resourceProfileNames: immutableWorker.profile.resourceProfileNames,
@@ -1561,19 +1626,6 @@ export class WorkerDelegationController {
         onStarted?.(startedRecord);
         const maxUsd = grant.budget.maxCostUsd;
         const executionPolicy = orchestrationProfile.executionPolicy;
-        const recursiveDelegateTool = wrapToolDefinition(createDelegateToolDefinition({
-            startWorkerDelegation: (childRequest) => this.start({ ...childRequest, parentAgentId: agentId }),
-            runWorkerDelegation: (childRequest) => this.runOnce({ ...childRequest, parentAgentId: agentId }),
-            orchestrationProfiles: this.getProfileCatalog(),
-            workerModelPinPolicy: this.deps.getSettingsManager().getWorkerModelPinPolicy(),
-            workerAgentControl: this.agentControl,
-            caller: { kind: "worker", agentId },
-            warn: (message) => this.safeWarn(message),
-            resolveMessageReplayScope: () => ({
-                sessionId: this.deps.getSessionId(),
-                branchId: durableHandle.attemptId,
-            }),
-        }));
         const agentBinding = lifecycle.getAgent(agentId);
         if (!agentBinding) {
             this.cancelAndPublish(lifecycle, prepared.record.laneId, "orchestration_agent_missing");
@@ -1593,10 +1645,42 @@ export class WorkerDelegationController {
         const shellOutputDirectory = shellGranted
             ? getProcessWorkRun(this.deps.getAgentDir(), "outputs", "tool-streams").path
             : undefined;
+        const adapterSources = {};
+        if (executionPlan.toolManifests.some((manifest) => manifest.toolName === "artifact_retrieve")) {
+            const artifactStore = this.deps.getArtifactStore?.();
+            if (artifactStore)
+                adapterSources.artifactStore = artifactStore;
+        }
+        if (executionPlan.toolManifests.some((manifest) => manifest.toolName === "skill")) {
+            const broker = this.deps.getSkillReadBroker?.();
+            if (broker)
+                adapterSources.skill = broker;
+        }
+        if (executionPlan.toolManifests.some((manifest) => manifest.toolName === "skill_audit")) {
+            const source = this.deps.getSkillAuditSource?.();
+            if (source)
+                adapterSources.skillAudit = source;
+        }
+        if (executionPlan.toolManifests.some((manifest) => manifest.toolName === "run_toolkit_script")) {
+            adapterSources.runToolkitScript = {
+                getScripts: () => this.deps.getSettingsManager().getToolkitScripts(),
+                execute: (script, scriptArgs, signal) => executeToolkitScript({
+                    script,
+                    scriptArgs,
+                    cwd: executionPlan.cwd,
+                    ...(grant.budget.maxWallClockMs && grant.budget.maxWallClockMs > 0
+                        ? { timeoutMs: grant.budget.maxWallClockMs }
+                        : {}),
+                    signal,
+                }),
+            };
+        }
+        const workerToolAdapters = Object.keys(adapterSources).length > 0 ? createWorkerToolAdapterRegistry(adapterSources) : undefined;
         if (shellSessionKey)
             this.shellSessionKeys.add(shellSessionKey);
         const toolSurface = createLaneToolSurface({
-            cwd: this.deps.getCwd(),
+            cwd: executionPlan.cwd,
+            deniedPaths: executionPlan.deniedPaths,
             readMemory: executionPlan.readMemory ? (query) => this.deps.readMemoryForLane(query) : undefined,
             writeEnabled: executionPlan.writeEnabled,
             writePaths: executionPlan.writePaths,
@@ -1606,7 +1690,7 @@ export class WorkerDelegationController {
             ...(shellOutputDirectory ? { shellOutputDirectory } : {}),
             grant,
             toolManifests: executionPlan.toolManifests,
-            additionalTools: [recursiveDelegateTool],
+            ...(workerToolAdapters ? { workerToolAdapters } : {}),
             initialUsage,
             sharedBudget,
         });
@@ -1690,7 +1774,7 @@ export class WorkerDelegationController {
             durableHandle,
             parentSessionId: this.deps.getSessionId(),
             agentDir: this.deps.getAgentDir(),
-            cwd: this.deps.getCwd(),
+            cwd: executionPlan.cwd,
             model,
             thinkingLevel: modelBinding.thinkingLevel,
             laneCapability,
@@ -1711,7 +1795,7 @@ export class WorkerDelegationController {
                     actions,
                     gateway: toolSurface.gateway,
                     toolManifests: executionPlan.toolManifests,
-                    cwd: this.deps.getCwd(),
+                    cwd: executionPlan.cwd,
                     ...(actionJournal ? { actionJournal } : {}),
                 })
                 : undefined,
@@ -1724,6 +1808,7 @@ export class WorkerDelegationController {
                 getUsage: executor.ledger.getUsage,
                 request: workerRequest,
                 handle: durableHandle,
+                cwd: executionPlan.cwd,
             });
             leaseHeartbeat.start();
             const executionResult = await executor.run();
@@ -1799,7 +1884,7 @@ export class WorkerDelegationController {
                 accepted: outcome.accepted,
                 costUsd: finalUsage.costUsd,
                 reasonCode: outcome.reasonCode,
-                cwd: this.deps.getCwd(),
+                cwd: executionPlan.cwd,
                 inputTokens: finalUsage.inputTokens,
                 outputTokens: finalUsage.outputTokens,
                 totalTokens: reportedUsage.totalTokens,
@@ -1889,7 +1974,7 @@ export class WorkerDelegationController {
                         claim: failureClaim,
                         accepted: false,
                         costUsd: failureUsage.costUsd,
-                        cwd: this.deps.getCwd(),
+                        cwd: executionPlan.cwd,
                         inputTokens: failureUsage.inputTokens,
                         outputTokens: failureUsage.outputTokens,
                         totalTokens: reportedUsage.totalTokens,