@quantiya/codevibe-codex-plugin 2.0.6 → 2.0.8

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

@@ -1,14 +1,18 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { AppSyncClient } from '../appsync';
 import { Session } from '../types';
 import { OrchestrationStore } from './store';
+import { AdvisoryAttachmentJournal } from './advisory-attachment-journal';
 import type { ImageAttachment } from './types';
 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 +25,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 +39,13 @@ 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;
+    /** @internal isolated durable advisory-attachment authority for tests. */
+    advisoryAttachmentJournal?: AdvisoryAttachmentJournal;
     /**
      * CP-1.b IMPL r2 H-3 — Optional planner adapter. When supplied,
      * `runOrchestrationShell` binds the active session via
@@ -93,7 +110,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 +145,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 +157,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 +166,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 +222,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 +237,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 +427,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 +607,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 +692,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 +754,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 +798,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 +819,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 +866,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 +907,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 +1039,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/node_modules/@quantiya/codevibe-core/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;
+};

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

@@ -1,20 +1,4 @@
 import { Mode, Tier } from './types';
-/**
- * Thrown when a Free-tier user explicitly requests `--mode orchestration`.
- * Per §2 + §16 LOCK #1: Orchestration Mode is Pro/Max-gated; Free-tier
- * users hit this error with the upgrade URL.
- */
-export declare class TierError extends Error {
-    constructor(message: string);
-}
-/**
- * Parsed arguments the entrypoint hands to `pickMode`. Either flag is
- * optional; a value of `undefined` means "not specified".
- */
-export interface ParsedModeArgs {
-    /** `--mode companion` | `--mode orchestration` | undefined */
-    mode?: Mode;
-}
 /**
  * Test seam — lets the unit tests inject a deterministic prompt
  * callback instead of opening a real TTY.
@@ -28,15 +12,13 @@ export interface ModeSelectionDeps {
  * read or written here.
  *
  * Rules:
- *   1. Free-tier + `--mode orchestration` → `TierError` with upgrade URL.
- *   2. Explicit `--mode` flag → honor it.
- *   3. Free-tier (no flag) → 'companion'.
- *   4. Pro/Max (no flag) → always prompt the user (sticky preference is
+ *   1. Free-tier → 'companion'.
+ *   2. Pro/Max → always prompt the user (sticky preference is
  *      never consulted; the answer is not persisted).
  */
-export declare function pickMode(args: ParsedModeArgs, tier: Tier, deps?: ModeSelectionDeps): Promise<Mode>;
+export declare function pickMode(tier: Tier, deps?: ModeSelectionDeps): Promise<Mode>;
 /**
  * Default deps wiring — production callers can omit `deps` from
- * `pickMode()` and get this. Tests override via the optional 3rd arg.
+ * `pickMode()` and get this. Tests override via the optional 2nd arg.
  */
 export declare function defaultDeps(): ModeSelectionDeps;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/planner-offer-e1.d.ts

@@ -0,0 +1,97 @@
+import type { ShellEventEmit, ShellEventEmitResult } from './emit-shell-event';
+/** The run-scoped shell emitter (`createShellEventEmitter(...)`). */
+export type ShellEmitter = (args: ShellEventEmit) => Promise<ShellEventEmitResult>;
+/** The run-scoped `openPrompts` TTL co-refresh transport (§3.1). */
+export type OpenPromptTtlRefresher = (promptIds: string[]) => Promise<string[]>;
+/** Everything the ledger needs to (re-)emit an offer raise. */
+export interface PlannerOfferRaiseContext {
+    sessionId: string;
+    /** The offer question — the INTERACTIVE_PROMPT content (re-raised verbatim). */
+    content: string;
+    /** The offer payload — the INTERACTIVE_PROMPT metadata (re-raised verbatim). */
+    metadata: Record<string, unknown>;
+    agentType?: string;
+    title?: string;
+}
+/**
+ * The core CORE_OFFER producer ledger + durable-ledger refresh loop. A single
+ * instance lives per process (one orchestration shell per process); `beginRun`
+ * re-binds the transports + resets state for a fresh run.
+ */
+export declare class PlannerOfferE1Ledger {
+    /** Open offers, keyed by the offer's stable `conversationEntryId` (§6a-4). */
+    private readonly raises;
+    /** promptIds whose raise emit is un-acked → retry-until-ack (mirrors the plugins'
+     * `e1NeedsReRaise`). */
+    private readonly needsReRaise;
+    /** promptIds whose resolution emit is un-acked → retry-until-ack (F-C4). */
+    private readonly pendingResolutions;
+    private timer;
+    private emit;
+    private refreshTtl;
+    private readonly refreshMs;
+    private draining;
+    constructor(opts?: {
+        refreshMs?: number;
+    });
+    /**
+     * Install the run-scoped TTL-refresh transport and RESET all per-run state. Call
+     * once at shell start; a re-run (tests) gets a clean ledger + no stale timer.
+     */
+    beginRun(refreshTtl: OpenPromptTtlRefresher): void;
+    /**
+     * F-C1 — raise (or re-present) a planner offer and INSPECT the emit result. On a
+     * transient failure (`{emitted:false}` or a throw) PARK the promptId for
+     * retry-until-ack. First presentation mints a fresh secret + committed promptId;
+     * a re-present across turns reuses it (stable id → the backend re-raises on the
+     * `ownerToken=:token` branch, no duplicate row). Never throws.
+     */
+    raiseOffer(emit: ShellEmitter, conversationEntryId: string, ctx: PlannerOfferRaiseContext): Promise<void>;
+    /**
+     * F-C4 — resolve an offer: emit the SIGNED resolution NOTIFICATION so its
+     * `openPrompts` row exact-clears, retried-until-ack. The ledger identity is moved
+     * OUT of the open-offer set (stops refresh/re-raise) INTO the pending-resolution
+     * set and is NOT dropped until the clear is backend-acknowledged (or is proven
+     * un-attestable → over-nag to TTL). A no-op if the offer never raised a row (a
+     * pre-E1 in-flight offer). Never throws.
+     */
+    resolveOffer(emit: ShellEmitter, conversationEntryId: string, sessionId: string): Promise<void>;
+    /** Stop the refresh timer (shell teardown). Idempotent. */
+    stopTimer(): void;
+    /** Is there a LIVE open-offer ledger entry for this entryId? (content-key floor) */
+    hasOpenOffer(conversationEntryId: string): boolean;
+    /** The committed promptId for an open offer (undefined once resolved/absent). */
+    promptIdFor(conversationEntryId: string): string | undefined;
+    isParkedForReRaise(promptId: string): boolean;
+    hasPendingResolution(promptId: string): boolean;
+    /** Run ONE refresh tick synchronously (the interval calls this; exposed for tests). */
+    runTick(): Promise<void>;
+    private getOrCreateEntry;
+    private buildRaiseEmit;
+    /**
+     * Emit ONE offer raise + park on failure (F-C1). ACK (`{emitted:true}`) clears any
+     * retry flag; `{emitted:false}` or a throw parks the promptId so a later tick
+     * re-emits until the backend writes the row.
+     */
+    private emitRaise;
+    /**
+     * Emit ONE resolution + retry-until-ack (F-C4). ACK (`{emitted:true}`) drops the
+     * identity (the row exact-cleared, or the conditional Delete no-op'd for an
+     * already-gone row — both acknowledged). A transient `{emitted:false}` keeps the
+     * identity for the next tick; a terminal/un-attestable reason (or the retry cap)
+     * gives up → the row over-nags to its own TTL.
+     */
+    private emitResolution;
+    /** Retry every parked raise whose ledger entry is still open (F-C1 drain). */
+    private drainReRaises;
+    /** Retry every un-acked resolution; give up past the attempt cap (F-C4 drain). */
+    private drainResolutions;
+    /**
+     * §3.1 — co-refresh the OPEN offers' `openPrompts` row TTLs; FULL-re-raise any
+     * promptId the backend reports as already aged-out (return-driven re-raise, §6a-4).
+     */
+    private refreshOpenTtls;
+    private findOpenEntryByPromptId;
+    private ensureTimer;
+    private maybeStopTimer;
+}