@quantiya/codevibe-claude-plugin 2.0.32 → 2.0.34

package/node_modules/@quantiya/codevibe-core/dist/local-model/__tests__/ollama-context-window.test.d.ts

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

package/node_modules/@quantiya/codevibe-core/dist/local-model/ollama.d.ts

@@ -21,6 +21,31 @@ export type OllamaRuntimeConfigResult = {
  * turn re-ups the window) and on the shell-start pre-warm.
  */
 export declare const OLLAMA_KEEP_ALIVE = "30m";
+/**
+ * Explicit context window for EVERY local generate (2026-09-12). Nothing set
+ * `num_ctx` before, so the shared model server ran at Ollama's 4,096-token
+ * default while the classify prompt alone was ~3,000 tokens: a wider session
+ * projection, a fetched page or a longer answer would have overflowed, and
+ * Ollama clips an overflowing prompt from the HEAD — silently dropping the
+ * routing rules. Measured on the dogfood machine (gemma4:12b-it-qat, Ollama
+ * 0.31.1): 16,384 → 7.4 GB resident, 100 % GPU, ~5 s load — the same footprint
+ * as 4,096 thanks to the model's sliding-window attention.
+ */
+export declare const OLLAMA_NUM_CTX = 16384;
+/**
+ * Disable the model's THINKING channel on every generate (2026-09-12, the decisive
+ * finding behind the "empty / cut-short answer" incidents). `gemma4:12b-it-qat` is a
+ * thinking model in Ollama 0.31.1: with `think` unspecified it still generates its
+ * reasoning channel, Ollama strips it from `response`, and every one of those tokens
+ * counts against `num_predict` — the dogfood article answer rendered 477 visible tokens
+ * out of 1,400 and ended mid-word with `done_reason: "length"`; an end-of-life lookup
+ * rendered NOTHING. With `think: false` the same lookup answers in 34 tokens / 8 s and
+ * the article answer completes (535 tokens, `done_reason: "stop"`, 33 s) — measured in
+ * the hot-fix packet (`browse-diag-think-r1.txt`). The classifier's forced-JSON
+ * generate is not affected either way (its token counts match its visible JSON), but
+ * it gets the same flag so every local call is explicit.
+ */
+export declare const OLLAMA_THINK = false;
 /**
  * Dogfood #618 — floor for ADVISORY generations (brainstorm/familiarize
  * fallback, up to 700–1400 output tokens on a 12B + long conversation-context
@@ -47,6 +72,16 @@ export declare const PULL_STALL_TIMEOUT_MS: number;
 export declare function isSafeOllamaModelName(model: string | null | undefined): model is string;
 export declare function parseLocalOllamaHost(raw: string | undefined): string | null;
 export declare function loadOllamaRuntimeConfigFromEnv(env?: NodeJS.ProcessEnv): OllamaRuntimeConfigResult;
+/**
+ * Ollama does not report that it clipped a prompt to the window; the only
+ * signal is a prompt evaluation that fills the window. A prompt that evaluated
+ * `num_ctx - num_predict` tokens or more was (or could have been) head-clipped,
+ * and a head-clipped classify prompt has lost its routing rules — refuse to
+ * route on it. Normal prompts are a fifth of the window, so this never fires
+ * on a healthy call; cached-prefix calls report fewer tokens and cannot fire
+ * spuriously either.
+ */
+export declare function promptFilledContextWindow(promptEvalCount: number | undefined, numPredict: number): boolean;
 /** A single streamed `/api/pull` progress record surfaced to callers. */
 export interface OllamaPullProgress {
     /** e.g. `pulling <digest>`, `downloading`, `verifying sha256 digest`, `writing manifest`, `success`. */
@@ -58,6 +93,64 @@ export interface OllamaPullProgress {
 }
 /** Progress sink for {@link requestOllamaPull}. Defaults to a no-op so existing callers/tests are unaffected. */
 export type OllamaPullProgressListener = (progress: OllamaPullProgress) => void;
+/**
+ * Consecutive streamed tokens that render NO visible text before the generation is cut
+ * off. Observed 2026-09-12 on gemma4:12b-it-qat / Ollama 0.31.1 at temperature 0: the model
+ * can fall into a loop of hidden tokens (`done_reason: "length"`, `eval_count` = the full
+ * `num_predict`, zero or few visible characters) — from the first token on an end-of-life
+ * lookup, or mid-answer after "between 2" on the dogfood article — burning 60–120 s of
+ * generation for nothing. A real answer never emits this many empty chunks in a row.
+ */
+export declare const EMPTY_TOKEN_WATCHDOG = 24;
+/**
+ * Idle guard for the same loop when the server streams NOTHING for the hidden tokens
+ * (observed on Ollama 0.31.1: no chunks at all until `done`): once visible text has
+ * started arriving, a healthy generation streams a token every few hundred ms at most,
+ * so a silence this long after the first chunk is the loop — cut off and keep the text.
+ * Not armed before the first chunk: prompt evaluation of a long prompt is legitimately
+ * silent for tens of seconds.
+ */
+export declare const STREAM_IDLE_CUTOFF_MS = 12000;
+/** Test seam — shorten the idle guard. */
+export declare function __setStreamIdleCutoffMsForTests(ms: number | null): void;
+/** Marker appended to an answer the watchdog cut short, so the reader can tell. */
+export declare const CUT_OFF_MARKER = " [\u2026]";
+/**
+ * Stage-1 r1 F6 (2026-09-12) — a conservative token ESTIMATE for prompt budgeting.
+ * Character budgets assume ~4 chars per token, which holds for English but not for
+ * CJK text (zh-TW is the owner's locale): a CJK / kana / Hangul / full-width
+ * character is counted as ONE token, everything else at 3.5 chars per token.
+ * Calibrated against `prompt_eval_count` on the real model (packet evidence
+ * `cjk-probe-r1.txt`). Over-estimating is the safe direction: a prompt that
+ * fills the window is refused, not clipped.
+ */
+export declare function estimateTokens(text: string): number;
+/** Message of the error thrown when a full `num_predict` budget rendered no visible text. */
+export declare const HIDDEN_TOKEN_LOOP_MESSAGE = "Ollama generate produced no visible text for its whole token budget (hidden-token loop)";
+export interface OllamaStreamedGeneration {
+    text: string;
+    doneReason?: string;
+    promptEvalCount?: number;
+    evalCount?: number;
+    /** Set when a watchdog cut the generation off. */
+    cutOff?: 'empty-token-loop' | 'idle';
+}
+/**
+ * STREAMED generate for the long text answerers (advisory / browse). Reads Ollama's
+ * newline-delimited chunks, concatenates `response`, and — the reason it streams —
+ * aborts the request as soon as {@link EMPTY_TOKEN_WATCHDOG} consecutive chunks carried
+ * no visible text, returning what was rendered so far (the caller decides whether an
+ * empty result is a failure). A single non-streamed JSON body (test stubs, older
+ * servers) is accepted as one final chunk. Error chunks, non-200 status, the size cap
+ * and the timeout keep the same semantics as {@link requestOllamaGenerate}.
+ */
+export declare function requestOllamaGenerateStream(config: OllamaRuntimeConfig, promptText: string, opts?: {
+    numPredict?: number;
+    formatJson?: boolean;
+    jsonSchema?: object;
+    images?: string[];
+    timeoutMs?: number;
+}): Promise<OllamaStreamedGeneration>;
 /**
  * STREAM a model pull from Ollama `/api/pull`, surfacing per-chunk download progress and
  * aborting only on a STALL (no bytes for {@link PULL_STALL_TIMEOUT_MS}) — never on a total

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

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