@quantiya/codevibe-core 2.0.85 → 2.0.86

package/dist/orchestration-shell/cli.js

@@ -35885,14 +35885,6 @@ function attachmentsToPipelineImages(attachments) {
     read: () => readImageFdSafe(attachment.sourcePath, MAX_IMAGE_BYTES)
   }));
 }
-function isBlindImageClarification(prompt, clarifyingQuestion) {
-  if (clarifyingQuestion && clarifyingQuestion.trim().length > 0) {
-    let q = clarifyingQuestion.toLowerCase();
-    return /what .*like me to do with the (screenshot|image)/i.test(q) || /what .*want me to do with the (screenshot|image)/i.test(q) || /how should i use (that|this) information/i.test(q) || /information from the (screenshot|image)/i.test(q) || /rephrase that as a specific command or request/i.test(q) || /cannot (see|view|read|inspect) (the )?(image|screenshot)/i.test(q) || /describe what you('d| would) like me to do with (the )?(screenshot|image)/i.test(q);
-  }
-  let p = prompt.toLowerCase();
-  return /what('s| is| do you see) (in |on )?(the |this )?(screenshot|image|picture)/i.test(p) || /what does (the |this )?(screenshot|image|picture) (show|contain|depict)/i.test(p) || /what (shape|color|text) is (in |on )?(this |the )?(image|screenshot)/i.test(p);
-}
 
 // src/orchestration-shell/slash-suggest.ts
 function isSlashCommandInProgress(value) {
@@ -67590,34 +67582,6 @@ function isWebAccessNeeded(text2) {
     text2
   ));
 }
-function hasFileMutationIntent(text2) {
-  if (!text2 || typeof text2 != "string") return !1;
-  let stripped = stripLeadingAgentControlToken(text2).trim(), textWithoutUrls = stripped.replace(/https?:\/\/[^\s]+/gi, " ").trim();
-  if (/\b(?:how\s+(?:to|do\s+I|can\s+I)|explain\s+how\s+to|tell\s+me\s+how\s+to)\b/i.test(stripped) || /(?:^|[.?!;])\s*(?:what\s+(?:is|are)\b|c[oó]mo\s+(?:hacer|puedo|se\s+puede|escribir|guardar|crear)|comment\s+(?:faire|écrire|sauvegarder|créer|enregistrer)|wie\s+(?:kann\s+ich|macht\s+man|schreibt\s+man|speichert\s+man|erstellt\s+man))\b/i.test(stripped) || /(?:如何|怎么|怎样|告诉我(?:如何|怎么|怎样)|解释如何|请问|什么是)/.test(stripped) || /(?:どうやって|方法(?:を(?:教えて|説明して))|やり方を教えて|でしょうか|とは(?:何|なん)ですか)/.test(stripped) || /(?:어떻게|방법을?\s*(?:알려줘|설명해줘)|법\s*설명|하는지\s*알려줘)/.test(stripped))
-    return !1;
-  if (/>{1,2}\s*[\w./-]+\b/.test(textWithoutUrls))
-    return !0;
-  let fileExt = "(?:md|markdown|txt|json|csv|ts|js|tsx|jsx|py|html|css|yaml|yml|log|sh|xml|toml|sql|env)", writeToFilePatternEn = new RegExp(
-    `\\b(?:write|save|create|dump|output|put|export|store|record|guardar|escribir|crear|enregistrer|\xE9crire|cr\xE9er|sauvegarder|speichern|schreiben|erstellen)\\b[\\s\\S]*?\\b(?:into|to|in|as|en|dans|auf|zu)\\b(?!\\s+(?:chat|console|stdout|screen|terminal)\\b)[\\s\\S]*?(?:(?:a|an|the|un|une|ein|eine|el|la)?\\s*file(?:\\s+named|\\s+called)?\\s+)?[\\w./-]+\\.${fileExt}\\b`,
-    "i"
-  ), writeToFilePatternGermanic = new RegExp(
-    `\\b(?:in|auf|zu|into|to)\\s+[\\w./-]+\\.${fileExt}[\\s\\S]*?\\b(?:speichern|schreiben|erstellen|ablegen)\\b`,
-    "i"
-  ), namedFilePatternEn = /\b(?:into|to|in|en|dans|auf|zu)\s+(?:a|an|un|une|ein|eine|el|la)?\s*file(?:\s+(?:named|called))?\s+[\w./-]+\b/i, createFilePatternEn = /\b(?:create|add|touch)\s+(?:a|an|the)?\s*(?:new\s+)?(?:file|markdown\s+file|script)\b/i, directFileVerbPatternEn = new RegExp(
-    `\\b(?:create|write|touch|add|crear|escribir|cr\xE9er|\xE9crire|erstellen)\\s+[\\w./-]+\\.${fileExt}\\b`,
-    "i"
-  ), writeToFilePatternZh = new RegExp(
-    `(?:\u5199\u5165|\u4FDD\u5B58\u5230?|\u521B\u5EFA|\u751F\u6210|\u8F93\u51FA\u5230|\u5B58\u5165|\u5BFC\u51FA\u5230?|\u8BB0\u5F55\u5230?)[\\s\\S]*?[\\w./-]+\\.${fileExt}\\b`,
-    "i"
-  ), writeToFilePatternJa = new RegExp(
-    `(?:[\\w./-]+\\.${fileExt}[\\s\\S]*?(?:\u306B|\u3078)?\\s*(?:\u66F8\u304D\u51FA|\u4FDD\u5B58|\u4F5C\u6210|\u751F\u6210|\u51FA\u529B|\u8A18\u9332|\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8)|(?:\u66F8\u304D\u51FA|\u4FDD\u5B58|\u4F5C\u6210|\u751F\u6210|\u51FA\u529B|\u8A18\u9332|\u30A8\u30AF\u30B9\u30DD\u30FC\u30C8)[\\s\\S]*?[\\w./-]+\\.${fileExt})`,
-    "i"
-  ), writeToFilePatternKo = new RegExp(
-    `(?:[\\w./-]+\\.${fileExt}[\\s\\S]*?(?:\uC5D0|\uC73C\uB85C|\uB85C)?\\s*(?:\uC800\uC7A5|\uC791\uC131|\uC0DD\uC131|\uAE30\uB85D|\uCD9C\uB825|\uB0B4\uBCF4\uB0B4\uAE30)|(?:\uC800\uC7A5|\uC791\uC131|\uC0DD\uC131|\uAE30\uB85D|\uCD9C\uB825|\uB0B4\uBCF4\uB0B4\uAE30)[\\s\\S]*?[\\w./-]+\\.${fileExt})`,
-    "i"
-  );
-  return writeToFilePatternEn.test(textWithoutUrls) || writeToFilePatternGermanic.test(textWithoutUrls) || namedFilePatternEn.test(textWithoutUrls) || createFilePatternEn.test(textWithoutUrls) || directFileVerbPatternEn.test(textWithoutUrls) || writeToFilePatternZh.test(textWithoutUrls) || writeToFilePatternJa.test(textWithoutUrls) || writeToFilePatternKo.test(textWithoutUrls);
-}
 
 // src/orchestration-shell/quorum-loop.ts
 var CONTINUATION_EXPIRES_TTL_MS = 1440 * 60 * 1e3, ACTIVE_AGENT_KINDS = ["CLAUDE", "CODEX", "ANTIGRAVITY"], TEAM_RECOVERY_RELAUNCH_CONCURRENCY = 3;
@@ -83856,6 +83820,155 @@ var DEFAULT_REFRESH_MS = 300 * 1e3, MAX_RESOLUTION_TICK_ATTEMPTS = 12, TERMINAL_
   }
 };
 
+// src/orchestration-shell/gemma-intent-classifier.ts
+var INTENT_CLASSIFIER_JSON_SCHEMA = {
+  type: "object",
+  properties: {
+    action: {
+      type: "string",
+      enum: ["start_task", "familiarize", "advisory_response", "browse", "brainstorm", "ask_user"]
+    },
+    is_code_or_disk_mutation: { type: "boolean" },
+    confidence: { type: "string", enum: ["high", "low"] },
+    requires_file_read: { type: "boolean" },
+    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;
+function buildIntentClassifierPrompt(prompt, clarifications) {
+  return [
+    "You are a strict code/workspace intent classifier for CodeVibe.",
+    "Analyze the user prompt and clarifications to determine whether the user is requesting a code or filesystem mutation, or an informational/read-only turn.",
+    "Output STRICT JSON ONLY matching this schema:",
+    '{"action": "start_task"|"familiarize"|"advisory_response"|"browse"|"brainstorm"|"ask_user", "is_code_or_disk_mutation": boolean, "confidence": "high"|"low", "requires_file_read": boolean, "rationale": "short explanation"}',
+    "",
+    "Rules:",
+    '1. "is_code_or_disk_mutation": true if the user asks to create, modify, edit, delete, write, record, note, save, append, refactor, implement, or run code/tests/files on disk (e.g. "fix auth.ts", "delete temp.js", "create a React component", "run the test suite", "update the config file"). CRITICAL: writing, noting, recording, or saving data into any file (e.g. "note X in file.csv", "write X into file.txt", "record X in file.json") IS a disk mutation ("is_code_or_disk_mutation": true, "action": "start_task"). CRITICAL: adding comments to code or commenting helpers/functions in source files (e.g. "comment the helpers in auth.ts", "prepend a comment to auth.ts", "comment out the unused helpers") IS a code modification ("is_code_or_disk_mutation": true, "action": "start_task"), whereas providing commentary or feedback about code in chat (e.g. "comment on the logic in auth.ts", "comment on the error handling") is read-only ("is_code_or_disk_mutation": false, "action": "advisory_response").',
+    '2. "is_code_or_disk_mutation": false for read-only understanding, file inspection, or informational questions (e.g. "What files are here?", "Summarize numbers in statement.pdf", "Explain how auth works", "Organize them by category in your response", "Explain what happens when I press tab and enter", "Read auth.ts and explain why we can populate the values in output.json"). Questions asking to explain why tests fail, analyze crashes, explain system behavior after a change, or explain why an action/step is taken (e.g. "Explain why we update config.json", "Explain why we read notice.pdf and redact the amounts", "Explain why we inspect auth.ts and note findings into report.md"), or asking to paste example commands in a chat reply, are explanatory inquiries ("is_code_or_disk_mutation": false, "action": "advisory_response") when no explicit disk edit is commanded.',
+    "3. Action routing:",
+    '   - "familiarize": Read-only overview or exploration of the project, folder, files, or workspace structure without file modification.',
+    '   - "advisory_response": General questions, capability queries, or reading/summarizing/explaining specific files without disk mutation.',
+    '   - "start_task": Direct request to modify code, edit files, fix bugs, implement features, or run commands on disk.',
+    '   - "browse": Web browsing or search without disk mutation.',
+    '   - "brainstorm": Exploring architecture choices or design options.',
+    '4. "requires_file_read": true if answering the prompt requires reading or inspecting specific file(s) or document(s) in the workspace (e.g. "Tell me the wage amount from w2_2024_employer.txt", "Summarize statement.pdf", "Inspect auth.ts", "w2_2024_employer.txt"). false for general conceptual questions, project structure/familiarize, or questions not referencing specific workspace files.',
+    '5. Conversational keypresses (e.g. "press enter", "hit tab") and data attributes (e.g. "comment text", "table columns") are NOT code or file mutations.',
+    '6. If the request is ambiguous, self-contradictory, contains mixed read and write instructions, or you are uncertain, set "confidence": "low", "is_code_or_disk_mutation": true, and "action": "start_task".',
+    "",
+    clarifications && clarifications.length > 0 ? [
+      "Prior clarifications in this turn:",
+      ...clarifications.map((c, i) => `Q${i + 1}: ${c.question}
+A${i + 1}: ${c.answer}`),
+      ""
+    ].join(`
+`) : "",
+    "=== BEGIN USER PROMPT ===",
+    prompt,
+    "=== END USER PROMPT ==="
+  ].join(`
+`);
+}
+function parseIntentGemmaResponse(raw) {
+  try {
+    let parsed = JSON.parse(raw.trim());
+    return typeof parsed != "object" || parsed === null || typeof parsed.is_code_or_disk_mutation != "boolean" || !["start_task", "familiarize", "advisory_response", "browse", "brainstorm", "ask_user"].includes(
+      parsed.action
+    ) || parsed.confidence !== "high" && parsed.confidence !== "low" || typeof parsed.rationale != "string" || parsed.rationale.trim().length === 0 || parsed.action === "start_task" && !parsed.is_code_or_disk_mutation || parsed.action !== "start_task" && parsed.is_code_or_disk_mutation || typeof parsed.requires_file_read != "boolean" ? null : {
+      action: parsed.action,
+      is_code_or_disk_mutation: !!parsed.is_code_or_disk_mutation,
+      confidence: parsed.confidence,
+      rationale: parsed.rationale.trim(),
+      source: "model",
+      requires_file_read: parsed.requires_file_read
+    };
+  } catch {
+    return null;
+  }
+}
+function failClosedDefault(rationale, source2 = "semantic_fail_closed") {
+  return {
+    action: "start_task",
+    is_code_or_disk_mutation: !0,
+    confidence: "low",
+    rationale,
+    source: source2,
+    requires_file_read: !1
+  };
+}
+function isInfrastructureTransportOutage(err) {
+  if (!err || err instanceof GemmaPolicyError || err instanceof GemmaContextFullError || err instanceof GemmaEmptyOutputError || err instanceof GemmaHiddenTokenLoopError || err instanceof GemmaBackendTooOldError || err?.name === "GemmaPolicyError" || err?.name === "GemmaContextFullError" || err?.name === "GemmaEmptyOutputError" || err?.name === "GemmaHiddenTokenLoopError" || err?.name === "GemmaBackendTooOldError" || err?.name === "AssertionError" || err?.constructor?.name === "AssertionError")
+    return !1;
+  let errMessage = String(err?.message || ""), causeObj = err?.cause, causeMessage = String(causeObj?.message || "");
+  if (/\b(?:has no classify|no classify)\b/i.test(errMessage) || /\b(?:has no classify|no classify)\b/i.test(causeMessage))
+    return !1;
+  let e = err, cause = e.cause || void 0, causeCode = String(cause?.code || ""), causeName = String(cause?.name || ""), nestedCause = cause?.cause || void 0, nestedCauseCode = String(nestedCause?.code || ""), nestedCauseName = String(nestedCause?.name || ""), deepCause = nestedCause?.cause || void 0, deepCauseCode = String(deepCause?.code || "");
+  if (causeName === "AssertionError" || nestedCauseName === "AssertionError" || cause instanceof ReferenceError || cause instanceof RangeError || cause instanceof SyntaxError || nestedCause instanceof ReferenceError || nestedCause instanceof RangeError || nestedCause instanceof SyntaxError || causeName === "ReferenceError" || causeName === "RangeError" || causeName === "SyntaxError" || nestedCauseName === "ReferenceError" || nestedCauseName === "RangeError" || nestedCauseName === "SyntaxError")
+    return !1;
+  let networkCodes = [
+    "ECONNREFUSED",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EHOSTUNREACH",
+    "ENETUNREACH",
+    "ECONNRESET",
+    "EPIPE",
+    "ETIMEDOUT",
+    "UND_ERR_CONNECT_TIMEOUT",
+    "UND_ERR_SOCKET",
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_DESTROYED",
+    "UND_ERR_CLOSED"
+  ];
+  if (networkCodes.includes(causeCode) || networkCodes.includes(nestedCauseCode) || networkCodes.includes(deepCauseCode))
+    return !0;
+  if (err instanceof GemmaTransportError || err?.name === "GemmaTransportError")
+    return cause instanceof TypeError || causeName === "TypeError" || nestedCause instanceof TypeError || nestedCauseName === "TypeError" ? !!(networkCodes.includes(nestedCauseCode) || networkCodes.includes(causeCode) || networkCodes.includes(deepCauseCode)) : !0;
+  if (err instanceof TypeError || err?.name === "TypeError") {
+    let causeMsg = String(cause?.message || ""), parentMsg = String(e.message || "");
+    return !!(/\b(?:fetch failed)\b/i.test(parentMsg) && (/\b(?:connect ECONNREFUSED|ENOTFOUND|EAI_AGAIN|network|socket|timed?\s*out|und_err)\b/i.test(causeMsg) || /\b(?:connect ECONNREFUSED|ENOTFOUND|EAI_AGAIN|network|socket|und_err)\b/i.test(parentMsg)));
+  }
+  if (err instanceof ReferenceError || err instanceof RangeError || err instanceof SyntaxError || err?.name === "ReferenceError" || err?.name === "RangeError" || err?.name === "SyntaxError")
+    return !1;
+  if (err instanceof GemmaAbortError || err?.name === "AbortError")
+    return !0;
+  let name = String(e.name || ""), msg = String(e.message || ""), code = String(e.code || "");
+  return !!(name === "TimeoutError" || name === "AbortError" || code === "ETIMEDOUT" || code === "UND_ERR_CONNECT_TIMEOUT" || code === "UND_ERR_SOCKET" || code === "UND_ERR_HEADERS_TIMEOUT" || code === "UND_ERR_BODY_TIMEOUT" || code === "UND_ERR_DESTROYED" || code === "UND_ERR_CLOSED" || /\b(?:timed?\s*out|caller_aborted)\b/i.test(msg) || networkCodes.includes(code) || /\b(?:fetch failed|socket hang up|connection refused|network error|dns lookup failed|cannot reach|und_err_socket|und_err_connect_timeout)\b/i.test(
+    msg
+  ));
+}
+async function classifyPromptIntentWithGemma(input, port, opts) {
+  if (!input || !input.prompt || input.prompt.trim().length === 0)
+    return failClosedDefault("empty_prompt", "semantic_fail_closed");
+  if (opts?.signal?.aborted)
+    return failClosedDefault("caller_aborted", "infrastructure_outage");
+  let timeoutMs = opts?.timeoutMs ?? DEFAULT_INTENT_TIMEOUT_MS, controller = new AbortController(), timer, callerAbortHandler, failurePromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`Gemma intent classification timed out after ${timeoutMs}ms`)), controller.abort();
+    }, timeoutMs), opts?.signal && (callerAbortHandler = () => {
+      reject(new Error("caller_aborted")), controller.abort();
+    }, opts.signal.addEventListener("abort", callerAbortHandler, { once: !0 }));
+  });
+  try {
+    let prompt = buildIntentClassifierPrompt(input.prompt, input.clarifications), classifyPromise = port.classify({
+      prompt,
+      jsonSchema: INTENT_CLASSIFIER_JSON_SCHEMA,
+      maxOutputTokens: INTENT_MAX_OUTPUT_TOKENS,
+      signal: controller.signal,
+      timeoutMs
+    });
+    classifyPromise.catch(() => {
+    });
+    let res = await Promise.race([classifyPromise, failurePromise]), parsed = parseIntentGemmaResponse(res.text);
+    return parsed ? parsed.confidence === "low" ? failClosedDefault("low_confidence_intent", "semantic_fail_closed") : parsed : failClosedDefault("unparseable_gemma_intent_response", "semantic_fail_closed");
+  } catch (err) {
+    let msg = err?.message || "unknown";
+    return err instanceof GemmaPolicyError || err instanceof GemmaContextFullError || err instanceof GemmaEmptyOutputError || err instanceof GemmaHiddenTokenLoopError || err instanceof GemmaBackendTooOldError || err?.name === "GemmaPolicyError" || err?.name === "GemmaContextFullError" || err?.name === "GemmaEmptyOutputError" || err?.name === "GemmaHiddenTokenLoopError" || err?.name === "GemmaBackendTooOldError" ? failClosedDefault(`gemma_policy_or_capacity_error: ${msg}`, "semantic_fail_closed") : isInfrastructureTransportOutage(err) ? failClosedDefault(`gemma_transport_outage: ${msg}`, "infrastructure_outage") : failClosedDefault(`gemma_intent_error: ${msg}`, "semantic_fail_closed");
+  } finally {
+    timer && clearTimeout(timer), opts?.signal && callerAbortHandler && opts.signal.removeEventListener("abort", callerAbortHandler);
+  }
+}
+
 // src/orchestration-shell/brainstorm-quorum.ts
 var BRAINSTORM_PANEL_MIN_TIER = "MAX";
 function resolveBrainstormPanel(input) {
@@ -89197,7 +89310,7 @@ async function redelegateRepoStateReadQuietly(deps) {
   if (!repoStateRedelegationsInFlight.has(workspaceId)) {
     repoStateRedelegationsInFlight.add(workspaceId);
     try {
-      let workingDir = args.quorumLoop.getWorkingDir(), detected = typeof args.quorumLoop.getDetectedAgents == "function" ? args.quorumLoop.getDetectedAgents() : [], { agent } = selectImplementorAgent(detected), brief = renderFamiliarizeAgentBrief(
+      let workingDir = args.quorumLoop.getWorkingDir(), detected = typeof args.quorumLoop.getDetectedAgents == "function" ? args.quorumLoop.getDetectedAgents() : [], pref = readImplementorPreferenceSync(), { agent } = selectImplementorAgent(detected, null, [], pref.priorityOrder), brief = renderFamiliarizeAgentBrief(
         "The repository HEAD moved since the last codebase overview. Re-read the codebase and produce an updated structural overview."
       ), baseIntent = agentMentionIntentFromOverride(agent), intent = baseIntent ? { ...baseIntent, promptForPlanning: brief } : {
         target: "CLAUDE",
@@ -89277,7 +89390,7 @@ async function routeFamiliarize(deps) {
   let state = store.getState(), frontierAvailable = !!(args.localExecutor && args.quorumLoop);
   if (state.structuralSummary && frontierAvailable)
     try {
-      let workingDir = args.quorumLoop.getWorkingDir(), detected = typeof args.quorumLoop.getDetectedAgents == "function" ? args.quorumLoop.getDetectedAgents() : [], { agent } = selectImplementorAgent(detected), brief = renderFamiliarizeAgentBrief(deps.userPrompt), baseIntent = agentMentionIntentFromOverride(agent), intent = baseIntent ? { ...baseIntent, promptForPlanning: brief } : {
+      let workingDir = args.quorumLoop.getWorkingDir(), detected = typeof args.quorumLoop.getDetectedAgents == "function" ? args.quorumLoop.getDetectedAgents() : [], pref = readImplementorPreferenceSync(), { agent } = selectImplementorAgent(detected, null, [], pref.priorityOrder), brief = renderFamiliarizeAgentBrief(deps.userPrompt), baseIntent = agentMentionIntentFromOverride(agent), intent = baseIntent ? { ...baseIntent, promptForPlanning: brief } : {
         target: "CLAUDE",
         rawMention: "@claude",
         isLeadingControlToken: !0,
@@ -89373,6 +89486,61 @@ function renderFamiliarizeAgentBrief(userPrompt) {
   ].join(`
 `);
 }
+async function routeDocumentInspectionAdvisory(deps) {
+  let { store, args, userPrompt } = deps;
+  if (!args.localExecutor || !args.quorumLoop)
+    return store.dispatch({
+      type: "SHELL_ADVISORY",
+      source: "shell",
+      text: "A read-capable model is required to inspect and summarize documents in this workspace. No task was started and no files were modified."
+    }), !1;
+  let workingDir = args.quorumLoop.getWorkingDir(), detected = typeof args.quorumLoop.getDetectedAgents == "function" ? args.quorumLoop.getDetectedAgents() : [], pref = readImplementorPreferenceSync(), { agent } = selectImplementorAgent(detected, null, [], pref.priorityOrder), baseIntent = agentMentionIntentFromOverride(agent), intent = baseIntent ? { ...baseIntent, promptForPlanning: userPrompt } : {
+    target: "CLAUDE",
+    rawMention: "@claude",
+    isLeadingControlToken: !1,
+    promptForPlanning: userPrompt,
+    tokenStartUtf16: 0,
+    tokenEndUtf16: 0
+  }, showSpinner = store.getState().progress === null;
+  showSpinner && deps.onProgress?.({
+    phase: "advisory_dispatched",
+    agents: [agentDisplayName(agent)]
+  });
+  try {
+    let result = await runReadOnlyAgentAdvisoryResult({
+      shellArgs: args,
+      agent,
+      intent,
+      advisoryBrief: userPrompt,
+      workingDir
+    });
+    if (result.ok) {
+      let output = sanitizeForTerminal(result.text);
+      return store.dispatch({
+        type: "SHELL_ADVISORY",
+        source: "shell",
+        text: output
+      }), !0;
+    } else {
+      let failureMessage = "A read-capable model is required to inspect and summarize documents in this workspace. No task was started and no files were modified.";
+      return result.usage.unavailableReason === "workspace_mutation_detected" ? failureMessage = "A workspace mutation was detected during document inspection. Please inspect the workspace." : result.usage.unavailableReason === "workspace_verification_unavailable" ? failureMessage = "Workspace integrity could not be verified following document inspection." : result.timedOut && (failureMessage = "Document inspection timed out. No task was started and no files were modified."), store.dispatch({
+        type: "SHELL_ADVISORY",
+        source: "shell",
+        text: failureMessage
+      }), !1;
+    }
+  } catch (err) {
+    return logger.warn("[orchestration-shell] document inspection advisory failed", {
+      error: err.message
+    }), store.dispatch({
+      type: "SHELL_ADVISORY",
+      source: "shell",
+      text: "Document inspection encountered an unexpected error. Please inspect the workspace."
+    }), !1;
+  } finally {
+    showSpinner && deps.onProgress?.({ phase: "waiting_user" });
+  }
+}
 async function routeBrainstorm(deps) {
   let {
     store,
@@ -91090,7 +91258,7 @@ async function handleShellUserInput(deps) {
       wallClockMsRemaining: 3e4,
       reviseAttempts: 0
     }
-  }, decision, pendingStartConfirmation, showClassifySpinner = store.getState().progress === null, classifyPipeline = args.localAdvisoryRunner, stopClassifyRelabel;
+  }, decision, pendingStartConfirmation, isDemotedDocumentInspection = !1, showClassifySpinner = store.getState().progress === null, classifyPipeline = args.localAdvisoryRunner, stopClassifyRelabel;
   showClassifySpinner && (dispatchProgress({
     phase: "planner_classifying",
     ...classifyPipeline ? { runtimeNoun: progressRuntimeNoun(classifyPipeline) } : {}
@@ -91106,20 +91274,71 @@ async function handleShellUserInput(deps) {
     } finally {
       stopClassifyRelabel?.();
     }
-    if (logger.info("[orchestration-shell] Planner classified input", {
+    logger.info("[orchestration-shell] Planner classified input", {
       prompt: plannerInput.prompt,
       action: decision.action,
       rationale: decision.rationale
-    }), decision.action === "browse" && hasFileMutationIntent(plannerInput.prompt) && (decision = {
-      action: "start_task",
-      rationale: decision.rationale ? `${decision.rationale} (promoted to start_task due to file mutation intent)` : "web request with file mutation intent"
-    }), turnAttachments.length > 0 && decision.action === "ask_user" && isBlindImageClarification(plannerInput.prompt, decision.clarifying_question) && !hasFileMutationIntent(plannerInput.prompt) && !isDestructiveFileRequest(plannerInput.prompt) && (decision = {
-      action: "advisory_response",
-      rationale: decision.rationale || "analyze and answer inquiry about the attached image"
-    }), freshRetainedPage && decision.action === "ask_user" && isPromptRelevantToPage && !hasFileMutationIntent(plannerInput.prompt) && !isDestructiveFileRequest(plannerInput.prompt) && (decision = {
-      action: "advisory_response",
-      rationale: decision.rationale || "answer inquiry using retained web page context"
-    }), decision.action === "start_task" && plannerInput.clarifications.length === 0 && isDestructiveFileRequest(plannerInput.prompt))
+    }), isDemotedDocumentInspection = !1;
+    let gemmaEvaluatedIntent = !1, allTurnTexts = [
+      plannerInput.prompt,
+      ...plannerInput.clarifications.map((c) => c.answer)
+    ];
+    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
+      );
+      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",
+          { prompt: plannerInput.prompt, rationale: gemmaIntent.rationale }
+        ), decision = {
+          action: "start_task",
+          rationale: decision.rationale ? `${decision.rationale} (promoted to start_task via Gemma intent classifier)` : gemmaIntent.rationale
+        }) : gemmaIntent.is_code_or_disk_mutation ? logger.info(
+          "[orchestration-shell] Gemma intent classifier: confirmed start_task with code/disk mutation",
+          { prompt: plannerInput.prompt, rationale: gemmaIntent.rationale }
+        ) : gemmaIntent.action === "familiarize" && !gemmaIntent.requires_file_read ? (logger.info(
+          "[orchestration-shell] Gemma intent classifier: demoting start_task to familiarize",
+          { prompt: plannerInput.prompt, rationale: gemmaIntent.rationale }
+        ), decision = {
+          action: "familiarize",
+          rationale: decision.rationale ? `${decision.rationale} (demoted to familiarize 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 }
+        ), gemmaIntent.requires_file_read && (isDemotedDocumentInspection = !0), decision = {
+          action: "advisory_response",
+          rationale: decision.rationale ? `${decision.rationale} (demoted to advisory_response via Gemma intent classifier)` : gemmaIntent.rationale,
+          advisory_summary: void 0
+        });
+      else if (gemmaIntent.source === "semantic_fail_closed")
+        gemmaEvaluatedIntent = !0, logger.warn(
+          "[orchestration-shell] Gemma intent classifier: semantic fail-closed; asking user to clarify intent",
+          { rationale: gemmaIntent.rationale }
+        ), decision = {
+          action: "ask_user",
+          rationale: gemmaIntent.rationale,
+          clarifying_question: "Could you please clarify whether you would like to inspect/read files or modify code on disk?"
+        };
+      else {
+        gemmaEvaluatedIntent = !0;
+        let outageMessage = "Model service is temporarily unavailable. CodeVibe cannot process requests without a responsive model.";
+        logger.warn(
+          "[orchestration-shell] Gemma intent classifier: infrastructure outage; halting with user outage advisory",
+          { rationale: gemmaIntent.rationale }
+        ), store.dispatch({
+          type: "PLANNER_DECISION",
+          decision: {
+            action: "advisory_response",
+            rationale: gemmaIntent.rationale,
+            advisory_summary: outageMessage
+          }
+        }), clearPendingClarificationIfPresent(store);
+        return;
+      }
+    }
+    if (decision.action === "start_task" && plannerInput.clarifications.length === 0 && isDestructiveFileRequest(plannerInput.prompt))
       logger.warn(
         "[orchestration-shell] P43 backstop: a destructive file request was classified start_task without a confirmation this turn; asking first",
         { rationale: decision.rationale }
@@ -91232,7 +91451,7 @@ async function handleShellUserInput(deps) {
   } : void 0, isImageAdvisory = decision.action === "advisory_response" && turnAttachments.length > 0, mentionIntentForLocalSuppression = mentionIntent ?? agentMentionIntentFromOverride(effectiveExplicitAgentOverride), suppressMentionLocalAnswer = shouldSuppressMentionLocalAnswer(
     mentionIntentForLocalSuppression,
     decision
-  ), contextualAdvisoryTurns = decision.action === "advisory_response" && !isImageAdvisory && !suppressMentionLocalAnswer && args.localAdvisoryRunner ? collectPriorBrainstormTurns(store.getState().conversation, dispatchText) : [], isTextAdvisory = decision.action === "advisory_response" && !isImageAdvisory && !suppressMentionLocalAnswer && !!args.localAdvisoryRunner, reducerDecision = isImageAdvisory ? { ...decision, advisory_summary: void 0, clarifying_question: void 0, rationale: "" } : isTextAdvisory ? { ...decision, advisory_summary: void 0, clarifying_question: void 0, rationale: "" } : suppressMentionLocalAnswer ? { ...decision, advisory_summary: void 0, clarifying_question: void 0, rationale: "" } : decision.action === "team_decompose" || decision.action === "familiarize" || decision.action === "brainstorm" || // WEB-BROWSING (Stage-2-r3 MED): strip any advisory_summary/clarifying_question
+  ), contextualAdvisoryTurns = decision.action === "advisory_response" && !isImageAdvisory && !suppressMentionLocalAnswer && args.localAdvisoryRunner ? collectPriorBrainstormTurns(store.getState().conversation, dispatchText) : [], isTextAdvisory = decision.action === "advisory_response" && !isImageAdvisory && !suppressMentionLocalAnswer && !!args.localAdvisoryRunner, reducerDecision = isImageAdvisory ? { ...decision, advisory_summary: void 0, clarifying_question: void 0, rationale: "" } : isTextAdvisory ? { ...decision, advisory_summary: void 0, clarifying_question: void 0, rationale: "" } : suppressMentionLocalAnswer ? { ...decision, advisory_summary: void 0, clarifying_question: void 0, rationale: "" } : isDemotedDocumentInspection ? { ...decision, advisory_summary: void 0, clarifying_question: void 0, rationale: "" } : decision.action === "team_decompose" || decision.action === "familiarize" || decision.action === "brainstorm" || // WEB-BROWSING (Stage-2-r3 MED): strip any advisory_summary/clarifying_question
   // off a `browse` so no ungrounded planner text renders before the fetched answer.
   decision.action === "browse" ? { ...decision, advisory_summary: void 0, clarifying_question: void 0 } : decision;
   if (store.dispatch({
@@ -91240,7 +91459,21 @@ async function handleShellUserInput(deps) {
     decision: reducerDecision,
     ...brainstormMetadata ? { brainstorm: brainstormMetadata } : {},
     ...pendingStartConfirmation ? { startConfirmation: pendingStartConfirmation } : {}
-  }), suppressMentionLocalAnswer && mentionIntentForLocalSuppression) {
+  }), isDemotedDocumentInspection && !suppressMentionLocalAnswer) {
+    let advisoryBrief = composeReadOnlyAdvisoryBrief(
+      pendingForPlanning,
+      plannerPromptText,
+      answeredThisTurn
+    );
+    await routeDocumentInspectionAdvisory({
+      store,
+      args,
+      userPrompt: advisoryBrief,
+      onProgress: deps.onProgress
+    });
+    return;
+  }
+  if (suppressMentionLocalAnswer && mentionIntentForLocalSuppression) {
     let carriedMentionTargets = mentionTargets.length > 0 ? mentionTargets : latestMentionTargetsFromPendingClarification(pending2, answeredThisTurn), multiDirectedCarried = carriedMentionTargets.length > 1 && !carriedMentionTargets.includes("ALL"), advisoryBrief = composeReadOnlyAdvisoryBrief(
       multiDirectedCarried ? pending2 : pendingForPlanning,
       multiDirectedCarried ? dispatchText : plannerPromptText,
@@ -97671,14 +97904,16 @@ async function triggerStartupOrphanSweep(appsyncClient, currentSessionId, staleT
       ownerRootDir: shadowEnv?.ownerRootDir ?? processOwnerRoot(),
       ...shadowEnv
     };
-    return await reapOrphanShadows(/* @__PURE__ */ new Set(), env).catch((err) => {
+    await reapOrphanShadows(/* @__PURE__ */ new Set(), env).catch((err) => {
       logger.warn("[cli] shadow orphan startup sweep error (non-fatal)", {
         err: err?.message
       });
-    }), await appsyncClient.sweepOrphanSessions({
+    });
+    let envExcludes = (process.env.CODEVIBE_SWEEP_EXCLUDE_SESSION_IDS ?? "").split(",").map((s) => s.trim()).filter(Boolean), excludeSessionIds = Array.from(/* @__PURE__ */ new Set([currentSessionId, ...envExcludes]));
+    return await appsyncClient.sweepOrphanSessions({
       agentType: "CODEVIBE" /* CODEVIBE */,
       staleThresholdMs,
-      excludeSessionIds: [currentSessionId]
+      excludeSessionIds
     });
   } catch (err) {
     return logger.warn("[cli] startup orphan sweep failed (non-fatal)", {

package/dist/orchestration-shell/command-intent.d.ts

@@ -61,6 +61,24 @@ export declare function buildCommandIntentMetadata(text: string): CommandIntentM
  * Supports language-agnostic URLs, as well as English, Chinese, and Japanese web search intents.
  */
 export declare function isWebAccessNeeded(text: string): boolean;
+/**
+ * Common file and document extensions for code, documentation, scripts, data, and office files.
+ */
+export declare const DOCUMENT_AND_CODE_EXTENSIONS = "(?:pdf|docx|doc|xlsx|xls|csv|tsv|txt|md|markdown|json|yaml|yml|toml|env|log|ts|js|tsx|jsx|py|rs|go|java|c|cpp|h|html|css|sql|sh)";
+/**
+ * Strips negated mutation verb phrases (e.g. "do not fix ...", "don't modify ...",
+ * "without changing any code", "不做修改", "修正しないで", "수정하지 말고", "do not write report.md")
+ * from text so that negative constraints do not trigger mutation action verbs,
+ * while preserving any independent affirmative mutation instructions in the same clause.
+ */
+export declare function stripNegatedMutationSpans(text: string): string;
+/**
+ * Helper to recognize source content references that describe entities or topics inside a file or database
+ * (e.g. "generate a list of the fields in config.json", "generate a summary of the functions in README.md",
+ * "generate a summary of the error handling in auth.ts", "output a list of the functions in auth.sh")
+ * rather than write destinations.
+ */
+export declare function isGenerateSourceContentRef(target: string, hasWebContext?: boolean): boolean;
 /**
  * Detects whether a prompt expresses intent to create, write, save, or modify local files/reports,
  * as opposed to a purely read-only conversational request.

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

@@ -0,0 +1,48 @@
+export type PromptIntentAction = 'start_task' | 'familiarize' | 'advisory_response' | 'browse' | 'brainstorm' | 'ask_user';
+export type PromptIntentSource = 'model' | 'semantic_fail_closed' | 'infrastructure_outage';
+export interface PromptIntentClassification {
+    action: PromptIntentAction;
+    is_code_or_disk_mutation: boolean;
+    confidence: 'high' | 'low';
+    rationale: string;
+    source: PromptIntentSource;
+    requires_file_read?: boolean;
+}
+export interface GemmaIntentPort {
+    classify(req: {
+        prompt: string;
+        jsonSchema?: Record<string, unknown>;
+        maxOutputTokens: number;
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<{
+        text: string;
+    }>;
+}
+export declare const INTENT_CLASSIFIER_JSON_SCHEMA: Record<string, unknown>;
+export declare function buildIntentClassifierPrompt(prompt: string, clarifications?: {
+    question: string;
+    answer: string;
+}[]): string;
+export declare function parseIntentGemmaResponse(raw: string): PromptIntentClassification | null;
+/**
+ * Detect whether an error represents a genuine infrastructure transport/network/timeout outage
+ * rather than a model semantic, contract, capability, or internal programming error.
+ * Only genuine infrastructure outages permit falling back to secondary regex heuristics (Codex R50-F4, Claude NB2).
+ */
+export declare function isInfrastructureTransportOutage(err: unknown): boolean;
+/**
+ * Classify a user turn using Gemma with structured JSON.
+ * Returns `PromptIntentClassification`.
+ * Always fails closed to `start_task` on any error or ambiguity.
+ */
+export declare function classifyPromptIntentWithGemma(input: {
+    prompt: string;
+    clarifications?: {
+        question: string;
+        answer: string;
+    }[];
+}, port: GemmaIntentPort, opts?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<PromptIntentClassification>;

package/dist/orchestration-shell/index.d.ts

@@ -343,7 +343,7 @@ export { reducer } from './reducer';
 export { createOrchestrationStore, type OrchestrationStore } from './store';
 export { routeBrowse, RETAINED_PAGE_MAX_CHARS, type RouteBrowseDeps, type RetainedBrowsePage, } from './route-browse';
 export { composeBrainstormPanelBrief, fitTextToBudget, MAX_BRAINSTORM_PAGE_CHARS, MAX_BRAINSTORM_PAGE_TOKENS, MAX_BRAINSTORM_PAGE_BYTES, } from './brainstorm-quorum';
-export { extractQueryRelevantSnippets, isPromptRelevantToRetainedPage, htmlToText } from './web/extract';
+export { extractQueryRelevantSnippets, isPromptRelevantToRetainedPage, isBlindBrowseClarification, htmlToText } from './web/extract';
 export { validateAgyArgPrompt, AGY_ARG_PROMPT_MAX_UTF8_BYTES, } from '../agy-cli-contract';
 export type { Mode, Tier, PlannerDecision, AgentKind, PlannerHealthState, RunningTaskState, ReviewerSeatState, GateState, ExecutionEventEntry, RefusalEventEntry, BypassEventEntry, MobileEventEntry, EventStreamEntry, ConversationEntry, QueuedTask, PendingClarification, OrchestrationState, OrchestrationAction, LastModeFile, TeamState, TeamTrackEntry, TeamTrackState, TeamMergeGateStatus, LiveProgress, } from './types';
 export { formatElapsed, isSpinnerPhase, renderProgressLine, type TaskProgressEvent, type OnProgress, } from './task-progress';
@@ -925,6 +925,35 @@ export declare function routeFamiliarize(deps: {
     userPrompt?: string;
     onProgress?: (event: TaskProgressEvent) => void;
 }): Promise<void>;
+/**
+ * Routes a bare document inspection or file summarization inquiry
+ * (e.g. "Pick a file and summarize its numbers and key details", "Summarize package.json", "Summarize notice.pdf")
+ * to a read-only frontier agent in plan mode.
+ *
+ * When a frontier agent is available (`localExecutor` + `quorumLoop`):
+ * - Selects the default implementor agent from detected agents (default CLAUDE or ANTIGRAVITY).
+ * - Spawns the read-only agent via `runReadOnlyAgentAdvisoryResult` in plan mode.
+ * - The agent reads the file(s) and produces grounded document facts.
+ * - Dispatches the sanitized text to `store` as `SHELL_ADVISORY`.
+ * - NEVER calls `writeRepoState` and NEVER creates a task or shadow workspace.
+ *
+ * When no frontier agent is wired or invocation fails:
+ * - Fails closed with an explicit user-facing message explaining that a read-capable model is required.
+ * - NEVER displays internal classifier rationale as the user's answer.
+ */
+/**
+ * Parses numbered or disjunctive alternatives from a clarifying question string.
+ * Supports:
+ * - Numbered lists: "1. View in chat 2. Group in chat 3. Write summary to report.md" or "1) ... 2) ..."
+ * - Disjunctive lists: "A, B, or C?" or "A or B?"
+ */
+export declare function parseNumberedOptions(question: string): string[];
+export declare function routeDocumentInspectionAdvisory(deps: {
+    store: OrchestrationStore;
+    args: RunOrchestrationShellArgs;
+    userPrompt: string;
+    onProgress?: (event: TaskProgressEvent) => void;
+}): Promise<boolean>;
 export declare function routeBrainstorm(deps: {
     store: OrchestrationStore;
     args: RunOrchestrationShellArgs;

package/dist/orchestration-shell/web/extract.d.ts

@@ -56,3 +56,9 @@ export declare function isPromptRelevantToRetainedPage(prompt: string, retainedP
     title?: string;
     text?: string;
 } | null): boolean;
+/**
+ * Detects whether a planner clarifying question is a blind deflection regarding web browsing
+ * (e.g. asking for a URL, link, or website address because the model lacks awareness of the retained page),
+ * as opposed to a genuine question about user preferences, sections, files, or instructions.
+ */
+export declare function isBlindBrowseClarification(clarifyingQuestion?: string): boolean;

package/dist/prompt-parser.d.ts

@@ -42,3 +42,14 @@ export declare function normalizeSnapshot(snapshot: string): string;
 export declare function countUnescapedBackticks(str: string): number;
 export declare function isMcpHeadingLine(line: string): boolean;
 export declare function isPromptHeadingLine(line: string): boolean;
+import { parseInteractivePromptWithGemma, type TuiGemmaPort } from './tui-parser/gemma-tui-parser';
+export { parseInteractivePromptWithGemma, type TuiGemmaPort };
+/**
+ * Asynchronously parse an interactive prompt with model-based structured JSON parsing
+ * when available, respecting the CODEVIBE_TUI_PARSER operational kill-switch.
+ */
+export declare function parseInteractivePromptAsync(snapshot: string, port?: TuiGemmaPort, opts?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    boundedOptionBlock?: boolean;
+}): Promise<ParsedInteractivePrompt | null>;

package/dist/terminal-menu.d.ts

@@ -21,3 +21,13 @@ export declare function selectTerminalMenuOption(identity: string, number: strin
  * and a separate terminal footer with key hints.
  */
 export declare function parseActiveTerminalMenu(snapshot: string): TerminalMenu | null;
+import { parseActiveTerminalMenuWithGemma, type GemmaTerminalMenu, type TuiGemmaPort } from './tui-parser/gemma-tui-parser';
+export { parseActiveTerminalMenuWithGemma, type GemmaTerminalMenu };
+/**
+ * Asynchronously parse an active terminal menu using Gemma structured JSON when available,
+ * respecting the CODEVIBE_TUI_PARSER operational kill-switch.
+ */
+export declare function parseActiveTerminalMenuAsync(snapshot: string, port?: TuiGemmaPort, opts?: {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<TerminalMenu | null>;