@quantiya/codevibe-claude-plugin 2.0.41 → 2.0.43

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/cli.js

@@ -7955,6 +7955,39 @@ function createExplicitTtyExitCoordinator(deps) {
 // src/orchestration-shell/reducer.ts
 var import_ulid = require("ulid");
 
+// src/orchestration-shell/task-label.ts
+var GROUP_GATE_PREFIX = "group:";
+function shortTaskId(taskId) {
+  return taskId.length > 8 ? taskId.slice(0, 8) : taskId;
+}
+function taskLabel(state, taskId) {
+  let direct = state.taskOrdinals.get(taskId);
+  if (direct)
+    return direct.retryOf ? `#${direct.ordinal} retry` : `#${direct.ordinal}`;
+  if (taskId.startsWith(GROUP_GATE_PREFIX)) {
+    let group = state.taskOrdinals.get(taskId.slice(GROUP_GATE_PREFIX.length));
+    if (group) return `#${group.ordinal}`;
+  }
+  let team = state.team;
+  if (team && team.taskGroupId) {
+    let group = state.taskOrdinals.get(team.taskGroupId);
+    if (group) {
+      for (let [trackIndex, track] of team.tracks)
+        if (track.taskId === taskId) return `#${group.ordinal}.${trackIndex + 1}`;
+    }
+  }
+  return shortTaskId(taskId);
+}
+function taskIdForOrdinal(state, ordinal) {
+  for (let [id, record] of state.taskOrdinals)
+    if (record.ordinal === ordinal) return id;
+  return null;
+}
+function endedTaskAdvisory(described, taskId) {
+  let ended = described.find((t) => t.taskId === taskId && t.outcome === "discarded");
+  return ended ? `Task ${ended.label} ended on this side \u2014 its workspace copy was discarded; accepting this review applies nothing. Choose Abort (or Cancel) and re-run the request.` : null;
+}
+
 // src/orchestration-shell/web/sanitize.ts
 function sanitizeForTerminal(input) {
   if (!input) return "";
@@ -8270,6 +8303,23 @@ function liveLabel(event) {
 // src/orchestration-shell/reducer.ts
 var CONVERSATION_BUFFER_MAX = 500;
 function reducer(state, action) {
+  return normalizeActiveGatePrompt(reduceAction(state, action));
+}
+function isAnswerableGatePrompt(entry) {
+  if (entry.kind !== "gate-prompt" || entry.final !== !1) return !1;
+  let phase = entry.uiState.phase;
+  return phase === "awaiting-number" || phase === "awaiting-notes";
+}
+function normalizeActiveGatePrompt(state) {
+  let current = state.activeGatePromptId;
+  if (current !== null) {
+    let entry = state.conversation.find((e) => e.id === current);
+    if (entry && isAnswerableGatePrompt(entry)) return state;
+  }
+  let next = state.conversation.find(isAnswerableGatePrompt)?.id ?? null;
+  return next === current ? state : { ...state, activeGatePromptId: next };
+}
+function reduceAction(state, action) {
   switch (action.type) {
     case "USER_INPUT":
       return reduceUserInput(state, action.text, action.attachments, action.imagePaths);
@@ -8302,6 +8352,16 @@ function reducer(state, action) {
       return reducePlannerOfferPresented(state, action.offer);
     case "CLEAR_PENDING_PLANNER_OFFER":
       return { ...state, pendingPlannerOffer: null };
+    case "TASK_ORDINAL_ASSIGNED":
+      return reduceTaskOrdinalAssigned(state, action.taskId, action.kind, action.retryOf);
+    case "APPLY_CONFLICT_PRESENTED":
+      return reduceApplyConflictPresented(state, action.menu);
+    case "CLEAR_PENDING_APPLY_CONFLICT": {
+      if (action.taskId === void 0) return { ...state, pendingApplyConflicts: /* @__PURE__ */ new Map() };
+      if (!state.pendingApplyConflicts.has(action.taskId)) return state;
+      let rest = new Map(state.pendingApplyConflicts);
+      return rest.delete(action.taskId), { ...state, pendingApplyConflicts: rest };
+    }
     case "STRUCTURAL_SUMMARY_GENERATED":
       return {
         ...state,
@@ -8545,13 +8605,13 @@ function reduceReviewerStatusLine(state, event) {
 function reduceTaskProgress(state, event) {
   let s = state;
   if (MILESTONE_SCROLLBACK_PHASES.has(event.phase)) {
-    let milestone = {
+    let milestoneTaskId = "taskId" in event && typeof event.taskId == "string" ? event.taskId : null, milestoneLabel = milestoneTaskId ? taskLabel(state, milestoneTaskId) : "", milestonePrefix = milestoneLabel.startsWith("#") ? `[Task ${milestoneLabel}] ` : "", milestone = {
       kind: "advisory",
       id: (0, import_ulid.ulid)(),
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       final: !0,
       source: "shell",
-      text: renderProgressLine(event),
+      text: `${milestonePrefix}${renderProgressLine(event)}`,
       // R7 A4 (Stage-2 r4 Codex MED) — the halt_notice echo is DESKTOP-ONLY by
       // contract: `localOnly` keeps it out of the turn mirror + handoff briefs
       // (index.ts outbound-context filters), so operational halt text can never
@@ -8732,6 +8792,43 @@ function reducePlannerOfferPresented(state, offer) {
     pendingClarification: null
   };
 }
+function reduceTaskOrdinalAssigned(state, taskId, kind, retryOf) {
+  if (state.taskOrdinals.has(taskId)) return state;
+  let taskOrdinals = new Map(state.taskOrdinals);
+  return taskOrdinals.set(taskId, {
+    ordinal: state.nextTaskOrdinal,
+    kind,
+    ...retryOf ? { retryOf } : {}
+  }), { ...state, taskOrdinals, nextTaskOrdinal: state.nextTaskOrdinal + 1 };
+}
+var APPLY_CONFLICT_MENU_HINT = "Reply with a number 1-2 (or /task retry <n> / /task discard <n> while another review is open); other text closes this menu.";
+function reduceApplyConflictPresented(state, menu) {
+  let text2 = [
+    ...menu.conflicts.map(
+      (c) => `  ${c.path} \u2014 ${c.cause === "session-task" ? `changed by task ${c.byTaskLabel ?? "?"}` : c.cause === "write-error" ? "could not be written" : "changed outside CodeVibe"}`
+    ),
+    "",
+    "  1. Retry as a new task \u2014 re-run the request on a fresh snapshot (reviewed and approved again)",
+    "  2. Discard \u2014 keep your files as they are",
+    "",
+    APPLY_CONFLICT_MENU_HINT
+  ].join(`
+`), advisoryEntry = {
+    kind: "advisory",
+    id: (0, import_ulid.ulid)(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    final: !0,
+    source: "shell",
+    text: text2,
+    // Desktop-only by contract (design §3 C3 / §9): never mirrored, never folded
+    // into a workflow-handoff brief.
+    localOnly: !0
+  }, withEntry = appendConversation(state, advisoryEntry), menus = new Map(state.pendingApplyConflicts);
+  return menus.set(menu.taskId, { ...menu, conversationEntryId: advisoryEntry.id }), {
+    ...withEntry,
+    pendingApplyConflicts: menus
+  };
+}
 function reduceEventReceived(state, event, role) {
   if (state.conversation.some(
     (entry2) => entry2.kind === "subagent-event" && entry2.event.eventId === event.eventId
@@ -8841,13 +8938,18 @@ function findUnfinalizedGatePromptIndex(state, taskId) {
   }
   return -1;
 }
-function makeGatePromptPanel(envelope) {
+function makeGatePromptPanel(envelope, state) {
+  let label = state ? taskLabel(state, envelope.taskId) : "";
   return {
     kind: "gate-panel",
     id: (0, import_ulid.ulid)(),
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     final: !0,
-    panel: { variant: "prompt", envelope }
+    panel: {
+      variant: "prompt",
+      envelope,
+      ...label.startsWith("#") ? { taskLabel: `Task ${label}` } : {}
+    }
   };
 }
 function makeGateSummaryPanel(reviewSummary) {
@@ -8876,7 +8978,7 @@ function promoteQueuedGatePrompt(state, idx, target) {
     ...state.conversation.slice(idx + 1)
   ], promoted = appendConversation(
     { ...state, conversation: nextConversation },
-    makeGatePromptPanel(head)
+    makeGatePromptPanel(head, state)
   );
   return promotedReviewSummary !== void 0 && promotedReviewSummary.rounds.length > 0 && (promoted = appendConversation(promoted, makeGateSummaryPanel(promotedReviewSummary))), promoted;
 }
@@ -8909,7 +9011,7 @@ function reduceGatePromptReceived(state, envelope) {
     queue: [],
     uiState: durableResolution ? { phase: "resolved", resolvedBy: "durable", resolution: durableResolution } : isClaimed ? { phase: "claimed", decisionClaimId: state.gateActionClaims.get(envelope.gateId) ?? null } : { phase: "awaiting-number" }
   }, withControl = appendConversation(state, entry);
-  return appendConversation(withControl, makeGatePromptPanel(envelope));
+  return appendConversation(withControl, makeGatePromptPanel(envelope, state));
 }
 function reduceGatePromptDecisionFenced(state, promptEntryId, gateId, decisionAttemptId, canonicalRequestHash, decisionClaimId) {
   let idx = state.conversation.findIndex(
@@ -9326,6 +9428,12 @@ function buildInitialState(args) {
     // A1a #3/#4: the lightweight local interactive offer. null until the shell
     // presents a team-decomposition / build-transition offer.
     pendingPlannerOffer: null,
+    // P46a D1/C3: in-session task numbers (one counter, starts at 1) + the
+    // desktop-local apply-conflict menu (null until a promote collides).
+    taskOrdinals: /* @__PURE__ */ new Map(),
+    nextTaskOrdinal: 1,
+    pendingApplyConflicts: /* @__PURE__ */ new Map(),
+    activeGatePromptId: null,
     inputHistory: [],
     // CP-1.d §4.8 LOCK: structuralSummary stays null until session-start
     // generation completes; structuralSummaryError populated on failure.
@@ -10687,8 +10795,8 @@ function formatHaltReason3(reason) {
 function formatPromptKind2(promptKind) {
   return promptKind === ORCHESTRATION_ESCALATED_GATE_PROMPT_KIND ? "Escalated review" : promptKind === ORCHESTRATION_FINAL_APPROVAL_PROMPT_KIND ? "Final approval" : promptKind === CONTINUATION_OFFER_HANDOFF_PROMPT_KIND ? "Continue with which agent?" : promptKind;
 }
-function renderPromptVariant(envelope) {
-  let { ink } = getInkRuntime(), { Box, Text } = ink, haltReasonText = envelope.promptKind === ORCHESTRATION_ESCALATED_GATE_PROMPT_KIND ? formatHaltReason3(envelope.reason) : null, kindLabel = formatPromptKind2(envelope.promptKind), children = [], context = GateContextPanel({ envelope });
+function renderPromptVariant(envelope, taskLabel2) {
+  let { ink } = getInkRuntime(), { Box, Text } = ink, haltReasonText = envelope.promptKind === ORCHESTRATION_ESCALATED_GATE_PROMPT_KIND ? formatHaltReason3(envelope.reason) : null, kindLabel = taskLabel2 ? `${formatPromptKind2(envelope.promptKind)} \xB7 ${taskLabel2}` : formatPromptKind2(envelope.promptKind), children = [], context = GateContextPanel({ envelope });
   context && children.push(
     React11.createElement(
       Box,
@@ -10758,7 +10866,7 @@ function renderPromptVariant(envelope) {
 }
 function GatePanelEntry(props) {
   let { panel } = props.entry;
-  return panel.variant === "prompt" ? renderPromptVariant(panel.envelope) : renderReviewSummarySection(panel.reviewSummary);
+  return panel.variant === "prompt" ? renderPromptVariant(panel.envelope, panel.taskLabel) : renderReviewSummarySection(panel.reviewSummary);
 }
 
 // src/orchestration-shell/components/ConversationPane.tsx
@@ -17006,7 +17114,7 @@ function InputBar(props) {
       )
     );
   let placeholder = props.placeholder ?? "";
-  gatePromptMode?.kind === "awaiting-number" ? placeholder = `Type a number 1..${gatePromptMode.maxOption}` : gatePromptMode?.kind === "awaiting-notes" && (placeholder = "Type your notes + Enter");
+  gatePromptMode?.kind === "awaiting-number" ? placeholder = gatePromptMode.taskLabel ? `Type a number 1..${gatePromptMode.maxOption} \xB7 ${gatePromptMode.taskLabel}` : `Type a number 1..${gatePromptMode.maxOption}` : gatePromptMode?.kind === "awaiting-notes" && (placeholder = "Type your notes + Enter");
   let shown = displayValue(value), cur = clampCursor2(cursor, shown.length), valueWidth = Math.max(1, columns - 6), win = computeInputWindow(shown, cur, valueWidth, scrollRef.current);
   scrollRef.current = win.scroll;
   let origin = rowOrigin ?? { left: 0, top: 0 };
@@ -17383,13 +17491,20 @@ function decisionToGroupOutcome(decision) {
 // src/orchestration-shell/gate-decision-submit.ts
 var import_uuid3 = require("uuid");
 var defaultDecisionAttemptReceiptStore = new DecisionAttemptReceiptStore();
-function findActiveGatePromptEntry(conversation) {
-  for (let i = conversation.length - 1; i >= 0; i--) {
-    let entry = conversation[i];
-    if (entry.kind === "gate-prompt" && entry.final === !1)
-      return entry;
+function findActiveGatePromptEntry(conversation, activeGatePromptId = null) {
+  if (activeGatePromptId !== null) {
+    for (let entry of conversation)
+      if (entry.id === activeGatePromptId && entry.kind === "gate-prompt" && entry.final === !1)
+        return entry;
   }
-  return null;
+  let oldestOpen = null;
+  for (let entry of conversation) {
+    if (entry.kind !== "gate-prompt" || entry.final !== !1) continue;
+    let phase = entry.uiState.phase;
+    if (phase === "awaiting-number" || phase === "awaiting-notes") return entry;
+    oldestOpen ??= entry;
+  }
+  return oldestOpen;
 }
 function getStoreSessionId(store) {
   return store.getState().session.sessionId;
@@ -18019,7 +18134,7 @@ var readline = __toESM(require("readline"));
 function plannerDecisionRenderEnabled(env = process.env) {
   return env.CODEVIBE_PLANNER_DEBUG === "1";
 }
-function renderEntryAsLine(entry) {
+function renderEntryAsLine(entry, labelFor) {
   switch (entry.kind) {
     case "user-message":
       return `> ${entry.text}`;
@@ -18040,9 +18155,9 @@ function renderEntryAsLine(entry) {
     case "advisory":
       return `[${entry.source}] ${entry.text}`;
     case "gate-prompt": {
-      let lines = [], halt = entry.envelope.reason ? ` (${entry.envelope.reason})` : "";
+      let lines = [], halt = entry.envelope.reason ? ` (${entry.envelope.reason})` : "", label = labelFor?.(entry.envelope.taskId);
       lines.push(
-        `[gate-prompt ${entry.envelope.promptKind}${halt}] ${entry.envelope.summary ?? ""}`
+        `[gate-prompt ${entry.envelope.promptKind}${halt}]${label ? ` [${label}]` : ""} ${entry.envelope.summary ?? ""}`
       );
       for (let i = 0; i < entry.envelope.options.length; i++) {
         let opt = entry.envelope.options[i];
@@ -18086,8 +18201,13 @@ async function runLineLogFallback(args) {
     let newEntries = state.conversation.slice(printedUpTo);
     printedUpTo = state.conversation.length;
     for (let entry of newEntries)
-      entry.kind !== "gate-panel" && (entry.kind === "planner-decision" && !plannerDecisionRenderEnabled() || out.write(renderEntryAsLine(entry) + `
-`));
+      entry.kind !== "gate-panel" && (entry.kind === "planner-decision" && !plannerDecisionRenderEnabled() || out.write(
+        renderEntryAsLine(entry, (taskId) => {
+          let label = taskLabel(state, taskId);
+          return label.startsWith("#") ? `Task ${label}` : void 0;
+        }) + `
+`
+      ));
   }), rl = readline.createInterface({ input: inp, output: out, terminal: !1 }), onAbort = null;
   args.signal && (args.signal.aborted ? rl.close() : (onAbort = () => {
     try {
@@ -18146,13 +18266,32 @@ function buildTrackLabelByTaskId(team) {
     entry.taskId && map.set(entry.taskId, `Track ${displayTrackNumber(idx)}`);
   return map.size > 0 ? map : null;
 }
-function deriveGatePromptMode(active, gateActionRecoveryBlocked = !1) {
+function buildGateLabelByTaskId(state) {
+  let trackLabels = buildTrackLabelByTaskId(state.team), map = new Map(trackLabels ?? []);
+  for (let entry of state.conversation) {
+    if (entry.kind !== "gate-prompt") continue;
+    let id = entry.envelope.taskId;
+    if (map.has(id) && map.get(id).startsWith("Task ")) continue;
+    let label = taskLabel(state, id);
+    if (!label.startsWith("#")) continue;
+    let track = trackLabels?.get(id);
+    map.set(id, track ? `Task ${label} \xB7 ${track}` : `Task ${label}`);
+  }
+  return map.size > 0 ? map : null;
+}
+function deriveGatePromptMode(active, gateActionRecoveryBlocked = !1, labelByTaskId = null) {
   if (!active) return null;
   if (gateActionRecoveryBlocked && active.uiState.phase !== "resolved")
     return { kind: "submitting" };
   switch (active.uiState.phase) {
-    case "awaiting-number":
-      return { kind: "awaiting-number", maxOption: active.envelope.options.length };
+    case "awaiting-number": {
+      let taskLabel2 = labelByTaskId?.get(active.envelope.taskId);
+      return {
+        kind: "awaiting-number",
+        maxOption: active.envelope.options.length,
+        ...taskLabel2 ? { taskLabel: taskLabel2 } : {}
+      };
+    }
     case "awaiting-notes":
       return { kind: "awaiting-notes", decisionDraft: active.uiState.decisionDraft };
     case "submitting":
@@ -18184,7 +18323,7 @@ function OrchestrationApp(props) {
   }, [wizardOpen, isRawModeSupported]);
   let staticOrderRef = React18.useRef(null);
   staticOrderRef.current || (staticOrderRef.current = makeStaticOrderAccum());
-  let trackLabelByTaskId = buildTrackLabelByTaskId(state.team), staticConversation = plannerDecisionRenderEnabled() ? state.conversation : state.conversation.filter((e) => e.kind !== "planner-decision");
+  let trackLabelByTaskId = buildGateLabelByTaskId(state), staticConversation = plannerDecisionRenderEnabled() ? state.conversation : state.conversation.filter((e) => e.kind !== "planner-decision");
   appendNewlyFinal(staticOrderRef.current, staticConversation, (entry) => ({
     key: entry.id,
     element: renderConversationEntry(entry, trackLabelByTaskId),
@@ -18195,9 +18334,10 @@ function OrchestrationApp(props) {
     ...staticOrderRef.current.items
   ], nonFinal = state.conversation.filter(
     (e) => !e.final
-  ), activeGateEntry = findActiveGatePromptEntry(state.conversation), gatePromptMode = deriveGatePromptMode(
+  ), activeGateEntry = findActiveGatePromptEntry(state.conversation, state.activeGatePromptId), gatePromptMode = deriveGatePromptMode(
     activeGateEntry,
-    state.gateActionRecoveryBlocked
+    state.gateActionRecoveryBlocked,
+    trackLabelByTaskId
   ), terminalRows = process.stdout.rows ?? 24, FIXED_CHROME_ROWS = 8, teamReserveRows = state.team ? 5 + state.team.tracks.size : 0, dropdownFits = terminalRows - FIXED_CHROME_ROWS - teamReserveRows >= DROPDOWN_MAX_ROWS + MIN_LIVE_ROWS, dropdownActive = state.progress === null && gatePromptMode === null && state.reviewerWizard === null && dropdownFits, dropdownReserveRows = dropdownActive ? DROPDOWN_MAX_ROWS : 0, wizardReserveRows = state.reviewerWizard ? WIZARD_MAX_ROWS : 0, { rendered: cappedNonFinal, hiddenCount } = capLiveEntries(
     nonFinal,
     terminalRows,
@@ -18616,11 +18756,11 @@ function renderLocalGemmaPlannerPrompt(input, options) {
     "Never refuse merely because the user asks about local repository files, the current directory, the workspace, or the project. Refuse only for clearly unsafe requests such as exposing secrets/credentials, destructive root/home deletion, malware, bypassing auth/paywalls, or exfiltration.",
     "",
     "Routing rules:",
-    '- start_task: user asks to create, add, edit, fix, implement, refactor, test, run tests, or review a SPECIFIC, BOUNDED change \u2014 such as their pending diff, staged/uncommitted changes, a named file, or a pull request. (A BROAD "review/audit the WHOLE codebase for bugs" is read-only understanding \u2192 familiarize, NOT start_task \u2014 see below.) If the user says current directory, current working directory, repo root, workspace, ".", "./", or an absolute path, treat the target as sufficiently specified. If the requested content is obvious, such as a JavaScript hello-world file, do not ask for extra content. A SINGLE task is start_task even when it has multiple steps; choose team_decompose ONLY when the user explicitly asks for parallel work (see below).',
+    '- start_task: user asks to create, add, edit, fix, implement, refactor, test, run tests, or review a SPECIFIC, BOUNDED change \u2014 such as their pending diff, staged/uncommitted changes, a named file, or a pull request. (A BROAD "review/audit the WHOLE codebase for bugs" is read-only understanding \u2192 familiarize, NOT start_task \u2014 see below.) If the user says current directory, current working directory, repo root, workspace, ".", "./", or an absolute path, treat the target as sufficiently specified. If the requested content is obvious, such as a JavaScript hello-world file, do not ask for extra content. A SINGLE task is start_task even when it has multiple steps; choose team_decompose ONLY when the user explicitly asks for parallel work (see below). This ALSO includes requests that fetch/check an external URL or search online AND write, save, create, or update local files, reports, or code (e.g. "check https://... and write a report into report.md" -> start_task).',
     '- team_decompose: user EXPLICITLY asks to split the work into MULTIPLE PARALLEL tasks or tracks, run an "agent team", do things "in parallel", or describes 2+ INDEPENDENT pieces (typically touching different files) to run concurrently. Prefer team_decompose over start_task whenever the request names an agent team or parallel/separate tracks. A single multi-step task is start_task, NOT team_decompose.',
     '- familiarize: user asks to read, inspect, understand, explain, or summarize the current project, codebase, repository, folder, files, or working directory without asking for a mutation. This ALSO covers a BROAD read-only REVIEW or AUDIT of the WHOLE repository/codebase \u2014 e.g. "review the codebase for bugs", "audit the repo for issues", "look over the whole project for problems": reviewing the ENTIRE repo for bugs/quality/security is a read-only understanding task, so it is familiarize, NOT start_task. (A BOUNDED review of a specific pending DIFF or named file is start_task instead.)',
     `- brainstorm: user asks to explore options, tradeoffs, risks, architecture directions, or recommendations for THIS project's design or implementation before deciding what to design or implement. brainstorm is NOT for opinions or analysis of a web page, article, or answer from earlier in this session \u2014 that is advisory_response. Use brainstorm for exploratory prompts such as "brainstorm ways to build offline support" or "compare approaches to create a local context store". Do NOT use brainstorm when the user asks for immediate mutation, a design artifact, a hard gate, tests, review, commit, deploy, or release; choose the workflow action or ask one clarifying question.`,
-    '- browse: user asks to read/open/fetch/summarize a specific web URL (http/https), OR to look something up on the web / search online / find the latest on a topic. Put any explicit URL(s) in "browseUrls" (array) and, when there is no URL, put the search query in "browseQuery". This route fetches the page (or searches) on the user machine and answers from the content; it is NOT a familiarize (which reads the LOCAL repo) and NOT advisory_response.',
+    '- browse: user asks a read-only question to read/open/fetch/summarize a specific web URL (http/https), OR to look something up on the web / search online / find the latest on a topic, WITHOUT asking to create, write, or modify any local files. If the user asks to fetch a URL or search AND save/write/create local files or reports, choose start_task instead. Put any explicit URL(s) in "browseUrls" (array) and, when there is no URL, put the search query in "browseQuery". This route fetches the page (or searches) on the user machine and answers from the content; it is NOT a familiarize (which reads the LOCAL repo) and NOT advisory_response.',
     options?.isSubprocessRunner ? `- advisory_response: user asks a general question that does not require repository context or file changes. Put a COMPLETE, natural, conversational ANSWER to the question in the "advisory_summary" field (a full helpful reply, like a chat assistant \u2014 NOT a one-line label or a restatement of the question); explain core principles accurately: for search/pathfinding, start with the start node in the open set, use strictly standard A* terminology (open set and closed set only; never invent other sets like missed set or turn set), and compare with Dijkstra's algorithm; explain that a more accurate, higher admissible heuristic (closer to the true remaining cost) guides the search more directly to the goal and expands fewer nodes, whereas a smaller or zero heuristic (like Dijkstra's algorithm) explores in all directions and expands more nodes; a heuristic must be admissible (never overestimate the true distance) to guarantee an optimal shortest path; write all mathematical expressions in clean plain text like f(n) = g(n) + h(n) (never use LaTeX math notation, \\text{}, math mode $, or backslashes); format the entire explanation in clean, well-structured markdown prose paragraphs separated by blank lines (do not use bullet lists, numbered sub-lists, or backslash line breaks; write complete narrative paragraphs); never use tab characters or \\t; never use double quotes inside advisory_summary (use single quotes ' if quoting terms); keep "rationale" a short internal classification reason. Answer directly and warmly, e.g. "Yes \u2014 I can \u2026".` : '- advisory_response: user asks a general question or capability question. Put a concise, natural, 1-sentence direct answer or definition in "advisory_summary" (e.g. "Yes, I can write Rust" or "A* is a best-first pathfinding algorithm that expands nodes by f(n) = g(n) + h(n)"); do NOT write preambles like "Here is..." or conversational labels; keep "rationale" a short reason. The downstream local advisory engine generates the full answer.',
     options?.isSubprocessRunner ? '- FOLLOW-UP ON EARLIER CONTENT: when the user asks for your thoughts, opinion, analysis, critique, or a deeper explanation of something already fetched or answered earlier in this session (a web page that was read, a search result, a previous reply) \u2014 e.g. "I am looking for your thoughts", "what do you think about that", "go deeper on that", "is that right?" \u2014 choose advisory_response and put the COMPLETE reply in advisory_summary (no downstream answerer runs for this runner). Never brainstorm, familiarize, or browse again for such a follow-up.' : `- FOLLOW-UP ON EARLIER CONTENT: when the user asks for your thoughts, opinion, analysis, critique, or a deeper explanation of something already fetched or answered earlier in this session (a web page that was read, a search result, a previous reply) \u2014 e.g. "I am looking for your thoughts", "what do you think about that", "go deeper on that", "is that right?" \u2014 choose advisory_response with a one-sentence advisory_summary (the shell's answerer writes the full reply from the page and the conversation). Never brainstorm, familiarize, or browse again for such a follow-up.`,
     options?.isSubprocessRunner ? "- summarize_current_status: user asks what changed, what the last task did, current progress, or workflow status." : "- Questions about progress, what changed, what the last task did, or workflow status are advisory_response too: the shell attaches its own status record to the answer, so never invent task history.",
@@ -18658,6 +18798,8 @@ function renderLocalGemmaPlannerPrompt(input, options) {
     'User: "look up the React 19 release notes online" -> {"action":"browse","rationale":"web lookup","browseQuery":"React 19 release notes"}',
     'User: "what is the latest LTS version of Node.js?" -> {"action":"browse","rationale":"freshness lookup needs current web info, not stale knowledge","browseQuery":"latest LTS version Node.js"}',
     'User: "what is the current stable version of Python?" -> {"action":"browse","rationale":"current version is a freshness web lookup","browseQuery":"current stable version Python"}',
+    'User: "check https://registry.npmjs.org/@quantiya/codevibe-core/latest and write a report into report.md" -> {"action":"start_task","rationale":"check external URL and write report file"}',
+    'User: "Please use your codevibe_web_search tool to search for \\"Quantiya AI\\", then use codevibe_web_fetch to read https://quantiya.ai/ and write a 3-bullet summary of the site into a file named claude-web-test.md." -> {"action":"start_task","rationale":"search web and write summary file"}',
     `User: "fyi every FLAGS.md row should also say what the default is" (session.currentTaskState is in_progress) -> {"action":"advisory_response","rationale":"a convention stated while a task runs; acknowledge, no second task","advisory_summary":"Noted \u2014 FLAGS.md rows will also state each flag's default."}`,
     'User: "scratch that \u2014 descriptions should not end with a period" (session.currentTaskState is in_progress) -> {"action":"advisory_response","rationale":"retracts an earlier rule while a task runs","advisory_summary":"Understood \u2014 descriptions will not end with a period."}',
     'User: "also add a --cv-quiet flag to release.sh" (session.currentTaskState is in_progress) -> {"action":"start_task","rationale":"asks for a new deliverable while a task runs"}',
@@ -21326,6 +21468,57 @@ function buildCommandIntentMetadata(text2) {
   if (intent)
     return { command_intent: buildCommandIntentEnvelope(intent) };
 }
+function isWebAccessNeeded(text2) {
+  return !text2 || typeof text2 != "string" ? !1 : /https?:\/\/[^\s]+/i.test(text2) || /\bwww\.[^\s]+/i.test(text2) ? !0 : /(?:^|[.?!;])\s*(?:please\s+)?(?:implement|build|create|add|support|develop)\b[\s\S]{0,50}?\b(?:feature|functionality|function|button|capability|endpoint|command|module|ui|api|service)\b/i.test(
+    text2
+  ) || /\b(?:feature|functionality|function|capability)\b[\s\S]{0,40}?\b(?:to|that|which)\s+(?:search|browse|look\s+up)\b/i.test(
+    text2
+  ) || /(?:实现|添加|开发|支持|做个|写个)[\s\S]{0,30}?(?:功能|特性)/.test(text2) || /(?:功能|特性)[\s\S]{0,30}?(?:实现|添加|开发|支持)/.test(text2) || /(?:機能|기능)[\s\S]{0,30}?(?:実装|追加|作成|開発|구현|추가)/.test(text2) || /(?:実装|追加|作成|開発|구현|추가)[\s\S]{0,30}?(?:機能|기능)/.test(text2) ? !1 : !!(/(?:^|[.?!;])\s*(?:please\s+)?(?:search|browse)\s+(?:the\s+(?:web|internet)\b|online)(?:\s+(?:for|about)\b|\s*[,.;?!]?$)/i.test(
+    text2
+  ) || /(?:^|[.?!;])\s*(?:please\s+)?look\s+up\s+(?!where\b|how\b|who\b|why\b)[\w\s.-]{1,60}?\s+(?:online|on\s+the\s+web\b|on\s+the\s+internet\b)(?:\s+(?:for|about)\b|\s*[,.;?!]?$)/i.test(
+    text2
+  ) && !/\bonline\s+(?:checkout|users?|status|banking|store|shop|service|mode|game|player|account|system|portal|flow|documentation)\b/i.test(
+    text2
+  ) || /(?:^|[.?!;])\s*(?:please\s+)?(?:use|try|run|perform|do)\s+(?:a\s+)?(?:web|internet|online)\s+search(?:\s+(?:for|about|on)\b|\s*[,.;?!]?$)(?!\s+(?:api|service|endpoint|tests?|feature|sdk|library|component|function|code)\b)/i.test(
+    text2
+  ) || /(?:^|[.?!;])\s*(?:please\s+)?(?:google\s+(?:this|it|that)\b|search\s+(?:on\s+google|google)\s+for\b)/i.test(
+    text2
+  ) || /(?:^|[.?!;，。！？；])\s*(?:请|帮我|麻烦)?\s*(?:(?:去?上网|在网上|去官网|在官网|在官方网站)(?:搜索|查找|查阅|查一下|搜一下)(?!到|过|出|的|结果)|去网上搜(?:一下|索)|谷歌一下|(?:查阅|查找|搜索)(?:官网|官方网站)(?:的)?(?:文档|说明|api)|(?:在线|官网|联网)搜索一下)/i.test(
+    text2
+  ) || /(?:^|[.?!;])\s*(?:(?:ネット|オンライン)で\s*(?:検索して(?:みて|ください)?|調べて(?:みて|ください)?|探して(?:みて|ください)?)(?=$|[\s。、.!?])|ウェブ検索で\s*[\u4E00-\u9FFF\u30A0-\u30FF\w ]{1,20}を(?:調べて|探して))|(?:^|[.?!;])\s*[\w\s\u3040-\u30FF\u4E00-\u9FFF]{0,20}?ググ[るっ](?=$|[\s.?!;。~])/i.test(
+    text2
+  ) || /(?:^|[.?!;])\s*(?:[\w\s가-힣]{0,40}?\s+)?(?:인터넷|온라인|구글)에서\s*(?:검색해(?:봐|줘|요)|찾아(?:봐|줘)|조회해(?:봐|줘))(?=$|[\s.?!;。~])/i.test(
+    text2
+  ));
+}
+function hasFileMutationIntent(text2) {
+  if (!text2 || typeof text2 != "string") return !1;
+  let stripped = stripLeadingAgentControlToken(text2).trim(), textWithoutUrls = stripped.replace(/https?:\/\/[^\s]+/gi, " ").trim();
+  if (/\b(?:how\s+(?:to|do\s+I|can\s+I)|explain\s+how\s+to|tell\s+me\s+how\s+to)\b/i.test(stripped) || /(?:^|[.?!;])\s*(?:what\s+(?:is|are)\b|c[oó]mo\s+(?:hacer|puedo|se\s+puede|escribir|guardar|crear)|comment\s+(?:faire|écrire|sauvegarder|créer|enregistrer)|wie\s+(?:kann\s+ich|macht\s+man|schreibt\s+man|speichert\s+man|erstellt\s+man))\b/i.test(stripped) || /(?:如何|怎么|怎样|告诉我(?:如何|怎么|怎样)|解释如何|请问|什么是)/.test(stripped) || /(?:どうやって|方法(?:を(?:教えて|説明して))|やり方を教えて|でしょうか|とは(?:何|なん)ですか)/.test(stripped) || /(?:어떻게|방법을?\s*(?:알려줘|설명해줘)|법\s*설명|하는지\s*알려줘)/.test(stripped))
+    return !1;
+  if (/>{1,2}\s*[\w./-]+\b/.test(textWithoutUrls))
+    return !0;
+  let fileExt = "(?:md|markdown|txt|json|csv|ts|js|tsx|jsx|py|html|css|yaml|yml|log|sh|xml|toml|sql|env)", writeToFilePatternEn = new RegExp(
+    `\\b(?:write|save|create|dump|output|put|export|store|record|guardar|escribir|crear|enregistrer|\xE9crire|cr\xE9er|sauvegarder|speichern|schreiben|erstellen)\\b[\\s\\S]*?\\b(?:into|to|in|as|en|dans|auf|zu)\\b(?!\\s+(?:chat|console|stdout|screen|terminal)\\b)[\\s\\S]*?(?:(?:a|an|the|un|une|ein|eine|el|la)?\\s*file(?:\\s+named|\\s+called)?\\s+)?[\\w./-]+\\.${fileExt}\\b`,
+    "i"
+  ), writeToFilePatternGermanic = new RegExp(
+    `\\b(?:in|auf|zu|into|to)\\s+[\\w./-]+\\.${fileExt}[\\s\\S]*?\\b(?:speichern|schreiben|erstellen|ablegen)\\b`,
+    "i"
+  ), namedFilePatternEn = /\b(?:into|to|in|en|dans|auf|zu)\s+(?:a|an|un|une|ein|eine|el|la)?\s*file(?:\s+(?:named|called))?\s+[\w./-]+\b/i, createFilePatternEn = /\b(?:create|add|touch)\s+(?:a|an|the)?\s*(?:new\s+)?(?:file|markdown\s+file|script)\b/i, directFileVerbPatternEn = new RegExp(
+    `\\b(?:create|write|touch|add|crear|escribir|cr\xE9er|\xE9crire|erstellen)\\s+[\\w./-]+\\.${fileExt}\\b`,
+    "i"
+  ), writeToFilePatternZh = new RegExp(
+    `(?:\u5199\u5165|\u4FDD\u5B58\u5230?|\u521B\u5EFA|\u751F\u6210|\u8F93\u51FA\u5230|\u5B58\u5165|\u5BFC\u51FA\u5230?|\u8BB0\u5F55\u5230?)[\\s\\S]*?[\\w./-]+\\.${fileExt}\\b`,
+    "i"
+  ), writeToFilePatternJa = new RegExp(
+    `(?:[\\w./-]+\\.${fileExt}[\\s\\S]*?(?:\u306B|\u3078)?\\s*(?:\u66F8\u304D\u51FA|\u4FDD\u5B58|\u4F5C\u6210|\u751F\u6210|\u51FA\u529B|\u8A18\u9332|\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8)|(?:\u66F8\u304D\u51FA|\u4FDD\u5B58|\u4F5C\u6210|\u751F\u6210|\u51FA\u529B|\u8A18\u9332|\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8)[\\s\\S]*?[\\w./-]+\\.${fileExt})`,
+    "i"
+  ), writeToFilePatternKo = new RegExp(
+    `(?:[\\w./-]+\\.${fileExt}[\\s\\S]*?(?:\uC5D0|\uC73C\uB85C|\uB85C)?\\s*(?:\uC800\uC7A5|\uC791\uC131|\uC0DD\uC131|\uAE30\uB85D|\uCD9C\uB825|\uB0B4\uBCF4\uB0B4\uAE30)|(?:\uC800\uC7A5|\uC791\uC131|\uC0DD\uC131|\uAE30\uB85D|\uCD9C\uB825|\uB0B4\uBCF4\uB0B4\uAE30)[\\s\\S]*?[\\w./-]+\\.${fileExt})`,
+    "i"
+  );
+  return writeToFilePatternEn.test(textWithoutUrls) || writeToFilePatternGermanic.test(textWithoutUrls) || namedFilePatternEn.test(textWithoutUrls) || createFilePatternEn.test(textWithoutUrls) || directFileVerbPatternEn.test(textWithoutUrls) || writeToFilePatternZh.test(textWithoutUrls) || writeToFilePatternJa.test(textWithoutUrls) || writeToFilePatternKo.test(textWithoutUrls);
+}
 
 // src/orchestration-shell/route-browse.ts
 var RETAINED_PAGE_MAX_CHARS = 12e4, NO_MODEL_PREFIX = "Local CodeVibe model is required to read and summarize web pages.", RUN_INSTALL = "Run `codevibe model install` from a Pro/Max account, then ask again. No hosted model was called and no code was changed.";
@@ -21390,17 +21583,29 @@ function fetchErrorMessage(err, url) {
 async function readUrl(deps, runner, url) {
   let { store, userPrompt, signal } = deps, dispUrl = sanitizeForTerminal(url);
   advise(store, `Reading ${dispUrl}\u2026`);
-  let body, finalUrl, fetch2 = deps.guardedFetchFn ?? guardedFetch;
+  let body, finalUrl, contentType = "", fetch2 = deps.guardedFetchFn ?? guardedFetch;
   try {
-    let res = await fetch2(url, signal);
-    body = res.body, finalUrl = res.finalUrl;
+    let res = await fetch2(url, signal, { allowJson: !0 });
+    body = res.body, finalUrl = res.finalUrl, contentType = res.contentType;
   } catch (err) {
     if (signal?.aborted) return;
     let suffix = deps.delegateAnswer ? " The mentioned agent was not consulted." : "";
     err instanceof FetchError ? advise(store, `${fetchErrorMessage(err, dispUrl)}${suffix}`) : advise(store, `Couldn't read ${dispUrl} (${sanitizeForTerminal(err.message)}). No code was changed.${suffix}`);
     return;
   }
-  let dispFinal = sanitizeForTerminal(finalUrl), { title, text: text2 } = await htmlToText(body), safeTitle = sanitizeForTerminal(title).slice(0, 200), fullSafeText = sanitizeForTerminal(text2);
+  let dispFinal = sanitizeForTerminal(finalUrl), title = dispFinal, text2 = "";
+  if (contentType.toLowerCase().includes("application/json"))
+    try {
+      let parsed = JSON.parse(body);
+      text2 = JSON.stringify(parsed, null, 2);
+    } catch {
+      text2 = body;
+    }
+  else {
+    let extracted = await htmlToText(body);
+    title = extracted.title || dispFinal, text2 = extracted.text || "";
+  }
+  let safeTitle = sanitizeForTerminal(title).slice(0, 200), fullSafeText = sanitizeForTerminal(text2);
   if (signal?.aborted) return;
   if (!fullSafeText.trim()) {
     let suffix = deps.delegateAnswer ? " The mentioned agent was not consulted." : "";
@@ -21529,7 +21734,19 @@ async function readSearchResults(deps, runner, query, results) {
   advise(store, `Reading top ${targetResults.length} web pages in parallel\u2026`);
   let fetch2 = deps.guardedFetchFn ?? guardedFetch, fetchPromises = targetResults.map(async (res) => {
     try {
-      let fetched = await fetch2(res.url, signal), { title, text: text2 } = await htmlToText(fetched.body), safeTitle = sanitizeForTerminal(title || res.title || "").slice(0, 200), rawText = text2 || "";
+      let fetched = await fetch2(res.url, signal, { allowJson: !0 }), title = res.title || "", text2 = "";
+      if ((fetched.contentType || "").toLowerCase().includes("application/json"))
+        try {
+          let parsed = JSON.parse(fetched.body);
+          text2 = JSON.stringify(parsed, null, 2);
+        } catch {
+          text2 = fetched.body;
+        }
+      else {
+        let extracted = await htmlToText(fetched.body);
+        title = extracted.title || title, text2 = extracted.text || "";
+      }
+      let safeTitle = sanitizeForTerminal(title).slice(0, 200), rawText = text2 || "";
       return rawText.trim() ? {
         finalUrl: fetched.finalUrl,
         safeTitle,
@@ -26367,7 +26584,7 @@ async function requestSubcommand(deps, rawTarget) {
     return { exitCode: 1, stdout: "Continuation request is unavailable in this session." };
   let ctx = deps.getActiveRequestContext();
   if (!ctx)
-    return { exitCode: 1, stdout: "No active task to hand off." };
+    return { exitCode: 1, stdout: deps.explainNoActiveRequest?.() ?? "No active task to hand off." };
   try {
     return await deps.request(ctx, targetAgent) ? {
       exitCode: 0,
@@ -31273,7 +31490,7 @@ function stripAgyWebPlugin(workdir) {
 function buildImplementorArgv(agent, mode, workdir, options) {
   switch (agent) {
     case "CLAUDE": {
-      if (process.env.CODEVIBE_ENABLE_AGENT_WEB === "1" && !!options?.mcpConfigPath) {
+      if (!!options?.mcpConfigPath) {
         let disallowedTools = mode === "plan" ? "WebFetch,WebSearch,Bash,Agent,Task,Workflow,SendMessage,ListAgents" : "WebFetch,WebSearch,Agent,Task,Workflow,SendMessage,ListAgents", baseTools = mode === "plan" ? "Read,Grep,Glob" : "Read,Grep,Glob,Edit,Write,Bash", allowedTools = `${baseTools},mcp__codevibe-web__codevibe_web_search,mcp__codevibe-web__codevibe_web_fetch`;
         return {
           argv: [
@@ -31310,7 +31527,7 @@ function buildImplementorArgv(agent, mode, workdir, options) {
       let sandbox = mode === "plan" ? "read-only" : "workspace-write", lastMessagePath = import_node_path.default.join(
         import_node_os.default.tmpdir(),
         `quorum-impl-codex-${process.pid}-${(0, import_uuid4.v4)()}.txt`
-      ), webEnabled = process.env.CODEVIBE_ENABLE_AGENT_WEB === "1" && !!options?.mcpConfigPath, mcpServer = webEnabled ? extractMcpServerConfig(options?.mcpConfigPath) : null;
+      ), webEnabled = !!options?.mcpConfigPath, mcpServer = webEnabled ? extractMcpServerConfig(options?.mcpConfigPath) : null;
       return webEnabled && mcpServer ? {
         argv: [
           "codex",
@@ -31360,7 +31577,7 @@ function buildImplementorArgv(agent, mode, workdir, options) {
         throw new Error(
           "buildImplementorArgv: ANTIGRAVITY requires an absolute workdir (agy is workspace-centric \u2014 --add-dir is its only view of the tree); the call site must thread it (AGY-2.0 D3)"
         );
-      let webEnabled = process.env.CODEVIBE_ENABLE_AGENT_WEB === "1" && !!options?.mcpConfigPath, mcpServer = webEnabled ? extractMcpServerConfig(options?.mcpConfigPath) : null;
+      let webEnabled = !!options?.mcpConfigPath, mcpServer = webEnabled ? extractMcpServerConfig(options?.mcpConfigPath) : null;
       return webEnabled && mcpServer && setupAgyWebPlugin(workdir, mcpServer), {
         argv: [...agyImplementorArgvPrefix(mode), workdir, "--print", ""],
         capture: { kind: "stdout" }
@@ -31709,8 +31926,8 @@ var HookBridge = class {
   // EXECUTOR_REFUSAL (Class A audit) and THEN LOCAL_AUTHORITY_REFUSAL (shell-
   // visible). Reverse order would race the user-visible message ahead of the
   // audit trail. Tests assert the ordering invariant.
-  async bridgeAuthorityRefusal(err, args) {
-    let ctx = this.contextOrNull();
+  async bridgeAuthorityRefusal(err, args, taskCtx) {
+    let ctx = taskCtx ?? this.contextOrNull();
     ctx !== null && await this.deps.emitter.emitExecutorRefusal(ctx, {
       refusal: err.refusal,
       refusedMessageId: args.refusedMessageId
@@ -32292,7 +32509,7 @@ var ClassBConsumer = class {
       }
   }
   async handlePolicyRejection(packet, envelopeTaskId) {
-    let payload = packet.payload, ctx = this.deps.getContext(), hostedRecovery = payload?.recommendedRecovery, recommendedRecovery = hostedRecovery === "reauthorize_locally" || hostedRecovery === "abort_task" || hostedRecovery === "retry_after_resync" ? hostedRecovery : "ask_user";
+    let payload = packet.payload, ctx = envelopeTaskId ? { ...this.deps.getContext(), taskId: envelopeTaskId } : this.deps.getContext(), hostedRecovery = payload?.recommendedRecovery, recommendedRecovery = hostedRecovery === "reauthorize_locally" || hostedRecovery === "abort_task" || hostedRecovery === "retry_after_resync" ? hostedRecovery : "ask_user";
     await this.deps.emitter.emitExecutorRefusal(ctx, {
       refusal: {
         category: "policy_rejection",
@@ -38547,6 +38764,23 @@ var WorkspaceShadow = class _WorkspaceShadow {
       )
     );
   }
+  /**
+   * P46a C1 — the real tree's current content-hash + mode for a workspace-
+   * relative path, read exactly as the promote compare-and-set reads it
+   * (`readRealFileMetadata`; `{ hash: null, mode: null }` when absent). Used to
+   * record a promoted path's post-image and to attribute a later collision.
+   */
+  async readRealMetadata(rel) {
+    return assertSafeRelativePath(rel), assertNotInternalShadowPath(rel), readRealFileMetadata(this.workingDir, rel, this.workspaceRootAuthority);
+  }
+  /**
+   * P46a C2 — the real tree's current text content for a workspace-relative
+   * path (`null` when absent), for the retry brief's "files changed since your
+   * first attempt" diff. Bounded by `MAX_REVIEW_FILE_BYTES`; never logged.
+   */
+  async readRealFileText(rel) {
+    return assertSafeRelativePath(rel), assertNotInternalShadowPath(rel), (await readRealFileForManifest(this.workingDir, rel, this.workspaceRootAuthority)).content;
+  }
   /** Read the crash-durable reviewed artifact, or null for an unreviewed snapshot. */
   async readReviewedDiff() {
     return (await this.readStateMarker())?.reviewedDiff?.map((file) => ({ ...file })) ?? null;
@@ -47457,7 +47691,15 @@ function makeNoopTrackHandle(agentKind) {
 }
 var LocalExecutorImpl = class {
   constructor(deps) {
-    this.taskId = null;
+    /**
+     * P46a B2 — PER-TASK authority scopes: each task's TaskAuthorized path scope
+     * merged over the seeded scope (`mergeAuthorityScope`), keyed by task id. A
+     * spawn reads its OWN task's scope, never a union; authority never
+     * accumulates across tasks. Replaces the singleton `this.scope`/`this.taskId`
+     * pair, which made the SECOND concurrent task's spawn run under the FIRST
+     * task's authorized paths (and mis-attributed its audit context).
+     */
+    this.scopeByTask = /* @__PURE__ */ new Map();
     // CP-12 W2.b — per-track registry (idempotent N-track spawn) + a snapshot of
     // the most-recent TrackAssigned per track (for state-dir + scope on
     // MergeGate). EMPTY for single-track sessions (never touched).
@@ -47501,7 +47743,7 @@ var LocalExecutorImpl = class {
     // re-drain from a duplicate without relying on wall-clock resolution.
     this._lastMergeGateEmitMs = 0;
     this.memberReviewEvidenceByTask = /* @__PURE__ */ new Map();
-    this.sessionId = deps.sessionId, this.substrateEngager = deps.substrateEngager, this.strictBadgeSink = deps.strictBadgeSink, this.scope = deps.initialScope ?? makeEmptyScope(), this.baseCtx = deps.baseCtx, this.adapter = deps.adapter, this.emitShellEvent = deps.emitShellEvent, this.teamDeps = deps, this.onTeamMergeAuditSummary = deps.onTeamMergeAuditSummary, this.logger = deps.logger ?? { warn: (m, x) => console.warn(m, x) }, this.teamModeEnabled = !!(deps.spawnTrackImplementor && deps.appsyncClient && deps.repoRoot && deps.withSnapshotMergeGateFence), this.teamModeEnabled && typeof this.emitShellEvent == "function" && this.sessionId && this.replayPendingTeamDeliveries().catch((err) => {
+    this.sessionId = deps.sessionId, this.substrateEngager = deps.substrateEngager, this.strictBadgeSink = deps.strictBadgeSink, this.baseScope = deps.initialScope ?? makeEmptyScope(), this.baseCtx = deps.baseCtx, this.adapter = deps.adapter, this.emitShellEvent = deps.emitShellEvent, this.teamDeps = deps, this.onTeamMergeAuditSummary = deps.onTeamMergeAuditSummary, this.logger = deps.logger ?? { warn: (m, x) => console.warn(m, x) }, this.teamModeEnabled = !!(deps.spawnTrackImplementor && deps.appsyncClient && deps.repoRoot && deps.withSnapshotMergeGateFence), this.teamModeEnabled && typeof this.emitShellEvent == "function" && this.sessionId && this.replayPendingTeamDeliveries().catch((err) => {
       this.logger.warn("[LocalExecutorImpl] startup background replay of pending team deliveries failed (non-fatal)", {
         err: err?.message
       });
@@ -47529,8 +47771,8 @@ var LocalExecutorImpl = class {
     )), this.bridge = new HookBridge({
       emitter: this.emitter,
       emitShellEvent: this.emitShellEvent,
-      getAuthorityScope: () => this.scope,
-      getCurrentTaskId: () => this.taskId,
+      getAuthorityScope: () => this.baseScope,
+      getCurrentTaskId: () => null,
       getContextWithoutTask: () => this.baseCtx,
       adapter: this.adapter
     }), this.classBConsumer = new ClassBConsumer({
@@ -47538,7 +47780,7 @@ var LocalExecutorImpl = class {
       emitShellEvent: this.emitShellEvent,
       getContext: () => this.contextOrFallback(),
       advanceAuthorityScope: (newScope, taskId) => {
-        this.scope = mergeAuthorityScope(this.scope, newScope), this.taskId = taskId;
+        this.scopeByTask.set(taskId, mergeAuthorityScope(this.baseScope, newScope));
       },
       notifyPolicyRejection: (detail, category, recommendedRecovery, rejectedTaskId) => {
         this.emitShellEvent({
@@ -47630,19 +47872,20 @@ var LocalExecutorImpl = class {
    * is responsible for routing to `bridgeAuthorityErrorToShellRefusal` /
    * `HookBridge.bridgeAuthorityRefusal` per LOCK #C4-3.
    */
-  async enforceAuthority(action) {
+  async enforceAuthority(action, taskId) {
+    let scope = this.scopeFor(taskId);
     switch (action.kind) {
       case "Write":
-        await enforceWrite(this.scope, action.path);
+        await enforceWrite(scope, action.path);
         return;
       case "Read":
-        await enforceRead(this.scope, action.path);
+        await enforceRead(scope, action.path);
         return;
       case "Network":
-        enforceNetwork(this.scope);
+        enforceNetwork(scope);
         return;
       case "Command":
-        enforceCommand(this.scope, action.argv);
+        enforceCommand(scope, action.argv);
         return;
       default: {
         let _exhaustive = action;
@@ -47651,36 +47894,64 @@ var LocalExecutorImpl = class {
     }
   }
   /**
-   * Read-only view of the current authority scope per master §9:1286.
+   * P46a B2 — resolve the authority scope a caller runs under: the task's OWN
+   * merged scope once ITS TaskAuthorized arrived, else the seeded scope (before
+   * authorization, for a task this executor never saw authorized, and for a
+   * task-less caller). Never a union across tasks.
+   */
+  scopeFor(taskId) {
+    return (taskId ? this.scopeByTask.get(taskId) : void 0) ?? this.baseScope;
+  }
+  /**
+   * Read-only view of the SEEDED authority scope per master §9:1286 (P46a B2:
+   * `authorityScope()` keeps today's value at its only production caller — the
+   * continuation writer's clamp, frozen at wiring — which IS the seeded scope).
    * Returns a deep-frozen copy so callers cannot mutate the LE's state.
    */
   authorityScope() {
     return Object.freeze({
-      writeScopes: [...this.scope.writeScopes],
-      readScopes: [...this.scope.readScopes],
-      networkAllowed: this.scope.networkAllowed,
-      commandAllowlist: [...this.scope.commandAllowlist],
-      expiresAt: this.scope.expiresAt
+      writeScopes: [...this.baseScope.writeScopes],
+      readScopes: [...this.baseScope.readScopes],
+      networkAllowed: this.baseScope.networkAllowed,
+      commandAllowlist: [...this.baseScope.commandAllowlist],
+      expiresAt: this.baseScope.expiresAt
+    });
+  }
+  /** P46a B2 (Stage 1 r1 F7) — drop a task's merged scope when the task ends. */
+  forgetTaskScope(taskId) {
+    this.scopeByTask.delete(taskId);
+  }
+  /** P46a B2 — read-only view of ONE task's merged scope (the seeded scope when unauthorized). */
+  authorityScopeForTask(taskId) {
+    let scope = this.scopeFor(taskId);
+    return Object.freeze({
+      writeScopes: [...scope.writeScopes],
+      readScopes: [...scope.readScopes],
+      networkAllowed: scope.networkAllowed,
+      commandAllowlist: [...scope.commandAllowlist],
+      expiresAt: scope.expiresAt
     });
   }
   // --- Authority surface (re-exports through this class for the bound scope) ---
-  enforceCommand(argv) {
-    enforceCommand(this.scope, argv);
+  // P46a B2 — each takes an optional task id and resolves the seeded scope
+  // without one (none has a production caller today).
+  enforceCommand(argv, taskId) {
+    enforceCommand(this.scopeFor(taskId), argv);
   }
-  enforceNetwork() {
-    enforceNetwork(this.scope);
+  enforceNetwork(taskId) {
+    enforceNetwork(this.scopeFor(taskId));
   }
-  async enforceWrite(p) {
-    return enforceWrite(this.scope, p);
+  async enforceWrite(p, taskId) {
+    return enforceWrite(this.scopeFor(taskId), p);
   }
-  async enforceRead(p) {
-    return enforceRead(this.scope, p);
+  async enforceRead(p, taskId) {
+    return enforceRead(this.scopeFor(taskId), p);
   }
-  async safeWriteFile(p, data) {
-    return safeWriteFile(this.scope, p, data);
+  async safeWriteFile(p, data, taskId) {
+    return safeWriteFile(this.scopeFor(taskId), p, data);
   }
-  async safeReadFile(p, opts) {
-    return safeReadFile(this.scope, p, opts);
+  async safeReadFile(p, opts, taskId) {
+    return safeReadFile(this.scopeFor(taskId), p, opts);
   }
   // --- Spawn surface (wires lifecycle hooks to the emitter) ---
   // Per master CP-1 §9:1281-1283 — all three spawn methods take full
@@ -47711,11 +47982,11 @@ var LocalExecutorImpl = class {
       signal: advisoryAdmission.controller.signal
     });
     try {
-      let {
+      let spawnTaskScope = this.scopeFor(promptBoundArgs.taskId ?? null), {
         args: launchArgs,
         onExit,
         substrateEngaged
-      } = await this.engageSubstrateForSpawn(promptBoundArgs, this.scope), outerBoundaryConfines = substrateEngaged || isTrustedContainerBoundary(), finalArgs = {
+      } = await this.engageSubstrateForSpawn(promptBoundArgs, spawnTaskScope), outerBoundaryConfines = substrateEngaged || isTrustedContainerBoundary(), finalArgs = {
         ...launchArgs,
         argv: applyOuterBoundarySandbox(
           relocateCodexLastMessageForSubstrate(
@@ -47726,7 +47997,7 @@ var LocalExecutorImpl = class {
           launchArgs.agentKind ?? this.adapter,
           outerBoundaryConfines
         )
-      }, spawnScope = outerBoundaryConfines ? withBoundaryConfinedCommandAuthority(this.scope) : this.scope, handle = await this.spawnWithLifecycle(
+      }, spawnScope = outerBoundaryConfines ? withBoundaryConfinedCommandAuthority(spawnTaskScope) : spawnTaskScope, handle = await this.spawnWithLifecycle(
         finalArgs,
         (a) => spawnImplementor(spawnScope, a),
         onExit
@@ -47744,7 +48015,7 @@ var LocalExecutorImpl = class {
   async spawnHealthProbe(args) {
     if (this.workspaceShutdown)
       throw new Error("LocalExecutor session shutdown has fenced new health probes");
-    return this.spawnWithLifecycle(args, (a) => spawnHealthProbe(this.scope, a));
+    return this.spawnWithLifecycle(args, (a) => spawnHealthProbe(this.baseScope, a));
   }
   /**
    * Publish advisory ownership synchronously before the first spawn await.
@@ -47847,7 +48118,7 @@ var LocalExecutorImpl = class {
         );
       return { args, substrateEngaged: !1 };
     }
-    let effectiveTaskId = args.taskId ?? this.taskId;
+    let effectiveTaskId = args.taskId ?? null;
     if (effectiveTaskId === null) {
       if (args.requireConfined)
         throw new SpawnConfinementUnavailable(
@@ -47859,7 +48130,7 @@ var LocalExecutorImpl = class {
         "none"
       ), { args, substrateEngaged: !1 };
     }
-    let result = await this.substrateEngager({
+    let isWebActive = args.webTurnActive === !0, result = await this.substrateEngager({
       taskId: effectiveTaskId,
       agentKind,
       workdir: args.workingDir,
@@ -47868,7 +48139,8 @@ var LocalExecutorImpl = class {
       // A1d (design §8.1) — thread the spawn's confinement demand so the engager
       // can build the WRITE-CONFINED resolver row for a broker-less agent
       // (GEMINI/ANTIGRAVITY) rather than immediately returning `reduced_trust`.
-      requireConfined: args.requireConfined === !0
+      requireConfined: args.requireConfined === !0,
+      webBrowsingActive: isWebActive
     });
     if (result.mode === "reduced_trust") {
       if (args.requireConfined)
@@ -47997,7 +48269,7 @@ var LocalExecutorImpl = class {
     }
   }
   async spawnWithLifecycle(args, spawnFn, onSubstrateExit) {
-    let role = args.role, lifecycleAudit = args.lifecycleAudit ?? "active_task", lifecycleTaskId = args.taskId ?? this.taskId, lifecycleCtx = lifecycleTaskId ? { taskId: lifecycleTaskId, ...this.baseCtx } : null, substrateCleanupError, substrateCleanupPromise, cleanupSubstrate = async () => {
+    let role = args.role, lifecycleAudit = args.lifecycleAudit ?? "active_task", lifecycleTaskId = args.taskId ?? null, lifecycleCtx = lifecycleTaskId ? { taskId: lifecycleTaskId, ...this.baseCtx } : null, substrateCleanupError, substrateCleanupPromise, cleanupSubstrate = async () => {
       onSubstrateExit && (substrateCleanupPromise || (substrateCleanupPromise = onSubstrateExit().catch((error) => {
         throw substrateCleanupError = error, error;
       })), await substrateCleanupPromise);
@@ -48050,11 +48322,15 @@ var LocalExecutorImpl = class {
           ...err.refusal,
           detail: safeDetail
         });
-        await this.bridge.bridgeAuthorityRefusal(safeError, {
-          refusedMessageId: "spawn:" + role + ":" + Date.now(),
-          shellContent: `Refused spawn (${role}): ${safeDetail}`,
-          shellMetadata: { role, argv: safeArgv }
-        }), primary = safeError;
+        await this.bridge.bridgeAuthorityRefusal(
+          safeError,
+          {
+            refusedMessageId: "spawn:" + role + ":" + Date.now(),
+            shellContent: `Refused spawn (${role}): ${safeDetail}`,
+            shellMetadata: { role, argv: safeArgv }
+          },
+          lifecycleCtx
+        ), primary = safeError;
       }
       throw substrateCleanupError !== void 0 ? Object.assign(
         new Error("implementor spawn failed and substrate cleanup also failed"),
@@ -49453,11 +49729,12 @@ var LocalExecutorImpl = class {
     ];
     return {
       writeScopes,
-      // Reads cover the shared workspace (current read scopes) + own writes.
-      readScopes: [...this.scope.readScopes, ...writeScopes],
-      networkAllowed: this.scope.networkAllowed,
-      commandAllowlist: [...this.scope.commandAllowlist],
-      expiresAt: this.scope.expiresAt
+      // Reads cover the shared workspace (the seeded read scopes) + own writes.
+      // P46a B2 — derived from the SEEDED scope, never another task's grants.
+      readScopes: [...this.baseScope.readScopes, ...writeScopes],
+      networkAllowed: this.baseScope.networkAllowed,
+      commandAllowlist: [...this.baseScope.commandAllowlist],
+      expiresAt: this.baseScope.expiresAt
     };
   }
   /**
@@ -49583,13 +49860,18 @@ var LocalExecutorImpl = class {
     }
   }
   // --- Test seams ------------------------------------------------------------
-  /** Set the active taskId (production: CP-1.e on TASK_AUTHORIZED). */
-  setActiveTaskId(taskId) {
-    this.taskId = taskId;
-  }
-  /** Replace the active authority scope (production: CP-1.e on TASK_AUTHORIZED). */
+  /**
+   * Replace the SEEDED authority scope (test seam; production seeds it at
+   * construction via `initialScope`). P46a B2: per-task scopes are set only by
+   * a TaskAuthorized (`advanceAuthorityScope`) — use `setAuthorityScopeForTask`
+   * to simulate one in tests.
+   */
   setAuthorityScope(scope) {
-    this.scope = scope;
+    this.baseScope = scope;
+  }
+  /** P46a B2 test seam — install ONE task's merged scope as a TaskAuthorized would. */
+  setAuthorityScopeForTask(taskId, scope) {
+    this.scopeByTask.set(taskId, mergeAuthorityScope(this.baseScope, scope));
   }
   /** Expose emitter for §8.5 integration test introspection. */
   get emitterForTests() {
@@ -49607,21 +49889,18 @@ var LocalExecutorImpl = class {
   get trackHeartbeatCountForTests() {
     return this.trackHeartbeats.size;
   }
-  contextOrNull() {
-    return this.taskId === null ? null : { taskId: this.taskId, ...this.baseCtx };
-  }
   /**
    * Context resolver for ClassBConsumer emit paths (refusals + PolicyRejection).
-   * Class B inbound packets MAY arrive before a TaskAuthorized has set
-   * `this.taskId` (in fact, TaskAuthorized is the variant that SETS it). For
-   * the signature_invalid / ulid_replay / policy_rejection / malformed
-   * refusal-audit emit path we still need a valid envelope context, so we
-   * fall back to `pending` when no task is active. CP-2 may refine this; for
-   * CP-1.e the audit emit always succeeds with a deterministic placeholder.
+   * Class B inbound packets carry no task the executor could attribute a
+   * refusal to before they are verified (signature_invalid / ulid_replay /
+   * policy_rejection / malformed), and P46a B2 removed the singleton task id,
+   * so the refusal-audit emit uses the deterministic `pending` placeholder —
+   * never another task's id. Spawn-attributed emits resolve their task from
+   * the per-spawn `args.taskId` (`lifecycleCtx`).
    */
   contextOrFallback() {
     return {
-      taskId: this.taskId ?? "pending",
+      taskId: "pending",
       ...this.baseCtx
     };
   }
@@ -52023,6 +52302,97 @@ function resolveTeamExecution(_override, _env = process.env) {
 // src/orchestration-shell/quorum-loop.ts
 init_env_scrub();
 
+// src/credential-broker/scrubber.ts
+var REDACTION = "[REDACTED-CP7]", KEY_REDACTION = "[REDACTED-CP7-KEY]", SECRET_PATTERNS = [
+  {
+    // PEM private-key block (RSA / EC / OPENSSH / generic PRIVATE KEY).
+    patternClass: "private_key_pem",
+    regex: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |ENCRYPTED )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |ENCRYPTED )?PRIVATE KEY-----/g
+  },
+  {
+    // Anthropic API key: sk-ant-... .
+    patternClass: "anthropic_api_key",
+    regex: /sk-ant-[A-Za-z0-9_-]{20,}/g
+  },
+  {
+    // OpenAI API key: sk-... or sk-proj-... (>= 20 trailing chars).
+    patternClass: "openai_api_key",
+    regex: /sk-(?:proj-)?[A-Za-z0-9_-]{20,}/g
+  },
+  {
+    // AWS access key id (AKIA / ASIA + 16 uppercase alphanumerics).
+    patternClass: "aws_access_key_id",
+    regex: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g
+  },
+  {
+    // AWS secret access key VALUE assignment — a 40-char base64-ish secret
+    // bound to an `aws_secret_access_key`/`AWS_SECRET_ACCESS_KEY` key. Only
+    // the secret value is redacted, not the assignment label.
+    patternClass: "aws_secret_access_key",
+    regex: /(aws_secret_access_key|AWS_SECRET_ACCESS_KEY)(\s*[=:]\s*["']?)([A-Za-z0-9/+]{40})(["']?)/g
+  },
+  {
+    // GitHub tokens (ghp_/gho_/ghu_/ghs_/ghr_ + 36 chars).
+    patternClass: "github_token",
+    regex: /\bgh[pousr]_[A-Za-z0-9]{36}\b/g
+  },
+  {
+    // Authorization: Bearer <token> embedded in content (a bearer token
+    // riding in a model-bound field). Redacts the token, keeps the scheme.
+    patternClass: "bearer_token",
+    regex: /(Bearer\s+)([A-Za-z0-9._~+/=-]{16,})/g
+  }
+];
+function scrubString(value) {
+  return redactSecretShapes(value, REDACTION);
+}
+function redactSecretShapes(value, placeholder) {
+  let redacted = value, classes = [];
+  for (let pattern of SECRET_PATTERNS)
+    pattern.regex.lastIndex = 0, pattern.regex.test(redacted) && (pattern.regex.lastIndex = 0, pattern.patternClass === "aws_secret_access_key" ? redacted = redacted.replace(pattern.regex, `$1$2${placeholder}$4`) : pattern.patternClass === "bearer_token" ? redacted = redacted.replace(pattern.regex, `$1${placeholder}`) : redacted = redacted.replace(pattern.regex, placeholder), classes.push(pattern.patternClass));
+  return { redacted, classes };
+}
+function redactSecretShapesInText(value, placeholder = "[redacted secret]") {
+  return redactSecretShapes(value, placeholder).redacted;
+}
+function keyIsSecret(key) {
+  for (let pattern of SECRET_PATTERNS) {
+    pattern.regex.lastIndex = 0;
+    let hit = pattern.regex.test(key);
+    if (pattern.regex.lastIndex = 0, hit) return !0;
+  }
+  return !1;
+}
+function joinPath(base, key) {
+  return typeof key == "number" ? `${base}[${key}]` : /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) ? `${base}.${key}` : `${base}['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
+}
+function scrubValue(value, path75, findings) {
+  if (typeof value == "string") {
+    let { redacted, classes } = scrubString(value);
+    for (let patternClass of classes)
+      findings.push({ field: path75, patternClass });
+    return redacted;
+  }
+  if (Array.isArray(value))
+    return value.map((item, i) => scrubValue(item, joinPath(path75, i), findings));
+  if (value !== null && typeof value == "object") {
+    let out = /* @__PURE__ */ Object.create(null), redactedKeyCount = 0;
+    for (let [k, v] of Object.entries(value))
+      if (keyIsSecret(k)) {
+        redactedKeyCount += 1;
+        let placeholder = `${KEY_REDACTION}-${redactedKeyCount}`, placeholderPath = joinPath(path75, placeholder);
+        findings.push({ field: placeholderPath, patternClass: "secret_object_key" }), out[placeholder] = scrubValue(v, placeholderPath, findings);
+      } else
+        out[k] = scrubValue(v, joinPath(path75, k), findings);
+    return out;
+  }
+  return value;
+}
+function scrubRequestBody(body) {
+  let findings = [];
+  return { scrubbed: scrubValue(body, "$", findings), findings };
+}
+
 // src/orchestration-shell/context-items.ts
 var fs39 = __toESM(require("fs/promises")), import_fs2 = require("fs"), path57 = __toESM(require("path")), os32 = __toESM(require("os")), crypto27 = __toESM(require("crypto")), import_ulid3 = require("ulid"), import_uuid7 = require("uuid");
 init_logger2();
@@ -53898,97 +54268,6 @@ function renderRepoSliceCompact(repos, maxChars) {
 var fs40 = __toESM(require("fs/promises")), path58 = __toESM(require("path"));
 init_logger2();
 
-// src/credential-broker/scrubber.ts
-var REDACTION = "[REDACTED-CP7]", KEY_REDACTION = "[REDACTED-CP7-KEY]", SECRET_PATTERNS = [
-  {
-    // PEM private-key block (RSA / EC / OPENSSH / generic PRIVATE KEY).
-    patternClass: "private_key_pem",
-    regex: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |ENCRYPTED )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |ENCRYPTED )?PRIVATE KEY-----/g
-  },
-  {
-    // Anthropic API key: sk-ant-... .
-    patternClass: "anthropic_api_key",
-    regex: /sk-ant-[A-Za-z0-9_-]{20,}/g
-  },
-  {
-    // OpenAI API key: sk-... or sk-proj-... (>= 20 trailing chars).
-    patternClass: "openai_api_key",
-    regex: /sk-(?:proj-)?[A-Za-z0-9_-]{20,}/g
-  },
-  {
-    // AWS access key id (AKIA / ASIA + 16 uppercase alphanumerics).
-    patternClass: "aws_access_key_id",
-    regex: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g
-  },
-  {
-    // AWS secret access key VALUE assignment — a 40-char base64-ish secret
-    // bound to an `aws_secret_access_key`/`AWS_SECRET_ACCESS_KEY` key. Only
-    // the secret value is redacted, not the assignment label.
-    patternClass: "aws_secret_access_key",
-    regex: /(aws_secret_access_key|AWS_SECRET_ACCESS_KEY)(\s*[=:]\s*["']?)([A-Za-z0-9/+]{40})(["']?)/g
-  },
-  {
-    // GitHub tokens (ghp_/gho_/ghu_/ghs_/ghr_ + 36 chars).
-    patternClass: "github_token",
-    regex: /\bgh[pousr]_[A-Za-z0-9]{36}\b/g
-  },
-  {
-    // Authorization: Bearer <token> embedded in content (a bearer token
-    // riding in a model-bound field). Redacts the token, keeps the scheme.
-    patternClass: "bearer_token",
-    regex: /(Bearer\s+)([A-Za-z0-9._~+/=-]{16,})/g
-  }
-];
-function scrubString(value) {
-  return redactSecretShapes(value, REDACTION);
-}
-function redactSecretShapes(value, placeholder) {
-  let redacted = value, classes = [];
-  for (let pattern of SECRET_PATTERNS)
-    pattern.regex.lastIndex = 0, pattern.regex.test(redacted) && (pattern.regex.lastIndex = 0, pattern.patternClass === "aws_secret_access_key" ? redacted = redacted.replace(pattern.regex, `$1$2${placeholder}$4`) : pattern.patternClass === "bearer_token" ? redacted = redacted.replace(pattern.regex, `$1${placeholder}`) : redacted = redacted.replace(pattern.regex, placeholder), classes.push(pattern.patternClass));
-  return { redacted, classes };
-}
-function redactSecretShapesInText(value, placeholder = "[redacted secret]") {
-  return redactSecretShapes(value, placeholder).redacted;
-}
-function keyIsSecret(key) {
-  for (let pattern of SECRET_PATTERNS) {
-    pattern.regex.lastIndex = 0;
-    let hit = pattern.regex.test(key);
-    if (pattern.regex.lastIndex = 0, hit) return !0;
-  }
-  return !1;
-}
-function joinPath(base, key) {
-  return typeof key == "number" ? `${base}[${key}]` : /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) ? `${base}.${key}` : `${base}['${key.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}']`;
-}
-function scrubValue(value, path75, findings) {
-  if (typeof value == "string") {
-    let { redacted, classes } = scrubString(value);
-    for (let patternClass of classes)
-      findings.push({ field: path75, patternClass });
-    return redacted;
-  }
-  if (Array.isArray(value))
-    return value.map((item, i) => scrubValue(item, joinPath(path75, i), findings));
-  if (value !== null && typeof value == "object") {
-    let out = /* @__PURE__ */ Object.create(null), redactedKeyCount = 0;
-    for (let [k, v] of Object.entries(value))
-      if (keyIsSecret(k)) {
-        redactedKeyCount += 1;
-        let placeholder = `${KEY_REDACTION}-${redactedKeyCount}`, placeholderPath = joinPath(path75, placeholder);
-        findings.push({ field: placeholderPath, patternClass: "secret_object_key" }), out[placeholder] = scrubValue(v, placeholderPath, findings);
-      } else
-        out[k] = scrubValue(v, joinPath(path75, k), findings);
-    return out;
-  }
-  return value;
-}
-function scrubRequestBody(body) {
-  let findings = [];
-  return { scrubbed: scrubValue(body, "$", findings), findings };
-}
-
 // src/orchestration-shell/user-rules.ts
 var USER_RULE_ACTION = "user_rule", USER_RULE_RETIRED_ACTION = "user_rule_retired", USER_WORDS_VISIBLE_TO = ["planner", "brainstorm", "implementor"], USER_RULE_MAX_CHARS = 600, WORKFLOW_HANDOFF_SECTION_LABEL = "Workflow handoff context:", HANDOFF_SECTION_START = new RegExp(
   `(?:^|\\n)${WORKFLOW_HANDOFF_SECTION_LABEL.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\nSource: `
@@ -56936,10 +57215,74 @@ function teamRound0GateId(taskId, taskGroupId, trackIndex, dispatchGeneration) {
     TEAM_ROUND0_GATE_NAMESPACE
   );
 }
+var RETRY_BRIEF_SECTION_CAP = 8 * 1024, RETRY_BRIEF_TOTAL_CAP = 64 * 1024, UNIFIED_DIFF_MAX_CELLS = 4e6;
+function capText2(text2, cap) {
+  if (Buffer.byteLength(text2, "utf8") <= cap) return text2;
+  let marker = `
+\u2026 [truncated]`, cut = text2;
+  for (; Buffer.byteLength(cut, "utf8") + Buffer.byteLength(marker, "utf8") > cap && cut.length > 0; )
+    cut = cut.slice(0, Math.max(0, Math.floor(cut.length * 0.9) - 1));
+  return cut + marker;
+}
+function unifiedDiff(fromLabel, toLabel, fromText, toText) {
+  let a = fromText.length === 0 ? [] : fromText.split(`
+`), b = toText.length === 0 ? [] : toText.split(`
+`), ops = [];
+  if (a.length * b.length > UNIFIED_DIFF_MAX_CELLS) {
+    for (let i = 0; i < a.length; i++) ops.push({ kind: "-", line: a[i], ai: i, bi: 0 });
+    for (let j = 0; j < b.length; j++) ops.push({ kind: "+", line: b[j], ai: a.length, bi: j });
+  } else {
+    let rows = a.length + 1, cols = b.length + 1, table = new Uint32Array(rows * cols);
+    for (let i2 = a.length - 1; i2 >= 0; i2--)
+      for (let j2 = b.length - 1; j2 >= 0; j2--)
+        table[i2 * cols + j2] = a[i2] === b[j2] ? table[(i2 + 1) * cols + j2 + 1] + 1 : Math.max(table[(i2 + 1) * cols + j2], table[i2 * cols + j2 + 1]);
+    let i = 0, j = 0;
+    for (; i < a.length && j < b.length; )
+      a[i] === b[j] ? (ops.push({ kind: " ", line: a[i], ai: i, bi: j }), i++, j++) : table[(i + 1) * cols + j] >= table[i * cols + j + 1] ? (ops.push({ kind: "-", line: a[i], ai: i, bi: j }), i++) : (ops.push({ kind: "+", line: b[j], ai: i, bi: j }), j++);
+    for (; i < a.length; ) ops.push({ kind: "-", line: a[i], ai: i, bi: j }), i++;
+    for (; j < b.length; ) ops.push({ kind: "+", line: b[j], ai: i, bi: j }), j++;
+  }
+  let out = [`--- ${fromLabel}`, `+++ ${toLabel}`], CONTEXT = 3, k = 0;
+  for (; k < ops.length; ) {
+    if (ops[k].kind === " ") {
+      k++;
+      continue;
+    }
+    let start = Math.max(0, k - CONTEXT), end = k, lastChange = k;
+    for (; end < ops.length && (ops[end].kind !== " " && (lastChange = end), !(end - lastChange > 2 * CONTEXT)); )
+      end++;
+    end = Math.min(ops.length, lastChange + CONTEXT + 1);
+    let slice = ops.slice(start, end), fromStart = (slice.find((o) => o.kind !== "+")?.ai ?? ops[start].ai) + 1, toStart = (slice.find((o) => o.kind !== "-")?.bi ?? ops[start].bi) + 1, fromCount = slice.filter((o) => o.kind !== "+").length, toCount = slice.filter((o) => o.kind !== "-").length;
+    out.push(`@@ -${fromStart},${fromCount} +${toStart},${toCount} @@`);
+    for (let o of slice) out.push(`${o.kind}${o.line}`);
+    k = end, start = end;
+  }
+  return out.length === 2 && out.push("(no textual difference)"), out.join(`
+`);
+}
 var QuorumLoop = class _QuorumLoop {
   constructor(deps) {
-    /** The active task this desktop is driving (set at start_task). */
-    this.activeTaskId = null;
+    /**
+     * P46a B1 — the FOCUSED single task: the task the UI means when a command
+     * names none (`/continue`, `/review-reset`, the status "starting" row).
+     * Default = the most recently CONFIRMED START; `/task focus <n>` sets it
+     * explicitly; it advances to the newest remaining single task when the
+     * focused task ends; a rejected START never moves it. It replaces the three
+     * P45 singletons (`activeTaskId` / `activeBrief` / `activeImplementorAgent`):
+     * every reader now resolves through the task's OWN record
+     * (`singleTaskContextByTask`), never through "the latest task".
+     */
+    this.focusedTaskId = null;
+    /** P46a B1 — confirmed single tasks in START-confirmation order (focus fallback). */
+    this.confirmedSingleOrder = [];
+    /**
+     * P46a B1 — the most recent START still in flight (or null). A legacy
+     * GATE_DISPATCH with an EMPTY envelope task id can only belong to it (the P45
+     * rule); with no START in flight such a packet is a no-op left to recovery.
+     */
+    this.latestInFlightStart = null;
+    /** Stage 1 r1 F13 — every START still in flight, in issue order; `latestInFlightStart` is its last entry. */
+    this.startOrderInFlight = [];
     /** Tasks whose next automatic revise round must start a fresh review baseline. */
     this.reviewScopeResetTasks = /* @__PURE__ */ new Set();
     /** Non-terminal tasks for which `/review-reset` may arm the next revise round. */
@@ -56963,16 +57306,9 @@ var QuorumLoop = class _QuorumLoop {
     // only per QuorumLoop life; a `0`/absent entry omits the ` · ↓ <tokens>` segment.
     this.tokensByTaskId = /* @__PURE__ */ new Map();
     this.tokensCountedGates = /* @__PURE__ */ new Set();
-    /**
-     * The implementor brief for the active task (set at start_task). The
-     * GATE_DISPATCH consumer reads this to drive the round-0 implementor spawn —
-     * the brief is no longer threaded inline through the spawn call (the spawn
-     * moved out of `startTask` into the GATE_DISPATCH consumer, §3.C.20 FIX).
-     */
-    this.activeBrief = null;
     /**
      * IMAGE-ATTACHMENT-DESIGN.md §5 — TASK-SCOPED image attachments (parallel to
-     * `activeBrief`/`activeBriefByTask`). The single-impl path uses `activeAttachments`;
+     * `singleTaskContextByTask`/`activeBriefByTask`). The single-impl path uses `activeAttachments`;
      * the team path keys by the child `taskId` in `activeAttachmentsByTask` (armed at
      * `registerTeamTaskBrief`, before its buffered GATE_DISPATCH drains). Re-copied
      * into EACH round's shadow at `runImplementorRound` (round-0, revise, continuation,
@@ -57027,19 +57363,44 @@ var QuorumLoop = class _QuorumLoop {
     this.recoveredBriefsByAuthority = /* @__PURE__ */ new Map();
     this.activeBriefByTask = /* @__PURE__ */ new Map();
     /**
-     * P45 D1 (M7 E2E step 8, 2026-09-14) — the brief + agent of EVERY single-
-     * implementor task this loop started, keyed by task id. `activeTaskId` /
-     * `activeBrief` / `activeImplementorAgent` are the LATEST task only: when a
-     * second single task started while the first still ran (the planner routed a
-     * mid-task turn as a task), the first task's revise round was composed from
-     * the second task's request (`buildReviseBrief` fell back to `activeBrief`)
-     * and its round-0 dispatch — whose envelope names the FIRST task — would have
-     * been mis-read as a team dispatch. Round-0 spawns, revise rounds and the
-     * continuation context resolve through this map first; the singletons stay
-     * as the legacy fallback (an empty envelope task id, the test seam). Entries
-     * are removed with the task's other per-task state at its terminal cleanup.
+     * P45 D1 (M7 E2E step 8, 2026-09-14) / P46a B1 — the brief + agent of EVERY
+     * LIVE single-implementor task this loop started, keyed by task id. P45 added
+     * it beside the three "latest task" singletons (a second single task's
+     * request had replaced the first task's in its revise round); P46a deletes
+     * the singletons — round-0 spawns, revise rounds, the continuation context and
+     * every other reader resolve ONLY through this map. An entry exists from the
+     * START call (in flight) until the task's terminal cleanup; `retryOf` links a
+     * `#n retry` task to its `apply_failed` original (P46a C2/C3).
      */
     this.singleTaskContextByTask = /* @__PURE__ */ new Map();
+    /** Agent web browsing (upstream 2.0.37) — whether a task's ORIGINAL request needs web access; ends with the task (`forgetSingleTask`, team cleanup). */
+    this.webAccessByTask = /* @__PURE__ */ new Map();
+    /**
+     * P46a D2 — append-only per-loop-life record of every single task this loop
+     * started (confirmed or in flight) with its terminal outcome once known, for
+     * `/status` (`describeTasks`). Never deleted (bounded by the session's tasks).
+     */
+    this.singleTaskHistory = /* @__PURE__ */ new Map();
+    /**
+     * P46a C1 — every single-task promote THIS session landed, by workspace-
+     * relative path: the promoting task + the post-image hash/mode the promote
+     * compare-and-set reads (`readRealMetadata`; `null` hash = a deletion). Used
+     * to attribute a later collision to a `session-task` (the path's current
+     * metadata equals a recorded post-image) or `external` (anything else —
+     * including a session-promoted file the user edited afterwards, and every
+     * promote by another session). In-memory, fail-safe: empty after a desktop
+     * restart, so every collision then classifies as `external`.
+     */
+    this.promotedByPath = /* @__PURE__ */ new Map();
+    /** P46a C2 — originals whose ONE automatic retry has been issued (never a second). */
+    this.autoRetryIssuedFor = /* @__PURE__ */ new Set();
+    /**
+     * P46a C2 — retry STARTs planned inside the promote critical section and
+     * issued only after it (and the durable `apply_failed` record) completed:
+     * `startTask` runs the round-0 spawn before returning, so it must never run
+     * inside `promoteShadowLocked`.
+     */
+    this.pendingPromoteRetries = [];
     /**
      * CP-1.f revise-context fix (dogfood task 2ac68708, 2026-06-11) — the BINDING
      * user-requested changes for a task, accumulated across ALL revise rounds.
@@ -57502,8 +57863,6 @@ var QuorumLoop = class _QuorumLoop {
     this.lastWorkspaceOutcome = null;
     // ─── §3.C.18 — real Ed25519 signature verify (cached key) ───────────────
     this.cachedSigningKey = null;
-    /** The implementor agent the loop spawns (set at start_task). */
-    this.activeImplementorAgent = "CLAUDE";
     this.deps = deps, this.sleep = deps.sleep ?? realSleep2, this.loadCompletedSummariesFromDisk();
   }
   getCompletedSummariesPath() {
@@ -58092,13 +58451,95 @@ var QuorumLoop = class _QuorumLoop {
   isTaskTerminallyRetired(taskId) {
     return this.isWorkspaceTaskTerminallyRetired(taskId);
   }
-  /** The current active task id (for the recovery poll). */
+  /**
+   * P46a B1 — the FOCUSED single task (null when no single task is live). The
+   * P45 `activeTask` name is kept for the shell's readers; it now means the
+   * focused task, never "the latest task".
+   */
   get activeTask() {
-    return this.activeTaskId;
+    return this.focusedTaskId;
+  }
+  /** P46a B1 — every LIVE single task this loop started (in flight or confirmed). */
+  knownSingleTasks() {
+    return [...this.singleTaskContextByTask.keys()];
+  }
+  /**
+   * P46a B1 — `/task focus <n>`: make `taskId` the focused task. Refused (false)
+   * for a task this loop does not know as a live single task.
+   */
+  setFocusedTask(taskId) {
+    return this.singleTaskContextByTask.has(taskId) ? (this.focusedTaskId = taskId, !0) : !1;
+  }
+  /** P46a D1 — install the store-owned ordinal sink (the shell, after construction). */
+  setTaskOrdinalSink(sink) {
+    this.taskOrdinalSink = sink;
+  }
+  /** P46a C3 — install the desktop-local apply-conflict menu sink. */
+  setApplyConflictSink(sink) {
+    this.applyConflictSink = sink;
+  }
+  /** P46a C2 — install the retry-started notifier (the shell records the lifecycle row). */
+  setRetryStartedSink(sink) {
+    this.retryStartedSink = sink;
   }
-  /** Arm an explicit, one-shot comprehensive baseline for the active task. */
+  /** P46a D1 — `#n` / `#n retry` / short id for any task id (never throws). */
+  labelFor(taskId) {
+    try {
+      let label = this.taskOrdinalSink?.label(taskId);
+      if (label) return label;
+    } catch {
+    }
+    return taskId.length > 8 ? taskId.slice(0, 8) : taskId;
+  }
+  /**
+   * P46a D2 — every single task this loop started, for `/status`: its label,
+   * agent, request (desktop-local plaintext — the user's own words), link to an
+   * `apply_failed` original, loop state and whether it is the focused task.
+   */
+  describeTasks() {
+    let rows = [];
+    for (let [taskId, rec] of this.singleTaskHistory)
+      rows.push({
+        taskId,
+        label: this.labelFor(taskId),
+        agent: rec.agent,
+        // Stage 1 r3 F1 — a retry's excerpt is the user's own request, not its composed brief.
+        brief: rec.request ?? rec.brief,
+        ...rec.retryOf ? { retryOf: rec.retryOf } : {},
+        outcome: rec.outcome,
+        implementorActive: this.activeImplementorByTask.has(taskId),
+        focused: taskId === this.focusedTaskId
+      });
+    return rows;
+  }
+  /** Stage 1 r1 F13 — a START confirmed or rejected: the newest START still in flight (if any) becomes the empty-envelope target. */
+  dropInFlightStart(taskId) {
+    let at = this.startOrderInFlight.indexOf(taskId);
+    at >= 0 && this.startOrderInFlight.splice(at, 1), this.latestInFlightStart = this.startOrderInFlight.length > 0 ? this.startOrderInFlight[this.startOrderInFlight.length - 1] : null;
+  }
+  /**
+   * P46a B1 — a single task ended (promote, terminal discard, rejected START):
+   * drop its live record and, when it was the focused task, advance the focus
+   * to the newest remaining confirmed single task (or none).
+   */
+  forgetSingleTask(taskId, outcome) {
+    this.singleTaskContextByTask.delete(taskId), this.webAccessByTask.delete(taskId), this.deps.localExecutor.forgetTaskScope?.(taskId);
+    let history = this.singleTaskHistory.get(taskId);
+    history && history.outcome === "running" && (history.outcome = outcome);
+    let at = this.confirmedSingleOrder.indexOf(taskId);
+    at >= 0 && this.confirmedSingleOrder.splice(at, 1), this.focusedTaskId === taskId && (this.focusedTaskId = this.confirmedSingleOrder.length > 0 ? this.confirmedSingleOrder[this.confirmedSingleOrder.length - 1] : null);
+  }
+  /**
+   * Arm an explicit, one-shot comprehensive baseline for the FOCUSED task
+   * (P46a B1). Refused with the candidate list when the focused task has no
+   * eligible gate (or no single task is focused) — the shell renders the
+   * `#n` candidates so the user can `/task focus <n>` first.
+   */
   requestReviewScopeReset() {
-    return !this.activeTaskId || !this.reviewScopeResetEligibleTasks.has(this.activeTaskId) ? !1 : (this.reviewScopeResetTasks.add(this.activeTaskId), !0);
+    let focused = this.focusedTaskId;
+    return focused && this.reviewScopeResetEligibleTasks.has(focused) ? (this.reviewScopeResetTasks.add(focused), { armed: !0, taskId: focused }) : { armed: !1, candidates: [...this.singleTaskContextByTask.keys()].filter(
+      (id) => id !== focused && this.reviewScopeResetEligibleTasks.has(id)
+    ) };
   }
   /**
    * Audited-path fix (Fix 5) — the host's detected implementor agents
@@ -58280,8 +58721,7 @@ var QuorumLoop = class _QuorumLoop {
       return logger.warn("[QuorumLoop] startTask aborted \u2014 no session key", {
         sessionId: this.deps.session.sessionId
       }), null;
-    let previousSingle = this.activeTaskId !== null ? this.singleTaskContextByTask.get(this.activeTaskId) : void 0, previousActive = this.activeTaskId !== null && previousSingle ? { taskId: this.activeTaskId, brief: previousSingle.brief, agent: previousSingle.agent } : null;
-    this.activeTaskId = taskId, this.activeBrief = args.brief, appendContextItem(this.deps.session.sessionId, {
+    appendContextItem(this.deps.session.sessionId, {
       kind: "task_spec",
       author: { role: "engine" },
       sensitivity: "user",
@@ -58289,7 +58729,14 @@ var QuorumLoop = class _QuorumLoop {
       task_id: taskId,
       body: { text: args.brief }
     }).catch(() => {
-    }), this.activeAttachments = args.attachments ?? [], this.activeAttachmentsByTask.set(taskId, this.activeAttachments), this.activeImplementorAgent = this.resolveForcedImplementorAgent() ?? args.agent, this.singleTaskContextByTask.set(taskId, { brief: args.brief, agent: this.activeImplementorAgent }), this.startTasksInFlight.add(taskId), this.deps.armLeTaskId?.(taskId);
+    }), this.activeAttachments = args.attachments ?? [], this.activeAttachmentsByTask.set(taskId, this.activeAttachments);
+    let implementorAgent = this.resolveForcedImplementorAgent() ?? args.agent, record = {
+      brief: args.brief,
+      agent: implementorAgent,
+      ...args.retryOf ? { retryOf: args.retryOf } : {},
+      ...args.request !== void 0 ? { request: args.request } : {}
+    };
+    this.singleTaskContextByTask.set(taskId, record), this.singleTaskHistory.set(taskId, { ...record, outcome: "running" }), this.startTasksInFlight.add(taskId), this.startOrderInFlight.push(taskId), this.latestInFlightStart = taskId;
     let workflowState;
     try {
       workflowState = (await this.deps.appsyncClient.startTask({
@@ -58302,31 +58749,40 @@ var QuorumLoop = class _QuorumLoop {
         // an empty `[]` (host detected nothing) is sent verbatim →
         // Claude-only fail-safe.
         availableAgents: this.deps.detectedAgents,
-        implementorAgent: this.activeImplementorAgent.toLowerCase()
+        implementorAgent: implementorAgent.toLowerCase()
       })).workflowState;
     } catch (err) {
-      let wasNewest = this.activeTaskId === taskId, restoreTo = previousActive && this.singleTaskContextByTask.has(previousActive.taskId) ? previousActive : null;
-      wasNewest && (this.activeTaskId = restoreTo?.taskId ?? null, this.activeBrief = restoreTo?.brief ?? null, restoreTo && (this.activeImplementorAgent = restoreTo.agent)), this.singleTaskContextByTask.delete(taskId), this.startTasksInFlight.delete(taskId);
+      let wasLatestStart2 = this.latestInFlightStart === taskId;
+      this.forgetSingleTask(taskId, "rejected"), this.startTasksInFlight.delete(taskId), this.dropInFlightStart(taskId);
       for (let i = this.pendingGateDispatches.length - 1; i >= 0; i--) {
         let pending = this.pendingGateDispatches[i];
-        (pending.envelopeTaskId === taskId || !pending.envelopeTaskId && wasNewest) && this.pendingGateDispatches.splice(i, 1);
+        (pending.envelopeTaskId === taskId || !pending.envelopeTaskId && wasLatestStart2) && this.pendingGateDispatches.splice(i, 1);
       }
-      return wasNewest && this.deps.armLeTaskId?.(restoreTo?.taskId ?? null), logger.warn("[QuorumLoop] startTask failed \u2014 rolled back armed task + discarded buffered GATE_DISPATCH", {
+      return logger.warn("[QuorumLoop] startTask failed \u2014 dropped the task record + discarded its buffered GATE_DISPATCH", {
         err: err.message
       }), null;
     }
-    this.startTasksInFlight.delete(taskId), this.reviewScopeResetEligibleTasks.add(taskId), logger.info("[QuorumLoop] startTask succeeded \u2014 draining buffered GATE_DISPATCH (if any) then awaiting more", {
+    this.startTasksInFlight.delete(taskId);
+    let wasLatestStart = this.latestInFlightStart === taskId;
+    this.dropInFlightStart(taskId), this.reviewScopeResetEligibleTasks.add(taskId);
+    let ordinal = this.taskOrdinalSink?.assign(taskId, {
+      kind: "single",
+      ...args.retryOf ? { retryOf: args.retryOf } : {}
+    });
+    this.confirmedSingleOrder.push(taskId), this.focusedTaskId = taskId, logger.info("[QuorumLoop] startTask succeeded \u2014 draining buffered GATE_DISPATCH (if any) then awaiting more", {
       taskId,
+      ...ordinal !== void 0 ? { ordinal } : {},
+      ...args.retryOf ? { retryOf: args.retryOf } : {},
       workflowState,
       buffered: this.pendingGateDispatches.length
     });
     let drained = [];
     for (let i = this.pendingGateDispatches.length - 1; i >= 0; i--) {
       let entry = this.pendingGateDispatches[i];
-      (!entry.envelopeTaskId || entry.envelopeTaskId === taskId) && drained.unshift(this.pendingGateDispatches.splice(i, 1)[0]);
+      (!entry.envelopeTaskId && wasLatestStart || entry.envelopeTaskId === taskId) && drained.unshift(this.pendingGateDispatches.splice(i, 1)[0]);
     }
     for (let entry of drained)
-      await this.handleGateDispatch(entry.payload, entry.envelopeTaskId);
+      await this.handleGateDispatch(entry.payload, entry.envelopeTaskId ?? taskId);
     return { taskId };
   }
   // ─── §3.C.20 — GATE_DISPATCH → round-0 implementor spawn ────────────────
@@ -58349,7 +58805,7 @@ var QuorumLoop = class _QuorumLoop {
    * never thrown upward.
    */
   async handleGateDispatch(payload, envelopeTaskId) {
-    let dispatchTaskId = envelopeTaskId || this.activeTaskId;
+    let dispatchTaskId = envelopeTaskId || this.latestInFlightStart;
     if (dispatchTaskId && Array.isArray(payload.reviewerSeats) && payload.reviewerSeats.length > 0) {
       let roster = this.expectedRosterByTask.get(dispatchTaskId);
       roster || (roster = /* @__PURE__ */ new Map(), this.expectedRosterByTask.set(dispatchTaskId, roster));
@@ -58367,11 +58823,12 @@ var QuorumLoop = class _QuorumLoop {
       logger.info("[QuorumLoop] GateDispatch dedup no-op", { gateRunId: payload.gateRunId });
       return;
     }
-    if (typeof envelopeTaskId == "string" && envelopeTaskId.length > 0 && envelopeTaskId !== this.activeTaskId && // P45 D1 — a dispatch for an EARLIER single task (a later `startTask` moved
-    // `activeTaskId` on) is still a single-implementor dispatch, not a team one.
+    if (typeof envelopeTaskId == "string" && envelopeTaskId.length > 0 && // P45 D1 / P46a B1 — a dispatch for ANY single task this loop started (in
+    // flight or confirmed, earlier or later) is a single-implementor dispatch;
+    // only an unknown task id routes to the team handler.
     !this.singleTaskContextByTask.has(envelopeTaskId))
       return this.bufferTeamPacketDuringSeeding("gateDispatch", payload, envelopeTaskId) ? void 0 : this.handleTeamGateDispatch(payload, envelopeTaskId);
-    let inFlightFor = typeof envelopeTaskId == "string" && envelopeTaskId.length > 0 ? envelopeTaskId : this.activeTaskId;
+    let inFlightFor = typeof envelopeTaskId == "string" && envelopeTaskId.length > 0 ? envelopeTaskId : this.latestInFlightStart;
     if (inFlightFor !== null && this.startTasksInFlight.has(inFlightFor)) {
       logger.info("[QuorumLoop] GateDispatch buffered \u2014 startTask in flight (early-packet race)", {
         gateRunId: payload.gateRunId,
@@ -58379,15 +58836,15 @@ var QuorumLoop = class _QuorumLoop {
       }), this.pendingGateDispatches.push({ payload, envelopeTaskId });
       return;
     }
-    let single = typeof envelopeTaskId == "string" && envelopeTaskId.length > 0 ? this.singleTaskContextByTask.get(envelopeTaskId) : void 0, taskId = single ? envelopeTaskId : this.activeTaskId, brief = single?.brief ?? this.activeBrief, agent = single?.agent ?? this.activeImplementorAgent;
-    if (!taskId || !brief) {
-      logger.warn("[QuorumLoop] GateDispatch arrived before start_task recorded the active task \u2014 no-op (recovery will handle)", {
+    let single = typeof envelopeTaskId == "string" && envelopeTaskId.length > 0 ? this.singleTaskContextByTask.get(envelopeTaskId) : void 0;
+    if (!single || !envelopeTaskId) {
+      logger.warn("[QuorumLoop] GateDispatch names no task this loop started \u2014 no-op (recovery will handle)", {
         gateRunId: payload.gateRunId,
-        hasTaskId: !!taskId,
-        hasBrief: !!brief
+        hasEnvelopeTaskId: typeof envelopeTaskId == "string" && envelopeTaskId.length > 0
       });
       return;
     }
+    let taskId = envelopeTaskId, brief = single.brief, agent = single.agent;
     this.seenGateDispatchRunIds.add(payload.gateRunId);
     let sessionKey = await this.deps.getSessionKey(this.deps.session.sessionId);
     if (!sessionKey) {
@@ -58942,8 +59399,13 @@ ${section}`);
           settlePending = resolve23;
         }),
         ...args.teamAuthority ? { teamAuthority: args.teamAuthority } : {}
-      };
-      if (process.env.CODEVIBE_ENABLE_AGENT_WEB === "1" && (args.agent === "CLAUDE" || args.agent === "ANTIGRAVITY"))
+      }, needsWeb = this.webAccessByTask.get(args.taskId);
+      if (needsWeb === void 0) {
+        let singleRecord = this.singleTaskContextByTask.get(args.taskId), originalPrompt = (singleRecord ? singleRecord.request ?? singleRecord.brief : void 0) ?? this.activeBriefByTask.get(args.taskId)?.brief ?? // P46a B1 — no singleton fallback: a task without a record reads as no request.
+        (args.roundNumber === 0 ? args.brief : "");
+        needsWeb = isWebAccessNeeded(originalPrompt), this.webAccessByTask.set(args.taskId, needsWeb);
+      }
+      if (needsWeb && (args.agent === "CLAUDE" || args.agent === "ANTIGRAVITY"))
         try {
           agentWebTurn = await startAgentWebTurn({
             sessionId: this.deps.session.sessionId,
@@ -58974,13 +59436,13 @@ ${section}`);
           workingDirAuthority: snapshotAuthority,
           role: "implementor",
           agentKind: args.agent,
-          // CP-12 W2.b — thread THIS round's task id as per-spawn substrate/audit
-          // authority. On the TEAM path `args.taskId` is the per-track child
-          // `task_id` (the LE singleton stays unset/clobber-free for concurrent
-          // tracks); on the single-impl path it equals the armed singleton
-          // (`setActiveTaskId`), so the LE's `args.taskId ?? this.taskId` fallback
-          // yields byte-identical single-impl substrate engagement.
+          // CP-12 W2.b / P46a B2 — thread THIS round's task id as the per-spawn
+          // substrate/audit/authority identity. On the TEAM path `args.taskId` is
+          // the per-track child `task_id`; on the single-impl path it is the task's
+          // own id — the executor keeps no singleton any more and resolves the
+          // per-task authority scope (seeded until ITS TaskAuthorized) from it.
           taskId: args.taskId,
+          webTurnActive: !!agentWebTurn?.mcpConfigPath,
           timeoutMs: null,
           stdinTty: !0,
           // PHASE-CP-10-MIN (#585) — the cooperative abort signal (#C10M-16).
@@ -60203,7 +60665,7 @@ ${section}`);
       ));
     }
     for (let taskId of taskIds)
-      this.activeBriefByTask.get(taskId)?.taskGroupId === taskGroupId && (this.activeBriefByTask.delete(taskId), this.activeAttachmentsByTask.delete(taskId));
+      this.activeBriefByTask.get(taskId)?.taskGroupId === taskGroupId && (this.activeBriefByTask.delete(taskId), this.activeAttachmentsByTask.delete(taskId), this.webAccessByTask.delete(taskId));
     if (this.teamAttachmentsByGroup.delete(taskGroupId), failures.length > 0) {
       try {
         this.surfaceHalt(
@@ -60281,7 +60743,7 @@ ${section}`);
         });
         return;
       }
-    if (opts?.preserveReviseContext || (this.userNotesByTask.delete(taskId), this.reviewScopeResetTasks.delete(taskId), this.reviewScopeResetEligibleTasks.delete(taskId), this.roundHistoryByTask.delete(taskId), opts?.taskContinues !== !0 && this.singleTaskContextByTask.delete(taskId), this.rationaleByTask.delete(taskId), this.taskDegradedMetadataByTask.delete(taskId), this.expectedRosterByTask.delete(taskId), this.activeGateByTaskId.delete(taskId), this.conflictedSeatsByTask.delete(taskId), this.nonApprovedSeatsByTask.delete(taskId), this.restartFenceByTaskId.delete(taskId), appendContextItem(this.deps.session.sessionId, {
+    if (opts?.preserveReviseContext || (this.userNotesByTask.delete(taskId), this.reviewScopeResetTasks.delete(taskId), this.reviewScopeResetEligibleTasks.delete(taskId), this.roundHistoryByTask.delete(taskId), opts?.taskContinues !== !0 && this.forgetSingleTask(taskId, "discarded"), this.rationaleByTask.delete(taskId), this.taskDegradedMetadataByTask.delete(taskId), this.expectedRosterByTask.delete(taskId), this.activeGateByTaskId.delete(taskId), this.conflictedSeatsByTask.delete(taskId), this.nonApprovedSeatsByTask.delete(taskId), this.restartFenceByTaskId.delete(taskId), appendContextItem(this.deps.session.sessionId, {
       kind: "verdict",
       author: { role: "engine" },
       sensitivity: "user",
@@ -60327,7 +60789,123 @@ ${section}`);
    */
   async promoteShadow(taskId) {
     if (!(this.shuttingDown && (this.terminalClassBAdmissionsByTask.get(taskId)?.size ?? 0) === 0))
-      return this.runExclusiveShadowOp(taskId, () => this.promoteShadowLocked(taskId));
+      try {
+        await this.runExclusiveShadowOp(taskId, () => this.promoteShadowLocked(taskId));
+      } finally {
+        this.pendingPromoteRetries.length > 0 && setImmediate(() => {
+          this.drainPromoteRetries().catch((err) => {
+            logger.warn("[QuorumLoop] automatic retry drain failed", { err: err.message });
+          });
+        });
+      }
+  }
+  /** P46a C2 — start every planned automatic retry as a new linked task. */
+  async drainPromoteRetries() {
+    for (; this.pendingPromoteRetries.length > 0; ) {
+      let plan = this.pendingPromoteRetries.shift();
+      if (this.shuttingDown) {
+        logger.info("[QuorumLoop] automatic retry skipped \u2014 shutting down", { retryOf: plan.retryOf });
+        continue;
+      }
+      try {
+        let started = await this.startTask({
+          decision: { action: "start_task", rationale: "P46a automatic retry after a session-task collision" },
+          brief: plan.brief,
+          agent: plan.agent,
+          retryOf: plan.retryOf,
+          request: plan.request
+        });
+        started ? (this.retryStartedSink?.({ taskId: started.taskId, retryOf: plan.retryOf, agent: plan.agent }), this.surfaceHalt(
+          `Task ${this.labelFor(started.taskId)} started \u2014 the retry of task ${this.labelFor(plan.retryOf)}.`
+        )) : this.surfaceHalt(
+          `Could not start the automatic retry of task ${this.labelFor(plan.retryOf)} (the START was rejected). Re-issue the request to try again.`
+        );
+      } catch (err) {
+        logger.warn("[QuorumLoop] automatic retry START threw (non-fatal)", {
+          retryOf: plan.retryOf,
+          err: err.message
+        }), this.surfaceHalt(
+          `Could not start the automatic retry of task ${this.labelFor(plan.retryOf)}. Re-issue the request to try again.`
+        );
+      }
+    }
+  }
+  /** P46a D2 — correct a task's recorded outcome after its terminal cleanup ran. */
+  markTaskOutcome(taskId, outcome) {
+    let history = this.singleTaskHistory.get(taskId);
+    history && (history.outcome = outcome);
+  }
+  /**
+   * P46a C1 — classify each conflicting path: `session-task` when its current
+   * real-tree metadata equals a post-image a single-task promote of THIS
+   * session recorded (`promotedByPath`), else `external`.
+   */
+  async attributeConflicts(shadow, paths) {
+    let out = [];
+    for (let rel of paths) {
+      let recorded = this.promotedByPath.get(rel), cause = "external";
+      if (recorded)
+        try {
+          let current = await shadow.readRealMetadata(rel);
+          current.hash === recorded.postHash && current.mode === recorded.postMode && (cause = "session-task");
+        } catch {
+          cause = "external";
+        }
+      out.push({ path: rel, cause, ...cause === "session-task" && recorded ? { byTaskId: recorded.taskId } : {} });
+    }
+    return out;
+  }
+  /**
+   * P46a C2 — the retry brief: the original request, a "Files changed since
+   * your first attempt" section (a unified diff from the failed task's REVIEWED
+   * contents to the CURRENT real contents, per conflicting path, naming the
+   * session task that changed it), and the reviewed contents themselves. Every
+   * section is capped (`RETRY_BRIEF_SECTION_CAP` per path,
+   * `RETRY_BRIEF_TOTAL_CAP` overall — the brief becomes the retry task's
+   * durable `task_spec`, whose write is fire-and-forget) and secret-scrubbed
+   * (`redactSecretShapesInText`) before insertion.
+   */
+  async buildRetryBrief(shadow, failedTaskId, originalBrief, attributed, reviewed) {
+    let failedLabel = this.labelFor(failedTaskId), reviewedByPath = new Map(reviewed.map((file) => [file.path, file])), changed = [], contents = [];
+    for (let conflict of attributed) {
+      let who = conflict.cause === "session-task" && conflict.byTaskId ? `changed by task ${this.labelFor(conflict.byTaskId)} in this session` : "changed outside CodeVibe", reviewedFile = reviewedByPath.get(conflict.path), reviewedText = reviewedFile && reviewedFile.change_kind !== "deleted" ? reviewedFile.content : "", currentText = null, currentState = "";
+      try {
+        currentText = await shadow.readRealFileText(conflict.path);
+      } catch (err) {
+        currentText = null, currentState = err.code === "ENOENT" ? "; now absent" : "; unreadable now";
+      }
+      let diffText = unifiedDiff(
+        `reviewed (task ${failedLabel})`,
+        "current",
+        reviewedText,
+        currentText ?? ""
+      );
+      changed.push(
+        `### ${conflict.path} (${who}${currentState})`,
+        "```diff",
+        capText2(diffText, RETRY_BRIEF_SECTION_CAP),
+        "```"
+      ), reviewedFile && contents.push(
+        `### ${conflict.path}${reviewedFile.change_kind === "deleted" ? " (you deleted this file)" : ""}`,
+        "```",
+        capText2(reviewedText, RETRY_BRIEF_SECTION_CAP),
+        "```"
+      );
+    }
+    let changedSection = redactSecretShapesInText(changed.join(`
+`)), contentsSection = redactSecretShapesInText(contents.join(`
+`)), assembled = [
+      originalBrief.trim(),
+      "",
+      "## Files changed since your first attempt",
+      `Your first attempt (task ${failedLabel}) was reviewed and approved, but could not be applied: ${attributed.length} file(s) changed in the workspace after your attempt. Re-do the request against the CURRENT files. Each diff below goes from the contents you produced (your reviewed version) to the contents now in the workspace.`,
+      changedSection,
+      "",
+      "## Your reviewed contents from the first attempt",
+      contentsSection
+    ].join(`
+`);
+    return capText2(assembled, RETRY_BRIEF_TOTAL_CAP);
   }
   /**
    * CP-12 W2.b (§3.C.2b (d) / H3-4) — promote-quiescence BARRIER for `taskId`.
@@ -60350,6 +60928,12 @@ ${section}`);
     return this.promoteShadowLockedInner(taskId, originEpoch);
   }
   async promoteShadowLockedInner(taskId, originEpoch) {
+    let singleContext = this.singleTaskContextByTask.get(taskId), retryContext = singleContext ? {
+      brief: singleContext.brief,
+      agent: singleContext.agent,
+      ...singleContext.retryOf ? { retryOf: singleContext.retryOf } : {},
+      ...singleContext.request !== void 0 ? { request: singleContext.request } : {}
+    } : void 0;
     try {
       let teamAuthority = this.teamAuthorityForTask(taskId);
       if (this.teamRunIsHalted(teamAuthority)) return;
@@ -60362,9 +60946,15 @@ ${section}`);
           error: err?.message
         }), historySnapshot = null;
       }
-      this.userNotesByTask.delete(taskId), this.reviewScopeResetTasks.delete(taskId), this.reviewScopeResetEligibleTasks.delete(taskId), this.roundHistoryByTask.delete(taskId), this.singleTaskContextByTask.delete(taskId), this.rationaleByTask.delete(taskId), this.taskDegradedMetadataByTask.delete(taskId), this.expectedRosterByTask.delete(taskId), this.activeGateByTaskId.delete(taskId), this.conflictedSeatsByTask.delete(taskId), this.nonApprovedSeatsByTask.delete(taskId), this.restartFenceByTaskId.delete(taskId);
+      this.userNotesByTask.delete(taskId), this.reviewScopeResetTasks.delete(taskId), this.reviewScopeResetEligibleTasks.delete(taskId), this.roundHistoryByTask.delete(taskId), this.forgetSingleTask(taskId, "apply_failed"), this.rationaleByTask.delete(taskId), this.taskDegradedMetadataByTask.delete(taskId), this.expectedRosterByTask.delete(taskId), this.activeGateByTaskId.delete(taskId), this.conflictedSeatsByTask.delete(taskId), this.nonApprovedSeatsByTask.delete(taskId), this.restartFenceByTaskId.delete(taskId);
       let shadow = this.shadowsByTask.get(taskId);
       if (!shadow) {
+        if (this.singleTaskHistory.get(taskId)?.outcome === "discarded") {
+          this.surfaceHalt(
+            `Could not apply task ${this.labelFor(taskId)} \u2014 its workspace copy was discarded after its implementor round failed on this side; nothing was applied. Re-run the request.`
+          ), logger.warn("[QuorumLoop] promote on a discarded task \u2014 nothing applied", { taskId });
+          return;
+        }
         logger.info("[QuorumLoop] promote no-op \u2014 no in-memory shadow for task", { taskId });
         return;
       }
@@ -60614,7 +61204,8 @@ ${section}`);
           shadow,
           diff,
           terminalOutcomeReserved,
-          historySnapshot
+          historySnapshot,
+          retryContext
         );
       } finally {
         this.emitProgress({ phase: "progress_cleared" }, originEpoch);
@@ -60632,7 +61223,7 @@ ${section}`);
    * no-op/re-delivery/discard returns (which must stay silent). All emits carry the
    * caller-resolved `originEpoch`.
    */
-  async promoteApplyLocked(taskId, originEpoch, shadow, diff, terminalOutcomeReserved, historySnapshot) {
+  async promoteApplyLocked(taskId, originEpoch, shadow, diff, terminalOutcomeReserved, historySnapshot, retryContext) {
     this.emitProgress({ phase: "promoting", files: diff.length }, originEpoch);
     let teamPromoteEntry = this.activeBriefByTask.get(taskId), captureManifest = this.deps.durableStore && teamPromoteEntry && teamPromoteEntry.taskGroupId.length > 0 ? {
       trackIndex: teamPromoteEntry.trackIndex,
@@ -60652,21 +61243,85 @@ ${section}`);
       }
     } : void 0, res = await shadow.promote(diff, captureManifest ? { captureManifest } : void 0);
     if (res.conflicts.length > 0 || res.errors.length > 0) {
-      let paths = [...res.conflicts, ...res.errors.map((e) => e.path)];
-      if (this.surfaceHalt(
-        `Could not promote \u2014 ${paths.length} file(s) at ${paths.join(", ")} changed under the task or failed to write. The approved change was not fully applied.`
-      ), res.mutationState === "unresolved") {
-        logger.warn("[QuorumLoop] unresolved promotion retained for reconciliation", {
+      let paths = [...res.conflicts, ...res.errors.map((e) => e.path)], label = this.labelFor(taskId);
+      if (res.mutationState === "unresolved") {
+        this.surfaceHalt(
+          `Could not apply task ${label} \u2014 ${paths.length} file(s) at ${paths.join(", ")} changed under the task or failed to write; the snapshot is retained until it is reconciled.`
+        ), logger.warn("[QuorumLoop] unresolved promotion retained for reconciliation", {
           taskId,
           paths
+        }), this.markTaskOutcome(taskId, "unresolved");
+        return;
+      }
+      let isSingleTask = retryContext !== void 0 && !this.activeBriefByTask.has(taskId), attributed = isSingleTask ? await this.attributeConflicts(shadow, res.conflicts) : [], writeErrors = res.errors.length > 0, retryBrief = null, rootRequest = retryContext ? retryContext.request ?? retryContext.brief : "";
+      if (isSingleTask)
+        if (attributed.length > 0)
+          try {
+            retryBrief = await this.buildRetryBrief(
+              shadow,
+              taskId,
+              rootRequest,
+              attributed,
+              this.reviewedSnapshotByTask.get(taskId) ?? []
+            );
+          } catch (err) {
+            logger.warn("[QuorumLoop] retry brief composition failed (offering the original request only)", {
+              taskId,
+              err: err.message
+            }), retryBrief = rootRequest;
+          }
+        else
+          retryBrief = rootRequest;
+      if (await this.discardShadowLocked(taskId, shadow), this.markTaskOutcome(taskId, "apply_failed"), terminalOutcomeReserved && this.terminallyRetiredWorkspaceTasks.has(taskId) && await this.workspaceOutcomeSink.completeTask(taskId, "apply_failed"), !isSingleTask || retryBrief === null) {
+        this.surfaceHalt(
+          `Could not apply task ${label} \u2014 ${paths.length} file(s) at ${paths.join(", ")} changed under the task or failed to write. The approved change was not applied.`
+        );
+        return;
+      }
+      let sessionChanged = attributed.filter((c) => c.cause === "session-task"), byLabels = [...new Set(sessionChanged.map((c) => this.labelFor(c.byTaskId)))], causes = [];
+      sessionChanged.length > 0 && causes.push(`${sessionChanged.length} changed by task ${byLabels.join(", ")}`), attributed.length - sessionChanged.length > 0 && causes.push(`${attributed.length - sessionChanged.length} changed outside CodeVibe`), writeErrors && causes.push(`${res.errors.length} could not be written`);
+      let total = attributed.length + res.errors.length, summary = `${total} ${total === 1 ? "file" : "files"} (${causes.join("; ")})`;
+      if (!writeErrors && attributed.every((c) => c.cause === "session-task") && retryContext.retryOf === void 0 && !this.autoRetryIssuedFor.has(taskId)) {
+        this.autoRetryIssuedFor.add(taskId), this.pendingPromoteRetries.push({ retryOf: taskId, brief: retryBrief, agent: retryContext.agent, request: rootRequest }), this.surfaceHalt(
+          `Could not apply task ${label}: ${summary} after it was reviewed. Retrying automatically as a new task on a fresh snapshot (it will be reviewed and approved again).`
+        ), logger.info("[QuorumLoop] promote collided with a session task \u2014 automatic retry planned", {
+          taskId,
+          conflicts: attributed.length
         });
         return;
       }
-      await this.discardShadowLocked(taskId, shadow), terminalOutcomeReserved && this.terminallyRetiredWorkspaceTasks.has(taskId) && await this.workspaceOutcomeSink.completeTask(taskId, "apply_failed");
+      let autoRetried = retryContext.retryOf !== void 0 && this.autoRetryIssuedFor.has(retryContext.retryOf);
+      this.surfaceHalt(
+        `Could not apply task ${label}: ${summary}` + (autoRetried ? " \u2014 the automatic retry collided too." : ".")
+      );
+      let menu = {
+        taskId,
+        taskLabel: label,
+        conflicts: [
+          ...attributed.map((c) => ({
+            path: c.path,
+            cause: c.cause,
+            ...c.byTaskId ? { byTaskLabel: this.labelFor(c.byTaskId) } : {}
+          })),
+          ...res.errors.map((e) => ({ path: e.path, cause: "write-error" }))
+        ],
+        autoRetried,
+        retryBrief,
+        request: rootRequest,
+        agent: retryContext.agent
+      };
+      try {
+        this.applyConflictSink?.(menu);
+      } catch (err) {
+        logger.warn("[QuorumLoop] apply-conflict menu sink threw (ignored)", {
+          taskId,
+          err: err.message
+        });
+      }
       return;
     }
     if (!res.materialized)
-      if (res.recovered)
+      if (this.markTaskOutcome(taskId, "applied"), res.recovered)
         logger.info("[QuorumLoop] recovered fully-applied snapshot promotion", { taskId });
       else {
         logger.debug("[QuorumLoop] promote no-op \u2014 marker flipped to promoted mid-call", { taskId }), terminalOutcomeReserved && await this.workspaceOutcomeSink.completeTask(taskId, "applied", {
@@ -60685,6 +61340,19 @@ ${section}`);
         return;
       }
     let appliedPaths = res.recovered ? diff.map((file) => file.path) : res.promoted;
+    if (this.markTaskOutcome(taskId, "applied"), retryContext !== void 0 && !this.activeBriefByTask.has(taskId)) {
+      let at = (/* @__PURE__ */ new Date()).toISOString();
+      for (let rel of appliedPaths)
+        try {
+          let meta = await shadow.readRealMetadata(rel);
+          this.promotedByPath.set(rel, { taskId, postHash: meta.hash, postMode: meta.mode, at });
+        } catch (err) {
+          this.promotedByPath.delete(rel), logger.debug("[QuorumLoop] promoted-path post-image read failed (left unattributed)", {
+            taskId,
+            err: err.message
+          });
+        }
+    }
     terminalOutcomeReserved && await this.workspaceOutcomeSink.completeTask(taskId, "applied", {
       filesApplied: appliedPaths.length
     }), logger.info("[QuorumLoop] shadow promoted to real tree", {
@@ -60937,7 +61605,11 @@ ${section}`);
       });
       return;
     }
-    if (dispatchTaskId) {
+    if (logger.info("[QuorumLoop] ReviewerDispatch received", {
+      gateId: payload.gateId,
+      seatId: seat,
+      ...dispatchTaskId ? { taskId: dispatchTaskId } : {}
+    }), dispatchTaskId) {
       let roster = this.expectedRosterByTask.get(dispatchTaskId);
       roster || (roster = /* @__PURE__ */ new Map(), this.expectedRosterByTask.set(dispatchTaskId, roster)), roster.set(String(seat), String(payload.role || "reviewer"));
     }
@@ -61222,7 +61894,7 @@ ${section}`);
         "[QuorumLoop] reviewer-sandboxing DISABLED by operator opt-out (CODEVIBE_SANDBOX_REVIEWERS=0) \u2014 legacy path",
         { key }
       ), NO_TEARDOWN;
-    let taskId = this.taskByGateId.get(args.gateId) ?? this.activeTaskId;
+    let taskId = this.taskByGateId.get(args.gateId);
     if (!taskId)
       return this.surfaceReviewerReducedTrust(
         args,
@@ -61787,32 +62459,51 @@ ${section}`);
   // ─── §3.C.21b — dropped-packet recovery ─────────────────────────────────
   /**
    * On WS (re)connect/startup, poll for the seats assigned to this desktop for
-   * any in_review gate of the active task and spawn any seat NEITHER already
-   * running-in-memory NOR already verdict-submitted (double-guard). Without
-   * this, a REVIEWER_DISPATCH dropped during a WS gap hangs the gate forever.
+   * any in_review gate of EVERY in-flight task (P46a B3: the live single tasks,
+   * the tasks with an active implementor, and the registered team tracks — one
+   * query each) and spawn any seat NEITHER already running-in-memory NOR already
+   * verdict-submitted (double-guard). Without this, a REVIEWER_DISPATCH dropped
+   * during a WS gap hangs the gate forever. Residual (unchanged): after a full
+   * desktop restart the in-memory maps are empty.
    */
   async recoverInReviewAssignments() {
-    if (this.shuttingDown || !this.activeTaskId) return;
-    let assignments;
-    try {
-      assignments = await this.deps.appsyncClient.getInReviewAssignments(this.activeTaskId);
-    } catch (err) {
-      logger.warn("[QuorumLoop] getInReviewAssignments failed (non-fatal)", {
-        err: err.message
-      });
-      return;
-    }
-    if (!this.shuttingDown)
-      for (let a of assignments) {
-        if (this.shuttingDown) break;
-        let key = seatKey(a.gateId, a.seatId);
-        this.runningSeats.has(key) || this.submittedSeats.has(key) || this.spawnOneSeat({
-          gateId: a.gateId,
-          seatId: a.seatId,
-          role: a.role,
-          agentKind: a.agentKind
-        });
+    if (this.shuttingDown) return;
+    let taskIds = /* @__PURE__ */ new Set([
+      ...this.singleTaskContextByTask.keys(),
+      ...this.activeImplementorByTask.keys(),
+      ...this.activeBriefByTask.keys()
+    ]);
+    if (taskIds.size !== 0) {
+      logger.info("[QuorumLoop] recovering in-review assignments", { taskIds: [...taskIds] });
+      for (let taskId of taskIds) {
+        if (this.shuttingDown) return;
+        let assignments;
+        try {
+          assignments = await this.deps.appsyncClient.getInReviewAssignments(taskId);
+        } catch (err) {
+          logger.warn("[QuorumLoop] getInReviewAssignments failed (non-fatal)", {
+            taskId,
+            err: err.message
+          });
+          continue;
+        }
+        if (this.shuttingDown) return;
+        for (let a of assignments) {
+          if (this.shuttingDown) break;
+          let key = seatKey(a.gateId, a.seatId);
+          this.runningSeats.has(key) || this.submittedSeats.has(key) || (logger.info("[QuorumLoop] recovered in-review seat (its REVIEWER_DISPATCH was not consumed)", {
+            taskId,
+            gateId: a.gateId,
+            seatId: a.seatId
+          }), this.spawnOneSeat({
+            gateId: a.gateId,
+            seatId: a.seatId,
+            role: a.role,
+            agentKind: a.agentKind
+          }));
+        }
       }
+    }
   }
   // ─── §4 / #PR-4 / #GC-1 — shadow recovery + GC on reconnect/startup ──────
   /**
@@ -61852,7 +62543,7 @@ ${section}`);
         ]), signal);
         if (!this.admittedSessionWorkMayContinue(admission)) return;
         let now = Date.now(), ttlMs = env.ttlMs ?? DEFAULT_SHADOW_TTL_MS, keep = /* @__PURE__ */ new Set();
-        this.activeTaskId && keep.add(this.activeTaskId);
+        for (let taskId of this.singleTaskContextByTask.keys()) keep.add(taskId);
         for (let taskId of this.shadowsByTask.keys()) keep.add(taskId);
         for (let taskId of this.shadowCreateInFlight.keys()) keep.add(taskId);
         let failures = [], sameWorkspace = recoverable.filter(
@@ -62737,7 +63428,7 @@ ${section}`);
       });
       return;
     }
-    let taskId = this.taskByGateId.get(payload.gateId) ?? this.activeTaskId ?? "", originEpoch = this.originEpochFor(taskId);
+    let taskId = this.taskByGateId.get(payload.gateId) ?? "", originEpoch = this.originEpochFor(taskId);
     if (taskId === "") {
       logger.warn(
         "[QuorumLoop] ReviseFeedback could not resolve a task (in-memory state lost after restart?) \u2014 failing loud",
@@ -62747,7 +63438,17 @@ ${section}`);
       ), this.emitProgress({ phase: "progress_cleared" }, originEpoch);
       return;
     }
-    let trackEntry = this.activeBriefByTask.get(taskId), parentTeamAuthority = this.teamAuthorityByGateId.get(payload.gateId), teamAuthority = parentTeamAuthority ?? (trackEntry ? _QuorumLoop.teamAuthorityForEntry(trackEntry) : void 0);
+    let trackEntry = this.activeBriefByTask.get(taskId), singleEntry = this.singleTaskContextByTask.get(taskId);
+    if (!trackEntry && !singleEntry) {
+      logger.warn(
+        "[QuorumLoop] ReviseFeedback names a task with no live record (ended, or lost after restart?) \u2014 failing loud",
+        { taskId, gateId: payload.gateId, nextGateId: payload.nextGateId }
+      ), this.surfaceHalt(
+        `Could not resume this revise for task ${this.labelFor(taskId)} \u2014 its context is gone (re-issue the task to continue).`
+      ), this.emitProgress({ phase: "progress_cleared" }, originEpoch);
+      return;
+    }
+    let parentTeamAuthority = this.teamAuthorityByGateId.get(payload.gateId), teamAuthority = parentTeamAuthority ?? (trackEntry ? _QuorumLoop.teamAuthorityForEntry(trackEntry) : void 0);
     if (parentTeamAuthority && (!trackEntry || !this.teamEntryMayContinue(taskId, trackEntry, parentTeamAuthority))) {
       logger.info("[QuorumLoop] stale team ReviseFeedback refused \u2014 generation retired", {
         taskId,
@@ -62782,7 +63483,9 @@ ${section}`);
       gateId: payload.nextGateId,
       roundNumber: payload.nextRound,
       brief,
-      agent: trackEntry?.agent ?? this.singleTaskContextByTask.get(taskId)?.agent ?? this.activeImplementorAgent,
+      // P46a B1 — the TRACK's agent (team) or the single task's OWN agent (its
+      // record is guaranteed above); never a session-wide "active agent".
+      agent: trackEntry?.agent ?? singleEntry.agent,
       sessionKey,
       ...teamAuthority ? { teamAuthority } : {},
       ...priorRationale ? { priorRationale } : {},
@@ -62798,32 +63501,53 @@ ${section}`);
       } : {}
     });
   }
-  setActiveImplementorAgent(agent) {
-    this.activeImplementorAgent = agent;
+  /**
+   * P46a B1 — set a single task's implementor agent on ITS record (the only
+   * caller is `resumeFromContinuation`, after the user chose a target agent).
+   * Replaces the session-wide `setActiveImplementorAgent` singleton.
+   */
+  setTaskImplementorAgent(taskId, agent) {
+    let current = this.singleTaskContextByTask.get(taskId);
+    current && this.singleTaskContextByTask.set(taskId, { ...current, agent });
+    let history = this.singleTaskHistory.get(taskId);
+    history && (history.agent = agent);
   }
   // ─── PHASE-CP-10-MIN (#585) — continuation handoff ────────────────────────
   /**
-   * #585 #C10M-9 — resolve the active task's request context for `/continue
-   * request` (the entrypoint wires this to the slash route's
-   * `getActiveRequestContext`). Returns `null` when no implementor round is
-   * active (no gate to hand off from). The `gateId`/`roundNumber` come from the
-   * ACTIVE implementor registry (the round currently running); the brief +
-   * source agent come from the loop's active state.
+   * #585 #C10M-9 / P46a B1 (OQ-1, decided) — resolve WHICH single task a
+   * `/continue request` means: the FOCUSED task if it has an active implementor
+   * round; else the single task that has one; else refuse — `ambiguous` lists
+   * the candidates (the shell renders their `#n` so the user can
+   * `/task focus <n>` first), `none` means no task is running a round. The
+   * `gateId`/`roundNumber` come from the ACTIVE implementor registry (the round
+   * currently running); the brief + source agent from the task's own record.
    */
-  getActiveContinuationRequestContext() {
-    let taskId = this.activeTaskId;
-    if (!taskId) return null;
-    let active = this.activeImplementorByTask.get(taskId);
-    if (!active) return null;
-    let single = this.singleTaskContextByTask.get(taskId), brief = this.activeBriefByTask.get(taskId)?.brief ?? single?.brief ?? this.activeBrief ?? "";
+  resolveContinuationRequest() {
+    let withActiveRound = [...this.singleTaskContextByTask.keys()].filter(
+      (id) => this.activeImplementorByTask.has(id)
+    ), taskId = null;
+    if (this.focusedTaskId && this.activeImplementorByTask.has(this.focusedTaskId))
+      taskId = this.focusedTaskId;
+    else if (withActiveRound.length === 1)
+      taskId = withActiveRound[0];
+    else return withActiveRound.length === 0 ? { kind: "none" } : { kind: "ambiguous", candidates: withActiveRound };
+    let active = this.activeImplementorByTask.get(taskId), single = this.singleTaskContextByTask.get(taskId);
     return {
-      taskId,
-      gateId: active.gateId,
-      roundNumber: active.roundNumber,
-      brief,
-      sourceAgent: single?.agent ?? this.activeImplementorAgent
+      kind: "ok",
+      ctx: {
+        taskId,
+        gateId: active.gateId,
+        roundNumber: active.roundNumber,
+        brief: this.activeBriefByTask.get(taskId)?.brief ?? single.brief,
+        sourceAgent: single.agent
+      }
     };
   }
+  /** The `ok` projection of {@link resolveContinuationRequest} (null otherwise). */
+  getActiveContinuationRequestContext() {
+    let resolved = this.resolveContinuationRequest();
+    return resolved.kind === "ok" ? resolved.ctx : null;
+  }
   /**
    * #585 L-A — mint a fresh `expiresAt = now + TTL` at millisecond precision
    * (RFC-3339). Fresh per request so a CANCEL→re-request produces a distinct
@@ -63108,9 +63832,7 @@ ${section}`);
     }
     if (trackEntry && teamAuthority && !this.teamEntryMayContinue(input.taskId, trackEntry, teamAuthority) || this.shuttingDown) return !1;
     let brief = this.buildResumeBrief(packet);
-    this.setActiveImplementorAgent(input.targetAgent);
-    let resumedSingle = this.singleTaskContextByTask.get(input.taskId);
-    resumedSingle && this.singleTaskContextByTask.set(input.taskId, { brief: resumedSingle.brief, agent: input.targetAgent }), logger.info("[QuorumLoop] resuming from continuation", {
+    this.setTaskImplementorAgent(input.taskId, input.targetAgent), logger.info("[QuorumLoop] resuming from continuation", {
       taskId: input.taskId,
       sourceAgent: packet.sourceAgent,
       targetAgent: input.targetAgent,
@@ -63235,7 +63957,7 @@ ${section}`);
    * user requirement.
    */
   buildReviseBrief(taskId, payload) {
-    let originalBrief = this.activeBriefByTask.get(taskId)?.brief ?? this.singleTaskContextByTask.get(taskId)?.brief ?? this.activeBrief ?? "", userNotes = this.userNotesByTask.get(taskId) ?? [], history = (this.roundHistoryByTask.get(taskId) ?? []).filter(
+    let originalBrief = this.activeBriefByTask.get(taskId)?.brief ?? this.singleTaskContextByTask.get(taskId)?.brief ?? "", userNotes = this.userNotesByTask.get(taskId) ?? [], history = (this.roundHistoryByTask.get(taskId) ?? []).filter(
       (r) => r.round < payload.nextRound - 1
     );
     return composeReviseBrief(originalBrief, userNotes, payload, history);
@@ -63396,9 +64118,16 @@ ${section}`);
   get _submittedSeatsForTests() {
     return this.submittedSeats;
   }
-  /** @internal — test seam to set the active task without start_task. */
-  _setActiveTaskForTests(taskId, brief) {
-    this.activeTaskId = taskId, this.reviewScopeResetEligibleTasks.add(taskId), brief !== void 0 && (this.activeBrief = brief, this.singleTaskContextByTask.set(taskId, { brief, agent: this.activeImplementorAgent }));
+  /**
+   * @internal — test seam to register a single task (its record + focus)
+   * without start_task. P46a B1: the record is what every reader resolves, so
+   * the seam always creates one (an empty brief when none is given).
+   */
+  _setActiveTaskForTests(taskId, brief, agent = "CLAUDE", gateIds = []) {
+    this.reviewScopeResetEligibleTasks.add(taskId);
+    let existing = this.singleTaskContextByTask.get(taskId), record = { brief: brief ?? existing?.brief ?? "", agent: existing?.agent ?? agent };
+    this.singleTaskContextByTask.set(taskId, record), this.singleTaskHistory.has(taskId) || this.singleTaskHistory.set(taskId, { ...record, outcome: "running" }), this.confirmedSingleOrder.includes(taskId) || this.confirmedSingleOrder.push(taskId), this.focusedTaskId = taskId;
+    for (let gateId of gateIds) this.taskByGateId.set(gateId, taskId);
   }
   /** @internal — read a task's accumulated binding user notes. */
   _userNotesForTests(taskId) {
@@ -64247,6 +64976,23 @@ function resolveBrowseUrls(modelUrls, prompt) {
   let usable = modelUrls.filter(isWellFormedHttpUrl);
   return usable.length > 0 ? usable : void 0;
 }
+function numberedLabel(state, taskId) {
+  let label = taskLabel(state, taskId);
+  return label.startsWith("#") ? label : null;
+}
+function findActiveContinuationOfferEntry(conversation) {
+  for (let entry of conversation)
+    if (entry.kind === "gate-prompt" && entry.final === !1 && entry.envelope.promptKind === CONTINUATION_OFFER_HANDOFF_PROMPT_KIND)
+      return entry;
+  return null;
+}
+function mobileGateReplyAmbiguity(state, text2) {
+  if (!/^\s*\d+\s*$/.test(text2)) return null;
+  let open15 = state.conversation.filter(
+    (e) => e.kind === "gate-prompt" && e.final === !1 && (e.uiState.phase === "awaiting-number" || e.uiState.phase === "awaiting-notes")
+  );
+  return open15.length <= 1 ? null : `Several reviews are open on the desktop (${[...new Set(open15.map((e) => taskLabel(state, e.envelope.taskId)))].map((l) => `task ${l}`).join(", ")}); a number from the phone cannot choose between them yet \u2014 answer on the desktop, or wait until one review is left.`;
+}
 var OrchestrationShellStartupError = class extends Error {
   constructor(message, cause) {
     super(message), this.name = "OrchestrationShellStartupError", this.cause = cause;
@@ -64349,11 +65095,21 @@ function wireTeamMergeAuditSummary(store, target) {
 }
 async function runOrchestrationShell(args) {
   let store = createOrchestrationStore({ session: args.session }), originalStoreDispatch = store.dispatch.bind(store);
-  store.dispatch = ((action) => (action && action.type === "GATE_PROMPT_RECEIVED" && action.envelope && args.quorumLoop && typeof args.quorumLoop.registerActiveGate == "function" && args.quorumLoop.registerActiveGate(
-    action.envelope.taskId,
-    action.envelope.gateId,
-    action.envelope.currentRound ?? 0
-  ), originalStoreDispatch(action)));
+  store.dispatch = ((action) => {
+    action && action.type === "GATE_PROMPT_RECEIVED" && action.envelope && args.quorumLoop && typeof args.quorumLoop.registerActiveGate == "function" && args.quorumLoop.registerActiveGate(
+      action.envelope.taskId,
+      action.envelope.gateId,
+      action.envelope.currentRound ?? 0
+    );
+    let gateAlreadyShown = action && action.type === "GATE_PROMPT_RECEIVED" && action.envelope ? store.getState().conversation.some(
+      (e) => e.kind === "gate-prompt" && (e.envelope.gateId === action.envelope.gateId || e.queue.some((queued) => queued.gateId === action.envelope.gateId))
+    ) : !0, dispatched = originalStoreDispatch(action);
+    if (action && action.type === "GATE_PROMPT_RECEIVED" && action.envelope && !gateAlreadyShown) {
+      let described = typeof args.quorumLoop?.describeTasks == "function" ? args.quorumLoop.describeTasks() : [], advisory = endedTaskAdvisory(described, action.envelope.taskId);
+      advisory && originalStoreDispatch({ type: "SHELL_ADVISORY", source: "shell", text: advisory, localOnly: !0 });
+    }
+    return dispatched;
+  });
   let advisoryAttachmentJournal = advisoryAttachmentJournalFor(args);
   try {
     await advisoryAttachmentJournal.recoverDeadOwners();
@@ -64371,7 +65127,23 @@ async function runOrchestrationShell(args) {
       store.dispatch({ type: "SHELL_ADVISORY", source: "shell", text: message });
     }
   }) : void 0;
-  args.workspaceOutcomeTap && (args.workspaceOutcomeTap.sink = workspaceTerminalCoordinator), args.quorumLoop?.setWorkspaceOutcomeSink?.(workspaceTerminalCoordinator), plannerOfferE1Ledger.beginRun(
+  args.workspaceOutcomeTap && (args.workspaceOutcomeTap.sink = workspaceTerminalCoordinator), args.quorumLoop?.setWorkspaceOutcomeSink?.(workspaceTerminalCoordinator), args.quorumLoop?.setTaskOrdinalSink?.({
+    assign: (taskId, opts) => (store.dispatch({ type: "TASK_ORDINAL_ASSIGNED", taskId, kind: opts.kind, ...opts.retryOf ? { retryOf: opts.retryOf } : {} }), store.getState().taskOrdinals.get(taskId)?.ordinal),
+    label: (taskId) => taskLabel(store.getState(), taskId)
+  }), args.quorumLoop?.setApplyConflictSink?.((menu) => {
+    store.dispatch({ type: "APPLY_CONFLICT_PRESENTED", menu });
+  }), args.quorumLoop?.setRetryStartedSink?.((info) => {
+    store.dispatch({
+      type: "TASK_LIFECYCLE",
+      task: {
+        taskId: info.taskId,
+        agentKind: info.agent,
+        pid: 0,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "running"
+      }
+    });
+  }), plannerOfferE1Ledger.beginRun(
     (promptIds) => args.appsyncClient.refreshOpenPromptTtl(promptIds)
   );
   let unsubscribeWaitingUser = null;
@@ -64875,8 +65647,13 @@ async function runOrchestrationShell(args) {
       if (shellSubmissionsFenced) return;
       let fromMobile = options?.fromMobile === !0, convLenBefore = store.getState().conversation.length, userTurnTimestamp = (/* @__PURE__ */ new Date()).toISOString(), turnOwnership = { brainstormPanelOwned: !1 }, ownEntries = [];
       await turnAuthoringContext.run({ ownEntries }, async () => {
-        let handledByGate = !1;
-        if (fromMobile && findActiveGatePromptEntry(store.getState().conversation) && (mobileGateDecisionDeps === null ? (store.dispatch({
+        let handledByGate = !1, mobileAmbiguity = fromMobile ? mobileGateReplyAmbiguity(store.getState(), text2) : null;
+        if (mobileAmbiguity ? (store.dispatch({
+          type: "SHELL_ADVISORY",
+          source: "shell",
+          text: mobileAmbiguity,
+          handoffExcluded: !0
+        }), handledByGate = !0) : fromMobile && findActiveGatePromptEntry(store.getState().conversation, store.getState().activeGatePromptId) && (mobileGateDecisionDeps === null ? (store.dispatch({
           type: "SHELL_ADVISORY",
           source: "shell",
           text: "The desktop is still preparing the interactive prompt. Please send your choice again.",
@@ -65208,9 +65985,13 @@ async function runOrchestrationShell(args) {
       }
     }));
   }, onTerminalDecision = args.quorumLoop ? async (resolvedTaskId, postAction, expectedShadow, canonicalDecision, gateResolution) => {
-    let taskId = resolvedTaskId || args.quorumLoop?.activeTask;
-    if (!taskId) return;
-    let finalApprovalCancelled = postAction.kind === "final_approval_resolved" && postAction.decision.trim().toLowerCase() !== "approve", terminalAbort = postAction.kind === "abort_task";
+    if (!resolvedTaskId) {
+      logger.warn("[orchestration-shell] terminal decision without a task id \u2014 no shadow effect applied", {
+        kind: postAction.kind
+      });
+      return;
+    }
+    let taskId = resolvedTaskId, finalApprovalCancelled = postAction.kind === "final_approval_resolved" && postAction.decision.trim().toLowerCase() !== "approve", terminalAbort = postAction.kind === "abort_task";
     workspaceTerminalCoordinator?.hasTaskResolution(taskId) && (finalApprovalCancelled || terminalAbort) && await workspaceTerminalCoordinator.reserveTask(
       taskId,
       finalApprovalCancelled ? "CANCEL" : "ABORT"
@@ -65476,7 +66257,7 @@ async function runOrchestrationShell(args) {
           // Codex LOW). Only `handled:false` falls through to the planner.
           resolveGateInput: (text2) => routeGatePromptInput(
             gateDecisionDeps,
-            findActiveGatePromptEntry(store.getState().conversation),
+            findActiveGatePromptEntry(store.getState().conversation, store.getState().activeGatePromptId),
             text2
           ),
           signal: nonTtyAbort.signal
@@ -66013,11 +66794,11 @@ async function routeMobileUserPrompt(event, sessionKeyResolver, submit, updateEv
   }
 }
 async function routeMobileGatePromptInput(deps, text2) {
-  let before = findActiveGatePromptEntry(deps.store.getState().conversation);
+  let before = findActiveGatePromptEntry(deps.store.getState().conversation, deps.store.getState().activeGatePromptId);
   if (!before) return !1;
   let beforePhase = before.uiState.phase;
   if (!(await routeGatePromptInput(deps, before, text2)).handled) return !1;
-  let after = findActiveGatePromptEntry(deps.store.getState().conversation);
+  let after = findActiveGatePromptEntry(deps.store.getState().conversation, deps.store.getState().activeGatePromptId);
   return beforePhase === "awaiting-number" && after?.id === before.id && after.uiState.phase === "awaiting-notes" && deps.store.dispatch({
     type: "SHELL_ADVISORY",
     source: "shell",
@@ -66196,14 +66977,28 @@ function routeTeamShellEventToStore(store, evt) {
 }
 function parseTaskCommand(text2) {
   let rest = text2.trim().slice(5).trim();
-  if (rest.length === 0) return { agent: null, brief: "" };
+  if (rest.length === 0) return { agent: null, brief: "", focus: null, conflictChoice: null };
+  let focusMatch = /^focus\s+#?(\d{1,6})$/i.exec(rest);
+  if (focusMatch)
+    return { agent: null, brief: "", focus: Number.parseInt(focusMatch[1], 10), conflictChoice: null };
+  let conflictMatch = /^(retry|discard)\s+#?(\d{1,6})$/i.exec(rest);
+  if (conflictMatch)
+    return {
+      agent: null,
+      brief: "",
+      focus: null,
+      conflictChoice: {
+        choice: conflictMatch[1].toLowerCase() === "retry" ? 1 : 2,
+        ordinal: Number.parseInt(conflictMatch[2], 10)
+      }
+    };
   let tokens = rest.split(/\s+/), agent = null, startIdx = 0;
   if (tokens[0] === "--agent") {
     let value = (tokens[1] ?? "").toUpperCase();
     value === "CLAUDE" || value === "CODEX" || value === "ANTIGRAVITY" ? (agent = value, startIdx = 2) : startIdx = 1;
   }
   let brief = tokens.slice(startIdx).join(" ").trim();
-  return { agent, brief };
+  return { agent, brief, focus: null, conflictChoice: null };
 }
 function resolveEnvImplementorAgentOverride() {
   let raw = (process.env.CODEVIBE_IMPLEMENTOR_AGENT ?? "").trim().toUpperCase();
@@ -67000,10 +67795,10 @@ async function launchTeamFromWorkItems(deps) {
       });
       if (result.accepted && result.taskGroupId) {
         let gid = result.taskGroupId;
-        store.dispatch({ type: "TEAM_STARTED", taskGroupId: gid }), store.dispatch({
+        store.dispatch({ type: "TEAM_STARTED", taskGroupId: gid }), store.dispatch({ type: "TASK_ORDINAL_ASSIGNED", taskId: gid, kind: "group" }), store.dispatch({
           type: "SHELL_ADVISORY",
           source: "shell",
-          text: `Agent Teams group started (${gid}) \u2014 ${result.dispatchedTracks ?? workItems.length} tracks dispatched.`
+          text: `Task ${taskLabel(store.getState(), gid)} started \u2014 Agent Teams group (${gid}), ${result.dispatchedTracks ?? workItems.length} tracks dispatched.`
         });
         try {
           createShellEventEmitter(appsyncClient)({
@@ -67123,10 +67918,10 @@ async function dispatchSynthesizedSingleStartTask(deps) {
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         status: "running"
       }
-    }), note && store.dispatch({
+    }), store.dispatch({
       type: "SHELL_ADVISORY",
       source: "shell",
-      text: note
+      text: `Task ${taskLabel(store.getState(), result.taskId)} started with ${selectedAgent}.${note ? ` ${note}` : ""}`
     })) : store.dispatch({
       type: "SHELL_ADVISORY",
       source: "shell",
@@ -67769,6 +68564,12 @@ function buildContinuationActionDeps(args, store) {
   let loop = args.quorumLoop;
   return loop ? {
     getActiveRequestContext: () => loop.getActiveContinuationRequestContext(),
+    // P46a B1 (OQ-1) — when no single task resolves, say why: several tasks are
+    // running a round (list their `#n` so the user can `/task focus <n>`), or none.
+    explainNoActiveRequest: () => {
+      let resolved = loop.resolveContinuationRequest();
+      return resolved.kind === "ambiguous" ? "Several tasks are running \u2014 focus one first with `/task focus <n>`: " + resolved.candidates.map((id) => taskLabel(store.getState(), id)).join(", ") + "." : "No active task to hand off.";
+    },
     request: async (ctx, targetAgent) => loop.requestContinuation({
       taskId: ctx.taskId,
       gateId: ctx.gateId,
@@ -67779,8 +68580,8 @@ function buildContinuationActionDeps(args, store) {
       ...targetAgent ? { targetAgent } : {}
     }),
     getActiveOfferContext: () => {
-      let entry = findActiveGatePromptEntry(store.getState().conversation);
-      if (!entry || entry.envelope.promptKind !== CONTINUATION_OFFER_HANDOFF_PROMPT_KIND)
+      let entry = findActiveContinuationOfferEntry(store.getState().conversation);
+      if (!entry)
         return null;
       let offerId = entry.envelope.offerId;
       return typeof offerId != "string" || offerId.length === 0 ? null : {
@@ -68067,6 +68868,42 @@ function dispatchRefusalAdvisory(store, decision) {
 function isInteractiveTty() {
   return !!process.stdout.isTTY && process.env.CODEVIBE_NO_TUI !== "1";
 }
+async function resolveApplyConflict(deps) {
+  let { store, args, pending, choice, emit } = deps;
+  store.dispatch({ type: "CLEAR_PENDING_APPLY_CONFLICT", taskId: pending.taskId });
+  let echo = `\u2192 ${choice}. ${choice === 1 ? "Retry as a new task" : "Discard"}`;
+  emit === "advisory" && store.dispatch({ type: "SHELL_ADVISORY", source: "shell", text: echo, localOnly: !0 });
+  let result = choice === 1 ? await dispatchApplyConflictRetry({ store, quorumLoop: args.quorumLoop, menu: pending }) : `Discarded task ${pending.taskLabel} \u2014 your files are unchanged.`;
+  return emit === "advisory" && store.dispatch({ type: "SHELL_ADVISORY", source: "shell", text: result }), [result];
+}
+async function dispatchApplyConflictRetry(deps) {
+  let { store, quorumLoop, menu } = deps;
+  if (!quorumLoop)
+    return "Task start is unavailable in this session.";
+  try {
+    let result = await quorumLoop.startTask({
+      decision: { action: "start_task", rationale: `retry of task ${menu.taskLabel} after an apply conflict` },
+      brief: menu.retryBrief,
+      agent: menu.agent,
+      retryOf: menu.taskId,
+      request: menu.request
+    });
+    return result ? (store.dispatch({
+      type: "TASK_LIFECYCLE",
+      task: {
+        taskId: result.taskId,
+        agentKind: menu.agent,
+        pid: 0,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "running"
+      }
+    }), `Task ${taskLabel(store.getState(), result.taskId)} started with ${menu.agent} \u2014 the retry of task ${menu.taskLabel}.`) : `Couldn't start the retry of task ${menu.taskLabel} (the task START was rejected). Please re-issue the request.`;
+  } catch (err) {
+    return logger.warn("[orchestration-shell] apply-conflict retry dispatch failed (non-fatal)", {
+      error: err.message
+    }), `Couldn't start the retry of task ${menu.taskLabel}: ${err.message}`;
+  }
+}
 async function resolvePlannerOffer(deps) {
   let { store, args, emitShellEventBound, generator, ensureFreshContextStoreFn, offer, choice } = deps;
   await plannerOfferE1Ledger.resolveOffer(
@@ -68220,7 +69057,38 @@ async function handleShellUserInput(deps) {
     browseSignal = deps.browseSignal
   } = deps;
   if (text2.trim().length === 0) return;
-  let slashCommandText = text2.trimStart(), pendingOffer = store.getState().pendingPlannerOffer;
+  let slashCommandText = text2.trimStart(), pendingConflicts = [...store.getState().pendingApplyConflicts.values()];
+  if (pendingConflicts.length > 0 && deps.inputOrigin !== "mobile") {
+    let reply = text2.trim(), openLabels = pendingConflicts.map((m) => `task ${m.taskLabel}`).join(", "), conflictHint = () => {
+      store.dispatch({
+        type: "SHELL_ADVISORY",
+        source: "shell",
+        text: pendingConflicts.length === 1 ? `Reply 1 to retry task ${pendingConflicts[0].taskLabel} as a new task or 2 to discard it (or /task retry <n> / /task discard <n>); other text closes the menu.` : `Several apply-conflict menus are open (${openLabels}) \u2014 answer each with /task retry <n> or /task discard <n>; other text closes them.` + // Stage 1 r3 N2 — a pending suggestion's number is taken by the menus until they close.
+        (store.getState().pendingPlannerOffer ? " The pending suggestion can be answered by number once they are closed." : ""),
+        localOnly: !0
+      });
+    };
+    if (/^[0-9]$/.test(reply)) {
+      let choice = Number.parseInt(reply, 10);
+      if (pendingConflicts.length === 1 && (choice === 1 || choice === 2)) {
+        await resolveApplyConflict({ store, args, pending: pendingConflicts[0], choice, emit: "advisory" });
+        return;
+      }
+      conflictHint();
+      return;
+    }
+    if (/^[0-9]/.test(reply)) {
+      conflictHint();
+      return;
+    }
+    reply.startsWith("/") || (store.dispatch({ type: "CLEAR_PENDING_APPLY_CONFLICT" }), store.dispatch({
+      type: "SHELL_ADVISORY",
+      source: "shell",
+      text: pendingConflicts.length === 1 ? `Closed the apply-conflict menu for task ${pendingConflicts[0].taskLabel} \u2014 no retry was started; re-run the request if you still want that change.` : `Closed the apply-conflict menus for ${openLabels} \u2014 no retry was started; re-run the requests if you still want those changes.`,
+      localOnly: !0
+    }));
+  }
+  let pendingOffer = store.getState().pendingPlannerOffer;
   if (pendingOffer) {
     let interactionAdvisoryFlags = deps.inputOrigin === "mobile" ? { handoffExcluded: !0 } : { localOnly: !0 }, offerReply = text2.trim(), optionCount = pendingOffer.options.length, offerHint = () => {
       store.dispatch({
@@ -68466,7 +69334,12 @@ async function handleShellUserInput(deps) {
             kind: "gated",
             headline: AUDIT_BROWSER_MAX_HEADLINE,
             upgradeHint: AUDIT_BROWSER_UPGRADE_HINT
-          }) : renderSessionTaskList(store.getState(), args.quorumLoop?.activeTask ?? null);
+          }) : renderSessionTaskList(
+            store.getState(),
+            // P46a B1 — every live single task (not only "the latest") may
+            // still be inside its `startTask` without a lifecycle row.
+            typeof args.quorumLoop?.knownSingleTasks == "function" ? args.quorumLoop.knownSingleTasks() : args.quorumLoop?.activeTask ? [args.quorumLoop.activeTask] : []
+          );
         else
           try {
             let effectiveSessionId = explicitSessionId || args.session.sessionId, result = runAuditBrowserFn ? await runAuditBrowserFn(taskId, {
@@ -68555,14 +69428,33 @@ async function handleShellUserInput(deps) {
         }), output.output = "") : output.output = loaded.message;
       }
     else if (output.command === "/review-reset" && !output.sideEffect && output.output === "PENDING \u2014 entrypoint arms comprehensive review")
-      args.quorumLoop ? args.quorumLoop.requestReviewScopeReset() ? output.output = "The next revise round will start a fresh comprehensive review baseline." : output.output = "/review-reset requires an active task. Start a task before requesting a reset." : output.output = "/review-reset requires an orchestration session with a running loop (Pro/Max). It is unavailable in this session.";
+      if (!args.quorumLoop)
+        output.output = "/review-reset requires an orchestration session with a running loop (Pro/Max). It is unavailable in this session.";
+      else {
+        let reset = args.quorumLoop.requestReviewScopeReset();
+        reset.armed ? output.output = `Task ${taskLabel(store.getState(), reset.taskId)}: the next revise round will start a fresh comprehensive review baseline.` : reset.candidates.length > 0 ? output.output = "The focused task has no review round to reset. Tasks that do: " + reset.candidates.map((id) => taskLabel(store.getState(), id)).join(", ") + " \u2014 run `/task focus <n>` first." : output.output = "/review-reset requires an active task. Start a task before requesting a reset.";
+      }
     else if (output.command === "/task" && !output.sideEffect && output.output === "PENDING \u2014 entrypoint drives startTask")
       if (!args.quorumLoop)
         output.output = "/task requires an orchestration session with a running loop (Pro/Max). It is unavailable in this session.";
       else {
         let parsed = parseTaskCommand(slashCommandText);
-        if (!parsed.brief)
-          output.output = "Usage: /task [--agent claude|codex|antigravity] <implementation-request>. Pro/Max only; runs without planner classification.";
+        if (parsed.conflictChoice !== null) {
+          let { choice, ordinal } = parsed.conflictChoice, open15 = store.getState().pendingApplyConflicts, target = taskIdForOrdinal(store.getState(), ordinal), pending2 = target === null ? void 0 : open15.get(target);
+          if (deps.inputOrigin === "mobile")
+            output.output = "The apply-conflict menu is answered on the desktop (it is not mirrored to the phone yet).";
+          else if (pending2)
+            output.output = (await resolveApplyConflict({ store, args, pending: pending2, choice, emit: "collect" })).join(`
+`);
+          else {
+            let openLabels = [...open15.values()].map((m) => `task ${m.taskLabel}`).join(", ");
+            output.output = `No apply-conflict menu is open for task #${ordinal}.` + (open15.size > 0 ? ` Open: ${openLabels}.` : "");
+          }
+        } else if (parsed.focus !== null) {
+          let target = taskIdForOrdinal(store.getState(), parsed.focus);
+          target === null ? output.output = `No task #${parsed.focus} in this session. Run /status to list the tasks.` : args.quorumLoop.setFocusedTask(target) ? output.output = `Focused task ${taskLabel(store.getState(), target)}.` : output.output = `Task ${taskLabel(store.getState(), target)} is not a running single task (it has ended, or it is a team group).`;
+        } else if (!parsed.brief)
+          output.output = "Usage: /task [--agent claude|codex|antigravity] <implementation-request> | /task focus <n> | /task retry <n> | /task discard <n>. Pro/Max only; runs without planner classification.";
         else {
           let detected = typeof args.quorumLoop.getDetectedAgents == "function" ? args.quorumLoop.getDetectedAgents() : [], { agent, note } = selectImplementorAgent(detected, parsed.agent);
           try {
@@ -68582,16 +69474,21 @@ async function handleShellUserInput(deps) {
               agent,
               ...turnAttachments.length ? { attachments: turnAttachments } : {}
             });
-            result ? (store.dispatch({
-              type: "TASK_LIFECYCLE",
-              task: {
-                taskId: result.taskId,
-                agentKind: agent,
-                pid: 0,
-                startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-                status: "running"
-              }
-            }), output.output = note ? `Started task with ${agent}. ${note}` : `Started task with ${agent}.`) : output.output = "Could not start the task (no session key / START rejected). Check that you are signed in and try again.";
+            if (result) {
+              store.dispatch({
+                type: "TASK_LIFECYCLE",
+                task: {
+                  taskId: result.taskId,
+                  agentKind: agent,
+                  pid: 0,
+                  startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  status: "running"
+                }
+              });
+              let startedLabel = taskLabel(store.getState(), result.taskId);
+              output.output = note ? `Started task ${startedLabel} with ${agent}. ${note}` : `Started task ${startedLabel} with ${agent}.`;
+            } else
+              output.output = "Could not start the task (no session key / START rejected). Check that you are signed in and try again.";
           } catch (err) {
             output.output = `Failed to start task: ${err.message ?? String(err)}`, logger.warn("[orchestration-shell] /task dispatch failed", {
               error: err.message
@@ -68776,7 +69673,10 @@ async function handleShellUserInput(deps) {
   }, decision, showClassifySpinner = store.getState().progress === null;
   showClassifySpinner && store.dispatch({ type: "TASK_PROGRESS", event: { phase: "planner_classifying" } });
   try {
-    decision = await dispatchClassify(plannerInput), isLocalPlannerRuntime(args) && decision.action === "start_task" && plannerInput.clarifications.length === 0 && isDestructiveFileRequest(plannerInput.prompt) && (logger.warn(
+    decision = await dispatchClassify(plannerInput), isLocalPlannerRuntime(args) && decision.action === "browse" && hasFileMutationIntent(plannerInput.prompt) && (decision = {
+      action: "start_task",
+      rationale: decision.rationale ? `${decision.rationale} (promoted to start_task due to file mutation intent)` : "web request with file mutation intent"
+    }), isLocalPlannerRuntime(args) && decision.action === "start_task" && plannerInput.clarifications.length === 0 && isDestructiveFileRequest(plannerInput.prompt) && (logger.warn(
       "[orchestration-shell] P43 backstop: a destructive file request was classified start_task without a confirmation this turn; asking first",
       { rationale: decision.rationale }
     ), decision = {
@@ -69048,10 +69948,10 @@ async function handleShellUserInput(deps) {
           startedAt: (/* @__PURE__ */ new Date()).toISOString(),
           status: "running"
         }
-      }), note && store.dispatch({
+      }), store.dispatch({
         type: "SHELL_ADVISORY",
         source: "shell",
-        text: note
+        text: `Task ${taskLabel(store.getState(), result.taskId)} started with ${selectedAgent}.${note ? ` ${note}` : ""}`
       })) : store.dispatch({
         type: "SHELL_ADVISORY",
         source: "shell",
@@ -69589,17 +70489,20 @@ async function emitWithProvenNoWriteDowngrade(emitter, args) {
   let result = await emitter(args);
   !result.emitted && args.disableWriterAttestation !== !0 && (result.reason === "writer_ineligible" || result.reason === "definitive_rejection") && await emitter({ ...args, disableWriterAttestation: !0 });
 }
-function renderSessionTaskList(state, activeTaskId = null) {
+function renderSessionTaskList(state, liveTaskIds = []) {
   let tasks = [...state.sessionTasks.values()].sort(
     (a, b) => b.startedAt.localeCompare(a.startedAt)
-  ), activeUnlisted = activeTaskId !== null && !state.sessionTasks.has(activeTaskId) ? activeTaskId : null;
-  if (tasks.length === 0 && activeUnlisted === null)
+  ), unlisted = liveTaskIds.filter((id) => !state.sessionTasks.has(id));
+  if (tasks.length === 0 && unlisted.length === 0)
     return "No tasks have run in this session yet. Once a task runs, `/audit <task-id>` opens its full review history.";
   let lines = ["Tasks this session (newest first):"];
-  activeUnlisted !== null && lines.push(`  ${activeUnlisted} \u2014 task \xB7 running \xB7 starting`);
+  for (let id of [...unlisted].reverse()) {
+    let n = numberedLabel(state, id);
+    lines.push(`  ${id} \u2014 task${n ? ` ${n}` : ""} \xB7 running \xB7 starting`);
+  }
   for (let t of tasks)
     lines.push(
-      `  ${t.taskId} \u2014 ${t.agentKind ?? "team"} \xB7 ${t.status} \xB7 started ${t.startedAt}`
+      `  ${t.taskId} \u2014 ${numberedLabel(state, t.taskId) ? `${numberedLabel(state, t.taskId)} \xB7 ` : ""}${t.agentKind ?? "team"} \xB7 ${t.status} \xB7 started ${t.startedAt}`
     );
   return lines.push("Run `/audit <task-id>` to open a task\u2019s full review history."), lines.join(`
 `);
@@ -69615,7 +70518,20 @@ function parseIsoTimestamp(iso) {
   return Number.isFinite(t) ? t : 0;
 }
 function buildStatusSummary(state, quorumLoop) {
-  let lines = [];
+  let lines = [], described = typeof quorumLoop?.describeTasks == "function" ? quorumLoop.describeTasks() : [];
+  if (described.length > 0) {
+    let awaiting = /* @__PURE__ */ new Set();
+    for (let entry of state.conversation)
+      entry.kind === "gate-prompt" && !entry.final && awaiting.add(entry.envelope.taskId);
+    for (let taskId of state.pendingApplyConflicts.keys()) awaiting.add(taskId);
+    lines.push("Tasks this session:");
+    for (let t of described) {
+      let stateLabel = t.outcome === "running" ? awaiting.has(t.taskId) ? "awaiting you" : t.implementorActive ? "implementing" : "in review" : t.outcome === "applied" ? "done" : t.outcome === "apply_failed" ? awaiting.has(t.taskId) ? "apply failed \u2014 awaiting you" : "apply failed" : t.outcome === "unresolved" ? "apply failed \xB7 retained" : t.outcome === "rejected" ? "not started" : "discarded", retry = t.retryOf ? ` \xB7 retry of ${taskLabel(state, t.retryOf)}` : "";
+      lines.push(
+        `  ${t.label} \xB7 ${t.agent} \xB7 ${stateLabel}${retry} \xB7 ${truncate(sanitizeForTerminal(t.brief.replace(/\s+/g, " ").trim()), 60)}` + (t.focused ? " \u25C0 focused" : "")
+      );
+    }
+  }
   if (state.team) {
     let t = state.team, indices = [...t.tracks.keys()].sort((a, b) => a - b), n = indices.length, trackParts = indices.map((i) => {
       let e = t.tracks.get(i), details = [e.agent, e.taskId ? truncate(e.taskId, 12) : null].filter(
@@ -69630,21 +70546,27 @@ function buildStatusSummary(state, quorumLoop) {
     let teamLine = `Agent Teams group${groupRef} \u2014 ${n} ${n === 1 ? "track" : "tracks"} (MergeGate: ${MERGE_GATE_STATUS_LABEL[t.mergeGate]}${mergeElapsedStr})`;
     n > 0 && (teamLine += `: ${trackParts.join(", ")}`), teamLine += ".", t.groupResolved ? teamLine += t.outcome === "complete" ? " Team complete." : ` Team halted \u2014 ${t.outcome ?? t.haltReason ?? "unknown"}.` : t.haltReason && (teamLine += ` Halted: ${t.haltReason}.`), lines.push(teamLine);
   }
-  let hasRunning = hasRunningSingleTask(state), activeTask = quorumLoop?.activeTask ?? null, teamActive = state.team !== null && !state.team.groupResolved && state.team.haltReason === null, taskStarting = !hasRunning && !teamActive && activeTask !== null && !state.sessionTasks.has(activeTask);
+  let hasRunning = hasRunningSingleTask(state), startingTasks = (typeof quorumLoop?.knownSingleTasks == "function" ? quorumLoop.knownSingleTasks() : quorumLoop?.activeTask ? [quorumLoop.activeTask] : []).filter((id) => !state.sessionTasks.has(id)), activeTask = startingTasks.length > 0 ? startingTasks[startingTasks.length - 1] : null, teamActive = state.team !== null && !state.team.groupResolved && state.team.haltReason === null, taskStarting = !hasRunning && !teamActive && activeTask !== null;
   if (state.progress) {
     let startedAt = state.progress.startedAt, elapsed = !startedAt || isNaN(Date.parse(startedAt)) ? null : formatElapsed(Date.now() - Date.parse(startedAt)), tokens = state.progress.tokens, tokenStr = tokens && tokens > 0 ? ` \xB7 \u2193 ${formatTokens(tokens)}` : "";
     lines.push(
       `Current task: ${state.progress.text}${elapsed ? ` \xB7 ${elapsed}` : ""}${tokenStr}.`
     );
-  } else hasRunning ? lines.push("A task is running.") : taskStarting && lines.push(`A task is starting (${activeTask}).`);
+  } else hasRunning ? lines.push("A task is running.") : taskStarting && lines.push(
+    `A task is starting (${startingTasks.map((id) => numberedLabel(state, id) ? `${numberedLabel(state, id)} ${id}` : id).join(", ")}).`
+  );
   !state.progress && state.lastReviewerProgress && lines.push(`Reviewers: ${state.lastReviewerProgress.text}.`);
   for (let entry of state.conversation) {
     if (entry.kind !== "gate-prompt" || entry.final) continue;
     let label = GATE_PROMPT_KIND_LABEL[entry.envelope.promptKind] ?? entry.envelope.promptKind, queued = entry.queue.length > 0 ? `; ${entry.queue.length} more queued` : "";
     lines.push(
-      `Awaiting your decision: ${label} for task ${entry.envelope.taskId} \u2014 reply with an option number (1-${entry.envelope.options.length})${queued}.`
+      `Awaiting your decision: ${label} for task ${numberedLabel(state, entry.envelope.taskId) ? `${numberedLabel(state, entry.envelope.taskId)} (${entry.envelope.taskId})` : entry.envelope.taskId} \u2014 reply with an option number (1-${entry.envelope.options.length})${queued}.`
     );
   }
+  for (let menu of state.pendingApplyConflicts.values())
+    lines.push(
+      `Awaiting your decision: task ${menu.taskLabel} could not be applied \u2014 ` + (state.pendingApplyConflicts.size === 1 ? "reply 1 to retry as a new task or 2 to discard (or /task retry|discard <n>)." : `/task retry ${menu.taskLabel.replace(/^#/, "").split(" ")[0]} or /task discard ${menu.taskLabel.replace(/^#/, "").split(" ")[0]}.`)
+    );
   let rawOutcome = quorumLoop?.getLastWorkspaceOutcome() ?? null, outcome = null;
   if (rawOutcome !== null && !teamActive)
     if (rawOutcome.taskId) {
@@ -72365,6 +73287,14 @@ async function assertAuditOutsideWorkdir(auditPath, workdir) {
   return resolvedAuditPath;
 }
 async function engageSubstrate(input) {
+  if (input.webBrowsingActive)
+    return {
+      mode: "reduced_trust",
+      reducedTrust: !0,
+      reducedTrustReason: `Agent web browsing active for ${input.agentKind} \u2014 running in reduced-trust mode with shadow-diff capture and guarded web tools`,
+      teardown: async () => {
+      }
+    };
   let provider = providerForAgent(input.agentKind);
   if (provider === null)
     return input.requireConfined ? engageWriteConfinedResolverSandbox(input) : {
@@ -74831,14 +75761,10 @@ function buildAndArmQuorumLoop(args) {
     // manifest BEFORE the tree mutates (the C1 capture is already gated on
     // `this.deps.durableStore` inside `promoteShadowLocked`).
     ...args.durableStore ? { durableStore: args.durableStore } : {},
-    // CP-7 Stage-2 r3 (Codex) HIGH — ARM the LE's current/authorized task id at
-    // start_task so the round-0 implementor spawn engages the CP-7 substrate
-    // (sandbox + creditless badge) instead of the pre-TaskAuthorized
-    // reduced-trust path (local-executor-impl.ts:566). Rolled back on a START
-    // rejection by the loop. This is the SAME `taskId` state TaskAuthorized later
-    // advances; arming it early closes the round-0 window where the implementor
-    // would otherwise spawn unbadged/unsandboxed.
-    armLeTaskId: (taskId) => localExecutor.setActiveTaskId(taskId),
+    // P46a B2 — the executor keeps no singleton task id any more (the CP-7
+    // `armLeTaskId` arming is gone): every implementor spawn carries its own
+    // `taskId`, which engages the CP-7 substrate and resolves the per-task
+    // authority scope, single tasks included.
     // CP-7 §8 (Stage-1-resolved) — wire the REVIEWER substrate engager so each
     // Trusted-agent reviewer seat runs INSIDE the CP-7 sandbox + broker (no
     // ambient vendor creds; model call via the loopback broker), exactly like
@@ -74904,6 +75830,7 @@ async function buildQuorumLoopExecutor(args) {
     userContextFn: async () => ""
   }, localExecutor = new LocalExecutorImpl({
     sessionId: session.sessionId,
+    logger,
     // CP-1.f Hybrid authority split (mirrors the team LE) — the DESKTOP seeds
     // the implementor command allowlist so `enforceCommand` permits the spawn;
     // write/read/network stay empty (the engine authorizes PATH scopes via a
@@ -75145,6 +76072,7 @@ async function buildTeamLocalExecutor(args) {
     userContextFn: async () => ""
   }, localExecutor = new LocalExecutorImpl({
     sessionId: session.sessionId,
+    logger,
     initialScope,
     baseCtx: {
       sessionId: session.sessionId,