@quantiya/codevibe-claude-plugin 2.0.73 → 2.0.75

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/decision-attempt-recovery.d.ts

@@ -12,10 +12,10 @@ export interface DecisionAttemptRecoveryClient {
         promptId: string;
         sessionGenerationId?: string;
     }): Promise<unknown>;
-    submitGateDecisionV2?(request: Extract<DecisionAttemptReceipt['request'], {
+    submitGateDecision?(request: Extract<DecisionAttemptReceipt['request'], {
         promptKind: 'GATE';
     }>, canonicalRequestHash: string): Promise<DecisionSubmissionResult>;
-    submitGroupDecisionV2?(request: Extract<DecisionAttemptReceipt['request'], {
+    submitGroupDecision?(request: Extract<DecisionAttemptReceipt['request'], {
         promptKind: 'TASK_GROUP';
     }>, canonicalRequestHash: string): Promise<DecisionSubmissionResult>;
 }

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/gate-decision-submit.d.ts

@@ -8,8 +8,8 @@ import { DecisionAttemptReceiptStore, type CanonicalGateDecisionRequest, type Ca
  * inject a stub). Mirrors `ApplyUserDecisionClient` in `<OrchestrationApp>`.
  */
 export interface ApplyUserDecisionClient {
-    submitGateDecisionV2?(request: CanonicalGateDecisionRequest, canonicalRequestHash: string): Promise<DecisionSubmissionResult>;
-    submitGroupDecisionV2?(request: CanonicalGroupDecisionRequest, canonicalRequestHash: string): Promise<DecisionSubmissionResult>;
+    submitGateDecision?(request: CanonicalGateDecisionRequest, canonicalRequestHash: string): Promise<DecisionSubmissionResult>;
+    submitGroupDecision?(request: CanonicalGroupDecisionRequest, canonicalRequestHash: string): Promise<DecisionSubmissionResult>;
     /** Retained only as a structural compatibility member for older test/plugin clients. */
     applyUserDecision(input: {
         gateId: string;

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;