@runfusion/fusion 0.75.1-beta.1 → 0.75.1-beta.2

package/dist/extension.js

@@ -1103,6 +1103,9 @@ function isFusionSiblingBranch(branch) {
 function resolveEffectiveAutoMerge(task, settings) {
   return task.autoMerge ?? settings.autoMerge;
 }
+function hasUserAutoMergeHold(task) {
+  return task.autoMerge === false && task.autoMergeProvenance === "user";
+}
 function allowsAutoMergeProcessing(task, settings) {
   return (settings.autoMerge !== false || task.autoMerge === true) && !taskHasManualOpenPullRequest(task);
 }
@@ -63343,7 +63346,7 @@ function rowToTask(row) {
     executionStartBranch: row.executionStartBranch || void 0,
     branch: row.branch || void 0,
     autoMerge: row.autoMerge === null ? void 0 : row.autoMerge === 1,
-    autoMergeProvenance: row.autoMergeProvenance === "user" || row.autoMergeProvenance === "legacy-stamp" ? row.autoMergeProvenance : void 0,
+    autoMergeProvenance: row.autoMergeProvenance === "user" || row.autoMergeProvenance === "mission" || row.autoMergeProvenance === "legacy-stamp" ? row.autoMergeProvenance : void 0,
     baseCommitSha: row.baseCommitSha || void 0,
     scopeOverride: row.scopeOverride ? true : void 0,
     scopeOverrideReason: row.scopeOverrideReason || void 0,
@@ -72859,10 +72862,10 @@ ${feature.acceptanceCriteria}`);
               Apply the selected Missions header workflow atomically during TaskStore.createTask so newly triaged features land in the intended workflow lane. Duplicate-guard reuses skip this create path, preserving existing duplicate tasks without workflow mutation.
               */
               /*
-              FNXC:MissionAutoMerge 2026-07-18-12:00:
-              An autoMerge:false mission stamps each newly triaged task so its shared branch produces one PR instead of per-task auto-merges. Duplicate reuse intentionally bypasses this create-only override.
+              FNXC:MissionAutoMerge 2026-08-05-22:50:
+              An autoMerge:false mission stamps each newly triaged task as mission policy so its shared branch produces one PR instead of per-task auto-merges. Duplicate reuse intentionally bypasses this create-only override; policy must not impersonate an operator manual-hold choice.
               */
-              ...mission?.autoMerge === false ? { autoMerge: false } : {},
+              ...mission?.autoMerge === false ? { autoMerge: false, autoMergeProvenance: "mission" } : {},
               // FNXC:MissionTaskPrefix 2026-07-26-12:00: thread the mission's optional taskPrefix into TaskCreateInput for distributed id minting.
               ...mission?.taskPrefix ? { taskPrefix: mission.taskPrefix } : {},
               ...branchOptions?.workflowId !== void 0 ? { workflowId: branchOptions.workflowId } : {}
@@ -76040,10 +76043,10 @@ ${feature.acceptanceCriteria}`);
                 }
               } : {},
               /*
-              FNXC:MissionAutoMerge 2026-07-18-12:00:
-              An autoMerge:false mission stamps each newly triaged task so its shared branch produces one PR instead of per-task auto-merges. Duplicate reuse intentionally bypasses this create-only override.
+              FNXC:MissionAutoMerge 2026-08-05-22:50:
+              An autoMerge:false mission stamps each newly triaged task as mission policy so its shared branch produces one PR instead of per-task auto-merges. Duplicate reuse intentionally bypasses this create-only override; policy must not impersonate an operator manual-hold choice.
               */
-              ...mission?.autoMerge === false ? { autoMerge: false } : {},
+              ...mission?.autoMerge === false ? { autoMerge: false, autoMergeProvenance: "mission" } : {},
               // FNXC:MissionTaskPrefix 2026-07-26-12:00: thread the mission's optional taskPrefix into TaskCreateInput so the distributed allocator mints ERR-N (etc.) instead of the project prefix.
               ...mission?.taskPrefix ? { taskPrefix: mission.taskPrefix } : {},
               ...branchOptions?.workflowId !== void 0 ? { workflowId: branchOptions.workflowId } : {}
@@ -86394,7 +86397,9 @@ async function _createTaskInternalBackendImpl(store, input, title, resolvedWorkf
     sourceMetadata: withTaskBranchContextInSourceMetadata(input.source?.sourceMetadata, input.branchContext),
     branchContext: input.branchContext,
     autoMerge: input.autoMerge,
-    autoMergeProvenance: input.autoMerge === void 0 ? void 0 : "user",
+    // FNXC:SharedBranchMemberHold 2026-08-05-22:50: trusted mission creation
+    // preserves policy provenance; operator/API create requests retain user provenance.
+    autoMergeProvenance: input.autoMerge === void 0 ? void 0 : input.autoMergeProvenance ?? "user",
     // FNXC:CodingIdeasWorkflow 2026-07-05-19:45: land the task in its
     // workflow's manual intake column (e.g. Coding (Ideas) → "ideas") when
     // no explicit column is given (main FN-7591 parity).
@@ -127272,6 +127277,7 @@ var init_task_timing = __esm({
 });
 
 // ../core/src/session-identity-registry.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { resolve as resolve21 } from "node:path";
 import { realpathSync as realpathSync5 } from "node:fs";
 function getRegistry() {
@@ -127283,6 +127289,16 @@ function getRegistry() {
   }
   return registry3;
 }
+function getActiveInvocationStorage() {
+  const holder = globalThis;
+  const existing = holder[ACTIVE_INVOCATION_KEY];
+  if (existing instanceof AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new AsyncLocalStorage();
+  holder[ACTIVE_INVOCATION_KEY] = storage;
+  return storage;
+}
 function canonicalizeCwd(cwd) {
   const resolved = resolve21(cwd);
   try {
@@ -127310,8 +127326,13 @@ function registerFusionSessionIdentity(cwd, identity) {
   };
 }
 function resolveFusionSessionPrincipal(cwd) {
+  const canonicalCwd = canonicalizeCwd(cwd);
+  const activeInvocation = getActiveInvocationStorage().getStore();
+  if (activeInvocation?.cwdKeys.has(canonicalCwd)) {
+    return { kind: "agent", identity: activeInvocation.identity };
+  }
   const registry3 = getRegistry();
-  const list = registry3.get(canonicalizeCwd(cwd));
+  const list = registry3.get(canonicalCwd);
   if (!list || list.length === 0) {
     return { kind: "operator" };
   }
@@ -127320,14 +127341,24 @@ function resolveFusionSessionPrincipal(cwd) {
   }
   return { kind: "ambiguous", identities: [...list] };
 }
+function runWithFusionSessionIdentity(cwdKeys, identity, callback) {
+  const invocation = {
+    identity: { ...identity, registeredAt: Date.now() },
+    cwdKeys: new Set(cwdKeys.map(canonicalizeCwd))
+  };
+  return getActiveInvocationStorage().run(invocation, callback);
+}
 function __clearFusionSessionIdentityRegistryForTests() {
-  globalThis[REGISTRY_KEY] = /* @__PURE__ */ new Map();
+  const holder = globalThis;
+  holder[REGISTRY_KEY] = /* @__PURE__ */ new Map();
+  holder[ACTIVE_INVOCATION_KEY] = new AsyncLocalStorage();
 }
-var REGISTRY_KEY;
+var REGISTRY_KEY, ACTIVE_INVOCATION_KEY;
 var init_session_identity_registry = __esm({
   "../core/src/session-identity-registry.ts"() {
     "use strict";
     REGISTRY_KEY = "__FUSION_SESSION_IDENTITY_REGISTRY_V1__";
+    ACTIVE_INVOCATION_KEY = "__FUSION_SESSION_IDENTITY_ACTIVE_INVOCATION_V1__";
   }
 });
 
@@ -128298,6 +128329,7 @@ __export(src_exports, {
   hasRoleOverrides: () => hasRoleOverrides,
   hasSyncPassphraseConfigured: () => hasSyncPassphraseConfigured,
   hasTitleIdDrift: () => hasTitleIdDrift,
+  hasUserAutoMergeHold: () => hasUserAutoMergeHold,
   hashWorkflowIr: () => hashWorkflowIr,
   healSchemaDrift: () => healSchemaDrift,
   importMcpServersJson: () => importMcpServersJson,
@@ -128758,6 +128790,7 @@ __export(src_exports, {
   runMemoryBackupCommand: () => runMemoryBackupCommand,
   runReconciliationAbort: () => runReconciliationAbort,
   runScheduledEvalBatch: () => runScheduledEvalBatch,
+  runWithFusionSessionIdentity: () => runWithFusionSessionIdentity,
   sanitizeBranchSegment: () => sanitizeBranchSegment,
   sanitizeCliAgentSettings: () => sanitizeCliAgentSettings,
   sanitizeCliAgentsSettings: () => sanitizeCliAgentsSettings,
@@ -157407,6 +157440,7 @@ import { existsSync as existsSync43, readFileSync as readFileSync15, realpathSyn
 import { exec as exec2, execFile as execFile7 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
 import { createRequire as createRequire5 } from "node:module";
+import { randomUUID as randomUUID42 } from "node:crypto";
 import { basename as basename13, dirname as dirname21, join as join56, relative as relative6, isAbsolute as isAbsolute8, resolve as resolve24 } from "node:path";
 import {
   createAgentSession,
@@ -159117,7 +159151,8 @@ async function createFnAgent2(options) {
     });
   };
   const sessionIdentity = (() => {
-    const principalAgentId = options.actionGateContext?.agentId ?? options.permanentAgentGating?.requester?.actorId ?? "engine-session";
+    const namedAgentId = options.actionGateContext?.agentId ?? options.permanentAgentGating?.requester?.actorId;
+    const principalAgentId = namedAgentId ?? `engine-session-${randomUUID42()}`;
     const principalAgentName = options.actionGateContext?.agentName ?? options.permanentAgentGating?.requester?.actorName;
     return {
       agentId: principalAgentId,
@@ -159129,6 +159164,14 @@ async function createFnAgent2(options) {
   const sessionIdentityKeys = [...new Set([options.cwd, resolvedProjectRoot].filter((key) => Boolean(key)))];
   const attachSessionIdentity = (session) => {
     const identityDisposers = sessionIdentityKeys.map((key) => registerFusionSessionIdentity(key, sessionIdentity));
+    const sessionInvocations = session;
+    const wrapInvocation = (methodName) => {
+      const original = sessionInvocations[methodName];
+      if (typeof original !== "function") return;
+      sessionInvocations[methodName] = (...args) => runWithFusionSessionIdentity(sessionIdentityKeys, sessionIdentity, () => original.apply(session, args));
+    };
+    wrapInvocation("prompt");
+    wrapInvocation("promptWithFallback");
     const disposeBeforeIdentity = typeof session.dispose === "function" ? session.dispose.bind(session) : () => void 0;
     session.dispose = async () => {
       for (const disposeIdentity of identityDisposers) {
@@ -167328,10 +167371,11 @@ function createMergeAttemptHandler(deps) {
     );
   };
 }
-function createMergeGateHandler() {
+function createMergeGateHandler(deps = {}) {
   return async (_node, ctx) => {
     const settingsAutoMerge = ctx.settings?.autoMerge;
-    const autoMerge = ctx.task.autoMerge !== false && settingsAutoMerge !== false;
+    const settings = { autoMerge: settingsAutoMerge ?? true };
+    const autoMerge = !hasUserAutoMergeHold(ctx.task) && (await deps.isLiveSharedBranchMember?.(ctx.task, settings) === true || ctx.task.autoMerge !== false && settings.autoMerge !== false);
     return {
       outcome: "success",
       value: autoMerge ? "auto-on" : "auto-off"
@@ -167341,6 +167385,7 @@ function createMergeGateHandler() {
 var init_merge_runner = __esm({
   "../engine/src/workflow-node-runners/merge-runner.ts"() {
     "use strict";
+    init_src2();
     init_workflow_merge_nodes();
   }
 });
@@ -167684,7 +167729,7 @@ function createDefaultNodeHandlers(seams, runCustomNode, deps) {
     "parse-steps": parseSteps,
     code: createCodeNodeHandler(deps?.runCode),
     notify: createNotifyHandler(deps?.notifyDispatch),
-    "merge-gate": createMergeGateHandler(),
+    "merge-gate": createMergeGateHandler({ isLiveSharedBranchMember: deps?.isLiveSharedBranchMember }),
     "merge-attempt": createMergeAttemptHandler({
       primitives: deps?.primitives,
       seams,
@@ -168082,7 +168127,7 @@ var init_code_node_runner = __esm({
 // ../engine/src/agent-tools.ts
 import { appendFile as appendFile3, mkdir as mkdir26, readFile as readFile32, readdir as readdir9, realpath, stat as stat9, writeFile as writeFile24 } from "node:fs/promises";
 import { existsSync as existsSync50 } from "node:fs";
-import { createHash as createHash19, randomUUID as randomUUID42 } from "node:crypto";
+import { createHash as createHash19, randomUUID as randomUUID43 } from "node:crypto";
 import { tmpdir as tmpdir5 } from "node:os";
 import { extname as extname3, isAbsolute as isAbsolute12, join as join62, relative as relative11, resolve as resolve33, sep as sep9 } from "node:path";
 import { Type as Type2 } from "@earendil-works/pi-ai";
@@ -168728,7 +168773,7 @@ function createTaskCreateTool(store, provenance, options) {
               toType: "user",
               type: "agent-to-user",
               content: `Task proposal awaiting validation: ${title}`,
-              metadata: { kind: "task-proposal", proposalStatus: "pending", proposalIdempotencyKey: randomUUID42(), taskId: options.sourceTaskId, proposedTask: { title, description: params.description, priority: params.priority, workflowId: params.workflow_id, dependencies: params.dependencies } }
+              metadata: { kind: "task-proposal", proposalStatus: "pending", proposalIdempotencyKey: randomUUID43(), taskId: options.sourceTaskId, proposedTask: { title, description: params.description, priority: params.priority, workflowId: params.workflow_id, dependencies: params.dependencies } }
             });
             return { content: [{ type: "text", text: "Task proposal submitted to the operator for validation; no task was created." }], details: { proposed: true } };
           }
@@ -202305,16 +202350,29 @@ var init_self_healing = __esm({
           activeWork: await this.resolveActiveWorkColumnsFor(taskId, cache)
         };
       }
-      classifyPausedAbortWorkflowRecovery(task, settings, isExecuting, columns) {
+      /*
+      FNXC:SharedBranchMemberHold 2026-08-05-23:35:
+      Pause-abort recovery must resolve the same live intermediate-group predicate as
+      merge admission. Shared metadata alone is stale after group closure or a
+      default-branch collision, so it cannot suppress that task's standalone hold.
+      */
+      async isLiveSharedMemberIntegration(task, settings) {
+        const groupId = task.branchContext?.groupId?.trim();
+        const group = groupId ? await this.store.getBranchGroup?.(groupId) : null;
+        const defaultBranch = await resolveIntegrationBranch(this.options.rootDir, settings);
+        return isLiveSharedBranchGroupMemberIntegration(task, group, defaultBranch);
+      }
+      async classifyPausedAbortWorkflowRecovery(task, settings, isExecuting, columns) {
         const isPausedAbortPark = task.status === "failed" && typeof task.error === "string" && task.error.includes(PAUSE_ABORT_PARK_OPERATOR_MARKER) && task.error.includes(PAUSE_ABORT_PARK_ERROR_MARKER);
         if (!isPausedAbortPark) return { kind: "no-action", reason: "not-pause-abort" };
         if (task.paused || task.userPaused || isExecuting) return { kind: "no-action", reason: "unsafe-or-not-routable" };
         const errorText = typeof task.error === "string" ? task.error.toLowerCase() : "";
         const isTerminalMergePark = errorText.includes("conflict") || errorText.includes("contamination") || errorText.includes("foreign") || errorText.includes("retry-exhausted") || errorText.includes("retries exhausted") || errorText.includes("max retries");
         const completedSteps = task.steps.length > 0 && task.steps.every((step) => step.status === "done" || step.status === "skipped");
-        const sharedBranchMember = isSharedBranchGroupMemberIntegration(task);
-        const hasReviewProgress = columns.review.has(task.column) && allowsAutoMergeProcessing(task, settings) && task.mergeDetails?.mergeConfirmed !== true && !isTerminalMergePark && completedSteps;
-        const hasManualMergeHoldProgress = columns.review.has(task.column) && (!allowsAutoMergeProcessing(task, settings) || resolveEffectiveAutoMerge(task, settings) === false) && !sharedBranchMember && task.mergeDetails?.mergeConfirmed !== true && !isTerminalMergePark && completedSteps;
+        const liveSharedBranchMember = await this.isLiveSharedMemberIntegration(task, settings);
+        const autoMergeProcessing = allowsAutoMergeProcessing(task, settings) || liveSharedBranchMember;
+        const hasReviewProgress = columns.review.has(task.column) && autoMergeProcessing && task.mergeDetails?.mergeConfirmed !== true && !isTerminalMergePark && completedSteps;
+        const hasManualMergeHoldProgress = columns.review.has(task.column) && (hasUserAutoMergeHold(task) || !allowsAutoMergeProcessing(task, settings) || resolveEffectiveAutoMerge(task, settings) === false) && (!liveSharedBranchMember || hasUserAutoMergeHold(task)) && task.mergeDetails?.mergeConfirmed !== true && !isTerminalMergePark && completedSteps;
         if (hasManualMergeHoldProgress) {
           return { kind: "work-item-resume", reason: "pause-abort-manual-merge-hold" };
         }
@@ -207982,8 +208040,23 @@ var init_self_healing = __esm({
             return own.length > 0 ? new Set(own) : /* @__PURE__ */ new Set(["in-review"]);
           };
           const executingIds = this.options.getExecutingTaskIds?.() ?? /* @__PURE__ */ new Set();
+          const canRecoverMergeableReviewTask = async (task) => {
+            if (hasUserAutoMergeHold(task)) return false;
+            const groupId = task.branchContext?.groupId?.trim();
+            const branchGroup = groupId ? await this.store.getBranchGroup(groupId) : null;
+            const projectDefaultBranch = await resolveIntegrationBranch(this.options.rootDir, settings);
+            if (isLiveSharedBranchGroupMemberIntegration(task, branchGroup, projectDefaultBranch)) {
+              return true;
+            }
+            return allowsAutoMergeProcessing(task, settings) && resolveEffectiveAutoMerge(task, settings) !== false;
+          };
+          const mergeAdmission = await Promise.all(tasks2.map(async (task) => [
+            task.id,
+            await canRecoverMergeableReviewTask(task)
+          ]));
+          const mergeAdmissionByTaskId = new Map(mergeAdmission);
           const mergeable = tasks2.filter(
-            (t) => allowsAutoMergeProcessing(t, settings) && !t.paused && !executingIds.has(t.id) && t.status !== "failed" && // Exclude transient merge statuses. Active merges should be left alone;
+            (t) => mergeAdmissionByTaskId.get(t.id) === true && !t.paused && !executingIds.has(t.id) && t.status !== "failed" && // Exclude transient merge statuses. Active merges should be left alone;
             // stale ones are handled by recoverStaleMergingStatus().
             t.status !== "merging" && t.status !== "merging-pr" && // FNXC:Workspace 2026-06-22-09:30 (Phase D U1, KTD1 — admit workspace tasks):
             // A workspace task has task.worktree===null (its worktrees live per-repo in
@@ -211030,7 +211103,7 @@ var init_self_healing = __esm({
           for (const t of tasks2) {
             if (!this.isPauseAbortParkCandidate(t)) continue;
             const columns = await this.resolvePauseAbortColumnsFor(t.id, columnCache);
-            if (this.classifyPausedAbortWorkflowRecovery(t, settings, executingIds.has(t.id), columns).kind !== "no-action") {
+            if ((await this.classifyPausedAbortWorkflowRecovery(t, settings, executingIds.has(t.id), columns)).kind !== "no-action") {
               parked.push(t);
             }
           }
@@ -211047,7 +211120,7 @@ var init_self_healing = __esm({
                 continue;
               }
               const freshColumns = await this.resolvePauseAbortColumnsFor(fresh.id, columnCache);
-              const route = this.classifyPausedAbortWorkflowRecovery(fresh, settings, latestExecutingIds.has(fresh.id), freshColumns);
+              const route = await this.classifyPausedAbortWorkflowRecovery(fresh, settings, latestExecutingIds.has(fresh.id), freshColumns);
               if (route.kind === "no-action") {
                 continue;
               }
@@ -218098,7 +218171,8 @@ var init_workflow_graph_executor = __esm({
             parseSteps: deps.parseStepsDeps,
             runCode: deps.runCode,
             notifyDispatch: deps.notifyDispatch,
-            prNodes: deps.prNodes
+            prNodes: deps.prNodes,
+            isLiveSharedBranchMember: deps.isLiveSharedBranchMember
           }),
           ...deps.runnerRegistry?.toHandlers() ?? {},
           ...deps.handlers ?? {}
@@ -219334,6 +219408,10 @@ var init_workflow_graph_task_runner = __esm({
             runCode: this.deps.runCode,
             notifyDispatch: this.deps.notifyDispatch,
             prNodes: this.deps.prNodes,
+            // FNXC:SharedBranchMemberHold 2026-08-06-00:24: carry the executor's
+            // live group resolver into the graph merge gate; omitting it turns
+            // mission-policy members into manual holds before integration.
+            isLiveSharedBranchMember: this.deps.isLiveSharedBranchMember,
             /*
             FNXC:WorkflowResume 2026-06-29-08:49:
             Production graph runs must fetch live task steps during foreach replay. The runner is the workflow boundary that has store access, so it supplies the fresh projection seam instead of making executor self-healing guess after a stale step node fails.
@@ -227446,6 +227524,7 @@ ${feedback}`,
         if (info.phase !== "pre-merge") return false;
         if (info.status !== "advisory_failure" && info.status !== "failed") return false;
         const liveTask = await this.store.getTask(taskId).catch(() => fallbackTask);
+        if (hasUserAutoMergeHold(liveTask)) return false;
         const missingArtifactKeys = parseRequiredArtifactMissingValue(info.failureValue);
         if (missingArtifactKeys) {
           await this.recoverMissingRequiredArtifacts(liveTask, missingArtifactKeys, {
@@ -227702,6 +227781,7 @@ ${info.feedback}`, revisionKey),
        */
       async recoverFailedPreMergeWorkflowStep(task) {
         try {
+          if (hasUserAutoMergeHold(task)) return false;
           const failed = (task.workflowStepResults ?? []).filter((r) => (r.phase || "pre-merge") === "pre-merge" && r.status === "failed").sort((a, b3) => {
             const aTs = Date.parse(a.completedAt || a.startedAt || "");
             const bTs = Date.parse(b3.completedAt || b3.startedAt || "");
@@ -228228,6 +228308,7 @@ ${info.feedback}`, revisionKey),
               getTask: (taskId) => this.store.getTask(taskId)
             },
             runId: resolvedRunId,
+            isLiveSharedBranchMember: (nodeTask) => this.isLiveSharedBranchGroupMember(nodeTask),
             primitives: this.createAuthoritativeWorkflowPrimitives(settings),
             seams: this.createAuthoritativeWorkflowSeams(settings),
             prepareNodeExecution: (node, nodeTask, requirement) => this.prepareGraphNodeExecution(node, nodeTask, settings, requirement),
@@ -231169,6 +231250,7 @@ Graph value: ${failureValue}` : ""}`, budget.key),
         } catch {
           return false;
         }
+        if (hasUserAutoMergeHold(live)) return false;
         const sharedBranchMember = await this.isLiveSharedBranchGroupMember(live);
         if (!sharedBranchMember && !allowsAutoMergeProcessing(live, settings)) return false;
         if (!sharedBranchMember && resolveEffectiveAutoMerge(live, settings) === false) return false;
@@ -231230,8 +231312,8 @@ Graph value: ${failureValue}` : ""}`, budget.key),
         } catch {
           return false;
         }
-        if (await this.isLiveSharedBranchGroupMember(live)) return false;
-        return !allowsAutoMergeProcessing(live, settings) || resolveEffectiveAutoMerge(live, settings) === false;
+        if (await this.isLiveSharedBranchGroupMember(live) && !hasUserAutoMergeHold(live)) return false;
+        return hasUserAutoMergeHold(live) || !allowsAutoMergeProcessing(live, settings) || resolveEffectiveAutoMerge(live, settings) === false;
       }
       async handleStaleInReviewPlanPauseAbortReplay(live, result2, abortProvenance, pausedAborted, userCanceled, resumeLanesMemo) {
         if (!pausedAborted) return false;
@@ -231395,9 +231477,9 @@ Graph value: ${failureValue}` : ""}`, budget.key),
           if (settings.globalPause === true) return false;
         }
         if (live.column === resumeLanes.review) {
-          if (live.autoMerge === false) return false;
           if (!settings) return false;
           const sharedBranchMember = await this.isLiveSharedBranchGroupMember(live);
+          if (hasUserAutoMergeHold(live) || live.autoMerge === false && !sharedBranchMember) return false;
           if (!sharedBranchMember && !allowsAutoMergeProcessing(live, settings)) return false;
           if (live.mergeDetails?.mergeConfirmed === true) return false;
         }
@@ -248472,7 +248554,7 @@ var init_metric_parser = __esm({
 });
 
 // ../engine/src/eval/experiment-executor.ts
-import { randomUUID as randomUUID43 } from "node:crypto";
+import { randomUUID as randomUUID44 } from "node:crypto";
 var ExperimentMaxIterationsError, ExperimentGitNotConfiguredError, ExperimentExecutor;
 var init_experiment_executor = __esm({
   "../engine/src/eval/experiment-executor.ts"() {
@@ -248540,7 +248622,7 @@ var init_experiment_executor = __esm({
         }
         await this.semaphore.acquire();
         const controller = new AbortController();
-        const runHandle = randomUUID43();
+        const runHandle = randomUUID44();
         if (opts?.abortSignal) {
           opts.abortSignal.addEventListener("abort", () => controller.abort(), { once: true });
         }
@@ -257547,6 +257629,7 @@ var init_in_process_runtime = __esm({
             }
           }
           const prNodeGithubOps = this.config.prNodeGithubOps;
+          const secretsStore = await this.taskStore.getSecretsStore();
           const executorOptions = {
             /*
             FNXC:PlanReviewLease 2026-07-26-21:12:
@@ -257562,6 +257645,7 @@ var init_in_process_runtime = __esm({
             cliAgentRuntime: this.cliAgentRuntime?.bundle,
             pluginRunner: this.pluginRunner,
             messageStore: this.messageStore,
+            secretsStore,
             missionStore,
             reflectionService,
             // PR-entity nodes (U3): assemble the handler deps from the CLI-injected
@@ -257663,6 +257747,7 @@ var init_in_process_runtime = __esm({
               reflectionService,
               selfImproveService,
               credentialRotator: this.credentialRotator,
+              secretsStore,
               snapshotManager: autoClaimSnapshotManager,
               onMissed: (agentId, reason) => {
                 runtimeLog.warn(`Agent ${agentId} missed heartbeat: ${reason}`);
@@ -261524,7 +261609,21 @@ var init_project_engine = __esm({
       Cleared on the first non-busy outcome (success path resets it).
       */
       workspaceBusyReenqueues = /* @__PURE__ */ new Map();
+      workspaceBusyReenqueueTimers = /* @__PURE__ */ new Set();
       static WORKSPACE_BUSY_MAX_REENQUEUES = 10;
+      /*
+      FNXC:WorkspaceMergeDispatch 2026-08-05-23:56:
+      Workspace lease-contention retries are engine-owned lifecycle work, not detached callbacks.
+      Track only these busy re-enqueue timers so stop() can cancel them and tests can measure the
+      capped workspace ladder without confusing it with merge-body or maintenance timers.
+      */
+      scheduleWorkspaceBusyReenqueue(taskId, delayMs) {
+        const timer2 = setTimeout(() => {
+          this.workspaceBusyReenqueueTimers.delete(timer2);
+          if (!this.shuttingDown) this.internalEnqueueMerge(taskId);
+        }, delayMs);
+        this.workspaceBusyReenqueueTimers.add(timer2);
+      }
       /**
        * Pending manual merge resolvers — keyed by taskId.
        * When `onMerge` is called, the task is enqueued like auto-merge but a
@@ -262059,6 +262158,10 @@ ${detail}`);
           clearInterval(this.mergeActiveReconcileTimer);
           this.mergeActiveReconcileTimer = null;
         }
+        for (const timer2 of this.workspaceBusyReenqueueTimers) {
+          clearTimeout(timer2);
+        }
+        this.workspaceBusyReenqueueTimers.clear();
         for (const [taskId, deferred] of this.capacityDeferredMerges) {
           clearTimeout(deferred.timer);
           for (const resolver of deferred.resolvers) {
@@ -263358,16 +263461,15 @@ ${detail}`);
        * older low-priority task would start before a later urgent one.
        */
       async allowInReviewMergeProcessing(task, settings, store = this.runtime.getTaskStore()) {
-        if (allowsAutoMergeProcessing(task, settings)) {
-          return true;
-        }
+        if (hasUserAutoMergeHold(task)) return false;
         const groupId = task.branchContext?.groupId?.trim();
         const branchGroup = groupId ? await store.getBranchGroup?.(groupId) : null;
-        if (!branchGroup || branchGroup.status !== "open" || !branchGroup.branchName.trim()) {
-          return false;
-        }
         const projectDefaultBranch = await resolveIntegrationBranch(this.config.workingDirectory, settings);
-        return isLiveSharedBranchGroupMemberIntegration(task, branchGroup, projectDefaultBranch);
+        if (isLiveSharedBranchGroupMemberIntegration(task, branchGroup, projectDefaultBranch)) {
+          return true;
+        }
+        if (task.autoMerge === false && groupId) return false;
+        return allowsAutoMergeProcessing(task, settings);
       }
       async emitLegacyAutoMergeStampAdvisory(store) {
         if (this.legacyAutoMergeStampAdvisoryEmitted) {
@@ -264320,9 +264422,7 @@ ${detail}`);
                   runtimeLog.log(
                     `Workspace land busy re-enqueue ${busyCount + 1}/${_ProjectEngine.WORKSPACE_BUSY_MAX_REENQUEUES} for ${taskId} in ${delayMs / 1e3}s (no mergeRetry consumed \u2014 pure lease contention)`
                   );
-                  setTimeout(() => {
-                    if (!this.shuttingDown) this.internalEnqueueMerge(taskId);
-                  }, delayMs);
+                  this.scheduleWorkspaceBusyReenqueue(taskId, delayMs);
                 } else {
                   this.workspaceBusyReenqueues.delete(taskId);
                   await store.updateTask(taskId, { status: "failed", error: errorMsg }).catch(() => void 0);
@@ -267814,7 +267914,7 @@ var init_task_lifecycle_lanes = __esm({
 });
 
 // ../dashboard/src/ai-session-diagnostics.ts
-import { randomUUID as randomUUID44 } from "node:crypto";
+import { randomUUID as randomUUID45 } from "node:crypto";
 function defaultSink(level, scope, message, context) {
   const log41 = createLogger(scope);
   try {
@@ -267857,7 +267957,7 @@ function emit(level, scope, message, context) {
   const fullContext = {
     ...context,
     _emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    _diagnosticsId: randomUUID44()
+    _diagnosticsId: randomUUID45()
   };
   try {
     _sink(level, scope, message, fullContext);
@@ -268573,7 +268673,7 @@ var init_planning_board_tools = __esm({
 });
 
 // ../dashboard/src/planning.ts
-import { randomUUID as randomUUID45 } from "node:crypto";
+import { randomUUID as randomUUID46 } from "node:crypto";
 import { EventEmitter as EventEmitter34 } from "node:events";
 async function createPlanningRuntimeSession(options) {
   const { pluginRunner, runtimeHint, settings, ...runtimeOptions } = options ?? {};
@@ -268956,7 +269056,7 @@ async function createSession(ip, initialPlan, store, rootDir, promptOverrides, p
   if (!store) {
     throw new Error("store is required for AI-powered planning sessions");
   }
-  const sessionId = randomUUID45();
+  const sessionId = randomUUID46();
   const session = {
     id: sessionId,
     ip,
@@ -269526,7 +269626,7 @@ function normalizePlanningQuestion(input, userInput = "") {
   const type = source.type === "multi_select" || source.type === "single_select" ? source.type : "single_select";
   const question = typeof source.question === "string" && source.question.trim() ? source.question.trim() : fallback.question;
   const normalized = {
-    id: typeof source.id === "string" && source.id.trim() ? source.id : randomUUID45(),
+    id: typeof source.id === "string" && source.id.trim() ? source.id : randomUUID46(),
     type,
     question,
     ...typeof source.description === "string" && source.description.trim() ? { description: source.description.trim() } : {}
@@ -269552,7 +269652,7 @@ function normalizePlanningQuestion(input, userInput = "") {
 }
 function coerceQuestionResponse(response, session) {
   if (response.type === "question") return normalizePlanningQuestion(response.data, session.initialPlan);
-  return normalizePlanningQuestion({ id: randomUUID45(), type: "single_select", question: planningFallbackCopy(session.initialPlan).question }, session.initialPlan);
+  return normalizePlanningQuestion({ id: randomUUID46(), type: "single_select", question: planningFallbackCopy(session.initialPlan).question }, session.initialPlan);
 }
 async function validateSession(sessionId) {
   const session = await getSession(sessionId);
@@ -270300,7 +270400,7 @@ async function createTaskFromPlanSession(sessionId, store, options) {
       throw new InvalidSessionStateError("PLANNING_CREATED_TASK_MISSING");
     }
   }
-  const claimOwnerToken = randomUUID45();
+  const claimOwnerToken = randomUUID46();
   let claimed = await claimPlanningTaskCreation(sessionId, claimOwnerToken, (/* @__PURE__ */ new Date()).toISOString(), claimEpoch);
   if (!claimed) {
     session = await getDurablePlanningSession(sessionId).catch(() => void 0) ?? session;
@@ -282888,7 +282988,7 @@ var init_register_gitlab = __esm({
 
 // ../dashboard/src/terminal.ts
 import { spawn as spawn11 } from "node:child_process";
-import { randomUUID as randomUUID46 } from "node:crypto";
+import { randomUUID as randomUUID47 } from "node:crypto";
 import { EventEmitter as EventEmitter41 } from "node:events";
 function extractBaseCommand(command) {
   let trimmed = command.trim();
@@ -283048,7 +283148,7 @@ var init_terminal = __esm({
         if (!validation.valid) {
           return { sessionId: "", error: validation.error };
         }
-        const sessionId = randomUUID46();
+        const sessionId = randomUUID47();
         const childProcess5 = spawn11(command, [], {
           cwd,
           shell: true,
@@ -284520,7 +284620,7 @@ var init_src8 = __esm({
 
 // ../../plugins/fusion-plugin-openclaw-runtime/src/pi-module.ts
 import { spawn as spawn13 } from "node:child_process";
-import { randomUUID as randomUUID47 } from "node:crypto";
+import { randomUUID as randomUUID48 } from "node:crypto";
 import { readFile as readFile44 } from "node:fs/promises";
 function asString2(v2) {
   return typeof v2 === "string" && v2.trim() !== "" ? v2.trim() : void 0;
@@ -284580,7 +284680,7 @@ function extractStderrError(stderr, stdout) {
 }
 function createCliSession(opts) {
   return {
-    sessionId: randomUUID47(),
+    sessionId: randomUUID48(),
     agentId: opts.agentId ?? DEFAULT_AGENT_ID,
     systemPrompt: opts.systemPrompt,
     messages: [{ role: "developer", content: opts.systemPrompt }],
@@ -284775,7 +284875,7 @@ var init_mcp_config2 = __esm({
 });
 
 // ../../plugins/fusion-plugin-openclaw-runtime/src/runtime-adapter.ts
-import { randomUUID as randomUUID48 } from "node:crypto";
+import { randomUUID as randomUUID49 } from "node:crypto";
 var OpenClawRuntimeAdapter;
 var init_runtime_adapter2 = __esm({
   "../../plugins/fusion-plugin-openclaw-runtime/src/runtime-adapter.ts"() {
@@ -284798,8 +284898,8 @@ var init_runtime_adapter2 = __esm({
         let mcpProfile;
         let mcpConfigPath;
         if (toolDefs.length > 0) {
-          const bridge = writeOpenClawMcpBridgeFiles(toolDefs, randomUUID48());
-          mcpProfile = `fusion-${randomUUID48()}`;
+          const bridge = writeOpenClawMcpBridgeFiles(toolDefs, randomUUID49());
+          mcpProfile = `fusion-${randomUUID49()}`;
           mcpConfigPath = bridge.serverConfigPath;
           await configureOpenClawMcpServer({
             binaryPath: this.config.binaryPath,
@@ -287273,7 +287373,7 @@ import { existsSync as existsSync73, writeFileSync as writeFileSync15 } from "no
 import { tmpdir as tmpdir16 } from "node:os";
 import { dirname as dirname41, join as join93 } from "node:path";
 import { fileURLToPath as fileURLToPath9 } from "node:url";
-import { randomUUID as randomUUID49 } from "node:crypto";
+import { randomUUID as randomUUID50 } from "node:crypto";
 function toolsToMcpToolDefs2(tools) {
   if (!Array.isArray(tools)) return [];
   return tools.filter((tool) => tool && typeof tool.name === "string" && tool.name.trim().length > 0 && !BUILT_IN_TOOL_NAMES2.has(tool.name)).map((tool) => ({
@@ -287324,7 +287424,7 @@ async function startFusionToolBridge(tools) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join93(tmpdir16(), `fusion-grok-mcp-schemas-${process.pid}-${randomUUID49()}.json`);
+  const schemaPath = join93(tmpdir16(), `fusion-grok-mcp-schemas-${process.pid}-${randomUUID50()}.json`);
   writeFileSync15(schemaPath, JSON.stringify(defs));
   const server = createServer2(async (req, res) => {
     if (req.method !== "POST" || req.url !== "/tool-call") {
@@ -287350,7 +287450,7 @@ async function startFusionToolBridge(tools) {
       return;
     }
     try {
-      const result2 = await tool.execute(`grok-mcp-${randomUUID49()}`, parsed.arguments ?? {}, void 0, void 0, void 0);
+      const result2 = await tool.execute(`grok-mcp-${randomUUID50()}`, parsed.arguments ?? {}, void 0, void 0, void 0);
       res.statusCode = 200;
       res.setHeader("content-type", "application/json");
       res.end(
@@ -289394,7 +289494,7 @@ import { existsSync as existsSync77, rmSync as rmSync13, writeFileSync as writeF
 import { tmpdir as tmpdir18 } from "node:os";
 import { dirname as dirname46, join as join98 } from "node:path";
 import { fileURLToPath as fileURLToPath13 } from "node:url";
-import { randomBytes as randomBytes7, randomUUID as randomUUID50 } from "node:crypto";
+import { randomBytes as randomBytes7, randomUUID as randomUUID51 } from "node:crypto";
 function toolsToMcpToolDefs3(tools) {
   if (!Array.isArray(tools)) return [];
   return tools.filter((tool) => tool && typeof tool.name === "string" && tool.name.trim().length > 0 && !BUILT_IN_TOOL_NAMES3.has(tool.name)).map((tool) => ({
@@ -289445,7 +289545,7 @@ async function startFusionToolBridge2(tools, options = {}) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join98(tmpdir18(), `fusion-claude-mcp-schemas-${process.pid}-${randomUUID50()}.json`);
+  const schemaPath = join98(tmpdir18(), `fusion-claude-mcp-schemas-${process.pid}-${randomUUID51()}.json`);
   writeFileSync17(schemaPath, JSON.stringify(defs));
   const capabilityToken = randomBytes7(32).toString("base64url");
   const server = createServer3(async (req, res) => {
@@ -289510,7 +289610,7 @@ async function startFusionToolBridge2(tools, options = {}) {
       return;
     }
     try {
-      const result2 = await tool.execute(`claude-mcp-${randomUUID50()}`, parsed.arguments ?? {}, void 0, void 0, void 0);
+      const result2 = await tool.execute(`claude-mcp-${randomUUID51()}`, parsed.arguments ?? {}, void 0, void 0, void 0);
       res.statusCode = 200;
       res.setHeader("content-type", "application/json");
       res.end(
@@ -291587,7 +291687,7 @@ import { existsSync as existsSync79, unlinkSync as unlinkSync5, writeFileSync as
 import { tmpdir as tmpdir19 } from "node:os";
 import { dirname as dirname49, join as join101 } from "node:path";
 import { fileURLToPath as fileURLToPath15 } from "node:url";
-import { randomUUID as randomUUID51 } from "node:crypto";
+import { randomUUID as randomUUID52 } from "node:crypto";
 function toolsToMcpToolDefs4(tools) {
   if (!Array.isArray(tools)) return [];
   return tools.filter(
@@ -291644,7 +291744,7 @@ async function startFusionToolBridge3(tools) {
       byName.set(tool.name, tool);
     }
   }
-  const schemaPath = join101(tmpdir19(), `fusion-omp-mcp-schemas-${process.pid}-${randomUUID51()}.json`);
+  const schemaPath = join101(tmpdir19(), `fusion-omp-mcp-schemas-${process.pid}-${randomUUID52()}.json`);
   writeFileSync18(schemaPath, JSON.stringify(defs));
   const server = createServer4(async (req, res) => {
     if (req.method !== "POST" || req.url !== "/tool-call") {
@@ -291671,7 +291771,7 @@ async function startFusionToolBridge3(tools) {
     }
     try {
       const result2 = await tool.execute(
-        `omp-mcp-${randomUUID51()}`,
+        `omp-mcp-${randomUUID52()}`,
         parsed.arguments ?? {},
         void 0,
         void 0,
@@ -292564,7 +292664,7 @@ var init_paperclip_client = __esm({
 });
 
 // ../../plugins/fusion-plugin-paperclip-runtime/src/runtime-adapter.ts
-import { randomUUID as randomUUID52 } from "node:crypto";
+import { randomUUID as randomUUID53 } from "node:crypto";
 function sleep7(ms2) {
   return new Promise((resolve54) => setTimeout(resolve54, ms2));
 }
@@ -292693,7 +292793,7 @@ var init_runtime_adapter10 = __esm({
           apiKey: effectiveApiKey,
           agentId,
           companyId,
-          sessionId: randomUUID52(),
+          sessionId: randomUUID53(),
           systemPrompt: options.systemPrompt,
           cwd: options.cwd,
           mode: normalizeMode3(this.config.mode),
@@ -293371,7 +293471,7 @@ var init_types5 = __esm({
 });
 
 // ../dashboard/src/stt/model-manager.ts
-import { createHash as createHash28, randomUUID as randomUUID53 } from "node:crypto";
+import { createHash as createHash28, randomUUID as randomUUID54 } from "node:crypto";
 import { mkdir as mkdir31, open as open4, readFile as readFile46, readdir as readdir11, rename as rename10, rm as rm17, stat as stat12, writeFile as writeFile33 } from "node:fs/promises";
 import { join as join102, relative as relative19, resolve as resolve51, sep as sep15 } from "node:path";
 function parseSafeTarListing(listing) {
@@ -293452,8 +293552,8 @@ function createVoiceModelManager(options = {}) {
       if (!current(g2, signal)) return state;
       await mkdir31(cacheDir(), { recursive: true });
       if (!current(g2, signal)) return state;
-      partial2 = join102(cacheDir(), `.partial-${g2}-${randomUUID53()}`);
-      staging = join102(cacheDir(), `.staging-${g2}-${randomUUID53()}`);
+      partial2 = join102(cacheDir(), `.partial-${g2}-${randomUUID54()}`);
+      staging = join102(cacheDir(), `.staging-${g2}-${randomUUID54()}`);
       const file = await open4(partial2, "wx");
       try {
         const response = await (options.fetch ?? globalThis.fetch)(asset.url, { signal });
@@ -293501,7 +293601,7 @@ function createVoiceModelManager(options = {}) {
       await writeFile33(join102(staging, "manifest.json"), JSON.stringify({ filename: asset.filename, sha256: asset.sha256, installedAt: (/* @__PURE__ */ new Date()).toISOString(), expectedFiles: asset.expectedFiles }));
       await options.beforePromote?.(signal);
       if (!current(g2, signal)) return state;
-      const backup = join102(cacheDir(), `.backup-${g2}-${randomUUID53()}`);
+      const backup = join102(cacheDir(), `.backup-${g2}-${randomUUID54()}`);
       let movedPrevious = false;
       try {
         try {
@@ -293722,7 +293822,7 @@ var init_parakeet_service = __esm({
 });
 
 // ../dashboard/src/routes/register-voice-routes.ts
-import { randomUUID as randomUUID54 } from "node:crypto";
+import { randomUUID as randomUUID55 } from "node:crypto";
 import express from "express";
 async function settingsFor(ctx, req) {
   const scoped = await ctx.getScopedStore(req);
@@ -293801,7 +293901,7 @@ function createRegisterVoiceRoutes(deps = {}) {
           recognizer.close();
           return error2(res, 409, { error: "unavailable", reason: "model-removed" });
         }
-        const id = randomUUID54();
+        const id = randomUUID55();
         const now = Date.now();
         sessions6.set(id, { projectId, recognizer, next: 0, bytes: 0, last: now, expires: now + 3e5 });
         res.status(201).json({ sessionId: id, expiresAt: new Date(now + 3e5).toISOString(), modelId: model.id, language: language.language });
@@ -297127,14 +297227,14 @@ init_src2();
 init_gh_cli();
 init_src5();
 init_src15();
-import { randomUUID as randomUUID55 } from "node:crypto";
+import { randomUUID as randomUUID56 } from "node:crypto";
 import { Type as Type9 } from "typebox";
 import { StringEnum } from "@earendil-works/pi-ai";
 import { resolve as resolve53, relative as relative20, isAbsolute as isAbsolute26, sep as sep16, basename as basename29, extname as extname4, join as join105 } from "node:path";
 import { readFile as readFile47 } from "node:fs/promises";
 import { existsSync as existsSync82 } from "node:fs";
 import { spawn as spawn23 } from "node:child_process";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 function truncateAgentDiagnosticText(value, maxChars) {
   return value.length > maxChars ? `${value.slice(0, maxChars)}\u2026` : value;
 }
@@ -297239,7 +297339,7 @@ var storeCache2 = extensionStoreState.cache;
 var storeBootInflight = extensionStoreState.bootInflight;
 var storeBootFailureCooldown = extensionStoreState.bootFailureCooldown;
 var BOOT_FAILURE_COOLDOWN_MS = 5e3;
-var extensionToolSignal = new AsyncLocalStorage();
+var extensionToolSignal = new AsyncLocalStorage2();
 var EXTENSION_STORE_BOOT_TIMEOUT_MS = 3e4;
 var EXTENSION_TOOL_TIMEOUT_MS = 6e4;
 var SKILLS_INSTALL_TIMEOUT_MS = 3e5;
@@ -297541,6 +297641,28 @@ async function isEphemeralCallerAgent(cwd, callerAgentId) {
   }
 }
 var AMBIGUOUS_AGENT_PRINCIPAL_ID = "unknown-agent";
+function resolveSecretAccessPrincipal(ctx) {
+  const principal = resolveExtensionCallerPrincipal(ctx);
+  if (principal.kind === "ambiguous") return { kind: "ambiguous" };
+  if (principal.kind === "operator") {
+    return {
+      kind: "resolved",
+      actor: { actorId: "user", actorType: "user", actorName: "CLI User" },
+      agentId: null
+    };
+  }
+  return {
+    kind: "resolved",
+    actor: {
+      actorId: principal.identity.agentId,
+      actorType: "agent",
+      actorName: principal.identity.agentName ?? principal.identity.agentId
+    },
+    agentId: principal.identity.agentId,
+    ...principal.identity.agentName ? { agentName: principal.identity.agentName } : {},
+    ...principal.identity.taskId ? { taskId: principal.identity.taskId } : {}
+  };
+}
 function resolveExtensionCallerPrincipal(ctx) {
   const explicitAgentId = typeof ctx.agentId === "string" && ctx.agentId.trim().length > 0 ? ctx.agentId.trim() : void 0;
   if (explicitAgentId) {
@@ -298100,7 +298222,7 @@ function kbExtension(pi2) {
           const layer = store.getAsyncLayer();
           const messageStore = layer ? new MessageStore(null, { asyncLayer: layer }) : new MessageStore(store.getDatabase());
           const title = params.description.split(/\r?\n/, 1)[0]?.trim().slice(0, 80) || "Follow-up task";
-          await messageStore.sendMessage({ fromId: fnCtx.agentId ?? "ephemeral-worker", fromType: "agent", toId: DASHBOARD_USER_ID, toType: "user", type: "agent-to-user", content: `Task proposal awaiting validation: ${title}`, metadata: { kind: "task-proposal", proposalStatus: "pending", proposalIdempotencyKey: randomUUID55(), proposedTask: { title, description: params.description, priority: params.priority, workflowId: params.workflow_id, dependencies: params.depends } } });
+          await messageStore.sendMessage({ fromId: fnCtx.agentId ?? "ephemeral-worker", fromType: "agent", toId: DASHBOARD_USER_ID, toType: "user", type: "agent-to-user", content: `Task proposal awaiting validation: ${title}`, metadata: { kind: "task-proposal", proposalStatus: "pending", proposalIdempotencyKey: randomUUID56(), proposedTask: { title, description: params.description, priority: params.priority, workflowId: params.workflow_id, dependencies: params.depends } } });
           return { content: [{ type: "text", text: "Task proposal submitted to the operator for validation; no task was created." }], details: { proposed: true } };
         }
       }
@@ -299350,6 +299472,20 @@ Planning session completed. Task ${taskId} is now in planning and will be auto-p
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const fnCtx = ctx;
+      const secretPrincipal = resolveSecretAccessPrincipal(fnCtx);
+      if (secretPrincipal.kind === "ambiguous") {
+        return {
+          content: [{ type: "text", text: "Secret access was not requested because the calling agent identity is ambiguous. End one concurrent session and retry." }],
+          isError: true,
+          details: { error: "ambiguous-caller-identity", key: params.key, scope: params.scope ?? null }
+        };
+      }
+      const effectiveCtx = {
+        ...secretPrincipal.agentId ? { agentId: secretPrincipal.agentId } : {},
+        ...secretPrincipal.agentName ? { agentName: secretPrincipal.agentName } : {},
+        ...typeof fnCtx.taskId === "string" ? { taskId: fnCtx.taskId } : secretPrincipal.taskId ? { taskId: secretPrincipal.taskId } : {},
+        ...typeof fnCtx.runId === "string" ? { runId: fnCtx.runId } : {}
+      };
       const store = await getStore(ctx.cwd);
       const secretsStore = await store.getSecretsStore();
       const scopes = params.scope ? [params.scope] : ["project", "global"];
@@ -299372,36 +299508,32 @@ Planning session completed. Task ${taskId} is now in planning and will be auto-p
         settings: { secretsAccessPolicy: globalSettings.secretsAccessPolicy }
       });
       if (decision.policy === "deny") {
-        emitSecretAudit(store, fnCtx, "secret:approval-denied", `${resolvedScope}:${params.key}`);
+        emitSecretAudit(store, effectiveCtx, "secret:approval-denied", `${resolvedScope}:${params.key}`);
         return { content: [{ type: "text", text: "Secret access denied by policy." }], details: { error: "denied", key: params.key, scope: resolvedScope, policySource: decision.source } };
       }
       if (decision.policy === "prompt") {
         const cliLayer = requireProjectLayer(store, "CLI secret approval store");
         const approvalStore = new ApprovalRequestStore(null, { asyncLayer: cliLayer });
-        const dedupeKey = `secret-read:${resolvedScope}:${params.key}:${fnCtx.agentId ?? "unknown"}`;
-        const requesterActorId = fnCtx.agentId ?? "user";
-        const requesterSnapshot = fnCtx.agentId ? {
-          actorId: requesterActorId,
-          actorType: "agent",
-          actorName: fnCtx.agentName ?? fnCtx.agentId
-        } : { actorId: "user", actorType: "user", actorName: "CLI User" };
-        const existing = await findLatestApprovalRequestByDedupeKey(approvalStore, { requesterActorId, ...fnCtx.taskId ? { taskId: fnCtx.taskId } : {}, dedupeKey });
+        const requesterSnapshot = secretPrincipal.actor;
+        const requesterActorId = requesterSnapshot.actorId;
+        const dedupeKey = `secret-read:${resolvedScope}:${params.key}:${requesterActorId}`;
+        const existing = await findLatestApprovalRequestByDedupeKey(approvalStore, { requesterActorId, ...effectiveCtx.taskId ? { taskId: effectiveCtx.taskId } : {}, dedupeKey });
         if (existing?.status === "pending") {
-          emitSecretAudit(store, fnCtx, "secret:approval-requested", `${resolvedScope}:${params.key}`);
+          emitSecretAudit(store, effectiveCtx, "secret:approval-requested", `${resolvedScope}:${params.key}`);
           return {
             content: [{ type: "text", text: `Secret access approval request ${existing.id} is still pending. Approve via POST /api/approvals/:id/decision.` }],
             details: { outcome: "pending_approval", approvalRequestId: existing.id, key: params.key, scope: resolvedScope }
           };
         }
         if (existing?.status === "denied") {
-          emitSecretAudit(store, fnCtx, "secret:approval-denied", `${resolvedScope}:${params.key}`);
+          emitSecretAudit(store, effectiveCtx, "secret:approval-denied", `${resolvedScope}:${params.key}`);
           return {
             content: [{ type: "text", text: `Secret access request ${existing.id} was denied by the operator. Do not retry without operator direction.` }],
             details: { outcome: "denied", approvalRequestId: existing.id, key: params.key, scope: resolvedScope }
           };
         }
         if (existing?.status === "approved") {
-          const revealedAfterApproval = await secretsStore.revealSecret(record2.id, resolvedScope, { agentId: fnCtx.agentId ?? null });
+          const revealedAfterApproval = await secretsStore.revealSecret(record2.id, resolvedScope, { agentId: secretPrincipal.agentId });
           await approvalStore.markCompleted(existing.id, {
             actor: requesterSnapshot,
             note: "Secret revealed after approval",
@@ -299409,7 +299541,7 @@ Planning session completed. Task ${taskId} is now in planning and will be auto-p
             // get the same expectedRequesterActorId enforcement as the gate path.
             expectedRequesterActorId: requesterActorId
           });
-          emitSecretAudit(store, fnCtx, "secret:read", `${resolvedScope}:${params.key}`, { key: params.key, scope: resolvedScope, approvalRequestId: existing.id });
+          emitSecretAudit(store, effectiveCtx, "secret:read", `${resolvedScope}:${params.key}`, { key: params.key, scope: resolvedScope, approvalRequestId: existing.id });
           return {
             content: [{ type: "text", text: `Loaded secret '${params.key}' from ${resolvedScope} scope (approval ${existing.id} consumed).` }],
             details: { key: params.key, value: revealedAfterApproval.plaintextValue, scope: resolvedScope, approvalRequestId: existing.id }
@@ -299425,17 +299557,17 @@ Planning session completed. Task ${taskId} is now in planning and will be auto-p
             resourceId: record2.id,
             context: { approvalDedupeKey: dedupeKey, key: params.key, scope: resolvedScope }
           },
-          ...fnCtx.runId ? { runId: fnCtx.runId } : {},
-          ...fnCtx.taskId ? { taskId: fnCtx.taskId } : {}
+          ...effectiveCtx.runId ? { runId: effectiveCtx.runId } : {},
+          ...effectiveCtx.taskId ? { taskId: effectiveCtx.taskId } : {}
         });
-        emitSecretAudit(store, fnCtx, "secret:approval-requested", `${resolvedScope}:${params.key}`);
+        emitSecretAudit(store, effectiveCtx, "secret:approval-requested", `${resolvedScope}:${params.key}`);
         return {
           content: [{ type: "text", text: `Secret access requires approval. Request ${request2.id} is pending. Approve via POST /api/approvals/:id/decision.` }],
           details: { outcome: "pending_approval", approvalRequestId: request2.id, key: params.key, scope: resolvedScope }
         };
       }
-      const revealed = await secretsStore.revealSecret(record2.id, resolvedScope, { agentId: fnCtx.agentId ?? null });
-      emitSecretAudit(store, fnCtx, "secret:read", `${resolvedScope}:${params.key}`, { key: params.key, scope: resolvedScope });
+      const revealed = await secretsStore.revealSecret(record2.id, resolvedScope, { agentId: secretPrincipal.agentId });
+      emitSecretAudit(store, effectiveCtx, "secret:read", `${resolvedScope}:${params.key}`, { key: params.key, scope: resolvedScope });
       return {
         content: [{ type: "text", text: `Loaded secret '${params.key}' from ${resolvedScope} scope.` }],
         details: { key: params.key, value: revealed.plaintextValue, scope: resolvedScope }