@quantiya/codevibe-claude-plugin 2.0.44 → 2.0.46

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

@@ -2,6 +2,10 @@ import * as React from 'react';
 import { LiveProgress } from '../types';
 export interface LiveProgressLineProps {
     progress: LiveProgress | null;
+    /** P46b §3.7 — the task's label (`#2`) when several task lines render. */
+    label?: string;
+    /** P46b §3.7 — how many more busy tasks are not shown (last line only). */
+    moreCount?: number;
     /** Test seam; otherwise derived from the live terminal width, then 80 (mirrors StatusBar). */
     columns?: number;
 }

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

@@ -4,6 +4,19 @@ import { ConversationEntry, PostDecisionAction, Tier } from '../types';
 import type { PlannerRuntimeKind } from '../status-format';
 import type { UpdateReviewerPolicyInput, UserReviewerPolicySnapshot } from '../../types/reviewer';
 import { type ApplyUserDecisionClient as SharedApplyUserDecisionClient, type GroupDecisionSubmitDeps } from '../gate-decision-submit';
+/**
+ * Stable empty list passed to <InputBar> to SUPPRESS slash autocomplete unless
+ * it fits (Stage-1 MEDIUM + Stage-2 — #469): the dropdown lives in the live
+ * region below the input, so an open dropdown while the live region is tall
+ * could push total output over the terminal height and re-trigger Ink's
+ * whole-scrollback reprint. P46b §3.7 — the dropdown is offered while tasks run
+ * (progress lines no longer suppress it); a pinned gate-prompt card or the
+ * reviewer wizard still does, and while it can be open we reserve
+ * DROPDOWN_MAX_ROWS plus every progress line beyond the first in the height cap
+ * (below) so it always fits. Module-scope constant → stable identity.
+ */
+/** P46b §3.7 — at most this many per-task progress lines render (`+n more` after). */
+export declare const MAX_TASK_PROGRESS_LINES = 3;
 /**
  * Minimal SDK contract for the applyUserDecision wire. Structurally
  * compatible with the full `AppSyncClient.applyUserDecision` signature

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

@@ -127,11 +127,9 @@ export interface SessionCompactionCache {
     sessionId: string;
     /**
      * High-watermark `seq` — every item with `seq <= compactedThroughSeq` is
-     * covered by `distilled`. `null` = nothing compacted yet. This is ALSO
-     * the §6 startup/multi-device "local high-watermark seq ULID" (the LOCAL
-     * half — the hosted `seq > watermark` incremental pull rides with the
-     * hosted upload path, which does not exist yet; flagged in the A1f
-     * report).
+     * covered by `distilled`. `null` = nothing compacted yet. This is the LOCAL
+     * watermark; hosted blind-hold upload (shipped in A1e via `putContextItem`)
+     * tracks its own upload watermark in `hosted-sync.json`.
      */
     compactedThroughSeq: string | null;
     /**
@@ -238,6 +236,8 @@ export declare function projectDistilledForRole(entry: DistilledTaskSummary, rol
  *
  * LOSSLESS: the log is never touched — only the sidecar cache advances.
  * Fail-closed: an unverifiable chain compacts nothing. Never throws.
+ * Mutex-held per session: `onTaskBoundary` and `maybeFireCompactionSafetyValve`
+ * serialize strictly so a valve run never overwrites a boundary distillation.
  */
 export declare function compactSessionContext(deps: {
     sessionId: string;
@@ -402,3 +402,5 @@ export declare function gcContextItemLogs(deps: {
 export declare function onTaskBoundary(sessionId: string): Promise<void>;
 /** Test seam — reset module state (vitest-gated, the established pattern). */
 export declare function resetContextCompactionProcessStateForTests(): void;
+/** Test seam — inspect compactionChains size to verify prompt cleanup upon settlement. */
+export declare function getCompactionChainsSizeForTests(): number;

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

@@ -49,7 +49,7 @@ import { renderRehydratedSessionContext } from './context-compaction';
 import type { AgentKind as LocalExecutorAgentKind } from '../local-executor/types';
 import type { OrchestrationState as OrchestrationStateType } from './types';
 import { type TaskProgressEvent } from './task-progress';
-import { taskLabel } from './task-label';
+import { type PromptReplyOrigin } from './prompt-reply-router';
 /**
  * Gathers the implementor agents currently active across single-implementor running tasks
  * and multi-track Agent Teams tracks. Used for multi-track priority allocation.
@@ -63,14 +63,37 @@ export declare function findActiveContinuationOfferEntry(conversation: ReadonlyA
     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.
+ * P46a (Stage 1 r1 F2c) / P46b §3.7 — a bare digit from the phone cannot choose
+ * between several open prompts: every prompt the phone can answer counts (gate
+ * prompts awaiting a number or a note, the retry prompt, a pending planner
+ * offer). Returns the advisory naming them, or null when the reply is not a bare
+ * digit or at most one prompt is open. Pure.
  */
-export declare function mobileGateReplyAmbiguity(state: Parameters<typeof taskLabel>[0] & {
-    conversation: ReadonlyArray<ConversationEntry>;
-}, text: string): string | null;
+export declare function mobileGateReplyAmbiguity(state: Pick<OrchestrationStateType, 'conversation' | 'taskOrdinals' | 'team' | 'pendingApplyConflicts' | 'pendingPlannerOffer'>, text: string): string | null;
+/**
+ * P46b §3.13 item 3 — route a reply that names or must choose among the open
+ * prompts. Returns true when the line was consumed (answered, or refused with
+ * an advisory); false sends it down today's paths (the keyboard's active
+ * prompt, slash commands, the planner).
+ *
+ *   1. While any prompt is open, `#n <rest>` / `#offer <rest>` is always
+ *      consumed, from either origin: naming an open prompt it answers it
+ *      (making a gate the active prompt), otherwise an advisory.
+ *   2. Keyboard lines without `#` → today's paths (never refused).
+ *   3. Phone lines without `#`: a bare digit with several open prompts is
+ *      refused; with one it answers it. With several prompts awaiting a note a
+ *      plain line or bare `/cancel` is refused; with exactly one it is that
+ *      prompt's note (or leaves its notes entry). Anything else → today's paths.
+ */
+export declare function routeOpenPromptReply(deps: {
+    store: OrchestrationStore;
+    args: RunOrchestrationShellArgs;
+    emitShellEventBound: ReturnType<typeof createShellEventEmitter>;
+    generator: StructuralSummaryGenerator;
+    gateDecisionDeps: GateDecisionSubmitDeps | null;
+    origin: PromptReplyOrigin;
+    text: string;
+}): Promise<boolean>;
 export declare class OrchestrationShellStartupError extends Error {
     readonly cause?: unknown;
     constructor(message: string, cause?: unknown);
@@ -380,6 +403,8 @@ export declare function runOrchestrationShell(args: RunOrchestrationShellArgs):
  * simply renders with no review panel (fail-open).
  */
 export declare const TASK_REVIEW_SUMMARY_FETCH_TIMEOUT_MS = 5000;
+/** P46b §3.9 — the engine's phone retry prompt kind (core-rs `apply_retry.rs`). */
+export declare const APPLY_RETRY_PROMPT_KIND = "orchestration_apply_retry";
 /**
  * Plaintext-first dispatcher per #C8M-7 (Stage 1 R1 M6 lock):
  *   1. If `event.metadata` is an object, use it directly. Otherwise try
@@ -508,18 +533,48 @@ export declare function createSubscribedEventDispatcher(deps: {
     onDurableGateResolution?: (resolution: DurableGateResolution) => Promise<void> | void;
     updateEventStatus?: (input: UpdateEventStatusInput) => Promise<unknown>;
 }): (event: Event) => void;
+export declare function registerTeamTrackStarts(taskGroupId: string, initialRunning: number): void;
+export declare function routeTeamShellEventToStore(store: OrchestrationStore, evt: TeamTapEvent, postLine?: (text: string) => void): void;
+/**
+ * CP-12 W3 — minimal `/team <json>` arg parse. Accepts a JSON `WorkItemInput[]`
+ * (≥2 items). Shallow structural validation only — the backend
+ * `validate_create_input` (#C12-2 disjointness) is authoritative; we just need
+ * a well-formed array to drive `createTaskGroup`. Polished ergonomics
+ * (file-path-set shorthand, interactive builder) are [DEFERRED → CP-8 #469].
+ */
 /**
- * Route ONE team-mode LE shell event into the store's minimal `team` state.
- * The W2.b `emitTrackProgress` emits a NOTIFICATION carrying
- * `metadata.track_index` + `task_id` (+ `source: 'track_progress'`); the
- * `haltTaskGroup` path emits a NOTIFICATION with `source: 'task_group_halted'`.
- * We discriminate on `metadata.source` so non-team NOTIFICATIONs (planner
- * health, late-arrival audits) are IGNORED — they have no team `source` tag.
+ * Audited-path fix (Fix 4 + Fix 5) — parse a `/task` invocation into an optional
+ * implementor-agent override + the remaining brief. Supports a LEADING `--agent
+ * codex|claude|antigravity|agy` flag (case-insensitive value, space or '=' separated); everything after it (or the
+ * whole arg list when absent) is the brief, re-joined verbatim. The override is
+ * returned even when not detected on this host — `selectImplementorAgent` decides
+ * whether to honor it (fail-closed to the default with a user-facing note).
  *
- * Pure mapping → store dispatch; no rich rendering (that is [DEFERRED → CP-8
- * #469]). Called from the `teamShellEventTap.fn` installed at startup.
+ * Tolerant: an unknown `--agent <value>` is IGNORED (the `--agent` token is dropped,
+ * the unrecognized value becomes part of the brief) rather than erroring — keeps the shortcut
+ * forgiving. When using the composite `--agent=<value>` form, the entire token including
+ * any unrecognized value is dropped so it does not pollute the brief. `--agent` with no
+ * following value is dropped (no brief consumed).
  */
-export declare function routeTeamShellEventToStore(store: OrchestrationStore, evt: TeamTapEvent): void;
+export declare function parseTaskCommand(text: string): {
+    agent: LocalExecutorAgentKind | null;
+    brief: string;
+    /** P46a B1 — `/task focus <n>` (or `#n`): the task number to focus, else null. */
+    focus: number | null;
+    /** P46a C3 (Stage 1 r1 F3) — `/task retry <n>` / `/task discard <n>`: answer the apply-conflict menu of task #n. */
+    conflictChoice: {
+        choice: 1 | 2;
+        ordinal: number;
+    } | null;
+    /**
+     * P46b §3.7 — `/task cancel <n>`: `{ ordinal }`, or `{ ordinal: null }` for a
+     * `/task cancel` without a valid number (usage). Matched before the brief
+     * fallback, so it never starts a task with the brief "cancel …".
+     */
+    cancel: {
+        ordinal: number | null;
+    } | null;
+};
 export declare function readOnlyAgentPrompt(args: {
     agent: LocalExecutorAgentKind;
     intent: AgentMentionIntent;
@@ -656,6 +711,8 @@ export declare function launchTeamFromWorkItems(deps: {
      * rewrite resolves each chip to the right ref. Retained for REJECT_RESTART reissue.
      */
     attachmentPaths?: string[];
+    /** P46b §3.10 — the failed group this launch retries (the new group is `#m retry`). */
+    retryOf?: string;
 }): Promise<LaunchTeamOutcome>;
 /**
  * PHASE-589/469 W3.2 RESIDUAL 1 — re-dispatch the WHOLE team for a
@@ -679,7 +736,9 @@ export declare function reissueTeamFromRetainedSpec(deps: {
     quorumLoop?: QuorumLoop;
     sessionId: string;
     durableStore: RevertManifestStore;
-}, taskGroupId: string): Promise<void>;
+}, taskGroupId: string, options?: {
+    retryOf?: string;
+}): Promise<void>;
 /**
  * PHASE-590 §3.D — the `team_decompose` routing path. Runs the local decomposer,
  * shape-checks (the schema is applied inside the decomposer parse) +

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/prompt-reply-router.d.ts

@@ -0,0 +1,53 @@
+import type { ConversationEntry, OrchestrationState, PendingApplyConflict, PendingPlannerOffer } from './types';
+export type PromptReplyOrigin = 'keyboard' | 'mobile';
+type GatePromptEntry = Extract<ConversationEntry, {
+    kind: 'gate-prompt';
+}>;
+export type OpenPrompt = {
+    kind: 'gate';
+    /** `#3`, `#5.2`, or the short-id fallback of an unnumbered task. */
+    label: string;
+    entry: GatePromptEntry;
+    awaiting: 'number' | 'note';
+    optionCount: number;
+} | {
+    kind: 'apply';
+    label: string;
+    menu: PendingApplyConflict;
+    awaiting: 'number';
+    optionCount: 2;
+} | {
+    kind: 'offer';
+    label: 'offer';
+    offer: PendingPlannerOffer;
+    awaiting: 'number';
+    optionCount: number;
+};
+/** The reference a reply uses for `prompt`: `3`, `5.2` or `offer`. */
+export declare function promptReference(prompt: OpenPrompt): string;
+/** How advisories name `prompt`: `Task #3`, `Task #5.2`, `#offer`. */
+export declare function promptName(prompt: OpenPrompt): string;
+/** Every open prompt in presentation order (gates, then menus, then the offer). */
+export declare function listOpenPrompts(state: Pick<OrchestrationState, 'conversation' | 'taskOrdinals' | 'team' | 'pendingApplyConflicts' | 'pendingPlannerOffer'>, origin: PromptReplyOrigin): OpenPrompt[];
+/**
+ * `#2 1` → `{ reference: '2', rest: '1' }`; `#5.2 note text` → `{ '5.2', 'note text' }`;
+ * `#offer 3` → `{ 'offer', '3' }`; a bare `#2` → rest `''`. Null when the line
+ * does not start with a reference followed by whitespace or the end.
+ */
+export declare function parsePromptReference(text: string): {
+    reference: string;
+    rest: string;
+} | null;
+/** The open prompt a reference names, or null. */
+export declare function findPromptByReference(open: ReadonlyArray<OpenPrompt>, reference: string): OpenPrompt | null;
+/** §3.7 — a bare digit from the phone while several prompts are open. */
+export declare function severalPromptsAdvisory(open: ReadonlyArray<OpenPrompt>): string;
+/** §3.13 item 3.3.2 — a plain phone line while several prompts await a note. */
+export declare function severalNotesAdvisory(notes: ReadonlyArray<OpenPrompt>): string;
+/** §3.13 item 3.1 — a `#n` reply the named prompt cannot take. */
+export declare function expectedReplyAdvisory(prompt: OpenPrompt): string;
+/** §3.13 item 3.1 — a `#n` reply naming no open prompt. */
+export declare function noOpenPromptAdvisory(reference: string): string;
+/** §3.13 item 3 — the phone hint when a numbered answer opens a gate's notes entry. */
+export declare function notesHint(prompt: OpenPrompt): string;
+export {};

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

@@ -1,7 +1,7 @@
 import type { AppSyncClient, TeamTrackRecoveryRow } from '../appsync/appsync-client';
 import type { Session } from '../types';
 import type { LocalExecutor } from '../local-executor';
-import type { ClassBInbound } from '../local-executor/types';
+import type { ClassBInbound, QueuedWorkEndedPayload } from '../local-executor/types';
 import type { ImageAttachment } from './types';
 import { type TaskAuditSummaryModel, type ReviewHistorySnapshot, type UserDecisionRecord } from './audit-summary';
 import type { DecryptedReviewSummaryInput } from './gate-prompts';
@@ -596,6 +596,51 @@ export interface TaskOrdinalSink {
     }): number | undefined;
     label(taskId: string): string;
 }
+/**
+ * P46a D2 / P46b §3.7 — a single task's recorded state for `/status`. `queued`
+ * waits for a running-track slot; `cancelled` ended before it started
+ * (`QUEUED_WORK_ENDED`, or a `cancelled` START replay); `already_finished` is a
+ * START replay of work that already ended.
+ */
+export type SingleTaskOutcome = 'running' | 'queued' | 'applied' | 'discarded' | 'apply_failed' | 'unresolved' | 'rejected' | 'cancelled' | 'already_finished';
+/** P46b §3.3 — what a confirmed START did. */
+export interface StartTaskResultInfo {
+    taskId: string;
+    outcome: 'running' | 'queued' | 'already_finished' | 'cancelled';
+    /** Present when queued: 1-based position in the account's queue. */
+    queuePosition?: number;
+    runningTracks?: number;
+    trackBudget?: number;
+}
+/**
+ * P46b §3.13 item 1 — a single task's lifecycle change the shell turns into a
+ * store update and a phone line: queued at START, started (immediately or when
+ * a slot freed), or cancelled before it started.
+ */
+export type TaskLifecycleEvent = {
+    kind: 'queued';
+    taskId: string;
+    agent: AgentKind;
+    queuePosition?: number;
+    runningTracks?: number;
+    trackBudget?: number;
+} | {
+    kind: 'started';
+    taskId: string;
+    agent: AgentKind;
+    fromQueue: boolean;
+    retryOf?: string;
+} | {
+    kind: 'cancelled';
+    taskId: string;
+    reason: string;
+};
+/** P46b §3.6 — the desktop's slot-lease capability sent on every START. */
+export declare const SLOT_LEASE_PROTOCOL = 1;
+/** P46b §3.6 — one task lease heartbeat per held task every 2 minutes (the engine lease is 600 s). */
+export declare const TASK_LEASE_HEARTBEAT_INTERVAL_MS: number;
+/** P46b §3.3 — map the START answer's state label onto what the START did. */
+export declare function startOutcomeFor(workflowState: string): StartTaskResultInfo['outcome'];
 /** P46a C3 — the desktop-local "could not apply" menu the loop asks the shell to present. */
 export interface ApplyConflictMenu {
     taskId: string;
@@ -606,6 +651,14 @@ export interface ApplyConflictMenu {
         byTaskLabel?: string;
     }>;
     autoRetried: boolean;
+    /** P46b §3.10 — `group` for a team promote (`taskId` is the taskGroupId). */
+    kind?: 'single' | 'group';
+    /** P46b §3.9 — counts only, per cause (the retry prompt's content). */
+    counts?: {
+        sessionTask: number;
+        external: number;
+        writeErrors: number;
+    };
     retryBrief: string;
     /** The ROOT user request (Stage 1 r3 F1) — the menu's retry carries it (web-access decision, `/status`). */
     request: string;
@@ -636,6 +689,19 @@ export declare class QuorumLoop {
     private latestInFlightStart;
     /** Stage 1 r1 F13 — every START still in flight, in issue order; `latestInFlightStart` is its last entry. */
     private readonly startOrderInFlight;
+    /**
+     * P46b §3.7 — a queued task's START answer (position, running tracks, budget)
+     * and, once it ended before starting, the reason. Kept for `/status`.
+     */
+    private readonly queueInfoByTask;
+    /** P46b §3.7 — single tasks whose implementor has been spawned at least once (`starting` ends). */
+    private readonly spawnedSingleTasks;
+    /** P46b §3.13 item 1 — the shell's lifecycle sink (store update + phone line). */
+    private taskLifecycleSink?;
+    /** P46b §3.6 — the one per-session task lease heartbeat timer (null while stopped). */
+    private taskLeaseHeartbeatTimer;
+    /** P46b §3.6 — tasks whose heartbeat request is still in flight (one at a time per task). */
+    private readonly taskLeaseHeartbeatsInFlight;
     /** 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. */
@@ -1117,8 +1183,22 @@ export declare class QuorumLoop {
      */
     private recoverySeedingDepth;
     /**
-     * Recovery B.1 and B.2 can overlap. A per-call two-row batch is therefore
-     * insufficient: two concurrent calls could each launch two implementors.
+     * P46b (E2E T-3) — how many barrier holders are in their PASS-2 relaunch (each
+     * counted within `recoverySeedingDepth`), and the tracks they relaunch
+     * (refcounted task ids and brief slots). While EVERY holder is relaunching (none
+     * is still querying, seeding briefs or binding a `/team` create), only packets
+     * for a relaunched track keep buffering — the relaunch-before-drain dedup order
+     * is unchanged for them. A packet for any other track (a queued track promoted
+     * meanwhile, whose brief PASS 1 already seeded) is consumed live instead of
+     * waiting for every relaunched implementor round to finish, which can outlast
+     * its 15-minute lease.
+     */
+    private recoveryRelaunchPhaseDepth;
+    private readonly recoveryRelaunchTaskIds;
+    private readonly recoveryRelaunchSlots;
+    /**
+     * Recovery B.1 and B.2 can overlap. A per-call batch is therefore
+     * insufficient: two concurrent calls could each launch a full batch.
      * These permits are owned by the QuorumLoop/session and cover the complete
      * `launchRecoveredTrack` operation across every recovery entry path.
      */
@@ -1322,6 +1402,43 @@ export declare class QuorumLoop {
         retryOf: string;
         agent: AgentKind;
     }) => void) | undefined): void;
+    /**
+     * P46b §3.10 — a team promote could not be applied (the team promote has no
+     * per-path session attribution, so every changed path is `external`). A team
+     * gets no automatic retry: it always offers the menu (retry reissues the
+     * whole team from its retained launch spec).
+     */
+    reportTeamApplyConflict(info: {
+        taskGroupId: string;
+        conflicts: readonly string[];
+        writeErrors: readonly string[];
+    }): void;
+    /** P46b §3.13 item 1 — install the task lifecycle sink (the shell). */
+    setTaskLifecycleSink(sink: ((event: TaskLifecycleEvent) => void) | undefined): void;
+    /** P46b — notify the lifecycle sink; a throwing sink never breaks the loop. */
+    private emitTaskLifecycle;
+    /**
+     * P46b §3.6 — the first change of a queued task to `cancelled (reason)`. Shared
+     * by the `QUEUED_WORK_ENDED` packet, the `/status` catch-up and a `cancelled`
+     * answer to `/task cancel`, so whichever arrives first acts and the others do
+     * nothing. Returns true only on that first change.
+     */
+    markQueuedTaskCancelled(taskId: string, reason: string): boolean;
+    /** P46b §3.6 — the `QUEUED_WORK_ENDED` Class-B packet. */
+    private handleQueuedWorkEnded;
+    /** P46b §3.6 — start the per-session task lease heartbeat (idempotent). */
+    private ensureTaskLeaseHeartbeat;
+    /** P46b §3.6 — stop the task lease heartbeat (terminal: shutdown or no task left). */
+    private stopTaskLeaseHeartbeat;
+    /**
+     * P46b §3.6 — one heartbeat for every single task this desktop holds in the
+     * implement–review loop (queued, starting, implementing, in review, awaiting
+     * you): `recordExecutionEvent(PROGRESS_EVENT, {kind: TASK_LEASE_HEARTBEAT,
+     * taskId})`, which RENEWs the task's slot lease. A START still in flight is
+     * skipped (its holder may not exist yet); a beat still in flight is not
+     * doubled. Work this desktop no longer knows stops renewing and lapses.
+     */
+    sendTaskLeaseHeartbeats(): Promise<void>;
     /** P46a D1 — `#n` / `#n retry` / short id for any task id (never throws). */
     labelFor(taskId: string): string;
     /**
@@ -1335,9 +1452,15 @@ export declare class QuorumLoop {
         agent: AgentKind;
         brief: string;
         retryOf?: string;
-        outcome: 'running' | 'applied' | 'discarded' | 'apply_failed' | 'unresolved' | 'rejected';
+        outcome: SingleTaskOutcome;
         implementorActive: boolean;
         focused: boolean;
+        /** P46b §3.7 — START confirmed or dispatched, implementor not spawned yet. */
+        starting?: boolean;
+        /** P46b §3.7 — queue position from the START answer (queued tasks). */
+        queuePosition?: number;
+        /** P46b §3.6 — why a queued task ended before it started. */
+        cancelReason?: string;
     }>;
     /** Stage 1 r1 F13 — a START confirmed or rejected: the newest START still in flight (if any) becomes the empty-envelope target. */
     private dropInFlightStart;
@@ -1441,6 +1564,7 @@ export declare class QuorumLoop {
         gateDispatch: (payload: GateDispatchPayload, envelopeTaskId?: string) => Promise<void>;
         spawnReviewers: (payload: ReviewerDispatchPayload) => Promise<void>;
         runReviseRound: (payload: ReviseFeedbackPayload) => Promise<void>;
+        queuedWorkEnded: (payload: QueuedWorkEndedPayload) => Promise<void>;
     };
     private cachedSigningKey;
     private verifySignature;
@@ -1490,9 +1614,7 @@ export declare class QuorumLoop {
          * read this instead. Omitted for an ordinary task (its brief IS the request).
          */
         request?: string;
-    }): Promise<{
-        taskId: string;
-    } | null>;
+    }): Promise<StartTaskResultInfo | null>;
     /**
      * CP-1.f Wave 3 FIX — consume a GATE_DISPATCH packet. The engine emits this
      * after `startTask` creates the round-0 `reviewer_quorum` gate; its
@@ -2366,6 +2488,15 @@ export declare class QuorumLoop {
      * here; single-impl / non-team packets bypass this entirely.
      */
     bufferTeamPacketDuringSeeding(kind: 'trackAssigned' | 'gateDispatch', payload: unknown, envelopeTaskId?: string): boolean;
+    /**
+     * P46b (E2E T-3) — whether a live team packet belongs to a track a recovery is
+     * relaunching right now. A packet that names no track this can match (no
+     * envelope task id and no TrackAssigned ids) counts as one, so it keeps
+     * buffering exactly as before.
+     */
+    private isRecoveryRelaunchPacket;
+    private enterRecoveryRelaunchPhase;
+    private leaveRecoveryRelaunchPhase;
     /**
      * §4.3 — drain the buffered live TEAM packets through the normal live handlers
      * AFTER the recovery seed barrier lifts (`recoverySeedingDepth === 0`). Each

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

@@ -0,0 +1,29 @@
+/** The never-started halt reasons of `QUEUED_WORK_ENDED` (engine `halted_reason`). */
+export type QueuedTaskEndReason = 'user_cancelled_queued_task' | 'tier_changed' | 'queued_task_expired';
+/** `#4` → `4`, `#4 retry` → `4`, `#5.2` → `5.2`; anything else unchanged. */
+export declare function labelNumber(label: string): string;
+/** Desktop answer to a queued START (§3.7). */
+export declare function queuedDesktopLine(label: string, info: {
+    runningTracks?: number;
+    trackBudget?: number;
+}): string;
+/** Phone line for a queued START (§3.13 item 1). */
+export declare function queuedPhoneLine(label: string, info: {
+    runningTracks?: number;
+    trackBudget?: number;
+}): string;
+/** Phone line for every single-task start, immediate or from the queue. */
+export declare function startedPhoneLine(label: string, agent: string): string;
+/** Desktop line when a queued task starts because a slot freed. */
+export declare function startedFromQueueDesktopLine(label: string, agent: string): string;
+/** Phone line when a team starts (§3.13 item 1). */
+export declare function teamStartedPhoneLine(label: string, running: number, waiting: number): string;
+/** Phone line when a team track that waited starts later (`#5.4`). */
+export declare function trackStartedPhoneLine(trackLabel: string): string;
+/**
+ * The line (desktop and phone) for a task that never started and was halted.
+ * An unknown reason renders the neutral form.
+ */
+export declare function cancelledLine(label: string, reason: string): string;
+/** `/status` phase for a cancelled task: `cancelled (reason)`. */
+export declare function cancelledStatusLabel(reason?: string): string;

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

@@ -87,6 +87,7 @@ export type TaskProgressEvent = ({
     message: string;
 }) & {
     epoch?: number;
+    progressTaskId?: string;
     tokens?: number;
 };
 /** The callback the QuorumLoop invokes on each progress phase. */

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

@@ -177,7 +177,8 @@ export interface SessionTaskRecord {
     /** 'single' = TASK_LIFECYCLE-tracked; 'team' = Agent Teams track. */
     origin: 'single' | 'team';
     /**
-     * Singles: the lifecycle status — 'running' at dispatch, flipped terminal
+     * Singles: the lifecycle status — 'queued' while a START waits for a
+     * running-track slot (P46b), 'running' at dispatch, flipped terminal
      * by the task-end CLOSER progress events (promoted → 'completed',
      * discarded → 'cancelled', round_failed → 'failed'; Stage-2 r1 Codex
      * MED-2 — no production TASK_LIFECYCLE dispatch ever carries a terminal
@@ -589,6 +590,24 @@ export interface PendingApplyConflict {
     }>;
     /** True when this menu follows the one automatic retry's own promote failure. */
     readonly autoRetried: boolean;
+    /**
+     * P46b §3.10 — `group` when the failed promote was a team's (`taskId` is then
+     * the `taskGroupId`; retry reissues the team from its retained launch spec).
+     * Absent = a single task (P46a).
+     */
+    readonly kind?: 'single' | 'group';
+    /** P46b §3.9 — counts only: how many paths each cause failed. */
+    readonly counts?: {
+        readonly sessionTask: number;
+        readonly external: number;
+        readonly writeErrors: number;
+    };
+    /**
+     * P46b §3.9 (ID-20) — the engine retry prompt's gate id once
+     * `openApplyRetryOffer` succeeded: the phone can answer this menu, and it is
+     * resolved with the user's choice. Absent = the desktop-local menu only.
+     */
+    readonly offerGateId?: string;
     /** The `advisory` conversation entry that rendered the numbered options. */
     readonly conversationEntryId: string;
     /** The composed retry brief (original request + files changed since + reviewed contents). */
@@ -709,6 +728,11 @@ export interface LiveProgress {
     updatedAt: string;
     /** ISO — when THIS busy window opened; the wall-clock timer anchor. */
     startedAt: string;
+    /**
+     * P46b §3.7 — the task this line belongs to (from `emitProgressForTask`);
+     * undefined for a classify/familiarize/advisory window.
+     */
+    taskId?: string;
     /**
      * The per-TASK origin epoch of the event that opened/last-refreshed this window
      * (§2/§3). Undefined ONLY for the direct-dispatched classify/familiarize windows
@@ -810,6 +834,13 @@ export interface OrchestrationState {
      * Companion sessions never dispatch `TASK_PROGRESS`, so this stays null.
      */
     progress: LiveProgress | null;
+    /**
+     * `[ADDITIVE WIDENING — P46b §3.7]` One live line per single task that is
+     * busy right now, keyed by task id, under the same epoch/closer rules as
+     * `progress` applied per task. Team tracks are excluded (their rows live in
+     * `MultiTrackStatusNode`). Optional so pre-P46b state literals stay valid.
+     */
+    progressByTask?: Map<string, LiveProgress>;
     /**
      * `[ADDITIVE WIDENING — /reviewer-setup wizard, 2026-06-29]` The active
      * interactive reviewer-panel setup modal, or `null` when no wizard is open
@@ -1010,6 +1041,22 @@ export type OrchestrationAction = {
 } | {
     type: 'CLEAR_PENDING_APPLY_CONFLICT';
     taskId?: string;
+} | {
+    type: 'APPLY_CONFLICT_OFFER_OPENED';
+    taskId: string;
+    gateId: string;
+} | {
+    type: 'SINGLE_TASK_QUEUED';
+    taskId: string;
+    agentKind: string;
+    queuedAt: string;
+} | {
+    type: 'SINGLE_TASK_QUEUE_ENDED';
+    taskId: string;
+    reason: string;
+} | {
+    type: 'GATE_PROMPT_ACTIVATED';
+    promptEntryId: string;
 } | {
     type: 'STRUCTURAL_SUMMARY_GENERATED';
     summary: StructuralSummary;

package/node_modules/@quantiya/codevibe-core/dist/substrate/command-runner.d.ts

@@ -1,5 +1,6 @@
 import type { CommandResult, CommandRunner, RunnerProc } from './types';
 import type { WorkspaceRootAuthority } from '../local-executor/workspace-authority';
+import type { HostDescendantReap } from '../local-executor/descendant-reaper';
 /**
  * The production `CommandRunner` — runs `docker` / `sandbox-exec` via
  * `node:child_process`. No shell is used (argv is passed directly to
@@ -18,5 +19,6 @@ export declare class ChildProcessCommandRunner implements CommandRunner {
         cwd?: string;
         cwdAuthority?: WorkspaceRootAuthority;
         launchPathAuthorities?: readonly WorkspaceRootAuthority[];
+        descendantReap?: HostDescendantReap;
     }): RunnerProc;
 }

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

@@ -1,5 +1,6 @@
 import type { Readable, Writable } from "node:stream";
 import type { WorkspaceRootAuthority } from "../local-executor/workspace-authority";
+import type { HostDescendantReap } from "../local-executor/descendant-reaper";
 /**
  * Isolation backend for a substrate. `firecracker` is [DEF →
  * A3-after-C2] — declared so the union admits the hosted runner without
@@ -173,6 +174,8 @@ export interface SubstrateHandle {
         stdinTty: boolean;
         timeoutMs?: number;
         signal?: AbortSignal;
+        /** P46b ID-31 — the descendant sweep the process host runs if the desktop dies first. */
+        descendantReap?: HostDescendantReap;
     }): Promise<SubstrateProc>;
     /** Idempotent; MUST destroy the sandbox + its fs view. */
     teardown(): Promise<void>;
@@ -276,5 +279,7 @@ export interface CommandRunner {
          * they are not its cwd (for example Claude's private scratch root).
          */
         launchPathAuthorities?: readonly WorkspaceRootAuthority[];
+        /** P46b ID-31 — the descendant sweep the process host runs if the desktop dies first. */
+        descendantReap?: HostDescendantReap;
     }): RunnerProc;
 }

package/node_modules/@quantiya/codevibe-core/dist/substrate-launch/engage-substrate.d.ts

@@ -41,6 +41,8 @@ export interface EngageSubstrateInput {
      * legacy behavior for every existing caller.
      */
     requireConfined?: boolean;
+    /** F-P46a-4 — the implementor spawn's process-tree id (descendant reaping marker). */
+    processTreeId?: string;
     /** Ladder deps (injectable for tests). */
     ladderDeps?: FallbackLadderDeps;
     /** Broker upstream client override (tests inject a stub; default real fetch). */