@quantiya/codevibe-claude-plugin 2.0.42 → 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,
@@ -26444,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,
@@ -31786,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
@@ -32369,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",
@@ -38624,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;
@@ -47534,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).
@@ -47578,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
       });
@@ -47606,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({
@@ -47615,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({
@@ -47707,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;
@@ -47728,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
@@ -47788,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(
@@ -47803,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
@@ -47821,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.
@@ -47924,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(
@@ -48075,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);
@@ -48128,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"),
@@ -49531,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
     };
   }
   /**
@@ -49661,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() {
@@ -49685,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
     };
   }
@@ -52101,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();
@@ -53976,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: `
@@ -57014,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. */
@@ -57041,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,
@@ -57105,20 +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.
@@ -57581,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() {
@@ -58171,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;
+  }
+  /** 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;
   }
-  /** Arm an explicit, one-shot comprehensive baseline for the active task. */
+  /** 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
@@ -58359,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",
@@ -58368,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({
@@ -58381,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.webAccessByTask.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 ────────────────
@@ -58428,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));
@@ -58446,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,
@@ -58458,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) {
@@ -59023,7 +59401,8 @@ ${section}`);
         ...args.teamAuthority ? { teamAuthority: args.teamAuthority } : {}
       }, needsWeb = this.webAccessByTask.get(args.taskId);
       if (needsWeb === void 0) {
-        let originalPrompt = this.singleTaskContextByTask.get(args.taskId)?.brief ?? this.activeBriefByTask.get(args.taskId)?.brief ?? (args.roundNumber === 0 ? args.brief : this.activeBrief ?? "");
+        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"))
@@ -59057,12 +59436,11 @@ ${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,
@@ -60365,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.webAccessByTask.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",
@@ -60411,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`.
@@ -60434,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;
@@ -60446,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.webAccessByTask.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;
       }
@@ -60698,7 +61204,8 @@ ${section}`);
           shadow,
           diff,
           terminalOutcomeReserved,
-          historySnapshot
+          historySnapshot,
+          retryContext
         );
       } finally {
         this.emitProgress({ phase: "progress_cleared" }, originEpoch);
@@ -60716,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,
@@ -60736,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", {
@@ -60769,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", {
@@ -61021,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"));
     }
@@ -61306,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,
@@ -61871,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 ──────
   /**
@@ -61936,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(
@@ -62821,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",
@@ -62831,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,
@@ -62866,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 } : {},
@@ -62882,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
@@ -63192,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,
@@ -63319,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);
@@ -63480,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) {
@@ -64331,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;
@@ -64433,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();
@@ -64455,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;
@@ -64959,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.",
@@ -65292,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"
@@ -65560,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
@@ -66097,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",
@@ -66280,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();
@@ -67084,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)({
@@ -67207,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",
@@ -67853,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,
@@ -67863,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 : {
@@ -68151,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(
@@ -68304,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({
@@ -68550,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, {
@@ -68639,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 {
@@ -68666,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
@@ -69135,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",
@@ -69676,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(`
 `);
@@ -69702,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(
@@ -69717,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) {
@@ -74926,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