@quantiya/codevibe-core 2.0.84 → 2.0.86

package/dist/local-executor/shadow-recovery.d.ts

@@ -84,7 +84,7 @@ interface ShadowMarkerScan {
         detail: string;
     }>;
 }
-export declare function scanShadowMarkers(env?: ShadowEnv): Promise<ShadowMarkerScan>;
+export declare function scanShadowMarkers(env?: ShadowEnv, ownedTaskIds?: ReadonlySet<string>): Promise<ShadowMarkerScan>;
 export declare function reconcileExposureRetentions(retentions: ShadowMarkerScan['exposureRetentions'], recovered: readonly RecoveredShadow[], physicalCopyScope: string, env: ShadowEnv, retained: string[], snapshotIncarnations: SnapshotIncarnationIndex | null): Promise<void>;
 export declare function reclaimDisplacedShadow(record: DisplacedShadowMarkerRecord, env: ShadowEnv, physicalCopyScope: string, opts: {
     allowLiveOwner: boolean;
@@ -110,7 +110,7 @@ export declare function reconcileDisplacedSnapshots(records: readonly DisplacedS
  * self-consistent pair. A v2 root of a format this desktop does not know is list-only, so it is not offered for
  * recovery at all — recovery acts on what it is given.
  */
-export declare function listRecoverableShadows(env?: ShadowEnv): Promise<RecoveredShadow[]>;
+export declare function listRecoverableShadows(env?: ShadowEnv, ownedTaskIds?: ReadonlySet<string>): Promise<RecoveredShadow[]>;
 /** `env` pinned to one root pair, so every default inside a pass resolves to that pair and nothing else. */
 export declare function pairEnv(env: ShadowEnv, pass: {
     stateRootDir: string;

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) {
@@ -46359,7 +46351,24 @@ async function readAnchoredStateMarkerSnapshotForScan(stateRootAuthority, stateD
     }
   };
 }
-async function scanShadowMarkers(env = {}) {
+function pinShadowTaskScope(ownedTaskIds) {
+  let taskScope = ownedTaskIds === void 0 ? void 0 : new Set(ownedTaskIds);
+  if (taskScope)
+    for (let taskId of taskScope) {
+      if (taskId.length === 0) throw new Error("WorkspaceShadow: empty owned task id");
+      assertSafeStateComponent(taskId);
+    }
+  return taskScope;
+}
+async function scanShadowMarkers(env = {}, ownedTaskIds) {
+  let taskScope = pinShadowTaskScope(ownedTaskIds);
+  if (taskScope?.size === 0) return {
+    recovered: [],
+    exposureRetentions: [],
+    displacedSnapshots: [],
+    protectedDirNames: /* @__PURE__ */ new Set(),
+    unresolved: []
+  };
   let helperTimeout = env.helperTimeoutMs ?? env.workspaceAuthorityHelperTimeoutMs ?? (env.signal ? 2e3 : void 0), maxStateMarkerBytes = resolveStateMarkerByteLimit(env), requestedStateRoot = env.stateRootDir ?? defaultStateRoot(), requestedShadowRoot = (await resolveShadowRoots(env)).shadowRootDir;
   if (env.signal?.aborted) return { recovered: [], exposureRetentions: [], displacedSnapshots: [], protectedDirNames: /* @__PURE__ */ new Set(), unresolved: [] };
   let stateRootAuthority = await captureWorkspaceRootAuthority(requestedStateRoot, {
@@ -46413,7 +46422,9 @@ async function scanShadowMarkers(env = {}) {
   for (let taskEntry of entries) {
     if (env.signal?.aborted) break;
     if (isStateRootInfrastructureDirectory(taskEntry.name) || !taskEntry.isDirectory() || taskEntry.isSymbolicLink()) continue;
-    let taskId = taskEntry.name, stateDir = path54.join(stateRoot, taskId), stateDirAuthority;
+    let taskId = taskEntry.name;
+    if (taskScope && !taskScope.has(taskId)) continue;
+    let stateDir = path54.join(stateRoot, taskId), stateDirAuthority;
     try {
       stateDirAuthority = await captureWorkspaceRootAuthority(stateDir, {
         helperTimeoutMs: helperTimeout,
@@ -47075,7 +47086,9 @@ async function reconcileDisplacedSnapshots(records, keepTaskIds, ttlMs, now, phy
       });
     }
 }
-async function listRecoverableShadows(env = {}) {
+async function listRecoverableShadows(env = {}, ownedTaskIds) {
+  let taskScope = pinShadowTaskScope(ownedTaskIds);
+  if (taskScope?.size === 0) return [];
   let out = [];
   for (let pass of await shadowRootPasses(env)) {
     if (!await passIsActionable(pass)) {
@@ -47084,7 +47097,7 @@ async function listRecoverableShadows(env = {}) {
       });
       continue;
     }
-    let scan = await scanShadowMarkers(pairEnv(env, pass));
+    let scan = await scanShadowMarkers(pairEnv(env, pass), taskScope);
     for (let recovered of scan.recovered)
       out.push({ ...recovered, rootPair: { stateRootDir: pass.stateRootDir, shadowRootDir: pass.shadowRootDir } });
   }
@@ -47178,16 +47191,18 @@ async function reconcileShadowPublicationAuthorityInPair(taskIds, env) {
   );
 }
 async function listShadowCleanupResidue(taskIds, env = {}) {
+  let taskScope = pinShadowTaskScope(taskIds);
+  if (taskScope.size === 0) return [];
   let residue = [];
   for (let pass of await shadowRootPasses(env))
-    residue.push(...await listShadowCleanupResidueInPair(taskIds, pairEnv(env, pass)));
+    residue.push(...await listShadowCleanupResidueInPair(taskScope, pairEnv(env, pass)));
   return residue;
 }
 async function listShadowCleanupResidueInPair(taskIds, env) {
   if (taskIds.size === 0) return [];
   for (let taskId of taskIds)
     if (taskId.length === 0 || taskId === "." || taskId === ".." || taskId.includes("\0") || path54.basename(taskId) !== taskId) throw new Error("invalid owned task id for workspace cleanup audit");
-  let scan = await scanShadowMarkers(env), residue = [], add = (record2) => {
+  let scan = await scanShadowMarkers(env, taskIds), residue = [], add = (record2) => {
     taskIds.has(record2.taskId) && (residue.some(
       (item2) => item2.taskId === record2.taskId && item2.path === record2.path && item2.kind === record2.kind
     ) || residue.push(record2));
@@ -60849,7 +60864,7 @@ var LocalExecutorImpl = class {
     try {
       [canonicalRepo, recovered, owner] = await Promise.all([
         captureWorkspaceRootAuthority(repoRoot).then((value) => value.canonicalPath),
-        listRecoverableShadows(env),
+        listRecoverableShadows(env, this.integrationTaskIdsOwned),
         currentProcessIdentity()
       ]);
     } catch (err) {
@@ -67567,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;
@@ -74246,7 +74233,8 @@ ${section}`);
    * unresolved authority are preserved, but returned as explicit failures.
    */
   async cleanupOwnedTaskSnapshots(taskIds, context) {
-    let failures = [], attemptFailures = [], env = this.deps.shadowEnv ?? {};
+    if (taskIds.size === 0) return [];
+    let failures = [], attemptFailures = [], env = this.deps.shadowEnv ?? {}, cleanupStartedAt = Date.now();
     (await Promise.allSettled([...taskIds].map(
       (taskId) => this.runExclusiveShadowOp(taskId, async () => {
         let shadow = this.shadowsByTask.get(taskId);
@@ -74258,11 +74246,11 @@ ${section}`);
         `${context} mapped workspace ${[...taskIds][index]} disposal failed`
       ));
     });
-    let canonicalWorkingDir, recovered, currentOwner;
+    let mappedSettledAt = Date.now(), canonicalWorkingDir, recovered, currentOwner;
     try {
       [canonicalWorkingDir, recovered, currentOwner] = await Promise.all([
         captureWorkspaceRootAuthority(this.deps.workingDir).then((authority) => authority.canonicalPath),
-        (this.deps.shadowRecoveryOps?.listRecoverableShadows ?? listRecoverableShadows)(env),
+        (this.deps.shadowRecoveryOps?.listRecoverableShadows ?? listRecoverableShadows)(env, taskIds),
         currentProcessIdentity()
       ]);
     } catch (err) {
@@ -74271,10 +74259,10 @@ ${section}`);
         `${context} durable workspace enumeration failed`
       )), failures.push(...attemptFailures), failures;
     }
-    let ownedRecovered = recovered.filter(
+    let enumeratedAt = Date.now(), ownedRecovered = recovered.filter(
       (item2) => item2.workingDir === canonicalWorkingDir && taskIds.has(item2.taskId)
     );
-    if ((await Promise.allSettled(ownedRecovered.map(
+    (await Promise.allSettled(ownedRecovered.map(
       (item2) => this.runExclusiveShadowOp(item2.taskId, async () => {
         if (!(item2.ownerProcessIdentity.pid === currentOwner.pid && item2.ownerProcessIdentity.incarnationId === currentOwner.incarnationId) && await isProcessIdentityAlive(item2.ownerProcessIdentity))
           throw new Error(
@@ -74295,7 +74283,9 @@ ${section}`);
           `${context} durable workspace ${item2.taskId} (${item2.stateFile}) disposal failed`
         ));
       }
-    }), !this.deps.shadowRecoveryOps)
+    });
+    let recoveredSettledAt = Date.now();
+    if (!this.deps.shadowRecoveryOps)
       try {
         await reconcileShadowPublicationAuthority(taskIds, env);
       } catch (err) {
@@ -74306,7 +74296,7 @@ ${section}`);
       }
     try {
       let remaining;
-      this.deps.shadowRecoveryOps?.listShadowCleanupResidue ? remaining = await this.deps.shadowRecoveryOps.listShadowCleanupResidue(taskIds, env) : this.deps.shadowRecoveryOps?.listRecoverableShadows ? remaining = (await this.deps.shadowRecoveryOps.listRecoverableShadows(env)).filter(
+      this.deps.shadowRecoveryOps?.listShadowCleanupResidue ? remaining = await this.deps.shadowRecoveryOps.listShadowCleanupResidue(taskIds, env) : this.deps.shadowRecoveryOps?.listRecoverableShadows ? remaining = (await this.deps.shadowRecoveryOps.listRecoverableShadows(env, taskIds)).filter(
         (item2) => item2.workingDir === canonicalWorkingDir && taskIds.has(item2.taskId)
       ).map((item2) => ({
         taskId: item2.taskId,
@@ -74330,7 +74320,15 @@ ${section}`);
         `${context} final durable workspace enumeration failed`
       )), failures.push(...attemptFailures);
     }
-    return failures;
+    return logger.debug("[QuorumLoop] owned workspace cleanup phase durations", {
+      context,
+      taskCount: taskIds.size,
+      recoveredCount: ownedRecovered.length,
+      mappedRetirementMs: mappedSettledAt - cleanupStartedAt,
+      durableEnumerationMs: enumeratedAt - mappedSettledAt,
+      recoveredRetirementMs: recoveredSettledAt - enumeratedAt,
+      publicationAndAuditMs: Date.now() - recoveredSettledAt
+    }), failures;
   }
   async disposeWorkspaces(opts = {}) {
     let strict = opts.strict ?? !0;
@@ -83822,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) {
@@ -89163,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",
@@ -89243,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,
@@ -89339,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,
@@ -91056,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) } : {}
@@ -91072,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 }
@@ -91198,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({
@@ -91206,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,
@@ -97637,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.