@quantiya/codevibe-claude-plugin 2.0.42 → 2.0.43

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/components/InputBar.d.ts

@@ -84,6 +84,7 @@ export declare function computeInputWindow(display: string, caretCol: number, va
 export type GatePromptMode = {
     kind: 'awaiting-number';
     maxOption: number;
+    taskLabel?: string;
 } | {
     kind: 'awaiting-notes';
     decisionDraft: string;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/gate-decision-submit.d.ts

@@ -89,13 +89,34 @@ type GatePromptEntry = Extract<ConversationEntry, {
     kind: 'gate-prompt';
 }>;
 /**
- * §5.1 + #C8M-11 active-gate-prompt scan. Tail-to-head walk for the first
- * `kind:'gate-prompt'` entry with `final === false`. Pure; safe to call from a
+ * §5.1 + #C8M-11 active-gate-prompt scan: the OLDEST `kind:'gate-prompt'`
+ * entry with `final === false` (head-to-tail). Pure; safe to call from a
  * render path. Returns the entry verbatim so callers can pattern-match the
- * discriminated union directly. (Shared so the TTY component + non-TTY loop use
- * the identical scan.)
+ * discriminated union directly. (Shared so the TTY component, the mobile
+ * reply route and the non-TTY loop use the identical scan.)
+ *
+ * P46a (F-P46a-5): this used to be tail-to-head (the NEWEST open gate). With
+ * several tasks in flight, gates arrive in bursts, and the newest-wins rule
+ * moved the target under the user's fingers — the composer read `Task #2`,
+ * a gate for `#3` arrived, and the `1` that was typed for #2 approved #3
+ * (E2E r3 q1). Oldest-first keeps the active gate — its pinned card, the
+ * composer label `Type a number 1..N · Task #n`, and the gate a digit
+ * resolves — stable until the user answers it; newer gates wait their turn.
+ *
+ * Stage 1 r1 F2(b): an older open gate that is NOT answerable — stuck in
+ * `confirming` / `submitting` (the F-P46a-1 wedge) or `claimed` elsewhere —
+ * must not block every newer gate: the active gate is the oldest open gate in
+ * an ANSWERABLE phase (`awaiting-number` / `awaiting-notes`); when no open gate
+ * is answerable, the oldest open one (so the UI still shows its state).
+ *
+ * Stage 1 r2 F1: that choice is STICKY. Callers holding the store state pass
+ * `state.activeGatePromptId` (reducer-owned, see `normalizeActiveGatePrompt`):
+ * while that entry is open it stays the active gate, so an older gate whose
+ * submit rolled back to `awaiting-number` never takes the digits (or a
+ * half-typed note) back from the gate the user is answering. Without an id the
+ * scan above applies (pure callers and tests).
  */
-export declare function findActiveGatePromptEntry(conversation: ReadonlyArray<ConversationEntry>): GatePromptEntry | null;
+export declare function findActiveGatePromptEntry(conversation: ReadonlyArray<ConversationEntry>, activeGatePromptId?: string | null): GatePromptEntry | null;
 /**
  * Submit a gate decision: dispatch SUBMIT_STARTED, fire the SDK, dispatch
  * RESOLVED on success (and notify `onTerminalDecision`) or SUBMIT_FAILED on

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/index.d.ts

@@ -48,6 +48,23 @@ import { contextItemOccurrence, type ContextDurabilityReceipt } from './context-
 import { renderRehydratedSessionContext } from './context-compaction';
 import type { AgentKind as LocalExecutorAgentKind } from '../local-executor/types';
 import { type TaskProgressEvent } from './task-progress';
+import { taskLabel } from './task-label';
+/**
+ * P46a (Stage 1 r1 F2a) — the oldest unresolved continuation-offer gate
+ * prompt, whatever other gates are open. Pure.
+ */
+export declare function findActiveContinuationOfferEntry(conversation: ReadonlyArray<ConversationEntry>): (ConversationEntry & {
+    kind: 'gate-prompt';
+}) | null;
+/**
+ * P46a (Stage 1 r1 F2c) — a typed digit from the phone cannot choose between
+ * several open review gates (the phone shows no task label until P46b): the
+ * advisory to send back instead of answering the oldest gate, or null when the
+ * reply is not a bare digit or at most one gate is answerable. Pure.
+ */
+export declare function mobileGateReplyAmbiguity(state: Parameters<typeof taskLabel>[0] & {
+    conversation: ReadonlyArray<ConversationEntry>;
+}, text: string): string | null;
 export declare class OrchestrationShellStartupError extends Error {
     readonly cause?: unknown;
     constructor(message: string, cause?: unknown);

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/non-tty-fallback.d.ts

@@ -48,7 +48,7 @@ export declare function plannerDecisionRenderEnabled(env?: NodeJS.ProcessEnv): b
  * Renders a single `ConversationEntry` as a line-prefixed text string.
  * Strict text only — no ANSI escapes, no colors, no `\r` rewrites.
  */
-export declare function renderEntryAsLine(entry: ConversationEntry): string;
+export declare function renderEntryAsLine(entry: ConversationEntry, labelFor?: (taskId: string) => string | undefined): string;
 /**
  * Subscribes to the store and prints new conversation entries as
  * line-prefixed text. Returns a promise that resolves on `EXIT` action

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/quorum-loop.d.ts

@@ -325,19 +325,6 @@ export interface QuorumLoopDeps {
      * unset (see {@link resolveTeamExecution}).
      */
     teamExecution?: TeamExecution;
-    /**
-     * CP-7 Stage-2 r3 (Codex) HIGH — ARM the LE's current/authorized task id so
-     * the round-0 (and revise) implementor spawn engages the CP-7 trusted-execution
-     * substrate instead of the pre-TaskAuthorized reduced-trust path. `startTask`
-     * threads the minted taskId here BEFORE the round-0 spawn drains (and rolls it
-     * back to `null` on a START rejection); production wires it to
-     * `LocalExecutorImpl.setActiveTaskId`. ABSENT (legacy/tests) → the LE's task id
-     * is unchanged (the pre-fix behavior); production MUST wire it so the
-     * implementor never spawns unbadged/unsandboxed. The same state
-     * (`LocalExecutorImpl.taskId`) drives `engageSubstrateForSpawn` (local-executor-
-     * impl.ts:566) to call `substrateEngager` rather than emit a `tier:'none'` badge.
-     */
-    armLeTaskId?: (taskId: string | null) => void;
     /**
      * CP-7 §8 (Stage-1-resolved) — engage the CP-7 trusted-execution substrate +
      * broker for ONE reviewer seat. When wired (production via cli.ts →
@@ -599,12 +586,59 @@ interface TeamRunAuthority {
  * here closes packet-order races without extending or weakening the wire.
  */
 export declare function teamRound0GateId(taskId: string, taskGroupId: string, trackIndex: number, dispatchGeneration: number): string;
+/**
+ * P46a D1 — the reducer-owned in-session task numbering, reachable from the
+ * loop through this sink (installed by the shell after the store exists).
+ * `assign` returns the number the store assigned (undefined when unwired);
+ * `label` renders `#n` / `#n retry` / the short-id fallback for any task id.
+ */
+export interface TaskOrdinalSink {
+    assign(taskId: string, opts: {
+        kind: 'single' | 'group';
+        retryOf?: string;
+    }): number | undefined;
+    label(taskId: string): string;
+}
+/** P46a C3 — the desktop-local "could not apply" menu the loop asks the shell to present. */
+export interface ApplyConflictMenu {
+    taskId: string;
+    taskLabel: string;
+    conflicts: Array<{
+        path: string;
+        cause: 'session-task' | 'external' | 'write-error';
+        byTaskLabel?: string;
+    }>;
+    autoRetried: boolean;
+    retryBrief: string;
+    /** The ROOT user request (Stage 1 r3 F1) — the menu's retry carries it (web-access decision, `/status`). */
+    request: string;
+    agent: AgentKind;
+}
 export declare class QuorumLoop {
     private readonly deps;
     private readonly sleep;
     private workspaceOutcomeSink?;
-    /** The active task this desktop is driving (set at start_task). */
-    private activeTaskId;
+    /**
+     * 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".
+     */
+    private focusedTaskId;
+    /** P46a B1 — confirmed single tasks in START-confirmation order (focus fallback). */
+    private readonly 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.
+     */
+    private latestInFlightStart;
+    /** Stage 1 r1 F13 — every START still in flight, in issue order; `latestInFlightStart` is its last entry. */
+    private readonly startOrderInFlight;
     /** Tasks whose next automatic revise round must start a fresh review baseline. */
     private readonly reviewScopeResetTasks;
     /** Non-terminal tasks for which `/review-reset` may arm the next revise round. */
@@ -613,16 +647,9 @@ export declare class QuorumLoop {
     private readonly epochByTaskId;
     private readonly tokensByTaskId;
     private readonly tokensCountedGates;
-    /**
-     * 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).
-     */
-    private activeBrief;
     /**
      * 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,
@@ -677,20 +704,50 @@ export declare class QuorumLoop {
     private readonly recoveredBriefsByAuthority;
     private readonly activeBriefByTask;
     /**
-     * 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).
      */
     private readonly singleTaskContextByTask;
+    /** Agent web browsing (upstream 2.0.37) — whether a task's ORIGINAL request needs web access; ends with the task (`forgetSingleTask`, team cleanup). */
     private readonly webAccessByTask;
+    /**
+     * 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).
+     */
+    private readonly singleTaskHistory;
+    /**
+     * 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`.
+     */
+    private readonly promotedByPath;
+    /** P46a C2 — originals whose ONE automatic retry has been issued (never a second). */
+    private readonly autoRetryIssuedFor;
+    /**
+     * 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`.
+     */
+    private readonly pendingPromoteRetries;
+    /** P46a D1 — the store-owned ordinal sink (installed by the shell after construction). */
+    private taskOrdinalSink?;
+    /** P46a C3 — the desktop-local apply-conflict menu sink (installed by the shell). */
+    private applyConflictSink?;
+    /** P46a C2 — notified when an automatic retry task started (the shell records its lifecycle row). */
+    private retryStartedSink?;
     /**
      * 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.
@@ -1245,10 +1302,67 @@ export declare class QuorumLoop {
     setWorkspaceOutcomeSink(sink: WorkspaceOutcomeSink | undefined): void;
     isWorkspaceTaskTerminallyRetired(taskId: string): boolean;
     isTaskTerminallyRetired(taskId: string): boolean;
-    /** 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(): string | null;
-    /** Arm an explicit, one-shot comprehensive baseline for the active task. */
-    requestReviewScopeReset(): boolean;
+    /** P46a B1 — every LIVE single task this loop started (in flight or confirmed). */
+    knownSingleTasks(): string[];
+    /**
+     * 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: string): boolean;
+    /** P46a D1 — install the store-owned ordinal sink (the shell, after construction). */
+    setTaskOrdinalSink(sink: TaskOrdinalSink | undefined): void;
+    /** P46a C3 — install the desktop-local apply-conflict menu sink. */
+    setApplyConflictSink(sink: ((menu: ApplyConflictMenu) => void) | undefined): void;
+    /** P46a C2 — install the retry-started notifier (the shell records the lifecycle row). */
+    setRetryStartedSink(sink: ((info: {
+        taskId: string;
+        retryOf: string;
+        agent: AgentKind;
+    }) => void) | undefined): void;
+    /** P46a D1 — `#n` / `#n retry` / short id for any task id (never throws). */
+    labelFor(taskId: string): string;
+    /**
+     * 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(): Array<{
+        taskId: string;
+        label: string;
+        agent: AgentKind;
+        brief: string;
+        retryOf?: string;
+        outcome: 'running' | 'applied' | 'discarded' | 'apply_failed' | 'unresolved' | 'rejected';
+        implementorActive: boolean;
+        focused: boolean;
+    }>;
+    /** Stage 1 r1 F13 — a START confirmed or rejected: the newest START still in flight (if any) becomes the empty-envelope target. */
+    private dropInFlightStart;
+    /**
+     * 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).
+     */
+    private forgetSingleTask;
+    /**
+     * 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(): {
+        armed: true;
+        taskId: string;
+    } | {
+        armed: false;
+        candidates: string[];
+    };
     /**
      * Audited-path fix (Fix 5) — the host's detected implementor agents
      * (UPPERCASE `AgentKind`), as threaded into the loop at construction. Used by
@@ -1369,6 +1483,16 @@ export declare class QuorumLoop {
         agent: AgentKind;
         /** IMAGE-ATTACHMENT-DESIGN.md §5 — task-scoped image attachments, armed before the drain. */
         attachments?: ImageAttachment[];
+        /** P46a C2/C3 — the `apply_failed` original this task retries (renders `#n retry`). */
+        retryOf?: string;
+        /**
+         * P46a C2/C3 (Stage 1 r3 F1) — the ROOT user request a retry carries. A
+         * retry's `brief` is the COMPOSED retry brief (diffs + reviewed contents that
+         * can hold any text — URLs included); decisions that must follow the user's
+         * own words (the agent-web access decision, the next retry brief, `/status`)
+         * read this instead. Omitted for an ordinary task (its brief IS the request).
+         */
+        request?: string;
     }): Promise<{
         taskId: string;
     } | null>;
@@ -1821,6 +1945,27 @@ export declare class QuorumLoop {
      * half-applied tree.
      */
     promoteShadow(taskId: string): Promise<void>;
+    /** P46a C2 — start every planned automatic retry as a new linked task. */
+    private drainPromoteRetries;
+    /** P46a D2 — correct a task's recorded outcome after its terminal cleanup ran. */
+    private markTaskOutcome;
+    /**
+     * 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`.
+     */
+    private attributeConflicts;
+    /**
+     * 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.
+     */
+    private buildRetryBrief;
     /**
      * CP-12 W2.b (§3.C.2b (d) / H3-4) — promote-quiescence BARRIER for `taskId`.
      * Enqueues an EMPTY critical section behind any in-flight shadow lifecycle op
@@ -2143,9 +2288,12 @@ export declare class QuorumLoop {
     private submitVerdict;
     /**
      * 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.
      */
     recoverInReviewAssignments(): Promise<void>;
     /**
@@ -2333,17 +2481,37 @@ export declare class QuorumLoop {
      */
     private reconstructRound0GateDispatch;
     private handleReviseFeedback;
-    /** The implementor agent the loop spawns (set at start_task). */
-    private activeImplementorAgent;
-    setActiveImplementorAgent(agent: AgentKind): void;
     /**
-     * #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.
+     * 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.
+     */
+    private setTaskImplementorAgent;
+    /**
+     * #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.
      */
+    resolveContinuationRequest(): {
+        kind: 'ok';
+        ctx: {
+            taskId: string;
+            gateId: string;
+            roundNumber: number;
+            brief: string;
+            sourceAgent: AgentKind;
+        };
+    } | {
+        kind: 'ambiguous';
+        candidates: string[];
+    } | {
+        kind: 'none';
+    };
+    /** The `ok` projection of {@link resolveContinuationRequest} (null otherwise). */
     getActiveContinuationRequestContext(): {
         taskId: string;
         gateId: string;
@@ -2605,8 +2773,12 @@ export declare class QuorumLoop {
     get _runningSeatsForTests(): ReadonlySet<string>;
     /** @internal — test introspection. */
     get _submittedSeatsForTests(): ReadonlySet<string>;
-    /** @internal — test seam to set the active task without start_task. */
-    _setActiveTaskForTests(taskId: string, brief?: string): void;
+    /**
+     * @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: string, brief?: string, agent?: AgentKind, gateIds?: string[]): void;
     /** @internal — read a task's accumulated binding user notes. */
     _userNotesForTests(taskId: string): readonly string[];
     /** @internal — A1b: read a task's accumulated structured findings history. */

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/reducer.d.ts

@@ -14,3 +14,10 @@ export declare function reducer(state: OrchestrationState, action: Orchestration
  * task-start size heuristic.
  */
 export declare function hasRunningSingleTask(state: OrchestrationState): boolean;
+/**
+ * P46a C3 — the apply-conflict menu's reply hint. A digit answers it only while
+ * no review gate is awaiting a number (the gate composer takes digits first);
+ * `/task retry <n>` / `/task discard <n>` answer it unambiguously at any time.
+ * Slash commands keep the menu open; any other text closes it (Stage 1 r1 F3).
+ */
+export declare const 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.";

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/slash-routes/continuation.d.ts

@@ -52,6 +52,11 @@ export interface ContinuationCliDeps {
     } | null>;
     /** Resolve the active-task request context (loop state). `null` if no active task. */
     getActiveRequestContext?: () => ActiveContinuationRequestContext | null;
+    /**
+     * P46a B1 — the refusal text when `getActiveRequestContext` is null (several
+     * tasks running a round → the `#n` candidates; none → the plain message).
+     */
+    explainNoActiveRequest?: () => string;
     /**
      * PHASE-CP-10-MIN (#585) #C10M-9/11 — `/continue accept <target>`: the
      * rescue/headless path. The entrypoint wires this to call

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/task-label.d.ts

@@ -0,0 +1,25 @@
+import type { OrchestrationState } from './types';
+export declare function shortTaskId(taskId: string): string;
+/**
+ * The label for `taskId` (a single task id, a team child task id, a
+ * `taskGroupId`, or a `group:<id>` gate id).
+ */
+export declare function taskLabel(state: Pick<OrchestrationState, 'taskOrdinals' | 'team'>, taskId: string): string;
+/**
+ * Resolve `#n` / `n` (a single task or a team group number) back to the id
+ * that holds it, or null. Used by `/task focus <n>`.
+ */
+export declare function taskIdForOrdinal(state: Pick<OrchestrationState, 'taskOrdinals'>, ordinal: number): string | null;
+/**
+ * P46a (F-P46a-6) — the advisory the shell prints under a gate prompt whose
+ * task already ENDED on this side as `discarded` (its implementor round failed
+ * here — typically the result's submit lost its response in a network cut —
+ * while the engine still had the result, reviewed it and raised the gate).
+ * Accepting such a gate applies nothing; the user must know before deciding.
+ * Returns null for a live task or any other outcome.
+ */
+export declare function endedTaskAdvisory(described: ReadonlyArray<{
+    taskId: string;
+    label: string;
+    outcome: string;
+}>, taskId: string): string | null;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/types.d.ts

@@ -427,6 +427,7 @@ export type ConversationEntry = {
     panel: {
         variant: 'prompt';
         envelope: GatePromptEnvelope;
+        taskLabel?: string;
     } | {
         variant: 'summary';
         reviewSummary: ReviewSummaryPanelModel;
@@ -522,6 +523,51 @@ export interface PendingPlannerOffer {
     /** §13 Option-2 — ordered-with-dups carried paths for the number-based chip rewrite. */
     attachmentPaths?: string[];
 }
+/**
+ * P46a D1 — one in-session task number. Assigned by the reducer from ONE
+ * per-session counter (`nextTaskOrdinal`) at the START-confirmed point of a
+ * single task (`QuorumLoop.startTask`) or when `createTaskGroup` returns for a
+ * team (`launchTeamFromWorkItems`), so both paths share the numbering. A team
+ * group is one number (its child tasks render `#n.1`, `#n.2` via `state.team`).
+ * `retryOf` links a `#n retry` task (P46a C2/C3) to the `apply_failed` original.
+ * In-memory only: production has no session resume (design §2.4/A8), so every
+ * launch is a new session with its own numbering; nothing is persisted.
+ */
+export interface TaskOrdinalRecord {
+    readonly ordinal: number;
+    readonly kind: 'single' | 'group';
+    readonly retryOf?: string;
+}
+/**
+ * P46a C3 — the desktop-local "could not apply" menu. Modeled on
+ * `pendingPlannerOffer` (a local numbered reply resolves it; free text clears
+ * it) but NEVER mirrored to mobile — the durable, mobile-answerable form is
+ * P46b A5 (HD-10). Not durable: a desktop relaunch drops it with its session
+ * (the failed task's shadow is already discarded; the durable `apply_failed`
+ * outcome stands).
+ */
+export interface PendingApplyConflict {
+    /** The `apply_failed` task the menu is about. */
+    readonly taskId: string;
+    /** Its rendered label (`#n`, `#n retry`, or the short-id fallback). */
+    readonly taskLabel: string;
+    /** Workspace-relative paths + their attribution (paths only — never content). */
+    readonly conflicts: ReadonlyArray<{
+        readonly path: string;
+        readonly cause: 'session-task' | 'external' | 'write-error';
+        /** Rendered label of the session task whose promote changed the path. */
+        readonly byTaskLabel?: string;
+    }>;
+    /** True when this menu follows the one automatic retry's own promote failure. */
+    readonly autoRetried: boolean;
+    /** The `advisory` conversation entry that rendered the numbered options. */
+    readonly conversationEntryId: string;
+    /** The composed retry brief (original request + files changed since + reviewed contents). */
+    readonly retryBrief: string;
+    /** The ROOT user request the retry carries (Stage 1 r3 F1: web access and `/status` follow the user's own words). */
+    readonly request: string;
+    readonly agent: AgentKind;
+}
 /**
  * [ADDITIVE WIDENING — CP-12 W3, per PHASE-CP-12-DESIGN.md §3.5 "minimal
  * multi-track status node; rich UX is #469"]. Per-track lifecycle state as the
@@ -679,6 +725,32 @@ export interface OrchestrationState {
      * source of truth.
      */
     pendingPlannerOffer: PendingPlannerOffer | null;
+    /**
+     * `[ADDITIVE WIDENING — P46a D1]` The in-session task numbers, keyed by
+     * single-task id or team `taskGroupId`. Reducer-owned (`TASK_ORDINAL_ASSIGNED`)
+     * from the single per-session `nextTaskOrdinal` counter; never persisted.
+     */
+    taskOrdinals: Map<string, TaskOrdinalRecord>;
+    /** `[ADDITIVE WIDENING — P46a D1]` The next number to assign (starts at 1). */
+    nextTaskOrdinal: number;
+    /**
+     * `[ADDITIVE WIDENING — P46a C3]` The OPEN desktop-local apply-conflict menus,
+     * keyed by the failed task's id, in presentation order (empty by default).
+     * Set by `APPLY_CONFLICT_PRESENTED` (a second task's menu never replaces the
+     * first — Stage 1 r2 F2); `/task retry|discard <n>` answers one by number, a
+     * bare digit only when exactly one is open; other desktop text closes them
+     * (`CLEAR_PENDING_APPLY_CONFLICT`). Never mirrored to mobile (P46b A5).
+     */
+    pendingApplyConflicts: ReadonlyMap<string, PendingApplyConflict>;
+    /**
+     * `[ADDITIVE WIDENING — P46a D1]` The gate-prompt entry the desktop composer,
+     * its pinned card and a typed digit currently target (null when no open gate
+     * is answerable). Reducer-owned and STICKY (Stage 1 r2 F1): it stays on the
+     * current gate while that gate is answerable; only when it leaves the
+     * answerable phases does the oldest answerable open gate take over — a
+     * rolled-back older gate waits its turn instead of taking the digits back.
+     */
+    activeGatePromptId: string | null;
     inputHistory: string[];
     /**
      * `[ADDITIVE WIDENING — CP-1.d]` per `PHASE-CP-1-D-DESIGN.md` §4.8
@@ -884,6 +956,17 @@ export type OrchestrationAction = {
     offer: PendingPlannerOffer;
 } | {
     type: 'CLEAR_PENDING_PLANNER_OFFER';
+} | {
+    type: 'TASK_ORDINAL_ASSIGNED';
+    taskId: string;
+    kind: 'single' | 'group';
+    retryOf?: string;
+} | {
+    type: 'APPLY_CONFLICT_PRESENTED';
+    menu: Omit<PendingApplyConflict, 'conversationEntryId'>;
+} | {
+    type: 'CLEAR_PENDING_APPLY_CONFLICT';
+    taskId?: string;
 } | {
     type: 'STRUCTURAL_SUMMARY_GENERATED';
     summary: StructuralSummary;

package/node_modules/@quantiya/codevibe-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.37",
+  "version": "2.0.38",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-claude-plugin",
-  "version": "2.0.42",
+  "version": "2.0.43",
   "description": "Control Claude Code from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
@@ -48,7 +48,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^2.0.37",
+    "@quantiya/codevibe-core": "^2.0.38",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",