@caupulican/pi-adaptative 0.81.26 → 0.81.29

package/dist/core/background-lane-controller.js

@@ -14,7 +14,10 @@
  * delegations; goal auto-continue itself only ever asks the session to `continueGoalLoop`, so this
  * controller never touches `prompt()`, the last-assistant-message, retry, or streaming state.
  */
+import path from "node:path";
+import { createLaneToolSurface } from "./autonomy/lane-tool-surface.js";
 import { LaneTracker } from "./autonomy/lane-tracker.js";
+import { safeRealpathSync } from "./autonomy/path-scope.js";
 import { appendLaneRecordSnapshot, getLaneRecordSnapshots } from "./autonomy/session-lane-record.js";
 import { composeSubagentSystemPrompt } from "./autonomy/subagent-prompt.js";
 import { AUTONOMY_TELEMETRY_EVENT_TYPES } from "./autonomy/telemetry-events.js";
@@ -45,7 +48,37 @@ export class BackgroundLaneController {
     _researchLaneAbort = new AbortController();
     /** Session-lifetime abort for in-flight delegated workers. */
     _workerDelegationAbort = new AbortController();
+    /** Session-local de-duplication for fail-closed profile grants that cannot bind to lane tools. */
+    _warnedUnboundLaneToolGrants = new Set();
+    /** Every background execution is retained until its terminal result is observed. */
+    _workerPromises = new Map();
+    _queuedWorkers = new Map();
+    _workerNotificationTimer;
+    _workersCompletedSinceFlush = 0;
+    _workersFailedSinceFlush = 0;
     deps;
+    _scheduleWorkerNotification() {
+        if (this._workerNotificationTimer !== undefined)
+            return;
+        this._workerNotificationTimer = setTimeout(() => {
+            this._workerNotificationTimer = undefined;
+            this.deps.emit({
+                type: "delegate_workers",
+                active: this._laneTracker.getActiveCount("worker"),
+                completedSinceFlush: this._workersCompletedSinceFlush,
+                failedSinceFlush: this._workersFailedSinceFlush,
+            });
+            this._workersCompletedSinceFlush = 0;
+            this._workersFailedSinceFlush = 0;
+        }, 75);
+    }
+    _recordWorkerTerminal(status) {
+        if (status === "succeeded")
+            this._workersCompletedSinceFlush++;
+        else
+            this._workersFailedSinceFlush++;
+        this._scheduleWorkerNotification();
+    }
     constructor(deps) {
         this.deps = deps;
     }
@@ -174,10 +207,6 @@ export class BackgroundLaneController {
     scheduleResearchLaneFromIdle() {
         if (this._isResearchLaneRunning || this.deps.isDisposed() || this.deps.isChildSession())
             return;
-        if (!this.deps.getModelCapabilityProfile().backgroundLanesEnabled) {
-            this._lastResearchLaneSkipReason = "model_context_too_small";
-            return;
-        }
         const research = this.deps.getSettingsManager().getResearchLaneSettings();
         if (!research.enabled) {
             this._lastResearchLaneSkipReason = "research_lane_disabled";
@@ -195,6 +224,15 @@ export class BackgroundLaneController {
         }
         if (!this._buildResearchLaneDemand())
             return;
+        const shipment = this._resolveLaneShipment(research, "no_research_model");
+        if (!shipment.ok) {
+            this._lastResearchLaneSkipReason = shipment.skipReason;
+            return;
+        }
+        if (!this._laneCapabilityProfile(shipment.model).backgroundLanesEnabled) {
+            this._lastResearchLaneSkipReason = "model_research_unsupported";
+            return;
+        }
         this.clearResearchLaneTimer();
         this._researchLaneTimer = setTimeout(() => {
             this._researchLaneTimer = undefined;
@@ -252,7 +290,12 @@ export class BackgroundLaneController {
     _resolveLaneShipment(laneSettings, missingModelReason) {
         let laneProfile;
         if (laneSettings.profile) {
-            laneProfile = this.deps.getSettingsManager().getProfileRegistry().getProfile(laneSettings.profile);
+            const profileRef = laneSettings.profile.trim();
+            const registry = this.deps.getSettingsManager().getProfileRegistry();
+            laneProfile =
+                profileRef.startsWith("./") || profileRef.startsWith("../")
+                    ? registry.resolveProfileRef(profileRef, this.deps.getCwd())
+                    : registry.getProfile(profileRef);
             if (!laneProfile) {
                 return { ok: false, skipReason: "lane_profile_not_found" };
             }
@@ -278,21 +321,27 @@ export class BackgroundLaneController {
         }
         return { ok: true, model, laneProfile };
     }
-    /** UAC tool grants from a shipped lane profile, recorded on the lane envelope. */
-    _laneProfileToolGrants(laneProfile) {
-        const toolsFilter = laneProfile?.resources.tools;
-        return {
-            ...(toolsFilter?.allow && toolsFilter.allow.length > 0 ? { allowedTools: [...toolsFilter.allow] } : {}),
-            ...(toolsFilter?.block && toolsFilter.block.length > 0 ? { deniedTools: [...toolsFilter.block] } : {}),
-        };
+    _warnUnboundLaneToolGrants(laneProfile, surface) {
+        if (!laneProfile || surface.unboundAllowPatterns.length === 0)
+            return;
+        const warningKey = `${laneProfile.name}\0${[...surface.unboundAllowPatterns].sort().join("\0")}`;
+        if (this._warnedUnboundLaneToolGrants.has(warningKey))
+            return;
+        this._warnedUnboundLaneToolGrants.add(warningKey);
+        this.deps.emit({
+            type: "warning",
+            message: `Lane profile '${laneProfile.name}' grants unavailable isolated-lane tools: ${surface.unboundAllowPatterns.join(", ")}. Only classified lane tools can execute.`,
+        });
     }
     /** Stripped research envelope — never the foreground/architect envelope. */
-    _buildResearchLaneEnvelope(maxUsd, laneProfile) {
+    _buildResearchLaneEnvelope(maxUsd, laneProfile, surface) {
         return {
             id: `research-${this.deps.getSessionId()}-${Date.now()}`,
             profileId: laneProfile?.name,
             capabilities: ["research", "read_files", "memory_read"],
-            ...this._laneProfileToolGrants(laneProfile),
+            allowedTools: [...surface.allowedTools],
+            deniedTools: [...surface.deniedTools],
+            allowedPaths: [this.deps.getCwd()],
             maxEstimatedUsd: clampLaneMaxUsd(maxUsd, this.deps.getCapabilityEnvelope()?.maxEstimatedUsd),
             createdAt: new Date().toISOString(),
         };
@@ -323,6 +372,11 @@ export class BackgroundLaneController {
             return { started: false, skipReason: shipment.skipReason };
         }
         const { model, laneProfile } = shipment;
+        const laneCapability = this._laneCapabilityProfile(model);
+        if (!laneCapability.backgroundLanesEnabled) {
+            this._lastResearchLaneSkipReason = "model_research_unsupported";
+            return { started: false, skipReason: "model_research_unsupported" };
+        }
         this._isResearchLaneRunning = true;
         this._laneTracker.ensureCounterAtLeast(getLaneRecordSnapshots(this.deps.getSessionManager().getEntries()).length + 1);
         const startedRecord = this._laneTracker.start({ type: "research", goalId: demand.goalId });
@@ -336,11 +390,13 @@ export class BackgroundLaneController {
                 maxSources: settings.maxSources,
             });
             const maxUsd = clampLaneMaxUsd(settings.maxUsd, this.deps.getCapabilityEnvelope()?.maxEstimatedUsd);
+            const toolSurface = createLaneToolSurface({ cwd: this.deps.getCwd(), profile: laneProfile });
+            this._warnUnboundLaneToolGrants(laneProfile, toolSurface);
             const result = await runResearch({
                 query: demand.query,
                 context: demand.context,
                 sources: workspaceSources,
-                envelope: this._buildResearchLaneEnvelope(maxUsd, laneProfile),
+                envelope: this._buildResearchLaneEnvelope(maxUsd, laneProfile, toolSurface),
                 maxUsd,
                 maxSources: settings.maxSources,
                 maxFindings: settings.maxFindings,
@@ -358,7 +414,10 @@ export class BackgroundLaneController {
                         messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
                         model,
                         thinkingLevel: laneProfile?.thinking ?? "off",
-                        maxTokens: this._laneCapabilityProfile(model).laneMaxOutputTokens,
+                        maxTokens: laneCapability.laneMaxOutputTokens,
+                        tools: toolSurface.tools,
+                        maxTurns: 6,
+                        beforeToolCall: toolSurface.beforeToolCall,
                         signal,
                         // Core/soul/role are all static per configuration — the provider can cache the prefix.
                         cacheRetention: "short",
@@ -449,9 +508,38 @@ export class BackgroundLaneController {
      * {@link validateWorkerResult} before acceptance, and persist result + lane record + spawned
      * usage (idempotent per-lane reportId). Consumed by the `delegate` tool.
      */
-    async runWorkerDelegationOnce(request) {
+    startWorkerDelegation(request) {
+        const settings = this.deps.getSettingsManager().getWorkerDelegationSettings();
+        const foreground = this.deps.getModel();
+        const managedLocal = foreground?.provider === "ollama" || foreground?.provider === "transformers";
+        if (managedLocal) {
+            if (this._queuedWorkers.size >= 8 ||
+                this._laneTracker.getActiveCount("worker") >= settings.maxConcurrent + 8) {
+                return { started: false, skipReason: "worker_delegation_queue_full" };
+            }
+            const record = this._laneTracker.enqueue({ type: "worker" });
+            this._queuedWorkers.set(record.laneId, request);
+            this._scheduleWorkerNotification();
+            return { started: true, record };
+        }
+        let startedRecord;
+        const promise = this.runWorkerDelegationOnce(request, (record) => {
+            startedRecord = record;
+        });
+        if (!startedRecord) {
+            // Preparation is synchronous up to the first isolated completion await. A promise that
+            // rejected before producing a lane is still observed below, so it cannot become unhandled.
+            void promise.catch(() => undefined);
+            return { started: false, skipReason: "worker_not_started" };
+        }
+        this._workerPromises.set(startedRecord.laneId, promise);
+        void promise.then(() => this._workerPromises.delete(startedRecord?.laneId ?? ""), () => this._workerPromises.delete(startedRecord?.laneId ?? ""));
+        return { started: true, record: startedRecord };
+    }
+    async runWorkerDelegationOnce(request, onStarted, existingRecord) {
         const delegationSettings = this.deps.getSettingsManager().getWorkerDelegationSettings();
-        if (this._laneTracker.getActiveCount("worker") >= delegationSettings.maxConcurrent) {
+        const activeWorkers = this._laneTracker.getActiveCount("worker") - (existingRecord ? 1 : 0);
+        if (activeWorkers >= delegationSettings.maxConcurrent) {
             return { started: false, skipReason: "worker_delegation_already_running" };
         }
         if (this.deps.isDisposed()) {
@@ -462,6 +550,9 @@ export class BackgroundLaneController {
             return { started: false, skipReason: "missing_instructions" };
         }
         const settings = delegationSettings;
+        if (!this.deps.isDelegateToolActive()) {
+            return { started: false, skipReason: "delegate_tool_inactive" };
+        }
         if (!settings.enabled) {
             return { started: false, skipReason: "worker_delegation_disabled" };
         }
@@ -470,29 +561,45 @@ export class BackgroundLaneController {
             return { started: false, skipReason: shipment.skipReason };
         }
         const { model, laneProfile } = shipment;
+        const laneCapability = this._laneCapabilityProfile(model);
+        if (!laneCapability.backgroundLanesEnabled) {
+            return { started: false, skipReason: "model_delegation_unsupported" };
+        }
         this._laneTracker.ensureCounterAtLeast(getLaneRecordSnapshots(this.deps.getSessionManager().getEntries()).length + 1);
-        const startedRecord = this._laneTracker.start({ type: "worker" });
+        const startedRecord = existingRecord ?? this._laneTracker.start({ type: "worker" });
+        if (existingRecord)
+            this._laneTracker.markRunning(existingRecord.laneId);
+        onStarted?.(startedRecord);
         const maxUsd = Math.min(settings.maxUsd, this.deps.getCapabilityEnvelope()?.maxEstimatedUsd ?? Number.POSITIVE_INFINITY);
+        const writeEnabled = settings.writeEnabled && settings.writePaths.length > 0;
+        const toolSurface = createLaneToolSurface({
+            cwd: this.deps.getCwd(),
+            profile: laneProfile,
+            writeEnabled,
+            writePaths: settings.writePaths,
+        });
+        this._warnUnboundLaneToolGrants(laneProfile, toolSurface);
+        const allowedActionOps = new Set(toolSurface.allowedTools.filter((name) => name === "write" || name === "edit"));
+        const writeGranted = writeEnabled && allowedActionOps.size > 0;
         const workerRequest = {
             id: startedRecord.laneId,
             instructions,
             route: {
                 tier: "cheap",
-                risk: "read-only",
+                risk: writeGranted ? "scoped-write" : "read-only",
                 confidence: 1,
                 reasonCode: "scout_worker",
-                reasons: ["Read-only scout delegation"],
+                reasons: [writeGranted ? "Path-scoped worker delegation" : "Read-only scout delegation"],
             },
             envelope: {
                 id: `worker-${this.deps.getSessionId()}-${startedRecord.laneId}`,
                 profileId: laneProfile?.name,
                 // write_files 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: settings.writeEnabled && settings.writePaths.length > 0 ? ["read_files", "write_files"] : ["read_files"],
-                ...(settings.writeEnabled && settings.writePaths.length > 0
-                    ? { allowedPaths: [...settings.writePaths] }
-                    : {}),
-                ...this._laneProfileToolGrants(laneProfile),
+                capabilities: writeGranted ? ["read_files", "write_files"] : ["read_files"],
+                ...(writeGranted ? { allowedPaths: [...settings.writePaths] } : {}),
+                allowedTools: [...toolSurface.allowedTools],
+                deniedTools: [...toolSurface.deniedTools],
                 maxEstimatedUsd: maxUsd,
                 createdAt: new Date().toISOString(),
             },
@@ -513,17 +620,39 @@ export class BackgroundLaneController {
         const usageReportId = `worker:${this.deps.getSessionId()}:${startedRecord.laneId}`;
         try {
             let spentUsage;
+            const toolChangedFiles = new Set();
+            const toolIssues = new Set();
             const outcome = await runWorker({
                 request: workerRequest,
                 maxUsd,
                 maxWallClockMs: settings.maxWallClockMs,
                 usageReportId,
+                getChangedFiles: () => [...toolChangedFiles],
                 signal: this._workerDelegationAbort.signal,
                 // Parent validation must use the same relative-path baseline the runner reports in.
                 cwd: this.deps.getCwd(),
                 // Write lane (G2): runner-side action application through the envelope path scope.
                 applyActions: workerRequest.envelope.capabilities.includes("write_files")
-                    ? (actions) => applyWorkerActions({ actions, envelope: workerRequest.envelope, cwd: this.deps.getCwd() })
+                    ? (actions) => {
+                        const permitted = actions.filter((action) => allowedActionOps.has(action.op));
+                        const applied = applyWorkerActions({
+                            actions: permitted,
+                            envelope: workerRequest.envelope,
+                            cwd: this.deps.getCwd(),
+                        });
+                        return {
+                            ...applied,
+                            refused: [
+                                ...actions
+                                    .filter((action) => !allowedActionOps.has(action.op))
+                                    .map((action) => ({
+                                    path: action.path,
+                                    reason: `${action.op} is not granted by the lane profile`,
+                                })),
+                                ...applied.refused,
+                            ],
+                        };
+                    }
                     : undefined,
                 complete: async ({ systemPrompt, userPrompt, signal }) => {
                     const completion = await this.deps.runIsolatedCompletion({
@@ -537,7 +666,45 @@ export class BackgroundLaneController {
                         messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }],
                         model,
                         thinkingLevel: laneProfile?.thinking ?? "off",
-                        maxTokens: this._laneCapabilityProfile(model).laneMaxOutputTokens,
+                        maxTokens: laneCapability.laneMaxOutputTokens,
+                        tools: toolSurface.tools,
+                        maxTurns: 6,
+                        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));
+                                    }
+                                }
+                            }
+                            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",
@@ -547,6 +714,8 @@ export class BackgroundLaneController {
                         text: completion.text,
                         costUsd: completion.usage.cost.total,
                         stopReason: String(completion.stopReason),
+                        changedFiles: [...toolChangedFiles],
+                        blockers: [...toolIssues],
                     };
                 },
             });
@@ -556,6 +725,8 @@ export class BackgroundLaneController {
                     status: "canceled",
                     reasonCode: "session_disposed",
                 });
+                if (record)
+                    this._recordWorkerTerminal(record.status);
                 return { started: true, record, outcome };
             }
             this.deps.saveWorkerResultSnapshot(outcome.result, workerRequest);
@@ -568,6 +739,7 @@ export class BackgroundLaneController {
                 costUsd: outcome.costUsd,
             });
             if (record) {
+                this._recordWorkerTerminal(record.status);
                 appendLaneRecordSnapshot(this.deps.getSessionManager(), record);
                 // G3: worker lane terminal record -> worker_result event. Lane outcome only
                 // (status/reasonCode/cost) — never the worker's summary/changed-file text.
@@ -590,6 +762,8 @@ export class BackgroundLaneController {
                 status: "failed",
                 reasonCode: "worker_delegation_error",
             });
+            if (record)
+                this._recordWorkerTerminal(record.status);
             if (record && !this.deps.isDisposed()) {
                 appendLaneRecordSnapshot(this.deps.getSessionManager(), record);
                 this.deps.emitAutonomyTelemetry({
@@ -688,6 +862,41 @@ export class BackgroundLaneController {
         }
         return { started: true, model: modelRef, report };
     }
+    /** Start queued local workers at the owner session's foreground-idle boundary. */
+    drainQueuedWorkerDelegations() {
+        for (const [laneId, request] of [...this._queuedWorkers]) {
+            if (this._laneTracker.getActiveCount("worker") >
+                this.deps.getSettingsManager().getWorkerDelegationSettings().maxConcurrent)
+                break;
+            const record = this._laneTracker.getRecords().find((candidate) => candidate.laneId === laneId);
+            if (!record) {
+                this._queuedWorkers.delete(laneId);
+                continue;
+            }
+            this._queuedWorkers.delete(laneId);
+            const promise = this.runWorkerDelegationOnce(request, undefined, record);
+            this._workerPromises.set(laneId, promise);
+            void promise.then((outcome) => {
+                if (!outcome.started) {
+                    const terminal = this._laneTracker.complete(laneId, {
+                        status: "canceled",
+                        reasonCode: outcome.skipReason,
+                    });
+                    if (terminal)
+                        this._recordWorkerTerminal(terminal.status);
+                }
+                this._workerPromises.delete(laneId);
+            }, () => {
+                const terminal = this._laneTracker.complete(laneId, {
+                    status: "failed",
+                    reasonCode: "worker_background_error",
+                });
+                if (terminal)
+                    this._recordWorkerTerminal(terminal.status);
+                this._workerPromises.delete(laneId);
+            });
+        }
+    }
     /** Fitness reports persisted for THIS host (measured evidence for architect/profile decisions). */
     getStoredFitnessReports() {
         try {