@quantiya/codevibe-core 2.0.6 → 2.0.7

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

@@ -66,11 +66,49 @@ export interface CopiedAttachment {
     relPath: string;
     mime: string;
 }
+/**
+ * [#637 Stage-2 R6 HIGH] The pinned filesystem identity of the attachments dir
+ * (`dev`+`ino` from the validation/creation-time lstat). `O_NOFOLLOW` guards
+ * only the FINAL path component, so any op that RESOLVES THROUGH the dir
+ * (tmp-file open, rename, unlink, rmdir) must re-verify the parent dir is
+ * still the very same inode immediately beforehand — a concurrent swap of
+ * `.codevibe-attachments` to a symlink would otherwise redirect writes or
+ * deletions outside the repo.
+ */
+export interface AttachmentsDirIdentity {
+    dev: number;
+    ino: number;
+}
+/**
+ * [R6 HIGH] Identity re-check immediately before a write/cleanup op that
+ * resolves through the attachments dir: lstat (never follows), must be a REAL
+ * directory with the SAME dev+ino as pinned at validation time. Any mismatch,
+ * missing identity, or lstat failure → false (fail CLOSED). Node has no
+ * openat-style fd-relative open/rename/unlink; the immediately-preceding
+ * re-check is the accepted approximation (the residual window is the single
+ * syscall gap).
+ */
+export declare function verifyAttachmentsDirIdentity(dirPath: string, identity: AttachmentsDirIdentity | null): boolean;
 export interface PreparedAttachments {
     copiedAttachments: CopiedAttachment[];
     failedAttachments: ImageAttachment[];
     /** The brief with FAILED-copy refs rewritten to a neutral marker (no dangling ref). */
     roundBrief: string;
+    /**
+     * [#637 Stage-2 R5 LOW-3] True iff THIS call's OWN mkdir created the
+     * attachments dir (non-recursive — a dir raced into existence by another
+     * process signals EEXIST → false). The advisory caller gates its cleanup
+     * rmdir on this so it never removes a dir it did not create; a caller-side
+     * stat-before-await inference was racy.
+     */
+    createdAttachmentsDir: boolean;
+    /**
+     * [R6 HIGH] The pinned identity every copy was verified against — null when
+     * staging was refused or no directory could be established. Cleanup callers
+     * MUST pass this to `verifyAttachmentsDirIdentity` immediately before each
+     * unlink and the rmdir.
+     */
+    attachmentsDirIdentity: AttachmentsDirIdentity | null;
 }
 /**
  * Per-round copy + failure-rewrite in ONE step (§7.3, rev-7). For each attachment,
@@ -80,13 +118,31 @@ export interface PreparedAttachments {
  * in `roundBrief` to `[attached image skipped]` (so no dangling ref survives). The
  * returned `roundBrief` (failures neutralized) feeds BOTH the per-agent stdin AND
  * the execute-first payload. Never throws / never hard-blocks.
+ *
+ * [#637] `destMode: 'real_worktree'` — the read-only advisory panel stages into
+ * the user's REAL repo (no shadow). A pre-existing symlink / non-directory at
+ * `.codevibe-attachments` there belongs to the USER, so the whole staging is
+ * REFUSED (every attachment failed, refs neutralized; the advisory proceeds
+ * text-only) instead of the shadow path's rm-and-recreate. Default `'shadow'`
+ * keeps the replacement behavior — the shadow is disposable and the entry there
+ * could only be implementor-planted.
  */
-export declare function prepareAttachmentsForSpawn(roundBrief: string, attachments: ImageAttachment[], shadowDir: string): PreparedAttachments;
+export declare function prepareAttachmentsForSpawn(roundBrief: string, attachments: ImageAttachment[], shadowDir: string, opts?: {
+    destMode?: 'shadow' | 'real_worktree';
+    /**
+     * Injectable test seam (deterministic swap-window tests, same idiom as
+     * `IngestOptions.newId`): runs between the dir-identity pin and the
+     * per-file copies — exactly the [R6 HIGH] race window.
+     */
+    onDirEnsured?: () => void;
+}): PreparedAttachments;
 /**
  * Per-agent rendering of the copied-attachment refs, appended to the brief at spawn
  * (§7.2). The stored/canonical brief is agent-NEUTRAL (`.codevibe-attachments/<id>.<ext>`);
  * this adds the agent-specific pointer: Claude/Codex → an `Attached images:` list of
- * relative paths (read via their Read tool); Gemini → the `@./…` form.
+ * relative paths (read via their Read tool); Antigravity → an absolute-path list (its
+ * Read tool resolves against agy's own scratch project, not the shadow cwd). (Gemini was
+ * SUNSET in 2026-07 and is never dispatched — its `@./…` rendering branch was removed.)
  */
 export declare function renderAttachmentsForAgent(agent: string, copied: CopiedAttachment[], workdir?: string): string;
 /**

package/dist/orchestration-shell/bounded-shutdown.d.ts

@@ -0,0 +1,16 @@
+export type ShutdownDeadlineClass = 'normal' | 'signal';
+export interface BoundedSharedShutdownOperation {
+    wait: (deadlineClass?: ShutdownDeadlineClass) => Promise<void>;
+}
+export interface BoundedSharedShutdownOperationOptions {
+    start: () => Promise<void>;
+    normalTimeoutMs: number;
+    signalTimeoutMs: number;
+    onTimeout?: (deadlineClass: ShutdownDeadlineClass, timeoutMs: number) => void;
+}
+/**
+ * Starts one shutdown operation and gives normal and signal callers one shared
+ * absolute timeout each. Repeated callers never restart either the operation or
+ * their deadline, so nested teardown paths cannot multiply the exit latency.
+ */
+export declare function createBoundedSharedShutdownOperation(options: BoundedSharedShutdownOperationOptions): BoundedSharedShutdownOperation;

package/dist/orchestration-shell/brainstorm-quorum.d.ts

@@ -0,0 +1,118 @@
+import type { Tier } from './types';
+import type { CommandIntentTarget } from './command-intent';
+/**
+ * The frontier panel's active-set members. This is the intersection of the
+ * `@`-mention vocabulary (`command-intent.ts` — Gemini is excluded from direct
+ * mentions) with the review quorum's ACTIVE_AGENT_KINDS (`detectInstalledAgents`
+ * probes exactly these three; Gemini is legacy-readable but not new-routable).
+ */
+export type BrainstormPanelActiveAgent = 'CLAUDE' | 'CODEX' | 'ANTIGRAVITY';
+/**
+ * OQ-BRAINSTORM-COST resolution: the frontier brainstorm panel is **Max-only**
+ * ("Max-only panel?"). Firing frontier agents per turn is expensive; the default
+ * interactive brainstorm remains the local 12B (`routeBrainstorm`), available to
+ * Pro/Max. The panel (both `@all` broadcast AND a directed `@agent` frontier
+ * routing) is gated here.
+ */
+export declare const BRAINSTORM_PANEL_MIN_TIER: Tier;
+/**
+ * The resolved panel active set, mirroring the review quorum's
+ * "installed ∧ non-quota-walled ∧ tier-permitted" intersection
+ * (quorum-loop `getDetectedAgents()` + `pickAutoContinuationTarget`).
+ */
+export type BrainstormPanelResolution = {
+    kind: 'ready';
+    activeAgents: BrainstormPanelActiveAgent[];
+} | {
+    kind: 'tier_gated';
+} | {
+    kind: 'no_agents';
+} | {
+    kind: 'all_quota_walled';
+    walled: BrainstormPanelActiveAgent[];
+};
+/**
+ * Resolve which frontier agents fire for this brainstorm turn.
+ *
+ * Order of gates (each fails to a distinct, user-legible reason):
+ *  1. **Tier** — below Max → `tier_gated` (no agent is spawned).
+ *  2. **Target ∩ installed** — an `@all` broadcast targets every installed
+ *     panel agent; a directed `@claude`/`@codex`/`@agy` targets exactly that one
+ *     IF installed. Empty → `no_agents`.
+ *  3. **Minus quota-walled** — subtract the session's quota-exhausted set (the
+ *     way `pickAutoContinuationTarget` subtracts `quotaFailedAgentsByTask`). If
+ *     every candidate is walled → `all_quota_walled` (nothing fires).
+ *
+ * Pure: the caller supplies the already-detected installed set and the walled
+ * set (both live in index.ts's session-scoped state).
+ */
+export declare function resolveBrainstormPanel(input: {
+    tier: Tier;
+    target: CommandIntentTarget;
+    /**
+     * [#637] ALL mention targets of a multi-mention turn (ordered, de-duplicated —
+     * `extractAllAgentMentionIntents`). When present it supersedes `target` for
+     * the active-set computation: the candidates are the mentioned agents ∩
+     * installed IN MENTION ORDER, and any `'ALL'` member means the whole installed
+     * set (existing `@all` semantics win). `target` stays the FIRST mention — the
+     * frozen `CommandIntentEnvelope`'s. Absent/single-element → prior behavior.
+     */
+    targets?: readonly CommandIntentTarget[];
+    detectedAgents: readonly BrainstormPanelActiveAgent[];
+    quotaWalled: ReadonlySet<BrainstormPanelActiveAgent>;
+}): BrainstormPanelResolution;
+/**
+ * The ContextItem `author.agent_id` for a panel agent — the lowercase mention id
+ * (§4 example: `'claude' | 'codex' | 'gemini' | 'agy'`). The rehydration render
+ * shows this verbatim as the attribution label ("claude: …", "agy: …"), so a
+ * later `@claude "critique the above"` sees WHO said what.
+ */
+export declare function agentIdForAuthor(agent: BrainstormPanelActiveAgent): 'claude' | 'codex' | 'agy';
+/**
+ * §8.2 — surface the active-set count/identities UP FRONT so the fan-out cost is
+ * visible before it fires (the design's "→ Opus 4.8 · GPT-5.5 · Gemini 5.5").
+ * The display names come from the caller (index.ts `agentDisplayName`) so the
+ * mapping stays single-sourced.
+ */
+export declare function renderBrainstormPanelHeader(activeAgents: readonly BrainstormPanelActiveAgent[], displayName: (agent: BrainstormPanelActiveAgent) => string): string;
+/**
+ * Below Max: the frontier panel is fenced, but the local model still
+ * brainstorms. No frontier agent was called and no code was changed.
+ */
+export declare function brainstormTierGateMessage(target: CommandIntentTarget): string;
+/**
+ * Every candidate for this mention is currently quota-walled for the session.
+ */
+export declare function brainstormAllQuotaWalledMessage(walled: readonly BrainstormPanelActiveAgent[], displayName: (agent: BrainstormPanelActiveAgent) => string): string;
+/**
+ * [A1g] Stage-2 (Codex round-2 HIGH) — the CLOSED-LABEL notice for a single
+ * brainstorm-panel cell that FAILED (a spawn/exec error, a quota wall, OR the
+ * absolute-ceiling timeout — #635). This is the ONLY per-agent failure text that
+ * enters the panel section, which the turn-mirror mirrors to mobile as
+ * ASSISTANT_RESPONSE. The substantive diagnostic (the sanitized advisory fallback
+ * / raw error) MUST NOT ride this section — it stays desktop-local via
+ * `logger.warn` (the WIRE is what the ZK invariant governs, NOT the local log
+ * file, which never leaves the machine). The invariant is stricter than
+ * ZK-on-wire (the mirror is E2E-encrypted regardless): only a BOUNDED enum label
+ * is surfaced on the wire, never the agent's diagnostic. Three labels only —
+ * quota-wall vs timeout vs generic failure — so no free-form detail can leak
+ * through. [#635] the `'quota_walled'`/`'failed'` strings are preserved VERBATIM
+ * from the prior 2-label version; only `'timed_out'` is new.
+ */
+export type BrainstormPanelFailureReason = 'quota_walled' | 'timed_out' | 'failed';
+export declare function brainstormPanelFailureNotice(reason: BrainstormPanelFailureReason): string;
+/**
+ * Compose the panel brief fed to each frontier agent: the typed-store
+ * "idea-so-far + open-questions" projection (rendered by
+ * `renderRehydratedSessionContext(role:'brainstorm')`, so it carries prior
+ * attributed panel turns) as a labeled PREFIX, then the current request. The
+ * projection is PRIOR context only — the current turn is authored into the store
+ * AFTER this turn completes (the mirror chokepoint), so there is no overlap.
+ *
+ * Empty `priorContext` (fresh session / unverifiable chain — fail-closed to
+ * NOTHING) degrades to just the request, exactly as today.
+ */
+export declare function composeBrainstormPanelBrief(input: {
+    priorContext: string;
+    requestBrief: string;
+}): string;

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

@@ -1,6 +1,7 @@
 import { AppSyncClient } from '../appsync';
 import { Session } from '../types';
 import { Mode, Tier } from './types';
+import { type ModeSelectionDeps } from './mode-selection';
 import { type RunOrchestrationShellArgs } from './index';
 import { type ShellEventEmit } from './emit-shell-event';
 import { BackendPlannerClient, PlannerCacheLayer, PlannerHealthMachine, type LocalGemmaAdvisoryRunner, type LocalGemmaPlannerRunner } from '../planner';
@@ -15,46 +16,13 @@ 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
- * routes it through the explicit error renderer (SLASH_OUTPUT) so the
- * user sees an actionable message in the conversation pane instead of
- * a silent log line. Stub sessions (sessionId prefix `cp1a-local-` or
- * empty `encryptedKeys`) cannot reach the Lambda — `encryptedKeys` is
- * missing, the keychain resolver returns null, and the planner client
- * throws "session key unresolved" deep inside classify(). Surfacing
- * that as a typed error at the adapter boundary is cleaner than the
- * generic Error from `BackendPlannerClient.classify()`.
+ * Sentinel error rendered by the shell when the configured local planner
+ * runtime is unavailable. Session bootstrap failures are handled before the
+ * TUI opens and never use this planner-level error path.
  */
 export declare class PlannerUnavailableError extends Error {
     constructor(msg: string);
 }
-/**
- * CP-1.b IMPL r5 H-1 — Stub-session planner adapter.
- *
- * CP-1.a still ships a fake `cp1a-local-*` session with no
- * `encryptedKeys[]`. The production `BackendPlannerClient` cannot
- * classify against that session — the Lambda requires E2E-encrypted
- * payloads, which requires the session key, which the keychain
- * resolver cannot derive without `encryptedKeys`.
- *
- * Rather than wire up the production stack and let it fail with a
- * generic "session key unresolved" Error deep inside classify(), we
- * detect stub sessions at bootstrap and construct this adapter, which
- * throws a typed `PlannerUnavailableError` on classify(). The shell's
- * `handleShellUserInput` catches this and renders an actionable
- * message to the user (`PLANNER_UNAVAILABLE: <reason>`). CP-1.c lands
- * the real session bootstrap (resumeOrCreateSession + AppSync) and
- * this adapter is no longer wired in.
- */
-export declare class PlannerUnavailableAdapter implements PlannerAdapter {
-    private readonly reason;
-    private activeSessionId;
-    constructor(reason: string);
-    classify(_input: PlannerInput): Promise<PlannerDecision>;
-    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
@@ -68,21 +36,38 @@ export declare class LocalModelPlannerUnavailableAdapter implements PlannerAdapt
     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
- *       `buildStubSession()` prefix).
- *   (b) `session.encryptedKeys` is empty / missing (any session
- *       lacking E2E keys cannot route through the Lambda).
- *
- * Either signal triggers the stub-session adapter. The (b) gate is
- * a defensive fallback for the case where CP-1.c starts a real
- * session bootstrap but `prepareSessionEncryption()` returns null
- * (no device keys registered): the planner is genuinely unavailable
- * until the user registers a device key.
- */
-export declare function isStubSession(session: Session): boolean;
-export declare function buildStubSessionShellArgs(args: Omit<RunOrchestrationShellArgs, 'disableStructuralContextRefresh'>): RunOrchestrationShellArgs;
+export type OrchestrationSessionBootstrapFailureKind = 'auth_required' | 'backend_unavailable' | 'encryption_unavailable' | 'session_limit' | 'session_create_failed';
+/** An orchestration shell cannot exist without an admitted encrypted session. */
+export declare class OrchestrationSessionBootstrapError extends Error {
+    readonly kind: OrchestrationSessionBootstrapFailureKind;
+    readonly cause?: unknown;
+    constructor(kind: OrchestrationSessionBootstrapFailureKind, message: string, cause?: unknown);
+}
+export declare function classifyOrchestrationSessionBootstrapError(error: unknown): OrchestrationSessionBootstrapError;
+export declare class CliAuthenticationError extends Error {
+    readonly kind: 'auth_required' | 'auth_unavailable' | 'credential_storage_unavailable';
+    readonly cause?: unknown;
+    constructor(kind: 'auth_required' | 'auth_unavailable' | 'credential_storage_unavailable', message: string, cause?: unknown);
+}
+/** Subscription verification is mandatory before either product mode starts. */
+export declare class CliEntitlementError extends Error {
+    readonly kind: "entitlement_unavailable";
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+/** Both Companion and Orchestration require a verified signed-in account. */
+export declare function requireCliAuthentication(client: Pick<AppSyncClient, 'authenticateWithStoredTokens' | 'getLastAuthFailureKind'>): Promise<void>;
+export interface ParsedCliArgs {
+    agent?: 'CLAUDE' | 'CODEX' | 'ANTIGRAVITY';
+    help: boolean;
+    passthrough: string[];
+}
+export declare class CliUsageError extends Error {
+    constructor(message: string);
+}
+export declare function parseCliArgs(argv: string[]): ParsedCliArgs;
+/** Resolve the product mode without opening the mode picker for --agent. */
+export declare function resolveLaunchMode(args: Pick<ParsedCliArgs, 'agent'>, tier: Tier, deps?: ModeSelectionDeps): Promise<Mode>;
 /**
  * CP-1.f §3.C.19 — resolve a REAL backend session for the orchestration loop
  * (closes #513). When authenticated:
@@ -96,19 +81,45 @@ export declare function buildStubSessionShellArgs(args: Omit<RunOrchestrationShe
  *      `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.
+ * Authentication, encryption, and backend admission are hard prerequisites.
+ * Failures propagate to `main`, which exits before opening the shell.
  *
  * 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).
+ * (the dev/dogfood lever), otherwise `getSubscriptionStatus` must succeed.
  */
 export declare function resumeOrCreateSession(appsyncClient: AppSyncClient, deps?: {
     resolveSessionIdFn?: (client: AppSyncClient) => Promise<string | null>;
+    /** Already verified by CLI startup; avoids a contradictory second lookup. */
+    tier?: Tier;
+    /** Claims lifecycle responsibility immediately after backend admission. */
+    onAdmitted?: (session: Session) => void;
 }): Promise<{
     session: Session;
     tier: Tier;
 }>;
+export declare function resolveCliTier(appsyncClient: AppSyncClient): Promise<Tier>;
+/** Production startup boundary: preserve actionable typed tier failures. */
+export declare function resolveCliTierForStartup(appsyncClient: AppSyncClient, writeError?: (message: string) => void): Promise<Tier | null>;
+export interface AdmittedSessionOwnershipController {
+    /** Synchronous admission edge; safe to call from the pending-ledger helper. */
+    onAdmitted(session: Session): void;
+    /** Run post-admission startup until the shell accepts teardown ownership. */
+    run<T>(launch: (acceptOwnership: () => void) => Promise<T>): Promise<T>;
+    /** Close a failed bootstrap and retire any session already admitted. */
+    abort(): Promise<void>;
+}
+/**
+ * Install lifecycle ownership before admission begins. The pending-create path
+ * calls `onAdmitted` immediately after response validation, before any further
+ * keychain or ledger await, closing the post-admission cleanup/signal window.
+ */
+export declare function createAdmittedSessionOwnershipController(appsyncClient: AppSyncClient): AdmittedSessionOwnershipController;
+/** Test/consumer convenience for a session that has already been admitted. */
+export declare function runWithAdmittedSessionOwnership<T>(args: {
+    appsyncClient: AppSyncClient;
+    session: Session;
+    launch: (acceptOwnership: () => void) => Promise<T>;
+}): Promise<T>;
 /**
  * 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
@@ -124,7 +135,6 @@ export interface ParsedAuditArgs {
 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
@@ -220,7 +230,7 @@ export declare function main(argv: string[]): Promise<number>;
  *
  * Exported for unit tests; production callers go through `main()`.
  */
-export declare function buildProductionPlannerStack(appsyncClient: AppSyncClient, emitter: (args: ShellEventEmit) => Promise<void>): {
+export declare function buildProductionPlannerStack(appsyncClient: AppSyncClient, emitter: (args: ShellEventEmit) => Promise<unknown>): {
     adapter: BackendPlannerClient;
     cache: PlannerCacheLayer;
     health: PlannerHealthMachine;
@@ -247,6 +257,11 @@ export interface BuildTeamLocalExecutorResult {
      * `BuildQuorumLoopExecutorResult.policyRejectionTap`).
      */
     policyRejectionTap: PolicyRejectionTap;
+    /**
+     * A1e (P3 slice-wiring REMAP) — the dispatch-context tap holder (see
+     * `BuildQuorumLoopExecutorResult.dispatchContextTap`).
+     */
+    dispatchContextTap: DispatchContextTap;
     /**
      * PHASE-589/469 W3.2 — the two-phase group-escalation decision deps (WITHOUT
      * the store; `runOrchestrationShell` completes it). Threaded into
@@ -288,6 +303,24 @@ export interface PolicyRejectionTap {
         recommendedRecovery: string;
     }) => void;
 }
+/**
+ * A1e (P3 slice-wiring REMAP) — the dispatch-context tap holder (mirrors
+ * `progressTap`). `cli.ts` builds it with an inert `fn` (returns `''` — no
+ * block); the QuorumLoop's `projectDispatchContext` calls
+ * `dispatchContextTap.fn(input)`, and `runOrchestrationShell` installs the
+ * real composer (`composeDispatchContextBlock` — the resolved `context_ref`
+ * slice + the fresh-only `repo_state` overview + the §8.3 background
+ * re-delegation hook) at startup, where the shell's generator/tier/session
+ * scope lives. Until then (and for non-loop sessions) the projection is
+ * inert and the implementor stdin is byte-identical to pre-A1e.
+ */
+export interface DispatchContextTap {
+    fn: (input: {
+        taskId: string;
+        agent: string;
+        roundNumber: number;
+    }) => Promise<string>;
+}
 /**
  * [Gemma classifier · D11 + §Wiring] Resolve the reviewer verdict classifier
  * threaded onto `QuorumLoopDeps.classifyVerdict`.
@@ -318,6 +351,11 @@ export interface BuildQuorumLoopExecutorResult {
      * (a classified `SHELL_ADVISORY`).
      */
     policyRejectionTap: PolicyRejectionTap;
+    /**
+     * A1e (P3 slice-wiring REMAP) — the dispatch-context tap holder. `cli.ts`
+     * threads it into `runOrchestrationShell`, which installs the real composer.
+     */
+    dispatchContextTap: DispatchContextTap;
 }
 /**
  * CP-1.f §3.C — Stage-2 r2 (Codex) FIX B. Construct the SINGLE-TASK QuorumLoop +
@@ -345,7 +383,7 @@ export interface BuildQuorumLoopExecutorResult {
 export declare function buildQuorumLoopExecutor(args: {
     appsyncClient: AppSyncClient;
     session: Session;
-    emitter: (args: ShellEventEmit) => Promise<void>;
+    emitter: (args: ShellEventEmit) => Promise<unknown>;
     /** 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. */
@@ -357,17 +395,6 @@ export declare function buildQuorumLoopExecutor(args: {
      */
     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
@@ -379,7 +406,7 @@ export declare function mapTeamLeEventToShellEmit(e: Parameters<LEEmitShellEvent
 export declare function buildTeamLocalExecutor(args: {
     appsyncClient: AppSyncClient;
     session: Session;
-    emitter: (args: ShellEventEmit) => Promise<void>;
+    emitter: (args: ShellEventEmit) => Promise<unknown>;
     initialScope: AuthorityScope;
     /** CP-1.f LOCK RP-6 — host-detected agents threaded into the loop. */
     detectedAgents?: string[];