@quantiya/codevibe-codex-plugin 2.0.6 → 2.0.8

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

@@ -6,3 +6,12 @@ export declare const CONVERSATION_BUFFER_MAX = 500;
  * mutates `state` in place. Map fields are cloned via `new Map(state.x)`.
  */
 export declare function reducer(state: OrchestrationState, action: OrchestrationAction): OrchestrationState;
+/**
+ * P10 E3 r6/r8 — "is a single-implementor task actually running?" from the
+ * TRUTHFUL `sessionTasks` lifecycle (the task-end closers terminalize it;
+ * `runningTasks` never terminalizes in production and is kept ONLY for the
+ * decision-spawned-a-task size heuristic). Shared by the `/status` running
+ * line, `deriveCurrentTaskState` (the planner packet), and the reviewer-line
+ * SET guard below.
+ */
+export declare function hasRunningSingleTask(state: OrchestrationState): boolean;

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

@@ -1,6 +1,8 @@
 /**
  * One desktop-local progress phase. Discriminated by `phase`. Every variant is
- * counts + labels + paths only — NEVER plaintext (see the module invariant).
+ * counts + labels + paths only — never workspace/diff/reasoning plaintext —
+ * with the module invariant's ONE documented exception: `halt_notice.message`
+ * (controlled operational notice text; see the header + the entry's carve-out).
  */
 export type TaskProgressEvent = ({
     phase: 'shadow_created';
@@ -43,6 +45,7 @@ export type TaskProgressEvent = ({
     phase: 'round_failed';
     round: number;
     reason: string;
+    taskId?: string;
 } | {
     phase: 'continuation_offered';
     round: number;
@@ -57,18 +60,25 @@ export type TaskProgressEvent = ({
 } | {
     phase: 'promoted';
     files: number;
+    taskId?: string;
 } | {
     phase: 'discarding';
 } | {
     phase: 'discarded';
+    taskId?: string;
 } | {
     phase: 'waiting_user';
 } | {
     phase: 'planner_classifying';
 } | {
     phase: 'familiarizing';
+} | {
+    phase: 'agent_advisory';
 } | {
     phase: 'progress_cleared';
+} | {
+    phase: 'halt_notice';
+    message: string;
 }) & {
     epoch?: number;
     tokens?: number;
@@ -107,9 +117,12 @@ export declare function formatTokens(n: number): string;
  */
 export declare function isSpinnerPhase(phase: TaskProgressEvent['phase']): boolean;
 /**
- * Render the user-facing ONE-LINE text for a progress event. Pure (no plaintext
- * — only counts/labels/paths/elapsed). The TUI shows spinner phases as an
- * ephemeral live line and milestone phases as persisted scrollback entries.
+ * Render the user-facing ONE-LINE text for a progress event. Pure. No
+ * workspace/diff/reasoning plaintext — counts/labels/paths/elapsed, plus the
+ * module invariant's ONE documented exception: `halt_notice` renders its
+ * controlled operational `message` verbatim (see the header carve-out). The
+ * TUI shows spinner phases as an ephemeral live line and milestone phases as
+ * persisted scrollback entries.
  */
 export declare function renderProgressLine(event: TaskProgressEvent): string;
 /**

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

@@ -18,17 +18,17 @@ export declare const WorkItemInputSchema: z.ZodDiscriminatedUnion<"decompose", [
                 access: z.ZodEnum<["write", "read"]>;
             }, "strip", z.ZodTypeAny, {
                 path: string;
-                access: "write" | "read";
+                access: "read" | "write";
             }, {
                 path: string;
-                access: "write" | "read";
+                access: "read" | "write";
             }>, "many">;
             test_surfaces: z.ZodArray<z.ZodString, "many">;
             auto_modified_files: z.ZodArray<z.ZodString, "many">;
         }, "strip", z.ZodTypeAny, {
             shared_contracts: {
                 path: string;
-                access: "write" | "read";
+                access: "read" | "write";
             }[];
             write_paths: string[];
             test_surfaces: string[];
@@ -36,13 +36,13 @@ export declare const WorkItemInputSchema: z.ZodDiscriminatedUnion<"decompose", [
         }, {
             shared_contracts: {
                 path: string;
-                access: "write" | "read";
+                access: "read" | "write";
             }[];
             write_paths: string[];
             test_surfaces: string[];
             auto_modified_files: string[];
         }>;
-        implementorAgent: z.ZodEffects<z.ZodEnum<["CLAUDE", "CODEX", "GEMINI", "ANTIGRAVITY"]>, "CLAUDE" | "GEMINI" | "CODEX" | "ANTIGRAVITY", unknown>;
+        implementorAgent: z.ZodEffects<z.ZodEnum<["CLAUDE", "CODEX", "ANTIGRAVITY"]>, "CLAUDE" | "CODEX" | "ANTIGRAVITY", unknown>;
         isSharedTestOwner: z.ZodBoolean;
         description: z.ZodString;
     }, "strip", z.ZodTypeAny, {
@@ -50,20 +50,20 @@ export declare const WorkItemInputSchema: z.ZodDiscriminatedUnion<"decompose", [
         ownershipScope: {
             shared_contracts: {
                 path: string;
-                access: "write" | "read";
+                access: "read" | "write";
             }[];
             write_paths: string[];
             test_surfaces: string[];
             auto_modified_files: string[];
         };
-        implementorAgent: "CLAUDE" | "GEMINI" | "CODEX" | "ANTIGRAVITY";
+        implementorAgent: "CLAUDE" | "CODEX" | "ANTIGRAVITY";
         isSharedTestOwner: boolean;
     }, {
         description: string;
         ownershipScope: {
             shared_contracts: {
                 path: string;
-                access: "write" | "read";
+                access: "read" | "write";
             }[];
             write_paths: string[];
             test_surfaces: string[];
@@ -73,29 +73,28 @@ export declare const WorkItemInputSchema: z.ZodDiscriminatedUnion<"decompose", [
         implementorAgent?: unknown;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
-    decompose: true;
     workItems: {
         description: string;
         ownershipScope: {
             shared_contracts: {
                 path: string;
-                access: "write" | "read";
+                access: "read" | "write";
             }[];
             write_paths: string[];
             test_surfaces: string[];
             auto_modified_files: string[];
         };
-        implementorAgent: "CLAUDE" | "GEMINI" | "CODEX" | "ANTIGRAVITY";
+        implementorAgent: "CLAUDE" | "CODEX" | "ANTIGRAVITY";
         isSharedTestOwner: boolean;
     }[];
-}, {
     decompose: true;
+}, {
     workItems: {
         description: string;
         ownershipScope: {
             shared_contracts: {
                 path: string;
-                access: "write" | "read";
+                access: "read" | "write";
             }[];
             write_paths: string[];
             test_surfaces: string[];
@@ -104,6 +103,7 @@ export declare const WorkItemInputSchema: z.ZodDiscriminatedUnion<"decompose", [
         isSharedTestOwner: boolean;
         implementorAgent?: unknown;
     }[];
+    decompose: true;
 }>, z.ZodObject<{
     decompose: z.ZodLiteral<false>;
     reason: z.ZodString;
@@ -127,27 +127,37 @@ export type DecomposerResult = {
     reason: string;
 };
 /**
- * Read the implementor's FINAL message text per-agent (§3.B / L9). Unlike
- * `extractAgentSummary` (which returns '' for Codex because the diff is the
- * single-impl contract), the DECOMPOSER needs the actual reply text — so for
- * Codex we read AND unlink the `--output-last-message` temp file. A Codex
- * decomposer would otherwise always parse-fail on its `--json` JSONL stdout.
+ * Read the implementor's FINAL message text per-agent (§3.B / L9). For Codex
+ * we read AND unlink the `--output-last-message` temp file (a Codex decomposer
+ * would otherwise always parse-fail on its `--json` JSONL stdout). Since A1b
+ * the file branch delegates to the SHARED `readImplementorLastMessage` helper
+ * (the same read `extractAgentSummary` uses), threading `workdir` so a
+ * SUBSTRATE-relocated capture file is found at `<workdir>/<basename>` — the
+ * decomposer runs through `LocalExecutor.spawnImplementor` with a synthetic
+ * taskId, so CP-7 DOES engage for it and the relocation applies. Unlike
+ * `extractAgentSummary`, the decomposer reads even on a NON-ZERO exit (a
+ * partial reply may still parse) — the exit-code gate stays a quorum-loop
+ * concern.
  *   - Claude  → `capture.kind === 'stdout'` → `handle.stdout()`.
- *   - Codex   → `capture.kind === 'file'`   → read+unlink the temp file.
- *   - Gemini  → stdout, unwrap the `{ response }` JSON envelope.
+ *   - Codex   → `capture.kind === 'file'`   → shared read+unlink helper.
  * NEVER throws — a capture error returns '' (→ the caller's parse-fail →
  * single-task fallback).
  */
 export declare function readImplementorFinalMessage(plan: ReturnType<typeof buildImplementorArgv>, handle: {
     stdout: () => string;
-}, agent: AgentKind, exitCode: number): Promise<string>;
+}, agent: AgentKind, exitCode: number, workdir?: string): Promise<string>;
 /**
  * Build the decomposition prompt fed to the local decomposer on stdin (§3.B).
  * `brief` is the composed lossless implementation brief (§3.D step 0).
  * `availableAgents` is the DETECTED set (§3.C) — the strengths list is filtered
  * to it, and the decomposer is told to pick `implementorAgent` from it.
+ * `repoContext` (A1e slice-wiring REMAP) is the OPTIONAL bounded repository-
+ * context block (`composeDispatchContextBlock` — the resolved `context_ref`
+ * slice + the fresh-only `repo_state` overview), appended verbatim so the
+ * decomposer partitions with the SAME grounded repo picture the implementors
+ * get. Empty/absent → the prompt is byte-identical to pre-A1e.
  */
-export declare function buildDecomposerPrompt(brief: string, availableAgents: AgentKind[]): string;
+export declare function buildDecomposerPrompt(brief: string, availableAgents: AgentKind[], repoContext?: string): string;
 /**
  * #590 — append a deterministic "allowed test files" line to a track's brief so
  * the implementor agent writes its own-module tests at the EXACT declared
@@ -184,13 +194,21 @@ export interface RunLocalDecomposerDeps {
  * the first detected agent; CP-7 engages because `role:'implementor'` + a
  * (synthetic) `taskId` are passed.
  */
-export declare function runLocalDecomposer(deps: RunLocalDecomposerDeps, brief: string, availableAgents: AgentKind[]): Promise<DecomposerResult>;
+export declare function runLocalDecomposer(deps: RunLocalDecomposerDeps, brief: string, availableAgents: AgentKind[], 
+/**
+ * A1e (slice-wiring REMAP) — the optional bounded repository-context block
+ * (`composeDispatchContextBlock`), appended to the decomposer prompt so the
+ * partitioning is grounded in the same projected repo picture the
+ * implementors get. Empty/absent → byte-identical prompt.
+ */
+repoContext?: string): Promise<DecomposerResult>;
 /**
- * Validate + normalize each work item's `implementorAgent` against the DETECTED
- * agent set (§3.C — v1 is DETECTED-ONLY; NO capability-health filtering, NO
- * per-spawn auth-recheck). For each item: `.toUpperCase()`-normalize the
- * suggested agent; keep it if detected; else SUBSTITUTE the first detected
- * agent. If NO agent is detected → `null` (the caller falls back to single).
- * Returns NEW work items (does not mutate the inputs).
+ * Validate + normalize each work item's `implementorAgent` against the active
+ * detected agent set (§3.C — v1 is DETECTED-ONLY; NO capability-health
+ * filtering, NO per-spawn auth-recheck). For each item:
+ * `.toUpperCase()`-normalize the suggested agent; keep it if active +
+ * detected; else SUBSTITUTE the first active detected agent. If NO active
+ * agent is detected → `null` (the caller falls back to single). Returns NEW
+ * work items (does not mutate the inputs).
  */
 export declare function validateAgentAvailability(workItems: DecomposerWorkItem[], detected: AgentKind[]): DecomposerWorkItem[] | null;

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

@@ -136,6 +136,29 @@ export interface RunningTaskState {
     exitCode?: number;
     bypassReason?: 'deterministic_shortcut' | 'planner_outage' | 'planner_degraded_explicit_override';
 }
+/**
+ * P10 E3 r2 — one row of the bare-`/audit` session listing (the
+ * `sessionTasks` value). Deliberately NOT `RunningTaskState`: Agent Teams
+ * child tasks arrive via TEAM_TRACK_ASSIGNED (Stage-2 r1 Codex MED-1) which
+ * carries no pid, so forcing that shape would fabricate fields. Display-only.
+ */
+export interface SessionTaskRecord {
+    taskId: string;
+    /** Implementor agent when known; a team ASSIGNED event may omit it. */
+    agentKind?: string;
+    /** 'single' = TASK_LIFECYCLE-tracked; 'team' = Agent Teams track. */
+    origin: 'single' | 'team';
+    /**
+     * Singles: the lifecycle status — 'running' at dispatch, flipped terminal
+     * by the task-end CLOSER progress events (promoted → 'completed',
+     * discarded → 'cancelled', round_failed → 'failed'; Stage-2 r1 Codex
+     * MED-2 — no production TASK_LIFECYCLE dispatch ever carries a terminal
+     * status). Team rows: the TeamTrackState label verbatim.
+     */
+    status: string;
+    /** Singles: the dispatch stamp. Team rows: first-observed stamp. */
+    startedAt: string;
+}
 /**
  * §5.1 LOCK (lines 547-556). Single reviewer subprocess identity +
  * verdict. `reviewerKind` is hand-listed per CP-1 — CP-3 Stage A
@@ -330,6 +353,8 @@ export type ConversationEntry = {
     final: true;
     source: 'planner' | 'shell';
     text: string;
+    localOnly?: true;
+    handoffExcluded?: true;
 } | {
     kind: 'gate-prompt';
     id: string;
@@ -409,6 +434,54 @@ export interface PendingClarification {
      */
     attachmentPaths?: string[];
 }
+/**
+ * A1a #3/#4 — one numbered choice in a `PendingPlannerOffer`. Contract-ready
+ * shape (mirrors `GatePromptOption`) so an F4 mobile renderer (Wave 3, after the
+ * contract freeze) can consume it verbatim; `id` is a stable option key,
+ * `label`/`description` are the shell-authored (never model-authored) render copy.
+ */
+export interface PlannerOfferOption {
+    readonly id: string;
+    readonly label: string;
+    readonly description: string;
+}
+/**
+ * A1a #3/#4 (design §7 R3 / §8.3) — a lightweight interactive offer the shell
+ * presents instead of a silent spawn. Modeled on `pendingClarification` (NOT the
+ * server-coupled gate-prompt path): the offer + its numbered options are held in
+ * the local store, and the numbered reply resolves it locally. F4 mirrors a
+ * separate encrypted INTERACTIVE_PROMPT for mobile rendering; the local menu text
+ * stays out of workflow handoff context.
+ *
+ *  - `team_decomposition` (#4): the planner routed `team_decompose`; rather than
+ *    silent-launching a team, offer Accept-team / Reject→single / Talk-it-through.
+ *  - `build_transition` (#3): a mid-active-design "let's build it"; rather than
+ *    silent-spawning an implementor, offer Build-now / Keep-discussing.
+ *
+ * The stashed context lets each kind resolve WITHOUT re-classifying: the
+ * team-decomposition briefs the accept path feeds to `routeTeamDecompose` /
+ * `dispatchSynthesizedSingleStartTask`, and the build request the transition
+ * proceeds with.
+ */
+export interface PendingPlannerOffer {
+    kind: 'team_decomposition' | 'build_transition';
+    /** Contract-ready shape (mirror GatePromptOption). Shell-authored copy. */
+    options: ReadonlyArray<PlannerOfferOption>;
+    /** The `advisory` conversation entry that rendered the numbered options. */
+    conversationEntryId: string;
+    /** The planner's short reason (why this offer) — surfaced in the render. */
+    rationale: string;
+    /** team_decomposition: the decomposer input brief for `routeTeamDecompose`. */
+    decomposerBrief?: string;
+    /** team_decomposition / build fallback: the brief for reject → single agent. */
+    singleFallbackBrief?: string;
+    /** build_transition: the build request to proceed with on accept (no re-classify). */
+    originalUserPrompt?: string;
+    /** IMAGE-ATTACHMENT-DESIGN.md §5/§7.5 — team attachments, armed on the launch. */
+    attachments?: ImageAttachment[];
+    /** §13 Option-2 — ordered-with-dups carried paths for the number-based chip rewrite. */
+    attachmentPaths?: string[];
+}
 /**
  * [ADDITIVE WIDENING — CP-12 W3, per PHASE-CP-12-DESIGN.md §3.5 "minimal
  * multi-track status node; rich UX is #469"]. Per-track lifecycle state as the
@@ -445,7 +518,7 @@ export interface TeamTrackEntry {
 }
 /**
  * [ADDITIVE WIDENING — CP-12 W3] Minimal team state. `null` for
- * single-track/Companion/stub sessions (no team → no status node). Populated
+ * single-track/Companion sessions (no team → no status node). Populated
  * when `/team` accepts a task group + per-track W2.b shell events arrive.
  */
 export interface TeamState {
@@ -494,13 +567,15 @@ export interface TeamState {
  * the user is in control (a gate prompt is shown → `waiting_user` clears it).
  * Milestones (diff captured, verdicts received, promoted, …) are NOT stored here
  * — they are appended to `conversation` as persisted scrollback entries. This is
- * desktop-LOCAL only: counts/labels/elapsed, never plaintext (see
+ * desktop-LOCAL only: counts/labels/elapsed, never plaintext — `halt_notice`,
+ * the union's one free-text exception, can never open or refresh this live
+ * line (reducer phase-family guard); it is scrollback-only (see
  * `task-progress.ts`).
  */
 export interface LiveProgress {
     /** The phase of the in-flight spinner line. */
     phase: TaskProgressEvent['phase'];
-    /** The BOUNDED live label (counts/labels/paths only — no plaintext, no embedded timer). */
+    /** The BOUNDED live label (counts/labels/paths only — no plaintext; `halt_notice` never reaches here; no embedded timer). */
     text: string;
     /** When this line was last refreshed. Retained; currently unused (no component reads it). */
     updatedAt: string;
@@ -532,10 +607,25 @@ export interface OrchestrationState {
     plannerHealth: PlannerHealthState;
     conversation: ConversationEntry[];
     runningTasks: Map<string, RunningTaskState>;
+    sessionTasks: Map<string, SessionTaskRecord>;
+    lastReviewerProgress: {
+        text: string;
+        at: string;
+    } | null;
     queuedTasks: QueuedTask[];
     activeReviewerSeats: Map<string, ReviewerSeatState>;
     currentGate: GateState | null;
     pendingClarification: PendingClarification | null;
+    /**
+     * `[ADDITIVE WIDENING — A1a #3/#4]` The active lightweight local interactive
+     * offer (team-decomposition / build-transition), or `null` when none is in
+     * flight (the default). Set by `PLANNER_OFFER_PRESENTED`; a single in-range
+     * numeric reply resolves it locally (see `handleShellUserInput`), and any
+     * non-offer resolution clears it (`CLEAR_PENDING_PLANNER_OFFER`). F4 mirrors an
+     * encrypted INTERACTIVE_PROMPT for mobile, but this store node remains the local
+     * source of truth.
+     */
+    pendingPlannerOffer: PendingPlannerOffer | null;
     inputHistory: string[];
     /**
      * `[ADDITIVE WIDENING — CP-1.d]` per `PHASE-CP-1-D-DESIGN.md` §4.8
@@ -552,7 +642,7 @@ export interface OrchestrationState {
     structuralSummaryError: string | null;
     /**
      * `[ADDITIVE WIDENING — CP-12 W3]` per PHASE-CP-12-DESIGN.md §3.5. `null`
-     * for single-track/Companion/stub sessions (the status node is hidden).
+     * for single-track/Companion sessions (the status node is hidden).
      * Populated by `/team` (createTaskGroup accepted) + the W2.b per-track shell
      * events. Rich per-track timeline + MergeGate result card are
      * [DEFERRED → CP-8 #469].
@@ -563,7 +653,7 @@ export interface OrchestrationState {
      * live status line (spinner). `null` when idle / waiting on the user. Updated
      * in place by `TASK_PROGRESS` spinner phases; cleared by `waiting_user` and by
      * the terminal milestone phases (`promoted` / `discarded`). Non-loop /
-     * Companion / stub sessions never dispatch `TASK_PROGRESS`, so this stays null.
+     * Companion sessions never dispatch `TASK_PROGRESS`, so this stays null.
      */
     progress: LiveProgress | null;
     /**
@@ -585,7 +675,7 @@ export interface OrchestrationState {
  * props with no in-component network I/O:
  *   - `tier` decides the seat budget (Pro = 2 seats, Max = 3).
  *   - `installedAgents` is the host-detected agent set — the wizard offers ONLY
- *     these as reviewer choices (mirrors the `codevibe orchestration configure`
+ *     these as reviewer choices (mirrors the `/reviewer-setup`
  *     CLI), so a user can never pick an uninstalled agent.
  *   - `currentSeats` is shown as a CONTEXT line at the top of the wizard (the
  *     user's existing panel) — display only; the wizard starts fresh at the
@@ -675,6 +765,11 @@ export type OrchestrationAction = {
     task: RunningTaskState;
 } | {
     type: 'CLEAR_PENDING_CLARIFICATION';
+} | {
+    type: 'PLANNER_OFFER_PRESENTED';
+    offer: PendingPlannerOffer;
+} | {
+    type: 'CLEAR_PENDING_PLANNER_OFFER';
 } | {
     type: 'STRUCTURAL_SUMMARY_GENERATED';
     summary: StructuralSummary;
@@ -711,6 +806,8 @@ export type OrchestrationAction = {
     type: 'SHELL_ADVISORY';
     text: string;
     source: 'shell';
+    localOnly?: true;
+    handoffExcluded?: true;
 } | {
     type: 'GATE_PROMPT_NOTES_CANCELLED';
     promptEntryId: string;

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

@@ -0,0 +1,27 @@
+export interface WorkspaceShutdownOperations {
+    flushPlannerCache?: () => Promise<void>;
+    clearPlannerSession?: () => void;
+    disposeQuorumWorkspaces?: () => Promise<void>;
+    drainLocalWorkspaces?: () => Promise<void>;
+    /** Settle already-admitted shell turns after their agent processes drain. */
+    drainShellSubmissions?: () => Promise<void>;
+    /** Flush the settled turns' local and hosted canonical context publications. */
+    finalizeContextItemPublications?: () => Promise<void>;
+    /** Audit/retry exact advisory-image authority after every owning turn settles. */
+    disposeAdvisoryAttachmentAuthority?: () => Promise<void>;
+    disposeLocalDurableSessionResources?: () => Promise<void>;
+    /** Final hosted terminal mutation; no local or hosted turn publication follows. */
+    retireHostedSession?: () => Promise<void>;
+    onPlannerFlushFailure?: (error: Error) => void;
+    onWorkspaceFailure?: (error: Error) => void;
+}
+/**
+ * Start every independent shutdown fence before awaiting any one owner.
+ *
+ * The LocalExecutor's shared durable group retirement is deliberately a final
+ * phase: Quorum may still have an already-admitted terminal publisher that is
+ * allowed to finish while its ingress is closed. Only after both Quorum and
+ * LocalExecutor drains settle can the durable store be enumerated exactly once
+ * without a late publisher recreating a group behind the cleanup pass.
+ */
+export declare function runWorkspaceShutdownOperations(operations: WorkspaceShutdownOperations): Promise<void>;

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

@@ -3,5 +3,5 @@ export * from './adapter';
 export { PlannerCacheLayer } from './cache';
 export { PlannerHealthMachine } from './health-state';
 export { BackendPlannerClient, PlannerBudgetExceededError, PlannerTierGateRejectedError, type PlannerAppSyncTransport, type PlannerCryptoBridge, type SessionKeyResolver, type ShellEventEmit, type EmitShellEventFn, } from './client';
-export { LocalGemmaPlannerAdapter, parseLocalGemmaPlannerDecision, renderLocalGemmaPlannerPrompt, type LocalGemmaPlannerRunner, } from './local-gemma';
+export { LocalGemmaPlannerAdapter, parseLocalGemmaPlannerDecision, PlannerOutputUnparseableError, renderLocalGemmaPlannerPrompt, type LocalGemmaPlannerRunner, } from './local-gemma';
 export { parseLocalGemmaAdvisorySummary, renderLocalGemmaFamiliarizePrompt, type LocalGemmaAdvisoryRunner, } from './local-advisory';

package/node_modules/@quantiya/codevibe-core/dist/planner/local-advisory.d.ts

@@ -1,6 +1,17 @@
 import type { StructuralSummary } from '../structural-summary/types';
 export interface LocalGemmaAdvisoryRunner {
     generateAdvisory(promptText: string, options?: LocalGemmaAdvisoryOptions): Promise<string>;
+    /**
+     * Dogfood #618 — optional fire-and-forget model pre-warm (load + keep_alive).
+     * Never throws; resolves false on failure. Called once at shell startup.
+     */
+    warm?(): Promise<boolean>;
+    /**
+     * #618 Stage-2 — optional fire-and-forget model release (keep_alive: 0).
+     * Never throws; resolves false on failure. Called once at shell teardown so
+     * the model's memory isn't held for the keep_alive window after quit.
+     */
+    unload?(): Promise<boolean>;
     runtimeLabel: string;
 }
 export type LocalGemmaAdvisoryResponseFormat = 'json' | 'text';
@@ -46,6 +57,7 @@ export declare function renderLocalGemmaBrowsePrompt(args: {
     };
     content: string;
 }): string;
+export declare function boundedPriorBrainstormTurns(turns: string[] | undefined): string[];
 /**
  * WEB-BROWSING (search-route): turn the user's request + recent conversation into a
  * concise web-search QUERY. The local model resolves acronyms/pronouns from context

package/node_modules/@quantiya/codevibe-core/dist/planner/local-gemma.d.ts

@@ -5,8 +5,35 @@ export interface LocalGemmaPlannerRunner {
     classify(promptText: string): Promise<string>;
     generateAdvisory?: LocalGemmaAdvisoryRunner['generateAdvisory'];
     probe?(): Promise<PlannerProbeResult>;
+    /**
+     * Dogfood #618 — optional fire-and-forget model pre-warm (load into memory +
+     * arm keep_alive). Never throws; resolves false on failure. The shell calls
+     * this once at startup so the session's first classify/advisory doesn't pay
+     * the runtime's cold load.
+     */
+    warm?(): Promise<boolean>;
+    /**
+     * #618 Stage-2 — optional fire-and-forget model release (keep_alive: 0),
+     * called once at shell teardown. Never throws; resolves false on failure.
+     */
+    unload?(): Promise<boolean>;
     runtimeLabel: string;
 }
+/**
+ * A1a P0 (R3 — design §7 "the conductor must NEVER hard-fail"): thrown when the
+ * local Gemma model RESPONDED but its output could not be parsed into a valid
+ * route (out-of-domain prose, truncated JSON, unsupported action/keys, etc.).
+ *
+ * This is deliberately DISTINCT from an infrastructure failure (Ollama
+ * unreachable / timeout / budget / tier-gate — those reject out of the runner,
+ * never reach the parser). The orchestration shell catches THIS class and
+ * degrades to a safe "general question / not a build request" advisory route
+ * instead of surfacing a `planner-error`; a genuine infra failure still surfaces
+ * "Planner unavailable" because retrying would not help.
+ */
+export declare class PlannerOutputUnparseableError extends Error {
+    constructor(message: string);
+}
 /**
  * Text-only route classifier prompt. It intentionally excludes repository
  * paths, summaries, source snippets, file bodies, and the raw structural digest.

package/node_modules/@quantiya/codevibe-core/dist/planner/types.d.ts

@@ -63,6 +63,13 @@ export interface PlannerInput {
     clarifications: Clarification[];
     sessionContext: SessionContext;
     budgetHint: BudgetHint;
+    /**
+     * Local-planner-only, role-filtered rendering of the canonical ContextItems
+     * session history. The hosted planner client deliberately ignores this field;
+     * it exists so local Gemma can resolve ordinary multi-turn references without
+     * relying on shell text heuristics or a model-private conversation cache.
+     */
+    canonicalConversationContext?: string;
 }
 export interface PlannerDecision {
     action: 'start_task' | 'summarize_current_status' | 'advisory_response' | 'ask_user' | 'refuse' | 'team_decompose' | 'familiarize' | 'brainstorm' | 'browse';

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

@@ -7,8 +7,6 @@ export type { RunReviewerOptions, SubprocessError, SubprocessOutcome, } from './
 export { runReviewer, SubprocessErrorClass } from './subprocess.js';
 export type { ClaudeReviewerProviderOptions } from './providers/claude.js';
 export { ClaudeReviewerProvider } from './providers/claude.js';
-export type { GeminiEnvelope, GeminiModelStats, GeminiReviewerProviderOptions, GeminiStats, } from './providers/gemini.js';
-export { GeminiReviewerProvider } from './providers/gemini.js';
 export type { CodexReviewerProviderOptions } from './providers/codex.js';
 export { CodexReviewerProvider } from './providers/codex.js';
 export type { AntigravityReviewerProviderOptions } from './providers/antigravity.js';

package/node_modules/@quantiya/codevibe-core/dist/reviewer/output-parser.d.ts

@@ -19,7 +19,26 @@ export interface ParsedVerdict {
      * via `revise_missing_changes` / `suggested_changes_require_revise`).
      */
     suggested_changes: string[];
+    /**
+     * Ordered non-blocking observations from the explicit
+     * `RESIDUAL OBSERVATIONS:` section. These never count as suggested changes.
+     */
+    residual_observations: string[];
+}
+export interface ResidualObservationSplit {
+    /** Reviewer output with the explicit residual section removed. */
+    reviewText: string;
+    /** Ordered, non-empty residual observations. */
+    residualObservations: string[];
 }
+/**
+ * Split the optional P15 residual-observation section from reviewer prose.
+ *
+ * The heading must occupy its own line. Bullets are preferred, but plain
+ * non-empty lines are retained as observations so harmless reviewer format
+ * drift cannot turn a non-blocking note into a revision request.
+ */
+export declare function splitResidualObservations(raw: string): ResidualObservationSplit;
 /**
  * Why a reviewer's reply failed the locked-format check. Discriminated
  * union; the subprocess layer maps any of these into `ReviewerError` with

package/node_modules/@quantiya/codevibe-core/dist/reviewer/provider.d.ts

@@ -37,8 +37,10 @@ export interface ReviewerEvaluateOptions {
      * the workdir on BOTH backends — A5 `cwd: workdir`; Docker `docker exec -w
      * /workspace`) and reads it back from `<workdir>/<name>` on the host (the same
      * inode, even when A5 canonicalizes the workdir — the host read follows the
-     * symlink). The Claude / Gemini providers do not use a file output, so they
-     * ignore this field. ABSENT (legacy path / non-substrate) → the provider uses
+     * symlink). The Claude provider uses no file output and ignores this field;
+     * the Antigravity provider writes no verdict file either but DOES consume
+     * `workdir` (`--add-dir <workdir>` — agy is workspace-centric). ABSENT
+     * (legacy path / non-substrate) → the provider uses
      * its byte-identical legacy `os.tmpdir()` location.
      *
      * # Why this is NOT derivable from `substrate`
@@ -105,10 +107,11 @@ export interface ReviewerSpec {
      * is agent-agnostic here; each provider enforces the sandbox in its own
      * way:
      * - Claude: `--allowed-tools Read,Grep,Glob` CLI flag.
-     * - Gemini: `--approval-mode plan` (Gemini's first-class read-only mode).
-     *   The `tool_allowlist` is intentionally unused by the Gemini provider;
-     *   plan mode is the sandbox contract. 2.0.x task #62 tracks adding
-     *   `--policy <tempfile>` as defense-in-depth.
+     * - Antigravity: no native read-only flag AND no CP-7 substrate — agy is
+     *   reduced-trust (§6 Q4), so the loop pre-routes agy seats to the LEGACY
+     *   unsandboxed path with a reduced-trust badge. Agy 1.1.2 requires the
+     *   prompt as `--print <prompt>` and is granted the repo via
+     *   `--add-dir <workdir>`.
      * - Codex: `--sandbox read-only --skip-git-repo-check` flags + per-spawn
      *   ephemeral output file.
      */

package/node_modules/@quantiya/codevibe-core/dist/reviewer/providers/antigravity.d.ts

@@ -25,9 +25,8 @@ export declare class AntigravityReviewerProvider implements ReviewerProvider {
 /**
  * Construct the agy CLI invocation (design D4):
  *
- * - `--print ''` — non-interactive one-shot; the EMPTY value selects the
- *   STDIN prompt (fed by `runReviewer`), keeping multi-line markdown out of
- *   argv (same posture as gemini's `-p ''`).
+ * - `--print <prompt>` — non-interactive one-shot. Agy 1.1.2 requires the
+ *   prompt value in argv; stdin prompt mode was removed.
  * - `--model <hint>` — optional; omitted when `spec.model_hint` is `null`
  *   (agy default model).
  * - `--print-timeout <s>s` — agy's INTERNAL print-mode poll ceiling, derived