@quantiya/codevibe-claude-plugin 2.0.73 → 2.0.75

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;
+}

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

@@ -0,0 +1,66 @@
+import type { GemmaRuntime } from './gemma-errors';
+export type ImageFormat = 'png' | 'jpeg' | 'gif' | 'bmp' | 'webp';
+export interface RunnerImageCapability {
+    maxCount: number;
+    /** Sum of raw image bytes per call. */
+    maxTotalRawBytes: number;
+    maxImageRawBytes: number;
+    formats: readonly ImageFormat[];
+    /**
+     * Hosted only (§3.3): the exact serialized provider body must not exceed this, so a
+     * JSON-escaping-heavy prompt leaves room for fewer images.
+     */
+    maxProviderBodyBytes?: number;
+    /** Hosted only: the AppSync/Lambda leg's total ciphertext ceiling (planner-proxy, unchanged). */
+    maxTotalCiphertextBytes?: number;
+}
+export interface RunnerCapabilities {
+    images: RunnerImageCapability;
+}
+export interface RunnerResult {
+    text: string;
+    finishReason: 'stop' | 'length';
+}
+export interface RunnerClassifyOptions {
+    /** Absent → JSON-object mode (Ollama `format:"json"`, Mantle `json_object`). */
+    jsonSchema?: object;
+    maxOutputTokens: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface RunnerImage {
+    /** Raw base64, no `data:` prefix. */
+    base64: string;
+    format: ImageFormat;
+    rawBytes: number;
+}
+export interface RunnerAdvisoryOptions {
+    responseFormat: 'json' | 'text';
+    maxOutputTokens: number;
+    /** Already selected for THIS runner by the pipeline (§3.7). */
+    images: RunnerImage[];
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    /** Ollama transport knobs (§3.3); hosted ignores them. */
+    numCtx?: number;
+    think?: boolean;
+}
+export interface GemmaRunner {
+    readonly runtime: GemmaRuntime;
+    /** Display only: never read for behaviour. */
+    readonly label: string;
+    readonly capabilities: RunnerCapabilities;
+    classify(prompt: string, opts: RunnerClassifyOptions): Promise<RunnerResult>;
+    generateAdvisory(prompt: string, opts: RunnerAdvisoryOptions): Promise<RunnerResult>;
+    /** Liveness probe for the composite's recovery timer; never throws. */
+    probe(): Promise<boolean>;
+    /** Session binding (hosted needs the active session and its key; local ignores it). */
+    setActiveSession?(sessionId: string | null): void;
+    /** Fire-and-forget model pre-warm / release (local only); never throw. */
+    warm?(): Promise<boolean>;
+    unload?(): Promise<boolean>;
+}
+export declare const LOCAL_IMAGE_CAPABILITY: RunnerImageCapability;
+export declare const HOSTED_IMAGE_CAPABILITY: RunnerImageCapability;
+export declare function imageFormatFromMime(mime: string): ImageFormat | null;
+export declare function mimeFromImageFormat(format: ImageFormat): string;

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

@@ -0,0 +1,83 @@
+import { GemmaCallError } from './gemma-errors';
+import { type GemmaRunner, type RunnerAdvisoryOptions, type RunnerCapabilities, type RunnerClassifyOptions, type RunnerImage, type RunnerResult } from './gemma-runner';
+export interface HostedRenderedTransport {
+    classifyRenderedPlannerPrompt(input: {
+        sessionId: string;
+        encryptedPrompt: string;
+        responseSchema?: string;
+        maxOutputTokens: number;
+    }, signal?: AbortSignal): Promise<{
+        encryptedOutput: string;
+        finishReason: 'STOP' | 'LENGTH' | null;
+    }>;
+    generatePlannerAdvisoryRendered(input: {
+        sessionId: string;
+        prompt: string;
+        images?: string[];
+        maxTokens: number;
+        temperature: number;
+        responseFormat: 'TEXT' | 'JSON_OBJECT';
+    }, signal?: AbortSignal): Promise<{
+        advisoryText: string;
+        finishReason: 'STOP' | 'LENGTH' | null;
+    }>;
+}
+export interface HostedRunnerCrypto {
+    encryptString(plaintext: string, sessionKeyB64: string): string;
+    decryptString(ciphertextB64: string, sessionKeyB64: string): string;
+}
+export interface HostedSessionKeyResolver {
+    getSessionKey(sessionId: string): Promise<string | null>;
+}
+/**
+ * The model id the server's body uses (planner-proxy `DEFAULT_BEDROCK_MODEL_ID`). The client's
+ * 3,400,000 B body limit sits 100 KB under the server's 3,500,000 B check, which absorbs any
+ * difference in the model id the server is configured with.
+ */
+export declare const HOSTED_BODY_MODEL_ID = "google.gemma-4-26b-a4b";
+/**
+ * Mirror of planner-proxy `renderedChatBody` + `invokeMantle` (§4.2): the exact JSON body the
+ * server sends for a client-rendered call, so the pipeline can select images against the
+ * provider-body limit BEFORE sending (§3.3, §3.4 step 5). Field order is part of the contract;
+ * a cross-repo golden fixture pins it on both sides.
+ */
+export declare function hostedRenderedBody(req: {
+    promptText: string;
+    images?: Array<{
+        mime: string;
+        base64: string;
+    }>;
+    maxOutputTokens: number;
+    temperature: number;
+    responseFormat?: unknown;
+}): string;
+export declare function hostedRenderedBodyBytes(req: Parameters<typeof hostedRenderedBody>[0]): number;
+/** base64(AES-GCM(utf-8 plaintext)) length for a plaintext of `plaintextBytes` (nonce 12 + tag 16). */
+export declare function sessionCiphertextLength(plaintextBytes: number): number;
+/** Map any failure of a hosted call to the typed set (§3.2). Reads the server's verbatim message. */
+export declare function toHostedGemmaError(err: unknown, signal?: AbortSignal): GemmaCallError;
+export declare class HostedGemmaRunner implements GemmaRunner {
+    private readonly deps;
+    readonly runtime: "hosted";
+    readonly label = "Hosted Gemma (AWS Bedrock)";
+    readonly capabilities: RunnerCapabilities;
+    private activeSessionId;
+    constructor(deps: {
+        transport: HostedRenderedTransport;
+        crypto: HostedRunnerCrypto;
+        sessionKeyResolver: HostedSessionKeyResolver;
+    });
+    setActiveSession(sessionId: string | null): void;
+    private sessionAndKey;
+    private finish;
+    private withTimeout;
+    classify(prompt: string, opts: RunnerClassifyOptions): Promise<RunnerResult>;
+    generateAdvisory(prompt: string, opts: RunnerAdvisoryOptions): Promise<RunnerResult>;
+    /** Hosted is the composite's fallback; it is never probed for recovery. */
+    probe(): Promise<boolean>;
+}
+/** Data-URI image parts as the server will build them (for the body-size mirror). */
+export declare function hostedBodyImages(images: RunnerImage[]): Array<{
+    mime: string;
+    base64: string;
+}>;

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

@@ -5,6 +5,8 @@ export { PlannerHealthMachine } from './health-state';
 export { BackendPlannerClient, PlannerBudgetExceededError, PlannerTierGateRejectedError, type PlannerAppSyncTransport, type PlannerCryptoBridge, type SessionKeyResolver, type ShellEventEmit, type EmitShellEventFn, } from './client';
 export { LocalGemmaPlannerAdapter, parseLocalGemmaPlannerDecision, PlannerOutputUnparseableError, renderLocalGemmaPlannerPrompt, type LocalGemmaPlannerRunner, } from './local-gemma';
 export { parseLocalGemmaAdvisorySummary, renderLocalGemmaFamiliarizePrompt, renderLocalGemmaMultiBrowsePrompt, renderLocalGemmaBrowsePrompt, MAX_BROWSE_CONTENT_CHARS, MAX_MULTI_BROWSE_TOTAL_CONTENT_CHARS, MAX_MULTI_BROWSE_RENDERED_PROMPT_CHARS, type AdvisoryRunner, type AdvisoryOptions, type AdvisoryResponseFormat, type LocalGemmaAdvisoryRunner, type LocalGemmaAdvisoryOptions, type LocalGemmaAdvisoryResponseFormat, } from './local-advisory';
-export { CompositePlannerAdapter, type CompositePlannerAdapterOptions, } from './composite-adapter';
-export { HostedGemmaAdvisoryRunner, type HostedGemmaAdvisoryRunnerDeps, type HostedAdvisoryTransport, } from './hosted-advisory';
-export { CompositeAdvisoryRunner, type CompositeAdvisoryRunnerOptions, } from './composite-advisory';
+export { GemmaPlannerAdapter, applyMaxTierGate, renderGemmaPlannerPrompt, parseGemmaPlannerDecision, type GemmaClassifyPort, } from './local-gemma';
+export * from './gemma-errors';
+export * from './gemma-runner';
+export * from './gemma-pipeline';
+export * from './hosted-gemma-runner';

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

@@ -13,7 +13,6 @@ export interface AdvisoryRunner {
      */
     unload?(): Promise<boolean>;
     runtimeLabel: string;
-    readonly providerKind?: 'local' | 'hosted';
 }
 export type AdvisoryResponseFormat = 'json' | 'text';
 export interface AdvisoryOptions {
@@ -21,11 +20,9 @@ export interface AdvisoryOptions {
     numPredict?: number;
     /**
      * RAW base64 images (NO `data:` prefix) for the MULTIMODAL local answerer
-     * (IMAGE-ATTACHMENT-DESIGN.md §6). Set ONLY by the shell's `routeAdvisory` /
-     * image-brainstorm with `responseFormat:'text'`. The Ollama runtime forwards
-     * these to `/api/generate images[]`; the subprocess `LocalGemmaProcessRunner`
-     * has no image channel and IGNORES them (documented no-op, §6 Role B). NEVER set
-     * on the classifier (forced-JSON) or on `browse`/`familiarize`.
+     * (IMAGE-ATTACHMENT-DESIGN.md §6) on this legacy runner shape. The Ollama runtime
+     * forwards these to `/api/generate images[]`. The orchestration shell's image
+     * callers go through the Gemma pipeline's `advise()` (planner parity §3.7).
      */
     images?: string[];
     /**

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

@@ -21,7 +21,6 @@ export interface LocalGemmaPlannerRunner {
      */
     unload?(): Promise<boolean>;
     runtimeLabel: string;
-    readonly providerKind?: 'local' | 'hosted';
 }
 /**
  * A1a P0 (R3 — design §7 "the conductor must NEVER hard-fail"): thrown when the
@@ -67,7 +66,7 @@ export declare class PlannerOutputUnparseableError extends Error {
         degradeTo?: PlannerOutputUnparseableError['degradeTo'];
     });
 }
-export declare function localGemmaAllowedActions(isSubprocessRunner: boolean): ReadonlySet<PlannerDecision['action']>;
+export declare function localGemmaAllowedActions(): ReadonlySet<PlannerDecision['action']>;
 interface LocalGemmaDecisionJsonSchema {
     type: 'object';
     properties: {
@@ -75,19 +74,19 @@ interface LocalGemmaDecisionJsonSchema {
             type: 'string';
         };
         clarifying_question: {
-            type: 'string';
+            type: ['string', 'null'];
         };
         advisory_summary: {
-            type: 'string';
+            type: ['string', 'null'];
         };
         browseUrls: {
-            type: 'array';
+            type: ['array', 'null'];
             items: {
                 type: 'string';
             };
         };
         browseQuery: {
-            type: 'string';
+            type: ['string', 'null'];
         };
         action: {
             type: 'string';
@@ -97,30 +96,92 @@ interface LocalGemmaDecisionJsonSchema {
     required: string[];
     additionalProperties: boolean;
 }
-/** The Ollama runner's schema (no `summarize_current_status`). */
+/**
+ * The ONE planner decision schema (both runtimes). Its canonical SHA-256 is allow-listed by
+ * planner-proxy (`lambda/planner-proxy/schemas.ts`); a change here needs the backend
+ * allow-list updated first (design §4.1, §10) or hosted decoding degrades to JSON-object mode.
+ */
 export declare const LOCAL_GEMMA_DECISION_JSON_SCHEMA: LocalGemmaDecisionJsonSchema;
-/** The subprocess runner's schema keeps `summarize_current_status` (Stage-2 codex R1-F3). */
-export declare const LOCAL_GEMMA_SUBPROCESS_DECISION_JSON_SCHEMA: LocalGemmaDecisionJsonSchema;
+export declare const GEMMA_DECISION_JSON_SCHEMA: LocalGemmaDecisionJsonSchema;
 /**
- * Text-only route classifier prompt. It intentionally excludes repository
- * paths, summaries, source snippets, file bodies, and the raw structural digest.
+ * The shape the planner prompt was rendered with — sizes and counts only, never text (Stage 2
+ * codex S2-codex-F4: the evidence that a maximum input reached the model as rendered).
  */
-export declare function renderLocalGemmaPlannerPrompt(input: PlannerInput, options?: {
-    isSubprocessRunner?: boolean;
-}): string;
+export interface PlannerPromptShape {
+    /**
+     * The input after the per-field caps (prompt 4,000; clarifications compacted to 4, questions
+     * 300 / answers 900; context 6,000) and BEFORE fitting to the rendered-prompt cap. A maximum
+     * input (the design's S9 shape) shows every field at its cap here.
+     */
+    capped: {
+        userPromptChars: number;
+        clarifications: number;
+        clarificationQuestionChars: number[];
+        clarificationAnswerChars: number[];
+        contextChars: number;
+    };
+    /** What was rendered after fitting (oldest clarifications go first, then context, then prompt). */
+    userPromptChars: number;
+    clarifications: number;
+    clarificationQuestionChars: number[];
+    clarificationAnswerChars: number[];
+    contextChars: number;
+    examplesKept: number;
+    renderedChars: number;
+    renderedBytes: number;
+}
+export declare function renderLocalGemmaPlannerPrompt(input: PlannerInput): string;
+/** {@link renderLocalGemmaPlannerPrompt} plus the rendered shape (sizes and counts only). */
+export declare function renderLocalGemmaPlannerPromptWithShape(input: PlannerInput): {
+    prompt: string;
+    shape: PlannerPromptShape;
+};
 /** Characters of raw model output retained on {@link PlannerOutputUnparseableError.rawOutputHead}. */
 export declare const RAW_OUTPUT_HEAD_CHARS = 500;
 /** Terminal-control-free, bounded head of a raw model output for the warn log. */
 export declare function summarizeRawOutputForLog(raw: string): string;
-export declare function parseLocalGemmaPlannerDecision(raw: string, options?: {
-    isSubprocessRunner?: boolean;
-}): PlannerDecision;
-export declare class LocalGemmaPlannerAdapter implements PlannerAdapter {
-    private readonly runner;
-    private activeSessionId;
-    constructor(runner: LocalGemmaPlannerRunner);
+export declare function parseLocalGemmaPlannerDecision(raw: string): PlannerDecision;
+/**
+ * The adapter's view of the shared pipeline (`gemma-pipeline.ts`): a classify call that
+ * returns the raw model text. The adapter never sees which runtime answered (§3.2).
+ */
+export interface GemmaClassifyPort {
+    classify(req: {
+        prompt: string;
+        jsonSchema?: object;
+        maxOutputTokens: number;
+    }): Promise<{
+        text: string;
+    }>;
+    setActiveSession?(sessionId: string | null): void;
+}
+/**
+ * Planner parity D-4 (codevibe-backend docs/2.0/PLANNER-RUNTIME-PARITY-DESIGN.md §3.3): the
+ * Max-tier gate on `team_decompose`, on BOTH runtimes, exactly the server's former rule
+ * (planner-proxy `applyDeterministicMaxGate`). It runs post-parse, so a converted `start_task`
+ * still passes the shell's P43 destructive backstop and `confirmBeforeStart`.
+ */
+export declare function applyMaxTierGate(decision: PlannerDecision, tier: PlannerInput['sessionContext']['tier']): PlannerDecision;
+/**
+ * The ONE planner implementation for both runtimes (§3.1): render the shared prompt, classify
+ * through the pipeline (which owns failover and the runtime), parse with the shared parser,
+ * apply the Max gate. Identical logic whichever runtime answered.
+ */
+export declare class GemmaPlannerAdapter implements PlannerAdapter {
+    private readonly port;
+    constructor(port: GemmaClassifyPort);
     classify(input: PlannerInput): Promise<PlannerDecision>;
     probe(): Promise<PlannerProbeResult>;
     setActiveSession(sessionId: string | null): void;
 }
+/**
+ * Compatibility alias (§3.1: "the old name stays as an alias"): wraps a legacy text runner
+ * (`classify(prompt, { jsonSchema, numPredict }) → string`) as the classify port. Used by
+ * tests and spikes; production builds `GemmaPlannerAdapter` over the pipeline.
+ */
+export declare class LocalGemmaPlannerAdapter extends GemmaPlannerAdapter {
+    constructor(runner: LocalGemmaPlannerRunner);
+}
+export declare const renderGemmaPlannerPrompt: typeof renderLocalGemmaPlannerPrompt;
+export declare const parseGemmaPlannerDecision: typeof parseLocalGemmaPlannerDecision;
 export {};

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

@@ -64,10 +64,10 @@ export interface PlannerInput {
     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.
+     * Role-filtered rendering of the canonical ContextItems session history, given to
+     * the planner on BOTH runtimes (planner parity D-2: one rendered prompt for local and
+     * hosted). It lets the planner resolve ordinary multi-turn references without relying
+     * on shell text heuristics or a model-private conversation cache.
      */
     canonicalConversationContext?: string;
 }

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

@@ -1,4 +1,3 @@
-import type { LocalGemmaPlannerRunner } from '../planner/local-gemma';
 import type { AgentKind, ReviewerRole, VerdictKind } from './types';
 /** Per-verdict context (seat/role/agent) — carried for observability; the Gemma
  *  classification itself is context-free (deterministic on `rawText`). */
@@ -22,6 +21,20 @@ export type VerdictClassifier = (rawText: string, ctx: VerdictClassifierContext)
 export declare const VERDICT_CLASSIFIER_UNCERTAIN = "verdict_classifier_uncertain";
 export declare const VERDICT_CLASSIFIER_CONFLICT = "verdict_classifier_conflict";
 export declare const VERDICT_CLASSIFIER_UNAVAILABLE = "verdict_classifier_unavailable";
+/**
+ * The slice of `GemmaCallPipeline` the classifier uses (structural, so tests inject a
+ * fake). Absent `jsonSchema` → JSON-object mode on both runtimes.
+ */
+export interface VerdictGemmaPort {
+    classify(req: {
+        prompt: string;
+        maxOutputTokens: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        text: string;
+    }>;
+    runOutsideTurn<T>(fn: () => Promise<T>): Promise<T>;
+}
 /**
  * Build a fail-closed Gemma verdict classifier. Order:
  *   (1) empty `rawText.trim()===''` → ESCALATE (no `classify` call);
@@ -33,14 +46,14 @@ export declare const VERDICT_CLASSIFIER_UNAVAILABLE = "verdict_classifier_unavai
  * A genuine non-ESCALATE verdict (and a genuine reviewer ESCALATE) returns NO
  * `reason` so the provider keeps the reviewer's own reasoning.
  */
-export declare function makeGemmaVerdictClassifier(runner: LocalGemmaPlannerRunner, opts?: {
+export declare function makeGemmaVerdictClassifier(port: VerdictGemmaPort, opts?: {
     timeoutMs?: number;
 }): VerdictClassifier;
 /**
  * A trivial classifier that returns ESCALATE (with a closed `reason` label) for
- * every input, with no runner. Installed by the wiring when flag=`gemma` but the
- * Gemma runner is null at boot (Ollama unreachable) — so `gemma` mode NEVER
- * silently degrades to the regex parser (agy-MED-1).
+ * every input, with no model call. Installed by the wiring when flag=`gemma` but the
+ * session has no Gemma source at boot — so `gemma` mode NEVER silently degrades to
+ * the regex parser (agy-MED-1).
  */
 export declare function alwaysEscalateClassifier(reason: string): VerdictClassifier;
 /**

package/node_modules/@quantiya/codevibe-core/dist/tool-activity/consolidator.d.ts

@@ -42,6 +42,10 @@ export interface ToolActivityTransport {
     send(sessionId: string, envelope: ToolActivityOutboxEnvelope): Promise<void | DurableSyncResult>;
     /** Required for SYNC_V2: idempotent cleanup after durable source settlement. */
     settled?(sessionId: string, envelope: ToolActivityOutboxEnvelope): Promise<void>;
+    /** Finite request-format compatibility for already sealed legacy windows.
+     * New windows still use this transport's generation-bound format. Both
+     * delegates call the existing createEvent API, never alternate metering. */
+    sendRetainedLegacy?(sessionId: string, envelope: ToolActivityOutboxEnvelope): Promise<void>;
 }
 /**
  * True when a failed TOOL_ACTIVITY `createEvent` is the backend's TYPED
@@ -70,7 +74,7 @@ export interface ToolActivityConsolidatorOptions {
     outbox: ToolActivityOutbox;
     ledger: ToolActivityLedger;
     transport: ToolActivityTransport;
-    /** Seal the open window after this much wall-clock (default 3000ms). */
+    /** Seal after this much wall-clock or logical occurrence span (default 3000ms). */
     windowMs?: number;
     /** Seal (with `continues`) once the open window reaches this many occurrences (default 50). */
     maxOccurrences?: number;

package/node_modules/@quantiya/codevibe-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.68",
+  "version": "2.0.70",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-claude-plugin",
-  "version": "2.0.73",
+  "version": "2.0.75",
   "description": "Control Claude Code from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
@@ -48,7 +48,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^2.0.68",
+    "@quantiya/codevibe-core": "^2.0.70",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",