@quantiya/codevibe-claude-plugin 2.0.73 → 2.0.74

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

@@ -1,3 +1,4 @@
+import type { GemmaCallPipeline } from '../../planner/gemma-pipeline';
 import * as React from 'react';
 import { OrchestrationStore } from '../store';
 import { ConversationEntry, PostDecisionAction, Tier } from '../types';
@@ -38,7 +39,8 @@ export interface OrchestrationAppProps {
      */
     plannerRuntimeKind?: PlannerRuntimeKind;
     plannerLabel?: string;
-    plannerAdapter?: unknown;
+    /** The session's Gemma pipeline; the badge subscribes to its source changes (§3.5). */
+    plannerPipeline?: GemmaCallPipeline;
     /**
      * TUI redesign (2026-06-29) — the PLAINTEXT cwd for the status bar, threaded
      * from the shell entry (process.cwd()). Sourced here rather than from

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/git-status-summary.d.ts

@@ -1,4 +1,4 @@
-import { type AdvisoryRunner } from '../planner/local-advisory';
+import type { GemmaCallPipeline } from '../planner/gemma-pipeline';
 export interface GitExecResult {
     stdout: string;
     stderr?: string;
@@ -13,7 +13,8 @@ export interface ExecuteGitStatusSummaryOptions {
     cwd: string;
     prompt: string;
     hasActiveTask: boolean;
-    advisoryRunner?: AdvisoryRunner;
+    /** The session's Gemma pipeline (parity §3.5); absent → the deterministic parser only. */
+    advisoryRunner?: GemmaCallPipeline;
     execFileFn?: GitExecFileFn;
 }
 export interface GitStatusParsedIntent {
@@ -51,21 +52,15 @@ export declare function extractComparisonBaseRefInfo(prompt: string, options?: {
 export declare function extractComparisonBaseRef(prompt: string): string | undefined;
 export declare function isConceptualGitQuestion(prompt: string): boolean;
 export declare function isStagedDiffIntent(prompt: string): boolean;
-export declare function isQualifiedAdvisoryRunner(runner?: AdvisoryRunner): boolean;
-/**
- * Resolves the preferred advisory runner for intent classification per Pure LLM policy:
- * "If there is local LLM, use it over hosted LLM".
- */
-export declare function resolvePreferredAdvisoryRunner(runner?: AdvisoryRunner): AdvisoryRunner | null;
 export declare function renderLocalGemmaGitStatusQueryPrompt(args: {
     userPrompt: string;
 }): string;
 export declare function parseGemmaGitStatusResponse(raw: string): GitStatusParsedIntent | null;
-export declare function parseGitStatusQueryWithGemma(runner: AdvisoryRunner, prompt: string, timeoutMs?: number): Promise<GitStatusParsedIntent | null>;
+export declare function parseGitStatusQueryWithGemma(runner: GemmaCallPipeline, prompt: string, timeoutMs?: number): Promise<GitStatusParsedIntent | null>;
 export declare function parseGitStatusQuerySemantic(prompt: string): GitStatusParsedIntent;
 export declare function resolveGitStatusIntent(options: {
     prompt: string;
-    advisoryRunner?: AdvisoryRunner;
+    advisoryRunner?: GemmaCallPipeline;
 }): Promise<GitStatusParsedIntent>;
 /**
  * Safely format code blocks using collision-safe backtick fences (R2-F3).

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

@@ -1,3 +1,4 @@
+import { GemmaCallPipeline } from '../planner/gemma-pipeline';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { AppSyncClient } from '../appsync';
 import type { MobileInputStatusUpdater } from '../appsync';
@@ -37,9 +38,7 @@ import { type GatePromptEnvelope, type DecryptedReviewSummaryInput } from './gat
 import type { Event } from '../types/events';
 import { type StructuralSummaryGenerator } from '../structural-summary';
 import type { PlannerAdapter } from '../planner/adapter';
-import type { PlannerCacheLayer } from '../planner/cache';
 import type { PlannerInput, PlannerDecision as PlannerDecisionRuntime } from '../planner/types';
-import type { LocalGemmaAdvisoryRunner } from '../planner/local-advisory';
 import type { LocalExecutor } from '../local-executor';
 import type { WorkItemInput, DisjointnessRejection, RevertManifestStore } from '../local-executor';
 import type { QuorumLoop } from './quorum-loop';
@@ -125,29 +124,11 @@ export interface RunOrchestrationShellArgs {
      */
     plannerAdapter?: PlannerAdapter;
     /**
-     * CP-1.b IMPL r2 M-3 — Optional planner cache layer. With LOCK #18
-     * write-through removed, normal session exit (no LRU eviction, no
-     * TTL deletion) would lose pending in-memory inserts. When
-     * supplied, `runOrchestrationShell` calls `cache.flush()` from
-     * every teardown path (`/quit`, non-TTY EOF, SIGINT/SIGTERM,
-     * finally-block cleanup).
-     */
-    plannerCache?: PlannerCacheLayer;
-    /**
-     * Local Gemma planner M1/M2 — disables automatic structural-summary refreshes
-     * at shell startup and before natural-language classification. The local
-     * planner path must not scan or summarize the repository before route-source
-     * safety and an accepted local route exist. Accepted local routes such as
-     * `familiarize` may still run their own route-scoped refresh.
-     */
-    disableStructuralContextRefresh?: boolean;
-    /**
-     * Local Gemma planner migration state. `hosted` keeps the legacy backend
-     * planner semantics. `local_gemma_qat` means natural-language decisions came
-     * from the local runtime and need shell-owned M1 safety/milestone gates.
-     * `local_unavailable` means the user opted into local-model orchestration but
-     * the verified runtime is not usable; for Pro/Max sessions it falls back to
-     * hosted Bedrock planner, while Free tier operates in Companion Mode.
+     * Planner availability (parity §3.5). `local_unavailable` means the user opted
+     * into local-model orchestration but no planner source is usable, so the
+     * session runs in Companion Mode. The other values are display-only (the
+     * status badge's initial state); no shell behaviour branches on them — every
+     * shared rule runs identically on the local and hosted runtimes.
      */
     plannerRuntimeKind?: 'hosted' | 'local_gemma_qat' | 'local_unavailable';
     /**
@@ -165,12 +146,13 @@ export interface RunOrchestrationShellArgs {
      */
     cwd?: string;
     /**
-     * Local Gemma M3 advisory runtime. This is intentionally separate from the
-     * planner adapter interface: classification remains schema-only, while
-     * familiarization uses a bounded read-only advisory prompt after route
-     * safety, local runtime eligibility, and repository context refresh pass.
+     * The session's Gemma pipeline (planner parity §3), the ONLY caller of a Gemma
+     * runner: every advisory call (answers, brainstorm, browse readers, git-status
+     * intent) goes through it, with identical logic on the local and hosted
+     * runtimes. The planner adapter classifies through the same instance. The name
+     * is kept for continuity; absent when the session has no model source.
      */
-    localAdvisoryRunner?: LocalGemmaAdvisoryRunner;
+    localAdvisoryRunner?: GemmaCallPipeline;
     /**
      * CP-12 W3 §3.5 — the team-mode Local Executor. Present ONLY for an
      * Agent-Teams session: `cli.ts` constructs ONE per session (honoring the
@@ -877,8 +859,11 @@ export declare function routeBrainstorm(deps: {
     userPrompt: string;
     needsRepositoryContext?: boolean;
     priorTurns?: string[];
-    /** RAW base64 images (IMAGE-ATTACHMENT-DESIGN.md §6) — Ollama-runtime only; text-mode. */
-    images?: string[];
+    /**
+     * The turn's image attachments (IMAGE-ATTACHMENT-DESIGN.md §6). Read fd-safe and selected
+     * per attempt by the pipeline under the routed runtime's capability (parity §3.7).
+     */
+    attachments?: ImageAttachment[];
     onProgress?: (event: TaskProgressEvent) => void;
 }): Promise<void>;
 /**
@@ -888,17 +873,18 @@ export declare function routeBrainstorm(deps: {
  * classifier's `advisory_summary` — but that path is blind to the image. When an
  * image is attached, the reducer's inline render is suppressed (strip
  * summary+clarifying_question+rationale, §6/rev-13) and THIS produces the sole
- * answer: text-mode `generateAdvisory` with the RAW base64 `images[]` to the LOCAL
- * Ollama model, image framed as untrusted data, output `sanitizeForTerminal`-scrubbed.
- * 100% on-device. `browse`/`familiarize` are excluded (their answer is grounded on
- * other context). All-images-failed → the caller passes an empty `images` and we
- * proceed text-only.
+ * answer: a text-mode `pipeline.advise` with the turn's attachments, image framed as
+ * untrusted data, output `sanitizeForTerminal`-scrubbed. `browse`/`familiarize` are
+ * excluded (their answer is grounded on other context). Parity §3.7: the pipeline reads
+ * the attachments fd-safe and selects them per attempt for the routed runtime; the prompt
+ * states the number actually included, and the shared omitted-images note follows the call.
  */
 export declare function routeAdvisory(deps: {
     store: OrchestrationStore;
     args: RunOrchestrationShellArgs;
     userPrompt: string;
-    images: string[];
+    /** The turn's image attachments (empty for a text-only answer). */
+    attachments: ImageAttachment[];
     /**
      * #619 — recent conversation turns for the TEXT-ONLY answerer case. When an
      * `advisory_response` lands mid-conversation, the classifier's inline
@@ -926,13 +912,6 @@ export declare function routeAdvisory(deps: {
      * R1-F3 — classifier-emitted inline summary to use as fallback if generateAdvisory throws, times out, or returns empty.
      */
     fallbackSummary?: 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;
     /**
      * 2026-09-12 (updated 2026-09-23) — the page the `browse` route read most recently in this session.
      * Rendered as untrusted source material injected ONLY when the shell determines via
@@ -940,6 +919,11 @@ export declare function routeAdvisory(deps: {
      * over-grounding and false refusals on unrelated technical follow-ups like A* algorithm).
      */
     retainedPage?: RetainedBrowsePage;
+    /**
+     * Planner parity §3.5 / P-21 (Stage 2 codex S2-codex-F3): the turn's progress sink (the shell
+     * passes the dispatcher that also relays to mobile). Absent → the store only.
+     */
+    onProgress?: (event: TaskProgressEvent) => void;
 }): Promise<void>;
 export declare function parseTeamWorkItems(rawArg: string): {
     ok: true;
@@ -1142,7 +1126,6 @@ export declare function serializeShellSubmissions(handler: (text: string, images
  * slash route then reports "unavailable").
  */
 export declare function buildContinuationActionDeps(args: RunOrchestrationShellArgs, store: OrchestrationStore): Partial<ContinuationCliDeps>;
-export declare function shouldSuppressStructuralContextRefresh(args: RunOrchestrationShellArgs): boolean;
 /**
  * P46a C3 — "Retry as a new task": start a NEW linked task (`retryOf`) on a
  * fresh snapshot from the stashed retry brief (the original request + the

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

@@ -1,5 +1,5 @@
 import type { OrchestrationStore } from './store';
-import type { LocalGemmaAdvisoryRunner } from '../planner/local-advisory';
+import { type GemmaCallPipeline } from '../planner/gemma-pipeline';
 import { guardedFetch } from './web/fetch';
 import { webSearch } from './web/search';
 import type { TaskProgressEvent } from './task-progress';
@@ -19,8 +19,8 @@ export interface RetainedBrowsePage {
 export declare const RETAINED_PAGE_MAX_CHARS = 120000;
 export interface RouteBrowseDeps {
     store: OrchestrationStore;
-    /** Undefined when the local model isn't installed/enabled → no-model advisory. */
-    localAdvisoryRunner?: LocalGemmaAdvisoryRunner;
+    /** The session's Gemma pipeline; undefined when no model source exists → no-model advisory. */
+    localAdvisoryRunner?: GemmaCallPipeline;
     userPrompt: string;
     browseUrls?: string[];
     browseQuery?: string;
@@ -55,7 +55,7 @@ export interface RouteBrowseDeps {
 export declare function deriveSanitizedFallbackSearchQuery(prompt: string): string;
 /**
  * Orchestrate a `browse` route. Fetch an explicit URL, or run a web
- * search and read the top results in parallel, then answer via local Gemma. Mirrors
+ * search and read the top results in parallel, then answer via the Gemma pipeline. Mirrors
  * routeBrainstorm/routeFamiliarize (no-model advisory, clean failures, no crash).
  */
 export declare function routeBrowse(deps: RouteBrowseDeps): Promise<void>;

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

@@ -0,0 +1,63 @@
+import { GemmaCallError } from '../planner/gemma-errors';
+import type { GemmaCallPipeline, PipelineResult } from '../planner/gemma-pipeline';
+import type { PlannerRuntimeKind } from './status-format';
+type Outcome = PipelineResult | GemmaCallError | unknown;
+/** "Brainstorming with local Gemma…" (spinner, before the call). */
+export declare function brainstormingLabel(pipeline: GemmaCallPipeline): string;
+/** The answer spinner, before the call. */
+export declare function answeringLabel(pipeline: GemmaCallPipeline, hasImages: boolean): string;
+/**
+ * While subscribed, `onLabel` receives the answer spinner text for the runtime of every attempt
+ * that starts in the caller's turn (§3.5, P-21 / Codex R2-F4), so the failover retry re-labels
+ * the line for the runtime actually answering. Returns the unsubscribe.
+ */
+export declare function followAnsweringLabel(pipeline: GemmaCallPipeline, hasImages: boolean, onLabel: (label: string) => void): () => void;
+/** "Hosted Gemma" / "Local Gemma" for the runtime that produced (or last attempted) the outcome. */
+export declare function modelLabel(pipeline: GemmaCallPipeline, outcome: Outcome): string;
+/** "The model" (hosted) / "The local model" (local). */
+export declare function modelNoun(pipeline: GemmaCallPipeline, outcome: Outcome): string;
+/** "the model" (hosted) / "the local model" (local), mid-sentence. */
+export declare function modelNounInSentence(pipeline: GemmaCallPipeline, outcome: Outcome): string;
+/** The note under a concise fallback answer when the detailed generation came back empty. */
+export declare function emptyDetailedAnswerNote(pipeline: GemmaCallPipeline, outcome: Outcome): string;
+/** The note under a concise fallback answer when the detailed generation failed. */
+export declare function unavailableDetailedAnswerNote(pipeline: GemmaCallPipeline, outcome: Outcome, reason: string): string;
+/**
+ * The trust line. "No hosted model was called and no code was changed." only when neither the
+ * turn (TurnScope: classify, every advisory call, every retry) nor the given outcomes attempted
+ * hosted; otherwise "No code was changed." (R4-F5, R5-F1, Codex R2-F1).
+ */
+export declare function trustLine(pipeline: GemmaCallPipeline | null | undefined, ...outcomes: Outcome[]): string;
+/**
+ * "local Gemma" / "hosted Gemma" for the runtime a progress phase starts on (§3.5: "when a
+ * progress phase starts, from `currentRuntime()`"). Display text, carried on the progress event
+ * and rendered only by {@link progressPhaseLabel}.
+ */
+export declare function progressRuntimeNoun(pipeline: GemmaCallPipeline): string;
+/**
+ * While subscribed, `onRuntimeNoun` receives "local Gemma" / "hosted Gemma" for every attempt
+ * that starts in the caller's turn, so an active progress phase re-labels when a hosted retry
+ * starts (§3.5, Codex R2-F4). Returns the unsubscribe.
+ */
+export declare function followProgressRuntimeNoun(pipeline: GemmaCallPipeline, onRuntimeNoun: (runtimeNoun: string) => void): () => void;
+/**
+ * Progress-phase labels (desktop progress line and the mobile relay, §3.5). The runtime noun
+ * comes from the event (set when the phase starts and re-set when an attempt starts on another
+ * runtime); without one the label is runtime-neutral.
+ */
+export declare function progressPhaseLabel(phase: 'classifying' | 'browse_synthesizing' | 'brainstorming' | 'answering' | 'analyzing_images', runtimeNoun?: string): string;
+/**
+ * The status badge follows the session source (failover and recovery, §3.5): `onKind` receives
+ * the badge's display kind each time the source switches. The kind is read only by the badge
+ * formatter (`status-format.ts`). Returns the unsubscribe.
+ */
+export declare function followBadgeKind(pipeline: GemmaCallPipeline, onKind: (kind: Exclude<PlannerRuntimeKind, 'local_unavailable'>) => void): () => void;
+/**
+ * The shared note for images left out of an answer (§3.7). Posted after the call, before the
+ * answer — and with the empty-answer message when the attempt that reached its runner answered
+ * nothing (N6). Returns undefined when nothing was left out or no attempt reached a runner.
+ */
+export declare function omittedImagesNote(outcome: {
+    images?: Pick<PipelineResult, 'images'>['images'];
+}, attempted: number): string | undefined;
+export {};

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

@@ -9,13 +9,21 @@ export interface TaskProgressRelay {
     relay(event: TaskProgressEvent): Promise<boolean>;
     reset(): void;
 }
-export declare const TERMINAL_MILESTONES: Set<"preparing_workspace" | "shadow_created" | "implementor_running" | "diff_captured" | "submitting_diff" | "reviewers_dispatched" | "seat_update" | "verdicts_progress" | "revise_round" | "round_failed" | "continuation_offered" | "declared_tests_skipped" | "promoting" | "promoted" | "discarding" | "discarded" | "not_applied" | "waiting_user" | "planner_classifying" | "familiarizing" | "agent_advisory" | "web_formulating_query" | "web_searching" | "web_fetching" | "web_synthesizing" | "advisory_dispatched" | "advisory_seat_update" | "advisory_synthesizing" | "familiarize_scanning" | "familiarize_generating" | "brainstorming" | "team_decomposing" | "progress_cleared" | "halt_notice">;
+export declare const TERMINAL_MILESTONES: Set<"brainstorming" | "answering" | "preparing_workspace" | "shadow_created" | "implementor_running" | "diff_captured" | "submitting_diff" | "reviewers_dispatched" | "seat_update" | "verdicts_progress" | "revise_round" | "round_failed" | "continuation_offered" | "declared_tests_skipped" | "promoting" | "promoted" | "discarding" | "discarded" | "not_applied" | "waiting_user" | "planner_classifying" | "familiarizing" | "agent_advisory" | "web_formulating_query" | "web_searching" | "web_fetching" | "web_synthesizing" | "advisory_dispatched" | "advisory_seat_update" | "advisory_synthesizing" | "familiarize_scanning" | "familiarize_generating" | "team_decomposing" | "progress_cleared" | "halt_notice">;
 /**
  * Milestones that must be emitted immediately to mobile without debounce delay.
  * Includes terminal task outcomes, discrete reviewer verdict submissions, and
  * verdict collection progress, ensuring mobile notifications always precede gate prompts.
  */
 export declare function isImmediateMilestone(event: TaskProgressEvent): boolean;
+/**
+ * Planner parity §3.5 / P-11 / P-21 (Stage 2 codex S2-codex-F3): the phases whose mobile label
+ * names the runtime doing the work. Each carries the SAME text as the desktop line (from
+ * `runtime-labels.ts`), and a re-label of the phase in progress (the hosted retry after a
+ * failover, or recovery) is relayed at once rather than debounced, so the phone names the
+ * runtime actually working while that attempt is still running.
+ */
+export declare const RUNTIME_LABELLED_PHASES: ReadonlySet<TaskProgressEvent['phase']>;
 export declare const MAX_MOBILE_PROGRESS_MESSAGE_LENGTH = 120;
 export declare const DEFAULT_MIN_RELAY_INTERVAL_MS = 2500;
 /**

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

@@ -76,6 +76,7 @@ export type TaskProgressEvent = ({
     phase: 'waiting_user';
 } | {
     phase: 'planner_classifying';
+    runtimeNoun?: string;
 } | {
     phase: 'familiarizing';
 } | {
@@ -91,6 +92,7 @@ export type TaskProgressEvent = ({
     url?: string;
 } | {
     phase: 'web_synthesizing';
+    runtimeNoun?: string;
 } | {
     phase: 'advisory_dispatched';
     agents?: string[];
@@ -109,6 +111,11 @@ export type TaskProgressEvent = ({
     agent?: string;
 } | {
     phase: 'brainstorming';
+    runtimeNoun?: string;
+} | {
+    phase: 'answering';
+    images?: boolean;
+    runtimeNoun?: string;
 } | {
     phase: 'team_decomposing';
 } | {

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

@@ -33,3 +33,10 @@ export declare class PlannerCacheLayer {
     private ensureDir;
     private rmRecursiveSafe;
 }
+/**
+ * Planner parity §3.5 / P-20 — the planner keeps no cache on either runtime, so
+ * `/cache-clear` only removes what an earlier version may have left for THIS user: the
+ * workflow cache file and its `.bak` / `.tmp` siblings, by exact path (never a directory
+ * walk; `unlink` refuses a directory and removes a symlink itself, not its target).
+ */
+export declare function clearRetiredPlannerCache(userId: string, cacheRoot?: string): Promise<string>;

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

@@ -0,0 +1,61 @@
+import type { OmittedImage } from './gemma-pipeline';
+export type GemmaRuntime = 'local' | 'hosted';
+export declare abstract class GemmaCallError extends Error {
+    /** Every runtime the call attempted, in order (set by the pipeline). */
+    attemptedRuntimes: GemmaRuntime[];
+    /**
+     * The image selection of the last attempt that reached its runner (set by the pipeline), so
+     * an answer that fails after dispatch can still say which images were left out (§3.7, N6).
+     */
+    images?: {
+        included: number[];
+        omitted: OmittedImage[];
+    };
+    protected constructor(name: string, message: string);
+}
+/**
+ * The runtime could not be reached or did not answer: connection refused/reset, timeout,
+ * 5xx, throttling, a malformed transport response, or ANY unrecognised runner failure (the
+ * catch-all keeps today's composite failover behaviour, `composite-adapter.ts:170-190`).
+ * The only class a composite source fails over on.
+ */
+export declare class GemmaTransportError extends GemmaCallError {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/** The prompt does not fit the routed runtime's context window (D-13 capacity). */
+export declare class GemmaContextFullError extends GemmaCallError {
+    constructor(message: string);
+}
+/** The model produced no visible text and stopped normally. */
+export declare class GemmaEmptyOutputError extends GemmaCallError {
+    constructor(message?: string);
+}
+/** The model produced no visible text for its whole output budget (or a watchdog cut it). */
+export declare class GemmaHiddenTokenLoopError extends GemmaCallError {
+    constructor(message?: string);
+}
+/**
+ * The hosted server refused the call on policy: budget, tier, ownership, image, size,
+ * provider, malformed request; or the client has no session key yet. Never a failover.
+ */
+export type GemmaPolicyCode = 'BudgetExceeded' | 'TierGateRejected' | 'OwnershipRejected' | 'ImageRejected' | 'MalformedRequest' | 'RequestTooLarge' | 'ProviderUnsupported' | 'SessionUnavailable';
+export declare class GemmaPolicyError extends GemmaCallError {
+    readonly code: GemmaPolicyCode;
+    constructor(code: GemmaPolicyCode, message: string);
+}
+/** The hosted backend predates the client-rendered contract (§7). */
+export declare class GemmaBackendTooOldError extends GemmaCallError {
+    constructor(message?: string);
+}
+/** The caller abandoned the call. Never a failover or a source switch (§3.2, R3-F4). */
+export declare class GemmaAbortError extends GemmaCallError {
+    constructor(message?: string);
+}
+export declare function isGemmaCallError(err: unknown): err is GemmaCallError;
+/**
+ * The user-facing cause for a typed failure (§3.2 "Shell handling", identical on both
+ * runtimes). Returns `undefined` for an untyped error (the caller keeps its own text).
+ * Empty / hidden-token output keeps each caller's own wording.
+ */
+export declare function describeGemmaError(err: unknown): string | undefined;

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

@@ -0,0 +1,219 @@
+import { GemmaCallError, GemmaEmptyOutputError, type GemmaRuntime } from './gemma-errors';
+import { type GemmaRunner, type ImageFormat, type RunnerImage, type RunnerImageCapability } from './gemma-runner';
+/** §3.3 — every rendered prompt, both runtimes, before any runner call (= the server caps). */
+export declare const GEMMA_PROMPT_BYTE_BOUND = 100000;
+/** §3.3 — output budgets are capped at the hosted server ceiling on both runtimes. */
+export declare const GEMMA_MAX_OUTPUT_TOKENS = 1536;
+/**
+ * §3.3 / §4 — a classify call's budget is capped at the rendered-classify contract's ceiling
+ * (`maxOutputTokens: Int! # 1..1024`), on both runtimes, so no caller can send hosted a request
+ * the server refuses while local accepts it (Stage 1 R1-F7).
+ */
+export declare const GEMMA_CLASSIFY_MAX_OUTPUT_TOKENS = 1024;
+/** Marker appended to a text answer that ended early (moved here from `ollama.ts`, §3.3). */
+export declare const PIPELINE_CUT_OFF_MARKER = " [\u2026]";
+/** Composite recovery probe interval (unchanged from the composite adapter). */
+export declare const RECOVERY_PROBE_INTERVAL_MS = 30000;
+/**
+ * The runtimes attempted by ONE admitted natural-language turn. Each turn owns its scope;
+ * nothing can reset or replace another turn's record. Implemented with AsyncLocalStorage:
+ * every pipeline call made inside the turn's async context records into it, including the
+ * classify (the adapter never handles runtime facts) — and a slash command, which runs
+ * outside that context (it bypasses the submission queue), never touches it.
+ *
+ * Inheritance (Stage 1 N7): AsyncLocalStorage follows every async continuation, timers and
+ * un-awaited promises included, so background work a turn STARTS inherits its scope. Every
+ * pipeline call the shell makes for a turn is awaited inside it (classify, the answer, the
+ * brainstorm, the browse readers, the git-status intent). The one background caller — the
+ * verdict classifier, running inside a task the turn started — opts out with
+ * {@link GemmaCallPipeline.runOutsideTurn}; a new background entry point must do the same.
+ */
+export declare class TurnScope {
+    private readonly attempted;
+    /** Recorded when an attempt STARTS, before dispatch, so a pending hosted call counts. */
+    record(runtime: GemmaRuntime): void;
+    attemptedRuntimes(): GemmaRuntime[];
+}
+export interface RunnerSource {
+    current(): GemmaRunner;
+    /**
+     * True when a transport failure of `failed` (the runner THIS attempt used) can be retried
+     * on another runner. Decided by the failed runner, never by the source's current state:
+     * one source serves every concurrent call, so another call or the recovery probe may have
+     * moved it meanwhile (§3.2: failover is local → hosted only; §3.4: never hosted → local).
+     */
+    canFailOver(failed: GemmaRunner): boolean;
+    /** Switch to the fallback runner (a no-op switch when already there) and return it. */
+    failOver(failed: GemmaRunner, reason: GemmaCallError): GemmaRunner;
+    onSourceChange(listener: (runtime: GemmaRuntime) => void): () => void;
+    runners(): GemmaRunner[];
+    dispose(): void;
+    /** Sources that switch runtimes post a notice per switch (§3.4). */
+    bindNotice?(sink: (text: string) => void): void;
+}
+export declare class SingleRunnerSource implements RunnerSource {
+    private readonly runner;
+    constructor(runner: GemmaRunner);
+    current(): GemmaRunner;
+    canFailOver(_failed: GemmaRunner): boolean;
+    failOver(_failed: GemmaRunner, _reason: GemmaCallError): GemmaRunner;
+    onSourceChange(): () => void;
+    runners(): GemmaRunner[];
+    dispose(): void;
+}
+/**
+ * Pro/Max with a local model: local first, hosted on a TRANSPORT failure, back to local when
+ * the 30 s probe succeeds. One instance per session serves classify, advisory, git-status and
+ * the verdict classifier, so every consumer sees the same runtime at the same moment.
+ */
+export declare class CompositeRunnerSource implements RunnerSource {
+    private readonly local;
+    private readonly hosted;
+    private readonly notice;
+    private readonly probeIntervalMs;
+    private source;
+    private probeTimer;
+    private probing;
+    private readonly listeners;
+    private disposed;
+    private boundNotice;
+    constructor(local: GemmaRunner, hosted: GemmaRunner, notice?: (text: string) => void, probeIntervalMs?: number);
+    /** The pipeline binds its notice sink here, so the shell's advisory line gets the switch notices. */
+    bindNotice(sink: (text: string) => void): void;
+    private say;
+    current(): GemmaRunner;
+    canFailOver(failed: GemmaRunner): boolean;
+    failOver(_failed: GemmaRunner, reason: GemmaCallError): GemmaRunner;
+    onSourceChange(listener: (runtime: GemmaRuntime) => void): () => void;
+    runners(): GemmaRunner[];
+    dispose(): void;
+    private emit;
+    private startProbe;
+    /** Test seam + timer body. */
+    tick(): Promise<void>;
+}
+export interface PipelineImage {
+    /** Position in the user's attachment order (stable across attempts). */
+    index: number;
+    /** Reads the bytes (fd-safe in the shell). May throw: the image is then "unreadable". */
+    read(): {
+        buf: Buffer;
+        mime: string;
+    };
+}
+export type OmittedReason = 'over-limit' | 'format' | 'unreadable';
+export interface OmittedImage {
+    index: number;
+    reason: OmittedReason;
+    /** For a `format` omission of a known format (the note names it, e.g. WEBP on local). */
+    format?: ImageFormat;
+}
+export interface LoadedImage {
+    index: number;
+    image?: RunnerImage;
+    unreadable?: boolean;
+    /** The bytes are not one of the five image formats any runtime reads. */
+    unknownFormat?: boolean;
+}
+/** First-N-under-cap in attachment order (today's local rule, `attachments.ts:953-976`), per capability. */
+export declare function selectImagesForCapability(loaded: LoadedImage[], cap: RunnerImageCapability): {
+    selected: Array<{
+        index: number;
+        image: RunnerImage;
+    }>;
+    omitted: OmittedImage[];
+};
+/** Read each image once per call; selection is redone per attempt from these (§3.7). */
+export declare function loadPipelineImages(images: PipelineImage[]): LoadedImage[];
+export interface PipelineResult {
+    text: string;
+    finishReason: 'stop' | 'length';
+    runtime: GemmaRuntime;
+    attemptedRuntimes: GemmaRuntime[];
+    images: {
+        included: number[];
+        omitted: OmittedImage[];
+    };
+    callId: number;
+}
+export interface PipelineClassifyRequest {
+    prompt: string;
+    /** Absent → JSON-object mode (the verdict classifier). */
+    jsonSchema?: object;
+    maxOutputTokens: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface PipelineAdviseRequest {
+    /** Rendered per attempt, with the number of images that attempt includes (§3.7). */
+    buildPrompt: (ctx: {
+        includedImageCount: number;
+    }) => string;
+    images?: PipelineImage[];
+    responseFormat?: 'json' | 'text';
+    numPredict?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    numCtx?: number;
+    think?: boolean;
+}
+/** The shape today's text-only callers use (`AdvisoryOptions`), minus runtime facts. */
+export interface PipelineAdvisoryOptions {
+    responseFormat?: 'json' | 'text';
+    numPredict?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    numCtx?: number;
+    think?: boolean;
+    /** Ignored (§3.3: temperature is always 0). */
+    temperature?: number;
+    /** Raw base64 images (legacy shape). Image callers should use `advise()` instead. */
+    images?: string[];
+}
+/**
+ * A caller that rejects a returned answer as empty (after its own sanitization) reports it as the
+ * empty answer of the call that produced it: the error carries that call's attempted runtimes and
+ * image selection, so trust lines and notes stay truthful (§3.2). Runtime facts stay in the
+ * pipeline (core Stage 1 R1-F1).
+ */
+export declare function emptyOutputErrorFor(result: PipelineResult, message?: string): GemmaEmptyOutputError;
+export declare class GemmaCallPipeline {
+    private readonly source;
+    private callSeq;
+    private readonly turnAttemptListeners;
+    private noticeSink;
+    constructor(source: RunnerSource);
+    /** The shell's advisory line for the source's switch notices (§3.4); null detaches it. */
+    setNoticeSink(sink: ((text: string) => void) | null): void;
+    notify(text: string): void;
+    currentRuntime(): GemmaRuntime;
+    onSourceChange(listener: (runtime: GemmaRuntime) => void): () => void;
+    /**
+     * Progress re-labelling (§3.5, Codex R2-F4): while subscribed, `listener` hears the runtime
+     * of every attempt that STARTS in the caller's turn (outside a turn: every attempt), so an
+     * active progress phase re-labels when a hosted retry starts. Calls outside the turn (the
+     * verdict classifier) never re-label a turn's phase.
+     */
+    onTurnAttemptStart(listener: (runtime: GemmaRuntime) => void): () => void;
+    openTurn(): TurnScope;
+    runInTurn<T>(scope: TurnScope, fn: () => Promise<T>): Promise<T>;
+    /** Calls that are not part of the user's turn (the verdict classifier) never record into it. */
+    runOutsideTurn<T>(fn: () => Promise<T>): Promise<T>;
+    currentTurn(): TurnScope | undefined;
+    setActiveSession(sessionId: string | null): void;
+    warm(): Promise<boolean>;
+    unload(): Promise<boolean>;
+    dispose(): void;
+    /** Classify-mode call: the planner (via the adapter) and the verdict classifier. */
+    classify(req: PipelineClassifyRequest): Promise<PipelineResult>;
+    /** Advisory-mode call with per-attempt image selection and prompt rendering (§3.4, §3.7). */
+    advise(req: PipelineAdviseRequest): Promise<PipelineResult>;
+    /** Text-only callers' shape (browse readers, git-status intent). Returns the text. */
+    generateAdvisory(promptText: string, options?: PipelineAdvisoryOptions): Promise<string>;
+    private assertPromptBound;
+    /** §3.3 — the same rules on both runtimes. */
+    private postProcessAdvisory;
+    /** The attempt loop: failover on transport errors only, never after the caller aborted. */
+    private run;
+    private tag;
+}