@creative-dswork/dscode 0.2.6 → 0.2.7

package/dist/dscode.mjs

@@ -115,6 +115,33 @@ var init_qwen = __esm({
   }
 });
 
+// src/models/kimi.ts
+var KIMI_BASE_URL, KIMI_MODELS;
+var init_kimi = __esm({
+  "src/models/kimi.ts"() {
+    "use strict";
+    KIMI_BASE_URL = "https://api.moonshot.cn/v1";
+    KIMI_MODELS = {
+      "kimi-k3": {
+        api: "openai-completions",
+        provider: "kimi",
+        baseUrl: KIMI_BASE_URL,
+        reasoning: true,
+        thinkingLevelMap: { low: null, medium: null, high: null, max: "max" },
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 1048576,
+        maxTokens: 131072,
+        compat: {
+          supportsDeveloperRole: false,
+          thinkingFormat: "deepseek",
+          deferredToolsMode: "kimi"
+        }
+      }
+    };
+  }
+});
+
 // src/models/registry.ts
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
 import { createProvider, lazyApi, envApiKeyAuth } from "@earendil-works/pi-ai";
@@ -155,8 +182,13 @@ function resolveModel(provider, modelId) {
 function getThinkingLevel(provider, modelId) {
   try {
     const model = resolveModel(provider, modelId);
-    if (model.reasoning) return "high";
-    return "off";
+    if (!model.reasoning) return "off";
+    if (model.thinkingLevelMap) {
+      const supportedLevels = Object.entries(model.thinkingLevelMap).filter(([, v]) => v !== null);
+      if (supportedLevels.length === 0) return "off";
+      if (supportedLevels.length === 1 && supportedLevels[0][0] === "max") return "max";
+    }
+    return "high";
   } catch {
   }
   if (modelId.includes("thinking")) return "high";
@@ -179,11 +211,12 @@ function getEnvApiKey(provider) {
   }
   return void 0;
 }
-var providerFactories, customModelDefs, models, qwenProvider, API_KEY_ENV_VARS;
+var providerFactories, customModelDefs, models, qwenProvider, kimiProvider, API_KEY_ENV_VARS;
 var init_registry = __esm({
   "src/models/registry.ts"() {
     "use strict";
     init_qwen();
+    init_kimi();
     providerFactories = /* @__PURE__ */ new Map();
     customModelDefs = /* @__PURE__ */ new Map();
     models = builtinModels();
@@ -195,6 +228,15 @@ var init_registry = __esm({
       models: Object.entries(QWEN_MODELS).map(([id, def]) => ({ id, name: `Qwen: ${id}`, ...def })),
       api: lazyApi(() => import("@earendil-works/pi-ai/api/openai-completions"))
     });
+    kimiProvider = createProvider({
+      id: "kimi",
+      name: "Kimi (Moonshot)",
+      baseUrl: KIMI_BASE_URL,
+      auth: { apiKey: envApiKeyAuth("Kimi API key", ["KIMI_API_KEY", "MOONSHOT_API_KEY"]) },
+      models: Object.entries(KIMI_MODELS).map(([id, def]) => ({ id, name: `Kimi ${id}`, ...def })),
+      api: lazyApi(() => import("@earendil-works/pi-ai/api/openai-completions"))
+    });
+    models.setProvider(kimiProvider);
     models.setProvider(qwenProvider);
     API_KEY_ENV_VARS = {
       deepseek: "DEEPSEEK_API_KEY",
@@ -207,6 +249,7 @@ var init_registry = __esm({
       openrouter: "OPENROUTER_API_KEY",
       "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
       zai: "ZAI_API_KEY",
+      "kimi": "KIMI_API_KEY",
       "zai-coding-cn": "ZAI_CODING_CN_API_KEY",
       mistral: "MISTRAL_API_KEY",
       minimax: "MINIMAX_API_KEY",
@@ -453,7 +496,7 @@ function loadConfig(cliCwd) {
   const userCommandsDir = join(configDir, "commands");
   const projectCommandsDir = join(projectPath, ".dscode", "commands");
   const defaultThinkingLevel = getThinkingLevel(provider, modelId);
-  const validThinkingLevels = /* @__PURE__ */ new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
+  const validThinkingLevels = /* @__PURE__ */ new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
   const rawThinkingLevel = process.env.AGENT_THINKING_LEVEL ?? userConfig.thinkingLevel ?? merged.thinkingLevel;
   const thinkingLevel = rawThinkingLevel !== void 0 && validThinkingLevels.has(rawThinkingLevel) ? rawThinkingLevel : defaultThinkingLevel;
   const retryFromEnv = {
@@ -531,6 +574,7 @@ var init_config = __esm({
     PROVIDER_ENV_VARS = {
       deepseek: "DEEPSEEK_API_KEY",
       "kimi-coding": "KIMI_API_KEY",
+      "kimi": "KIMI_API_KEY",
       openai: "OPENAI_API_KEY",
       anthropic: "ANTHROPIC_API_KEY",
       google: "GEMINI_API_KEY",
@@ -538,7 +582,8 @@ var init_config = __esm({
       groq: "GROQ_API_KEY",
       openrouter: "OPENROUTER_API_KEY",
       mistral: "MISTRAL_API_KEY",
-      qwen: "DASHSCOPE_API_KEY"
+      qwen: "DASHSCOPE_API_KEY",
+      "moonshotai-cn": "MOONSHOT_API_KEY"
     };
   }
 });
@@ -547,17 +592,17 @@ var init_config = __esm({
 import { appendFileSync, mkdirSync as mkdirSync2, existsSync as existsSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
-function formatLine(level, channel, agentType, agentId, tag, message) {
+function formatLine(level, agentType, agentId, tag, message) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-  return `[${ts}] [${level.toUpperCase()}] [${channel}] [${agentType}/${agentId}] [${tag}] ${message}`;
+  return `[${ts}] [${level.toUpperCase()}] [${agentType}/${agentId}] [${tag}] ${message}`;
 }
 function ensureDir() {
   if (!existsSync2(LOG_DIR)) {
     mkdirSync2(LOG_DIR, { recursive: true });
   }
 }
-function channelPath(channel) {
-  return join2(LOG_DIR, `${channel}.log`);
+function filePath() {
+  return join2(LOG_DIR, "dscode.log");
 }
 var LEVEL_RANK, Logger, LOG_DIR;
 var init_logger = __esm({
@@ -579,32 +624,32 @@ var init_logger = __esm({
         this.minLevel = LEVEL_RANK[options.level ?? "debug"];
       }
       // ── Public API ──
-      debug(channel, tag, message) {
-        this.write("debug", channel, tag, message);
+      debug(tag, message) {
+        this.write("debug", tag, message);
       }
-      info(channel, tag, message) {
-        this.write("info", channel, tag, message);
+      info(tag, message) {
+        this.write("info", tag, message);
       }
-      warn(channel, tag, message) {
-        this.write("warn", channel, tag, message);
+      warn(tag, message) {
+        this.write("warn", tag, message);
       }
-      error(channel, tag, message) {
-        this.write("error", channel, tag, message);
+      error(tag, message) {
+        this.write("error", tag, message);
       }
-      clear(channel) {
+      clear() {
         try {
           ensureDir();
-          writeFileSync2(channelPath(channel), "", "utf-8");
+          writeFileSync2(filePath(), "", "utf-8");
         } catch {
         }
       }
       // ── Internal ──
-      write(level, channel, tag, message) {
+      write(level, tag, message) {
         if (LEVEL_RANK[level] < this.minLevel) return;
-        const line = formatLine(level, channel, this.type, this.id, tag, message);
+        const line = formatLine(level, this.type, this.id, tag, message);
         try {
           ensureDir();
-          appendFileSync(channelPath(channel), line + "\n", "utf8");
+          appendFileSync(filePath(), line + "\n", "utf8");
         } catch {
         }
       }
@@ -626,7 +671,7 @@ async function getSharp() {
     return sharpInstance;
   } catch {
     sharpAvailable = false;
-    _cacheLogger.warn("tool", "ImageCache", "sharp not available, images will be stored uncompressed");
+    _cacheLogger.warn("ImageCache", "sharp not available, images will be stored uncompressed");
     return null;
   }
 }
@@ -685,7 +730,7 @@ var init_cache = __esm({
             await pipeline.png().toFile(filepath);
             return { type: "image_ref", hash: filename, mimeType: "image/png" };
           } catch (err) {
-            _cacheLogger.warn("tool", "ImageCache", `sharp processing failed, storing original: ${String(err)}`);
+            _cacheLogger.warn("ImageCache", `sharp processing failed, storing original: ${String(err)}`);
           }
         }
         if (!existsSync3(filepath)) {
@@ -830,20 +875,20 @@ var init_store = __esm({
         const projPath = join4(this.projectDir, `${id}.json`);
         const globalPath = join4(this.globalDir, `${id}.json`);
         let raw;
-        let filePath;
+        let filePath2;
         if (existsSync4(projPath)) {
-          filePath = projPath;
+          filePath2 = projPath;
         } else if (existsSync4(globalPath)) {
-          filePath = globalPath;
+          filePath2 = globalPath;
         } else {
           throw new SessionValidateError(`Session not found: ${id}`);
         }
-        const stat4 = existsSync4(filePath);
+        const stat4 = existsSync4(filePath2);
         if (!stat4) {
           throw new SessionValidateError(`Session not found: ${id}`);
         }
         try {
-          raw = JSON.parse(readFileSync3(filePath, "utf8"));
+          raw = JSON.parse(readFileSync3(filePath2, "utf8"));
         } catch {
           throw new SessionValidateError("Session file is corrupted: invalid JSON");
         }
@@ -853,16 +898,16 @@ var init_store = __esm({
       async loadSessionFile(sessionId) {
         const projPath = join4(this.projectDir, `${sessionId}.json`);
         const globalPath = join4(this.globalDir, `${sessionId}.json`);
-        let filePath;
+        let filePath2;
         if (existsSync4(projPath)) {
-          filePath = projPath;
+          filePath2 = projPath;
         } else if (existsSync4(globalPath)) {
-          filePath = globalPath;
+          filePath2 = globalPath;
         } else {
           return null;
         }
         try {
-          const raw = JSON.parse(readFileSync3(filePath, "utf8"));
+          const raw = JSON.parse(readFileSync3(filePath2, "utf8"));
           return validateSession(raw, sessionId);
         } catch {
           return null;
@@ -1228,7 +1273,7 @@ var init_manager = __esm({
         try {
           this.saveSession(agent, pendingPermission);
         } catch (err) {
-          this.logger.error("session", "Save", `trySaveSession failed: ${String(err)}`);
+          this.logger.error("Save", `trySaveSession failed: ${String(err)}`);
         }
       }
       async loadSession(id, agent) {
@@ -9124,11 +9169,11 @@ ${lanes.join("\n")}
         const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames2);
         return nonPollingWatchFile;
         function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) {
-          const filePath = toCanonicalName(fileName);
-          if (fileWatcherCallbacks.add(filePath, callback).length === 1 && fileTimestamps) {
-            fileTimestamps.set(filePath, getModifiedTime3(fileName) || missingFileModifiedTime);
+          const filePath2 = toCanonicalName(fileName);
+          if (fileWatcherCallbacks.add(filePath2, callback).length === 1 && fileTimestamps) {
+            fileTimestamps.set(filePath2, getModifiedTime3(fileName) || missingFileModifiedTime);
           }
-          const dirPath = getDirectoryPath(filePath) || ".";
+          const dirPath = getDirectoryPath(filePath2) || ".";
           const watcher = dirWatchers.get(dirPath) || createDirectoryWatcher(getDirectoryPath(fileName) || ".", dirPath, fallbackOptions);
           watcher.referenceCount++;
           return {
@@ -9139,7 +9184,7 @@ ${lanes.join("\n")}
               } else {
                 watcher.referenceCount--;
               }
-              fileWatcherCallbacks.remove(filePath, callback);
+              fileWatcherCallbacks.remove(filePath2, callback);
             }
           };
         }
@@ -9150,19 +9195,19 @@ ${lanes.join("\n")}
             (eventName, relativeFileName) => {
               if (!isString2(relativeFileName)) return;
               const fileName = getNormalizedAbsolutePath(relativeFileName, dirName);
-              const filePath = toCanonicalName(fileName);
-              const callbacks = fileName && fileWatcherCallbacks.get(filePath);
+              const filePath2 = toCanonicalName(fileName);
+              const callbacks = fileName && fileWatcherCallbacks.get(filePath2);
               if (callbacks) {
                 let currentModifiedTime;
                 let eventKind = 1;
                 if (fileTimestamps) {
-                  const existingTime = fileTimestamps.get(filePath);
+                  const existingTime = fileTimestamps.get(filePath2);
                   if (eventName === "change") {
                     currentModifiedTime = getModifiedTime3(fileName) || missingFileModifiedTime;
                     if (currentModifiedTime.getTime() === existingTime.getTime()) return;
                   }
                   currentModifiedTime || (currentModifiedTime = getModifiedTime3(fileName) || missingFileModifiedTime);
-                  fileTimestamps.set(filePath, currentModifiedTime);
+                  fileTimestamps.set(filePath2, currentModifiedTime);
                   if (existingTime === missingFileModifiedTime) eventKind = 0;
                   else if (currentModifiedTime === missingFileModifiedTime) eventKind = 2;
                 }
@@ -16645,20 +16690,20 @@ ${lanes.join("\n")}
         function trySetLanguageAndTerritory(language2, territory2, errors2) {
           const compilerFilePath = normalizePath2(sys2.getExecutingFilePath());
           const containingDirectoryPath = getDirectoryPath(compilerFilePath);
-          let filePath = combinePaths(containingDirectoryPath, language2);
+          let filePath2 = combinePaths(containingDirectoryPath, language2);
           if (territory2) {
-            filePath = filePath + "-" + territory2;
+            filePath2 = filePath2 + "-" + territory2;
           }
-          filePath = sys2.resolvePath(combinePaths(filePath, "diagnosticMessages.generated.json"));
-          if (!sys2.fileExists(filePath)) {
+          filePath2 = sys2.resolvePath(combinePaths(filePath2, "diagnosticMessages.generated.json"));
+          if (!sys2.fileExists(filePath2)) {
             return false;
           }
           let fileContents = "";
           try {
-            fileContents = sys2.readFile(filePath);
+            fileContents = sys2.readFile(filePath2);
           } catch {
             if (errors2) {
-              errors2.push(createCompilerDiagnostic(Diagnostics.Unable_to_open_file_0, filePath));
+              errors2.push(createCompilerDiagnostic(Diagnostics.Unable_to_open_file_0, filePath2));
             }
             return false;
           }
@@ -16666,7 +16711,7 @@ ${lanes.join("\n")}
             setLocalizedDiagnosticMessages(JSON.parse(fileContents));
           } catch {
             if (errors2) {
-              errors2.push(createCompilerDiagnostic(Diagnostics.Corrupted_locale_file_0, filePath));
+              errors2.push(createCompilerDiagnostic(Diagnostics.Corrupted_locale_file_0, filePath2));
             }
             return false;
           }
@@ -22118,10 +22163,10 @@ ${lanes.join("\n")}
       function getExternalModuleNameFromPath(host, fileName, referencePath) {
         const getCanonicalFileName = (f) => host.getCanonicalFileName(f);
         const dir = toPath(referencePath ? getDirectoryPath(referencePath) : host.getCommonSourceDirectory(), host.getCurrentDirectory(), getCanonicalFileName);
-        const filePath = getNormalizedAbsolutePath(fileName, host.getCurrentDirectory());
+        const filePath2 = getNormalizedAbsolutePath(fileName, host.getCurrentDirectory());
         const relativePath = getRelativePathToDirectoryOrUrl(
           dir,
-          filePath,
+          filePath2,
           dir,
           getCanonicalFileName,
           /*isAbsolutePathAnUrl*/
@@ -22196,11 +22241,11 @@ ${lanes.join("\n")}
           /* Js */
         ];
       }
-      function getPossibleOriginalInputPathWithoutChangingExt(filePath, ignoreCase, outputDir, getCommonSourceDirectory2) {
+      function getPossibleOriginalInputPathWithoutChangingExt(filePath2, ignoreCase, outputDir, getCommonSourceDirectory2) {
         return outputDir ? resolvePath2(
           getCommonSourceDirectory2(),
-          getRelativePathFromDirectory(outputDir, filePath, ignoreCase)
-        ) : filePath;
+          getRelativePathFromDirectory(outputDir, filePath2, ignoreCase)
+        ) : filePath2;
       }
       function getPathsBasePath(options, host) {
         var _a;
@@ -131244,7 +131289,7 @@ ${lanes.join("\n")}
           const sourceRoot = normalizeSlashes(mapOptions.sourceRoot || "");
           return sourceRoot ? ensureTrailingDirectorySeparator(sourceRoot) : sourceRoot;
         }
-        function getSourceMapDirectory(mapOptions, filePath, sourceFile) {
+        function getSourceMapDirectory(mapOptions, filePath2, sourceFile) {
           if (mapOptions.sourceRoot) return host.getCommonSourceDirectory();
           if (mapOptions.mapRoot) {
             let sourceMapDir = normalizeSlashes(mapOptions.mapRoot);
@@ -131256,9 +131301,9 @@ ${lanes.join("\n")}
             }
             return sourceMapDir;
           }
-          return getDirectoryPath(normalizePath2(filePath));
+          return getDirectoryPath(normalizePath2(filePath2));
         }
-        function getSourceMappingURL(mapOptions, sourceMapGenerator, filePath, sourceMapFilePath, sourceFile) {
+        function getSourceMappingURL(mapOptions, sourceMapGenerator, filePath2, sourceMapFilePath, sourceFile) {
           if (mapOptions.inlineSourceMap) {
             const sourceMapText = sourceMapGenerator.toString();
             const base64SourceMapText = base64encode(sys, sourceMapText);
@@ -131274,7 +131319,7 @@ ${lanes.join("\n")}
               sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir);
               return encodeURI(
                 getRelativePathToDirectoryOrUrl(
-                  getDirectoryPath(normalizePath2(filePath)),
+                  getDirectoryPath(normalizePath2(filePath2)),
                   // get the relative sourceMapDir path based on jsFilePath
                   combinePaths(sourceMapDir, sourceMapFile),
                   // this is where user expects to see sourceMap
@@ -136253,11 +136298,11 @@ ${lanes.join("\n")}
           }
           return fsQueryResult;
         }
-        function addOrDeleteFile(fileName, filePath, eventKind) {
+        function addOrDeleteFile(fileName, filePath2, eventKind) {
           if (eventKind === 1) {
             return;
           }
-          const parentResult = getCachedFileSystemEntriesForBaseDir(filePath);
+          const parentResult = getCachedFileSystemEntriesForBaseDir(filePath2);
           if (parentResult) {
             updateFilesOfFileSystemEntry(
               parentResult,
@@ -136266,7 +136311,7 @@ ${lanes.join("\n")}
               /* Created */
             );
           } else {
-            clearFirstAncestorEntry(filePath);
+            clearFirstAncestorEntry(filePath2);
           }
         }
         function updateFilesOfFileSystemEntry(parentResult, baseName, fileExists22) {
@@ -137800,7 +137845,7 @@ ${lanes.join("\n")}
         function forEachResolution(resolutionCache, callback, file) {
           var _a2;
           if (file) (_a2 = resolutionCache == null ? void 0 : resolutionCache.get(file.path)) == null ? void 0 : _a2.forEach((resolution, name, mode) => callback(resolution, name, mode, file.path));
-          else resolutionCache == null ? void 0 : resolutionCache.forEach((resolutions, filePath) => resolutions.forEach((resolution, name, mode) => callback(resolution, name, mode, filePath)));
+          else resolutionCache == null ? void 0 : resolutionCache.forEach((resolutions, filePath2) => resolutions.forEach((resolution, name, mode) => callback(resolution, name, mode, filePath2)));
         }
         function getPackagesMap() {
           if (packageMap) return packageMap;
@@ -140139,26 +140184,26 @@ ${lanes.join("\n")}
           if (options.noEmit) {
             return false;
           }
-          const filePath = toPath3(file);
-          if (getSourceFileByPath(filePath)) {
+          const filePath2 = toPath3(file);
+          if (getSourceFileByPath(filePath2)) {
             return false;
           }
           const out = options.outFile;
           if (out) {
-            return isSameFile(filePath, out) || isSameFile(
-              filePath,
+            return isSameFile(filePath2, out) || isSameFile(
+              filePath2,
               removeFileExtension(out) + ".d.ts"
               /* Dts */
             );
           }
-          if (options.declarationDir && containsPath(options.declarationDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames())) {
+          if (options.declarationDir && containsPath(options.declarationDir, filePath2, currentDirectory, !host.useCaseSensitiveFileNames())) {
             return true;
           }
           if (options.outDir) {
-            return containsPath(options.outDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames());
+            return containsPath(options.outDir, filePath2, currentDirectory, !host.useCaseSensitiveFileNames());
           }
-          if (fileExtensionIsOneOf(filePath, supportedJSExtensionsFlat) || isDeclarationFileName(filePath)) {
-            const filePathWithoutExtension = removeFileExtension(filePath);
+          if (fileExtensionIsOneOf(filePath2, supportedJSExtensionsFlat) || isDeclarationFileName(filePath2)) {
+            const filePathWithoutExtension = removeFileExtension(filePath2);
             return !!getSourceFileByPath(
               filePathWithoutExtension + ".ts"
               /* Ts */
@@ -141570,9 +141615,9 @@ ${lanes.join("\n")}
         const newSignature = Debug.checkDefined(state.fileInfos.get(path)).signature;
         return newSignature !== oldSignature;
       }
-      function handleDtsMayChangeOfGlobalScope(state, filePath, invalidateJsFiles, cancellationToken, host) {
+      function handleDtsMayChangeOfGlobalScope(state, filePath2, invalidateJsFiles, cancellationToken, host) {
         var _a;
-        if (!((_a = state.fileInfos.get(filePath)) == null ? void 0 : _a.affectsGlobalScope)) return false;
+        if (!((_a = state.fileInfos.get(filePath2)) == null ? void 0 : _a.affectsGlobalScope)) return false;
         BuilderState.getAllFilesExcludingDefaultLibraryFile(
           state,
           state.program,
@@ -141638,9 +141683,9 @@ ${lanes.join("\n")}
         (_b = state.referencedMap.getKeys(affectedFile.resolvedPath)) == null ? void 0 : _b.forEach((exportedFromPath) => {
           if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, invalidateJsFiles, cancellationToken, host)) return true;
           const references = state.referencedMap.getKeys(exportedFromPath);
-          return references && forEachKey(references, (filePath) => handleDtsMayChangeOfFileAndExportsOfFile(
+          return references && forEachKey(references, (filePath2) => handleDtsMayChangeOfFileAndExportsOfFile(
             state,
-            filePath,
+            filePath2,
             invalidateJsFiles,
             seenFileAndExportsOfFile,
             cancellationToken,
@@ -141648,12 +141693,12 @@ ${lanes.join("\n")}
           ));
         });
       }
-      function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, invalidateJsFiles, seenFileAndExportsOfFile, cancellationToken, host) {
+      function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath2, invalidateJsFiles, seenFileAndExportsOfFile, cancellationToken, host) {
         var _a;
-        if (!tryAddToSet(seenFileAndExportsOfFile, filePath)) return void 0;
-        if (handleDtsMayChangeOfGlobalScope(state, filePath, invalidateJsFiles, cancellationToken, host)) return true;
-        handleDtsMayChangeOf(state, filePath, invalidateJsFiles, cancellationToken, host);
-        (_a = state.referencedMap.getKeys(filePath)) == null ? void 0 : _a.forEach(
+        if (!tryAddToSet(seenFileAndExportsOfFile, filePath2)) return void 0;
+        if (handleDtsMayChangeOfGlobalScope(state, filePath2, invalidateJsFiles, cancellationToken, host)) return true;
+        handleDtsMayChangeOf(state, filePath2, invalidateJsFiles, cancellationToken, host);
+        (_a = state.referencedMap.getKeys(filePath2)) == null ? void 0 : _a.forEach(
           (referencingFilePath) => handleDtsMayChangeOfFileAndExportsOfFile(
             state,
             referencingFilePath,
@@ -142297,10 +142342,10 @@ ${lanes.join("\n")}
                   }
                 }
                 if (state.compilerOptions.composite) {
-                  const filePath = sourceFiles[0].resolvedPath;
-                  emitSignature = handleNewSignature((_c = state.emitSignatures) == null ? void 0 : _c.get(filePath), emitSignature);
+                  const filePath2 = sourceFiles[0].resolvedPath;
+                  emitSignature = handleNewSignature((_c = state.emitSignatures) == null ? void 0 : _c.get(filePath2), emitSignature);
                   if (!emitSignature) return data.skippedDtsWrite = true;
-                  (state.emitSignatures ?? (state.emitSignatures = /* @__PURE__ */ new Map())).set(filePath, emitSignature);
+                  (state.emitSignatures ?? (state.emitSignatures = /* @__PURE__ */ new Map())).set(filePath2, emitSignature);
                 }
               } else if (state.compilerOptions.composite) {
                 const newSignature = handleNewSignature(
@@ -142783,8 +142828,8 @@ ${lanes.join("\n")}
       function canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(fileOrDirPath) {
         return canWatchDirectoryOrFilePath(fileOrDirPath);
       }
-      function canWatchAffectingLocation(filePath) {
-        return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(filePath);
+      function canWatchAffectingLocation(filePath2) {
+        return canWatchAffectedPackageJsonOrNodeModulesOfAtTypes(filePath2);
       }
       function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath, rootDir, rootPath, rootPathComponents, isRootWatchable, getCurrentDirectory, preferNonRecursiveWatch) {
         const failedLookupPathComponents = getPathComponents(failedLookupLocationPath);
@@ -143366,8 +143411,8 @@ ${lanes.join("\n")}
         function isNodeModulesAtTypesDirectory(dirPath) {
           return endsWith(dirPath, "/node_modules/@types");
         }
-        function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution) {
-          (resolution.files ?? (resolution.files = /* @__PURE__ */ new Set())).add(filePath);
+        function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath2, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution) {
+          (resolution.files ?? (resolution.files = /* @__PURE__ */ new Set())).add(filePath2);
           if (resolution.files.size !== 1) return;
           if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
             watchFailedLookupLocationOfResolution(resolution);
@@ -143609,8 +143654,8 @@ ${lanes.join("\n")}
           }
           return removeAtRoot;
         }
-        function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName) {
-          Debug.checkDefined(resolution.files).delete(filePath);
+        function stopWatchFailedLookupLocationOfResolution(resolution, filePath2, getResolutionWithResolvedFileName) {
+          Debug.checkDefined(resolution.files).delete(filePath2);
           if (resolution.files.size) return;
           resolution.files = void 0;
           const resolved = getResolutionWithResolvedFileName(resolution);
@@ -143657,34 +143702,34 @@ ${lanes.join("\n")}
             /* Recursive */
           );
         }
-        function removeResolutionsOfFileFromCache(cache, filePath, getResolutionWithResolvedFileName) {
-          const resolutions = cache.get(filePath);
+        function removeResolutionsOfFileFromCache(cache, filePath2, getResolutionWithResolvedFileName) {
+          const resolutions = cache.get(filePath2);
           if (resolutions) {
             resolutions.forEach(
               (resolution) => stopWatchFailedLookupLocationOfResolution(
                 resolution,
-                filePath,
+                filePath2,
                 getResolutionWithResolvedFileName
               )
             );
-            cache.delete(filePath);
+            cache.delete(filePath2);
           }
         }
-        function removeResolutionsFromProjectReferenceRedirects(filePath) {
+        function removeResolutionsFromProjectReferenceRedirects(filePath2) {
           if (!fileExtensionIs(
-            filePath,
+            filePath2,
             ".json"
             /* Json */
           )) return;
           const program = resolutionHost.getCurrentProgram();
           if (!program) return;
-          const resolvedProjectReference = program.getResolvedProjectReferenceByPath(filePath);
+          const resolvedProjectReference = program.getResolvedProjectReferenceByPath(filePath2);
           if (!resolvedProjectReference) return;
           resolvedProjectReference.commandLine.fileNames.forEach((f) => removeResolutionsOfFile(resolutionHost.toPath(f)));
         }
-        function removeResolutionsOfFile(filePath) {
-          removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModuleFromResolution);
-          removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirectiveFromResolution);
+        function removeResolutionsOfFile(filePath2) {
+          removeResolutionsOfFileFromCache(resolvedModuleNames, filePath2, getResolvedModuleFromResolution);
+          removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath2, getResolvedTypeReferenceDirectiveFromResolution);
         }
         function invalidateResolutions(resolutions, canInvalidate) {
           if (!resolutions) return false;
@@ -143699,10 +143744,10 @@ ${lanes.join("\n")}
           });
           return invalidated;
         }
-        function invalidateResolutionOfFile(filePath) {
-          removeResolutionsOfFile(filePath);
+        function invalidateResolutionOfFile(filePath2) {
+          removeResolutionsOfFile(filePath2);
           const prevHasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
-          if (invalidateResolutions(resolvedFileToResolution.get(filePath), returnTrue) && hasChangedAutomaticTypeDirectiveNames && !prevHasChangedAutomaticTypeDirectiveNames) {
+          if (invalidateResolutions(resolvedFileToResolution.get(filePath2), returnTrue) && hasChangedAutomaticTypeDirectiveNames && !prevHasChangedAutomaticTypeDirectiveNames) {
             resolutionHost.onChangedAutomaticTypeDirectiveNames();
           }
         }
@@ -144096,9 +144141,9 @@ ${lanes.join("\n")}
         var _a;
         const configFile = program.getCompilerOptions().configFile;
         if (!((_a = configFile == null ? void 0 : configFile.configFileSpecs) == null ? void 0 : _a.validatedFilesSpec)) return void 0;
-        const filePath = program.getCanonicalFileName(fileName);
+        const filePath2 = program.getCanonicalFileName(fileName);
         const basePath = getDirectoryPath(getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory()));
-        const index = findIndex(configFile.configFileSpecs.validatedFilesSpec, (fileSpec) => program.getCanonicalFileName(getNormalizedAbsolutePath(fileSpec, basePath)) === filePath);
+        const index = findIndex(configFile.configFileSpecs.validatedFilesSpec, (fileSpec) => program.getCanonicalFileName(getNormalizedAbsolutePath(fileSpec, basePath)) === filePath2);
         return index !== -1 ? configFile.configFileSpecs.validatedFilesSpecBeforeSubstitution[index] : void 0;
       }
       function getMatchedIncludeSpec(program, fileName) {
@@ -183289,13 +183334,13 @@ ${newComment.split("\n").map((c2) => ` * ${c2}`).join("\n")}
           ["./*"]
         );
         if (files) {
-          for (let filePath of files) {
-            filePath = normalizePath2(filePath);
-            if (exclude && comparePaths(filePath, exclude, scriptDirectory, ignoreCase) === 0) {
+          for (let filePath2 of files) {
+            filePath2 = normalizePath2(filePath2);
+            if (exclude && comparePaths(filePath2, exclude, scriptDirectory, ignoreCase) === 0) {
               continue;
             }
             const { name, extension } = getFilenameWithExtensionOption(
-              getBaseFileName(filePath),
+              getBaseFileName(filePath2),
               program,
               extensionOptions,
               /*isExportsOrImportsWildcard*/
@@ -189595,8 +189640,8 @@ ${content}
         }
         return void 0;
       }
-      function getPackagePathComponents(filePath) {
-        const components = getPathComponents(filePath);
+      function getPackagePathComponents(filePath2) {
+        const components = getPathComponents(filePath2);
         const nodeModulesIdx = components.lastIndexOf("node_modules");
         if (nodeModulesIdx === -1) {
           return void 0;
@@ -201069,8 +201114,8 @@ ${options.prefix}` : "\n" : options.prefix
           this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);
         }
         /** @internal */
-        fileIsOpen(filePath) {
-          return this.projectService.openFiles.has(filePath);
+        fileIsOpen(filePath2) {
+          return this.projectService.openFiles.has(filePath2);
         }
         /** @internal */
         writeLog(s) {
@@ -215423,15 +215468,15 @@ function generateDashboard(result, outputPath) {
   writeFileSync10(outputPath, html, "utf8");
   return outputPath;
 }
-function openDashboard(filePath) {
+function openDashboard(filePath2) {
   const platform = process.platform;
   let cmd;
   if (platform === "darwin") {
-    cmd = `open "${filePath}"`;
+    cmd = `open "${filePath2}"`;
   } else if (platform === "linux") {
-    cmd = `xdg-open "${filePath}"`;
+    cmd = `xdg-open "${filePath2}"`;
   } else if (platform === "win32") {
-    cmd = `start "" "${filePath}"`;
+    cmd = `start "" "${filePath2}"`;
   } else {
     return;
   }
@@ -215723,11 +215768,11 @@ function safeJsonParse(json, stepName, validator, logger) {
     parsed = JSON.parse(json);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    if (logger) logger.warn("analysis", stepName, `JSON parse: ${msg}`);
+    if (logger) logger.warn(stepName, `JSON parse: ${msg}`);
   }
   const result = validator(parsed);
   if (!result.ok) {
-    if (logger) logger.warn("analysis", stepName, `validation: ${result.errors.join("; ")}`);
+    if (logger) logger.warn(stepName, `validation: ${result.errors.join("; ")}`);
     if (result.partial !== void 0) return result.partial;
     return null;
   }
@@ -216742,13 +216787,13 @@ async function attributeWithLLM(data, steps, stats, meta, graphStore, attributio
     statsSummary,
     recoveryArcs
   );
-  if (logger) logger.info("analysis", "RuleAttribution", `Prompt size: ${prompt.length} chars, graph ${graphSnapshot ? `${graphSnapshot.dataFlows.length} dataFlows, ${graphSnapshot.subtasks.length} subtasks` : "none"}`);
+  if (logger) logger.info("RuleAttribution", `Prompt size: ${prompt.length} chars, graph ${graphSnapshot ? `${graphSnapshot.dataFlows.length} dataFlows, ${graphSnapshot.subtasks.length} subtasks` : "none"}`);
   let rawOutput;
   let rulesOutput = [];
   try {
     rawOutput = await callLLM(RULE_ATTRIBUTION_SYSTEM, prompt, harness, 16384);
   } catch (err) {
-    if (logger) logger.warn("analysis", "RuleAttribution", `LLM call failed: ${err.message}`);
+    if (logger) logger.warn("RuleAttribution", `LLM call failed: ${err.message}`);
     return [];
   }
   for (let attempt = 0; attempt < 2; attempt++) {
@@ -216760,11 +216805,11 @@ async function attributeWithLLM(data, steps, stats, meta, graphStore, attributio
           rawOutput = await callLLM(RULE_ATTRIBUTION_SYSTEM, retryPrompt, harness, 16384);
           continue;
         } catch {
-          if (logger) logger.warn("analysis", "RuleAttribution", "Retry LLM call failed");
+          if (logger) logger.warn("RuleAttribution", "Retry LLM call failed");
           return [];
         }
       }
-      if (logger) logger.warn("analysis", "RuleAttribution", "No JSON found in LLM response after retry");
+      if (logger) logger.warn("RuleAttribution", "No JSON found in LLM response after retry");
       return [];
     }
     let parsed;
@@ -216802,7 +216847,7 @@ Output the FULL corrected JSON array.`;
         rawOutput = await callLLM(RULE_ATTRIBUTION_SYSTEM, retryPrompt, harness, 16384);
         continue;
       } catch {
-        if (logger) logger.warn("analysis", "RuleAttribution", "Validation retry failed");
+        if (logger) logger.warn("RuleAttribution", "Validation retry failed");
         break;
       }
     }
@@ -216816,11 +216861,11 @@ Output the FULL corrected JSON array.`;
           rawOutput = await callLLM(RULE_ATTRIBUTION_SYSTEM, retryPrompt, harness, 16384);
           continue;
         } catch {
-          if (logger) logger.warn("analysis", "RuleAttribution", "Retry LLM call failed");
+          if (logger) logger.warn("RuleAttribution", "Retry LLM call failed");
           return [];
         }
       }
-      if (logger) logger.warn("analysis", "RuleAttribution", "No JSON found in LLM response after retry");
+      if (logger) logger.warn("RuleAttribution", "No JSON found in LLM response after retry");
       return [];
     }
     const parsed = safeJsonParse(json, "rule-attribution", validateHarnessRuleOutputs);
@@ -216836,14 +216881,14 @@ Output the FULL corrected JSON array.`;
         rawOutput = await callLLM(RULE_ATTRIBUTION_SYSTEM, retryPrompt, harness, 16384);
         continue;
       } catch {
-        if (logger) logger.warn("analysis", "RuleAttribution", "Validation retry failed");
+        if (logger) logger.warn("RuleAttribution", "Validation retry failed");
         return [];
       }
     }
   }
-  if (logger) logger.info("analysis", "RuleAttribution", `Generated ${rulesOutput.length} rules`);
+  if (logger) logger.info("RuleAttribution", `Generated ${rulesOutput.length} rules`);
   if (rulesOutput.length === 0) {
-    if (logger) logger.info("analysis", "RuleAttribution", `Raw LLM response (first 500): ${rawOutput.slice(0, 500)}`);
+    if (logger) logger.info("RuleAttribution", `Raw LLM response (first 500): ${rawOutput.slice(0, 500)}`);
   }
   return rulesOutput.map((r) => ({
     id: r.id,
@@ -218393,9 +218438,9 @@ function writeLibraryMetadata(skeleton, workspacePath) {
     `| Screenshots Taken | ${stats.screenshotsTaken} |`,
     ""
   ].join("\n");
-  const filePath = join24(workspacePath, "library", "meta.md");
-  writeFileSync12(filePath, content, "utf-8");
-  return filePath;
+  const filePath2 = join24(workspacePath, "library", "meta.md");
+  writeFileSync12(filePath2, content, "utf-8");
+  return filePath2;
 }
 function writeLibrarySkeleton(skeleton, workspacePath) {
   const lines = [];
@@ -218458,9 +218503,9 @@ function writeLibrarySkeleton(skeleton, workspacePath) {
   }
   lines.push(hints.join("\n"));
   lines.push("");
-  const filePath = join24(workspacePath, "library", "skeleton.md");
-  writeFileSync12(filePath, lines.join("\n"), "utf-8");
-  return filePath;
+  const filePath2 = join24(workspacePath, "library", "skeleton.md");
+  writeFileSync12(filePath2, lines.join("\n"), "utf-8");
+  return filePath2;
 }
 function writeLibrarySignals(skeleton, workspacePath) {
   const typeOrder = [
@@ -218504,9 +218549,9 @@ function writeLibrarySignals(skeleton, workspacePath) {
     lines.push("_No signal anchors detected._");
     lines.push("");
   }
-  const filePath = join24(workspacePath, "library", "signals.md");
-  writeFileSync12(filePath, lines.join("\n"), "utf-8");
-  return filePath;
+  const filePath2 = join24(workspacePath, "library", "signals.md");
+  writeFileSync12(filePath2, lines.join("\n"), "utf-8");
+  return filePath2;
 }
 function writeLibraryDataItems(skeleton, workspacePath) {
   const sorted = [...skeleton.dataItems].sort((a, b) => b.operationCount - a.operationCount);
@@ -218527,9 +218572,9 @@ function writeLibraryDataItems(skeleton, workspacePath) {
       lines.push("");
     }
   }
-  const filePath = join24(workspacePath, "library", "data-items.md");
-  writeFileSync12(filePath, lines.join("\n"), "utf-8");
-  return filePath;
+  const filePath2 = join24(workspacePath, "library", "data-items.md");
+  writeFileSync12(filePath2, lines.join("\n"), "utf-8");
+  return filePath2;
 }
 function writeLibrarySteps(steps, phases, workspacePath) {
   const MAX_STEPS_PER_FILE = 150;
@@ -218570,9 +218615,9 @@ function writeLibrarySteps(steps, phases, workspacePath) {
         }
         lines.push("");
       }
-      const filePath = join24(workspacePath, "library", "steps", fileName);
-      writeFileSync12(filePath, lines.join("\n"), "utf-8");
-      written.push(filePath);
+      const filePath2 = join24(workspacePath, "library", "steps", fileName);
+      writeFileSync12(filePath2, lines.join("\n"), "utf-8");
+      written.push(filePath2);
     }
   }
   return written;
@@ -218654,9 +218699,9 @@ function writeLibraryReadme(phase, workspacePath) {
     "- `glob(pattern)` \u2014 list files matching a pattern in library/ or notebook/",
     ""
   ].join("\n");
-  const filePath = join24(workspacePath, "library", "README.md");
-  writeFileSync12(filePath, content, "utf-8");
-  return filePath;
+  const filePath2 = join24(workspacePath, "library", "README.md");
+  writeFileSync12(filePath2, content, "utf-8");
+  return filePath2;
 }
 function writeLibrary(skeleton, steps, ruleResult, phase, workspacePath) {
   let fileCount = 0;
@@ -218750,7 +218795,7 @@ var init_progress = __esm({
           this.logProgressBar();
         }
         if (this.logger) {
-          this.logger.info("analysis", "Progress", label);
+          this.logger.info("Progress", label);
         }
       }
       onPhaseProgress(phaseIndex, event, subZoneId) {
@@ -218789,7 +218834,7 @@ var init_progress = __esm({
         this.emitWebEvent("phaseDone", { phaseIndex, summary, durationMs });
         if (summary) {
           if (this.onLog) this.onLog(`\u2713 ${summary}`);
-          if (this.logger) this.logger.info("analysis", "Progress", `Phase ${phaseIndex} done: ${summary}`);
+          if (this.logger) this.logger.info("Progress", `Phase ${phaseIndex} done: ${summary}`);
         }
         this.logProgressBar();
       }
@@ -218814,7 +218859,7 @@ var init_progress = __esm({
           this.logProgressBar();
         }
         if (this.logger) {
-          this.logger.info("analysis", "Progress", msg);
+          this.logger.info("Progress", msg);
         }
       }
       dispose() {
@@ -218916,7 +218961,7 @@ async function runFocusPipeline(data, harness, sessionStats, onLog, logger) {
   }
   const pipelineStart = Date.now();
   let totalLLMCalls = 0;
-  if (logger) logger.info("analysis", "FocusPipeline", `Start: ${steps.length} steps, session ${sessionId.slice(0, 8)}`);
+  if (logger) logger.info("FocusPipeline", `Start: ${steps.length} steps, session ${sessionId.slice(0, 8)}`);
   const progress = new ProgressDisplay({ onLog, logger });
   progress.onPhaseStart(0);
   await yieldTui();
@@ -218936,7 +218981,7 @@ async function runFocusPipeline(data, harness, sessionStats, onLog, logger) {
   const workspacePath = createWorkspace(sessionId);
   const { fileCount } = writeLibrary(skeleton, steps, ruleResult, "SCAN", workspacePath);
   cleanOldWorkspaces(10);
-  if (logger) logger.info("analysis", "Phase0", `Library: ${fileCount} files \u2192 ${workspacePath}`);
+  if (logger) logger.info("Phase0", `Library: ${fileCount} files \u2192 ${workspacePath}`);
   progress.onPhaseDone(0, `\u5199\u5165 ${fileCount} \u4E2A\u6587\u4EF6`, Date.now() - pipelineStart);
   await yieldTui();
   progress.onPhaseStart(1);
@@ -218944,7 +218989,7 @@ async function runFocusPipeline(data, harness, sessionStats, onLog, logger) {
   const scanResult = await scanSession(skeleton, harness, workspacePath, sessionId, progress);
   totalLLMCalls++;
   const scanSummary = scanResult.noIssuesDetected ? "\u672A\u68C0\u6D4B\u5230\u95EE\u9898" : `\u8BC6\u522B\u5230 ${scanResult.zones.length} \u4E2A attention zones: ${scanResult.zones.map((z) => z.id).join(", ")}`;
-  if (logger) logger.info("analysis", "SCAN", scanSummary);
+  if (logger) logger.info("SCAN", scanSummary);
   progress.onPhaseDone(1, scanSummary, Date.now() - pipelineStart);
   await yieldTui();
   if (scanResult.noIssuesDetected || scanResult.zones.length === 0) {
@@ -218961,7 +219006,7 @@ async function runFocusPipeline(data, harness, sessionStats, onLog, logger) {
       Date.now(),
       logger
     );
-    if (logger) logger.info("analysis", "FocusPipeline", "Early exit: no issues detected");
+    if (logger) logger.info("FocusPipeline", "Early exit: no issues detected");
     return { ...sessionStats, phases: [], deviations: [], rootCauses: [], rules: rules2, timeline: [], causalGraph: null, attribution: null, rulesApplied: [] };
   }
   progress.onPhaseStart(2);
@@ -218980,7 +219025,7 @@ async function runFocusPipeline(data, harness, sessionStats, onLog, logger) {
       zoneAnalyses.push({ zoneId: zone.id, subtasks: [], subtaskEdges: [], agentNodes: [], agentEdges: [], stepDataFlows: [], candidates: [], topCandidate: null, zoneGraphComplete: false });
     }
   }
-  if (logger) logger.info("analysis", "ZOOM", `${zoneAnalyses.length} zones, ${zoneAnalyses.filter((z) => z.zoneGraphComplete).length} complete`);
+  if (logger) logger.info("ZOOM", `${zoneAnalyses.length} zones, ${zoneAnalyses.filter((z) => z.zoneGraphComplete).length} complete`);
   progress.onPhaseDone(2, `${zoneAnalyses.length} zones \u5206\u6790\u5B8C\u6210`, Date.now() - pipelineStart);
   await yieldTui();
   progress.onPhaseStart(3);
@@ -218996,7 +219041,7 @@ async function runFocusPipeline(data, harness, sessionStats, onLog, logger) {
   );
   totalLLMCalls++;
   const synthSummary = attribution.mistakeStep > 0 ? `\u6839\u56E0: ${attribution.mistakeAgent}@Step ${attribution.mistakeStep}` : "\u5F52\u56E0\u5B8C\u6210";
-  if (logger) logger.info("analysis", "SYNTH", synthSummary);
+  if (logger) logger.info("SYNTH", synthSummary);
   progress.onPhaseDone(3, synthSummary, Date.now() - pipelineStart);
   await yieldTui();
   progress.onPhaseStart(4);
@@ -219017,11 +219062,11 @@ async function runFocusPipeline(data, harness, sessionStats, onLog, logger) {
     sessionStats.metadata.sessionId,
     Date.now()
   );
-  if (logger) logger.info("analysis", "Phase4", `${rules.length} rules extracted`);
+  if (logger) logger.info("Phase4", `${rules.length} rules extracted`);
   progress.onPhaseDone(4, `${rules.length} \u6761\u89C4\u5219`, Date.now() - pipelineStart);
   const totalDuration = Date.now() - pipelineStart;
   const keyFindings = attribution.mistakeStep > 0 ? `\u6839\u56E0: ${attribution.mistakeAgent}@Step ${attribution.mistakeStep}` : "\u672A\u68C0\u6D4B\u5230\u660E\u786E\u6839\u56E0";
-  if (logger) logger.info("analysis", "FocusPipeline", `Done: ${(totalDuration / 1e3).toFixed(1)}s, ${totalLLMCalls} LLM calls, ${keyFindings}`);
+  if (logger) logger.info("FocusPipeline", `Done: ${(totalDuration / 1e3).toFixed(1)}s, ${totalLLMCalls} LLM calls, ${keyFindings}`);
   progress.showCompletion({ totalDurationMs: totalDuration, totalLLMCalls, keyFindings });
   progress.dispose();
   const report = { skeleton, scan: scanResult, zoneAnalyses, attribution, totalLLMCalls };
@@ -219134,11 +219179,11 @@ async function executeStep1(steps, question, harness, logger) {
     const prev = result[i];
     const next = result[i + 1];
     if (prev.stepEnd >= next.stepStart) {
-      if (logger) logger.warn("analysis", "Step1", `Fixing overlap: ${prev.id} (${prev.stepStart}-${prev.stepEnd}) overlaps ${next.id} (${next.stepStart}-${next.stepEnd}), truncating ${prev.id}.stepEnd to ${next.stepStart - 1}`);
+      if (logger) logger.warn("Step1", `Fixing overlap: ${prev.id} (${prev.stepStart}-${prev.stepEnd}) overlaps ${next.id} (${next.stepStart}-${next.stepEnd}), truncating ${prev.id}.stepEnd to ${next.stepStart - 1}`);
       prev.stepEnd = next.stepStart - 1;
     }
     if (prev.stepEnd + 1 < next.stepStart) {
-      if (logger) logger.warn("analysis", "Step1", `Filling gap: gap ${prev.stepEnd + 1}-${next.stepStart - 1} between ${prev.id} and ${next.id}, extending ${prev.id}.stepEnd to ${next.stepStart - 1}`);
+      if (logger) logger.warn("Step1", `Filling gap: gap ${prev.stepEnd + 1}-${next.stepStart - 1} between ${prev.id} and ${next.id}, extending ${prev.id}.stepEnd to ${next.stepStart - 1}`);
       prev.stepEnd = next.stepStart - 1;
     }
   }
@@ -219191,16 +219236,16 @@ async function executeStep3(subtasks, steps, harness, logger) {
       const prompt = buildStep3SingleSubtaskPrompt(subtask, steps, subtasks);
       const flows = await callAndValidate(harness, prompt, validateStepDataFlows, 4096, `Step 3 / ${subtask.id}`);
       allFlows.push(...flows);
-      if (logger) logger.info("analysis", "Step3", `Subtask ${subtask.id}: ${flows.length} data flows extracted`);
+      if (logger) logger.info("Step3", `Subtask ${subtask.id}: ${flows.length} data flows extracted`);
     } catch (err) {
-      if (logger) logger.warn("analysis", "Step3", `Subtask ${subtask.id}: ${err instanceof Error ? err.message : String(err)}`);
+      if (logger) logger.warn("Step3", `Subtask ${subtask.id}: ${err instanceof Error ? err.message : String(err)}`);
       failedSubtasks++;
     }
   }
   if (failedSubtasks > 0) {
-    if (logger) logger.warn("analysis", "Step3", `${failedSubtasks}/${subtasks.length} subtasks failed to produce data flows`);
+    if (logger) logger.warn("Step3", `${failedSubtasks}/${subtasks.length} subtasks failed to produce data flows`);
   }
-  if (logger) logger.info("analysis", "Step3", `Subtask summary: ${allFlows.length} total data flows from ${subtasks.length - failedSubtasks}/${subtasks.length} subtasks`);
+  if (logger) logger.info("Step3", `Subtask summary: ${allFlows.length} total data flows from ${subtasks.length - failedSubtasks}/${subtasks.length} subtasks`);
   return { agents, dataFlows: allFlows };
 }
 async function executeStep4(subtasks, agentNodes, harness) {
@@ -219407,7 +219452,7 @@ function loadRuleStore(projectPath, logger) {
       updatedAt: parsed.updatedAt ?? Date.now()
     };
   } catch (err) {
-    if (logger) logger.warn("analysis", "RuleStore", `Failed to load rules.json, starting fresh: ${err.message}`);
+    if (logger) logger.warn("RuleStore", `Failed to load rules.json, starting fresh: ${err.message}`);
     return createEmptyStore(projectPath);
   }
 }
@@ -219418,7 +219463,7 @@ function saveRuleStore(store, logger) {
     store.updatedAt = Date.now();
     writeFileSync13(path, JSON.stringify(store, null, 2), "utf8");
   } catch (err) {
-    if (logger) logger.error("analysis", "RuleStore", `Failed to save rules.json: ${err.message}`);
+    if (logger) logger.error("RuleStore", `Failed to save rules.json: ${err.message}`);
   }
 }
 function createEmptyStore(projectPath) {
@@ -219476,7 +219521,7 @@ async function semanticMerge(newRules, existingStore, harness, logger) {
           rawOutput = await callMergeLLM(RULE_MERGE_SYSTEM, prompt + "\n\n\u26A0 Output PURE JSON array only.", harness);
           continue;
         }
-        if (logger) logger.warn("analysis", "RuleStore", "No JSON in merge LLM response, adding all as new");
+        if (logger) logger.warn("RuleStore", "No JSON in merge LLM response, adding all as new");
         break;
       }
       const parsed = validateMergeDecisions(JSON.parse(json));
@@ -219494,10 +219539,10 @@ async function semanticMerge(newRules, existingStore, harness, logger) {
         );
         continue;
       }
-      if (logger) logger.warn("analysis", "RuleStore", `Merge validation failed: ${parsed.errors.join("; ")}`);
+      if (logger) logger.warn("RuleStore", `Merge validation failed: ${parsed.errors.join("; ")}`);
     }
   } catch (err) {
-    if (logger) logger.warn("analysis", "RuleStore", `Semantic merge LLM call failed, adding all as new: ${err.message}`);
+    if (logger) logger.warn("RuleStore", `Semantic merge LLM call failed, adding all as new: ${err.message}`);
   }
   const merged = { ...existingStore.rules };
   const decisionMap = new Map(decisions.map((d) => [d.newRuleId, d]));
@@ -219578,7 +219623,7 @@ async function runEval(sessionId, ctx) {
         }
       }
     }
-    evalLogger.clear("analysis");
+    evalLogger.clear();
     ui.addInfo(`\u6B63\u5728\u5206\u6790 session ${resolvedId.slice(0, 8)}...`);
     const onLog = (msg) => {
       ui.addInfo(msg);
@@ -219604,9 +219649,9 @@ async function runEval(sessionId, ctx) {
 [${analysisLabel}] Messages: ${result.metadata.totalMessages} | Tool calls: ${result.stats.toolCalls} | Error rate: ${result.stats.errorRate}${attributionInfo} | Rules: ${rulesTriggered}`
     );
   } catch (err) {
-    evalLogger.error("analysis", "Pipeline", `crash: ${err instanceof Error ? err.message : String(err)}`);
+    evalLogger.error("Pipeline", `crash: ${err instanceof Error ? err.message : String(err)}`);
     if (err instanceof Error && err.stack) {
-      evalLogger.error("analysis", "Pipeline", `stack:
+      evalLogger.error("Pipeline", `stack:
 ${err.stack}`);
     }
     ui.addError(`eval: ${err instanceof Error ? err.message : String(err)}`);
@@ -220624,18 +220669,18 @@ function safeResolveWithin(projectPath, relPath) {
   }
   return resolved;
 }
-function isTextPath(filePath) {
-  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+function isTextPath(filePath2) {
+  const ext = filePath2.slice(filePath2.lastIndexOf(".")).toLowerCase();
   if (BINARY_EXTENSIONS.has(ext)) return false;
   if (TEXT_EXTENSIONS.has(ext)) return true;
   return false;
 }
-function isImagePath(filePath) {
-  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+function isImagePath(filePath2) {
+  const ext = filePath2.slice(filePath2.lastIndexOf(".")).toLowerCase();
   return IMAGE_EXTENSIONS.has(ext);
 }
-function imageMimeType(filePath) {
-  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+function imageMimeType(filePath2) {
+  const ext = filePath2.slice(filePath2.lastIndexOf(".")).toLowerCase();
   return IMAGE_MIME_MAP[ext] ?? "image/png";
 }
 function isBinaryContent(buf) {
@@ -220645,8 +220690,8 @@ function isBinaryContent(buf) {
   }
   return false;
 }
-function inferLanguage(filePath) {
-  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+function inferLanguage(filePath2) {
+  const ext = filePath2.slice(filePath2.lastIndexOf(".")).toLowerCase();
   return LANG_MAP[ext] ?? "";
 }
 function isLikelyFilePath(text) {
@@ -221570,8 +221615,8 @@ __export(web_backend_exports, {
   WebUiBackend: () => WebUiBackend
 });
 import { createServer, request as httpRequest2 } from "node:http";
-import { readFileSync as readFileSync21, existsSync as existsSync24, mkdirSync as mkdirSync13, writeFileSync as writeFileSync14, rmSync as rmSync3, readdirSync as readdirSync9, statSync as statSync5 } from "node:fs";
-import { join as join29, extname as extname2, resolve as resolve10 } from "node:path";
+import { readFileSync as readFileSync22, existsSync as existsSync25, mkdirSync as mkdirSync13, writeFileSync as writeFileSync15, rmSync as rmSync3, readdirSync as readdirSync9, statSync as statSync5 } from "node:fs";
+import { join as join30, extname as extname2, resolve as resolve10 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function extractImagesFromToolResult(result) {
   if (!result || typeof result !== "object") return void 0;
@@ -221631,8 +221676,8 @@ var init_web_backend = __esm({
       lastArtifactHtml = "";
       isAssistantTurn = false;
       cleanupUploadDir(sessionId) {
-        const uploadDir = join29(this.config.projectPath, ".dscode", "uploads", sessionId);
-        if (existsSync24(uploadDir)) {
+        const uploadDir = join30(this.config.projectPath, ".dscode", "uploads", sessionId);
+        if (existsSync25(uploadDir)) {
           try {
             rmSync3(uploadDir, { recursive: true, force: true });
           } catch {
@@ -222021,13 +222066,13 @@ var init_web_backend = __esm({
               const sm = this.harness.sessionManager;
               const sessionId = sm.getCurrentSessionId?.() ?? "default";
               const ts = Date.now();
-              const uploadDir = join29(this.config.projectPath, ".dscode", "uploads", sessionId);
+              const uploadDir = join30(this.config.projectPath, ".dscode", "uploads", sessionId);
               mkdirSync13(uploadDir, { recursive: true });
               const tempPaths = [];
               for (const uf of cmd.uploadedFiles) {
                 const tempName = `${ts}-${uf.name}`;
-                const tempPath = join29(uploadDir, tempName);
-                writeFileSync14(tempPath, Buffer.from(uf.content, "base64"));
+                const tempPath = join30(uploadDir, tempName);
+                writeFileSync15(tempPath, Buffer.from(uf.content, "base64"));
                 tempPaths.push(tempPath);
               }
               if (tempPaths.length > 0) {
@@ -222113,7 +222158,7 @@ ${refsResolved.text}` : refsResolved.text;
                   mimeType: img.mimeType
                 }));
                 this.pendingImages = [];
-                this.harness.logger.info("tool", "web-backend", `promptWithImages: textLen=${text.length}, images=${imageContents.length}, img[0].dataLen=${imageContents[0]?.data?.length ?? 0}, mime=${imageContents[0]?.mimeType ?? "?"}`);
+                this.harness.logger.info("WebBackend", `promptWithImages: textLen=${text.length}, images=${imageContents.length}, img[0].dataLen=${imageContents[0]?.data?.length ?? 0}, mime=${imageContents[0]?.mimeType ?? "?"}`);
                 await this.harness.promptWithImages(text, imageContents);
               } else {
                 this.pendingImages = [];
@@ -222142,7 +222187,7 @@ ${refsResolved.text}` : refsResolved.text;
                   fuzzyPattern: fuzzy,
                   permissionArgs: this.currentPermissionArgs
                 };
-                this.harness.logger.info("session", "WebBackend", "saving pendingPermission to metadata, then denying");
+                this.harness.logger.info("WebBackend", "saving pendingPermission to metadata, then denying");
                 sm.saveSession(this.harness.agent, meta.pendingPermission);
               }
               this.permissionResolve({ decision: "deny" });
@@ -222272,9 +222317,9 @@ ${refsResolved.text}` : refsResolved.text;
         }
       }
       handleCache(client, cmd) {
-        const uploadsDir = join29(this.config.projectPath, ".dscode", "uploads");
+        const uploadsDir = join30(this.config.projectPath, ".dscode", "uploads");
         if (cmd.action === "clear") {
-          if (existsSync24(uploadsDir)) {
+          if (existsSync25(uploadsDir)) {
             try {
               rmSync3(uploadsDir, { recursive: true, force: true });
             } catch {
@@ -222286,16 +222331,16 @@ ${refsResolved.text}` : refsResolved.text;
         let totalBytes = 0;
         let fileCount = 0;
         let sessionCount = 0;
-        if (existsSync24(uploadsDir)) {
+        if (existsSync25(uploadsDir)) {
           const sessionDirs = readdirSync9(uploadsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
           sessionCount = sessionDirs.length;
           for (const dir of sessionDirs) {
-            const sessionPath = join29(uploadsDir, dir.name);
+            const sessionPath = join30(uploadsDir, dir.name);
             const files = readdirSync9(sessionPath, { withFileTypes: true });
             for (const f of files) {
               if (f.isFile()) {
                 try {
-                  const st = statSync5(join29(sessionPath, f.name));
+                  const st = statSync5(join30(sessionPath, f.name));
                   totalBytes += st.size;
                   fileCount++;
                 } catch {
@@ -222630,15 +222675,15 @@ ${matchList}` });
               const meta = sessionManager.getCurrentMetadata();
               if (meta?.pendingPermission) {
                 pendingPermission = meta.pendingPermission;
-                this.harness.logger.info("session", "WebBackend", "using pendingPermission from metadata");
+                this.harness.logger.info("WebBackend", "using pendingPermission from metadata");
               }
             }
             this.harness.abort();
             if (pendingPermission) {
-              this.harness.logger.info("session", "WebBackend", `saving with pendingPermission: ${JSON.stringify(pendingPermission)}`);
+              this.harness.logger.info("WebBackend", `saving with pendingPermission: ${JSON.stringify(pendingPermission)}`);
               sessionManager.saveSession(agent, pendingPermission);
             } else {
-              this.harness.logger.info("session", "WebBackend", "saving without pendingPermission");
+              this.harness.logger.info("WebBackend", "saving without pendingPermission");
               this.harness.saveSessionNow();
             }
             const result = await sessionManager.loadSession(match.id, agent);
@@ -222881,15 +222926,15 @@ ${matchList}` });
         req.pipe(proxyReq);
       }
       serveSpa(req, res) {
-        const projectDist = join29(resolve10(this.projectRoot), "dist", "web");
-        const moduleDist = join29(fileURLToPath3(new URL(".", import.meta.url)), "web");
-        const webDist = existsSync24(projectDist) ? projectDist : moduleDist;
-        let filePath = join29(webDist, req.url === "/" ? "index.html" : req.url);
-        const qIdx = filePath.indexOf("?");
-        if (qIdx >= 0) filePath = filePath.slice(0, qIdx);
-        const hIdx = filePath.indexOf("#");
-        if (hIdx >= 0) filePath = filePath.slice(0, hIdx);
-        const ext = extname2(filePath);
+        const projectDist = join30(resolve10(this.projectRoot), "dist", "web");
+        const moduleDist = join30(fileURLToPath3(new URL(".", import.meta.url)), "web");
+        const webDist = existsSync25(projectDist) ? projectDist : moduleDist;
+        let filePath2 = join30(webDist, req.url === "/" ? "index.html" : req.url);
+        const qIdx = filePath2.indexOf("?");
+        if (qIdx >= 0) filePath2 = filePath2.slice(0, qIdx);
+        const hIdx = filePath2.indexOf("#");
+        if (hIdx >= 0) filePath2 = filePath2.slice(0, hIdx);
+        const ext = extname2(filePath2);
         const mimeTypes = {
           ".html": "text/html",
           ".js": "application/javascript",
@@ -222902,12 +222947,12 @@ ${matchList}` });
           ".woff": "font/woff"
         };
         try {
-          if (existsSync24(filePath) && ext) {
-            const content = readFileSync21(filePath);
+          if (existsSync25(filePath2) && ext) {
+            const content = readFileSync22(filePath2);
             res.writeHead(200, { "Content-Type": mimeTypes[ext] ?? "application/octet-stream" });
             res.end(content);
           } else {
-            const html = readFileSync21(join29(webDist, "index.html"));
+            const html = readFileSync22(join30(webDist, "index.html"));
             res.writeHead(200, { "Content-Type": "text/html" });
             res.end(html);
           }
@@ -222920,9 +222965,9 @@ ${matchList}` });
         try {
           let styleConstraints = "";
           try {
-            const skillPath = join29(this.config.projectPath, ".dscode", "html_output_skill");
-            if (existsSync24(skillPath)) {
-              styleConstraints = readFileSync21(skillPath, "utf-8");
+            const skillPath = join30(this.config.projectPath, ".dscode", "html_output_skill");
+            if (existsSync25(skillPath)) {
+              styleConstraints = readFileSync22(skillPath, "utf-8");
             }
           } catch {
           }
@@ -223007,6 +223052,10 @@ Modify the HTML to fulfill the user's request. Output the complete modified HTML
             }
           }
           fullHtml = this.stripArtifactFences(fullHtml);
+          try {
+            writeFileSync15(join30(this.config.projectPath, "_artifact_debug.html"), fullHtml, "utf-8");
+          } catch {
+          }
           this.lastArtifactHtml = fullHtml;
           client.send({ type: "artifact_end" });
         } catch (err) {
@@ -223140,8 +223189,8 @@ Modify the HTML to fulfill the user's request. Output the complete modified HTML
 
 // src/core/main.ts
 init_config();
-import { existsSync as existsSync25, readFileSync as readFileSync22 } from "node:fs";
-import { dirname as dirname7, join as join30, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync26, readFileSync as readFileSync23 } from "node:fs";
+import { dirname as dirname7, join as join31, resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { randomBytes } from "node:crypto";
 
@@ -224143,13 +224192,13 @@ var CheckpointManager = class {
     return this.baseCommit;
   }
   /** Save a checkpoint of the file before modification. */
-  save(filePath, writerType) {
-    const fileExists4 = existsSync7(filePath);
-    const content = fileExists4 ? readFileSync6(filePath) : null;
-    this.store.delete(filePath);
+  save(filePath2, writerType) {
+    const fileExists4 = existsSync7(filePath2);
+    const content = fileExists4 ? readFileSync6(filePath2) : null;
+    this.store.delete(filePath2);
     this.store.save(
       {
-        filePath,
+        filePath: filePath2,
         baseCommit: this.baseCommit,
         writerType,
         timestamp: Date.now(),
@@ -224160,31 +224209,31 @@ var CheckpointManager = class {
     );
   }
   /** Restore file from its checkpoint and remove the checkpoint. */
-  rollback(filePath) {
-    const entry = this.store.load(filePath);
+  rollback(filePath2) {
+    const entry = this.store.load(filePath2);
     if (!entry) {
-      throw new Error(`No checkpoint found for ${filePath}`);
+      throw new Error(`No checkpoint found for ${filePath2}`);
     }
     if (entry.content !== null) {
-      const parentDir = dirname(filePath);
+      const parentDir = dirname(filePath2);
       if (!existsSync7(parentDir)) {
         mkdirSync6(parentDir, { recursive: true });
       }
-      writeFileSync6(filePath, entry.content);
+      writeFileSync6(filePath2, entry.content);
     } else {
-      if (existsSync7(filePath)) {
-        unlinkSync2(filePath);
+      if (existsSync7(filePath2)) {
+        unlinkSync2(filePath2);
       }
     }
-    this.store.delete(filePath);
+    this.store.delete(filePath2);
   }
   /** Commit (remove) the checkpoint after a successful write. */
-  commit(filePath) {
-    this.store.delete(filePath);
+  commit(filePath2) {
+    this.store.delete(filePath2);
   }
   /** Check if a file has an uncommitted checkpoint. */
-  isDirty(filePath) {
-    return this.store.load(filePath) !== null;
+  isDirty(filePath2) {
+    return this.store.load(filePath2) !== null;
   }
   /** List all file paths with uncommitted checkpoints. */
   listDirty() {
@@ -224199,20 +224248,20 @@ var CheckpointManager = class {
 // src/checkpoint/write-tracker.ts
 var FileWriteTracker = class {
   writers = /* @__PURE__ */ new Map();
-  recordWrite(filePath, writerType) {
-    this.writers.set(filePath, writerType);
+  recordWrite(filePath2, writerType) {
+    this.writers.set(filePath2, writerType);
   }
-  getWriter(filePath) {
-    return this.writers.get(filePath) ?? null;
+  getWriter(filePath2) {
+    return this.writers.get(filePath2) ?? null;
   }
-  getContinuity(filePath, currentWriter) {
-    const prev = this.writers.get(filePath);
+  getContinuity(filePath2, currentWriter) {
+    const prev = this.writers.get(filePath2);
     if (prev === void 0 || prev === currentWriter) return "clean";
     return "mixed";
   }
   /** Mark a file as having been written by bash (external/black-box writer). */
-  markExternalWrite(filePath) {
-    this.writers.set(filePath, "bash");
+  markExternalWrite(filePath2) {
+    this.writers.set(filePath2, "bash");
     return { anchorInvalidated: true };
   }
 };
@@ -224226,11 +224275,11 @@ var FileSystemCheckpointStore = class {
     this.baseDir = baseDir;
     mkdirSync7(this.baseDir, { recursive: true });
   }
-  safeName(filePath) {
-    return filePath.replace(/[\/\\:]/g, "_").replace(/^_+/, "");
+  safeName(filePath2) {
+    return filePath2.replace(/[\/\\:]/g, "_").replace(/^_+/, "");
   }
-  findCheckpointDir(filePath) {
-    const prefix = this.safeName(filePath) + "-";
+  findCheckpointDir(filePath2) {
+    const prefix = this.safeName(filePath2) + "-";
     if (!existsSync8(this.baseDir)) return null;
     let entries;
     try {
@@ -224258,8 +224307,8 @@ var FileSystemCheckpointStore = class {
       writeFileSync7(join7(dir, "original"), content);
     }
   }
-  load(filePath) {
-    const dir = this.findCheckpointDir(filePath);
+  load(filePath2) {
+    const dir = this.findCheckpointDir(filePath2);
     if (!dir) return null;
     const metaPath = join7(dir, "meta.json");
     const originalPath = join7(dir, "original");
@@ -224267,8 +224316,8 @@ var FileSystemCheckpointStore = class {
     const content = existsSync8(originalPath) ? readFileSync7(originalPath) : null;
     return { meta, content };
   }
-  delete(filePath) {
-    const dir = this.findCheckpointDir(filePath);
+  delete(filePath2) {
+    const dir = this.findCheckpointDir(filePath2);
     if (dir) {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -224321,27 +224370,27 @@ var SnapshotStore = class {
    * Record a snapshot of a file. Called after read_file returns hashed content
    * (so the model receives the file_version and can use it for later edits).
    */
-  record(filePath, fileVersion, content) {
-    const key = this.makeKey(filePath, fileVersion);
+  record(filePath2, fileVersion, content) {
+    const key = this.makeKey(filePath2, fileVersion);
     const existing = this.lruKeys.indexOf(key);
     if (existing >= 0) {
       this.lruKeys.splice(existing, 1);
       this.lruKeys.push(key);
-      const entries2 = this.byFile.get(filePath);
+      const entries2 = this.byFile.get(filePath2);
       const entry2 = entries2.find((e) => e.fileVersion === fileVersion);
       if (entry2) entry2.timestamp = Date.now();
       return;
     }
     const entry = {
-      filePath,
+      filePath: filePath2,
       fileVersion,
       content,
       timestamp: Date.now()
     };
-    let entries = this.byFile.get(filePath);
+    let entries = this.byFile.get(filePath2);
     if (!entries) {
       entries = [];
-      this.byFile.set(filePath, entries);
+      this.byFile.set(filePath2, entries);
     }
     entries.unshift(entry);
     while (entries.length > this.maxSnapshotsPerFile) {
@@ -224364,12 +224413,12 @@ var SnapshotStore = class {
    * Look up a snapshot by file path and version.
    * Returns the full file content or null if not found.
    */
-  lookup(filePath, fileVersion) {
-    const entries = this.byFile.get(filePath);
+  lookup(filePath2, fileVersion) {
+    const entries = this.byFile.get(filePath2);
     if (!entries) return null;
     const entry = entries.find((e) => e.fileVersion === fileVersion);
     if (!entry) return null;
-    const key = this.makeKey(filePath, fileVersion);
+    const key = this.makeKey(filePath2, fileVersion);
     const idx = this.lruKeys.indexOf(key);
     if (idx >= 0) {
       this.lruKeys.splice(idx, 1);
@@ -224381,13 +224430,13 @@ var SnapshotStore = class {
   /**
    * Remove all snapshots for a file (called after successful write_file / overwrite_file).
    */
-  invalidate(filePath) {
-    const entries = this.byFile.get(filePath);
+  invalidate(filePath2) {
+    const entries = this.byFile.get(filePath2);
     if (!entries) return;
     for (const e of entries) {
       this.removeFromLru(this.makeKey(e.filePath, e.fileVersion));
     }
-    this.byFile.delete(filePath);
+    this.byFile.delete(filePath2);
   }
   /** Remove all snapshots. */
   clear() {
@@ -224399,8 +224448,8 @@ var SnapshotStore = class {
     return this.lruKeys.length;
   }
   // --- Private helpers ---
-  makeKey(filePath, fileVersion) {
-    return `${filePath}::${fileVersion}`;
+  makeKey(filePath2, fileVersion) {
+    return `${filePath2}::${fileVersion}`;
   }
   parseKey(key) {
     const idx = key.lastIndexOf("::");
@@ -225506,17 +225555,17 @@ function buildDiffPreview(snapshotLines, expectedLines, currentLines, patch) {
 
 // src/drivers/edit/undo-store.ts
 var undoSnapshots = /* @__PURE__ */ new Map();
-function captureUndoSnapshot(filePath, content) {
-  undoSnapshots.set(filePath, content);
+function captureUndoSnapshot(filePath2, content) {
+  undoSnapshots.set(filePath2, content);
 }
-function getUndoSnapshot(filePath) {
-  return undoSnapshots.get(filePath);
+function getUndoSnapshot(filePath2) {
+  return undoSnapshots.get(filePath2);
 }
-function clearUndoSnapshot(filePath) {
-  undoSnapshots.delete(filePath);
+function clearUndoSnapshot(filePath2) {
+  undoSnapshots.delete(filePath2);
 }
-function hasUndoSnapshot(filePath) {
-  return undoSnapshots.has(filePath);
+function hasUndoSnapshot(filePath2) {
+  return undoSnapshots.has(filePath2);
 }
 
 // src/drivers/edit/syntax-validate.ts
@@ -225530,11 +225579,11 @@ var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([
   ".html",
   ".json"
 ]);
-function isSyntaxCheckSupported(filePath) {
-  return SUPPORTED_EXTENSIONS.has(extname(filePath).toLowerCase());
+function isSyntaxCheckSupported(filePath2) {
+  return SUPPORTED_EXTENSIONS.has(extname(filePath2).toLowerCase());
 }
-function getSyntaxTarget(filePath) {
-  const ext = extname(filePath).toLowerCase();
+function getSyntaxTarget(filePath2) {
+  const ext = extname(filePath2).toLowerCase();
   switch (ext) {
     case ".js":
       return { kind: "js" };
@@ -225565,8 +225614,8 @@ async function getTypeScript() {
   }
   return _tsModule;
 }
-async function validateSyntax(filePath, content) {
-  const target = getSyntaxTarget(filePath);
+async function validateSyntax(filePath2, content) {
+  const target = getSyntaxTarget(filePath2);
   if (!target) {
     return { valid: true };
   }
@@ -225910,7 +225959,7 @@ var editTool = {
       };
     }
     if (file_path && !path) {
-      _editLogger.warn("tool", "Edit", "file_path is deprecated, use path instead");
+      _editLogger.warn("Edit", "file_path is deprecated, use path instead");
     }
     const resolved = resolve4(effectivePath);
     if (!await fileExists3(resolved)) {
@@ -226838,10 +226887,10 @@ function stripBomAndDecode(buf) {
   }
   return buf.toString("utf8");
 }
-function parseSkillManifest(filePath, source) {
+function parseSkillManifest(filePath2, source) {
   let raw;
   try {
-    const buf = readFileSync9(filePath);
+    const buf = readFileSync9(filePath2);
     raw = stripBomAndDecode(buf);
   } catch {
     return null;
@@ -226858,7 +226907,7 @@ function parseSkillManifest(filePath, source) {
     tools: parsed.tools,
     instructions: body || void 0,
     source,
-    path: filePath
+    path: filePath2
   };
 }
 function parseFrontmatter(text) {
@@ -227153,10 +227202,10 @@ function stripBomAndDecode2(buf) {
 function normalizeName(name) {
   return name.toLowerCase().replace(/\s+/g, "");
 }
-function parseCommandFile(filePath, source, derivedName) {
+function parseCommandFile(filePath2, source, derivedName) {
   let raw;
   try {
-    const buf = readFileSync10(filePath);
+    const buf = readFileSync10(filePath2);
     raw = stripBomAndDecode2(buf);
   } catch {
     return null;
@@ -227170,7 +227219,7 @@ function parseCommandFile(filePath, source, derivedName) {
   if (!parsed.description) return null;
   if (parsed.name !== void 0 && normalizeName(parsed.name) !== normalizeName(derivedName)) {
     console.warn(
-      `[commands] Skipping ${filePath}: frontmatter name "${parsed.name}" does not match path-derived name "${derivedName}"`
+      `[commands] Skipping ${filePath2}: frontmatter name "${parsed.name}" does not match path-derived name "${derivedName}"`
     );
     return null;
   }
@@ -227179,7 +227228,7 @@ function parseCommandFile(filePath, source, derivedName) {
     description: parsed.description,
     body,
     source,
-    path: filePath
+    path: filePath2
   };
 }
 function parseFrontmatter2(text) {
@@ -227373,10 +227422,10 @@ var PermissionManager = class {
     const toolName = context.toolCall.name;
     const argsStr = JSON.stringify(context.args);
     if ((toolName === "read_file" || toolName === "write_file") && this.denyRegexes.length > 0) {
-      const filePath = context.args?.path;
-      if (filePath) {
+      const filePath2 = context.args?.path;
+      if (filePath2) {
         for (const { pattern, regex } of this.denyRegexes) {
-          if (regex.test(filePath)) {
+          if (regex.test(filePath2)) {
             return { block: true, reason: `Denied by file pattern: ${pattern}` };
           }
         }
@@ -227788,6 +227837,7 @@ var MCPClient = class {
       if (this.closing) return;
       if (!this.closed) {
         this.closed = true;
+        this.emit({ type: "disconnected", serverName: this.config.name, reason: `MCP server "${this.config.name}" exited with code ${code}` });
         setImmediate(() => {
           const stderr = stderrBuf.trim().slice(0, 500);
           const detail = stderr ? `: ${stderr}` : "";
@@ -227795,6 +227845,14 @@ var MCPClient = class {
         });
       }
     });
+    this.process.on("error", (err) => {
+      if (this.closing) return;
+      if (!this.closed) {
+        this.closed = true;
+        this.emit({ type: "disconnected", serverName: this.config.name, reason: `MCP server "${this.config.name}" error: ${err.message}` });
+        this.rejectAllPending(new Error(`MCP server "${this.config.name}" error: ${err.message}`));
+      }
+    });
     this.process.on("error", (err) => {
       if (this.closing) return;
       if (!this.closed) {
@@ -227867,11 +227925,18 @@ var MCPClient = class {
           res.on("end", () => {
             if (!this.closed) {
               this.closed = true;
+              this.emit({ type: "disconnected", serverName: this.config.name, reason: `MCP server "${this.config.name}" SSE connection closed` });
               this.rejectAllPending(new Error(`MCP server "${this.config.name}" SSE connection closed`));
             }
           });
           res.on("error", (err) => {
-            reject(new Error(`MCP server "${this.config.name}" SSE error: ${err.message}`));
+            if (!this.closed) {
+              this.closed = true;
+              this.emit({ type: "disconnected", serverName: this.config.name, reason: `MCP server "${this.config.name}" SSE error: ${err.message}` });
+              this.rejectAllPending(new Error(`MCP server "${this.config.name}" SSE error: ${err.message}`));
+            } else {
+              reject(new Error(`MCP server "${this.config.name}" SSE error: ${err.message}`));
+            }
           });
         }
       );
@@ -228099,7 +228164,7 @@ var MCPClient = class {
         return;
       }
       if (this.resolvedTransport === "streamable-http") {
-        this.sendHttpMessage(this.config.url, { jsonrpc: "2.0", id, method, params: finalParams }, true, true).then((response) => {
+        this.sendHttpWithSessionRecovery(this.config.url, { jsonrpc: "2.0", id, method, params: finalParams }, id).then((response) => {
           const entry2 = this.pending.get(id);
           if (!entry2) return;
           if (response.statusCode >= 400) {
@@ -228285,6 +228350,30 @@ var MCPClient = class {
     }
     return headers;
   }
+  async sendHttpWithSessionRecovery(url, payload, id) {
+    const response = await this.sendHttpMessage(url, payload, true, true);
+    const newSessionId = this.getHeader(response.headers, "mcp-session-id");
+    if (newSessionId && newSessionId !== this.sessionId) {
+      this.sessionId = newSessionId;
+    }
+    const isSessionExpired = (response.statusCode === 404 || response.statusCode === 410) && !this.getHeader(response.headers, "mcp-session-id");
+    if (isSessionExpired && !this.closed) {
+      try {
+        await this.connectStreamableHttp();
+        const retryResponse = await this.sendHttpMessage(url, payload, true, true);
+        const retrySessionId = this.getHeader(retryResponse.headers, "mcp-session-id");
+        if (retrySessionId) {
+          this.sessionId = retrySessionId;
+        }
+        return retryResponse;
+      } catch (reinitErr) {
+        this.closed = true;
+        this.emit({ type: "disconnected", serverName: this.config.name, reason: `MCP session recovery failed: ${reinitErr.message}` });
+        throw reinitErr;
+      }
+    }
+    return response;
+  }
   async sendHttpMessage(url, payload, isRequest, includeContentType) {
     const parsed = new URL(url);
     const requester = parsed.protocol === "https:" ? httpsRequest : httpRequest;
@@ -228462,6 +228551,20 @@ function normalizeHtmlMimeType(mimeType) {
   if (!mimeType) return "";
   return mimeType.split(";").map((part) => part.trim()).sort().join(";");
 }
+function classifyError(err, transport, statusCode) {
+  const msg = err.message ?? "";
+  if (/ECONNREFUSED|ETIMEDOUT/i.test(msg)) return "transient";
+  if (statusCode !== void 0) {
+    if (statusCode === 502 || statusCode === 503 || statusCode === 504) return "transient";
+    if (statusCode === 401 || statusCode === 403) return "permanent";
+    if (statusCode === 404 || statusCode === 410) return "session_expired";
+  }
+  if (/ENOTFOUND/i.test(msg)) return "permanent";
+  if (transport === "stdio" && /exited/i.test(msg)) return "transient";
+  if (transport === "sse" && /connection closed/i.test(msg)) return "transient";
+  if (/invalid|no command|no url/i.test(msg)) return "permanent";
+  return "transient";
+}
 var MCPManager = class {
   constructor(configs) {
     this.configs = configs;
@@ -228587,37 +228690,66 @@ var MCPManager = class {
     if (this.driverRegistry) {
       this.driverRegistry.unregister(mcpDriverName(name));
     }
-    state.status = "connecting";
-    try {
-      const client = new MCPClient(cfg);
-      client.onEvent((event) => this.handleClientEvent(event));
-      await client.connect();
-      this.clients.set(name, client);
-      const tools = await client.listTools();
-      this.registerDriver(name, tools);
-      state.status = "connected";
-      state.error = void 0;
-      state.toolCount = tools.length;
-      state.negotiatedProtocolVersion = client.getNegotiatedProtocolVersion() ?? void 0;
-      state.resolvedTransport = client.getResolvedTransport();
-      state.compatibilityMode = client.getCompatibilityMode();
-      state.refreshState = "idle";
-      state.refreshError = void 0;
-      state.lastRefreshAt = Date.now();
-      return true;
-    } catch (err) {
-      const state2 = this.states.get(name);
-      if (state2.status === "connected" || state2.status === "error") {
+    state.status = "reconnecting";
+    const client = new MCPClient(cfg);
+    client.onEvent((event) => this.handleClientEvent(event));
+    await client.connect();
+    this.clients.set(name, client);
+    const tools = await client.listTools();
+    this.registerDriver(name, tools);
+    state.status = "connected";
+    state.error = void 0;
+    state.toolCount = tools.length;
+    state.negotiatedProtocolVersion = client.getNegotiatedProtocolVersion() ?? void 0;
+    state.resolvedTransport = client.getResolvedTransport();
+    state.compatibilityMode = client.getCompatibilityMode();
+    state.refreshState = "idle";
+    state.refreshError = void 0;
+    state.lastRefreshAt = Date.now();
+    return true;
+  }
+  reconnectTimers = /* @__PURE__ */ new Map();
+  scheduleReconnect(name, attempt) {
+    const state = this.states.get(name);
+    if (!state) return;
+    if (state.status === "disconnected") return;
+    if (attempt >= 10) {
+      state.status = "error";
+      state.error = "Reconnect attempts exhausted";
+      state.refreshState = "error";
+      state.refreshError = "Reconnect attempts exhausted";
+      this.emit({ type: "tools_refresh_failed", serverName: name, error: "Reconnect attempts exhausted" });
+      return;
+    }
+    state.status = "reconnecting";
+    const delay = Math.min(3e4, 1e3 * Math.pow(2, attempt)) + Math.random() * 500;
+    const timer = setTimeout(async () => {
+      this.reconnectTimers.delete(name);
+      try {
         await this.reconnectServer(name);
-      } else {
-        state2.status = "error";
-        state2.error = err.message ?? "Unknown error";
-        state2.refreshState = "error";
-        state2.refreshError = err.message ?? "Unknown error";
+        state.refreshState = "idle";
+        state.refreshError = void 0;
+        this.emit({ type: "tools_refreshed", serverName: name, toolCount: state.toolCount });
+      } catch (err) {
+        const cfg = this.configs.find((c2) => c2.name === name);
+        const errorClass = classifyError(err, cfg?.transport ?? "stdio");
+        if (errorClass === "permanent" || errorClass === "session_expired") {
+          if (errorClass === "session_expired") {
+            this.scheduleReconnect(name, 0);
+            return;
+          }
+          state.status = "error";
+          state.error = err.message ?? "Unknown error";
+          state.refreshState = "error";
+          state.refreshError = err.message ?? "Unknown error";
+          state.toolCount = 0;
+          this.emit({ type: "tools_refresh_failed", serverName: name, error: err.message ?? "Unknown error" });
+          return;
+        }
+        this.scheduleReconnect(name, attempt + 1);
       }
-      state2.toolCount = 0;
-      return false;
-    }
+    }, delay);
+    this.reconnectTimers.set(name, timer);
   }
   async registerDrivers(registry) {
     this.driverRegistry = registry;
@@ -228633,7 +228765,7 @@ var MCPManager = class {
       } catch (err) {
         const state = this.states.get(name);
         if (state.status === "connected" || state.status === "error") {
-          await this.reconnectServer(name);
+          this.scheduleReconnect(name, 0);
         } else {
           state.status = "error";
           state.error = err.message ?? "Unknown error";
@@ -228659,6 +228791,10 @@ var MCPManager = class {
       })
     );
     this.clients.clear();
+    for (const timer of this.reconnectTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.reconnectTimers.clear();
   }
   async connectServer(name) {
     const existing = this.clients.get(name);
@@ -228826,6 +228962,10 @@ var MCPManager = class {
       if (event.type === "resources_list_changed") {
         state.lastRefreshAt = Date.now();
       }
+      if (event.type === "disconnected") {
+        state.status = "reconnecting";
+        this.scheduleReconnect(event.serverName, 0);
+      }
     }
     for (const listener of this.eventListeners) {
       listener(event);
@@ -229592,9 +229732,9 @@ var ConversationView = class {
     mkdirSync8(cacheDir, { recursive: true });
     const ext = displayMimeType.split("/")[1] || "png";
     const filename = `${Date.now()}.${ext}`;
-    const filePath = join16(cacheDir, filename);
-    writeFileSync9(filePath, Buffer.from(displayData, "base64"));
-    this.pushText(c.dim(`[image: ${filePath}]`));
+    const filePath2 = join16(cacheDir, filename);
+    writeFileSync9(filePath2, Buffer.from(displayData, "base64"));
+    this.pushText(c.dim(`[image: ${filePath2}]`));
     if (format !== "webp") {
       try {
         const img = new Image(displayData, displayMimeType, this.imageTheme, {
@@ -230013,6 +230153,13 @@ var FileTracker = class {
   getDisplayPaths() {
     return [...this.entries.values()];
   }
+  /** Reverse lookup: return the absolute path for a given display path, or undefined. */
+  getAbsPath(displayPath) {
+    for (const [absPath, dp] of this.entries) {
+      if (dp === displayPath) return absPath;
+    }
+    return void 0;
+  }
   /** Clear all tracked files. */
   clear() {
     this.entries.clear();
@@ -230108,6 +230255,19 @@ function formatCost(total) {
   if (total >= 0.01) return `$${total.toFixed(4)}`;
   return `\xA2${(total * 100).toFixed(2)}`;
 }
+function findFileMarkerAt(text, cursorLine, cursorCol) {
+  const lines = text.split("\n");
+  if (cursorLine < 0 || cursorLine >= lines.length) return void 0;
+  const line = lines[cursorLine];
+  const re = /\[file:([^\]]+)\]/g;
+  let m;
+  while ((m = re.exec(line)) !== null) {
+    if (cursorCol >= m.index && cursorCol <= m.index + m[0].length) {
+      return m[1];
+    }
+  }
+  return void 0;
+}
 var TuiApp = class {
   deps;
   terminal;
@@ -230152,6 +230312,8 @@ var TuiApp = class {
   drainedSubmitImages = null;
   // Pre-drained files: captured in input listener before Editor's onChange("") clears them
   drainedSubmitFiles = null;
+  // Absolute path shown when cursor is on a [file:xxx] placeholder
+  hoveredFilePath = null;
   lastPasteTime = 0;
   // ── Kitty protocol multi-chunk buffer ──
   // Kitty transmits large images in chunks. Accumulate base64 payloads here
@@ -230220,6 +230382,14 @@ var TuiApp = class {
           }
         }
       }
+      const cursor = this.editor.getCursor();
+      const editorText = this.editor.getText();
+      const hoveredDisplayPath = findFileMarkerAt(editorText, cursor.line, cursor.col);
+      if (hoveredDisplayPath) {
+        this.hoveredFilePath = this.fileTracker.getAbsPath(hoveredDisplayPath) ?? null;
+      } else {
+        this.hoveredFilePath = null;
+      }
       this.updateAttachmentBar();
     };
     this.tui.addInputListener((data) => {
@@ -230565,7 +230735,9 @@ var TuiApp = class {
     const chipsLine = parts.join(" ");
     const scrollHint = this.attachmentScrollOffset > 0 ? ` +${this.attachmentScrollOffset} more` : "";
     const hintLine = c.dim(`Ctrl+Shift+\u2190 \u2192 scroll${scrollHint} \xB7 Esc clear all`);
-    this.imageStatus.setText(`${chipsLine}
+    const hoverLine = this.hoveredFilePath ? c.dim(`
+Path: ${this.hoveredFilePath}`) : "";
+    this.imageStatus.setText(`${chipsLine}${hoverLine}
 ${hintLine}`);
     this.tui.requestRender(true);
   }
@@ -231132,17 +231304,11 @@ ${hintLine}`);
     if (hasFiles) {
       const imageRefs = fileRefs.filter((f) => isImagePath(f));
       const nonImageRefs = fileRefs.filter((f) => !isImagePath(f));
-      if (nonImageRefs.length > 0) {
-        const pathLines = nonImageRefs.map((f) => `- \`${f}\``).join("\n");
-        text = text ? `${text}
-
-\u{1F4C1} Attached files:
-${pathLines}` : `\u{1F4C1} Attached files:
-${pathLines}`;
-      }
+      const promptFilePaths = nonImageRefs.length > 0 ? [...nonImageRefs] : [];
       if (imageRefs.length > 0) {
         const dedupedImageRefs = imageRefs.filter((f) => !atPathAbsPaths.has(f));
         if (dedupedImageRefs.length > 0) {
+          promptFilePaths.push(...dedupedImageRefs);
           const refsResolved = resolveFileRefs(this.deps.config.projectPath, dedupedImageRefs, this.deps.config.atFile ?? {});
           if (refsResolved.warnings.length > 0) {
             for (const warn of refsResolved.warnings) {
@@ -231159,11 +231325,18 @@ ${pathLines}`;
           }
         }
       }
+      if (promptFilePaths.length > 0) {
+        const pathLines = promptFilePaths.map((f) => `- \`${f}\``).join("\n");
+        text = text ? `${text}
+
+\u{1F4C1} Attached files:
+${pathLines}` : `\u{1F4C1} Attached files:
+${pathLines}`;
+      }
     }
-    if (images && images.length > 0 && !resolveModel(this.deps.config.provider, this.deps.config.modelId).input.includes("image"))
-      this.conversation.addInfo(
-        c.dim(`${resolveModel(this.deps.config.provider, this.deps.config.modelId).name} does not support image input natively \u2014 using vision model or OCR.`)
-      );
+    this.conversation.addInfo(
+      c.dim(`${resolveModel(this.deps.config.provider, this.deps.config.modelId).name} does not support image input natively \u2014 using vision model or OCR.`)
+    );
     const imageIndicator = images ? c.dim(`[${images.length} image(s) attached]`) : "";
     const userMessage = hasText ? imageIndicator ? `${text}
 ${imageIndicator}` : text : imageIndicator;
@@ -231380,9 +231553,9 @@ async function ocrImages(images, signal) {
 }
 
 // src/drivers/vision/client.ts
+init_logger();
 init_models();
 init_models();
-init_logger();
 var _clog = new Logger({ type: "harness", id: process.env.DSCODE_RUNTIME_ID ?? "vision-client" });
 function resolveVisionModel(visionConfig, fallbackApiKey, onWarning) {
   if (!visionConfig?.provider || !visionConfig?.model) return null;
@@ -231432,14 +231605,12 @@ async function describeImagesViaVisionModel(images, visionModel, apiKey, signal)
       throw err;
     }
     const errMsg = err instanceof Error ? err.message : String(err);
-    _clog.warn("tool", "vision-client", `describeImages FAILED: ${errMsg}. images=${images.length}, totalBase64=${images.reduce((s, i) => s + (i.data?.length ?? 0), 0)}, img[0].mime=${images[0]?.mimeType ?? "?"}`);
+    _clog.warn("vision-client", `describeImages FAILED: ${errMsg}. images=${images.length}, totalBase64=${images.reduce((s, i) => s + (i.data?.length ?? 0), 0)}, img[0].mime=${images[0]?.mimeType ?? "?"}`);
     throw err;
   }
 }
 
 // src/drivers/vision/pipeline.ts
-init_logger();
-var _plog = new Logger({ type: "harness", id: process.env.DSCODE_RUNTIME_ID ?? "pipeline" });
 var ImagePipeline = class {
   visionConfig;
   fallbackApiKey;
@@ -231472,7 +231643,6 @@ var ImagePipeline = class {
     const compressedImages = compressedRaw.every((img) => img !== null) ? compressedRaw : normalizedImages;
     if (signal?.aborted) throw new DOMException("The operation was aborted", "AbortError");
     const vision = resolveVisionModel(this.visionConfig, this.fallbackApiKey, this.onWarning);
-    _plog.info("tool", "image-pipeline", `vision resolved: ${vision ? `${vision.model.provider}/${vision.model.id}` : "null \u2014 falling to OCR"}, images=${normalizedImages.length}, img[0].dataLen=${normalizedImages[0]?.data?.length ?? 0}, mime=${normalizedImages[0]?.mimeType ?? "?"}`);
     if (vision) {
       try {
         onProgress?.({ phase: "describing", cachedRefs });
@@ -231494,11 +231664,9 @@ ${description}
           throw err;
         }
         const errMsg = err instanceof Error ? err.message : String(err);
-        _plog.warn("tool", "image-pipeline", `vision FAILED: ${errMsg}. img[0].dataLen=${normalizedImages[0]?.data?.length ?? 0}, mime=${normalizedImages[0]?.mimeType ?? "?"}, preview=${normalizedImages[0]?.data?.slice(0, 80) ?? "?"}`);
         this.onWarning(`Vision model failed: ${errMsg}. Falling back to OCR.`);
       }
     }
-    _plog.info("tool", "image-pipeline", `entering OCR fallback, images=${normalizedImages.length}`);
     if (signal?.aborted) throw new DOMException("The operation was aborted", "AbortError");
     try {
       onProgress?.({ phase: "ocr", cachedRefs });
@@ -231601,12 +231769,12 @@ var ConfigWatch = class {
 
 // src/context/anchor-invalidation.ts
 var pendingEvents = [];
-function recordInvalidation(filePath, lineCount, fileVersion) {
-  const existing = pendingEvents.findIndex((e) => e.filePath === filePath);
+function recordInvalidation(filePath2, lineCount, fileVersion) {
+  const existing = pendingEvents.findIndex((e) => e.filePath === filePath2);
   if (existing >= 0) {
-    pendingEvents[existing] = { filePath, lineCount, fileVersion };
+    pendingEvents[existing] = { filePath: filePath2, lineCount, fileVersion };
   } else {
-    pendingEvents.push({ filePath, lineCount, fileVersion });
+    pendingEvents.push({ filePath: filePath2, lineCount, fileVersion });
   }
 }
 function consumePendingNotices() {
@@ -231652,7 +231820,7 @@ var HarnessEventBus = class {
       try {
         handler(event);
       } catch (err) {
-        this.logger.error("tool", "EventBus", `handler error for "${event.type}": ${String(err)}`);
+        this.logger.error("EventBus", `handler error for "${event.type}": ${String(err)}`);
       }
     }
   }
@@ -231689,6 +231857,8 @@ var Harness = class {
   shuttingDown = false;
   turnIndex = 0;
   visionAbortController = null;
+  autoSaveTimer;
+  lastSavedMessageCount = 0;
   constructor(config, logger, debug) {
     this.logger = logger;
     this.configStore = new ConfigWatch(config);
@@ -231777,7 +231947,7 @@ var Harness = class {
           await self.dumpDebugPrompt();
           return self.contextManager.transform(msgs, signal);
         } catch (err) {
-          this.logger.error("tool", "TransformContext", String(err));
+          this.logger.error("TransformContext", String(err));
           return msgs;
         }
       },
@@ -231800,7 +231970,7 @@ var Harness = class {
             }
           }
         } catch (err) {
-          this.logger.error("tool", "AfterToolCall", String(err));
+          this.logger.error("AfterToolCall", String(err));
         }
         if (_signal?.aborted) {
           return { terminate: true };
@@ -231843,6 +232013,7 @@ var Harness = class {
       const lastAssistantMsg = this.findLastAssistantMessage(msgs);
       if (!lastAssistantMsg || lastAssistantMsg.stopReason !== "error") {
         this.sessionManager.trySaveSession(this.agent);
+        this.lastSavedMessageCount = this.agent.state.messages.length;
         return;
       }
       const errorMsg = lastAssistantMsg.errorMessage ?? "Unknown model error";
@@ -231858,6 +232029,7 @@ var Harness = class {
         this.events.emit({ type: "ui:error", text: `Model error: ${errorMsg}` });
         this.events.emit({ type: "turn:error", error: errorMsg, attempt: attempt + 1, maxRetries });
         this.sessionManager.trySaveSession(this.agent);
+        this.lastSavedMessageCount = this.agent.state.messages.length;
         return;
       }
       if (attempt >= maxRetries) {
@@ -231873,6 +232045,7 @@ var Harness = class {
         this.events.emit({ type: "turn:error", error: errorMsg, attempt: attempt + 1, maxRetries });
         this.events.emit({ type: "ui:error", text: "\u2717 All retries exhausted" });
         this.sessionManager.trySaveSession(this.agent);
+        this.lastSavedMessageCount = this.agent.state.messages.length;
         return;
       }
       this.events.emit({
@@ -231891,6 +232064,24 @@ var Harness = class {
    */
   saveSessionNow() {
     this.sessionManager.trySaveSession(this.agent);
+    this.lastSavedMessageCount = this.agent.state.messages.length;
+  }
+  /**
+   * Start periodic auto-save (every 15s) during agent execution.
+   * Only saves when new messages have been added since last save.
+   */
+  startAutoSave() {
+    this.autoSaveTimer = setInterval(() => {
+      if (this.agent?.state?.messages) {
+        const currentCount = this.agent.state.messages.length;
+        if (currentCount !== this.lastSavedMessageCount) {
+          this.logger.info("AutoSave", `Periodic auto-save (${currentCount} messages, was ${this.lastSavedMessageCount})`);
+          this.sessionManager.trySaveSession(this.agent);
+          this.lastSavedMessageCount = currentCount;
+        }
+      }
+    }, 15e3);
+    this.autoSaveTimer.unref();
   }
   findLastUserMessageIndex(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -232039,6 +232230,7 @@ var Harness = class {
       }));
     }
     this.sessionManager.trySaveSession(this.agent);
+    this.lastSavedMessageCount = this.agent.state.messages.length;
     const restoredImgs = [];
     for (const ref of cachedRefs) {
       const cached2 = ImageCache.getSync(ref);
@@ -232099,6 +232291,7 @@ var Harness = class {
         this.toolRegistry.initialize(this.makeSkillTool());
         this.agent.state.tools = this.toolRegistry.buildToolsForRequest();
       }
+      this.startAutoSave();
       if (!this.config.apiKey) {
         this.events.emit({ type: "ui:info", text: [
           "Welcome to DSCode! To get started, configure your API key:",
@@ -232160,6 +232353,7 @@ var Harness = class {
       return { success: false, error: `Path does not exist: ${resolvedPath}` };
     }
     this.sessionManager.trySaveSession(this.agent);
+    this.lastSavedMessageCount = this.agent.state.messages.length;
     process.chdir(resolvedPath);
     this.configStore.setProjectPath(resolvedPath);
     this.sessionManager.updateProjectPath(this.config.dataDir, resolvedPath);
@@ -232193,7 +232387,7 @@ var Harness = class {
       this.ui.setMcpManager?.(this.mcpManager);
       this.ui.pushMcpState?.();
     } catch (err) {
-      this.logger.error("tool", "McpReload", String(err));
+      this.logger.error("McpReload", String(err));
     }
     this.agent.state.tools = this.toolRegistry.buildToolsForRequest();
     const memories = this.memoryManager.getRelevantMemories();
@@ -232203,7 +232397,12 @@ var Harness = class {
     return { success: true };
   }
   async shutdown() {
+    if (this.autoSaveTimer) {
+      clearInterval(this.autoSaveTimer);
+      this.autoSaveTimer = void 0;
+    }
     this.sessionManager.trySaveSession(this.agent);
+    this.lastSavedMessageCount = this.agent.state.messages.length;
     if (this.shuttingDown) return;
     this.shuttingDown = true;
     this.mcpEventUnsubscribe?.();
@@ -232216,14 +232415,14 @@ var Harness = class {
       try {
         await this.appHostManager.shutdown();
       } catch (err) {
-        this.logger.error("tool", "AppHostShutdown", String(err));
+        this.logger.error("AppHostShutdown", String(err));
       }
     }
     if (this.mcpManager) {
       try {
         await this.mcpManager.shutdown();
       } catch (err) {
-        this.logger.error("tool", "McpShutdown", String(err));
+        this.logger.error("McpShutdown", String(err));
       }
     }
   }
@@ -232315,13 +232514,13 @@ You have a \`skill\` tool available. When you decide to use a skill from the lis
     const hash = String(prompt.length);
     if (hash === this.debugPromptLastHash) return;
     this.debugPromptLastHash = hash;
-    const { mkdirSync: mkdirSync14, writeFileSync: writeFileSync15 } = await import("node:fs");
-    const { join: join31 } = await import("node:path");
-    const dumpDir = join31(this.config.projectPath, "dump");
+    const { mkdirSync: mkdirSync14, writeFileSync: writeFileSync16 } = await import("node:fs");
+    const { join: join32 } = await import("node:path");
+    const dumpDir = join32(this.config.projectPath, "dump");
     mkdirSync14(dumpDir, { recursive: true });
-    const filePath = join31(dumpDir, "system-prompt.md");
-    writeFileSync15(filePath, prompt, "utf8");
-    process.stderr.write("\n[dscode] --debug: system prompt dumped to " + filePath + " (" + prompt.length + " chars)\n\n");
+    const filePath2 = join32(dumpDir, "system-prompt.md");
+    writeFileSync16(filePath2, prompt, "utf8");
+    process.stderr.write("\n[dscode] --debug: system prompt dumped to " + filePath2 + " (" + prompt.length + " chars)\n\n");
   }
   makeSkillTool() {
     const skillManager = this.skillManager;
@@ -232457,6 +232656,14 @@ You have a \`skill\` tool available. When you decide to use a skill from the lis
   bindEvents() {
     this.agent.subscribe((event) => {
       switch (event.type) {
+        case "message_end": {
+          if (event.message?.role === "user") {
+            this.logger.info("PreTurnSave", `Saving session pre-turn (${this.agent.state.messages.length} messages)`);
+            this.sessionManager.trySaveSession(this.agent);
+            this.lastSavedMessageCount = this.agent.state.messages.length;
+          }
+          break;
+        }
         case "message_update": {
           const ev = event.assistantMessageEvent;
           if (!ev) break;
@@ -232498,12 +232705,14 @@ You have a \`skill\` tool available. When you decide to use a skill from the lis
         if (event.type === "agent_end") {
           this.events.emit({ type: "processing:stop" });
           this.sessionManager.trySaveSession(this.agent);
+          this.lastSavedMessageCount = this.agent.state.messages.length;
         }
         if (event.type === "agent_start") {
           this.events.emit({ type: "turn:streaming:start" });
         }
         if (event.type === "turn_end") {
           this.sessionManager.trySaveSession(this.agent);
+          this.lastSavedMessageCount = this.agent.state.messages.length;
           const turnEndMsg = event.message;
           const rawUsage = turnEndMsg?.usage;
           this.events.emit({ type: "turn:end", stopReason: turnEndMsg?.stopReason, usage: rawUsage ? { input: rawUsage.input, output: rawUsage.output, cacheRead: rawUsage.cacheRead, cacheWrite: rawUsage.cacheWrite, total: rawUsage.totalTokens, cost: { total: rawUsage.cost.total } } : void 0 });
@@ -232515,8 +232724,9 @@ You have a \`skill\` tool available. When you decide to use a skill from the lis
           }
         }
       } catch (err) {
-        this.logger.error("tool", "AgentEvent", String(err));
+        this.logger.error("AgentEvent", String(err));
         this.sessionManager.trySaveSession(this.agent);
+        this.lastSavedMessageCount = this.agent.state.messages.length;
       }
     });
   }
@@ -232611,6 +232821,132 @@ You have a \`skill\` tool available. When you decide to use a skill from the lis
 
 // src/core/main.ts
 init_logger();
+
+// src/core/od-daemon.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync24, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { join as join29 } from "node:path";
+function findProjectOd(odDir) {
+  const expandedDir = expandTilde2(odDir);
+  const odPath = join29(expandedDir, "node_modules", ".bin", "od");
+  if (existsSync24(odPath)) return odPath;
+  return null;
+}
+function resolveOdCommand(odDir, port) {
+  const expandedDir = expandTilde2(odDir);
+  const odPath = findProjectOd(odDir);
+  if (odPath) {
+    return { cmd: odPath, args: ["--port", String(port), "--no-open"], cwd: expandedDir };
+  }
+  return { cmd: "pnpm", args: ["tools-dev", "run", "web", "--", "--port", String(port), "--no-open"], cwd: expandedDir };
+}
+function startOdDaemon(odDir, odPort) {
+  const { cmd, args, cwd } = resolveOdCommand(odDir, odPort);
+  const child = spawn2(cmd, args, {
+    cwd,
+    stdio: "ignore",
+    env: { ...process.env, OD_PORT: String(odPort) }
+  });
+  child.unref();
+  return child;
+}
+async function waitForOdDaemon(port, timeoutMs = 3e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/api/projects`);
+      if (res.status === 200) {
+        console.log(`Open Design daemon ready on port ${port}`);
+        return true;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  console.warn(`Open Design daemon did not become healthy within ${timeoutMs / 1e3}s`);
+  return false;
+}
+var cleanupHandlers = [];
+function runOdCleanup() {
+  for (const handler of cleanupHandlers) {
+    handler();
+  }
+  cleanupHandlers = [];
+}
+var cleanupHooksInstalled = false;
+function installCleanupHooks() {
+  if (cleanupHooksInstalled) return;
+  cleanupHooksInstalled = true;
+  process.on("exit", runOdCleanup);
+  process.on("SIGINT", runOdCleanup);
+  process.on("SIGTERM", runOdCleanup);
+}
+function registerOdCleanup(odChild) {
+  installCleanupHooks();
+  const handler = () => {
+    if (odChild.exitCode !== null || odChild.signalCode !== null) return;
+    odChild.kill("SIGTERM");
+    const forceKill = setTimeout(() => {
+      if (odChild.exitCode === null && odChild.signalCode === null) {
+        odChild.kill("SIGKILL");
+      }
+    }, 3e3);
+    forceKill.unref();
+  };
+  cleanupHandlers.push(handler);
+}
+function expandTilde2(filePath2) {
+  if (filePath2.startsWith("~")) {
+    return join29(homedir10(), filePath2.slice(1));
+  }
+  return filePath2;
+}
+var MCP_PATH = join29(homedir10(), ".mcp.json");
+function ensureOdMcpEntry(odDir, odPort) {
+  const expandedDir = expandTilde2(odDir);
+  const daemonCliPath = join29(expandedDir, "apps", "daemon", "src", "cli.ts");
+  const daemonUrl = `http://127.0.0.1:${odPort}`;
+  let mcpConfig;
+  try {
+    if (existsSync24(MCP_PATH)) {
+      const raw = readFileSync21(MCP_PATH, "utf8");
+      mcpConfig = JSON.parse(raw);
+    } else {
+      mcpConfig = {};
+    }
+  } catch (e) {
+    if (existsSync24(MCP_PATH)) {
+      console.warn(
+        `Cannot read ~/.mcp.json: ${e instanceof Error ? e.message : String(e)}`
+      );
+      return false;
+    }
+    mcpConfig = {};
+  }
+  const servers = mcpConfig.mcpServers ?? {};
+  const existing = servers["open-design"];
+  if (existing?.args?.[1] === daemonCliPath && existing?.args?.[4] === daemonUrl) {
+    return true;
+  }
+  servers["open-design"] = {
+    command: "npx",
+    args: ["tsx", daemonCliPath, "mcp", "--daemon-url", daemonUrl]
+  };
+  mcpConfig.mcpServers = servers;
+  try {
+    writeFileSync14(MCP_PATH, JSON.stringify(mcpConfig, null, 2) + "\n");
+    console.log(`~/.mcp.json updated with open-design MCP entry`);
+    return true;
+  } catch (e) {
+    console.warn(
+      `Cannot write ~/.mcp.json: ${e instanceof Error ? e.message : String(e)}`
+    );
+    return false;
+  }
+}
+
+// src/core/main.ts
 function generateRuntimeId() {
   return "rt_" + randomBytes(4).toString("hex");
 }
@@ -232627,12 +232963,12 @@ function emergencySaveSession() {
   }
 }
 process.on("unhandledRejection", (reason) => {
-  harnessLogger.error("lifecycle", "UnhandledRejection", String(reason));
+  harnessLogger.error("UnhandledRejection", String(reason));
   emergencySaveSession();
 });
 process.on("uncaughtException", (err) => {
   const msg = err instanceof Error ? err.message : String(err);
-  harnessLogger.error("lifecycle", "UncaughtException", msg);
+  harnessLogger.error("UncaughtException", msg);
   emergencySaveSession();
   setTimeout(() => {
     process.exit(1);
@@ -232642,28 +232978,28 @@ var sigintCount = 0;
 process.on("SIGINT", () => {
   sigintCount++;
   if (sigintCount === 1) {
-    harnessLogger.info("lifecycle", "SIGINT", "Shutting down... (press Ctrl+C again to force quit)");
+    harnessLogger.info("SIGINT", "Shutting down... (press Ctrl+C again to force quit)");
     emergencySaveSession();
   } else {
-    harnessLogger.info("lifecycle", "SIGINT", "Force quitting...");
+    harnessLogger.info("SIGINT", "Force quitting...");
     emergencySaveSession();
     process.exit(0);
   }
 });
 process.on("SIGTERM", () => {
-  harnessLogger.info("lifecycle", "SIGTERM", "Received SIGTERM, shutting down...");
+  harnessLogger.info("SIGTERM", "Received SIGTERM, shutting down...");
   emergencySaveSession();
   process.exit(0);
 });
 function readCliVersion() {
   const currentDir = dirname7(fileURLToPath4(import.meta.url));
   const candidates = [
-    join30(currentDir, "..", "package.json"),
-    join30(currentDir, "..", "..", "package.json")
+    join31(currentDir, "..", "package.json"),
+    join31(currentDir, "..", "..", "package.json")
   ];
   for (const candidate of candidates) {
-    if (!existsSync25(candidate)) continue;
-    const pkg = JSON.parse(readFileSync22(candidate, "utf8"));
+    if (!existsSync26(candidate)) continue;
+    const pkg = JSON.parse(readFileSync23(candidate, "utf8"));
     if (typeof pkg.version === "string" && pkg.version.trim() !== "") {
       return pkg.version;
     }
@@ -232676,11 +233012,14 @@ function parseArgs() {
   let webPort = 3e3;
   let debug = false;
   let cwd;
+  let withOd = false;
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--web") {
       web = true;
     } else if (args[i] === "--debug") {
       debug = true;
+    } else if (args[i] === "--with-od") {
+      withOd = true;
     } else if (args[i] === "--web-port" && i + 1 < args.length) {
       webPort = parseInt(args[++i], 10);
       if (isNaN(webPort) || webPort < 1 || webPort > 65535) {
@@ -232690,15 +233029,91 @@ function parseArgs() {
       cwd = resolve11(args[++i]);
     }
   }
-  return { web, webPort, debug, cwd };
+  return { web, webPort, debug, cwd, withOd };
 }
 async function main() {
   if (process.argv.slice(2).some((arg) => arg === "--version" || arg === "-v")) {
     console.log(readCliVersion());
     return;
   }
-  const { web, webPort, debug, cwd } = parseArgs();
+  const { web, webPort, debug, cwd, withOd } = parseArgs();
   const projectRoot = process.cwd();
+  if (withOd) {
+    const odDir = process.env.OPEN_DESIGN_DIR;
+    const odPort = parseInt(process.env.OD_PORT ?? "7456", 10);
+    if (!odDir) {
+      console.warn("OPEN_DESIGN_DIR is not set. Create a .env file from .env.example");
+    } else {
+      ensureOdMcpEntry(odDir, odPort);
+      const alreadyAlive = await waitForOdDaemon(odPort, 2e3);
+      if (!alreadyAlive) {
+        try {
+          const odChild = startOdDaemon(odDir, odPort);
+          registerOdCleanup(odChild);
+          let odRestartCount = 0;
+          let lastRestartTime = 0;
+          const attachExitHandler = (child) => {
+            child.on("exit", (code, signal) => {
+              if (signal) {
+                harnessLogger.info("ODDaemon", `Open Design daemon killed by signal ${signal}`);
+              } else if (code !== 0 && code !== null) {
+                harnessLogger.info("ODDaemon", `Open Design daemon exited with code ${code}`);
+              }
+              if (code !== 0 && code !== null && withOd) {
+                const now = Date.now();
+                if (now - lastRestartTime < 5e3) {
+                  odRestartCount++;
+                } else {
+                  odRestartCount = 1;
+                }
+                lastRestartTime = now;
+                if (odRestartCount > 3) {
+                  harnessLogger.warn("ODDaemon", "Open Design daemon restart loop detected (3 rapid restarts), giving up");
+                  return;
+                }
+                harnessLogger.info("ODDaemon", `Restarting Open Design daemon (attempt ${odRestartCount})...`);
+                try {
+                  const newChild = startOdDaemon(odDir, odPort);
+                  registerOdCleanup(newChild);
+                  attachExitHandler(newChild);
+                  void waitForOdDaemon(odPort).then((healthy) => {
+                    if (healthy) {
+                      harnessLogger.info("ODDaemon", "Open Design daemon restarted successfully");
+                    }
+                  });
+                } catch (e) {
+                  harnessLogger.warn("ODDaemon", `Failed to restart Open Design daemon: ${e instanceof Error ? e.message : String(e)}`);
+                }
+              }
+            });
+            child.on("error", (err) => {
+              if (err.code === "ENOENT") {
+                const expandedDir = expandTilde2(odDir);
+                if (!existsSync26(expandedDir)) {
+                  console.warn(
+                    `Open Design directory not found: ${expandedDir}. Check OPEN_DESIGN_DIR in .env`
+                  );
+                } else {
+                  console.warn(
+                    `Cannot start Open Design daemon: command not found. Install pnpm (https://pnpm.io/installation) or run \`cd ${expandedDir} && pnpm link --global\` for the global od command.`
+                  );
+                }
+              } else {
+                harnessLogger.warn("ODDaemon", `Open Design daemon error: ${err.message}`);
+              }
+            });
+          };
+          attachExitHandler(odChild);
+          await waitForOdDaemon(odPort);
+        } catch (e) {
+          harnessLogger.warn(
+            "ODDaemon",
+            `Failed to start Open Design daemon: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+      }
+    }
+  }
   const config = loadConfig(cwd);
   if (config.apiKey) {
     const envVar = PROVIDER_ENV_VARS[config.provider] ?? "DEEPSEEK_API_KEY";
@@ -232728,7 +233143,7 @@ async function main() {
   }
 }
 main().catch((err) => {
-  harnessLogger.error("lifecycle", "FatalStartup", err instanceof Error ? err.message : String(err));
+  harnessLogger.error("FatalStartup", err instanceof Error ? err.message : String(err));
   emergencySaveSession();
   process.exit(1);
 });