chainlesschain 0.166.106 → 0.166.108

package/src/harness/prompt-compressor.js

@@ -407,9 +407,9 @@ export class PromptCompressor {
     if (
       this.llmQuery &&
       (currentTokens > this.maxTokens || result.length > this.maxMessages) &&
-      result.length > 4
+      messages.length > 4
     ) {
-      const summarized = await this._summarize(result);
+      const summarized = await this._summarize(result, messages);
       result = summarized.messages;
       summaryStats = summarized.stats;
       if (summaryStats.summaryMode !== "none") {
@@ -565,7 +565,7 @@ export class PromptCompressor {
     return result;
   }
 
-  async _summarize(messages) {
+  async _summarize(messages, sourceMessages = messages) {
     // Compaction summaries and collapsed tool groups are derived history, not
     // immutable host instructions. Fold them into the next summary so a long
     // session cannot retain one additional durable system message per cycle.
@@ -573,11 +573,11 @@ export class PromptCompressor {
       (m) => m.role === "system" && !isCompactionArtifact(m),
     );
     const last = [...messages].reverse().find((m) => m.role === "user");
-    const toSummarize = messages.filter(
-      (m) => (m.role !== "system" || isCompactionArtifact(m)) && m !== last,
-    );
-
-    if (toSummarize.length < 3) {
+    if (
+      sourceMessages.filter(
+        (m) => m.role !== "system" || isCompactionArtifact(m),
+      ).length < 3
+    ) {
       return {
         messages,
         stats: {
@@ -590,7 +590,15 @@ export class PromptCompressor {
       };
     }
 
-    const prompt = summaryPrompt(toSummarize, this.summaryInputMaxChars);
+    // The pinned request remains in the output, but the summarizer also needs
+    // it to retain the objective/constraints when there is only one user turn.
+    // Pair tool observations against the original history: deduplication and
+    // collapse may already have removed empty assistant tool-call messages.
+    // The same bounded summary input budget applies to this source history.
+    const summarySources = sourceMessages.filter(
+      (m) => m.role !== "system" || isCompactionArtifact(m),
+    );
+    const prompt = summaryPrompt(summarySources, this.summaryInputMaxChars);
     let summary;
     let summaryMode = "llm-structured";
     let degraded = false;
@@ -713,7 +721,7 @@ export class PromptCompressor {
       }
     }
     if (degraded) {
-      summary = buildExtractiveHandoff(toSummarize, {
+      summary = buildExtractiveHandoff(summarySources, {
         maxFallbackSourceChars: Math.min(
           this.summaryInputMaxChars,
           SUMMARY_INPUT_DEFAULT_MAX_CHARS,

package/src/harness/structured-handoff.js

@@ -3,6 +3,7 @@
  * parent-to-child agent context. The field order is part of the wire format.
  */
 
+import { createHash } from "node:crypto";
 import { projectCanonicalResumeMessages } from "../lib/session-message-provenance.js";
 
 export const STRUCTURED_HANDOFF_FIELDS = Object.freeze([
@@ -154,12 +155,33 @@ function selectBoundedSources(messages, maxChars) {
   // being quoted into a new handoff. Only the runtime WeakMap capability is
   // admitted; ordinary user/assistant/tool conversation remains eligible.
   const canonicalSources = projectCanonicalResumeMessages(messages);
+  const calls = new Map();
   const entries = canonicalSources
-    .map((message, index) => ({
-      index,
-      role: typeof message?.role === "string" ? message.role : "unknown",
-      text: normalizeText(contentText(message)),
-    }))
+    .map((message, index) => {
+      for (const call of Array.isArray(message.tool_calls)
+        ? message.tool_calls
+        : []) {
+        if (message.role === "assistant" && call?.id && call.function)
+          calls.set(call.id, call.function);
+      }
+      const facts =
+        message.role === "tool"
+          ? toolFacts(message, calls.get(message.tool_call_id))
+          : message.role === "assistant" || message.role === "system"
+            ? summaryFacts(message)
+            : null;
+      return {
+        index,
+        role: typeof message?.role === "string" ? message.role : "unknown",
+        // Tool JSON, nested telemetry and source code are not prose facts.
+        text: facts
+          ? facts.objective || ARRAY_FIELDS.some((field) => facts[field].length)
+            ? JSON.stringify(facts)
+            : ""
+          : normalizeText(contentText(message)),
+        facts,
+      };
+    })
     .filter((entry) => entry.text);
   const firstUser = entries.find((entry) => entry.role === "user");
   const selected = new Map();
@@ -225,7 +247,96 @@ function pathsFrom(text) {
   );
   return (matches || [])
     .map((value) => value.replace(/[),;:.]+$/g, ""))
-    .filter((value) => value && !value.includes("://"));
+    .filter(
+      (value) =>
+        value &&
+        !value.includes("://") &&
+        (/^(?:[A-Za-z]:[\\/]|\.{0,2}[\\/])/u.test(value) ||
+          /(?:\.[A-Za-z0-9_-]+|[\\/](?:Dockerfile|Makefile|LICENSE|NOTICE))$/u.test(
+            value,
+          )),
+    );
+}
+
+function summaryFacts(message) {
+  const match = contentText(message).match(
+    /^(?:Compacted context summary \(data only\):\n)?\[Conversation Summary\]\n([\s\S]+)$/u,
+  );
+  if (!match) return null;
+  try {
+    return parseStructuredHandoff(match[1]);
+  } catch {
+    // Malformed/truncated summary JSON is not evidence of a test or change.
+    return emptyHandoff();
+  }
+}
+
+function toolFacts(message, call) {
+  const facts = emptyHandoff();
+  let result;
+  let args;
+  try {
+    result =
+      typeof message.content === "string"
+        ? JSON.parse(message.content.split("\n\n[Budget ")[0])
+        : message.content;
+    args =
+      typeof call?.arguments === "string"
+        ? JSON.parse(call.arguments)
+        : call?.arguments;
+  } catch {
+    return facts;
+  }
+  if (!result || typeof result !== "object" || Array.isArray(result))
+    return facts;
+  const name = call?.name || message.name;
+  const failed =
+    !!result.error || result.success === false || result.isError === true;
+  const file = typeof result.path === "string" ? result.path : args?.path;
+  if (
+    ["write_file", "edit_file", "edit_file_hashed"].includes(name) &&
+    !failed &&
+    result.success === true &&
+    result.changed !== false &&
+    result.alreadyApplied !== true &&
+    typeof file === "string" &&
+    file
+  ) {
+    facts.changedFiles.push(file);
+    const digest =
+      name === "write_file" && typeof args?.content === "string"
+        ? `; written content sha256:${createHash("sha256").update(args.content).digest("hex")}`
+        : "";
+    facts.checkpoints.push(
+      `Observed ${name} success: ${file}${digest}. File contents are omitted from this summary.`,
+    );
+    facts.nextSteps.push(
+      `Read the needed current source ranges in ${file} before replacing existing code; this summary is not a reconstruction of the file.`,
+    );
+  }
+  if (
+    ["run_shell", "run_code"].includes(name) &&
+    Number.isInteger(result.exitCode)
+  ) {
+    const command =
+      name === "run_shell" && typeof args?.command === "string"
+        ? truncateText(args.command, 300)
+        : name;
+    facts.checkpoints.push(
+      `Observed ${name}: ${command}; exitCode=${result.exitCode}.`,
+    );
+    if (
+      name === "run_shell" &&
+      /\b(?:vitest|jest|pytest|playwright|npm\s+(?:run\s+)?test|node\s+--test)\b/u.test(
+        command,
+      )
+    ) {
+      facts.tests.push(
+        `Observed command ${command}; exitCode=${result.exitCode}.`,
+      );
+    }
+  }
+  return facts;
 }
 
 function emptyHandoff(objective = "") {
@@ -313,12 +424,40 @@ export function buildExtractiveHandoff(messages, options = {}) {
   const sources = selectBoundedSources(messages, maxFallbackSourceChars);
   const firstUser = sources.find((entry) => entry.role === "user");
   const candidates = emptyHandoff(
-    truncateText(firstUser?.text || "", maxItemChars),
+    truncateText(
+      firstUser?.text ||
+        sources.find((entry) => entry.facts?.objective)?.facts.objective ||
+        "",
+      maxItemChars,
+    ),
   );
 
   for (const source of sources) {
-    for (const fragment of fragments(source.text)) {
-      candidates.changedFiles.push(...pathsFrom(fragment));
+    if (source.facts) {
+      // Extract typed observations before budgeting, never regex-match a
+      // serialized tool payload (which may contain arbitrary source text).
+      for (const field of ARRAY_FIELDS)
+        candidates[field].push(...source.facts[field]);
+      continue;
+    }
+    // Quoted implementation examples are source data, not executed outcomes.
+    const prose = source.text.replace(
+      /```[\s\S]*?(?:```|$)|~~~[\s\S]*?(?:~~~|$)/gu,
+      "",
+    );
+    for (const fragment of fragments(prose)) {
+      const statusNarrative =
+        source.role !== "user" &&
+        !/^(?:must|must not|do not|don't|only|next|todo|remaining|then|we will|will|need to)\b/iu.test(
+          fragment,
+        );
+      if (
+        statusNarrative &&
+        /^(?:changed|modified|updated|created|deleted|wrote|edited)\b/iu.test(
+          fragment,
+        )
+      )
+        candidates.changedFiles.push(...pathsFrom(fragment));
       if (
         /^(?:constraint|constraints|requirement|requirements|must|must not|do not|don't|only|约束|必须|不要|只能|仅限)\b/iu.test(
           fragment,
@@ -326,10 +465,7 @@ export function buildExtractiveHandoff(messages, options = {}) {
         /\bwithout\s+(?:widening|changing|removing|losing)\b/iu.test(fragment)
       ) {
         candidates.constraints.push(
-          stripLabel(
-            fragment,
-            "constraint(?:s)?|requirement(?:s)?|must(?: not)?|do not|don't|only|约束|必须|不要|只能|仅限",
-          ),
+          stripLabel(fragment, "constraint(?:s)?|requirement(?:s)?|约束"),
         );
       }
       if (
@@ -345,6 +481,7 @@ export function buildExtractiveHandoff(messages, options = {}) {
         );
       }
       if (
+        statusNarrative &&
         /\b(?:test|tests|vitest|jest|pytest|playwright|lint|typecheck|build)\b/iu.test(
           fragment,
         ) &&
@@ -367,6 +504,7 @@ export function buildExtractiveHandoff(messages, options = {}) {
         );
       }
       if (
+        statusNarrative &&
         /\b(?:checkpoint|commit\s+[0-9a-f]{7,40}|implemented|completed|done|verified|checkpoint|检查点|已完成|已实现)\b/iu.test(
           fragment,
         )

package/src/lib/agent-session-export.js

@@ -1,3 +1,4 @@
+import { projectToolRoundMessages } from "./session-tool-round.js";
 /**
  * Agent-session Markdown export — Claude-Code `/export` parity for the JSONL
  * headless/agent session store (`~/.../sessions/<id>.jsonl`, the `--resume`
@@ -63,6 +64,25 @@ export function renderAgentSessionMarkdown(sessionId, events, opts = {}) {
   for (const ev of events) {
     if (!ev || typeof ev !== "object") continue;
     switch (ev.type) {
+      case "tool_round":
+        for (const message of projectToolRoundMessages(ev)) {
+          L.push(
+            message.role === "assistant"
+              ? "## Assistant tool calls"
+              : `### Tool result ${message.tool_call_id}`,
+          );
+          L.push(
+            "",
+            fence(
+              message.role === "assistant"
+                ? message.tool_calls
+                : message.content,
+              "json",
+            ),
+            "",
+          );
+        }
+        break;
       case "user_message":
         users += 1;
         L.push("## 👤 User");

package/src/lib/background-agent-supervisor.js

@@ -1394,6 +1394,60 @@ export function mutateBackgroundAgentState(id, updater, options = {}) {
   );
 }
 
+export async function mutateBackgroundAgentStateWithLockRetry(
+  id,
+  updater,
+  options = {},
+) {
+  const now = options.now || Date.now;
+  const sleep =
+    options.sleep ||
+    ((milliseconds) =>
+      new Promise((resolvePromise) =>
+        setTimeout(resolvePromise, milliseconds),
+      ));
+  const mutate = options.mutate || mutateBackgroundAgentState;
+  const numericOption = (value, fallback, minimum) => {
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.max(minimum, number) : fallback;
+  };
+  const timeoutMs = numericOption(options.timeoutMs ?? 30_000, 30_000, 0);
+  const lockTimeoutMs = numericOption(
+    options.lockTimeoutMs ?? 10_000,
+    10_000,
+    0,
+  );
+  const initialRetryMs = numericOption(options.initialRetryMs ?? 100, 100, 1);
+  const maxRetryMs = Math.max(
+    initialRetryMs,
+    numericOption(options.maxRetryMs ?? 1_000, 1_000, 1),
+  );
+  const deadline = now() + timeoutMs;
+  let attempts = 0;
+
+  for (;;) {
+    attempts += 1;
+    try {
+      return mutate(id, updater, {
+        timeoutMs: Math.min(lockTimeoutMs, Math.max(0, deadline - now())),
+      });
+    } catch (error) {
+      if (error?.code !== "STATE_LOCK_UNAVAILABLE") throw error;
+      const remainingMs = deadline - now();
+      if (remainingMs <= 0) {
+        error.attempts = attempts;
+        throw error;
+      }
+      const retryMs = Math.min(
+        maxRetryMs,
+        initialRetryMs * 2 ** Math.min(attempts - 1, 4),
+        remainingMs,
+      );
+      await sleep(retryMs);
+    }
+  }
+}
+
 export function writeBackgroundAgentState(state, options = {}) {
   return mutateBackgroundAgentState(state.id, () => state, {
     createIfMissing: options.createIfMissing === true,

package/src/lib/cli-goal-catalog.js

@@ -0,0 +1,129 @@
+/** Bounded, explicit metadata discovery for native IDE goal pickers. */
+import fs from "node:fs";
+import path from "node:path";
+import { resolveConfigDataRoot } from "./paths.js";
+import { goalFileStoreId } from "./goal-store.js";
+import { createCliGoalSnapshotReader } from "./cli-goal-source.js";
+
+export const CLI_GOAL_CATALOG_SCHEMA = "chainlesschain.goal-catalog.v1";
+const MAX_DIRECTORY_ENTRIES = 2048;
+const safeId = (id) =>
+  typeof id === "string" &&
+  /^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/u.test(id) &&
+  !id.includes("..");
+function fail(code) {
+  throw new Error(code);
+}
+function cursor(storeId, afterId) {
+  return Buffer.from(JSON.stringify({ v: 1, storeId, afterId })).toString(
+    "base64url",
+  );
+}
+function decodeCursor(value, storeId) {
+  if (value === undefined) return "";
+  try {
+    if (
+      typeof value !== "string" ||
+      value.length > 1024 ||
+      !/^[A-Za-z0-9_-]+$/u.test(value)
+    )
+      throw 0;
+    const raw = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+    if (
+      Object.keys(raw).sort().join(",") !== "afterId,storeId,v" ||
+      raw.v !== 1 ||
+      raw.storeId !== storeId ||
+      !safeId(raw.afterId) ||
+      cursor(storeId, raw.afterId) !== value
+    )
+      throw 0;
+    return raw.afterId;
+  } catch {
+    fail("CLI_GOAL_CATALOG_INVALID_CURSOR");
+  }
+}
+
+/** Each page visits at most limit candidates, including invalid sources.
+ * Pages are fresh reads; this does not promise a frozen cross-page snapshot. */
+export function readCliGoalCatalog(options = {}) {
+  const cwd = path.resolve(options.cwd || process.cwd());
+  const env = Object.freeze({ ...(options.env || process.env) });
+  const root = path.resolve(
+    options.root ||
+      path.join(resolveConfigDataRoot({ cwd, env }).path, "goals"),
+  );
+  const storeId = goalFileStoreId(root);
+  const limit = options.limit ?? 20;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 20)
+    fail("CLI_GOAL_CATALOG_INVALID_LIMIT");
+  const afterId = decodeCursor(options.after, storeId);
+  const result = {
+    schema: CLI_GOAL_CATALOG_SCHEMA,
+    storeId,
+    snapshot: true,
+    observedAt: new Date().toISOString(),
+    entries: [],
+    scannedCount: 0,
+    skippedCount: 0,
+    invalidNameCount: 0,
+    nextCursor: null,
+  };
+  try {
+    fs.lstatSync(root);
+  } catch (error) {
+    if (error.code === "ENOENT") return result;
+    throw error;
+  }
+  const source = createCliGoalSnapshotReader(root);
+  const directory = fs.opendirSync(root);
+  const ids = [];
+  try {
+    let count = 0;
+    for (let entry; (entry = directory.readSync()); ) {
+      if (++count > MAX_DIRECTORY_ENTRIES)
+        fail("CLI_GOAL_CATALOG_DIRECTORY_LIMIT");
+      if (!entry.name.endsWith(".json")) continue;
+      const id = entry.name.slice(0, -5);
+      if (!safeId(id)) {
+        result.invalidNameCount++;
+        continue;
+      }
+      if (safeId(id) && id > afterId) ids.push(id);
+    }
+  } finally {
+    directory.closeSync();
+  }
+  source.checkRoot();
+  ids.sort();
+  const snapshots = [];
+  const page = ids.slice(0, limit);
+  result.scannedCount = page.length;
+  for (const id of page) {
+    try {
+      const snapshot = source.read(id);
+      const goal = snapshot.goal;
+      const title = (goal.title || goal.objective)
+        .replace(
+          /[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]/gu,
+          " ",
+        )
+        .slice(0, 160);
+      result.entries.push({
+        id: goal.id,
+        title,
+        status: goal.status,
+        revision: goal.revision,
+        controlGeneration: goal.controlGeneration,
+      });
+      snapshots.push(snapshot);
+    } catch {
+      result.skippedCount++;
+    }
+  }
+  // A changed valid source aborts the page instead of returning stale metadata.
+  for (const snapshot of snapshots) source.revalidate(snapshot);
+  source.checkRoot();
+  if (ids.length > page.length)
+    result.nextCursor = cursor(storeId, page.at(-1));
+  return result;
+}

package/src/lib/cli-goal-source.js

@@ -0,0 +1,119 @@
+/** Bounded standalone file reads shared by explicit CLI snapshots. */
+import fs from "node:fs";
+import { createHash } from "node:crypto";
+import { createGoalFileAdapter } from "./goal-store.js";
+
+function fail(code) {
+  throw new Error(code);
+}
+function sameFile(a, b) {
+  return (
+    a.dev === b.dev &&
+    a.ino === b.ino &&
+    a.size === b.size &&
+    a.mtimeMs === b.mtimeMs &&
+    a.ctimeMs === b.ctimeMs
+  );
+}
+
+/** Pin the configured store, including directory identity, for this snapshot. */
+function sourceReader(root, onRead) {
+  const realRoot = fs.realpathSync(root);
+  const initialRoot = fs.statSync(root);
+  function checkRoot() {
+    const stat = fs.statSync(root);
+    if (
+      !stat.isDirectory() ||
+      fs.realpathSync(root) !== realRoot ||
+      stat.dev !== initialRoot.dev ||
+      stat.ino !== initialRoot.ino
+    )
+      fail("CLI_GOAL_STORE_CHANGED");
+  }
+  const readJson = (file) => {
+    checkRoot();
+    const entry = fs.lstatSync(file);
+    if (!entry.isFile() || entry.isSymbolicLink())
+      fail("CLI_GOAL_REGULAR_FILE_REQUIRED");
+    let fd;
+    try {
+      fd = fs.openSync(
+        file,
+        fs.constants.O_RDONLY |
+          (fs.constants.O_NOFOLLOW || 0) |
+          (fs.constants.O_NONBLOCK || 0),
+      );
+      const before = fs.fstatSync(fd);
+      if (!before.isFile() || !sameFile(entry, before))
+        fail("CLI_GOAL_SOURCE_CHANGED");
+      if (before.size > 64 * 1024) fail("CLI_GOAL_SOURCE_TOO_LARGE");
+      const buffer = Buffer.alloc(before.size + 1);
+      let count = 0;
+      while (count < buffer.length) {
+        const size = fs.readSync(
+          fd,
+          buffer,
+          count,
+          buffer.length - count,
+          count,
+        );
+        if (!size) break;
+        count += size;
+      }
+      checkRoot();
+      const after = fs.lstatSync(file);
+      if (
+        count !== before.size ||
+        !sameFile(before, fs.fstatSync(fd)) ||
+        !after.isFile() ||
+        after.isSymbolicLink() ||
+        !sameFile(before, after)
+      )
+        fail("CLI_GOAL_SOURCE_CHANGED");
+      const bytes = buffer.subarray(0, count);
+      const value = JSON.parse(
+        new TextDecoder("utf-8", { fatal: true }).decode(bytes),
+      );
+      onRead(createHash("sha256").update(bytes).digest("hex"));
+      return value;
+    } finally {
+      if (fd !== undefined) fs.closeSync(fd);
+    }
+  };
+  return { readJson, checkRoot };
+}
+
+export function createCliGoalSnapshotReader(root) {
+  let rawDigest;
+  const source = sourceReader(root, (value) => {
+    rawDigest = value;
+  });
+  const adapter = createGoalFileAdapter({ root, readJson: source.readJson });
+  function read(id) {
+    const goal = adapter.get(id);
+    if (!goal) fail("CLI_GOAL_NOT_FOUND");
+    return { goal, digest: rawDigest };
+  }
+  function revalidate(snapshot) {
+    let current;
+    try {
+      current = read(snapshot.goal.id);
+    } catch {
+      fail("CLI_GOAL_SOURCE_CHANGED");
+    }
+    if (
+      current.digest !== snapshot.digest ||
+      current.goal.storeId !== snapshot.goal.storeId ||
+      current.goal.revision !== snapshot.goal.revision ||
+      current.goal.controlGeneration !== snapshot.goal.controlGeneration
+    )
+      fail("CLI_GOAL_SOURCE_CHANGED");
+    return current.goal;
+  }
+  return {
+    storeId: adapter.storeId,
+    read,
+    revalidate,
+    checkRoot: source.checkRoot,
+  };
+}

package/src/lib/coding-task-guidance.js

@@ -5,8 +5,9 @@ export const CODING_TASK_QUALITY_GUIDANCE = `Coding task quality:
 - Resolve each relative import from the destination file's directory. Read back the completed file and fix newDiagnostics from write/edit results before finishing. A successful write confirms persistence, not syntax, test execution or acceptance.
 - Regression tests need a working positive control and a negative control that exercises the requested behavior through the real production entry point. Assert observable effects; avoid mocks or alternate calls that bypass the behavior under test. Complete the current worker/request when testing cancellation and replacement.
 - For boundary regressions, derive expected defaults, computed values and rejection rules from the implementation or the explicit requested contract. Inject mismatched, tampered or stale input through the real entry point while keeping other prerequisites valid; verify that the fixture reaches the intended check rather than failing during setup. Compare observable results with independent expected values or authoritative state, not a helper that merely recomputes the same result.
+- Trace rejection before asserting its aftermath: a request can be rejected before registration or persistence. Check whether state stays unchanged, a failed record is saved, or an event is emitted; do not assume every rejection creates a failed task. When testing attribution, verify independently recorded identities and provenance as well as message contents; identical text can still be attributed to the wrong source.
 - Use available execution tools for a focused check when permitted. When execution tools are unavailable, inspect imports, API contracts and fixtures using the available file tools, and clearly say that tests were not run. Never describe a read-back or static check as a passing test or end-to-end verification.
-- Finish requested file changes before the final response. Reserve output and remaining requests for writing, read-back and focused validation. For large files, aim for a few thousand characters of new content per call: write a small complete section, then extend it with edit_file using a unique existing anchor and a replacement containing that anchor plus the next complete section. Keep each tool call complete and wait for its result before extending the file again; do not repeatedly rewrite the growing file. State what was delivered, what was checked and what remains unverified.`;
+- Finish requested file changes before the final response. Reserve output and remaining requests for writing, read-back and focused validation. For large files, aim for a few thousand characters of new content per call: write a small complete section, then extend it with edit_file using a unique existing anchor and a replacement containing that anchor plus the next complete section. A list of available tool names is not a limit on the number of tool calls; use further calls within the actual request budget to finish and inspect the file. Keep each tool call complete and wait for its result before extending the file again; do not repeatedly rewrite the growing file. State what was delivered, what was checked and what remains unverified, without repeating that account in multiple drafts.`;
 
 export const HERMETIC_CODING_SYSTEM_PROMPT = `You are a hermetic coding assistant. The exposed file tools are the complete tool surface. Inspect and mutate only the exact paths authorized by the user request. Do not invoke hidden tools, commands, language servers or other execution paths.
 

package/src/lib/config-schema.js

@@ -83,7 +83,7 @@ const DESCRIPTORS = [
       "Requested live service tier; model and endpoint support are checked before dispatch",
   }),
   descriptor("llm.visionModel", ["string", "null"], {
-    description: "Model used for image turns",
+    description: "Fallback for image turns when the main model lacks vision",
   }),
   descriptor("llm.fallbackModel", ["string", "null"], {
     deprecated: true,