@quantiya/codevibe-claude-plugin 2.0.72 → 2.0.74

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

@@ -117,6 +117,9 @@ export declare class ToolActivityConsolidator {
     private inFlight;
     /** Windows currently in backoff-limbo (neither queued nor in flight). */
     private retrying;
+    /** One session-wide pause for an explicit shared transport/status denial. */
+    private sendNotBefore;
+    private sendWakeTimer;
     private closed;
     /**
      * §4.5(b)/#232 — waiters woken by {@link deliver}'s finally so a bounded drain

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

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.67",
+  "version": "2.0.69",
   "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.72",
+  "version": "2.0.74",
   "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.67",
+    "@quantiya/codevibe-core": "^2.0.69",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",

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

@@ -1,39 +0,0 @@
-import type { Tier } from '../orchestration-shell/types';
-import type { PlannerAdapter, PlannerDecision, PlannerInput, PlannerProbeResult } from './adapter';
-import type { PlannerHealthMachine } from './health-state';
-export interface CompositePlannerAdapterOptions {
-    localAdapter?: PlannerAdapter | null;
-    hostedAdapter: PlannerAdapter;
-    tier: Tier;
-    localRuntimeKind?: 'hosted' | 'local_gemma_qat' | 'local_unavailable';
-    localRuntimeLabel?: string;
-    hostedHealth?: PlannerHealthMachine | null;
-    recoveryProbeIntervalMs?: number;
-    onNotice?: (message: string) => void;
-    onBeforeHostedFallback?: (input: PlannerInput) => Promise<PlannerInput>;
-}
-export declare class CompositePlannerAdapter implements PlannerAdapter {
-    private readonly opts;
-    private activeSessionId;
-    private currentSource;
-    private recoveryTimer;
-    private readonly sourceChangeListeners;
-    private readonly recoveryIntervalMs;
-    private beforeHostedFallbackHook;
-    constructor(opts: CompositePlannerAdapterOptions);
-    setBeforeHostedFallback(hook: (input: PlannerInput) => Promise<PlannerInput>): void;
-    get activeSource(): 'local' | 'hosted';
-    get runtimeKind(): 'local_gemma_qat' | 'local_unavailable' | 'hosted';
-    get runtimeLabel(): string;
-    get suppressStructuralContextRefresh(): boolean;
-    onSourceChange(listener: (source: 'local' | 'hosted') => void): () => void;
-    private notifySourceChange;
-    private transitionToHosted;
-    private transitionToLocal;
-    private startRecoveryProbe;
-    private stopRecoveryProbe;
-    setActiveSession(sessionId: string | null): void;
-    classify(input: PlannerInput): Promise<PlannerDecision>;
-    probe(): Promise<PlannerProbeResult>;
-    dispose(): void;
-}

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

@@ -1,26 +0,0 @@
-import type { Tier } from '../orchestration-shell/types';
-import type { AdvisoryOptions, AdvisoryRunner } from './local-advisory';
-export interface CompositeAdvisoryRunnerOptions {
-    localRunner?: AdvisoryRunner | null;
-    hostedRunner: AdvisoryRunner;
-    tier: Tier;
-    onNotice?: (message: string) => void;
-    onFallbackToHosted?: (error: Error) => void;
-}
-/**
- * CompositeAdvisoryRunner coordinates local and hosted advisory execution:
- * - Free Tier Invariant: strictly isolates Free tier from cloud inference ($0 marginal cost).
- * - Local-First Preference: routes natural language turns / browse to local Gemma when healthy.
- * - Dynamic Failover: if local Gemma fails (Ollama down, crash, OOM), seamlessly falls back
- *   to hosted Bedrock Gemma for Pro/Max users without interrupting the session.
- */
-export declare class CompositeAdvisoryRunner implements AdvisoryRunner {
-    private readonly opts;
-    private localHealthy;
-    constructor(opts: CompositeAdvisoryRunnerOptions);
-    get runtimeLabel(): string;
-    get providerKind(): 'local' | 'hosted';
-    generateAdvisory(promptText: string, options?: AdvisoryOptions): Promise<string>;
-    warm(): Promise<boolean>;
-    unload(): Promise<boolean>;
-}

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

@@ -1,40 +0,0 @@
-import type { AdvisoryOptions, AdvisoryRunner } from './local-advisory';
-import type { PlannerCryptoBridge, SessionKeyResolver } from './client';
-export interface HostedAdvisoryTransport {
-    generatePlannerAdvisory(input: {
-        sessionId: string;
-        prompt: string;
-        images?: string[];
-        maxTokens?: number;
-        temperature?: number;
-    }): Promise<{
-        advisoryText: string;
-        serverLatencyMs: number;
-        providerUsed: string;
-    }>;
-}
-export interface HostedGemmaAdvisoryRunnerDeps {
-    transport: HostedAdvisoryTransport;
-    crypto: PlannerCryptoBridge;
-    sessionKeyResolver: SessionKeyResolver;
-    activeSessionIdHolder: {
-        value: string | null;
-    };
-}
-/**
- * HostedGemmaAdvisoryRunner executes advisory text generation (browse synthesis,
- * brainstorm, etc.) against Google Gemma 3 12B on AWS Bedrock via AppSync planner proxy.
- *
- * Wire payload is encrypted in transit under the session key via AES-256-GCM to
- * the planner proxy Lambda in us-east-1, and decrypted server-side for AWS Bedrock Gemma 3 12B.
- * Multimodal image attachments (options.images) are encrypted under the session key.
- */
-export declare class HostedGemmaAdvisoryRunner implements AdvisoryRunner {
-    private readonly deps;
-    readonly runtimeLabel = "Hosted Gemma (AWS Bedrock)";
-    readonly providerKind: "hosted";
-    constructor(deps: HostedGemmaAdvisoryRunnerDeps);
-    generateAdvisory(promptText: string, options?: AdvisoryOptions): Promise<string>;
-    warm(): Promise<boolean>;
-    unload(): Promise<boolean>;
-}