@quantiya/codevibe-claude-plugin 2.0.31 → 2.0.33

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

@@ -21,8 +21,23 @@ export declare const COMPACTION_KEEP_HOT_RECENT_ITEMS = 16;
  * hosted 7-day session TTL; chosen here (design leaves the number open).
  */
 export declare const CONTEXT_ITEMS_RETENTION_MS: number;
-/** The rendered session-context section's own budget (inside the F6 total). */
+/**
+ * The rendered session-context section's own budget (inside the F6 total) for
+ * the implementor dispatch block and the brainstorm panel: 2,000 chars, every
+ * line capped by `capForRender`, stop at the first line that does not fit — the
+ * shipped behaviour. The planner's classification render uses
+ * `SESSION_CONTEXT_SECTION_MAX_CHARS_CLASSIFY` below (Stage-1 r1 F5 / r2 F2,
+ * 2026-09-12).
+ */
 export declare const SESSION_CONTEXT_SECTION_MAX_CHARS = 2000;
+/**
+ * The planner's CLASSIFICATION render (2026-09-12): hot turns render WHOLE inside
+ * a 6,000-char section under the local runner's explicit 16K-token window.
+ * Stage-1 r1 F5 — this applies ONLY to `purpose: 'classification'`: the implementor
+ * dispatch block (hard 4,800-char total, `DISPATCH_CONTEXT_MAX_CHARS`) and the
+ * brainstorm panel keep the 2,000-char section and the per-line cap above.
+ */
+export declare const SESSION_CONTEXT_SECTION_MAX_CHARS_CLASSIFY = 6000;
 /**
  * A1f Stage-1 R1 HIGH + Stage-2 R1 (H1/M2/M3/M5) — one distilled FACT:
  *  - `body` — the source item's COMPLETE typed payload, verbatim (M3:
@@ -136,6 +151,13 @@ export declare function compactionCachePath(sessionId: string): string;
  * hot view). Never throws.
  */
 export declare function loadCompactionCache(sessionId: string): Promise<SessionCompactionCache>;
+/**
+ * Stage-1 r1 F4 — an ends-preserving cut for the ONE line that must survive even
+ * when it exceeds the section (the newest hot item): the head carries the referent,
+ * the tail the latest words, and the marker makes the cut visible to the model.
+ */
+export declare const RENDER_CUT_MARKER = " [\u2026] ";
+export declare function cutPreservingEnds(text: string, max: number): string;
 /**
  * Stage-2 R1 H1 — the dispatch-scope predicate, applied IDENTICALLY to hot
  * items and distilled facts (composes WITH the §5 label floor, never

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

@@ -0,0 +1,28 @@
+export type DestructiveRequestMatch = {
+    kind: 'none';
+}
+/** One named file is the whole object of the deletion. */
+ | {
+    kind: 'target';
+    target: string;
+}
+/** A deletion of several / located / unnamed files — the question quotes the request. */
+ | {
+    kind: 'neutral';
+};
+/** Classify `text` against the backstop's shapes (see the module comment). */
+export declare function matchDestructiveFileRequest(text: string): DestructiveRequestMatch;
+/**
+ * True when `text` asks to delete / remove a named file or a file/folder object.
+ * A conservative shape matcher (a backstop, not a classifier): false for edits
+ * that only mention a file or removal inside a file.
+ */
+export declare function isDestructiveFileRequest(text: string): boolean;
+/** The file the request names as the WHOLE object of the deletion, when there is exactly that. */
+export declare function destructiveRequestTarget(text: string): string | undefined;
+/**
+ * The confirmation the classifier should have asked (P43 shape: target-specific
+ * when one named file is the whole object, otherwise quoting the request), ending
+ * with the yes/no instruction the answered round relies on.
+ */
+export declare function destructiveConfirmationQuestion(text: string): string;

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

@@ -2,6 +2,22 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { AppSyncClient } from '../appsync';
 import { Session } from '../types';
 import { OrchestrationStore } from './store';
+import { type RetainedBrowsePage } from './route-browse';
+/**
+ * WEB-BROWSING-DESIGN.md rev 6 — the address for a model-chosen fetch.
+ *
+ * The classifier owns the fetch-vs-search decision: a `browse` decision WITH
+ * `browseUrls` is a fetch, one WITHOUT is a search (`browseQuery`). This helper
+ * never turns a search into a fetch (Stage-1 r1 F4: a URL that merely appears
+ * in "search for alternatives to https://x.com" stays a search). For a fetch,
+ * the user's literal URL is the address: the classify prompt is path-redacted
+ * before the model sees it, so the model's echo can be mangled
+ * (`https://[path]` in the 2026-09-11 incident) or drift. Only when the prompt
+ * carries no URL are the model's well-formed URLs used; a fetch decision whose
+ * every URL is unusable and whose prompt has none yields no URL (the route then
+ * falls back to `browseQuery` or asks for a URL).
+ */
+export declare function resolveBrowseUrls(modelUrls: string[] | undefined, prompt: string): string[] | undefined;
 import { AdvisoryAttachmentJournal } from './advisory-attachment-journal';
 import type { ImageAttachment } from './types';
 import { type GateDecisionSubmitDeps, type GroupDecisionSubmitDeps } from './gate-decision-submit';
@@ -765,6 +781,12 @@ export declare function routeAdvisory(deps: {
      * image couldn't be used instead of answering as if none was attached.
      */
     attemptedImages?: number;
+    /**
+     * 2026-09-12 — the page the `browse` route read most recently in this session.
+     * Rendered as untrusted source material the model uses ONLY when the request is
+     * about that page (the model decides relevance, the shell does not).
+     */
+    retainedPage?: RetainedBrowsePage;
 }): Promise<void>;
 export declare function parseTeamWorkItems(rawArg: string): {
     ok: true;
@@ -971,6 +993,8 @@ export declare function tokenizeCommandLine(input: string): {
     error?: string;
 };
 export declare function handleShellUserInput(deps: HandleShellUserInputDeps): Promise<void>;
+/** Test seam — clear the per-session retained pages between cases. */
+export declare function resetRetainedBrowsePagesForTests(): void;
 /**
  * [A1g] Stage-2 round-4 (Codex round-3 MEDIUM) — the EXPLICIT per-turn panel-
  * ownership token. `serializeShellSubmissions` mints ONE fresh object per

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

@@ -1,5 +1,19 @@
 import type { OrchestrationStore } from './store';
 import type { LocalGemmaAdvisoryRunner } from '../planner/local-advisory';
+/**
+ * A page the shell read this session, retained (2026-09-12) so a follow-up
+ * ("that sounds like a summary, I am looking for your thoughts") can be answered
+ * by the local model WITH the page in front of it instead of from a three-sentence
+ * summary — or a re-fetch. Text is already terminal-sanitized and bounded.
+ */
+export interface RetainedBrowsePage {
+    url: string;
+    title: string;
+    text: string;
+    readAt: string;
+}
+/** Retained page text bound — the answerer caps again at render time. */
+export declare const RETAINED_PAGE_MAX_CHARS = 24000;
 export interface RouteBrowseDeps {
     store: OrchestrationStore;
     /** Undefined when the local model isn't installed/enabled → no-model advisory. */
@@ -11,6 +25,8 @@ export interface RouteBrowseDeps {
     priorTurns?: string[];
     /** Esc-abort signal (shell-owned AbortController). */
     signal?: AbortSignal;
+    /** Called once readable text was extracted from a fetched page (before summarizing). */
+    onPageRead?: (page: RetainedBrowsePage) => void;
 }
 /**
  * Orchestrate a `browse` route. Fetch an explicit URL, or run a keyless web

package/node_modules/@quantiya/codevibe-core/dist/planner/__tests__/local-gemma-browse-regression.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@quantiya/codevibe-core/dist/planner/__tests__/local-gemma-followup-hotfix.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@quantiya/codevibe-core/dist/planner/__tests__/url-protect.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -31,38 +31,75 @@ export interface LocalGemmaPlannerRunner {
  * without inventing a successful classification or starting a task.
  */
 export declare class PlannerOutputUnparseableError extends Error {
-    constructor(message: string);
+    /**
+     * The first {@link RAW_OUTPUT_HEAD_CHARS} characters of the model output that
+     * failed to parse (terminal-control bytes stripped), attached by the adapter so
+     * the shell's warn line records WHAT the model said. Before 2026-09-11 nothing
+     * logged the raw text and the `<channel|>` echo incident needed a live repro
+     * to diagnose. Absent when the error was raised without a raw string in hand.
+     */
+    rawOutputHead?: string;
+    /**
+     * Design §7 R3 (restored 2026-09-12 after the dogfood follow-up incident):
+     * `'parse'` — the model's text never became a JSON object (prose, truncated or
+     * conflicting output); `'validation'` — a JSON object with a recognised `action`
+     * was produced but a per-action key rule or the schema rejected it. The shell
+     * fails closed on the first class and may degrade the second to the safe
+     * advisory route when {@link degradeTo} names an answer-type intent.
+     */
+    readonly kind: 'parse' | 'validation';
+    /**
+     * The rejected decision's ANSWER-TYPE intent — `advisory_response` / `brainstorm`
+     * (answered through the local advisory route) or `refuse` (rendered as the
+     * shell's deterministic refusal with this rationale) — plus whatever user-facing
+     * text it carried. NEVER set for `start_task` / `team_decompose` / `browse` (a
+     * broken decision must never start work or fetch anything), nor for `ask_user` /
+     * `familiarize` (Stage-1 r1 F2: those fail closed).
+     */
+    readonly degradeTo?: {
+        action: PlannerDecision['action'];
+        rationale?: string;
+        advisorySummary?: string;
+    };
+    constructor(message: string, options?: {
+        kind?: 'parse' | 'validation';
+        degradeTo?: PlannerOutputUnparseableError['degradeTo'];
+    });
 }
-export declare const LOCAL_GEMMA_DECISION_JSON_SCHEMA: {
-    type: string;
+export declare function localGemmaAllowedActions(isSubprocessRunner: boolean): ReadonlySet<PlannerDecision['action']>;
+interface LocalGemmaDecisionJsonSchema {
+    type: 'object';
     properties: {
         rationale: {
-            type: string;
+            type: 'string';
         };
         clarifying_question: {
-            type: string;
+            type: 'string';
         };
         advisory_summary: {
-            type: string;
+            type: 'string';
         };
         browseUrls: {
-            type: string;
+            type: 'array';
             items: {
-                type: string;
-                pattern: string;
+                type: 'string';
             };
         };
         browseQuery: {
-            type: string;
+            type: 'string';
         };
         action: {
-            type: string;
-            enum: ("start_task" | "summarize_current_status" | "advisory_response" | "ask_user" | "refuse" | "team_decompose" | "familiarize" | "brainstorm" | "browse")[];
+            type: 'string';
+            enum: PlannerDecision['action'][];
         };
     };
     required: string[];
     additionalProperties: boolean;
-};
+}
+/** The Ollama runner's schema (no `summarize_current_status`). */
+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;
 /**
  * Text-only route classifier prompt. It intentionally excludes repository
  * paths, summaries, source snippets, file bodies, and the raw structural digest.
@@ -70,7 +107,13 @@ export declare const LOCAL_GEMMA_DECISION_JSON_SCHEMA: {
 export declare function renderLocalGemmaPlannerPrompt(input: PlannerInput, options?: {
     isSubprocessRunner?: boolean;
 }): string;
-export declare function parseLocalGemmaPlannerDecision(raw: string): PlannerDecision;
+/** 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;
@@ -79,3 +122,4 @@ export declare class LocalGemmaPlannerAdapter implements PlannerAdapter {
     probe(): Promise<PlannerProbeResult>;
     setActiveSession(sessionId: string | null): void;
 }
+export {};

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

@@ -0,0 +1,20 @@
+/** Source of the shared http(s) URL matcher (no `g` state — build with {@link httpUrlPattern}). */
+export declare const HTTP_URL_PATTERN_SOURCE = "https?:\\/\\/[^\\s\"'`<>,)}\\]\u3001\u3002\u3003\u3008\u3009\u300A\u300B\u300C\u300D\u300E\u300F\u3010\u3011\u3014\u3015\u3016\u3017\u3018\u3019\u301A\u301B\u301C\u301D\u301E\u301F\uFF01-\uFF0F\uFF1A-\uFF20\uFF3B-\uFF40\uFF5B-\uFF65]+";
+/** A fresh global RegExp for {@link HTTP_URL_PATTERN_SOURCE}. */
+export declare function httpUrlPattern(): RegExp;
+/** Replace every http(s) URL with an opaque placeholder; returns the URLs in order. */
+export declare function protectUrls(text: string): {
+    text: string;
+    urls: string[];
+};
+/** Put the URLs captured by {@link protectUrls} back in place of their placeholders. */
+export declare function restoreUrls(text: string, urls: string[]): string;
+/** `http:`/`https:` and parseable by WHATWG `URL`; never a redacted `[path]` echo. */
+export declare function isWellFormedHttpUrl(candidate: string): boolean;
+/**
+ * The literal http(s) URLs a user typed, in order, de-duplicated, with trailing
+ * sentence punctuation dropped (`read https://x.com/a.` → `https://x.com/a`) and
+ * balanced parentheses kept (`…/wiki/Foo_(bar)` stays whole — F7). Pure text
+ * extraction — scheme/port/host validation stays in `guardedFetch`.
+ */
+export declare function extractHttpUrls(text: string): string[];

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

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.26",
+  "version": "2.0.28",
   "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.31",
+  "version": "2.0.33",
   "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.26",
+    "@quantiya/codevibe-core": "^2.0.28",
     "@quantiya/quorum-core": "^1.0.1",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",