@quantiya/codevibe-core 2.0.1 → 2.0.2

package/dist/orchestration-shell/audit-browser.d.ts

@@ -0,0 +1,115 @@
+/** Fail-closed payload line (routing step 3 + decrypt failure). */
+export declare const ENTRY_DETAILS_UNAVAILABLE = "Entry details unavailable";
+/** Empty/sparse chain empty-state. */
+export declare const NO_AUDIT_ENTRIES = "No audit entries yet.";
+/** queryAudit error / 1 MB overflow empty-state. */
+export declare const AUDIT_LOG_TOO_LARGE = "Audit log too large to display here \u2014 export coming soon";
+/** Screen title. */
+export declare const AUDIT_LOG_TITLE = "Audit log";
+/** Max interstitial headline (non-Max → render this + the existing upgrade CTA). */
+export declare const AUDIT_BROWSER_MAX_HEADLINE = "The audit browser is a Max feature";
+/**
+ * The SINGLE shared client constant naming which `kind`s may render directly
+ * from a non-envelope plaintext payload (shared-contract §3 step 2). Today
+ * exactly `task_authorized`. Any other non-envelope payload FAILS CLOSED.
+ * A future CP-9/CP-12 wire-public kind must be added here explicitly before
+ * it renders plaintext — the default for "plaintext I don't recognize" is
+ * suppress-not-show (zero-knowledge defense).
+ */
+export declare const WIRE_PUBLIC_PLAINTEXT_KINDS: ReadonlySet<string>;
+/**
+ * `auditKindCopy` — every key is a REAL serde wire label from the Rust enum
+ * (`codevibe-audit/src/lib.rs:121-337`, `#[serde(rename_all = "snake_case")]`).
+ * The `audit-browser.test.ts` asserts every key is in the canonical wire-label
+ * set (so a typo can't silently ship). Unknown/future kind → the raw snake_case
+ * string (see `auditKindLabel`), never blank.
+ */
+export declare const auditKindCopy: Readonly<Record<string, string>>;
+/** Humanize a wire kind via `auditKindCopy`; unknown/future → raw snake_case. */
+export declare function auditKindLabel(kind: string): string;
+/**
+ * The minimal content-decrypt primitive the router needs — structurally
+ * compatible with `cryptoService.decryptContent(ciphertextB64, sessionKeyB64)`.
+ * Injected so the parity test runs with a mock (no live crypto).
+ */
+export type DecryptContentFn = (encryptedB64: string, sessionKeyBase64: string) => string;
+/** How a single entry's payload resolved (§3). */
+export type AuditEntryRouteStatus = 'decrypted' | 'plaintext' | 'unavailable';
+/** A reviewer-verdict suggested-change / finding row (untruncated). */
+export interface AuditReviewerVerdictModel {
+    /** Display label for the 4-value verdict via `decisionCopy` (unknown → raw). */
+    readonly decisionLabel: string;
+    /** Seat / role / agent provenance line, or null when absent. */
+    readonly provenance: string | null;
+    /** The UNTRUNCATED reviewer reasoning, or null when absent. */
+    readonly reasoning: string | null;
+    /** Each suggested-changes entry (untruncated), or empty. */
+    readonly suggestedChanges: ReadonlyArray<string>;
+}
+/** A `task_authorized` wire-public plaintext authority model. */
+export interface AuditTaskAuthorizedModel {
+    readonly authorizedAction: string | null;
+    readonly authorityScope: string | null;
+    readonly authorityExpiresAt: string | null;
+    readonly approvalEventId: string | null;
+}
+/** The render model for ONE audit entry (§4). */
+export interface AuditEntryModel {
+    /** Per-entry stable key (timestamp + entryId fallback). */
+    readonly entryId: string;
+    /** Humanized kind label (`auditKindCopy`; unknown → raw snake_case). */
+    readonly kindLabel: string;
+    /** Raw snake_case kind (for tests / forward-compat display). */
+    readonly kind: string;
+    /** RFC3339 timestamp (header line), or null when absent. */
+    readonly timestamp: string | null;
+    /** How the payload resolved. */
+    readonly status: AuditEntryRouteStatus;
+    /**
+     * The neutral payload line shown when `status === 'unavailable'`
+     * (`Entry details unavailable`), else null.
+     */
+    readonly unavailableLine: string | null;
+    /** Reviewer-verdict full review (only `reviewer_verdict_recorded`), or null. */
+    readonly reviewerVerdict: AuditReviewerVerdictModel | null;
+    /** `task_authorized` authority scalars, or null. */
+    readonly taskAuthorized: AuditTaskAuthorizedModel | null;
+    /**
+     * Best-effort pretty-printed JSON of an ALREADY-SAFE payload (a decrypted
+     * envelope OR an allow-listed plaintext) that didn't match its expected
+     * per-kind shape, OR an unknown-but-ENVELOPE kind. NEVER set for a
+     * fail-closed entry. Null when a structured model rendered instead.
+     */
+    readonly rawJson: string | null;
+}
+/**
+ * Route ONE audit row's payload per shared-contract §3 (shape-detect →
+ * allow-list → fail-closed) and build its render model. INVARIANT: every row
+ * yields a rendered model OR the neutral `Entry details unavailable` line —
+ * NEVER ciphertext, NEVER a crash, NEVER raw-JSON for an unknown non-envelope
+ * plaintext.
+ *
+ * @param row        one raw `Record<string, unknown>` from `queryAudit().rows`
+ * @param sessionKey the task's session key (base64), or null when unavailable
+ * @param decrypt    injected `cryptoService.decryptContent` (mock in tests)
+ */
+export declare function routeAuditEntry(row: Record<string, unknown>, sessionKey: string | null, decrypt: DecryptContentFn): AuditEntryModel;
+/** The full render model for the per-task audit browser. */
+export interface AuditBrowserModel {
+    readonly title: string;
+    /** Newest-first entry models. Empty → render `emptyLine`. */
+    readonly entries: ReadonlyArray<AuditEntryModel>;
+    /** Set when there are zero entries (the `No audit entries yet.` line). */
+    readonly emptyLine: string | null;
+}
+/**
+ * Build the full newest-first audit browser model from the server-ascending
+ * `rows`. PURE — takes the rows + the session key + the injected decrypt fn.
+ * Ordering (§2): the rows come back server-ascending; we reverse to newest-first
+ * (using `timestamp`/`entryId` as keys — there is NO `seq_num` on the wire).
+ */
+export declare function buildAuditBrowserModel(rows: ReadonlyArray<Record<string, unknown>>, sessionKey: string | null, decrypt: DecryptContentFn): AuditBrowserModel;
+/** Render a single entry model as readable plaintext lines. */
+export declare function renderAuditEntryText(entry: AuditEntryModel): string[];
+/** Render the whole browser model as a readable newest-first timeline. */
+export declare function renderAuditBrowserText(model: AuditBrowserModel): string;

package/dist/orchestration-shell/audit-runner.d.ts

@@ -0,0 +1,59 @@
+import type { AppSyncClient } from '../appsync';
+import type { Tier } from './types';
+import { type AuditBrowserModel, type DecryptContentFn } from './audit-browser';
+/** Upgrade CTA appended below the Max interstitial (matches the existing copy). */
+export declare const AUDIT_BROWSER_UPGRADE_HINT = "Upgrade to Max at https://quantiya.ai/codevibe to access the audit browser.";
+/**
+ * The minimal AppSync surface the runner needs — `queryAudit` (the existing
+ * 2-arg `{taskId,sessionId}` method) + `getSubscriptionStatus`. Narrowed so the
+ * tests can inject a stub without the full client.
+ */
+export type AuditAppSyncClient = Pick<AppSyncClient, 'queryAudit' | 'getSubscriptionStatus'>;
+export interface RunAuditBrowserDeps {
+    /** The authenticated AppSync client (caller ran `authenticateWithStoredTokens`). */
+    appsyncClient: AuditAppSyncClient;
+    /** The task to browse. */
+    taskId: string;
+    /** The session the task belongs to (the `queryAudit` 2-arg shape needs it). */
+    sessionId: string;
+    /**
+     * The effective tier. When provided (the CLI passes `readTierFromEnvOrDefault`),
+     * it is authoritative (honors `CODEVIBE_TIER`). When omitted, the runner reads
+     * `getSubscriptionStatus().tier` from the backend.
+     */
+    tier?: Tier;
+    /** Test seam — defaults to `cryptoService.decryptContent`. */
+    decryptFn?: DecryptContentFn;
+    /** Test seam — defaults to `keychainManager.getSessionKey(sessionId)`. */
+    getSessionKeyFn?: (sessionId: string) => Promise<string | null>;
+    /**
+     * Test seam — overrides the Max-gate tier resolution entirely (skips
+     * getSubscriptionStatus). When set, this wins over `tier` + the backend read.
+     */
+    resolveTierFn?: () => Promise<Tier>;
+}
+/** The outcome of a browser run. */
+export type RunAuditBrowserResult = {
+    kind: 'gated';
+    headline: string;
+    upgradeHint: string;
+} | {
+    kind: 'ok';
+    model: AuditBrowserModel;
+} | {
+    kind: 'error';
+    line: string;
+    reason: string;
+};
+/**
+ * Run the per-task audit browser: Max-gate → fetch → resolve session key →
+ * route + build the newest-first render model. Returns a discriminated result
+ * the shell / CLI render. NEVER throws (every failure → a structured result).
+ */
+export declare function runAuditBrowser(deps: RunAuditBrowserDeps): Promise<RunAuditBrowserResult>;
+/**
+ * Render a `RunAuditBrowserResult` as readable plaintext (the meta-CLI default
+ * output + the inline `/audit` shell output). The `--json` CLI path renders the
+ * model directly as JSON instead (see `cli.ts`).
+ */
+export declare function renderAuditResultText(result: RunAuditBrowserResult): string;

package/dist/orchestration-shell/bracketed-paste.d.ts

@@ -0,0 +1,26 @@
+/** DECSET enable: terminal starts wrapping pastes in START…END. */
+export declare const ENABLE_BRACKETED_PASTE = "\u001B[?2004h";
+/** DECSET disable: restore normal paste behavior. */
+export declare const DISABLE_BRACKETED_PASTE = "\u001B[?2004l";
+/** Paste-start marker (6 bytes). */
+export declare const PASTE_START = "\u001B[200~";
+/** Paste-end marker (6 bytes). */
+export declare const PASTE_END = "\u001B[201~";
+/** Minimal write-stream shape we need (real `process.stdout` satisfies it). */
+export interface DecsetStream {
+    write(s: string): unknown;
+    isTTY?: boolean;
+    writable?: boolean;
+}
+/** `<OrchestrationApp>` registers its `useStdout().stdout` here on mount. */
+export declare function setRenderStdout(stdout: DecsetStream | null): void;
+/** Enable bracketed paste on the render stdout (idempotent; TTY-gated). */
+export declare function enableBracketedPaste(explicit?: DecsetStream | null): void;
+/**
+ * Disable bracketed paste (idempotent; TTY-gated). Safe to call from the signal
+ * path AND the unmount cleanup (double-call is a no-op once disabled). Callers
+ * that clear the render-stdout ref MUST disable FIRST, then clear (Stage-2 LOW).
+ */
+export declare function disableBracketedPaste(explicit?: DecsetStream | null): void;
+/** Test-only: reset module state between tests. */
+export declare function __resetBracketedPasteStateForTests(): void;

package/dist/orchestration-shell/cli.d.ts

@@ -1,8 +1,19 @@
 import { AppSyncClient } from '../appsync';
 import { Session } from '../types';
+import { Mode, Tier } from './types';
+import { type RunOrchestrationShellArgs } from './index';
 import { type ShellEventEmit } from './emit-shell-event';
-import { BackendPlannerClient, PlannerCacheLayer, PlannerHealthMachine } from '../planner';
+import { BackendPlannerClient, PlannerCacheLayer, PlannerHealthMachine, type LocalGemmaAdvisoryRunner, type LocalGemmaPlannerRunner } from '../planner';
 import type { PlannerAdapter, PlannerInput, PlannerDecision, PlannerProbeResult } from '../planner/adapter';
+import { type LocalExecutor, type AuthorityScope, type EmitShellEventFn as LEEmitShellEventFn } from '../local-executor';
+import { type EngineGroupState } from '../local-executor';
+import type { TeamTapEvent } from './index';
+import type { GroupDecisionSubmitDeps } from './gate-decision-submit';
+import { QuorumLoop } from './quorum-loop';
+import type { TaskProgressEvent } from './task-progress';
+import { type VerdictClassifier } from '../reviewer/verdict-classifier';
+import { type LocalModelArtifactConfig, type LocalModelCommand, type LocalModelEntitlement, type LocalModelStore } from '../local-model/manager';
+import { type LocalModelState } from '../local-model/state';
 /**
  * CP-1.b IMPL r5 H-1 — Sentinel error thrown by the stub-session
  * planner adapter. `handleShellUserInput` catches this typed class and
@@ -44,6 +55,19 @@ export declare class PlannerUnavailableAdapter implements PlannerAdapter {
     probe(): Promise<PlannerProbeResult>;
     setActiveSession(sessionId: string | null): void;
 }
+/**
+ * Local-LLM planner placeholder for the Gemma QAT migration slice. This adapter
+ * is intentionally local-only: it never calls AppSync planner mutations or any
+ * hosted fallback. Until the verified Gemma runner is wired, natural-language
+ * planning requests fail closed with an actionable shell message.
+ */
+export declare class LocalModelPlannerUnavailableAdapter implements PlannerAdapter {
+    private readonly reason;
+    constructor(reason: string);
+    classify(_input: PlannerInput): Promise<PlannerDecision>;
+    probe(): Promise<PlannerProbeResult>;
+    setActiveSession(_sessionId: string | null): void;
+}
 /**
  * CP-1.b IMPL r5 H-1 — Detect a CP-1.a stub session. Two signals:
  *   (a) `sessionId` starts with `cp1a-local-` (the
@@ -58,6 +82,119 @@ export declare class PlannerUnavailableAdapter implements PlannerAdapter {
  * until the user registers a device key.
  */
 export declare function isStubSession(session: Session): boolean;
+export declare function buildStubSessionShellArgs(args: Omit<RunOrchestrationShellArgs, 'disableStructuralContextRefresh'>): RunOrchestrationShellArgs;
+/**
+ * CP-1.f §3.C.19 — resolve a REAL backend session for the orchestration loop
+ * (closes #513). When authenticated:
+ *   1. resume the user's most-recent ACTIVE session via `getSession` (which
+ *      returns `encryptedKeys`) AND warm the session-key cache from them so the
+ *      QuorumLoop's `getSessionKey` is non-null, OR
+ *   2. create a new orchestration session with the FULL E2E bootstrap
+ *      (`prepareSessionEncryption` → `createSession` with isEncrypted /
+ *      encryptedKeys / creatorDeviceId / encryptionVersion → `cacheSessionKey`),
+ *      so the orchestration/planner-proxy Lambda is a recipient in
+ *      `Session.encryptedKeys` (can decrypt encProposal/verdict) AND the local
+ *      key cache is warm. Stage-1 FIX 1 — replaces the prior crypto-dropping
+ *      `createSession` reimplementation that hung the loop ("no session key").
+ * Falls back to `buildStubSession()` when unauthenticated / offline / on any
+ * error — the stub-session guards downstream keep that path fully usable.
+ *
+ * The tier is resolved here too (§3.C.19): a `CODEVIBE_TIER` env override wins
+ * (the dev/dogfood lever), else `getSubscriptionStatus`, else FREE (fail-closed
+ * — Orchestration Mode is never surfaced to Free).
+ */
+export declare function resumeOrCreateSession(appsyncClient: AppSyncClient, deps?: {
+    resolveSessionIdFn?: (client: AppSyncClient) => Promise<string | null>;
+}): Promise<{
+    session: Session;
+    tier: Tier;
+}>;
+/**
+ * CP-8 Slice C (#570) — parse a top-level `audit show <task-id> [--json]
+ * [--session <id>]` subcommand from the raw argv. Returns null when the argv is
+ * NOT an audit subcommand (so `main` falls through to mode selection). Detected
+ * BEFORE the mode parse so `audit` isn't swallowed as a passthrough arg.
+ */
+export interface ParsedAuditArgs {
+    taskId: string;
+    json: boolean;
+    /** Explicit session override; when absent the runner resolves the active session. */
+    sessionId?: string;
+}
+export declare function parseAuditArgs(argv: string[]): ParsedAuditArgs | null;
+export interface ParsedModelArgs {
+    command: LocalModelCommand | 'help';
+    viaWithLocalModelFlag: boolean;
+}
+/**
+ * Parse local-model meta commands before mode selection. These commands must
+ * not be swallowed as Companion passthrough args, because the entitlement gate
+ * has to run before any model download, warmup, or health check can start.
+ */
+export declare function parseModelArgs(argv: string[]): ParsedModelArgs | null;
+export declare function runModelCli(parsed: ParsedModelArgs, deps?: {
+    appsyncClient?: AppSyncClient;
+    resolveEntitlement?: () => Promise<LocalModelEntitlement>;
+    stdout?: (s: string) => void;
+    stderr?: (s: string) => void;
+}): Promise<number>;
+export interface LocalModelBootDecision {
+    mode: Mode;
+    notice: string | null;
+}
+export declare function resolveLocalModelBoot(args: {
+    requestedMode: Mode;
+    entitlement: LocalModelEntitlement;
+    state: LocalModelState;
+}): LocalModelBootDecision;
+export interface LocalGemmaPlannerBuildResult {
+    adapter: PlannerAdapter;
+    advisoryRunner: LocalGemmaAdvisoryRunner | null;
+    /**
+     * REVIEWER-VERDICT-GEMMA-CLASSIFIER-DESIGN.md (§Wiring) — the SAME resolved
+     * Gemma runner instance as {@link advisoryRunner} (both `null` on the unavailable
+     * path), exposed with the wider `LocalGemmaPlannerRunner` type (it carries
+     * `classify`, which the verdict classifier needs; `advisoryRunner` keeps the
+     * stricter `LocalGemmaAdvisoryRunner` type its consumer requires). One instance ⇒
+     * a SINGLE availability source for both the planner and the verdict classifier —
+     * they can never disagree about whether Gemma is up.
+     */
+    classifyRunner: LocalGemmaPlannerRunner | null;
+    runtimeKind: NonNullable<RunOrchestrationShellArgs['plannerRuntimeKind']>;
+    /**
+     * TUI redesign (2026-06-29) — display label for the status-bar planner badge
+     * (model name, tag-stripped, e.g. `gemma4`). Derived even on the unavailable
+     * path so the degraded badge can still name the intended model.
+     */
+    runtimeLabel: string;
+    reason: string | null;
+}
+export declare function buildLocalGemmaPlannerAdapter(args: {
+    state: LocalModelState;
+    config?: LocalModelArtifactConfig;
+    store?: LocalModelStore;
+    env?: NodeJS.ProcessEnv;
+}): Promise<LocalGemmaPlannerBuildResult>;
+/**
+ * CP-8 Slice C (#570) — the meta-CLI `codevibe audit show <task-id> [--json]`
+ * entrypoint. Authenticates the AppSync client (mirrors the `main()` auth
+ * wiring), resolves the task's session id (explicit `--session` OR the most
+ * recent ACTIVE session), runs the Max-gated browser, and prints either the
+ * JSON model (`--json`) or a readable newest-first timeline (default).
+ *
+ * Returns a process exit code (0 = printed something the user expects; 2 =
+ * usage error). The Max interstitial + error empty-state are NOT failures —
+ * they print and return 0.
+ *
+ * Exported for unit tests; production goes through `main()`.
+ */
+export declare function runAuditCli(parsed: ParsedAuditArgs, deps?: {
+    appsyncClient?: AppSyncClient;
+    /** Test seam — overrides the active-session resolution. */
+    resolveSessionIdFn?: (client: AppSyncClient) => Promise<string | null>;
+    stdout?: (s: string) => void;
+    stderr?: (s: string) => void;
+}): Promise<number>;
 export declare function main(argv: string[]): Promise<number>;
 /**
  * CP-1.b IMPL r4 H-1 — Production planner stack factory.
@@ -78,6 +215,204 @@ export declare function buildProductionPlannerStack(appsyncClient: AppSyncClient
     cache: PlannerCacheLayer;
     health: PlannerHealthMachine;
 };
+export interface BuildTeamLocalExecutorResult {
+    localExecutor: LocalExecutor;
+    teamShellEventTap: {
+        fn: (args: TeamTapEvent) => void;
+    };
+    /**
+     * CP-1.f §3.C — the reviewer-quorum loop driver, constructed alongside the LE
+     * and wired into the LE's Class B consumer (real Ed25519 verify +
+     * REVIEWER_DISPATCH spawnReviewers + REVISE_FEEDBACK runReviseRound).
+     * `runOrchestrationShell` threads it for start_task START + reconnect recovery.
+     */
+    quorumLoop: QuorumLoop;
+    /**
+     * CP-1.f live progress surfacing — the progress tap holder (see
+     * `BuildQuorumLoopExecutorResult.progressTap`).
+     */
+    progressTap: ProgressTap;
+    /**
+     * Audited-path fix (Fix 1) — the PolicyRejection tap holder (see
+     * `BuildQuorumLoopExecutorResult.policyRejectionTap`).
+     */
+    policyRejectionTap: PolicyRejectionTap;
+    /**
+     * PHASE-589/469 W3.2 — the two-phase group-escalation decision deps (WITHOUT
+     * the store; `runOrchestrationShell` completes it). Threaded into
+     * `gateDecisionDeps.groupDecision` so a synthesized `task_group_halted`
+     * 5-option prompt resolves through `submitGroupDecision`.
+     */
+    groupDecisionDeps: Omit<GroupDecisionSubmitDeps, 'store'>;
+    /**
+     * PHASE-589/469 W3.1 (C4) — the startup reconcile-before-GC over the durable
+     * revert manifests. `runOrchestrationShell` awaits it ONCE at team-wiring
+     * startup, BEFORE the live Class B loop consumes packets.
+     */
+    reconcileRevertManifests: () => Promise<void>;
+}
+/**
+ * CP-1.f live progress surfacing — the desktop-local progress tap holder
+ * (mirrors `teamShellEventTap`). `cli.ts` builds it with a no-op `fn`; the
+ * QuorumLoop's `onProgress` calls `progressTap.fn(event)`, and
+ * `runOrchestrationShell` installs the store-dispatching `fn` at startup. Until
+ * then (and for non-loop sessions) the `fn` is inert. The loop also wraps every
+ * emit so a throwing `fn` can never break the loop.
+ */
+export interface ProgressTap {
+    fn: (event: TaskProgressEvent) => void;
+}
+/**
+ * Audited-path fix (Fix 1) — the PolicyRejection tap holder (mirrors
+ * `progressTap`). `cli.ts` builds it with a no-op `fn`; the LE's
+ * `onPolicyRejection` dep calls `policyRejectionTap.fn(info)`, and
+ * `runOrchestrationShell` installs the store-dispatching `fn` (a classified
+ * `SHELL_ADVISORY`) at startup. Until then (and for non-loop sessions) the `fn`
+ * is inert. The shadow-discard side is handled inside `cli.ts`'s wiring (it has
+ * the QuorumLoop reference); this tap carries ONLY the user-visible advisory.
+ */
+export interface PolicyRejectionTap {
+    fn: (info: {
+        detail: string;
+        category: string;
+        recommendedRecovery: string;
+    }) => void;
+}
+/**
+ * [Gemma classifier · D11 + §Wiring] Resolve the reviewer verdict classifier
+ * threaded onto `QuorumLoopDeps.classifyVerdict`.
+ *
+ *  - `classifyRunner === undefined` → the classifier is NOT wired (unit tests /
+ *    the canned-prompt legacy paths the design leaves on regex) → `undefined`
+ *    (the provider uses `parseVerdictOutput`). Production ALWAYS wires it (a
+ *    `LocalGemmaPlannerRunner | null`), so this branch never fires in production.
+ *  - `CODEVIBE_REVIEWER_VERDICT_CLASSIFIER=regex` → `undefined` (the ONLY operator
+ *    revert to the regex parser). Any other value (incl. a typo) stays `gemma` so
+ *    a mistyped flag can NEVER silently disable the fail-closed classifier.
+ *  - `gemma` (default) → the real fail-closed Gemma classifier when the runner is
+ *    present; a dummy always-ESCALATE classifier when it is `null` (Ollama
+ *    unreachable at boot) — NEVER a silent regex fallback (agy-MED-1).
+ */
+export declare function resolveVerdictClassifier(classifyRunner: LocalGemmaPlannerRunner | null | undefined, env?: NodeJS.ProcessEnv): VerdictClassifier | undefined;
+export interface BuildQuorumLoopExecutorResult {
+    localExecutor: LocalExecutor;
+    quorumLoop: QuorumLoop;
+    /**
+     * CP-1.f live progress surfacing — the progress tap holder. `cli.ts` threads
+     * it into `runOrchestrationShell`, which installs the store-dispatching `fn`.
+     */
+    progressTap: ProgressTap;
+    /**
+     * Audited-path fix (Fix 1) — the PolicyRejection tap holder. `cli.ts` threads
+     * it into `runOrchestrationShell`, which installs the store-dispatching `fn`
+     * (a classified `SHELL_ADVISORY`).
+     */
+    policyRejectionTap: PolicyRejectionTap;
+}
+/**
+ * CP-1.f §3.C — Stage-2 r2 (Codex) FIX B. Construct the SINGLE-TASK QuorumLoop +
+ * its driving LE for a non-team orchestration session (Pro OR Max-without-teams).
+ *
+ * The single-implementor reviewer-quorum loop is a Pro+Max feature (Pro = 2
+ * seats, Max = 3 seats per `codevibe-policy`); only Agent Teams / MergeGate
+ * (CP-12) is Max-only. Before this fix the QuorumLoop was built ONLY inside
+ * `buildTeamLocalExecutor` (gated on `tier === 'MAX'`), so a real Pro
+ * orchestration session got NO loop → `start_task` silently no-op'd (the only
+ * `start_task` execution branch requires `args.quorumLoop`).
+ *
+ * The LE here is a MINIMAL single-track LE — it OMITS every team dep
+ * (`spawnTrackImplementor` / `buildTrackArgv` / `appsyncClient` / `repoRoot` /
+ * `deviceSigningKey` / `teamSessionKeyB64` / …), so `teamModeEnabled` is FALSE
+ * (a teams Class B packet is dropped, not acted on). It KEEPS the 4
+ * reviewer-quorum consumer deps (so the loop receives GATE_DISPATCH /
+ * REVIEWER_DISPATCH / REVISE_FEEDBACK) + the substrate engager (so the
+ * implementor still spawns inside the CP-7 moat). The shell wires the returned
+ * `localExecutor` for the Class B subscription + `quorumLoop` for start_task +
+ * reconnect recovery, EXACTLY as the team path does.
+ *
+ * Exported for unit tests; production goes through `main()`.
+ */
+export declare function buildQuorumLoopExecutor(args: {
+    appsyncClient: AppSyncClient;
+    session: Session;
+    emitter: (args: ShellEventEmit) => Promise<void>;
+    /** CP-1.f LOCK RP-6 — host-detected agents threaded into the loop. */
+    detectedAgents?: string[];
+    /** #585 auto-continuation (Max) — the resolved tier, threaded to the loop. */
+    tier?: Tier;
+    /**
+     * [Gemma classifier · §Wiring] The resolved Gemma runner (same instance as the
+     * planner's), forwarded to `buildAndArmQuorumLoop` where the verdict classifier is
+     * built. ABSENT (tests) → the classifier is not wired → regex parser.
+     */
+    classifyRunner?: LocalGemmaPlannerRunner | null;
+}): Promise<BuildQuorumLoopExecutorResult>;
+/**
+ * PHASE-589+469 W2 (#TC-5) — map an LE hook-bridge event to the chokepoint's
+ * `ShellEventEmit`. The team-result summary (`ASSISTANT_RESPONSE`, from
+ * `emitGroupConvergence`) KEEPS its type AND forwards `content` (the
+ * light-markdown digest the phone renders); `LOCAL_AUTHORITY_REFUSAL` maps 1:1;
+ * every other type is coerced to `NOTIFICATION` (audit fallback — those never
+ * occur on the team paths). Exported so the #TC-5 test drives the REAL mapping
+ * (not a reproduction): a regression that dropped the `ASSISTANT_RESPONSE` type
+ * or its `content` — which would silently make the mobile summary dead — is
+ * caught here.
+ */
+export declare function mapTeamLeEventToShellEmit(e: Parameters<LEEmitShellEventFn>[0]): ShellEventEmit;
+/**
+ * Construct the team-mode LocalExecutorImpl + the store-tap holder. Returns the
+ * pair `runOrchestrationShell` consumes (`localExecutor` + `teamShellEventTap`).
+ *
+ * Exported for the W3 E2E smoke (which injects stub deps) + future callers;
+ * production goes through `main()`.
+ */
+export declare function buildTeamLocalExecutor(args: {
+    appsyncClient: AppSyncClient;
+    session: Session;
+    emitter: (args: ShellEventEmit) => Promise<void>;
+    initialScope: AuthorityScope;
+    /** CP-1.f LOCK RP-6 — host-detected agents threaded into the loop. */
+    detectedAgents?: string[];
+    /** #585 auto-continuation (Max) — the resolved tier, threaded to the loop. */
+    tier?: Tier;
+    /**
+     * TEST SEAM — override the durable revert-manifest store root. Production omits it
+     * (defaults to the shared `~/.codevibe/revert-state/`). Tests pass an ISOLATED temp
+     * dir so the CLAIM→revert→COMMIT flow can't be contaminated by another test's
+     * leftover manifest/journal in the shared root (which stranded the COMMIT phase →
+     * `['claim']` in the full suite while passing in isolation), and so a sandboxed
+     * runner that can't write `~/.codevibe` doesn't EPERM.
+     */
+    durableRootDir?: string;
+    /**
+     * [Gemma classifier · §Wiring] The resolved Gemma runner (same instance as the
+     * planner's), forwarded to `buildAndArmQuorumLoop` where the verdict classifier is
+     * built. ABSENT (tests) → the classifier is not wired → regex parser.
+     */
+    classifyRunner?: LocalGemmaPlannerRunner | null;
+}): Promise<BuildTeamLocalExecutorResult>;
+/**
+ * PHASE-589/469 W3.1 (C4 / RESIDUAL 2) — probe the engine's TERMINAL view of a
+ * team group for the startup reconcile, via the `getTaskGroupStatus` query (the
+ * group row's authoritative `status` + `halt_reason`). This is what closes the
+ * OFFLINE lease-timeout case: a group the sweeper drove `Halted` while the desktop
+ * was down now resolves to `terminal_rejected` here → the reconcile auto-reverts
+ * the applied tree before a backend expiry could strand it dirty.
+ *
+ *   - `halted`                                  → `'terminal_rejected'` (revert)
+ *   - `complete`                                → `'terminal_kept'`     (mark accepted)
+ *   - any non-terminal status (scheduling /     → `'in_flight'`         (leave the
+ *     tracks_in_flight / draining /                                      manifest)
+ *     merge_gate_pending)
+ *   - `unknown` (vanished / unowned / TTL'd)    → `'unknown'`           (orphan-TTL
+ *     OR a probe error                                                   fallback GC)
+ *
+ * Fail-open on a probe error → `'unknown'` (the manifest is kept for the orphan-TTL
+ * fallback rather than blindly reverting a possibly-kept group). A
+ * `reject_revert_in_progress` CLAIM-crash manifest is NEVER GC'd regardless (its
+ * lifecycle is non-terminal), so it survives every restart and resumes its revert.
+ */
+export declare function probeEngineGroupState(appsyncClient: AppSyncClient, taskGroupId: string): Promise<EngineGroupState>;
 import { HookBridge } from '../local-executor/hook-bridge';
 export interface BridgeRefusalArgs {
     refusedMessageId: string;