@quantiya/codevibe-codex-plugin 2.0.6 → 2.0.8

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

@@ -1,22 +1,25 @@
 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 { ImageAttachment } from './types';
 import { type ImplementorMode } from '../local-executor/implementor-argv';
+import { type FallbackLadderDeps } from '../substrate-launch/fallback-ladder';
 import type { ConflictModelCaller } from '../local-executor/class2-resolver';
 import type { ConflictResolverContext } from '../local-executor/merge-conflict-resolve';
 import type { AgentKind } from '../local-executor/types';
 import type { GateDispatchPayload, ReviewerDispatchPayload, ReviseFeedbackPayload } from '../local-executor/types';
 import type { TeamTrackFailureReason } from '../local-executor/task-group-types';
-import { WorkspaceShadow, type ShadowEnv } from '../local-executor/workspace-shadow';
+import { WorkspaceShadow, type RecoveredShadow, type ShadowCleanupResidue, type ShadowEnv } from '../local-executor/workspace-shadow';
 import type { RevertManifestStore } from '../local-executor/durable-store';
+import { captureWorkspaceRootAuthority } from '../local-executor/workspace-authority';
 import { type TeamExecution } from '../local-executor/team-execution-flag';
 import { type RenderedConflict, type TrackIntentDiff } from '../local-executor/wb2-review-bundle';
 import { ReviewerRegistry } from '../reviewer/registry';
 import { type ReviewerFailureReason } from '../reviewer/provider';
 import type { SubstrateHandle } from '../substrate/types';
 import type { VerdictClassifier } from '../reviewer/verdict-classifier';
-import type { AgentKind as ReviewerAgentKind, ReviewerRole } from '../reviewer/types';
+import type { AgentKind as ReviewerAgentKind, ReviewerRole, VerdictKind } from '../reviewer/types';
 import type { OnProgress } from './task-progress';
 import { runShellCommand } from '../local-executor/verification-gates/shell-runner';
 import type { PostDecisionAction, Tier } from './types';
@@ -60,7 +63,7 @@ export declare function classifyImplementorRoundFailure(err: unknown): string;
  * Fixtures (L1):
  *   - Codex (PINNED — CP-13 §0/§2-D1 live sample): `You've hit your usage limit
  *     … try again at <date>` → match on `usage limit` (case-insensitive).
- *   - Claude / Gemini: TBD — CP-13 has not captured real samples. Inventing
+ *   - Claude: TBD — CP-13 has not captured real samples. Inventing
  *     strings risks a FALSE-NEGATIVE classifier that misses a real quota error,
  *     so they are left as additive one-liners to fill once real samples land.
  *     An UNMATCHED quota error degrades FAIL-SAFE to the existing born-halt
@@ -135,6 +138,76 @@ export declare function selectFinalTier2Reviewer(detected: readonly AgentKind[],
  * and never falls through. Pure; NEVER throws.
  */
 export declare function selectFinalTier2Candidates(detected: readonly AgentKind[], resolverAgents: ReadonlySet<string>, override?: AgentKind | null): AgentKind[];
+/**
+ * A1b — ONE reviewer verdict as captured desktop-side at `submitVerdict`,
+ * BEFORE the engine flattens the round's panel into free-text
+ * `ReviseSeatFinding.findings`. This is what lets round N's revise brief carry
+ * the STRUCTURED findings of rounds < N-1 (the "addressing 0 findings" /
+ * re-flagging-fixed-issues fix) without any wire change.
+ */
+export interface RoundFindingRecord {
+    /** The gate round the verdict reviewed (0-based, from `roundByGateId`). */
+    round: number;
+    /** Numeric seat id as a string (matches `ReviseSeatFinding.seatId` shape). */
+    seatId: string;
+    role: ReviewerRole;
+    reviewerAgent: ReviewerAgentKind;
+    verdict: VerdictKind;
+    /** Capped to HISTORY_SUGGESTION_MAX_CHARS each at capture. */
+    suggestedChanges: string[];
+    /** Capped to HISTORY_REASONING_MAX_CHARS at capture. Stored for audit /
+     *  bounded reuse; NOT rendered into the brief (the brief carries verdict +
+     *  suggested changes only). */
+    reasoning: string;
+}
+/**
+ * A1b — ONE implementor rationale entry (Stage-2 R1 Codex LOW-4: the round is
+ * RECORDED with the text, so a round that produced no summary can never drift
+ * the labeling — consumers render the entry's ACTUAL round, never an inferred
+ * `nextRound - 1`).
+ */
+export interface RationaleEntry {
+    /** The implementor round that produced this summary (0-based). */
+    round: number;
+    /** The summary text, char-capped at capture (RATIONALE_ENTRY_MAX_CHARS). */
+    text: string;
+}
+/**
+ * A1d / P2 resolver-intent (design §5 — the resolver's need-to-know projection:
+ * "conflicted paths + 3-way markers + both tracks' intent diffs + each track's
+ * brief + task intent"). ALL fields optional + already BOUNDED by the caller
+ * (`RESOLVER_INTENT_DIFF_MAX_BYTES` / `RESOLVER_TRACK_BRIEF_MAX_BYTES`);
+ * absent/empty ⇒ the brief is byte-identical to the pre-A1d shape (graceful
+ * degrade — mirrors the A1b rationale posture).
+ */
+export interface ResolverIntentContext {
+    /** The INCOMING track's brief (the THEIRS side's task intent), bounded. */
+    incomingBrief?: string | null;
+    /** The incoming track's index (labeling only). */
+    incomingTrackIndex?: number;
+    /**
+     * Briefs of the group's OTHER registered tracks (the OURS side — the
+     * integration tip is the base plus the already-merged tracks), bounded,
+     * sorted by trackIndex.
+     */
+    integrationBriefs?: readonly {
+        trackIndex: number;
+        brief: string;
+    }[];
+    /** Bounded base→trackTip unified diff (THEIRS intent), or a placeholder line. */
+    incomingIntentDiff?: string | null;
+    /** Bounded base→integrationTip unified diff (OURS intent), or a placeholder line. */
+    integrationIntentDiff?: string | null;
+}
+/**
+ * CP-14 WB2 (D1, locked) — the brief delivered on the resolver agent's stdin. It
+ * enumerates the class-2 conflicted paths (which carry 3-way markers), instructs
+ * write-in-place + remove EVERY marker, and tells the agent that ONLY its edits to
+ * the listed files are kept (selective import — any other edit is discarded). The
+ * agent may read other files + run build/test to verify, but those artifacts do
+ * not import (they only help it converge).
+ */
+declare function renderAgenticResolveBrief(conflictedPaths: readonly string[], implementorRationale?: string | null, intent?: ResolverIntentContext): string;
 /**
  * CP-7 §8 (Stage-1-resolved) — the narrow result the QuorumLoop consumes from
  * the reviewer substrate engager. Mirrors `SubstrateLaunch.EngageResult` /
@@ -210,6 +283,19 @@ export interface QuorumLoopDeps {
     getSessionKey: (sessionId: string) => Promise<string | null>;
     /** Working dir for spawned subprocesses (canonicalized). */
     workingDir: string;
+    /**
+     * A1d (Stage-2 R1 Codex MED) — test seams for the RESOLVER-SPECIFIC
+     * construction probe (`probeResolverDispatchConfinement`). `ladderDeps`
+     * stubs the §6 Q2 substrate ladder; `trustedContainer` stubs the
+     * trusted-container boundary check. ABSENT (production) → the real ladder +
+     * `isTrustedContainerBoundary`. The probe decides only whether the agentic
+     * closure is WIRED — the dispatch-time `requireConfined` engage remains the
+     * sole load-bearing confinement gate.
+     */
+    resolverProbeDeps?: {
+        ladderDeps?: FallbackLadderDeps;
+        trustedContainer?: () => boolean;
+    };
     /**
      * CP-14 Wave A — the team execution model. `worktree_merge` makes each team
      * track commit to a persistent branch (the merge-before-push spine) instead of
@@ -238,15 +324,32 @@ export interface QuorumLoopDeps {
      * agent reviewer runs INSIDE the sandbox with no ambient vendor creds and a
      * broker-routed model call — closing the CP-14 §8/§13 reviewer-sandbox gap.
      * ABSENT (legacy / companion / tests) → reviewers take the legacy unsandboxed
-     * path BYTE-IDENTICAL (§7 non-regression). Reviewer-sandboxing is ALSO gated
-     * behind an opt-in env flag (`CODEVIBE_SANDBOX_REVIEWERS=1`, read in
-     * `engageSeatSubstrate` on the `spawnOneSeat` path) that DEFAULTS OFF — so
-     * even when this engager is wired,
-     * reviewers stay on the legacy path until the broker round-trip is observed
-     * green in a configured env (see `reviewerSandboxingEnabled`). The flag is
+     * path BYTE-IDENTICAL (§7 non-regression). Reviewer-sandboxing DEFAULTS ON
+     * when this engager is wired (R7 A4), with an operator opt-out env flag
+     * (`CODEVIBE_SANDBOX_REVIEWERS=0`, read in `engageSeatSubstrate` on the
+     * `spawnOneSeat` path — see `reviewerSandboxingEnabled`). The flag is
      * independent of implementor sandboxing (which has its own engager).
      */
     engageReviewerSubstrate?: ReviewerSubstrateEngager;
+    /**
+     * A1e (P3 slice-wiring REMAP) — compose the bounded repository-context
+     * block for a task dispatch: the resolved `context_ref` structural slice
+     * (`mintContextRef` → `resolveContextRef` → `sliceSummary`) + the FRESH-ONLY
+     * `repo_state` overview (design §8.3 freshness — a stale record fires the
+     * background re-delegation and is NEVER projected). Wired by `cli.ts` to a
+     * tap holder; `runOrchestrationShell` installs the real composer
+     * (`composeDispatchContextBlock`) — the progressTap late-binding pattern.
+     * Appended to the ROUND-0 implementor STDIN payload ONLY (never
+     * `args.brief`, which becomes the execute-first `task_brief` → the
+     * reviewer prompts — the same self-visibility boundary as the A1b prior-
+     * rationale block). Returns `''` for "no block". ABSENT (legacy / companion
+     * / tests) → byte-identical stdin (no projection).
+     */
+    projectDispatchContext?: (input: {
+        taskId: string;
+        agent: AgentKind;
+        roundNumber: number;
+    }) => Promise<string>;
     /**
      * CP-1.f LOCK RP-6 — this orchestration host's detected coding agents
      * (UPPERCASE `CLAUDE` / `CODEX` / `GEMINI`), computed ONCE by `cli.ts` via
@@ -283,6 +386,22 @@ export interface QuorumLoopDeps {
      * production uses the defaults (`~/.codevibe/shadow-state`, `os.tmpdir()`).
      */
     shadowEnv?: ShadowEnv;
+    /**
+     * Deterministic recovery seams. Production omits this object and uses the
+     * imported filesystem implementations. Tests may park an exact recovery
+     * await to prove the session-disposal admission/drain boundary without
+     * weakening any production timeout or filesystem check.
+     */
+    shadowRecoveryOps?: {
+        listRecoverableShadows?: (env: ShadowEnv) => Promise<RecoveredShadow[]>;
+        listShadowCleanupResidue?: (taskIds: ReadonlySet<string>, env: ShadowEnv) => Promise<ShadowCleanupResidue[]>;
+        captureWorkspaceRootAuthority?: typeof captureWorkspaceRootAuthority;
+        reopenShadow?: (recovered: RecoveredShadow, env: ShadowEnv) => Promise<WorkspaceShadow | null>;
+        reapOrphanShadows?: (keepTaskIds: ReadonlySet<string>, env: ShadowEnv) => Promise<{
+            reaped: string[];
+            retained: string[];
+        }>;
+    };
     /**
      * CP-1.f execute-first (#EF-1 / #SR-2) — surface a user-visible halt /
      * fail-closed message to the orchestration timeline. Wired by the shell to an
@@ -339,6 +458,7 @@ export interface QuorumLoopDeps {
         taskGroupId: string;
         trackIndex: number;
         state: 'Passed' | 'Failed';
+        resolvedBy: 'engine' | 'user';
     }) => void;
     /**
      * PHASE-589/469 W3.1 (C1) — the durable revert-manifest store. For a TEAM
@@ -359,8 +479,10 @@ export interface QuorumLoopDeps {
      *
      * SECURITY INVARIANT: events carry ONLY counts/labels/paths/elapsed — never
      * diff content, file contents, reviewer reasoning, prompts, or any decrypted
-     * plaintext (the `TaskProgressEvent` union is the allowlist). The loop wraps
-     * every emit so a throwing listener can NEVER break the loop.
+     * plaintext (the `TaskProgressEvent` union is the allowlist, with its ONE
+     * documented exception: `halt_notice.message`, controlled operational notice
+     * text from `surfaceHalt` — see task-progress.ts's header carve-out). The
+     * loop wraps every emit so a throwing listener can NEVER break the loop.
      */
     onProgress?: OnProgress;
     /**
@@ -412,6 +534,21 @@ declare function reviewerAgentToLeAgent(agent: ReviewerAgentKind): AgentKind;
  * leading token isn't a non-negative integer.
  */
 export declare function numericSeatId(resolvedSeatId: string): number | null;
+interface TeamRunAuthority {
+    taskGroupId: string;
+    trackIndex: number;
+    dispatchGeneration: number;
+}
+/**
+ * Byte-equivalent to the engine's
+ * `round0_gate_id_for_track(task, group, track, generation)`.
+ *
+ * Live GateDispatch packets intentionally carry no mutable "current" pointer.
+ * Their deterministic id is the authenticated correlation between the signed
+ * TrackAssigned generation and the signed GateDispatch. Keeping the formula
+ * here closes packet-order races without extending or weakening the wire.
+ */
+export declare function teamRound0GateId(taskId: string, taskGroupId: string, trackIndex: number, dispatchGeneration: number): string;
 export declare class QuorumLoop {
     private readonly deps;
     private readonly sleep;
@@ -481,6 +618,8 @@ export declare class QuorumLoop {
      * share a `trackIndex` overwrite each other's brief.
      */
     private teamBriefsByKey;
+    /** Recovery-authored briefs keyed by task/group/index/generation authority. */
+    private readonly recoveredBriefsByAuthority;
     private readonly activeBriefByTask;
     /**
      * CP-1.f revise-context fix (dogfood task 2ac68708, 2026-06-11) — the BINDING
@@ -501,6 +640,46 @@ export declare class QuorumLoop {
      * task's notes.
      */
     private readonly userNotesByTask;
+    /**
+     * A1b — STRUCTURED reviewer findings accumulated across ALL of a task's
+     * review rounds, captured at `submitVerdict` (the desktop-local hook where
+     * the full `ReviewerVerdict` passes through BEFORE the engine flattens the
+     * panel to free-text `ReviseSeatFinding.findings`). Round N's revise brief
+     * renders rounds < N-1 from here as the `## Findings history` section, so
+     * the implementor SEES what earlier rounds flagged (the "addressing 0
+     * findings" / re-flagging-fixed-issues fix) with NO wire change.
+     *
+     * Desktop-local capture is design-correct for GA: the locked shared-context
+     * design's single-write-authority means ONE desktop runs ALL of a task's
+     * seats, so every verdict for the task passes through THIS process's
+     * `submitVerdict` (multi-desktop seat fan-out is post-GA; a cross-desktop
+     * history store would be designed then). Lifecycle mirrors `userNotesByTask`
+     * exactly: cleared on promote / discard / round-0 restart replacement.
+     */
+    private readonly roundHistoryByTask;
+    /**
+     * A1b — the implementor's own per-round stdout rationale (the
+     * `extractAgentSummary` text), recorded as `{ round, text }` (LOW-4: labels
+     * come from the RECORDED round — a summary-less round can never drift them),
+     * bounded per entry, newest last. Three bounded consumers:
+     *   1. The NEXT revise round's implementor stdin (`## Your prior rationale`,
+     *      ≤ PRIOR_RATIONALE_BRIEF_MAX_BYTES) — self-visibility only; it rides
+     *      the stdin, NEVER the task_brief the reviewers see.
+     *   2. The agentic class-2 resolver brief (≤ RATIONALE_RESOLVER_MAX_BYTES,
+     *      ungated — the resolver is intent-starved by design).
+     *   3. Reviewer packets, ONLY behind the DEFAULT-OFF
+     *      OQ-REVIEWER-RATIONALE flag, as a labeled UNTRUSTED claim.
+     * Lifecycle mirrors `userNotesByTask` (promote / terminal discard / restart
+     * clear; PRESERVED across the non-terminal quota-fork/takeover discards).
+     */
+    private readonly rationaleByTask;
+    /**
+     * A1b — gate → the round number its implementor ran (set beside
+     * `taskByGateId` in `runImplementorRound`), so `submitVerdict` can stamp the
+     * verdict's `RoundFindingRecord.round`. Same append-only lifecycle as
+     * `taskByGateId` (per QuorumLoop life; bounded by the session's gate count).
+     */
+    private readonly roundByGateId;
     /** Seats with a reviewer subprocess currently running, keyed `gateId::seatId`. */
     private readonly runningSeats;
     /** Seats whose verdict has been submitted, keyed `gateId::seatId`. */
@@ -530,6 +709,60 @@ export declare class QuorumLoop {
      * desktop suppression closes the late-LOCAL-submit race. Keyed by taskId.
      */
     private readonly activeImplementorByTask;
+    /** Spawn requests that own a shadow but have not yet returned a killable handle. */
+    private readonly pendingImplementorByTask;
+    /**
+     * Exact lifecycle ownership keyed by gate, including an older generation
+     * displaced from the per-task "current" maps above. Group halt and session
+     * teardown enumerate these registries so every real pending/active process
+     * remains abortable until its own round releases ownership.
+     */
+    private readonly activeImplementorByGate;
+    private readonly pendingImplementorByGate;
+    /**
+     * Full implementor-round coroutines owned by this session. Process handles
+     * cover only the agent subprocess; capture, validation, submission, and
+     * failure cleanup continue after that leader exits. Session teardown must
+     * await this set before deleting any workspace those continuations can use.
+     */
+    private readonly implementorRoundPromises;
+    /** Exact task ownership for group-local cancellation/drain (no unrelated wait). */
+    private readonly implementorRoundPromisesByTask;
+    /**
+     * Team GateDispatch callbacks admitted before their first await. Supersede,
+     * terminal group halt, and session teardown drain this exact registry before
+     * retiring snapshots, closing the pre-round ownership gap.
+     */
+    private readonly teamDispatchAdmissionsByTask;
+    /**
+     * Per-task registration tail. Every caller publishes its immutable gate /
+     * generation intent before joining this queue, so a successor gate received
+     * while an earlier registration drains is still correlated exactly.
+     */
+    private readonly teamTaskRegistrationByTask;
+    /** Exact deterministic gate authority, retained through retirement for stale replay refusal. */
+    private readonly teamGateBindingByRunId;
+    /** All queued/active registration intents, used to publish successor fences synchronously. */
+    private readonly teamRegistrationIntentsByTask;
+    /** Terminal group ids: set synchronously before any halt await or side effect. */
+    private readonly haltedTeamGroups;
+    /** Exact non-terminal generation fences retained after a newer dispatch wins. */
+    private readonly supersededTeamRuns;
+    /**
+     * Task ids whose old generation is being aborted/drained before its newer
+     * brief is installed. GateDispatch buffers behind this synchronous barrier.
+     */
+    private readonly supersedingTeamTaskIds;
+    /**
+     * Child task ids observed for a terminal group. GateDispatch carries only the
+     * child task id, so this closes the post-halt/no-brief replay path: after the
+     * brief is retired, a late dispatch is rejected instead of being buffered as
+     * an apparently early packet. A successful registration for a different,
+     * non-halted group clears the tombstone, which keeps task-id reuse safe.
+     */
+    private readonly haltedTeamTaskIds;
+    /** Serializes exact group bundle publication against the terminal halt fence. */
+    private readonly teamBundleOpsByGroup;
     /**
      * PHASE-CP-10-MIN (#585) §2.3 / #C10M-16 — offers already resumed (the
      * dedupe set; keyed on `offer_id`, the same axis as the audit slot #C10M-4).
@@ -580,6 +813,8 @@ export declare class QuorumLoop {
      * cardinality is bounded by those same dedup sets).
      */
     private readonly taskByGateId;
+    /** Exact immutable team generation that authored each team gate. */
+    private readonly teamAuthorityByGateId;
     /**
      * GATE_DISPATCH `gateRunId`s already consumed (idempotent re-delivery dedup).
      * A sweeper / WS re-deliver of the SAME round-0 dispatch must NOT double-spawn
@@ -603,18 +838,25 @@ export declare class QuorumLoop {
      */
     private readonly recoveredGateRunIds;
     /**
-     * §4.1 — DURABLE per-track tombstone for a present-but-CORRUPT brief
+     * §4.1 — in-session per-authority tombstone for a present-but-CORRUPT brief
      * ciphertext (decrypt threw during recovery PASS 1). Blocks BOTH recovery
      * relaunch (PASS 2) AND any future LIVE `TrackAssigned`/drain for that track
      * (§4.3) — a corrupt brief must NEVER spawn an empty-brief implementor on
      * EITHER path. The track times out via the engine sweeper (bounded). Distinct
      * from a `null` `encryptedBrief` (a legit empty brief).
      *
-     * CP-12 W4 (#593 Stage-2 r2): keyed by the COMPOSITE `teamBriefKey(taskGroupId,
-     * trackIndex)`, NOT bare `trackIndex` — B.2 aggregates across groups, so a
-     * tombstone on group A's track 0 must not block group B's (valid) track 0.
+     * Round 46: keyed by complete `(taskGroupId, trackIndex, taskId,
+     * dispatchGeneration)` authority, so a corrupt predecessor cannot block a
+     * clean successor that reuses the slot.
      */
     private readonly corruptBriefTracks;
+    /**
+     * The newest fully validated recovery authority seeded for each group/index
+     * slot. It prevents an asynchronously late, older recovery response (or stale
+     * live TrackAssigned) from replacing the brief selected for a newer
+     * generation. The actual tombstone remains keyed by the complete authority.
+     */
+    private readonly recoveryAuthorityBySlot;
     /**
      * #592 PROVENANCE GUARD (2026-06-26) — the task-group ids THIS desktop
      * ORIGINATED (recorded in `armB1Recovery`, right after a successful
@@ -631,11 +873,12 @@ export declare class QuorumLoop {
      */
     private readonly ownedGroupIds;
     /**
-     * CP-12 W4 (#593 Stage-2 r2) — the composite key for `teamBriefsByKey` +
-     * `corruptBriefTracks`. `(taskGroupId, trackIndex)` so two in-flight groups
-     * that share a `trackIndex` (B.2 aggregates session-wide) never collide.
+     * Slot key for parse-time briefs and the selected recovery projection.
+     * Deletion/launch authority never uses this key alone.
      */
     private teamBriefKey;
+    private recoveryAuthorityKey;
+    private isCorruptBriefAuthority;
     /**
      * PHASE-589/469 W3.1 (C1) — the GROUP-WIDE monotonic promote-order counter,
      * keyed by `taskGroupId`. Each team track promote reserves
@@ -720,6 +963,21 @@ export declare class QuorumLoop {
      * This also makes concurrent B.1+B.2 safe (no per-op toggle race).
      */
     private recoverySeedingDepth;
+    /**
+     * Every asynchronously delivered session coroutine that can reach a task
+     * workspace: Class-B consumption, shadow recovery, and B.1/B.2 team
+     * recovery. Admission is synchronous and closes when `shuttingDown` flips.
+     * Disposal drains this set before it enumerates task resources, so no
+     * accepted callback can mutate a map or filesystem after the boundary.
+     */
+    private readonly sessionWorkPromises;
+    private readonly sessionWorkAdmissions;
+    /** TaskAuthorized callbacks accepted before shutdown may finish promotion. */
+    private readonly terminalClassBAdmissionsByTask;
+    private trackExistingSessionWork;
+    private startSessionWork;
+    private admittedSessionWorkMayContinue;
+    private trackTeamRecovery;
     /**
      * §4.3 — TEAM Class B packets buffered while the recovery seed barrier is up
      * (`recoverySeedingDepth > 0`). Drained through the normal live handlers AFTER
@@ -783,25 +1041,28 @@ export declare class QuorumLoop {
      */
     private readonly shadowsByTask;
     /**
-     * PHASE-598 (Codex impl-r5 / LOCK #598-11) — the REVIEWED diff snapshot per TEAM
-     * task, stored when a round's gate goes live (reviewers dispatched). `promoteShadow`
-     * fails-closed if the live shadow drifts from it before promote — the airtight
-     * backstop for a declared test that spawns a DETACHED writer (the test runner waits
-     * only on the direct child, so such a writer can mutate the shadow AFTER the
-     * post-test re-capture passes but BEFORE promote). Presence ⇔ team task: single-impl
-     * never stores, so its promote path is unchanged. Cleared on promote/discard.
+     * Session-sticky task ids whose snapshots this loop may retire. The set does
+     * not shrink when an in-memory map entry is cleared: normal teardown performs
+     * a fresh durable enumeration and must still recognize an interrupted exact
+     * marker. It also prevents one embedded shell from adopting another shell's
+     * same-workspace snapshot merely because both share a state root.
+     */
+    private readonly workspaceTaskIdsOwned;
+    /**
+     * In-session terminal retirement tombstones. A recovery scan that started
+     * before a terminal discard/promote must not reinstall its stale instance
+     * after that terminal operation wins the task mutex.
+     */
+    private readonly terminallyRetiredWorkspaceTasks;
+    /**
+     * In-memory cache of the crash-durable reviewed artifact for every task. The
+     * authoritative copy lives in the private snapshot marker and is persisted
+     * before submission; promotion always re-reads that copy. Cleared with the
+     * instance on promote/discard.
      */
     private readonly reviewedSnapshotByTask;
     /** Guards concurrent shadow-create for the same task (round-0 + an early re-deliver). */
     private readonly shadowCreateInFlight;
-    /**
-     * CP-14 Wave A — the ONE pinned base SHA per task group (`worktree_merge`),
-     * captured (memoized) at the first track of the group BEFORE any shadow is
-     * created, so EVERY track branches from the same base → a deterministic
-     * merge-train input (Stage-1 plan-review MED-3). Promise-memoized so concurrent
-     * track registrations share a single `git rev-parse HEAD`.
-     */
-    private readonly groupBaseShaInFlight;
     /**
      * Per-task async MUTEX for shadow LIFECYCLE mutations (restart-race fix,
      * 2026-06-11 Stage-2 Codex r2). A promise-chain serializes EVERY map/stateDir-
@@ -818,10 +1079,12 @@ export declare class QuorumLoop {
      * sequencing layer (errors propagate to the OWNING caller, never poison the
      * chain for the next op), and clears the entry once the tail it stored is the
      * one that settled (so an idle task leaks no entry). The serialized region is
-     * fs/git-only with NO nested `runExclusiveShadowOp` call (the wrapped methods
+     * filesystem-only with NO nested `runExclusiveShadowOp` call (the wrapped methods
      * never call each other), so it cannot self-deadlock.
      */
     private readonly shadowOpsByTask;
+    /** Once set, no new implementor workspace may be created for this session. */
+    private shuttingDown;
     /**
      * Serialize one shadow lifecycle op for `taskId` behind any in-flight op for
      * the same task. The op's result/rejection is returned to ITS caller; a
@@ -830,6 +1093,30 @@ export declare class QuorumLoop {
      * appended is still the current tail (no later op queued behind us).
      */
     private runExclusiveShadowOp;
+    private static sameTeamAuthority;
+    private static teamAuthorityKey;
+    private static teamAuthorityForEntry;
+    private static immutableTeamTaskEntry;
+    private static sameTeamTaskEntry;
+    private publishTeamRegistrationIntent;
+    private releaseTeamRegistrationIntent;
+    private refreshTeamSupersedingFence;
+    private hasQueuedNewerTeamRegistration;
+    private retireTeamGateBindings;
+    private teamAuthorityForTask;
+    private teamRunIsHalted;
+    private teamEntryMayContinue;
+    private admitTeamDispatch;
+    private drainTeamDispatchAdmissions;
+    private runTeamBundlePublication;
+    /**
+     * Retire one older team dispatch generation before installing its successor.
+     * The exact authority fence is published synchronously, then every pending /
+     * active real handle and the complete round continuation is drained. The old
+     * snapshot is removed only after process ownership is proven empty.
+     */
+    private retireSupersededTeamRun;
+    private rememberWorkspaceLifecycleFailure;
     /**
      * The last terminal workspace outcome (promote / discard) this loop applied,
      * for the `summarize_current_status` shell answer (Fix 2). RELATIVE file paths
@@ -904,6 +1191,15 @@ export declare class QuorumLoop {
     } | {
         kind: 'discarded';
     } | null;
+    /**
+     * Session-owned Class-B ingress. The subscription calls this wrapper instead
+     * of invoking the LocalExecutor directly, making delivery admission atomic
+     * with the teardown fence. A packet accepted before shutdown is drained;
+     * packets delivered after shutdown are ignored before verification or side
+     * effects. TaskAuthorized gets a narrow terminal admission so its already-
+     * delivered promote can finish before disposal enumerates the task.
+     */
+    consumeClassB(packet: ClassBInbound, envelopeTaskId?: string): Promise<void>;
     /** The DI callbacks the shell wires into its ClassBConsumer. */
     classBConsumerDeps(): {
         classBSignatureVerifier: (packet: import('../local-executor/types').ClassBInbound) => Promise<boolean>;
@@ -1000,14 +1296,15 @@ export declare class QuorumLoop {
      */
     setTeamAttachments(taskGroupId: string, attachments: ImageAttachment[]): void;
     /**
-     * CP-12 W2.b (§3.C.3) — read the brief for `(taskGroupId, trackIndex)`. The
+     * CP-12 W2.b (§3.C.3) — read the brief for a team track. The
      * `registerTeamTask` bridge (wired in the shell) reads this when `TrackAssigned`
      * correlates a track to its child `task_id`; recovery PASS 2 reads it for a
      * relaunched track. Empty string when the user issued no `description` for the
      * track (a track with no brief runs an empty-brief round-0; the engine's #EF-1
-     * born-halt surfaces it). Composite-keyed (#593 Stage-2 r2) — see `teamBriefKey`.
+     * born-halt surfaces it). Recovery callers pass task/generation so the
+     * complete-authority store is consulted; two-argument calls are diagnostic.
      */
-    getTeamBrief(taskGroupId: string, trackIndex: number): string;
+    getTeamBrief(taskGroupId: string, trackIndex: number, taskId?: string, dispatchGeneration?: number): string;
     /**
      * CP-12 W2.b (§3.C.3 / M5) — the brief→task_id bridge. `launchTrack` calls this
      * at `TrackAssigned` (the FIRST surface carrying both `track_index` AND the
@@ -1024,10 +1321,19 @@ export declare class QuorumLoop {
         agent: AgentKind;
         taskGroupId: string;
         trackIndex: number;
+        /** Optional only for direct legacy test/recovery callers. */
+        dispatchGeneration?: number;
+        /**
+         * Recovery/direct-call correlation when the caller already has the
+         * engine gate id. Live TrackAssigned callers omit it and use the exact
+         * deterministic engine formula.
+         */
+        gateRunId?: string;
         writePaths: string[];
         autoModifiedFiles: string[];
         testSurfaces: string[];
-    }): Promise<void>;
+    }): Promise<'accepted' | 'refused'>;
+    private registerTeamTaskBriefOwned;
     /**
      * CP-12 W2.b (§3.C.2) — the TEAM analogue of the single-impl round-0 spawn.
      * Routes by the OUTER envelope's `task_id` (the payload has none): resolves
@@ -1059,19 +1365,11 @@ export declare class QuorumLoop {
     private replaceShadowForRound0Locked;
     /**
      * CP-14 P1 — the team execution model this session SIGNALS on
-     * `createTaskGroup` (`executionModel`). Always `worktree_merge` since the
-     * §10 retirement (2026-07-03): overlapping-track dispatch with the
-     * merge-train + the server contract gate as the authority.
+     * `createTaskGroup` (`executionModel`). `worktree_merge` is retained as the
+     * wire label; locally it means reviewed bundles integrated in a disposable
+     * filesystem snapshot, with no Git requirement.
      */
     teamExecutionModel(): TeamExecution;
-    /**
-     * CP-14 Wave A — the ONE pinned group base SHA (memoized): `git rev-parse HEAD`
-     * in the workspace, captured at the FIRST track of the group, BEFORE any track
-     * shadow/branch is created, so every track roots at the same base (Stage-1
-     * MED-3). Concurrent callers share one rev-parse via the in-flight promise.
-     * Throws if HEAD can't be resolved (a non-git workspace is ineligible upstream).
-     */
-    private ensureGroupBaseSha;
     /**
      * CP-1.f execute-first (§4) — ensure the per-task SHADOW exists, creating it
      * BEFORE the round-0 spawn. Idempotent: round-0 + an early GATE_DISPATCH
@@ -1101,6 +1399,8 @@ export declare class QuorumLoop {
         agent: AgentKind;
         sessionKey: string;
         mode?: ImplementorMode;
+        /** Immutable team-generation authority captured at packet admission. */
+        teamAuthority?: TeamRunAuthority;
         /**
          * CP-12 W2.b (§3.C.2b option a / H3) — TEAM only. After `captureDiff` and
          * BEFORE submit, validate every changed file against the track's declared
@@ -1116,13 +1416,27 @@ export declare class QuorumLoop {
             testSurfaces: string[];
             trackIndex: number;
         };
+        /**
+         * A1b — the implementor's OWN summary from the prior round, threaded by
+         * `handleReviseFeedback` so the revise implementor does not re-derive its
+         * own reasoning. Appended to the STDIN payload ONLY (self-visibility) —
+         * NEVER to `args.brief`, which becomes the execute-first `task_brief`
+         * rendered into the reviewer prompts (OQ-REVIEWER-RATIONALE: GA reviewers
+         * see NO rationale; the flag-gated reviewer path is separate).
+         */
+        priorRationale?: {
+            round: number;
+            text: string;
+        };
     }): Promise<void>;
+    private runImplementorRoundOwned;
     /**
      * Extract the agent's informational stdout summary (audit-only; reviewers
      * never see it — they review the captured diff). Best-effort: a failure to
      * read the summary is NON-fatal (the diff is the source of truth). For Codex
-     * the clean reply is the `--output-last-message` temp file; for Gemini it is
-     * the JSON envelope's `.response`; Claude `--print` is clean stdout.
+     * the clean reply is the `--output-last-message` temp file; Claude
+     * `--print --output-format json` is unwrapped to `.result`. (Gemini was SUNSET
+     * in 2026-07 — its JSON-envelope unwrap branch was removed; it is never spawned.)
      */
     private extractAgentSummary;
     /**
@@ -1164,6 +1478,17 @@ export declare class QuorumLoop {
      * `gateId` is the track's CURRENT round-N reviewer_quorum gate; REQUIRED for a
      * revisable reason (the engine rejects a revisable marker without it). The
      * TERMINAL-reason callers omit it.
+     *
+     * @returns `autoRevised` — whether the engine's AUTHORITATIVE returned
+     * `trackState` was non-`Failed` (W2 auto-revise: the track stays InFlight and
+     * a `REVISE_FEEDBACK` for the SAME taskId follows). A1b (Stage-2 R2 Codex
+     * MEDIUM-1): the revisable-reason callers key their `discardShadow`
+     * `preserveReviseContext` on THIS, so an auto-revised track's revise round
+     * still sees the accumulated notes/history/rationale, while a genuinely
+     * terminal track (Failed return, thrown/absent marker → state unknown, no
+     * taskGroupId) clears as before. A thrown marker whose write actually landed
+     * server-side is the one lossy edge (the engine may revise while the desktop
+     * cleared) — that degrades to the pre-A1b contextless brief, never worse.
      */
     private reportTeamTrackFailure;
     /**
@@ -1204,6 +1529,21 @@ export declare class QuorumLoop {
      * `TaskGroupHalted` convergence is the authoritative group resolution).
      */
     reportTeamTrackUserResolved(taskId: string, postAction: PostDecisionAction): void;
+    /**
+     * Authoritative TaskGroupHalted bridge from LocalExecutor. Calling this async
+     * method publishes the terminal group fence synchronously (before its first
+     * await), then stops the actual QuorumLoop-owned pending/active implementors,
+     * drains their complete round coroutines and bundle publications, and retires
+     * every exact snapshot for the halted generation.
+     */
+    haltTeamTaskGroup(input: {
+        taskGroupId: string;
+        members: readonly {
+            taskId: string;
+            trackIndex: number;
+            dispatchGeneration: number;
+        }[];
+    }): Promise<void>;
     /**
      * CP-1.f execute-first — discard the task's shadow (a non-TaskAuthorized
      * terminal). Best-effort: a teardown failure is logged + leaves the durable
@@ -1233,7 +1573,38 @@ export declare class QuorumLoop {
      * runImplementorRound) the behavior is exactly as before — discard whatever is
      * currently mapped for the task.
      */
-    discardShadow(taskId: string, expected?: WorkspaceShadow): Promise<void>;
+    discardShadow(taskId: string, expected?: WorkspaceShadow, opts?: {
+        /**
+         * A1b (Stage-2 R1 Codex MEDIUM-1) — set by the NON-terminal discard
+         * callers where the TASK continues on the SAME taskId after the shadow
+         * is gone: the quota fork (`handleQuotaExhaustedFork` → continuation →
+         * `resumeFromContinuation(input.taskId)`) and the four mid-round
+         * `handoffClaimed` takeover suppressions (a `/continue request` /
+         * foreign-accept claims the handoff, then the continuation resumes the
+         * same task). On those paths the accumulated revise context — binding
+         * user notes, structured findings history, implementor rationale — MUST
+         * survive into the resumed rounds; wiping it here was exactly the
+         * "resume starts amnesiac" defect. Terminal discards (user
+         * reject/abort, policy rejection, born-halt, round failure,
+         * all-agents-exhausted) omit this and clear as before. If the user
+         * DECLINES the continuation offer, the preserved maps simply linger
+         * until the task's eventual terminal (bounded: per-task caps), or
+         * process end — an accepted, documented residual.
+         */
+        preserveReviseContext?: boolean;
+        /**
+         * P10 E3 r4 (Stage-1 r4 M-1) — set by `onTerminalDecision` for the
+         * `restart_proposal` discard ONLY: the restart reuses the SAME taskId
+         * and runs a fresh round-0, so the `discarded` closer must NOT carry
+         * the taskId (a stamped closer would flip the session-listing record
+         * to 'cancelled' and the M3 no-resurrect guard would lock it there —
+         * even after the restarted task promotes). Deliberately does NOT touch
+         * the revise-context clear or `terminallyRetiredWorkspaceTasks` — a
+         * restart is a fresh round-0 (context cleared as before); ONLY the
+         * listing stamp is suppressed.
+         */
+        taskContinues?: boolean;
+    }): Promise<void>;
     private discardShadowLocked;
     /**
      * CP-1.f execute-first (#PR-1/#PR-3) — promote the task's shadow onto the real
@@ -1374,9 +1745,8 @@ export declare class QuorumLoop {
      *     path (that defeats the moat).
      *
      * TRI-STATE (decided here, mirroring the implementor LE):
-     *   1. No engager wired OR `CODEVIBE_SANDBOX_REVIEWERS` not opted in (DEFAULT
-     *      OFF; opt in with `=1`/`=true`) → LEGACY (byte-identical non-regression).
-     *      No badge.
+     *   1. No engager wired OR `CODEVIBE_SANDBOX_REVIEWERS=0` opted out (the gate
+     *      DEFAULTS ON — R7 A4) → LEGACY (byte-identical non-regression). No badge.
      *   1b. No resolvable taskId (cannot scope a per-task broker) → LEGACY + a
      *      reduced-trust badge (Stage-2 r1 Codex LOW — a trust-downgrade must be
      *      VISIBLE, never a silent ambient-cred fallback; see
@@ -1409,8 +1779,8 @@ export declare class QuorumLoop {
     private surfaceReviewerReducedTrust;
     /**
      * Wave B §2.1 confinement TRI-STATE for a merge-gate model/reviewer invocation
-     * (LOCK #C14-MOAT). Path A: the CP-7 substrate/broker (opted in + a Trusted agent
-     * + engage succeeds → a handle; no ambient vendor cred in the child). Path B: a
+     * (LOCK #C14-MOAT). Path A: the CP-7 substrate/broker (not opted out + a Trusted
+     * agent + engage succeeds → a handle; no ambient vendor cred in the child). Path B: a
      * trusted-container boundary (legacy spawn confined by the OUTER container — the
      * dogfood/E2E path). Path C: neither → NOT confined. A path-A engage that
      * throws/reduced-trusts falls through to B/C (both safe: B confined, C refuses),
@@ -1431,6 +1801,37 @@ export declare class QuorumLoop {
         caller: ConflictModelCaller;
         teardown: () => Promise<void>;
     } | null>;
+    /**
+     * A1d (Stage-2 R1 Codex MED) — the RESOLVER-SPECIFIC construction probe:
+     * can the DISPATCH-time `requireConfined` engage establish a confining
+     * substrate on this host? Wire-vs-legacy ONLY — the dispatch's own engage
+     * (`spawnImplementor({ requireConfined: true })`) remains the sole
+     * load-bearing gate; a probe mistake can never yield an unconfined spawn.
+     *
+     *   - A real §6 Q2 ladder tier (`sandbox_exec` / `docker`) → ESTABLISHABLE.
+     *     A5 covers EVERY agent: the CP-7 broker substrate for the
+     *     provider-backed agents (CLAUDE/CODEX) AND the A1d write-confined
+     *     resolver row for the broker-less agents (GEMINI/ANTIGRAVITY). The
+     *     docker tier covers the provider-backed agents; a broker-less track's
+     *     slot on that tier fail-closes at dispatch to the clean
+     *     `dispatch_unconfined` human-gate (FD-2) — no worse than unwired for
+     *     that slot, and it does not block provider-backed slots in the group.
+     *   - No tier + trusted container → ESTABLISHABLE (the PRESERVED
+     *     D5-AMEND-1 posture: the closure wires and every slot fail-closes
+     *     cleanly at dispatch — dogfood-verified 2026-07-03, 101ms human-gate).
+     *   - No tier, no container → NOT establishable → the closure stays
+     *     unwired, keeping today's IMMEDIATE legacy human-gate instead of
+     *     converting it into a per-slot spawn-time fail-close.
+     *
+     * Deliberately DECOUPLED from `engageWaveBConfinement` and its
+     * `CODEVIBE_SANDBOX_REVIEWERS` gate (default-ON, `=0` opts out — R7 A4):
+     * that flag gates REVIEWER sandboxing (per-seat, `makeConflictModelCaller`,
+     * Tier-2) exactly as before — riding
+     * it here made the A1d resolver row unreachable on the default bare host.
+     * The ladder select is side-effect-free (no launch, no broker); test seams
+     * via `deps.resolverProbeDeps`.
+     */
+    private probeResolverDispatchConfinement;
     /**
      * CP-14 WB2 §2.1/§2.2/§2.3 — build the AGENTIC class-2 resolver, or `null` on
      * path C (no confinement). When wired, a slot's class-2 conflicts are resolved
@@ -1438,11 +1839,19 @@ export declare class QuorumLoop {
      * disposable repo, then fd-safe selective-importing ONLY the conflicted files.
      * SECURITY-CRITICAL — fail-closed on BOTH layers:
      *
-     *   1. CONSTRUCTION-time (mirrors `makeConflictModelCaller` returning null): probe
-     *      `engageWaveBConfinement` ONCE against the loop workdir; path C → return
-     *      `null` → `resolveAgentic` is NOT set on the context → a fresh class-2
-     *      conflict takes the legacy `caller` path (which on path C is the
-     *      CONFINEMENT-UNAVAILABLE caller → human-gate). Byte-identical to today.
+     *   1. CONSTRUCTION-time — the RESOLVER-SPECIFIC probe (A1d, Stage-2 R1 Codex
+     *      MED): `probeResolverDispatchConfinement` wires the closure iff the
+     *      DISPATCH-time engage could establish a confining substrate on this
+     *      host (a real §6 Q2 ladder tier, or the preserved trusted-container
+     *      posture). Deliberately DECOUPLED from `engageWaveBConfinement`'s
+     *      `CODEVIBE_SANDBOX_REVIEWERS` gate (default-ON post-R7-A4) — that flag
+     *      gates REVIEWER
+     *      sandboxing (seat/`makeConflictModelCaller`/Tier-2, unchanged), and
+     *      riding it here made the A1d write-confined resolver row unreachable
+     *      on the default bare-host path. Unwired → return `null` →
+     *      `resolveAgentic` is NOT set on the context → a fresh class-2 conflict
+     *      takes the legacy `caller` path (which on path C is the
+     *      CONFINEMENT-UNAVAILABLE caller → human-gate).
      *   2. DISPATCH-time (Stage-2 Codex HIGH — confinement BOUND TO THE ACTUAL SPAWN):
      *      `dispatchImplementor` spawns with `requireConfined: true`, so
      *      `LocalExecutor.spawnImplementor` → `engageSubstrateForSpawn` THROWS
@@ -1536,6 +1945,26 @@ export declare class QuorumLoop {
      * re-delivered packet (or the next live edge) promotes it.
      */
     recoverShadows(): Promise<void>;
+    private recoverShadowsOwned;
+    /**
+     * Session-exit ownership boundary. Stop future creates, wait behind every
+     * in-flight per-task lifecycle operation, then synchronously reclaim each
+     * live snapshot. Startup TTL cleanup remains only the SIGKILL/power-loss
+     * fallback, not normal lifecycle management.
+     */
+    private reconcileUnresolvedBundleRetention;
+    private retireExactShadow;
+    /**
+     * Strict, exhaustive cleanup for task ids this loop owns. It first attempts
+     * every mapped exact instance, then performs a fresh authenticated marker
+     * enumeration and reopens/retire any same-task instance absent from memory.
+     * A final fresh enumeration is the convergence proof. Live foreign owners and
+     * unresolved authority are preserved, but returned as explicit failures.
+     */
+    private cleanupOwnedTaskSnapshots;
+    disposeWorkspaces(opts?: {
+        strict?: boolean;
+    }): Promise<void>;
     /**
      * §4.3 — true while a team recovery is seeding briefs (the startup barrier is
      * down). The Class B consume path checks this to BUFFER a live TEAM packet
@@ -1545,17 +1974,18 @@ export declare class QuorumLoop {
      */
     isRecoverySeeding(): boolean;
     /**
-     * §4.3 (Stage-2 r1 Codex MED) — true if `(taskGroupId, trackIndex)` carries a
-     * corrupt-brief TOMBSTONE. The LE consults this at the TOP of `launchTrack`
+     * §4.3 (Stage-2 r1 Codex MED) — true if the complete team generation carries
+     * a corrupt tombstone or is stale relative to recovered authority. The LE
+     * consults this at the TOP of `launchTrack`
      * (before any register / spawn / lease-renewing progress emit) so a tombstoned
      * track is refused on the LIVE path as early as on the recovery path — never
      * spawning an empty-brief implementor or mutating registry state for it. The
      * engine sweeper times the un-launched track out (bounded).
      *
-     * CP-12 W4 (#593 Stage-2 r2): keyed by `(taskGroupId, trackIndex)` so a corrupt
-     * brief in group A never blocks a different group B's track with the same index.
+     * Production supplies taskId + dispatchGeneration. The optional form remains
+     * only for backward-compatible diagnostics/tests.
      */
-    isTrackTombstoned(taskGroupId: string, trackIndex: number): boolean;
+    isTrackTombstoned(taskGroupId: string, trackIndex: number, taskId?: string, dispatchGeneration?: number): boolean;
     /**
      * #592 PROVENANCE GUARD (live path) — true if `taskGroupId` is a team group this
      * desktop did NOT originate AND this desktop owns ≥1 group. Wired to the LE's
@@ -1659,6 +2089,8 @@ export declare class QuorumLoop {
      * so this method just seeds + relaunches (it is always invoked under a barrier
      * that is already down, and may run multiple times within one barrier window).
      */
+    private normalizeTeamRecoveryRow;
+    private normalizeTeamRecoveryRows;
     recoverTeamTracks(rows: TeamTrackRecoveryRow[]): Promise<void>;
     /**
      * §4.1 PASS 2 (one row) — validate → recoverLaunchTrack → repair-on-duplicate →
@@ -1717,20 +2149,44 @@ export declare class QuorumLoop {
      * literal NEVER appearing in this file. The branch is `NODE_ENV==='test'`-gated
      * so it is never evaluated in prod regardless.
      */
+    /**
+     * #585 §5.5 / L2 + GA [A2] — parse the force-quota test seam's VALUE grammar.
+     * Returns `null` outside `NODE_ENV === 'test'` or when the fragment-assembled
+     * force-quota env var is unset. The env-var KEY is assembled from fragments so
+     * the force-quota literal NEVER appears verbatim in the published bundle (the
+     * `verify-no-test-hooks` CI grep asserts its absence); the whole gate is ALSO
+     * `NODE_ENV==='test'`-gated so it is never evaluated in prod.
+     *
+     * Value grammar (GA [A2] additive extension — same env var, no new hook, so
+     * the hostile-grep list is unchanged):
+     *   - `<AGENT>`          — classic mode: synthetic quota stderr + forced
+     *                          EMPTY diff → drives the born-halt continuation
+     *                          fork (the `continuation-handoff-quota` E2E).
+     *   - `<AGENT>:partial`  — mid-task partial-diff mode: synthetic quota
+     *                          stderr, but the captured diff is KEPT so the
+     *                          loop's submit-partial-to-review degradation is
+     *                          exercised instead of the fork (an implementor
+     *                          quota-killed MID-TASK with partial work present).
+     * Both segments are case-insensitive.
+     */
+    private forcedQuotaSpec;
     /**
      * #585 §5.5 / L2 — the SINGLE source of the force-quota test gate. Returns true
      * when (a) `NODE_ENV === 'test'` AND (b) the fragment-assembled force-quota env
-     * var names `agent`. The env-var KEY is assembled from fragments so the
-     * force-quota literal NEVER appears verbatim in the published bundle (the
-     * `verify-no-test-hooks` CI grep asserts its absence);
-     * the whole gate is ALSO `NODE_ENV==='test'`-gated so it is never evaluated in
-     * prod. Drives BOTH the synthetic quota stderr (`resolveQuotaClassificationText`)
-     * AND the forced empty-diff born-halt (`runImplementorRound` capture site) — the
-     * two halves that make the `continuation-handoff-quota` E2E reproducible (a real
-     * model will not deterministically exit with NO diff, which the quota fork
-     * requires).
+     * var names `agent` (either value-grammar mode — see `forcedQuotaSpec`).
+     * Drives BOTH the synthetic quota stderr (`resolveQuotaClassificationText`)
+     * AND the capture-site diff handling (`runImplementorRound`): classic mode
+     * forces the EMPTY-diff born-halt (a real model will not deterministically
+     * exit with NO diff, which the quota fork requires); `:partial` mode keeps
+     * the captured diff (GA [A2] — validates submit-partial-to-review).
      */
     private isForcedQuotaAgent;
+    /**
+     * GA [A2] — true when the force-quota seam is armed in `:partial` mode (see
+     * `forcedQuotaSpec` grammar). Only meaningful alongside `isForcedQuotaAgent`;
+     * prod-unreachable through the same `NODE_ENV==='test'` gate.
+     */
+    private isForcedQuotaPartialDiffMode;
     /**
      * Test seam — force the ROUND-0 implementor agent (overriding the session
      * default). `NODE_ENV==='test'`-gated; the env key is fragment-assembled so the
@@ -1799,6 +2255,7 @@ export declare class QuorumLoop {
         decision: string;
         action: PostDecisionAction;
     }): Promise<void>;
+    private onApplyUserDecisionEchoOwned;
     /**
      * #585 §3.5 / #C10M-11/13 — resume the task with the user's chosen agent.
      * The SERVER has ALREADY minted the `nextGateId` row + advanced to
@@ -1815,6 +2272,7 @@ export declare class QuorumLoop {
     resumeFromContinuation(input: {
         taskId: string;
         targetAgent: AgentKind;
+        sourceGateId?: string;
         nextGateId: string;
         nextRound: number;
     }): Promise<boolean>;
@@ -1864,6 +2322,61 @@ export declare class QuorumLoop {
      * user requirement.
      */
     private buildReviseBrief;
+    /**
+     * A1b — append one structured reviewer verdict to the task's findings
+     * history (called from `submitVerdict`). Per-field caps bound each record
+     * (reasoning ≤ HISTORY_REASONING_MAX_CHARS, each suggestion ≤
+     * HISTORY_SUGGESTION_MAX_CHARS); a per-(task, round) SOFT byte cap degrades
+     * later same-round records to verdict-only stubs (seat + verdict stay
+     * visible; the byte-heavy narrative is dropped) so a pathological panel can
+     * never balloon the in-memory history.
+     */
+    private recordRoundFinding;
+    /**
+     * A1b — record the implementor's own per-round summary as its rationale,
+     * stamped with the round that produced it (LOW-4). Empty/whitespace
+     * summaries are skipped (the entry's ABSENCE is what keeps labels honest —
+     * a later consumer renders the newest entry's OWN round, never an inferred
+     * one); each entry is char-capped and the per-task list keeps only the
+     * newest RATIONALE_MAX_ENTRIES (defensive — a task's round count is already
+     * bounded upstream).
+     */
+    private recordImplementorRationale;
+    /**
+     * A1b — the task's accumulated rationale as ONE bounded string (newest
+     * entries win: oldest are dropped first, and the survivor text is hard
+     * byte-capped). `null` when the task has no rationale (or no task resolved)
+     * so callers can keep their no-rationale shape byte-identical.
+     */
+    private boundedRationale;
+    /**
+     * A1d / P2 resolver-intent (design §5/§8.1) — build the bounded INTENT
+     * projection for one agentic slot resolve:
+     *
+     *   - "each track's brief + task intent" → the INCOMING track's brief
+     *     (THEIRS) + the group's other registered tracks' briefs (OURS — the
+     *     integration tip is the base plus the already-merged tracks), from the
+     *     desktop-local `activeBriefByTask` registry (never on the wire), each
+     *     capped to `RESOLVER_TRACK_BRIEF_MAX_BYTES`.
+     *   - "both tracks' intent diffs" → bounded `base→theirs` / `base→ours`
+     *     hermetic diffs (≤ `RESOLVER_INTENT_DIFF_MAX_BYTES` per side). An
+     *     over-budget/unreadable side degrades to a placeholder line; a
+     *     binary/non-UTF-8-bearing diff (NUL / U+FFFD) likewise (mirrors the
+     *     Tier-2 bundle's placeholder discipline). `baseSha` absent (the
+     *     reconstruction-replay caller) → no diffs.
+     *
+     * GRACEFUL-DEGRADE, never gating: intent is an ADDITIVE projection — a
+     * failure to compute any piece must not human-gate a resolve that succeeds
+     * without it (the final-tip Tier-2 gate re-reviews fail-closed regardless).
+     */
+    private buildResolverIntentContext;
+    /**
+     * A1b — the newest recorded rationale entry for a task (or undefined),
+     * shaped for `runImplementorRound`'s `priorRationale`. The label is the
+     * entry's OWN recorded round (LOW-4) — never an inferred `nextRound - 1`,
+     * which drifts when the immediately previous round produced no summary.
+     */
+    private latestPriorRationale;
     /** @internal — test introspection. */
     get _runningSeatsForTests(): ReadonlySet<string>;
     /** @internal — test introspection. */
@@ -1872,6 +2385,19 @@ export declare class QuorumLoop {
     _setActiveTaskForTests(taskId: string, brief?: 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. */
+    _roundHistoryForTests(taskId: string): readonly RoundFindingRecord[];
+    /** @internal — A1b: read a task's accumulated implementor rationale entries. */
+    _rationaleForTests(taskId: string): readonly RationaleEntry[];
+    /** @internal — A1b: the bounded rationale slice a resolver/reviewer consumer gets. */
+    _boundedRationaleForTests(taskId: string | undefined, maxBytes: number): string | null;
+    /** @internal — A1d: the bounded resolver-intent projection for one slot resolve. */
+    _buildResolverIntentContextForTests(args: {
+        implementorTaskId: string;
+        oursCommit: string;
+        theirsCommit: string;
+        baseSha?: string;
+    }): Promise<ResolverIntentContext>;
     /** @internal — read the consumed REVISE_FEEDBACK dedup ids (Stage-2 r1 guard). */
     get _seenReviseFeedbackIdsForTests(): ReadonlySet<string>;
     /** @internal — read the live in-memory shadow handle for a task (or undefined). */
@@ -1897,4 +2423,4 @@ export declare class QuorumLoop {
     _replaceShadowForRound0UnlockedForTests(taskId: string): Promise<void>;
     _ensureShadowUnlockedForTests(taskId: string): Promise<WorkspaceShadow>;
 }
-export { reviewerAgentToLeAgent };
+export { reviewerAgentToLeAgent, renderAgenticResolveBrief };