@quantiya/codevibe-core 2.0.6 → 2.0.7

package/dist/orchestration-shell/emit-shell-event.d.ts

@@ -1,10 +1,11 @@
 import { AppSyncClient } from '../appsync';
+import { type Session } from '../types';
 /**
  * §3 LOCK lines 173-181. Names + per-type metadata shapes are part of
  * the Stage A contract. CP-1.a ships the union; CP-1.b/c/d add call
  * sites for each emit type.
  */
-export type NewEventTypeKind = 'MODE_SELECTED' | 'PLANNER_DECISION' | 'PLANNER_CACHE_HIT' | 'PLANNER_DEGRADED' | 'PLANNER_OUTAGE' | 'PLANNER_RECOVERED' | 'SLASH_COMMAND_INVOKED' | 'STRUCTURAL_SUMMARY_GENERATED' | 'LOCAL_AUTHORITY_REFUSAL' | 'NOTIFICATION' | 'ASSISTANT_RESPONSE' | 'USER_PROMPT';
+export type NewEventTypeKind = 'MODE_SELECTED' | 'PLANNER_DECISION' | 'PLANNER_CACHE_HIT' | 'PLANNER_DEGRADED' | 'PLANNER_OUTAGE' | 'PLANNER_RECOVERED' | 'SLASH_COMMAND_INVOKED' | 'STRUCTURAL_SUMMARY_GENERATED' | 'LOCAL_AUTHORITY_REFUSAL' | 'NOTIFICATION' | 'TEAM_DECOMPOSED' | 'TEAM_TRACK_STATUS' | 'TEAM_GROUP_RESOLVED' | 'ASSISTANT_RESPONSE' | 'USER_PROMPT' | 'INTERACTIVE_PROMPT';
 /**
  * §3 LOCK lines 160-170. ShellEventEmit contract.
  *
@@ -29,6 +30,10 @@ export interface ShellEventEmit {
     isEncrypted: true;
     /** RFC3339; if omitted, server fills in via existing VTL. */
     timestamp?: string;
+    /** Pre-minted nonce when encrypted metadata must bind the response nonce. */
+    writerEventNonce?: string;
+    /** Proven local key mismatch: emit the safe legacy joined fallback. */
+    disableWriterAttestation?: boolean;
 }
 /**
  * Test seam — allows the unit tests to swap the AppSync client without
@@ -38,27 +43,43 @@ export interface ShellEventEmit {
 export interface EmitShellEventDeps {
     appsyncClient: Pick<AppSyncClient, 'createEvent'>;
     getSessionKey: (sessionId: string) => Promise<string | null>;
-    getCohortFlag: (name: string, sessionId: string) => Promise<boolean>;
+    session?: Session;
 }
+export type ShellEventEmitResult = {
+    emitted: true;
+    eventId: string;
+    sessionId: string;
+    type: NewEventTypeKind;
+    source: 'DESKTOP';
+    writer?: {
+        authenticated: true;
+        eventNonce: string;
+        contentCiphertextSha256: string;
+        metadataCiphertextSha256: string;
+    };
+} | {
+    emitted: false;
+    reason: 'missing_session_key' | 'auth_required' | 'auth_unavailable' | 'create_failed' | 'definitive_rejection' | 'invalid_response' | 'writer_ineligible';
+    error?: unknown;
+};
 /**
- * §3 LOCK lines 184-207. Single chokepoint enforcing the cohort-flag
- * gate + encryption invariants for all 9 new EventTypes.
+ * §3 LOCK lines 184-207. Single chokepoint enforcing the encryption
+ * invariants for all 9 new EventTypes.
  *
- * When the cohort flag is off: log at debug and return without
- * touching AppSync. When on: encrypt content + metadata under the
- * session key, call `createEvent` via Pattern B Lambda resolver
- * (existing surface, no schema change).
+ * Encrypts content + metadata under the session key, then calls
+ * `createEvent` via Pattern B Lambda resolver (existing surface, no
+ * schema change). Emits unconditionally (the cohort gate was removed).
  *
  * `deps` is the test seam. Production callers omit it and the function
  * resolves the default `keychainManager` + `cryptoService` references.
  * The AppSync client is REQUIRED — there is no global default in
  * codevibe-core (each plugin instantiates its own `AppSyncClient`).
  */
-export declare function emitShellEvent(args: ShellEventEmit, deps: EmitShellEventDeps): Promise<void>;
+export declare function emitShellEvent(args: ShellEventEmit, deps: EmitShellEventDeps): Promise<ShellEventEmitResult>;
 /**
  * Convenience helper for production callers — binds default
- * dependencies (`keychainManager` for session-key lookup,
- * `getCohortFlag` for the flag read) and accepts the AppSync client
- * separately because there's no global default in `codevibe-core`.
+ * dependencies (`keychainManager` for session-key lookup) and accepts
+ * the AppSync client separately because there's no global default in
+ * `codevibe-core`.
  */
-export declare function createShellEventEmitter(appsyncClient: Pick<AppSyncClient, 'createEvent'>): (args: ShellEventEmit) => Promise<void>;
+export declare function createShellEventEmitter(appsyncClient: Pick<AppSyncClient, 'createEvent'>, session?: Session): (args: ShellEventEmit) => Promise<ShellEventEmitResult>;

package/dist/orchestration-shell/explicit-tty-exit.d.ts

@@ -0,0 +1,18 @@
+export interface ExplicitTtyExitDeps {
+    runPlannerTeardown: () => Promise<void>;
+    retireSession: () => Promise<void>;
+    unmount: () => void;
+}
+export interface ExplicitTtyExitCoordinator {
+    completion: Promise<void>;
+    start: () => void;
+}
+/**
+ * Owns the explicit `/exit` and `/quit` boundary for the Ink shell.
+ *
+ * Ink's `waitUntilExit()` normally resolves after `unmount()`, but terminal
+ * stream teardown can leave that promise pending. The explicit completion
+ * promise lets the shell continue into its catch-all cleanup after the durable
+ * session retirement has finished, independent of Ink's internal exit promise.
+ */
+export declare function createExplicitTtyExitCoordinator(deps: ExplicitTtyExitDeps): ExplicitTtyExitCoordinator;

package/dist/orchestration-shell/gate-prompts.d.ts

@@ -71,8 +71,8 @@ export interface GatePromptOption {
     readonly description: string;
     /**
      * PHASE-CP-10-MIN (#585) — the per-option target agent for the
-     * `continuation_offer_handoff` prompt (CLAUDE/CODEX/GEMINI/ANTIGRAVITY).
-     * On the wire the 3-4 agent options all carry `id: "CONTINUE_WITH"` (a valid
+     * `continuation_offer_handoff` prompt (CLAUDE/CODEX/ANTIGRAVITY).
+     * On the wire the 3 agent options all carry `id: "CONTINUE_WITH"` (a valid
      * `UserDecisionKind`); the agent rides this NEW per-option `targetAgent`
      * field (Rust `OptionPayload.target_agent` with
      * `#[serde(rename="targetAgent", skip_serializing_if="Option::is_none")]`,
@@ -114,7 +114,7 @@ export interface GatePromptEnvelope {
     readonly verdictDetails?: GateVerdictDetails;
     /** The continuation offer's desktop-minted ULID (`metadata.offerId`). */
     readonly offerId?: string;
-    /** The agent that halted (closed enum CLAUDE/CODEX/GEMINI/ANTIGRAVITY; `metadata.sourceAgent`). */
+    /** The agent that halted (closed enum CLAUDE/CODEX/ANTIGRAVITY; `metadata.sourceAgent`). */
     readonly sourceAgent?: string;
     /** The authoritative 64-hex SHA-256 packet hash (`metadata.packetHash`). */
     readonly packetHash?: string;

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

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { AppSyncClient } from '../appsync';
 import { Session } from '../types';
 import { OrchestrationStore } from './store';
@@ -6,9 +7,11 @@ import { type GroupDecisionSubmitDeps } from './gate-decision-submit';
 import { type ContinuationCliResult, type ContinuationCliDeps } from './slash-routes/continuation';
 import { loadReviewerWizardData } from './slash-routes/reviewers';
 import { createShellEventEmitter } from './emit-shell-event';
+import { type AgentMentionIntent, type CommandIntentTarget } from './command-intent';
+import { type BrainstormPanelActiveAgent } from './brainstorm-quorum';
 import { type RunAuditBrowserResult } from './audit-runner';
 import { Tier } from './types';
-import type { PendingClarification } from './types';
+import type { ConversationEntry, PendingClarification } from './types';
 import { type GatePromptEnvelope, type DecryptedReviewSummaryInput } from './gate-prompts';
 import type { Event, UpdateEventStatusInput } from '../types/events';
 import { type StructuralSummaryGenerator } from '../structural-summary';
@@ -21,7 +24,13 @@ import type { WorkItemInput, DisjointnessRejection, RevertManifestStore } from '
 import type { QuorumLoop } from './quorum-loop';
 import { ensureFreshContextStore } from './context-store';
 import type { EnsureFreshResult } from './context-store';
+import { contextItemOccurrence, type ContextDurabilityReceipt } from './context-items';
+import { renderRehydratedSessionContext } from './context-compaction';
 import { type TaskProgressEvent } from './task-progress';
+export declare class OrchestrationShellStartupError extends Error {
+    readonly cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
 export interface RunOrchestrationShellArgs {
     /** Authenticated AppSync client (caller is responsible for `authenticateWithStoredTokens`). */
     appsyncClient: AppSyncClient;
@@ -29,6 +38,11 @@ export interface RunOrchestrationShellArgs {
     session: Session;
     /** Current tier — used by the StatusBar + downstream tier gating. */
     tier: Tier;
+    /**
+     * Startup lifecycle handoff. Called only after this function's catch-all
+     * teardown `finally` is armed; until then the admitting CLI owns retirement.
+     */
+    acceptSessionLifecycleOwnership?: () => void;
     /**
      * CP-1.b IMPL r2 H-3 — Optional planner adapter. When supplied,
      * `runOrchestrationShell` binds the active session via
@@ -93,7 +107,7 @@ export interface RunOrchestrationShellArgs {
      *   (a) subscribes `subscribeToClassBPackets(session.userId)` →
      *       `localExecutor.consumeClassB(packet)` (item 2) + teardown cleanup;
      *   (b) enables the `/team` slash command (item 5).
-     * A single-track/Companion/stub session OMITS this — no Class B
+     * A single-track/Companion session OMITS this — no Class B
      * subscription, no team mode, no status node (byte-identical behavior).
      */
     localExecutor?: LocalExecutor;
@@ -128,7 +142,7 @@ export interface RunOrchestrationShellArgs {
      * `runOrchestrationShell` installs the store-dispatching `fn` so the loop's
      * `onProgress` events render as an ephemeral spinner line + persisted
      * milestones, and emits `waiting_user` when a gate prompt arrives. A non-loop
-     * / Companion / stub session OMITS this — no spinner line ever renders.
+     * / Companion session OMITS this — no spinner line ever renders.
      */
     progressTap?: {
         fn: (event: TaskProgressEvent) => void;
@@ -140,7 +154,7 @@ export interface RunOrchestrationShellArgs {
      * PolicyRejection becomes a classified `SHELL_ADVISORY` in the conversation
      * (the existing mobile NOTIFICATION path is unchanged). The shadow-discard side
      * is handled by `cli.ts` (which holds the QuorumLoop reference). A non-loop /
-     * Companion / stub session OMITS this.
+     * Companion session OMITS this.
      */
     policyRejectionTap?: {
         fn: (info: {
@@ -149,6 +163,22 @@ export interface RunOrchestrationShellArgs {
             recommendedRecovery: string;
         }) => void;
     };
+    /**
+     * A1e (P3 slice-wiring REMAP) — the dispatch-context tap holder (`cli.ts`
+     * builds it alongside the loop). When present, `runOrchestrationShell`
+     * installs the real composer (`composeDispatchContextBlock`): the resolved
+     * `context_ref` structural slice + the FRESH-ONLY `repo_state` overview,
+     * with the §8.3 stale→background-re-delegation hook wired to the quiet
+     * frontier re-read. A non-loop / Companion session OMITS this — the
+     * implementor stdin stays byte-identical to pre-A1e.
+     */
+    dispatchContextTap?: {
+        fn: (input: {
+            taskId: string;
+            agent: string;
+            roundNumber: number;
+        }) => Promise<string>;
+    };
     /**
      * PHASE-589/469 W3.2 — the two-phase group-escalation decision deps, built in
      * `cli.ts` alongside the team LE (the keychain/E2E/signing-heavy assembly:
@@ -189,10 +219,12 @@ export interface TeamTapEvent {
 }
 export { processMarkers, withRoleMarker } from './process-markers';
 export { emitShellEvent, createShellEventEmitter, type ShellEventEmit, type NewEventTypeKind, } from './emit-shell-event';
-export { pickMode, TierError, type ParsedModeArgs, type ModeSelectionDeps, } from './mode-selection';
+export { pickMode, type ModeSelectionDeps, } from './mode-selection';
 export { readStickyPreference, writeStickyPreference, stickyPreferenceFilePath, } from './sticky-preference';
-export { getCohortFlag, cohortFlagFilePath } from './cohort-flag';
-export { deriveWorkspaceId, deriveRepoId, normalizeRepoRelativePath, contextStoreDir, loadContextStore, writeContextStore, computeSummaryInputHash, probeFreshness, ensureFreshContextStore, mintContextRef, resolveContextRef, sliceSummary, type ContextRef, type SliceSelector, type SliceSelectorEntry, type ContextStoreMetadata, type ContextStoreEntry, type ResolvedContextSlice, type FreshnessProbeResult, type EnsureFreshResult, type EnsureFreshDeps, } from './context-store';
+export { deriveWorkspaceId, deriveRepoId, normalizeRepoRelativePath, contextStoreDir, loadContextStore, writeContextStore, writeRepoState, loadRepoState, type RepoStateRecord, gcContextStore, computeSummaryInputHash, probeFreshness, ensureFreshContextStore, mintContextRef, resolveContextRef, sliceSummary, type ContextRef, type SliceSelector, type SliceSelectorEntry, type ContextStoreMetadata, type ContextStoreEntry, type ResolvedContextSlice, type FreshnessProbeResult, type EnsureFreshResult, type EnsureFreshDeps, } from './context-store';
+export { CONTEXT_SESSION_PSEUDO_TASK_NAMESPACE, deriveSessionPseudoTaskId, auditPartitionTaskIdFor, appendContextItem, flushContextItems, readContextItems, readVerifiedContextItems, verifyContextItemChain, buildContextItemWireRow, decryptContextItemWireRow, projectItemsForRole, labelPermitsRole, projectRepoStateForDispatch, appendRepoStateItem, composeDispatchContextBlock, contextItemsLogPath, isTransientContextItem, DISPATCH_CONTEXT_MAX_CHARS, NON_GIT_REPO_STATE_MAX_AGE_MS, type ContextItem, type ContextItemDraft, type ContextItemKind, type ContextItemAuthor, type ContextItemSensitivity, type ContextItemProjectionRole, type ContextItemValidity, type ContextItemWireRow, type RepoStateBody, type RepoStateProjection, type ChainVerificationResult, type VerifiedContextItemsResult, } from './context-items';
+export { configureContextItemsHostedSync, wakeContextItemsHostedSync, drainContextItemsHostedSync, clearContextItemsHostedSync, contextItemsHostedSyncStatePath, type ContextItemsHostedSyncDeps, } from './context-items-hosted-sync';
+export { compactSessionContext, maybeFireCompactionSafetyValve, rehydrateSessionContext, renderRehydratedSessionContext, distillItems, projectDistilledForRole, loadCompactionCache, compactionCachePath, onTaskBoundary, gcContextItemLogs, scheduleContextItemsGc, COMPACTION_SAFETY_VALVE_TAIL_BYTES, COMPACTION_KEEP_HOT_RECENT_ITEMS, CONTEXT_ITEMS_RETENTION_MS, SESSION_CONTEXT_SECTION_MAX_CHARS, type DistilledFact, type DistilledTaskSummary, type SessionCompactionCache, type CompactionResult, type RehydratedSessionContext, } from './context-compaction';
 export { routeSlashCommand, applySlashOutput, type SlashOutput, type ShellAction, } from './slash-router';
 export { buildAuditBrowserModel, routeAuditEntry, auditKindLabel, auditKindCopy, renderAuditBrowserText, renderAuditEntryText, ENTRY_DETAILS_UNAVAILABLE, NO_AUDIT_ENTRIES, AUDIT_LOG_TOO_LARGE, AUDIT_LOG_TITLE, AUDIT_BROWSER_MAX_HEADLINE, WIRE_PUBLIC_PLAINTEXT_KINDS, type AuditBrowserModel, type AuditEntryModel, type AuditReviewerVerdictModel, type AuditTaskAuthorizedModel, type DecryptContentFn, } from './audit-browser';
 export { runAuditBrowser, renderAuditResultText, AUDIT_BROWSER_UPGRADE_HINT, type RunAuditBrowserResult, type RunAuditBrowserDeps, } from './audit-runner';
@@ -202,6 +234,59 @@ export { createOrchestrationStore, type OrchestrationStore } from './store';
 export type { Mode, Tier, PlannerDecision, AgentKind, PlannerHealthState, RunningTaskState, ReviewerSeatState, GateState, ExecutionEventEntry, RefusalEventEntry, BypassEventEntry, MobileEventEntry, EventStreamEntry, ConversationEntry, QueuedTask, PendingClarification, OrchestrationState, OrchestrationAction, LastModeFile, TeamState, TeamTrackEntry, TeamTrackState, TeamMergeGateStatus, LiveProgress, } from './types';
 export { formatElapsed, isSpinnerPhase, renderProgressLine, type TaskProgressEvent, type OnProgress, } from './task-progress';
 export { runDeclaredTestSurfaces, DECLARED_TEST_TIMEOUT_MS, type DeclaredTestResult, type DeclaredTestReason, type RunDeclaredTestSurfacesArgs, } from './declared-test-runner';
+/**
+ * [A1g] Round-5 (Codex round-4 MEDIUM) — INVOCATION-OWNED conversation deltas.
+ *
+ * The turn mirror (`emitOrchestrationTurnMirror`) authors THIS turn's conductor
+ * reply + mobile `ASSISTANT_RESPONSE` from the entries this submission produced.
+ * It USED to slice a GLOBAL window (`conversation.slice(convLenBefore)` → end),
+ * which is only sound for a strictly-serialized turn. A slash COMMAND bypasses
+ * the NL queue (`serializeShellSubmissions`), so it runs CONCURRENTLY with an
+ * in-flight `@all` panel / NL turn; the global window then bleeds in the
+ * concurrent turn's non-`localOnly` advisory (e.g. the panel's joined
+ * `### Agent …` blob), which the bypassing (always-UNOWNED) mirror would author
+ * as its OWN conductor turn — MISATTRIBUTING the agents' design output to the
+ * conductor (defeating the F2 suppression the owning turn applies).
+ *
+ * The fix attributes each newly-appended `ConversationEntry` to the submission
+ * that dispatched it. `AsyncLocalStorage` carries a per-submission `ownEntries`
+ * sink; the wrapped `store.dispatch` (below) pushes each new conversation entry
+ * into the CURRENTLY-EXECUTING submission's sink. ALS propagates the context
+ * across `await`s AND isolates concurrent submissions, so `@all`'s advisory
+ * lands in `@all`'s sink and a concurrent `/status`'s mirror never sees it. The
+ * mirror then authors from `ownEntries` (this turn's OWN entries), not the
+ * global slice. Backward-compatible: callers/tests that pass no `ownEntries`
+ * fall back to the `convLenBefore` slice (unchanged behavior).
+ */
+export interface TurnAuthoringSink {
+    ownEntries: ConversationEntry[];
+}
+export declare const turnAuthoringContext: AsyncLocalStorage<TurnAuthoringSink>;
+/**
+ * [A1g] Round-5 (Codex round-4 MEDIUM) — install the invocation-owned-delta
+ * attribution wrapper on `store.dispatch`. After each dispatch, any NEWLY
+ * appended `ConversationEntry` is pushed into the CURRENTLY-EXECUTING
+ * submission's `ownEntries` sink (from `turnAuthoringContext`). ALS hands the
+ * wrapper the right sink even across `await`s and through the whole handler
+ * call tree, so concurrent submissions (a slash bypass vs. an in-flight `@all`)
+ * never cross-contaminate each other's invocation-owned delta. Dispatched
+ * outside a submission (no active sink) ⇒ no attribution (those entries were
+ * never part of a turn's mirror anyway). Exported so the concurrent-isolation
+ * property can be unit-tested without spinning up the full TUI.
+ *
+ * [A1g] Round-6 (Codex round-5 MEDIUM) — detect new entries by ulid IDENTITY,
+ * NOT by `conversation.length` growth. The conversation is a RING BUFFER that
+ * front-evicts at `CONVERSATION_BUFFER_MAX` (reducer.ts `appendConversation`),
+ * so once at capacity an append keeps `length` FLAT — a length-growth test
+ * would then collect NOTHING, so the mirror emits neither the companion prompt
+ * nor the reply AND omits the human ContextItem, while the ownership token
+ * still drains the buffered panel replies → agent turns persisted WITHOUT their
+ * human question (fail-closed question-before-answer violation). An id-set diff
+ * is eviction-proof. A reentrancy depth-guard ensures a synchronous nested
+ * dispatch (a subscriber that re-dispatches) is attributed exactly once by the
+ * OUTERMOST diff — never double-pushed.
+ */
+export declare function installTurnAuthoringDispatchWrapper(store: OrchestrationStore): void;
 /**
  * §5 lines 336-365 LOCK + §16 LOCK #14. Single entrypoint that wires
  * the store + emit chokepoint + slash router and either mounts the
@@ -339,6 +424,42 @@ export declare function createSubscribedEventDispatcher(deps: {
  * #469]). Called from the `teamShellEventTap.fn` installed at startup.
  */
 export declare function routeTeamShellEventToStore(store: OrchestrationStore, evt: TeamTapEvent): void;
+export declare const BRAINSTORM_PANEL_ADVISORY_TIMEOUT_MS = 1800000;
+export declare function routeReadOnlyAgentMention(args: {
+    store: OrchestrationStore;
+    shellArgs: RunOrchestrationShellArgs;
+    intent: AgentMentionIntent;
+    advisoryBrief: string;
+    /**
+     * [#637] This turn's validated image attachments + the ordered `[Image #N]`
+     * chip-path list — the SAME `turnAttachments`/`turnImagePaths` pair the /task
+     * path threads into `composeImplementationBrief`. When present, the panel
+     * dispatch rewrites the brief's image tokens to staged in-worktree refs and
+     * appends a per-agent read-list per cell, so a CLI advisory agent receives
+     * real file refs instead of the literal chip token / a raw local path.
+     */
+    attachments?: ImageAttachment[];
+    attachmentPaths?: string[];
+    /**
+     * [#637] ALL `@`-mention targets of this turn (ordered, de-duplicated —
+     * `extractAllAgentMentionIntents`). Widens ONLY the LOCAL panel active set on
+     * a multi-mention directed turn; the FROZEN `CommandIntentEnvelope` still
+     * carries the FIRST mention (`args.intent`). Absent/single-element → exactly
+     * the prior directed behavior.
+     */
+    mentionTargets?: readonly CommandIntentTarget[];
+    /**
+     * [A1g] Round-4 — the per-turn ownership token this invocation stamps when it
+     * commits to a panel turn (see `BrainstormTurnOwnership`). Optional so direct
+     * unit callers/tests can omit it; the turn-mirror reads the SAME object to
+     * decide whether to drain this turn's buffered replies.
+     */
+    turnOwnership?: BrainstormTurnOwnership;
+    emitShellEventBound?: ReturnType<typeof createShellEventEmitter>;
+    promptText?: string;
+    promptOrigin?: 'desktop' | 'mobile';
+    mobilePromptEventId?: string;
+}): Promise<boolean>;
 /**
  * PHASE-590 §3.D step 0 / §4.4 — compose the LOSSLESS implementation brief.
  *
@@ -483,6 +604,8 @@ export declare function routeTeamDecompose(deps: {
     /** Stage-2 R3 HIGH — the loop's durable store, so the live launch persists the retained spec + attachments. */
     durableStore?: RevertManifestStore;
 }): Promise<void>;
+/** Test seam — reset the module-level A1e composer (vitest-gated). */
+export declare function resetDispatchContextComposerForTests(): void;
 /**
  * CP-4 §4.1 (#600) — `familiarize` desktop route: the context-priming task.
  *
@@ -566,6 +689,23 @@ export declare function routeAdvisory(deps: {
     args: RunOrchestrationShellArgs;
     userPrompt: string;
     images: string[];
+    /**
+     * #619 — recent conversation turns for the TEXT-ONLY answerer case. When an
+     * `advisory_response` lands mid-conversation, the classifier's inline
+     * `advisory_summary` is BLIND to context (it rendered a meta-monologue "I
+     * will provide a helpful response…" in real dogfood). With `priorTurns`
+     * threaded, THIS produces the sole answer instead: a context-aware direct
+     * reply from the local answerer. Turns are already bounded + per-turn capped
+     * by the collector (compact-don't-wipe).
+     */
+    priorTurns?: string[];
+    /**
+     * #619 Stage-2 (Codex LOW) — how many images the USER attached this turn,
+     * regardless of how many survived base64 read. When >0 but `images` is empty
+     * (all unreadable), the prompt keeps the image framing so the model says the
+     * image couldn't be used instead of answering as if none was attached.
+     */
+    attemptedImages?: number;
 }): Promise<void>;
 export declare function parseTeamWorkItems(rawArg: string): {
     ok: true;
@@ -611,6 +751,16 @@ export interface HandleShellUserInputDeps extends StructuralSummaryRunDeps {
      * and the `[Image #N]` labels are stripped from the classify prompt.
      */
     images?: string[];
+    /**
+     * The submission's origin. `'mobile'` marks the mobile→desktop RETURN path
+     * (`routeMobileUserPrompt` → the serialized submission wrapper): the turn mirror
+     * suppresses USER_PROMPT to avoid duplicating the phone's sent message, while
+     * pending planner offers remain answerable because F4 mirrors them as
+     * INTERACTIVE_PROMPT. Absent ⇒ a keyboard turn.
+     */
+    inputOrigin?: 'mobile';
+    /** Loaded mobile USER_PROMPT event id used as the structured turn anchor. */
+    inputOriginEventId?: string;
     /** Test seam — defaults to the real `addBodyPath`. */
     addBodyPathFn?: (path: string, tier: Tier) => Promise<unknown>;
     /** Test seam — defaults to the real `regenerateStructuralSummary`. */
@@ -645,6 +795,12 @@ export interface HandleShellUserInputDeps extends StructuralSummaryRunDeps {
      * touching the filesystem / git.
      */
     ensureFreshContextStoreFn?: typeof ensureFreshContextStore;
+    /**
+     * Test seam for the local planner's canonical multi-turn context projection.
+     * Production uses the same role-filtered ContextItems renderer used by agent
+     * dispatch; hosted-planner turns do not call it.
+     */
+    renderRehydratedSessionContextFn?: typeof renderRehydratedSessionContext;
     /**
      * `/reviewer-setup` wizard (2026-06-29) — Test seam for the async wizard-open
      * data load. Defaults to the real `loadReviewerWizardData` (detect installed
@@ -660,6 +816,14 @@ export interface HandleShellUserInputDeps extends StructuralSummaryRunDeps {
      * path (vitest runs non-TTY) and `() => false` for the fallback advisory.
      */
     isInteractiveTtyFn?: () => boolean;
+    /**
+     * [A1g] Round-4 — the per-turn brainstorm-panel ownership token minted by
+     * `serializeShellSubmissions` for THIS submission. The read-only `@`-mention
+     * router stamps `brainstormPanelOwned` on it when it commits to a panel turn;
+     * the turn-mirror reads the SAME object to decide whether to drain this turn's
+     * buffered replies. Optional — direct unit callers/tests may omit it.
+     */
+    turnOwnership?: BrainstormTurnOwnership;
 }
 /**
  * Slash + natural-language dispatch. Extracted from `runOrchestrationShell`
@@ -699,6 +863,8 @@ export interface ShellSubmitOptions {
      * keyboard turn (both `USER_PROMPT` + `ASSISTANT_RESPONSE` mirror as today).
      */
     fromMobile?: boolean;
+    /** Exact loaded MOBILE USER_PROMPT anchor for an attributed agent turn. */
+    mobilePromptEventId?: string;
 }
 export declare function serializeShellSubmissions(handler: (text: string, images?: string[], options?: ShellSubmitOptions) => Promise<void>): (text: string, images?: string[], options?: ShellSubmitOptions) => Promise<void>;
 /**
@@ -738,37 +904,123 @@ export declare function buildContinuationActionDeps(args: RunOrchestrationShellA
 export declare function detectBrowseFastPath(text: string, pending: PendingClarification | null): string[] | null;
 export declare function handleShellUserInput(deps: HandleShellUserInputDeps): Promise<void>;
 /**
- * COMPANION-MIRROR (dogfood 2026-07-05) — mirror ONE just-completed conversational
- * (natural-language) turn to the backend so the paired mobile companion can SEE the
- * orchestration chat.
- *
- * The orchestration shell previously emitted only MODE_SELECTED (+ NOTIFICATION
- * audits + the team-result ASSISTANT_RESPONSE) to the backend — a plain `"hi"` →
- * planner-greeting turn produced NO `USER_PROMPT` / `ASSISTANT_RESPONSE`, so the phone
- * showed nothing for conversational turns. This mirrors, per turn, via the SAME
- * cohort-gated + E2E-encrypted `emitShellEvent` chokepoint MODE_SELECTED uses:
- *   - USER_PROMPT        — the user's submitted text (this turn's `user-message` entry)
- *   - ASSISTANT_RESPONSE — the planner/shell conversational reply rendered this turn
- *
- * Scope = CONVERSATIONAL (NON-team) turns:
- *   - No `user-message` appended this turn (slash command / empty input) ⇒ nothing to
- *     mirror (return early — slash commands already emit their own SLASH_COMMAND_INVOKED).
- *   - This turn was a `start_task` / `team_decompose` decision ⇒ the reply is OWNED by
- *     the team-result path (`emitGroupConvergence` → `leEmitShellEvent`, which emits its
- *     OWN ASSISTANT_RESPONSE when the team converges — cli.ts `mapTeamLeEventToShellEmit`).
- *     We emit ONLY the USER_PROMPT and leave the reply to that path — NO double-emit.
- *     The reducer ALWAYS appends a (TUI-hidden) `planner-decision` entry, so the delta
- *     carries the action even though the team launch's TASK_LIFECYCLE may land async.
- *
- * Ordering: USER_PROMPT carries the turn-start timestamp and ASSISTANT_RESPONSE a
- * later `new Date()` (classify took real time), so the companion's (timestamp,id) sort
- * renders prompt-before-reply.
- *
- * Fail-soft: an emit throw is logged, never fatal to the shell — matching the sibling
- * MODE_SELECTED emit. The stub-session refusal + cohort gate + no-session-key
- * fail-closed all live INSIDE `emitShellEvent`; we route through it (never bypass it)
- * and pass PLAINTEXT `content` (the chokepoint encrypts under the session key).
+ * [A1g] Stage-2 round-4 (Codex round-3 MEDIUM) — the EXPLICIT per-turn panel-
+ * ownership token. `serializeShellSubmissions` mints ONE fresh object per
+ * submission and threads it into BOTH `handleShellUserInput` (whose router SETS
+ * `brainstormPanelOwned` at the SAME point it commits to a panel turn + buffers
+ * replies) AND the turn-mirror (which DRAINS the buffered replies and suppresses
+ * step-4b conductor authoring iff owned). Ownership is decided by the ACTUAL
+ * router this invocation — never re-inferred from the current turn's text.
+ *
+ * Re-inferring from `userEntry.text` (the prior `isBrainstormMentionTurn` probe)
+ * was WRONG on two paths: (a) a clarification-ANSWER turn that carries an earlier
+ * `@agent` override routes the panel (via `agentMentionIntentFromOverride` →
+ * `suppressMentionLocalAnswer`), yet its OWN text has no leading `@`-mention, so
+ * the mirror failed to drain — leaking a stale buffered reply into a LATER
+ * mention turn; (b) a bypassing slash command (`/status`) has no user-message
+ * entry at all. A per-invocation token is immune to both: the slash / clarify
+ * turn simply never sets it, and the routing turn always does. Replaces the old
+ * session-keyed `brainstormPanelTurns` marker (the token fully subsumes it —
+ * "a panel ran this turn" is exactly `brainstormPanelOwned`).
+ */
+export interface BrainstormTurnOwnership {
+    brainstormPanelOwned: boolean;
+    agentTurn?: {
+        route: 'broadcast' | 'directed';
+        turnId: string;
+        header: string;
+        cells: Array<{
+            authorAgent: BrainstormPanelActiveAgent;
+            status: 'completed' | 'quota_walled' | 'failed';
+            boundedBody: string;
+        }>;
+        prompt: {
+            kind: 'legacy_joined';
+        } | {
+            kind: 'mobile_existing';
+            eventId: string;
+        } | {
+            kind: 'agent_turn_pre_emitted';
+            eventId: string;
+            writerEventNonce: string;
+            contentCiphertextSha256: string;
+            metadataCiphertextSha256: string;
+        } | {
+            kind: 'agent_turn_pre_emit_failed';
+        };
+        responseWriterEventNonce: string;
+        authoring?: {
+            kind: 'committed';
+            receipt: ContextDurabilityReceipt;
+            humanOccurrence: ReturnType<typeof contextItemOccurrence>;
+            agentOccurrences: Map<string, ReturnType<typeof contextItemOccurrence>>;
+        } | {
+            kind: 'authority_failed';
+        };
+    };
+}
+/** Vitest-gated reset for the M5 registry + [A1g] panel state (the established seam pattern). */
+export declare function resetTurnAuthoringStateForTests(): void;
+/**
+ * [A1g] Stage-2 (agy LOW-3) — release a session's turn-authoring + panel state at
+ * shell teardown. The shell is single-session-per-process, so these session-keyed
+ * maps hold ≤1 key in practice; this closes the unbounded-growth seam anyway (and
+ * the pre-existing A1f `openQuestionRegistry` gap) so a long-lived host embedding
+ * the shell across sessions never accumulates dead keys. Idempotent; safe to call
+ * on any exit path. Non-throwing (delete on a Map/Set never throws).
  */
+export declare function clearTurnAuthoringSessionState(sessionId: string): void;
+/**
+ * A1f (design §6 + the A1e-deferred full-vocabulary authoring) — author this
+ * turn's typed ContextItems at the ONE per-turn chokepoint: the turn mirror
+ * runs once per serialized turn (keyboard AND mobile-origin — the §4.2
+ * single write authority folds mobile turns into the chain HERE) with the
+ * turn's conversation delta.
+ *
+ * Deterministic emitter-assigned labels (§4.2 — never the conductor):
+ *  - human `turn` (DURABLE per Finding-2) — Stage-2 R1 H1: labeled
+ *    planner/brainstorm ONLY (conversation, not task contract — §5
+ *    explicitly excludes the full conversation from implementor windows;
+ *    the implementor-sanctioned "answered clarifications + prior handoff
+ *    turns" ride the existing brief-composition path, not this projection).
+ *    An answering turn carries `refs` to the question item it answers (M5).
+ *  - `decision` per planner-decision entry (author `conductor`; durable) —
+ *    broadly visible (task-shaping, §6 distillation payload), task-scoped
+ *    when the decision carries a taskId (H1 scope).
+ *  - `open_question` when THIS turn asked a still-unanswered clarification
+ *    (author `conductor`; durable) — broadly visible ("answered
+ *    clarifications" are §5-sanctioned; the M5 linkage retires it once
+ *    answered).
+ *  - conductor reply `turn` (TRANSIENT — Finding-2 buffer) —
+ *    planner/brainstorm-visible.
+ *
+ * Stage-2 (Codex MEDIUM-2 / agy HIGH-1) — an AWAITABLE per-turn barrier:
+ * every append this turn REGISTERS is collected into `pending` and the
+ * function resolves only once they all settle. `emitOrchestrationTurnMirror`
+ * awaits it, so — since the mirror runs inside `serializeShellSubmissions` —
+ * Turn N's appends are durably registered BEFORE Turn N+1's turn begins (no
+ * cross-turn [T1-human, T2-human, T1-panel] interleave). Registration is still
+ * synchronous (the M5 registry + mutex chain order are unchanged: the only
+ * `await` is the final `Promise.all` after every append is registered). Every
+ * pushed promise is individually `.catch()`-guarded, so the barrier never
+ * rejects — authoring must never fail the turn. Ends with the §6 O(1) mid-task
+ * safety-valve check (fire-and-forget; NOT part of the barrier). Exported for
+ * direct testing.
+ */
+export declare function authorTurnContextItems(deps: {
+    store: OrchestrationStore;
+    sessionId: string;
+    delta: ConversationEntry[];
+    /**
+     * [A1g] Round-4 — did THIS invocation's router commit to a brainstorm-panel
+     * turn (the `BrainstormTurnOwnership` token it stamped)? Only an owning turn
+     * drains its buffered replies + suppresses step-4b. Absent/false ⇒ not a panel
+     * turn (a plain conversational turn, a bypassing slash command, or an untagged
+     * clarification answer that did not itself route a panel).
+     */
+    panelOwnedThisTurn?: boolean;
+    turnOwnership?: BrainstormTurnOwnership;
+}): Promise<void>;
 export declare function emitOrchestrationTurnMirror(deps: {
     store: OrchestrationStore;
     sessionId: string;
@@ -784,6 +1036,23 @@ export declare function emitOrchestrationTurnMirror(deps: {
      * the planner's reply reaches mobile. Absent/false ⇒ a keyboard turn (mirror both).
      */
     skipUserPromptMirror?: boolean;
+    /**
+     * [A1g] Round-4 — the per-turn brainstorm-panel ownership token minted for THIS
+     * submission (see `BrainstormTurnOwnership`). Threaded to `authorTurnContextItems`
+     * as the drain authority. Absent for callers/tests that never route a panel.
+     */
+    turnOwnership?: BrainstormTurnOwnership;
+    /**
+     * [A1g] Round-5 (Codex round-4 MEDIUM) — the conversation entries THIS
+     * submission produced (see `turnAuthoringContext`). When present, the mirror
+     * authors from these INVOCATION-OWNED entries instead of a global
+     * `conversation.slice(convLenBefore)` window — so a concurrent slash bypass's
+     * advisory (or this turn's advisory bleeding into a concurrent bypass) is
+     * never mis-authored to the wrong turn. Absent ⇒ fall back to the
+     * `convLenBefore` slice (unchanged behavior for callers/tests that don't
+     * thread a sink).
+     */
+    ownEntries?: ConversationEntry[];
 }): Promise<void>;
 /**
  * CP-4 §4.2 (Codex r1 M1 — the double-walk unify) — the SINGLE structural-

package/dist/orchestration-shell/mention-suggest.d.ts

@@ -0,0 +1,11 @@
+export interface MentionSuggestion {
+    name: string;
+    blurb: string;
+}
+export declare function buildMentionSuggestions(availableAgents?: readonly string[]): MentionSuggestion[];
+export declare function isMentionInProgress(value: string, cursor?: number): boolean;
+export declare function filterMentionSuggestions(value: string, suggestions: readonly MentionSuggestion[], cursor?: number): MentionSuggestion[];
+export declare function replaceMentionAtCursor(value: string, cursor: number, replacement: string): {
+    value: string;
+    cursor: number;
+};