@quantiya/codevibe-core 2.0.88 → 2.0.90

package/dist/local-executor/binary-classifier.d.ts

@@ -0,0 +1,117 @@
+/** Random access to one immutable file. The caller owns opening and closing it. */
+export interface FileSource {
+    size: number;
+    read(position: number, length: number): Promise<Buffer>;
+}
+export type OfficeFormat = 'docx' | 'xlsx' | 'pptx';
+export type FileClass = {
+    kind: 'text';
+} | {
+    kind: 'office';
+    format: OfficeFormat;
+} | {
+    kind: 'image';
+    format: 'png' | 'jpeg' | 'gif' | 'webp' | 'heic';
+} | {
+    kind: 'pdf';
+} | {
+    kind: 'other';
+    format: 'audio' | 'video' | 'archive' | 'other_binary';
+};
+/** §10.2: per-part inflate output limit (64 MiB). */
+export declare const MAX_OFFICE_PART_BYTES: number;
+/**
+ * Per-archive cumulative inflated output limit (256 MiB) across all parts of one
+ * Office file version, bounding total memory and inflate work on multi-part archives.
+ */
+export declare const MAX_OFFICE_ARCHIVE_INFLATED_BYTES: number;
+/** Initial header scan length (8 KiB) for magic detection and initial UTF-8/NUL check. */
+export declare const HEADER_SCAN_BYTES: number;
+/** Chunk size (64 KiB) for streaming full-file strict UTF-8 and NUL verification. */
+export declare const UTF8_SCAN_CHUNK_BYTES: number;
+/**
+ * Compute standard IEEE 802.3 CRC32 of `buf` as an unsigned 32-bit integer (`0..0xffffffff`).
+ * Uses a deterministic lookup table so CRC32 verification works across all Node.js >= 22.0.0
+ * runtimes without depending on `zlib.crc32` (added in Node 22.2.0).
+ */
+export declare function computeCrc32(buf: Buffer): number;
+export interface ZipEntryMeta {
+    name: string;
+    method: number;
+    flags: number;
+    crc32: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    localHeaderOffset: number;
+}
+export interface ZipArchiveMeta {
+    cdOffset: number;
+    entries: Map<string, ZipEntryMeta>;
+}
+export type ZipInspectResult = {
+    ok: true;
+    archive: ZipArchiveMeta;
+} | {
+    ok: false;
+    reason: 'zip64' | 'part_too_large' | 'malformed';
+};
+export type ZipEntryReadResult = {
+    ok: true;
+    bytes: Buffer;
+} | {
+    ok: false;
+    reason: 'zip64' | 'part_too_large' | 'malformed';
+};
+/**
+ * Read up to `length` bytes starting at `position`, looping across short reads.
+ * Returns `null` if EOF is reached before `length` bytes or arguments are out of range.
+ * Rejections from `source.read` propagate untouched.
+ */
+export declare function readExact(source: FileSource, position: number, length: number): Promise<Buffer | null>;
+/**
+ * Validate a ZIP central-directory entry name:
+ * - non-empty and bounded length
+ * - no ASCII or C1 control characters (`\p{Cc}`), format/bidi/BOM characters (`\p{Cf}`),
+ *   or Unicode line/paragraph separators (`\p{Zl}`, `\p{Zp}`)
+ * - no backslashes (`\`) or leading `/`
+ * - no empty (`//`), `.`, or `..` path segments
+ */
+export declare function isSafeZipPartName(name: string): boolean;
+/**
+ * Parse a ZIP archive's End of Central Directory and Central Directory via random access.
+ * Refuses ZIP64 archives (`reason: 'zip64'`), oversized central directories (`reason: 'part_too_large'`),
+ * and malformed/unsafe/duplicate part names (`reason: 'malformed'`).
+ */
+export declare function inspectZipArchive(source: FileSource): Promise<ZipInspectResult>;
+/**
+ * Read and inflate one entry from a validated ZIP archive, enforcing the 64 MiB
+ * per-part bound, verifying local file header consistency, and checking CRC32 integrity.
+ */
+export declare function readZipEntryBytes(source: FileSource, archive: ZipArchiveMeta, entry: ZipEntryMeta): Promise<ZipEntryReadResult>;
+/**
+ * Find the index past the closing `>` of an XML declaration (`<!DOCTYPE ...>`,
+ * `<!ENTITY ...>`, etc.) starting at `lt` (`xml.startsWith('<!', lt)`),
+ * respecting quoted strings (`"..."`, `'...'`), nested comments (`<!-- ... -->`),
+ * nested processing instructions (`<? ... ?>`), and internal DTD subset brackets (`[ ... ]`).
+ * Returns `-1` if the declaration is unclosed.
+ */
+export declare function findXmlDeclarationEnd(xml: string, lt: number): number;
+/**
+ * Linear O(N) stripper for XML comments (`<!-- ... -->`), processing instructions (`<? ... ?>`),
+ * CDATA sections (`<![CDATA[ ... ]]>`), and DOCTYPE/declarations (`<! ... >`).
+ * Used when inspecting structural XML tags so commented-out or DTD-declared elements are ignored.
+ */
+export declare function stripXmlCommentsAndDeclarations(xml: string): string;
+/**
+ * Detect whether `[Content_Types].xml` names a WordprocessingML (`docx`),
+ * SpreadsheetML (`xlsx`), or PresentationML (`pptx`) main part.
+ * Strips XML comments and declarations first so commented-out `<Override>` elements are ignored.
+ * Returns `'ambiguous'` if multiple distinct Office main content types are present.
+ */
+export declare function detectOfficeFormatFromContentTypes(contentTypesXml: string): OfficeFormat | 'ambiguous' | null;
+/** Verify that the archive contains the structural parts required for `format`. */
+export declare function hasRequiredOfficeMainParts(entries: Map<string, ZipEntryMeta>, format: OfficeFormat): boolean;
+/**
+ * Classify `source` according to §10.1 (`text`, `office`, `image`, `pdf`, or `other`).
+ */
+export declare function classifyFile(source: FileSource): Promise<FileClass>;

package/dist/local-executor/office-extractor.d.ts

@@ -0,0 +1,61 @@
+import { type FileSource, type OfficeFormat } from './binary-classifier';
+export type { FileSource, OfficeFormat } from './binary-classifier';
+export interface OfficePartChange {
+    part: string;
+    change: 'added' | 'removed' | 'modified';
+    mark: 'text changed' | 'no text change — inspect the part';
+}
+export type OfficeExtraction = {
+    ok: true;
+    format: OfficeFormat;
+    beforeText: string | null;
+    afterText: string;
+    parts: OfficePartChange[];
+} | {
+    ok: false;
+    fallback: 'other_binary';
+    reason: 'zip64' | 'part_too_large' | 'malformed';
+};
+/**
+ * Maximum cumulative extracted text characters and element-overhead units (32 MiB)
+ * per Office archive version, preventing memory exhaustion or V8 RangeError on
+ * high-expansion shared-string or dense-element inputs.
+ */
+export declare const MAX_OFFICE_EXTRACTED_TEXT_BYTES: number;
+/**
+ * Maximum cumulative decoded XML characters (64 MiB) across all extracted XML parts
+ * of one Office archive version before text extraction runs.
+ */
+export declare const MAX_OFFICE_DECODED_XML_CHARS: number;
+/**
+ * Per-element budget charge (64 bytes) applied to structural XML elements (`<si>`, `<c>`,
+ * `<sheet>`, `<definedName>`, `<Relationship>`, `<p:sldId>`, `<w:p>`, `<a:p>`, `<w:comment>`,
+ * and inner elements buffered inside `<w:comment>`) so millions of empty tags
+ * (`<si/>`, `<c/>`, `<sheet/>`, `<a>`) cannot allocate unbounded arrays.
+ */
+export declare const ELEMENT_BUDGET_OVERHEAD = 64;
+/**
+ * Per-chunk budget charge (32 bytes) applied alongside character length whenever a
+ * text fragment is pushed into an intermediate chunk array or string accumulator,
+ * bounding V8 array/string-object overhead on millions of tiny text runs.
+ */
+export declare const CHUNK_BUDGET_OVERHEAD = 32;
+declare class TextBudget {
+    private readonly limit;
+    private used;
+    constructor(limit?: number);
+    add(chars: number): boolean;
+    get exceeded(): boolean;
+}
+/**
+ * Decode standard XML named and numeric character entities in a single linear O(N) pass
+ * without global regex replacement (`Runtime_RegExpExecMultiple`). Caches `nextSemi` so
+ * semicolons are never rescanned across multiple `&` characters, emits slices only when
+ * a valid entity is decoded (charging `CHUNK_BUDGET_OVERHEAD` per decoded entity when a
+ * budget is supplied), and leaves undecoded `&` sequences in the original contiguous
+ * string slice with zero intermediate string allocations. Doubly-escaped sequences
+ * (e.g. `&#38;lt;` or `&#x26;#65;`) are decoded once.
+ */
+export declare function decodeXmlEntities(raw: string, budget?: TextBudget): string;
+/** `before` is null for a created file. A deletion needs no extraction text beyond the `before/` original. */
+export declare function extractOfficeChange(before: FileSource | null, after: FileSource): Promise<OfficeExtraction>;

package/dist/orchestration-shell/cli.js

@@ -24263,7 +24263,13 @@ var AppSyncClient = class _AppSyncClient {
       this.assertSyncAccount(userId);
       let session2 = await this.getSession(state.sessionId);
       if (!current()) return;
-      if (this.assertSyncAccount(userId), !session2 || session2.userId !== userId || !["ACTIVE" /* ACTIVE */, "PAUSED" /* PAUSED */].includes(session2.status))
+      if (this.assertSyncAccount(userId), !session2 || session2.sessionId !== state.sessionId || session2.userId !== userId || state.syncSessionGenerationId !== void 0 && session2.sessionGenerationId !== state.syncSessionGenerationId)
+        throw new SyncEventClientError("SYNC_SESSION_UNAVAILABLE");
+      if (session2.status === "INACTIVE" /* INACTIVE */ && session2.sessionGenerationId) {
+        this.notifyRetiredSession(state.sessionId);
+        return;
+      }
+      if (!["ACTIVE" /* ACTIVE */, "PAUSED" /* PAUSED */].includes(session2.status))
         throw new SyncEventClientError("SYNC_SESSION_UNAVAILABLE");
       let retainedIds = /* @__PURE__ */ new Set();
       state.mobileInputRecoveryHeld = !1, session2.sessionGenerationId && (state.compatibilityInboundIds = retainedIds, state.syncSessionGenerationId = session2.sessionGenerationId), this.createLegacySubscription(state), !(!session2.sessionGenerationId || !current()) && (async () => {
@@ -25289,11 +25295,23 @@ var AppSyncClient = class _AppSyncClient {
         sessionId,
         lastHeartbeatAt: heartbeatAt
       });
-      return this.heartbeatTokens.get(sessionId) !== token4 || refreshed.status !== "ACTIVE" /* ACTIVE */ && (await this.updateSession({
+      if (this.heartbeatTokens.get(sessionId) !== token4 || refreshed.status !== "ACTIVE" /* ACTIVE */ && (await this.updateSession({
         sessionId,
         lastHeartbeatAt: heartbeatAt,
         status: "ACTIVE" /* ACTIVE */
-      }), this.heartbeatTokens.get(sessionId) !== token4) ? "stopped" : (logger.debug("[AppSyncClient] Heartbeat sent", { sessionId }), "confirmed");
+      }), this.heartbeatTokens.get(sessionId) !== token4))
+        return "stopped";
+      if (this.syncDisplayListeners.size > 0 && this.authenticated && this.currentUserId) {
+        let userId = this.currentUserId;
+        if (Array.from(this.syncDisplayListeners).some(
+          (entry5) => entry5.userId === userId
+        ) && !this.companionSyncStatusSnapshot(userId)) {
+          let refreshAbort = new AbortController(), refreshDeadline = setTimeout(() => refreshAbort.abort(), 4500);
+          refreshDeadline.unref?.(), this.refreshCompanionSyncDisplayOnMaintenance(userId, refreshAbort.signal).catch(() => {
+          }).finally(() => clearTimeout(refreshDeadline));
+        }
+      }
+      return logger.debug("[AppSyncClient] Heartbeat sent", { sessionId }), "confirmed";
     } catch (error) {
       return logger.warn("[AppSyncClient] Heartbeat failed", { sessionId, error }), isRetiredSessionError(error) ? "retired" : "failed";
     }
@@ -28797,22 +28815,43 @@ var LOCAL_GEMMA_ALLOWED_OUTPUT_KEYS = /* @__PURE__ */ new Set([
   // would throw "included unsupported keys" on every browse decision.
   "browseUrls",
   "browseQuery"
-]), LOCAL_GEMMA_NULLABLE_OUTPUT_KEYS = ["clarifying_question", "advisory_summary", "browseUrls", "browseQuery"];
-function buildLocalGemmaDecisionJsonSchema() {
+]), LOCAL_GEMMA_NULLABLE_OUTPUT_KEYS = ["clarifying_question", "advisory_summary", "browseUrls", "browseQuery"], LOCAL_GEMMA_DECISION_REQUIRED_KEYS = ["rationale", "clarifying_question", "advisory_summary", "browseUrls", "browseQuery", "action"], LOCAL_GEMMA_FIELD_CARRYING_ACTIONS = /* @__PURE__ */ new Set(["browse", "ask_user", "advisory_response"]);
+function decisionBranch(actions, fields) {
   return {
     type: "object",
     properties: {
       rationale: { type: "string" },
-      clarifying_question: { type: ["string", "null"] },
-      advisory_summary: { type: ["string", "null"] },
-      browseUrls: { type: ["array", "null"], items: { type: "string" } },
-      browseQuery: { type: ["string", "null"] },
-      action: { type: "string", enum: [...localGemmaAllowedActions()] }
+      clarifying_question: fields.clarifying_question,
+      advisory_summary: fields.advisory_summary,
+      browseUrls: fields.browseUrls,
+      browseQuery: fields.browseQuery,
+      action: { type: "string", enum: actions }
     },
-    required: ["rationale", "clarifying_question", "advisory_summary", "browseUrls", "browseQuery", "action"],
+    required: [...LOCAL_GEMMA_DECISION_REQUIRED_KEYS],
     additionalProperties: !1
   };
 }
+function buildLocalGemmaDecisionJsonSchema() {
+  let nul = { type: "null" }, otherActions = [...localGemmaAllowedActions()].filter((a) => !LOCAL_GEMMA_FIELD_CARRYING_ACTIONS.has(a));
+  return {
+    anyOf: [
+      decisionBranch(["browse"], {
+        clarifying_question: nul,
+        advisory_summary: nul,
+        browseUrls: { type: ["array", "null"], items: { type: "string" } },
+        browseQuery: { type: ["string", "null"] }
+      }),
+      decisionBranch(["ask_user"], { clarifying_question: { type: "string" }, advisory_summary: nul, browseUrls: nul, browseQuery: nul }),
+      decisionBranch(["advisory_response"], {
+        clarifying_question: nul,
+        advisory_summary: { type: ["string", "null"] },
+        browseUrls: nul,
+        browseQuery: nul
+      }),
+      decisionBranch(otherActions, { clarifying_question: nul, advisory_summary: nul, browseUrls: nul, browseQuery: nul })
+    ]
+  };
+}
 var LOCAL_GEMMA_DECISION_JSON_SCHEMA = buildLocalGemmaDecisionJsonSchema();
 var LOCAL_GEMMA_MAX_USER_PROMPT_CHARS = 4e3, LOCAL_GEMMA_MAX_CLARIFICATIONS = 4, LOCAL_GEMMA_MAX_CLARIFICATION_QUESTION_CHARS = 300, LOCAL_GEMMA_MAX_CLARIFICATION_ANSWER_CHARS = 900, LOCAL_GEMMA_MAX_CANONICAL_CONTEXT_CHARS = 6e3, LOCAL_GEMMA_MAX_RENDERED_PROMPT_CHARS = 24e3;
 function truncatePlannerTextPreservingEnds(text2, maxChars) {
@@ -29170,7 +29209,7 @@ function parseLocalGemmaPlannerDecision(raw) {
       throw validationError("Gemma planner browse output must not include advisory_summary or clarifying_question", obj, canDegrade);
   } else {
     let hasRealBrowseUrls = Array.isArray(obj.browseUrls) && obj.browseUrls.some(isRealHttpUrl), hasRealBrowseQuery = typeof obj.browseQuery == "string" && obj.browseQuery.trim().length > 0, userFacingPlannerText = typeof obj.advisory_summary == "string" && obj.advisory_summary.trim().length > 0 || typeof obj.clarifying_question == "string" && obj.clarifying_question.trim().length > 0, taskStartingAction = obj.action === "start_task" || obj.action === "team_decompose";
-    if ((hasRealBrowseUrls || hasRealBrowseQuery) && (userFacingPlannerText || taskStartingAction || obj.action === "refuse" || obj.action === "ask_user"))
+    if ((hasRealBrowseUrls || hasRealBrowseQuery) && (userFacingPlannerText || taskStartingAction || obj.action === "advisory_response" && hasRealBrowseQuery || obj.action === "refuse" || obj.action === "ask_user"))
       throw new PlannerOutputUnparseableError(
         "Gemma planner non-browse output must not combine browse fields with user-facing or task-starting planner output",
         { kind: "validation" }
@@ -77317,7 +77356,7 @@ function OrchestrationApp(props) {
         setLiveRuntimeKind(kind), setLiveRuntimeLabel(props.plannerLabel ?? "");
       });
   }, [props.plannerPipeline, props.plannerLabel]);
-  let [syncDisplay, setSyncDisplay] = React22.useState(null), syncDisplayRef = React22.useRef(syncDisplay), syncOwner = state.session.userId;
+  let [syncDisplay, setSyncDisplay] = React22.useState(null), [syncBootstrapSettledFor, setSyncBootstrapSettledFor] = React22.useState(null), syncDisplayRef = React22.useRef(syncDisplay), syncOwner = state.session.userId;
   React22.useEffect(() => {
     let source2 = props.companionSyncStateSource;
     if (!source2) return;
@@ -77325,16 +77364,19 @@ function OrchestrationApp(props) {
       if (!active) return;
       clearTimeout(expiry);
       let display = { userId: syncOwner, state: next };
-      syncDisplayRef.current = display, setSyncDisplay(display), next && (expiry = setTimeout(() => update(null), Math.max(0, next.validUntilEpochMs - Date.now())), expiry.unref?.());
+      syncDisplayRef.current = display, setSyncDisplay(display), next && (setSyncBootstrapSettledFor(syncOwner), expiry = setTimeout(() => update(null), Math.max(0, next.validUntilEpochMs - Date.now())), expiry.unref?.());
     };
-    update(null);
+    setSyncBootstrapSettledFor(null), update(null);
     try {
       unsubscribe = source2.subscribeCompanionSyncState(syncOwner, update);
     } catch {
+      active && setSyncBootstrapSettledFor(syncOwner);
     }
     let deadline = setTimeout(() => abort.abort(), 4500);
     return deadline.unref?.(), Promise.resolve().then(() => source2.getCompanionSyncState(abort.signal)).catch(() => {
-    }).finally(() => clearTimeout(deadline)), () => {
+    }).finally(() => {
+      clearTimeout(deadline), active && setSyncBootstrapSettledFor(syncOwner);
+    }), () => {
       active = !1, clearTimeout(expiry), clearTimeout(deadline), abort.abort(), unsubscribe?.();
     };
   }, [props.companionSyncStateSource, syncOwner]);
@@ -77613,7 +77655,7 @@ ${formatImplementorPolicy(detected, updated, props.tier)}`
       tier: props.tier,
       plannerRuntimeKind: liveRuntimeKind,
       plannerLabel: liveRuntimeLabel,
-      companionSyncBadge: props.companionSyncStateSource ? companionSyncBadge(syncDisplay?.userId === syncOwner ? syncDisplay.state : null) : null
+      companionSyncBadge: props.companionSyncStateSource && (syncDisplay?.userId === syncOwner && syncDisplay.state || syncBootstrapSettledFor === syncOwner) ? companionSyncBadge(syncDisplay?.userId === syncOwner ? syncDisplay.state : null) : null
     }),
     // CP-12 W3 §3.5 — minimal multi-track status node, mounted ONLY when a team
     // is active. Single-track / Companion sessions leave `state.team`
@@ -83897,7 +83939,7 @@ var INTENT_CLASSIFIER_JSON_SCHEMA = {
     rationale: { type: "string" }
   },
   required: ["action", "is_code_or_disk_mutation", "confidence", "requires_file_read", "rationale"]
-}, DEFAULT_INTENT_TIMEOUT_MS = 5e3, INTENT_MAX_OUTPUT_TOKENS = 256;
+}, DEFAULT_INTENT_TIMEOUT_MS = 3e4, INTENT_MAX_OUTPUT_TOKENS = 256;
 function buildIntentClassifierPrompt(prompt, clarifications) {
   return [
     "You are a strict code/workspace intent classifier for CodeVibe.",
@@ -86714,7 +86756,7 @@ async function runOrchestrationShellSession(args) {
       { teardownDeadlineExpired: !0 }
     ) : void 0,
     start: () => {
-      shellSubmissionsFenced = !0, shellSyncRecovery.stop(), fenceHostedSessionIngress(), taskOrdinalsAtEarlyRelease = store.getState().taskOrdinals.size, earlySessionWorkRelease = releaseSessionWorkBeforeRetirement();
+      shellSubmissionsFenced = !0, activeBrowseAbortController?.abort(), shellSyncRecovery.stop(), fenceHostedSessionIngress(), taskOrdinalsAtEarlyRelease = store.getState().taskOrdinals.size, earlySessionWorkRelease = releaseSessionWorkBeforeRetirement();
       let splitLocalDurableRetirement = typeof args.localExecutor?.disposeDurableSessionResources == "function", workspaceShutdown = startWorkspaceShutdownOperations({
         ...args.plannerAdapter || args.localAdvisoryRunner ? {
           clearPlannerSession: () => {
@@ -91342,6 +91384,13 @@ async function handleShellUserInput(deps) {
     } finally {
       stopClassifyRelabel?.();
     }
+    if (browseSignal?.aborted) {
+      logger.info(
+        "[orchestration-shell] Planner classify turn aborted via browseSignal; returning silently",
+        { prompt: plannerInput.prompt }
+      ), clearPendingClarificationIfPresent(store);
+      return;
+    }
     logger.info("[orchestration-shell] Planner classified input", {
       prompt: plannerInput.prompt,
       action: decision.action,
@@ -91354,8 +91403,16 @@ async function handleShellUserInput(deps) {
     if ((decision.action === "start_task" || decision.action === "browse") && args.localAdvisoryRunner && process.env.CODEVIBE_INTENT_CLASSIFIER !== "regex") {
       let gemmaIntent = await classifyPromptIntentWithGemma(
         { prompt: plannerInput.prompt, clarifications: plannerInput.clarifications },
-        args.localAdvisoryRunner
+        args.localAdvisoryRunner,
+        ...browseSignal ? [{ signal: browseSignal }] : []
       );
+      if (browseSignal?.aborted) {
+        logger.info(
+          "[orchestration-shell] Gemma intent classifier aborted via browseSignal; returning silently",
+          { prompt: plannerInput.prompt, rationale: gemmaIntent.rationale }
+        ), clearPendingClarificationIfPresent(store);
+        return;
+      }
       if (gemmaIntent.source === "model")
         gemmaEvaluatedIntent = !0, decision.action === "browse" ? gemmaIntent.is_code_or_disk_mutation && (logger.info(
           "[orchestration-shell] Gemma intent classifier: promoting browse to start_task with code/disk mutation",
@@ -91372,6 +91429,12 @@ async function handleShellUserInput(deps) {
         ), decision = {
           action: "familiarize",
           rationale: decision.rationale ? `${decision.rationale} (demoted to familiarize via Gemma intent classifier)` : gemmaIntent.rationale
+        }) : gemmaIntent.action === "browse" && !gemmaIntent.requires_file_read ? (logger.info(
+          "[orchestration-shell] Gemma intent classifier: demoting start_task to browse",
+          { prompt: plannerInput.prompt, rationale: gemmaIntent.rationale }
+        ), decision = {
+          action: "browse",
+          rationale: decision.rationale ? `${decision.rationale} (demoted to browse via Gemma intent classifier)` : gemmaIntent.rationale
         }) : (logger.info(
           "[orchestration-shell] Gemma intent classifier: demoting start_task to advisory_response",
           { prompt: plannerInput.prompt, rationale: gemmaIntent.rationale }

package/dist/orchestration-shell/gemma-intent-classifier.d.ts

@@ -20,6 +20,7 @@ export interface GemmaIntentPort {
     }>;
 }
 export declare const INTENT_CLASSIFIER_JSON_SCHEMA: Record<string, unknown>;
+export declare const DEFAULT_INTENT_TIMEOUT_MS = 30000;
 export declare function buildIntentClassifierPrompt(prompt: string, clarifications?: {
     question: string;
     answer: string;

package/dist/planner/local-gemma.d.ts

@@ -67,35 +67,44 @@ export declare class PlannerOutputUnparseableError extends Error {
     });
 }
 export declare function localGemmaAllowedActions(): ReadonlySet<PlannerDecision['action']>;
-interface LocalGemmaDecisionJsonSchema {
+type NullField = {
+    type: 'null';
+};
+type StringField = {
+    type: 'string';
+};
+type NullableStringField = {
+    type: ['string', 'null'];
+};
+type NullableUrlsField = {
+    type: ['array', 'null'];
+    items: {
+        type: 'string';
+    };
+};
+/** One per-action branch of the planner decision schema (planner parity D-15). */
+export interface LocalGemmaDecisionBranchSchema {
     type: 'object';
     properties: {
-        rationale: {
-            type: 'string';
-        };
-        clarifying_question: {
-            type: ['string', 'null'];
-        };
-        advisory_summary: {
-            type: ['string', 'null'];
-        };
-        browseUrls: {
-            type: ['array', 'null'];
-            items: {
-                type: 'string';
-            };
-        };
-        browseQuery: {
-            type: ['string', 'null'];
-        };
+        rationale: StringField;
+        clarifying_question: StringField | NullableStringField | NullField;
+        advisory_summary: NullableStringField | NullField;
+        browseUrls: NullableUrlsField | NullField;
+        browseQuery: NullableStringField | NullField;
         action: {
             type: 'string';
             enum: PlannerDecision['action'][];
         };
     };
     required: string[];
-    additionalProperties: boolean;
+    additionalProperties: false;
+}
+/** The planner decision schema: exactly one branch per action family (planner parity D-15). */
+export interface LocalGemmaDecisionJsonSchema {
+    anyOf: LocalGemmaDecisionBranchSchema[];
 }
+/** Every action the decision schema can emit, in branch order (each exactly once). */
+export declare function localGemmaDecisionSchemaActions(schema?: LocalGemmaDecisionJsonSchema): PlannerDecision['action'][];
 /**
  * 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

package/package.json

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