@adhdev/daemon-standalone 0.9.53 → 0.9.54

package/dist/index.js

@@ -28139,13 +28139,13 @@ var require_dist2 = __commonJS({
       return LOG_DIR;
     }
     function getCurrentDaemonLogPath(date5 = /* @__PURE__ */ new Date()) {
-      return path6.join(LOG_DIR, `daemon-${date5.toISOString().slice(0, 10)}.log`);
+      return path9.join(LOG_DIR, `daemon-${date5.toISOString().slice(0, 10)}.log`);
     }
     function checkDateRotation() {
       const today = getDateStr();
       if (today !== currentDate) {
         currentDate = today;
-        currentLogFile = path6.join(LOG_DIR, `daemon-${currentDate}.log`);
+        currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
         cleanOldLogs();
       }
     }
@@ -28159,7 +28159,7 @@ var require_dist2 = __commonJS({
           const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs22.unlinkSync(path6.join(LOG_DIR, file2));
+              fs22.unlinkSync(path9.join(LOG_DIR, file2));
             } catch {
             }
           }
@@ -28169,8 +28169,8 @@ var require_dist2 = __commonJS({
     }
     function rotateSizeIfNeeded() {
       try {
-        const stat4 = fs22.statSync(currentLogFile);
-        if (stat4.size > MAX_LOG_SIZE) {
+        const stat22 = fs22.statSync(currentLogFile);
+        if (stat22.size > MAX_LOG_SIZE) {
           const backup = currentLogFile.replace(".log", ".1.log");
           try {
             fs22.unlinkSync(backup);
@@ -28276,7 +28276,7 @@ var require_dist2 = __commonJS({
       writeToFile(`Log level: ${currentLevel}`);
     }
     var fs22;
-    var path6;
+    var path9;
     var os42;
     var LEVEL_NUM;
     var LEVEL_LABEL;
@@ -28299,12 +28299,12 @@ var require_dist2 = __commonJS({
       "src/logging/logger.ts"() {
         "use strict";
         fs22 = __toESM2(require("fs"));
-        path6 = __toESM2(require("path"));
+        path9 = __toESM2(require("path"));
         os42 = __toESM2(require("os"));
         LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
         LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
         currentLevel = "info";
-        LOG_DIR = process.platform === "win32" ? path6.join(process.env.LOCALAPPDATA || process.env.APPDATA || path6.join(os42.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path6.join(os42.homedir(), "Library", "Logs", "adhdev") : path6.join(os42.homedir(), ".local", "share", "adhdev", "logs");
+        LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os42.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os42.homedir(), "Library", "Logs", "adhdev") : path9.join(os42.homedir(), ".local", "share", "adhdev", "logs");
         MAX_LOG_SIZE = 5 * 1024 * 1024;
         MAX_LOG_DAYS = 7;
         try {
@@ -28312,16 +28312,16 @@ var require_dist2 = __commonJS({
         } catch {
         }
         currentDate = getDateStr();
-        currentLogFile = path6.join(LOG_DIR, `daemon-${currentDate}.log`);
+        currentLogFile = path9.join(LOG_DIR, `daemon-${currentDate}.log`);
         cleanOldLogs();
         try {
-          const oldLog = path6.join(LOG_DIR, "daemon.log");
+          const oldLog = path9.join(LOG_DIR, "daemon.log");
           if (fs22.existsSync(oldLog)) {
-            const stat4 = fs22.statSync(oldLog);
-            const oldDate = stat4.mtime.toISOString().slice(0, 10);
-            fs22.renameSync(oldLog, path6.join(LOG_DIR, `daemon-${oldDate}.log`));
+            const stat22 = fs22.statSync(oldLog);
+            const oldDate = stat22.mtime.toISOString().slice(0, 10);
+            fs22.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
           }
-          const oldLogBackup = path6.join(LOG_DIR, "daemon.log.old");
+          const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
           if (fs22.existsSync(oldLogBackup)) {
             fs22.unlinkSync(oldLogBackup);
           }
@@ -28353,7 +28353,7 @@ var require_dist2 = __commonJS({
           }
         };
         interceptorInstalled = false;
-        LOG_PATH = path6.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+        LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
       }
     });
     function normalizeInputEnvelope(input) {
@@ -29254,8 +29254,8 @@ var require_dist2 = __commonJS({
             if (cwd) {
               try {
                 const fs16 = require("fs");
-                const stat4 = fs16.statSync(cwd);
-                if (!stat4.isDirectory()) cwd = os8.homedir();
+                const stat22 = fs16.statSync(cwd);
+                if (!stat22.isDirectory()) cwd = os8.homedir();
               } catch {
                 cwd = os8.homedir();
               }
@@ -29335,9 +29335,9 @@ var require_dist2 = __commonJS({
     function findBinary(name) {
       const trimmed = String(name || "").trim();
       if (!trimmed) return trimmed;
-      const expanded = trimmed.startsWith("~") ? path10.join(os9.homedir(), trimmed.slice(1)) : trimmed;
-      if (path10.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
-        return path10.isAbsolute(expanded) ? expanded : path10.resolve(expanded);
+      const expanded = trimmed.startsWith("~") ? path13.join(os9.homedir(), trimmed.slice(1)) : trimmed;
+      if (path13.isAbsolute(expanded) || expanded.includes("/") || expanded.includes("\\")) {
+        return path13.isAbsolute(expanded) ? expanded : path13.resolve(expanded);
       }
       const isWin = os9.platform() === "win32";
       try {
@@ -29353,7 +29353,7 @@ var require_dist2 = __commonJS({
       }
     }
     function isScriptBinary(binaryPath) {
-      if (!path10.isAbsolute(binaryPath)) return false;
+      if (!path13.isAbsolute(binaryPath)) return false;
       try {
         const fs16 = require("fs");
         const resolved = fs16.realpathSync(binaryPath);
@@ -29369,7 +29369,7 @@ var require_dist2 = __commonJS({
       }
     }
     function looksLikeMachOOrElf(filePath) {
-      if (!path10.isAbsolute(filePath)) return false;
+      if (!path13.isAbsolute(filePath)) return false;
       try {
         const fs16 = require("fs");
         const resolved = fs16.realpathSync(filePath);
@@ -29520,7 +29520,7 @@ var require_dist2 = __commonJS({
       };
     }
     var os9;
-    var path10;
+    var path13;
     var import_child_process4;
     var buildCliSpawnEnv;
     var COMMON_COMPARABLE_WRAP_WORDS;
@@ -29528,7 +29528,7 @@ var require_dist2 = __commonJS({
       "src/cli-adapters/provider-cli-shared.ts"() {
         "use strict";
         os9 = __toESM2(require("os"));
-        path10 = __toESM2(require("path"));
+        path13 = __toESM2(require("path"));
         import_child_process4 = require("child_process");
         init_spawn_env();
         buildCliSpawnEnv = import_session_host_core3.sanitizeSpawnEnv;
@@ -29839,9 +29839,9 @@ var require_dist2 = __commonJS({
       const allArgs = [...spawnConfig.args, ...extraArgs];
       let shellCmd;
       let shellArgs;
-      const useShellUnix = !isWin && (!!spawnConfig.shell || !path11.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
+      const useShellUnix = !isWin && (!!spawnConfig.shell || !path14.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
       const isCmdShim = isWin && /\.(cmd|bat)$/i.test(binaryPath);
-      const useShellWin = !!spawnConfig.shell || isCmdShim || !path11.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
+      const useShellWin = !!spawnConfig.shell || isCmdShim || !path14.isAbsolute(binaryPath) || isScriptBinary(binaryPath);
       const useShell = isWin ? useShellWin : useShellUnix;
       if (useShell) {
         shellCmd = isWin ? "cmd.exe" : process.env.SHELL || "/bin/zsh";
@@ -29918,13 +29918,13 @@ var require_dist2 = __commonJS({
       return "";
     }
     var os10;
-    var path11;
+    var path14;
     var import_session_host_core22;
     var init_provider_cli_runtime = __esm2({
       "src/cli-adapters/provider-cli-runtime.ts"() {
         "use strict";
         os10 = __toESM2(require("os"));
-        path11 = __toESM2(require("path"));
+        path14 = __toESM2(require("path"));
         import_session_host_core22 = require_dist();
         init_provider_cli_shared();
       }
@@ -30724,7 +30724,7 @@ var require_dist2 = __commonJS({
                   `[${this.cliType}] Waiting for interactive prompt: status=${status} stableMs=${stableMs} recentOutputMs=${recentlyOutput} screen=${JSON.stringify(summarizeCliTraceText(screenText, 220)).slice(0, 260)}`
                 );
               }
-              await new Promise((resolve12) => setTimeout(resolve12, 50));
+              await new Promise((resolve15) => setTimeout(resolve15, 50));
             }
             const finalScreenText = this.terminalScreen.getText() || "";
             LOG2.warn(
@@ -31912,7 +31912,7 @@ var require_dist2 = __commonJS({
               const deadline = Date.now() + 1e4;
               while (this.startupParseGate && Date.now() < deadline) {
                 this.resolveStartupState("send_wait");
-                await new Promise((resolve12) => setTimeout(resolve12, 50));
+                await new Promise((resolve15) => setTimeout(resolve15, 50));
               }
             }
             if (!allowInterventionPrompt) {
@@ -31993,13 +31993,13 @@ var require_dist2 = __commonJS({
             }
             this.responseEpoch += 1;
             this.responseSettleIgnoreUntil = Date.now() + submitDelayMs + this.timeouts.outputSettle + 250;
-            await new Promise((resolve12, reject) => {
+            await new Promise((resolve15, reject) => {
               let resolved = false;
               const completion = {
                 resolveOnce: () => {
                   if (resolved) return;
                   resolved = true;
-                  resolve12();
+                  resolve15();
                 },
                 rejectOnce: (error48) => {
                   if (resolved) return;
@@ -32161,17 +32161,17 @@ var require_dist2 = __commonJS({
             }
           }
           waitForStopped(timeoutMs) {
-            return new Promise((resolve12) => {
+            return new Promise((resolve15) => {
               const startedAt = Date.now();
               const timer = setInterval(() => {
                 if (!this.ptyProcess || this.currentStatus === "stopped") {
                   clearInterval(timer);
-                  resolve12(true);
+                  resolve15(true);
                   return;
                 }
                 if (Date.now() - startedAt >= timeoutMs) {
                   clearInterval(timer);
-                  resolve12(false);
+                  resolve15(false);
                 }
               }, 100);
             });
@@ -32409,6 +32409,7 @@ var require_dist2 = __commonJS({
       DEFAULT_CDP_SCAN_INTERVAL_MS: () => DEFAULT_CDP_SCAN_INTERVAL_MS,
       DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS: () => DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS2,
       DEFAULT_DAEMON_PORT: () => DEFAULT_DAEMON_PORT,
+      DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS: () => DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
       DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS2,
       DEFAULT_SESSION_HOST_APP_NAME: () => DEFAULT_SESSION_HOST_APP_NAME,
       DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS2,
@@ -32427,8 +32428,12 @@ var require_dist2 = __commonJS({
       DaemonCommandRouter: () => DaemonCommandRouter,
       DaemonStatusReporter: () => DaemonStatusReporter,
       DevServer: () => DevServer,
+      GitCommandError: () => GitCommandError,
+      GitWorkspaceMonitor: () => GitWorkspaceMonitor,
       IdeProviderInstance: () => IdeProviderInstance,
+      InMemoryGitSnapshotStore: () => InMemoryGitSnapshotStore,
       LOG: () => LOG2,
+      MIN_GIT_WORKSPACE_POLL_INTERVAL_MS: () => MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
       MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS: () => MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS2,
       MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS: () => MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS2,
       NodePtyTransportFactory: () => NodePtyTransportFactory,
@@ -32456,9 +32461,14 @@ var require_dist2 = __commonJS({
       buildUserChatMessage: () => buildUserChatMessage,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
       clearDebugTrace: () => clearDebugTrace,
+      compareGitSnapshots: () => compareGitSnapshots,
       configureDebugTraceStore: () => configureDebugTraceStore,
       connectCdpManager: () => connectCdpManager,
       createDebugTraceStore: () => createDebugTraceStore,
+      createDefaultGitCommandServices: () => createDefaultGitCommandServices,
+      createGitCompactSummary: () => createGitCompactSummary,
+      createGitSnapshotStore: () => createGitSnapshotStore,
+      createGitWorkspaceMonitor: () => createGitWorkspaceMonitor2,
       createInteractionId: () => createInteractionId,
       detectAllVersions: () => detectAllVersions,
       detectCLIs: () => detectCLIs,
@@ -32473,6 +32483,9 @@ var require_dist2 = __commonJS({
       getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
       getDaemonLogDir: () => getDaemonLogDir,
       getDebugRuntimeConfig: () => getDebugRuntimeConfig,
+      getGitDiffSummary: () => getGitDiffSummary,
+      getGitFileDiff: () => getGitFileDiff,
+      getGitRepoStatus: () => getGitRepoStatus,
       getHostMemorySnapshot: () => getHostMemorySnapshot,
       getLogLevel: () => getLogLevel,
       getNpmExecOptions: () => getNpmExecOptions,
@@ -32484,6 +32497,7 @@ var require_dist2 = __commonJS({
       getSessionHostRecoveryLabel: () => getSessionHostRecoveryLabel,
       getSessionHostSurfaceKind: () => getSessionHostSurfaceKind,
       getWorkspaceState: () => getWorkspaceState2,
+      handleGitCommand: () => handleGitCommand,
       hasCdpManager: () => hasCdpManager,
       hashSignatureParts: () => hashSignatureParts,
       initDaemonComponents: () => initDaemonComponents2,
@@ -32492,9 +32506,11 @@ var require_dist2 = __commonJS({
       isBuiltinChatMessageKind: () => isBuiltinChatMessageKind,
       isCdpConnected: () => isCdpConnected,
       isExtensionInstalled: () => isExtensionInstalled,
+      isGitCommandName: () => isGitCommandName,
       isIdeRunning: () => isIdeRunning,
       isManagedStatusWaiting: () => isManagedStatusWaiting,
       isManagedStatusWorking: () => isManagedStatusWorking,
+      isPathInside: () => isPathInside,
       isSessionHostLiveRuntime: () => isSessionHostLiveRuntime,
       isSessionHostRecoverySnapshot: () => isSessionHostRecoverySnapshot,
       isSetupComplete: () => isSetupComplete,
@@ -32512,10 +32528,13 @@ var require_dist2 = __commonJS({
       normalizeChatMessageKind: () => normalizeChatMessageKind,
       normalizeChatMessages: () => normalizeChatMessages,
       normalizeChatTailActiveModal: () => normalizeChatTailActiveModal,
+      normalizeGitOutput: () => normalizeGitOutput,
+      normalizeGitWorkspaceSubscriptionParams: () => normalizeGitWorkspaceSubscriptionParams2,
       normalizeInputEnvelope: () => normalizeInputEnvelope,
       normalizeManagedStatus: () => normalizeManagedStatus,
       normalizeMessageParts: () => normalizeMessageParts,
       normalizeSessionModalFields: () => normalizeSessionModalFields,
+      parsePorcelainV2Status: () => parsePorcelainV2Status,
       parseProviderSourceConfigUpdate: () => parseProviderSourceConfigUpdate,
       partitionSessionHostDiagnosticsSessions: () => partitionSessionHostDiagnosticsSessions,
       partitionSessionHostRecords: () => partitionSessionHostRecords,
@@ -32531,9 +32550,11 @@ var require_dist2 = __commonJS({
       resolveChatMessageKind: () => resolveChatMessageKind,
       resolveCurrentGlobalInstallSurface: () => resolveCurrentGlobalInstallSurface,
       resolveDebugRuntimeConfig: () => resolveDebugRuntimeConfig,
+      resolveGitRepository: () => resolveGitRepository,
       resolveSessionHostAppName: () => resolveSessionHostAppName,
       resolveSessionHostAppNameResolution: () => resolveSessionHostAppNameResolution2,
       runAsyncBatch: () => runAsyncBatch2,
+      runGit: () => runGit,
       saveConfig: () => saveConfig,
       saveState: () => saveState,
       setDebugRuntimeConfig: () => setDebugRuntimeConfig,
@@ -32544,21 +32565,1125 @@ var require_dist2 = __commonJS({
       shutdownDaemonComponents: () => shutdownDaemonComponents2,
       spawnDetachedDaemonUpgradeHelper: () => spawnDetachedDaemonUpgradeHelper,
       startDaemonDevSupport: () => startDaemonDevSupport2,
+      summarizeGitStatus: () => summarizeGitStatus,
       updateConfig: () => updateConfig,
       upsertSavedProviderSession: () => upsertSavedProviderSession
     });
     module2.exports = __toCommonJS2(index_exports);
+    var import_node_child_process = require("child_process");
+    var import_node_fs3 = require("fs");
+    var import_promises4 = require("fs/promises");
+    var path5 = __toESM2(require("path"));
+    var import_node_util = require("util");
+    var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+    var DEFAULT_TIMEOUT_MS = 5e3;
+    var DEFAULT_MAX_BUFFER = 1024 * 1024;
+    var GitCommandError = class extends Error {
+      reason;
+      stdout;
+      stderr;
+      exitCode;
+      signal;
+      argv;
+      cwd;
+      constructor(reason, message, details = {}) {
+        super(message);
+        if (details.cause !== void 0) {
+          this.cause = details.cause;
+        }
+        this.name = "GitCommandError";
+        this.reason = reason;
+        this.stdout = normalizeGitOutput(details.stdout);
+        this.stderr = normalizeGitOutput(details.stderr);
+        this.exitCode = details.exitCode;
+        this.signal = details.signal;
+        this.argv = details.argv ? [...details.argv] : void 0;
+        this.cwd = details.cwd;
+      }
+    };
+    async function resolveGitRepository(workspace, options = {}) {
+      const normalizedWorkspace = await validateWorkspace(workspace);
+      const result = await execGitRaw(normalizedWorkspace, ["rev-parse", "--show-toplevel"], options, {
+        mapNotGitRepo: true
+      });
+      const repoRoot = path5.resolve(result.stdout.trim());
+      if (!repoRoot) {
+        throw new GitCommandError("not_git_repo", "Git did not return a repository root", {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          argv: ["rev-parse", "--show-toplevel"],
+          cwd: normalizedWorkspace
+        });
+      }
+      return {
+        workspace: normalizedWorkspace,
+        repoRoot,
+        isGitRepo: true
+      };
+    }
+    async function runGit(repoOrWorkspace, argv, options = {}) {
+      validateGitArgv(argv);
+      const repo = typeof repoOrWorkspace === "string" ? await resolveGitRepository(repoOrWorkspace, options) : repoOrWorkspace;
+      if (!repo.repoRoot || !repo.isGitRepo) {
+        throw new GitCommandError("not_git_repo", "Workspace is not a Git repository", {
+          argv,
+          cwd: repo.workspace
+        });
+      }
+      const cwd = options.cwd ? await validateWorkspace(options.cwd) : await validateWorkspace(repo.workspace);
+      const canonicalRepoRoot = await (0, import_promises4.realpath)(repo.repoRoot);
+      const canonicalCwd = await (0, import_promises4.realpath)(cwd);
+      if (!isPathInside(canonicalRepoRoot, canonicalCwd)) {
+        throw new GitCommandError("path_outside_repo", "Git cwd is outside the repository root", {
+          argv,
+          cwd
+        });
+      }
+      return execGitRaw(cwd, argv, options);
+    }
+    function normalizeGitOutput(value) {
+      if (typeof value === "string") return value.replace(/\r\n/g, "\n");
+      if (Buffer.isBuffer(value)) return value.toString("utf8").replace(/\r\n/g, "\n");
+      if (value == null) return "";
+      return String(value).replace(/\r\n/g, "\n");
+    }
+    function isPathInside(parent, child) {
+      const relative3 = path5.relative(path5.resolve(parent), path5.resolve(child));
+      return relative3 === "" || !relative3.startsWith("..") && !path5.isAbsolute(relative3);
+    }
+    async function validateWorkspace(workspace) {
+      if (typeof workspace !== "string" || workspace.length === 0 || workspace.includes("\0")) {
+        throw new GitCommandError("invalid_args", "Workspace must be a non-empty path");
+      }
+      if (!path5.isAbsolute(workspace)) {
+        throw new GitCommandError("invalid_args", "Workspace must be an absolute path", { cwd: workspace });
+      }
+      const normalizedWorkspace = path5.resolve(workspace);
+      try {
+        const info = await (0, import_promises4.stat)(normalizedWorkspace);
+        if (!info.isDirectory()) {
+          throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
+            cwd: normalizedWorkspace
+          });
+        }
+        await (0, import_promises4.access)(normalizedWorkspace, import_node_fs3.constants.R_OK);
+      } catch (error48) {
+        if (error48 instanceof GitCommandError) throw error48;
+        throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
+          cwd: normalizedWorkspace,
+          cause: error48
+        });
+      }
+      return normalizedWorkspace;
+    }
+    function validateGitArgv(argv) {
+      if (!Array.isArray(argv) || argv.length === 0) {
+        throw new GitCommandError("invalid_args", "Git argv must be a non-empty string array", { argv });
+      }
+      for (const arg of argv) {
+        if (typeof arg !== "string" || arg.length === 0 || arg.includes("\0")) {
+          throw new GitCommandError("invalid_args", "Git argv contains an invalid argument", { argv });
+        }
+      }
+      if (argv.includes("-C") || argv.some((arg) => arg.startsWith("--git-dir") || arg.startsWith("--work-tree"))) {
+        throw new GitCommandError("invalid_args", "Git argv contains unsafe repository override arguments", {
+          argv
+        });
+      }
+    }
+    async function execGitRaw(cwd, argv, options, behavior = {}) {
+      validateGitArgv(argv);
+      try {
+        const result = await execFileAsync("git", [...argv], {
+          cwd,
+          encoding: "utf8",
+          timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+          maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
+          windowsHide: true
+        });
+        return {
+          stdout: normalizeGitOutput(result.stdout),
+          stderr: normalizeGitOutput(result.stderr)
+        };
+      } catch (error48) {
+        throw mapExecError(error48, cwd, argv, behavior);
+      }
+    }
+    function mapExecError(error48, cwd, argv, behavior) {
+      const execError = error48;
+      const stdout = normalizeGitOutput(execError.stdout);
+      const stderr = normalizeGitOutput(execError.stderr);
+      const code = execError.code;
+      const signal = execError.signal;
+      const message = [stderr.trim(), execError.message].filter(Boolean).join("\n");
+      if (code === "ENOENT") {
+        return new GitCommandError("git_not_installed", "Git executable was not found", {
+          stdout,
+          stderr,
+          exitCode: code,
+          signal,
+          argv,
+          cwd,
+          cause: error48
+        });
+      }
+      if (execError.killed || /timed out/i.test(execError.message)) {
+        return new GitCommandError("timeout", "Git command timed out", {
+          stdout,
+          stderr,
+          exitCode: code,
+          signal,
+          argv,
+          cwd,
+          cause: error48
+        });
+      }
+      if (behavior.mapNotGitRepo && /not a git repository/i.test(stderr + "\n" + execError.message)) {
+        return new GitCommandError("not_git_repo", "Workspace is not a Git repository", {
+          stdout,
+          stderr,
+          exitCode: code,
+          signal,
+          argv,
+          cwd,
+          cause: error48
+        });
+      }
+      return new GitCommandError("git_command_failed", message || "Git command failed", {
+        stdout,
+        stderr,
+        exitCode: code,
+        signal,
+        argv,
+        cwd,
+        cause: error48
+      });
+    }
+    async function getGitRepoStatus(workspace, options = {}) {
+      const lastCheckedAt = Date.now();
+      try {
+        const repo = await resolveGitRepository(workspace, options);
+        const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
+        const parsed = parsePorcelainV2Status(statusOutput.stdout);
+        const head = await readHead(repo, options);
+        const stashCount = await readStashCount(repo, options);
+        return {
+          workspace: repo.workspace,
+          repoRoot: repo.repoRoot,
+          isGitRepo: true,
+          branch: parsed.branch,
+          headCommit: head.commit,
+          headMessage: head.message,
+          upstream: parsed.upstream,
+          ahead: parsed.ahead,
+          behind: parsed.behind,
+          staged: parsed.staged,
+          modified: parsed.modified,
+          untracked: parsed.untracked,
+          deleted: parsed.deleted,
+          renamed: parsed.renamed,
+          hasConflicts: parsed.conflictFiles.length > 0,
+          conflictFiles: parsed.conflictFiles,
+          stashCount,
+          lastCheckedAt
+        };
+      } catch (error48) {
+        if (error48 instanceof GitCommandError) {
+          return emptyStatus(workspace, lastCheckedAt, error48);
+        }
+        return emptyStatus(
+          workspace,
+          lastCheckedAt,
+          new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error48 })
+        );
+      }
+    }
+    function parsePorcelainV2Status(output) {
+      const parsed = {
+        branch: null,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        modified: 0,
+        untracked: 0,
+        deleted: 0,
+        renamed: 0,
+        conflictFiles: []
+      };
+      for (const line of output.split("\n")) {
+        if (!line) continue;
+        if (line.startsWith("# branch.head ")) {
+          const branch = line.slice("# branch.head ".length).trim();
+          parsed.branch = branch && branch !== "(detached)" ? branch : null;
+          continue;
+        }
+        if (line.startsWith("# branch.upstream ")) {
+          parsed.upstream = line.slice("# branch.upstream ".length).trim() || null;
+          continue;
+        }
+        if (line.startsWith("# branch.ab ")) {
+          const match = line.match(/\+(-?\d+)\s+-(-?\d+)/);
+          if (match) {
+            parsed.ahead = Number.parseInt(match[1] ?? "0", 10) || 0;
+            parsed.behind = Number.parseInt(match[2] ?? "0", 10) || 0;
+          }
+          continue;
+        }
+        if (line.startsWith("? ")) {
+          parsed.untracked += 1;
+          continue;
+        }
+        if (line.startsWith("u ")) {
+          const fields = line.split(" ");
+          const filePath = fields.slice(10).join(" ");
+          if (filePath) parsed.conflictFiles.push(filePath);
+          continue;
+        }
+        if (line.startsWith("1 ") || line.startsWith("2 ")) {
+          const fields = line.split(" ");
+          const xy = fields[1] ?? "..";
+          const indexStatus = xy[0] ?? ".";
+          const worktreeStatus = xy[1] ?? ".";
+          if (isStagedStatus(indexStatus)) parsed.staged += 1;
+          if (worktreeStatus === "M" || worktreeStatus === "T") parsed.modified += 1;
+          if (indexStatus === "D" || worktreeStatus === "D") parsed.deleted += 1;
+          if (indexStatus === "R" || worktreeStatus === "R") parsed.renamed += 1;
+          if (xy.includes("U")) {
+            const filePath = fields.slice(line.startsWith("2 ") ? 9 : 8).join(" ").split("	")[0] ?? "";
+            if (filePath) parsed.conflictFiles.push(filePath);
+          }
+        }
+      }
+      parsed.conflictFiles = Array.from(new Set(parsed.conflictFiles));
+      return parsed;
+    }
+    async function readHead(repo, options) {
+      try {
+        const result = await runGit(repo, ["log", "-1", "--pretty=%h%x00%s"], options);
+        const text = result.stdout.trimEnd();
+        if (!text) return { commit: null, message: null };
+        const [commit, ...messageParts] = text.split("\0");
+        return {
+          commit: commit || null,
+          message: messageParts.join("\0") || null
+        };
+      } catch {
+        return { commit: null, message: null };
+      }
+    }
+    async function readStashCount(repo, options) {
+      try {
+        const result = await runGit(repo, ["stash", "list", "--format=%gd"], options);
+        return result.stdout.split("\n").filter((line) => line.trim().length > 0).length;
+      } catch {
+        return 0;
+      }
+    }
+    function isStagedStatus(status) {
+      return status !== "." && status !== "?" && status !== "U";
+    }
+    function emptyStatus(workspace, lastCheckedAt, error48) {
+      return {
+        workspace,
+        repoRoot: null,
+        isGitRepo: false,
+        branch: null,
+        headCommit: null,
+        headMessage: null,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+        staged: 0,
+        modified: 0,
+        untracked: 0,
+        deleted: 0,
+        renamed: 0,
+        hasConflicts: false,
+        conflictFiles: [],
+        stashCount: 0,
+        lastCheckedAt,
+        error: error48.stderr || error48.message,
+        reason: error48.reason
+      };
+    }
+    var import_promises22 = require("fs/promises");
+    var path23 = __toESM2(require("path"));
+    var DEFAULT_MAX_FILES = 200;
+    var DEFAULT_MAX_BYTES = 2e5;
+    async function getGitDiffSummary(workspace, options = {}) {
+      const lastCheckedAt = Date.now();
+      try {
+        const repo = await resolveGitRepository(workspace, options);
+        const repoRoot = repo.repoRoot;
+        const [unstagedNameStatus, unstagedNumstat, stagedNameStatus, stagedNumstat, untracked] = await Promise.all([
+          runGit(repo, ["diff", "--no-ext-diff", "--name-status"], { ...options, cwd: repoRoot }),
+          runGit(repo, ["diff", "--no-ext-diff", "--numstat"], { ...options, cwd: repoRoot }),
+          runGit(repo, ["diff", "--cached", "--no-ext-diff", "--name-status"], { ...options, cwd: repoRoot }),
+          runGit(repo, ["diff", "--cached", "--no-ext-diff", "--numstat"], { ...options, cwd: repoRoot }),
+          runGit(repo, ["ls-files", "--others", "--exclude-standard"], { ...options, cwd: repoRoot })
+        ]);
+        const outputBytes = byteLength(
+          unstagedNameStatus.stdout + unstagedNumstat.stdout + stagedNameStatus.stdout + stagedNumstat.stdout + untracked.stdout
+        );
+        const changes = [
+          ...combineDiffEntries(unstagedNameStatus.stdout, unstagedNumstat.stdout, false),
+          ...combineDiffEntries(stagedNameStatus.stdout, stagedNumstat.stdout, true),
+          ...parseUntrackedFiles(untracked.stdout)
+        ];
+        const maxFiles = normalizePositiveInteger(options.maxFiles, DEFAULT_MAX_FILES);
+        const maxBytes = normalizePositiveInteger(options.maxBytes, DEFAULT_MAX_BYTES);
+        const files = changes.slice(0, maxFiles);
+        const truncated = changes.length > files.length || outputBytes > maxBytes;
+        return {
+          workspace: repo.workspace,
+          repoRoot,
+          isGitRepo: true,
+          files,
+          totalInsertions: files.reduce((sum, file2) => sum + file2.insertions, 0),
+          totalDeletions: files.reduce((sum, file2) => sum + file2.deletions, 0),
+          truncated,
+          lastCheckedAt
+        };
+      } catch (error48) {
+        const gitError = error48 instanceof GitCommandError ? error48 : new GitCommandError("git_command_failed", "Failed to read Git diff summary", { cause: error48 });
+        return {
+          workspace,
+          repoRoot: null,
+          isGitRepo: false,
+          files: [],
+          totalInsertions: 0,
+          totalDeletions: 0,
+          truncated: false,
+          lastCheckedAt,
+          error: gitError.stderr || gitError.message,
+          reason: gitError.reason
+        };
+      }
+    }
+    async function getGitFileDiff(workspace, filePath, options = {}) {
+      const lastCheckedAt = Date.now();
+      const repo = await resolveGitRepository(workspace, options);
+      const repoRoot = repo.repoRoot;
+      const selected = await resolveRepoFilePath(repoRoot, filePath);
+      const maxBytes = normalizePositiveInteger(options.maxBytes, DEFAULT_MAX_BYTES);
+      const [unstaged, staged] = await Promise.all([
+        runGit(repo, ["diff", "--no-ext-diff", "--", selected.relativePath], { ...options, cwd: repoRoot }),
+        runGit(repo, ["diff", "--cached", "--no-ext-diff", "--", selected.relativePath], { ...options, cwd: repoRoot })
+      ]);
+      let diff = [unstaged.stdout, staged.stdout].filter((part) => part.length > 0).join("\n");
+      if (!diff) {
+        const untracked = await runGit(repo, ["ls-files", "--others", "--exclude-standard", "--", selected.relativePath], {
+          ...options,
+          cwd: repoRoot
+        });
+        const untrackedFiles = untracked.stdout.split("\n").filter(Boolean);
+        if (untrackedFiles.includes(selected.relativePath)) {
+          diff = await buildUntrackedDiff(selected.absolutePath, selected.relativePath, maxBytes + 1);
+        }
+      }
+      const bounded = truncateText(diff, maxBytes);
+      return {
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        path: selected.relativePath,
+        diff: bounded.text,
+        truncated: bounded.truncated,
+        lastCheckedAt
+      };
+    }
+    function combineDiffEntries(nameStatusOutput, numstatOutput, staged) {
+      const statusEntries = parseNameStatus(nameStatusOutput);
+      const numstatEntries = parseNumstat(numstatOutput);
+      return statusEntries.map((entry, index) => {
+        const stats = numstatEntries[index];
+        return {
+          path: entry.path,
+          oldPath: entry.oldPath,
+          status: entry.status,
+          staged,
+          insertions: stats?.insertions ?? 0,
+          deletions: stats?.deletions ?? 0,
+          binary: stats?.binary || void 0
+        };
+      });
+    }
+    function parseNameStatus(output) {
+      return output.split("\n").filter(Boolean).map((line) => {
+        const fields = line.split("	");
+        const code = fields[0] ?? "";
+        const statusLetter = code[0] ?? "M";
+        if (statusLetter === "R") {
+          return {
+            oldPath: fields[1] ?? "",
+            path: fields[2] ?? fields[1] ?? "",
+            status: "renamed"
+          };
+        }
+        if (statusLetter === "C") {
+          return {
+            oldPath: fields[1] ?? "",
+            path: fields[2] ?? fields[1] ?? "",
+            status: "copied"
+          };
+        }
+        return {
+          path: fields[1] ?? "",
+          status: mapNameStatus(statusLetter)
+        };
+      }).filter((entry) => entry.path.length > 0);
+    }
+    function parseNumstat(output) {
+      return output.split("\n").filter(Boolean).map((line) => {
+        const fields = line.split("	");
+        const insertionsText = fields[0] ?? "0";
+        const deletionsText = fields[1] ?? "0";
+        const binary = insertionsText === "-" || deletionsText === "-";
+        return {
+          path: fields.slice(2).join("	"),
+          insertions: binary ? 0 : Number.parseInt(insertionsText, 10) || 0,
+          deletions: binary ? 0 : Number.parseInt(deletionsText, 10) || 0,
+          binary
+        };
+      });
+    }
+    function parseUntrackedFiles(output) {
+      return output.split("\n").filter(Boolean).map((filePath) => ({
+        path: filePath,
+        status: "untracked",
+        staged: false,
+        insertions: 0,
+        deletions: 0
+      }));
+    }
+    function mapNameStatus(status) {
+      switch (status) {
+        case "A":
+          return "added";
+        case "D":
+          return "deleted";
+        case "R":
+          return "renamed";
+        case "C":
+          return "copied";
+        case "U":
+          return "conflict";
+        case "M":
+        case "T":
+        default:
+          return "modified";
+      }
+    }
+    async function resolveRepoFilePath(repoRoot, filePath) {
+      if (typeof filePath !== "string" || filePath.length === 0 || filePath.includes("\0")) {
+        throw new GitCommandError("invalid_args", "File path must be a non-empty path");
+      }
+      const canonicalRepoRoot = await (0, import_promises22.realpath)(repoRoot).catch(() => path23.resolve(repoRoot));
+      const absolutePath = path23.isAbsolute(filePath) ? path23.resolve(filePath) : path23.resolve(repoRoot, filePath);
+      const checkPath = await (0, import_promises22.realpath)(absolutePath).catch(() => absolutePath);
+      const relativeBase = isPathInside(canonicalRepoRoot, checkPath) ? canonicalRepoRoot : path23.resolve(repoRoot);
+      if (!isPathInside(canonicalRepoRoot, checkPath) && !isPathInside(repoRoot, absolutePath)) {
+        throw new GitCommandError("path_outside_repo", "Selected file path is outside the repository root", {
+          cwd: repoRoot
+        });
+      }
+      const relativePath = path23.relative(relativeBase, checkPath).split(path23.sep).join("/");
+      if (!relativePath || relativePath.startsWith("..") || path23.isAbsolute(relativePath)) {
+        throw new GitCommandError("path_outside_repo", "Selected file path is outside the repository root", {
+          cwd: repoRoot
+        });
+      }
+      return { absolutePath, relativePath };
+    }
+    async function buildUntrackedDiff(absolutePath, relativePath, readLimit) {
+      const content = await (0, import_promises22.readFile)(absolutePath, "utf8");
+      const limitedContent = content.length > readLimit ? content.slice(0, readLimit) : content;
+      const lines = limitedContent.length > 0 ? limitedContent.split("\n") : [];
+      const plusLines = lines.filter((line, index) => index < lines.length - 1 || line.length > 0).map((line) => `+${line}`).join("\n");
+      const lineCount = plusLines ? plusLines.split("\n").length : 0;
+      return [
+        `diff --git a/${relativePath} b/${relativePath}`,
+        "new file mode 100644",
+        "index 0000000..0000000",
+        "--- /dev/null",
+        `+++ b/${relativePath}`,
+        `@@ -0,0 +1,${lineCount} @@`,
+        plusLines
+      ].filter((line) => line.length > 0).join("\n");
+    }
+    function truncateText(text, maxBytes) {
+      if (byteLength(text) <= maxBytes) return { text, truncated: false };
+      return { text: Buffer.from(text, "utf8").subarray(0, maxBytes).toString("utf8"), truncated: true };
+    }
+    function byteLength(text) {
+      return Buffer.byteLength(text, "utf8");
+    }
+    function normalizePositiveInteger(value, fallback) {
+      if (!Number.isFinite(value) || value == null || value <= 0) return fallback;
+      return Math.floor(value);
+    }
+    function countStatusChangedFiles(status) {
+      const conflictCount = status.conflictFiles.length > 0 ? status.conflictFiles.length : status.hasConflicts ? 1 : 0;
+      return status.staged + status.modified + status.untracked + status.deleted + status.renamed + conflictCount;
+    }
+    function createGitCompactSummary(status, diffSummary) {
+      const statusChangedFiles = countStatusChangedFiles(status);
+      const diffChangedFiles = diffSummary?.files.length ?? 0;
+      const changedFiles = Math.max(statusChangedFiles, diffChangedFiles);
+      const conflictCount = status.conflictFiles.length > 0 ? status.conflictFiles.length : status.hasConflicts ? 1 : 0;
+      return {
+        isGitRepo: status.isGitRepo,
+        repoRoot: status.repoRoot,
+        branch: status.branch,
+        dirty: status.staged > 0 || status.modified > 0 || status.untracked > 0 || status.deleted > 0 || status.renamed > 0 || conflictCount > 0 || changedFiles > 0,
+        changedFiles,
+        ahead: status.ahead,
+        behind: status.behind,
+        hasConflicts: status.hasConflicts || conflictCount > 0,
+        lastCheckedAt: Math.max(status.lastCheckedAt, diffSummary?.lastCheckedAt ?? status.lastCheckedAt),
+        error: status.error ?? diffSummary?.error,
+        reason: status.reason ?? diffSummary?.reason
+      };
+    }
+    var summarizeGitStatus = createGitCompactSummary;
+    function normalizeCapacity(capacity) {
+      return Math.max(1, Math.floor(capacity ?? 100));
+    }
+    function createEmptyDiffSummary(status) {
+      return {
+        workspace: status.workspace,
+        repoRoot: status.repoRoot,
+        isGitRepo: status.isGitRepo,
+        files: [],
+        totalInsertions: 0,
+        totalDeletions: 0,
+        truncated: false,
+        lastCheckedAt: status.lastCheckedAt,
+        error: status.error,
+        reason: status.reason
+      };
+    }
+    function changedFileKey(file2) {
+      return `${file2.oldPath ?? ""}\0${file2.path}`;
+    }
+    function uniqueSorted(values) {
+      return Array.from(new Set(Array.from(values).filter(Boolean))).sort((a, b2) => a.localeCompare(b2));
+    }
+    function plural(count, singular, pluralText = `${singular}s`) {
+      return count === 1 ? singular : pluralText;
+    }
+    function compareGitSnapshots(before, after) {
+      const beforeFileKeys = new Set(before.diffSummary.files.map(changedFileKey));
+      const changedAfterFiles = after.diffSummary.files.filter((file2) => !beforeFileKeys.has(changedFileKey(file2)));
+      const addedFiles = [];
+      const modifiedFiles = [];
+      const deletedFiles = [];
+      const renamedFiles = [];
+      const untrackedFiles = [];
+      const conflictFilesFromDiff = [];
+      let totalInsertions = 0;
+      let totalDeletions = 0;
+      for (const file2 of changedAfterFiles) {
+        totalInsertions += file2.insertions;
+        totalDeletions += file2.deletions;
+        switch (file2.status) {
+          case "added":
+          case "copied":
+            addedFiles.push(file2.path);
+            break;
+          case "modified":
+            modifiedFiles.push(file2.path);
+            break;
+          case "deleted":
+            deletedFiles.push(file2.path);
+            break;
+          case "renamed":
+            renamedFiles.push({ oldPath: file2.oldPath ?? file2.path, path: file2.path });
+            break;
+          case "untracked":
+            untrackedFiles.push(file2.path);
+            break;
+          case "conflict":
+            conflictFilesFromDiff.push(file2.path);
+            break;
+        }
+      }
+      renamedFiles.sort((a, b2) => `${a.oldPath}\0${a.path}`.localeCompare(`${b2.oldPath}\0${b2.path}`));
+      const conflictFiles = uniqueSorted([...after.status.conflictFiles, ...conflictFilesFromDiff]);
+      const changedFiles = changedAfterFiles.length;
+      const hasConflicts = after.status.hasConflicts || conflictFiles.length > 0;
+      const summaryParts = [];
+      if (changedFiles > 0) summaryParts.push(`${changedFiles} ${plural(changedFiles, "file")} changed`);
+      if (addedFiles.length > 0) summaryParts.push(`${addedFiles.length} added`);
+      if (modifiedFiles.length > 0) summaryParts.push(`${modifiedFiles.length} modified`);
+      if (deletedFiles.length > 0) summaryParts.push(`${deletedFiles.length} deleted`);
+      if (renamedFiles.length > 0) summaryParts.push(`${renamedFiles.length} renamed`);
+      if (untrackedFiles.length > 0) summaryParts.push(`${untrackedFiles.length} untracked`);
+      if (hasConflicts) summaryParts.push(`${conflictFiles.length || 1} ${plural(conflictFiles.length || 1, "conflict")}`);
+      return {
+        beforeSnapshotId: before.id,
+        afterSnapshotId: after.id,
+        workspace: after.workspace,
+        repoRoot: after.repoRoot,
+        changedFiles,
+        addedFiles: uniqueSorted(addedFiles),
+        modifiedFiles: uniqueSorted(modifiedFiles),
+        deletedFiles: uniqueSorted(deletedFiles),
+        renamedFiles,
+        untrackedFiles: uniqueSorted(untrackedFiles),
+        conflictFiles,
+        totalInsertions,
+        totalDeletions,
+        hasConflicts,
+        currentStatus: after.status,
+        summaryText: summaryParts.length > 0 ? summaryParts.join(", ") : "No file-set changes between snapshots."
+      };
+    }
+    var InMemoryGitSnapshotStore = class {
+      snapshots = /* @__PURE__ */ new Map();
+      order = [];
+      capacity;
+      now;
+      idPrefix;
+      getStatusProvider;
+      getDiffSummaryProvider;
+      counter = 0;
+      constructor(options = {}) {
+        this.capacity = normalizeCapacity(options.capacity);
+        this.now = options.now ?? Date.now;
+        this.idPrefix = options.idPrefix ?? "git-snapshot";
+        this.getStatusProvider = options.getStatus;
+        this.getDiffSummaryProvider = options.getDiffSummary;
+      }
+      async create(input) {
+        const getStatus = input.getStatus ?? this.getStatusProvider;
+        if (!getStatus) {
+          throw new Error("GitSnapshotStore requires an injected getStatus provider");
+        }
+        const status = await getStatus(input.workspace);
+        const getDiffSummary = input.getDiffSummary ?? this.getDiffSummaryProvider;
+        const diffSummary = getDiffSummary ? await getDiffSummary(input.workspace, status) : createEmptyDiffSummary(status);
+        const createdAt = this.now();
+        const id = `${this.idPrefix}-${createdAt}-${++this.counter}`;
+        const snapshot = {
+          id,
+          workspace: input.workspace,
+          repoRoot: status.repoRoot ?? input.workspace,
+          sessionId: input.sessionId,
+          turnId: input.turnId,
+          reason: input.reason,
+          status,
+          diffSummary,
+          createdAt
+        };
+        this.snapshots.set(id, snapshot);
+        this.order.push(id);
+        this.enforceCapacity();
+        return snapshot;
+      }
+      get(id) {
+        return this.snapshots.get(id);
+      }
+      compare(beforeSnapshotId, afterSnapshotId) {
+        const before = this.snapshots.get(beforeSnapshotId);
+        if (!before) throw new Error(`Unknown before snapshot: ${beforeSnapshotId}`);
+        const after = this.snapshots.get(afterSnapshotId);
+        if (!after) throw new Error(`Unknown after snapshot: ${afterSnapshotId}`);
+        return compareGitSnapshots(before, after);
+      }
+      list(query = {}) {
+        const limit = Math.max(1, Math.floor(query.limit ?? this.capacity));
+        return this.order.map((id) => this.snapshots.get(id)).filter((snapshot) => Boolean(snapshot)).filter((snapshot) => !query.workspace || snapshot.workspace === query.workspace).filter((snapshot) => !query.sessionId || snapshot.sessionId === query.sessionId).slice(-limit);
+      }
+      clear() {
+        this.snapshots.clear();
+        this.order.splice(0, this.order.length);
+      }
+      enforceCapacity() {
+        while (this.order.length > this.capacity) {
+          const evictedId = this.order.shift();
+          if (evictedId) this.snapshots.delete(evictedId);
+        }
+      }
+    };
+    function createGitSnapshotStore(options = {}) {
+      return new InMemoryGitSnapshotStore(options);
+    }
+    var DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS = 5e3;
+    var MIN_GIT_WORKSPACE_POLL_INTERVAL_MS = 1e3;
+    function defaultStatusProvider(workspace) {
+      return getGitRepoStatus(workspace);
+    }
+    function defaultDiffSummaryProvider(workspace) {
+      return getGitDiffSummary(workspace);
+    }
+    function normalizeIntervalMs(value, defaultIntervalMs, minIntervalMs) {
+      const requested = Number.isFinite(value) ? Math.floor(value) : defaultIntervalMs;
+      return Math.max(minIntervalMs, requested > 0 ? requested : defaultIntervalMs);
+    }
+    function normalizeGitWorkspaceSubscriptionParams2(params, options = {}) {
+      const minIntervalMs = Math.max(1, Math.floor(options.minIntervalMs ?? MIN_GIT_WORKSPACE_POLL_INTERVAL_MS));
+      const defaultIntervalMs = Math.max(minIntervalMs, Math.floor(options.defaultIntervalMs ?? DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS));
+      return {
+        workspace: params.workspace,
+        includeDiffSummary: Boolean(params.includeDiffSummary),
+        intervalMs: normalizeIntervalMs(params.intervalMs, defaultIntervalMs, minIntervalMs)
+      };
+    }
+    var GitWorkspaceMonitor = class {
+      getStatusProvider;
+      getDiffSummaryProvider;
+      now;
+      minIntervalMs;
+      defaultIntervalMs;
+      keyPrefix;
+      cache = /* @__PURE__ */ new Map();
+      listeners = /* @__PURE__ */ new Set();
+      seq = 0;
+      constructor(options = {}) {
+        this.getStatusProvider = options.getStatus ?? defaultStatusProvider;
+        this.getDiffSummaryProvider = options.getDiffSummary ?? defaultDiffSummaryProvider;
+        this.now = options.now ?? Date.now;
+        this.minIntervalMs = Math.max(1, Math.floor(options.minIntervalMs ?? MIN_GIT_WORKSPACE_POLL_INTERVAL_MS));
+        this.defaultIntervalMs = Math.max(
+          this.minIntervalMs,
+          Math.floor(options.defaultIntervalMs ?? DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS)
+        );
+        this.keyPrefix = options.keyPrefix ?? "git";
+      }
+      async refresh(params) {
+        const normalized = this.normalize(typeof params === "string" ? { workspace: params } : params);
+        const status = await this.getStatusProvider(normalized.workspace);
+        const diffSummary = normalized.includeDiffSummary ? await this.getDiffSummaryProvider(normalized.workspace, status) : void 0;
+        const compactSummary = createGitCompactSummary(status, diffSummary);
+        const timestamp = this.now();
+        const seq = ++this.seq;
+        const key = this.keyForWorkspace(normalized.workspace);
+        const update = {
+          topic: "workspace.git",
+          key,
+          workspace: normalized.workspace,
+          status,
+          diffSummary,
+          seq,
+          timestamp
+        };
+        const cacheEntry = {
+          key,
+          workspace: normalized.workspace,
+          status,
+          diffSummary,
+          compactSummary,
+          seq,
+          timestamp
+        };
+        this.cache.set(normalized.workspace, cacheEntry);
+        this.emit(update, cacheEntry);
+        return update;
+      }
+      poll(params) {
+        return this.refresh(params);
+      }
+      getCached(workspace) {
+        return this.cache.get(workspace);
+      }
+      getCompactSummary(workspace) {
+        return this.cache.get(workspace)?.compactSummary;
+      }
+      onUpdate(listener) {
+        this.listeners.add(listener);
+        return () => {
+          this.listeners.delete(listener);
+        };
+      }
+      createSubscription(params, listener) {
+        const normalized = this.normalize(params);
+        const scopedListener = listener ? (update, cacheEntry) => {
+          if (update.workspace === normalized.workspace) listener(update, cacheEntry);
+        } : void 0;
+        const unsubscribe = scopedListener ? this.onUpdate(scopedListener) : () => void 0;
+        return {
+          params: normalized,
+          refresh: () => this.refresh(normalized),
+          getCached: () => this.getCached(normalized.workspace),
+          dispose: unsubscribe
+        };
+      }
+      normalize(params) {
+        return normalizeGitWorkspaceSubscriptionParams2(params, {
+          defaultIntervalMs: this.defaultIntervalMs,
+          minIntervalMs: this.minIntervalMs
+        });
+      }
+      keyForWorkspace(workspace) {
+        return `${this.keyPrefix}:${workspace}`;
+      }
+      emit(update, cacheEntry) {
+        for (const listener of this.listeners) {
+          listener(update, cacheEntry);
+        }
+      }
+    };
+    function createGitWorkspaceMonitor2(options = {}) {
+      return new GitWorkspaceMonitor(options);
+    }
+    var path32 = __toESM2(require("path"));
+    var GIT_COMMAND_NAMES = /* @__PURE__ */ new Set([
+      "git_status",
+      "git_diff_summary",
+      "git_diff_file",
+      "git_snapshot_create",
+      "git_snapshot_compare",
+      "git_log",
+      "git_checkpoint",
+      "git_stash_push",
+      "git_stash_pop",
+      "git_checkout_files"
+    ]);
+    var MUTATING_COMMAND_NAMES = /* @__PURE__ */ new Set([
+      "git_checkpoint",
+      "git_stash_push",
+      "git_stash_pop",
+      "git_checkout_files"
+    ]);
+    var SNAPSHOT_REASONS = /* @__PURE__ */ new Set([
+      "session_baseline",
+      "before_user_input_dispatch",
+      "before_agent_work",
+      "after_agent_work",
+      "manual"
+    ]);
+    var FAILURE_REASONS = /* @__PURE__ */ new Set([
+      "not_git_repo",
+      "git_not_installed",
+      "timeout",
+      "path_outside_repo",
+      "dirty_index_required",
+      "conflict",
+      "invalid_args",
+      "git_command_failed"
+    ]);
+    function failure(reason, error48) {
+      return { success: false, reason, error: error48 };
+    }
+    function serviceNotImplemented(command) {
+      return failure("invalid_args", `${command} is not implemented: daemon-core Git service is not configured`);
+    }
+    var defaultSnapshotStore = createGitSnapshotStore({
+      getStatus: (workspace) => getGitRepoStatus(workspace),
+      getDiffSummary: (workspace) => getGitDiffSummary(workspace)
+    });
+    function createDefaultGitCommandServices() {
+      return {
+        getStatus: ({ workspace }) => getGitRepoStatus(workspace),
+        getDiffSummary: ({ workspace }) => getGitDiffSummary(workspace),
+        getDiffFile: ({ workspace, path: filePath }) => getGitFileDiff(workspace, filePath),
+        createSnapshot: ({ workspace, reason, sessionId, turnId }) => defaultSnapshotStore.create({
+          workspace,
+          reason,
+          sessionId,
+          turnId
+        }),
+        compareSnapshots: ({ beforeSnapshotId, afterSnapshotId }) => defaultSnapshotStore.compare(beforeSnapshotId, afterSnapshotId),
+        getLog: ({ workspace, limit, path: filePath, since, until }) => getGitLog(workspace, { limit, path: filePath, since, until })
+      };
+    }
+    var defaultGitCommandServices = createDefaultGitCommandServices();
+    function validateWorkspace2(args) {
+      if (typeof args?.workspace !== "string") {
+        return failure("invalid_args", "workspace must be a non-empty absolute path");
+      }
+      const workspace = args.workspace.trim();
+      if (!workspace || !path32.isAbsolute(workspace)) {
+        return failure("invalid_args", "workspace must be a non-empty absolute path");
+      }
+      return { workspace };
+    }
+    function validateRepoPath(args) {
+      if (typeof args?.path !== "string" || !args.path.trim()) {
+        return failure("invalid_args", "path must be a non-empty repository-relative path");
+      }
+      return { path: args.path.trim() };
+    }
+    function validateSnapshotId(args, key) {
+      if (typeof args?.[key] !== "string" || !args[key].trim()) {
+        return failure("invalid_args", `${key} must be a non-empty string`);
+      }
+      return args[key].trim();
+    }
+    function parseSnapshotReason(args) {
+      if (args?.reason === void 0 || args?.reason === null || args?.reason === "") {
+        return "manual";
+      }
+      if (typeof args.reason !== "string" || !SNAPSHOT_REASONS.has(args.reason)) {
+        return failure("invalid_args", "reason must be a valid GitSnapshotReason");
+      }
+      return args.reason;
+    }
+    function optionalString(value) {
+      return typeof value === "string" && value.trim() ? value.trim() : void 0;
+    }
+    function optionalBoolean(value) {
+      return typeof value === "boolean" ? value : void 0;
+    }
+    function boundedLogLimit(value) {
+      if (value === void 0 || value === null || value === "") return 50;
+      const numeric = typeof value === "number" ? value : Number(value);
+      if (!Number.isFinite(numeric)) return 50;
+      return Math.max(1, Math.min(200, Math.floor(numeric)));
+    }
+    function failureReasonFromError(error48) {
+      return typeof error48?.reason === "string" && FAILURE_REASONS.has(error48.reason) ? error48.reason : "git_command_failed";
+    }
+    async function runService(fn2) {
+      try {
+        return await fn2();
+      } catch (error48) {
+        return failure(failureReasonFromError(error48), error48?.message || "Git command failed");
+      }
+    }
+    function isGitCommandName(command) {
+      return GIT_COMMAND_NAMES.has(command);
+    }
+    async function handleGitCommand(command, args, services = defaultGitCommandServices) {
+      if (!isGitCommandName(command)) {
+        return failure("invalid_args", `Unknown Git command: ${command}`);
+      }
+      if (MUTATING_COMMAND_NAMES.has(command)) {
+        return failure("invalid_args", `${command} is not implemented in daemon-core read-only Git routing`);
+      }
+      const workspaceResult = validateWorkspace2(args);
+      if ("success" in workspaceResult) return workspaceResult;
+      const { workspace } = workspaceResult;
+      switch (command) {
+        case "git_status": {
+          if (!services.getStatus) return serviceNotImplemented(command);
+          const status = await runService(() => services.getStatus({ workspace }));
+          return "success" in status ? status : { success: true, status };
+        }
+        case "git_diff_summary": {
+          if (!services.getDiffSummary) return serviceNotImplemented(command);
+          const diffSummary = await runService(() => services.getDiffSummary({ workspace, staged: optionalBoolean(args?.staged) }));
+          return "success" in diffSummary ? diffSummary : { success: true, diffSummary };
+        }
+        case "git_diff_file": {
+          if (!services.getDiffFile) return serviceNotImplemented(command);
+          const pathResult = validateRepoPath(args);
+          if (typeof pathResult !== "object" || "success" in pathResult) return pathResult;
+          const diff = await runService(() => services.getDiffFile({
+            workspace,
+            path: pathResult.path,
+            staged: optionalBoolean(args?.staged)
+          }));
+          return "success" in diff ? diff : { success: true, diff };
+        }
+        case "git_snapshot_create": {
+          if (!services.createSnapshot) return serviceNotImplemented(command);
+          const reason = parseSnapshotReason(args);
+          if (typeof reason !== "string") return reason;
+          const snapshot = await runService(() => services.createSnapshot({
+            workspace,
+            reason,
+            sessionId: optionalString(args?.sessionId),
+            turnId: optionalString(args?.turnId)
+          }));
+          return "success" in snapshot ? snapshot : { success: true, snapshot };
+        }
+        case "git_snapshot_compare": {
+          if (!services.compareSnapshots) return serviceNotImplemented(command);
+          const beforeSnapshotId = validateSnapshotId(args, "beforeSnapshotId");
+          if (typeof beforeSnapshotId !== "string") return beforeSnapshotId;
+          const afterSnapshotId = validateSnapshotId(args, "afterSnapshotId");
+          if (typeof afterSnapshotId !== "string") return afterSnapshotId;
+          const compare = await runService(() => services.compareSnapshots({ workspace, beforeSnapshotId, afterSnapshotId }));
+          return "success" in compare ? compare : { success: true, compare };
+        }
+        case "git_log": {
+          if (!services.getLog) {
+            return failure("invalid_args", "git_log is not implemented: bounded daemon-core Git log service is not configured");
+          }
+          const log = await runService(() => services.getLog({
+            workspace,
+            limit: boundedLogLimit(args?.limit),
+            path: optionalString(args?.path),
+            since: optionalString(args?.since),
+            until: optionalString(args?.until)
+          }));
+          return "success" in log ? log : { success: true, log };
+        }
+        default:
+          return failure("invalid_args", `Unknown Git command: ${command}`);
+      }
+    }
+    function formatOptionalGitLogRangeArg(flag, value) {
+      return value ? [`${flag}=${value}`] : [];
+    }
+    async function getGitLog(workspace, options) {
+      const lastCheckedAt = Date.now();
+      const repo = await resolveGitRepository(workspace);
+      const repoRoot = repo.repoRoot;
+      const boundedLimit = Math.max(1, Math.min(200, Math.floor(options.limit || 50)));
+      const selectedPath = options.path ? validateGitLogPath(repoRoot, options.path) : void 0;
+      const result = await runGit(
+        repo,
+        [
+          "log",
+          `--max-count=${boundedLimit}`,
+          "--format=%H%x00%an%x00%ae%x00%at%x00%ct%x00%s",
+          ...formatOptionalGitLogRangeArg("--since", options.since),
+          ...formatOptionalGitLogRangeArg("--until", options.until),
+          "--",
+          ...selectedPath ? [selectedPath] : []
+        ],
+        { cwd: repoRoot }
+      );
+      const entries = result.stdout.split("\n").filter((line) => line.trim().length > 0).map((line) => {
+        const [commit = "", authorName, authorEmail, authoredAt, committedAt, ...messageParts] = line.split("\0");
+        return {
+          commit,
+          message: messageParts.join("\0"),
+          authorName: authorName || void 0,
+          authorEmail: authorEmail || void 0,
+          authoredAt: authoredAt ? Number.parseInt(authoredAt, 10) * 1e3 : void 0,
+          committedAt: committedAt ? Number.parseInt(committedAt, 10) * 1e3 : void 0
+        };
+      }).filter((entry) => entry.commit.length > 0);
+      return {
+        workspace: repo.workspace,
+        repoRoot,
+        isGitRepo: true,
+        entries,
+        limit: boundedLimit,
+        truncated: entries.length >= boundedLimit,
+        lastCheckedAt
+      };
+    }
+    function validateGitLogPath(repoRoot, filePath) {
+      if (!filePath.trim() || filePath.includes("\0")) {
+        throw new GitCommandError("invalid_args", "path must be a non-empty repository-relative path");
+      }
+      if (path32.isAbsolute(filePath)) {
+        throw new GitCommandError("invalid_args", "path must be repository-relative");
+      }
+      const normalized = path32.normalize(filePath).split(path32.sep).join("/");
+      const absolutePath = path32.resolve(repoRoot, normalized);
+      if (!isPathInside(repoRoot, absolutePath) || normalized.startsWith("../") || normalized === "..") {
+        throw new GitCommandError("path_outside_repo", "Git log path is outside the repository root");
+      }
+      return normalized;
+    }
     init_config();
     var fs5 = __toESM2(require("fs"));
     var os6 = __toESM2(require("os"));
-    var path5 = __toESM2(require("path"));
+    var path42 = __toESM2(require("path"));
     var import_crypto22 = require("crypto");
     var MAX_WORKSPACES = 50;
     function expandPath(p) {
       const t = (p || "").trim();
       if (!t) return "";
-      if (t.startsWith("~")) return path5.join(os6.homedir(), t.slice(1).replace(/^\//, ""));
-      return path5.resolve(t);
+      if (t.startsWith("~")) return path42.join(os6.homedir(), t.slice(1).replace(/^\//, ""));
+      return path42.resolve(t);
     }
     function validateWorkspacePath(absPath) {
       try {
@@ -32572,7 +33697,7 @@ var require_dist2 = __commonJS({
       }
     }
     function defaultWorkspaceLabel(absPath) {
-      const base = path5.basename(absPath) || absPath;
+      const base = path42.basename(absPath) || absPath;
       return base;
     }
     function getDefaultWorkspacePath(config2) {
@@ -32663,9 +33788,9 @@ var require_dist2 = __commonJS({
       return getDefaultWorkspacePath(config2) || void 0;
     }
     function findWorkspaceByPath(config2, rawPath) {
-      const abs = path5.resolve(expandPath(rawPath));
+      const abs = path42.resolve(expandPath(rawPath));
       if (!abs) return void 0;
-      return (config2.workspaces || []).find((w) => path5.resolve(expandPath(w.path)) === abs);
+      return (config2.workspaces || []).find((w) => path42.resolve(expandPath(w.path)) === abs);
     }
     function addWorkspaceEntry(config2, rawPath, label, options) {
       const abs = expandPath(rawPath);
@@ -32681,7 +33806,7 @@ var require_dist2 = __commonJS({
       const v2 = validateWorkspacePath(abs);
       if (!v2.ok) return { error: v2.error };
       const list = [...config2.workspaces || []];
-      if (list.some((w) => path5.resolve(w.path) === abs)) {
+      if (list.some((w) => path42.resolve(w.path) === abs)) {
         return { error: "Workspace already in list" };
       }
       if (list.length >= MAX_WORKSPACES) {
@@ -32713,7 +33838,7 @@ var require_dist2 = __commonJS({
       if (validateWorkspacePath(abs).ok !== true) return { error: "Workspace path is no longer valid" };
       return { config: { ...config2, defaultWorkspaceId: id } };
     }
-    var path23 = __toESM2(require("path"));
+    var path52 = __toESM2(require("path"));
     function normalizeSummaryItem(item) {
       if (!item || typeof item !== "object") return null;
       const id = String(item.id || "").trim();
@@ -32778,9 +33903,9 @@ var require_dist2 = __commonJS({
     function normalizeWorkspace(workspace) {
       if (!workspace) return "";
       try {
-        return path23.resolve(expandPath(workspace));
+        return path52.resolve(expandPath(workspace));
       } catch {
-        return path23.resolve(workspace);
+        return path52.resolve(workspace);
       }
     }
     function buildRecentActivityKey(entry) {
@@ -32946,14 +34071,14 @@ var require_dist2 = __commonJS({
         sessionNotificationUnreadOverrides: nextSessionNotificationUnreadOverrides
       };
     }
-    var path32 = __toESM2(require("path"));
+    var path6 = __toESM2(require("path"));
     var MAX_SAVED_SESSIONS = 500;
     function normalizeWorkspace2(workspace) {
       if (!workspace) return "";
       try {
-        return path32.resolve(expandPath(workspace));
+        return path6.resolve(expandPath(workspace));
       } catch {
-        return path32.resolve(workspace);
+        return path6.resolve(workspace);
       }
     }
     function buildSavedProviderSessionKey(providerSessionId) {
@@ -33068,7 +34193,7 @@ var require_dist2 = __commonJS({
     var import_child_process = require("child_process");
     var import_fs3 = require("fs");
     var import_os22 = require("os");
-    var path42 = __toESM2(require("path"));
+    var path7 = __toESM2(require("path"));
     var BUILTIN_IDE_DEFINITIONS = [];
     var registeredIDEs = /* @__PURE__ */ new Map();
     function registerIDEDefinition(def) {
@@ -33087,9 +34212,9 @@ var require_dist2 = __commonJS({
     function findCliCommand(command) {
       const trimmed = String(command || "").trim();
       if (!trimmed) return null;
-      if (path42.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
-        const candidate = trimmed.startsWith("~") ? path42.join((0, import_os22.homedir)(), trimmed.slice(1)) : trimmed;
-        const resolved = path42.isAbsolute(candidate) ? candidate : path42.resolve(candidate);
+      if (path7.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+        const candidate = trimmed.startsWith("~") ? path7.join((0, import_os22.homedir)(), trimmed.slice(1)) : trimmed;
+        const resolved = path7.isAbsolute(candidate) ? candidate : path7.resolve(candidate);
         return (0, import_fs3.existsSync)(resolved) ? resolved : null;
       }
       try {
@@ -33117,7 +34242,7 @@ var require_dist2 = __commonJS({
     function checkPathExists(paths) {
       const home = (0, import_os22.homedir)();
       for (const p of paths) {
-        const normalized = p.startsWith("~") ? path42.join(home, p.slice(1)) : p;
+        const normalized = p.startsWith("~") ? path7.join(home, p.slice(1)) : p;
         if (normalized.includes("*")) {
           const username = home.split(/[\\/]/).pop() || "";
           const resolved = normalized.replace("*", username);
@@ -33173,7 +34298,7 @@ var require_dist2 = __commonJS({
     }
     var import_child_process2 = require("child_process");
     var os22 = __toESM2(require("os"));
-    var path52 = __toESM2(require("path"));
+    var path8 = __toESM2(require("path"));
     var import_fs4 = require("fs");
     function parseVersion(raw) {
       const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
@@ -33186,36 +34311,36 @@ var require_dist2 = __commonJS({
     function expandHome(value) {
       const trimmed = value.trim();
       if (!trimmed.startsWith("~")) return trimmed;
-      return path52.join(os22.homedir(), trimmed.slice(1));
+      return path8.join(os22.homedir(), trimmed.slice(1));
     }
     function isExplicitCommandPath(command) {
       const trimmed = command.trim();
-      return path52.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+      return path8.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
     }
     function resolveCommandPath(command) {
       const trimmed = command.trim();
       if (!trimmed) return null;
       if (isExplicitCommandPath(trimmed)) {
         const expanded = expandHome(trimmed);
-        const candidate = path52.isAbsolute(expanded) ? expanded : path52.resolve(expanded);
+        const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
         return (0, import_fs4.existsSync)(candidate) ? candidate : null;
       }
       return null;
     }
     function execAsync(cmd, timeoutMs = 5e3) {
-      return new Promise((resolve12) => {
+      return new Promise((resolve15) => {
         const child = (0, import_child_process2.exec)(cmd, {
           encoding: "utf-8",
           timeout: timeoutMs,
           ...process.platform === "win32" ? { windowsHide: true } : {}
         }, (err, stdout) => {
           if (err || !stdout?.trim()) {
-            resolve12(null);
+            resolve15(null);
           } else {
-            resolve12(stdout.trim());
+            resolve15(stdout.trim());
           }
         });
-        child.on("error", () => resolve12(null));
+        child.on("error", () => resolve15(null));
       });
     }
     async function detectCLIs(providerLoader, options) {
@@ -33572,7 +34697,7 @@ var require_dist2 = __commonJS({
       * Returns multiple entries if multiple IDE windows are open on same port
       */
       static listAllTargets(port) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve15) => {
           const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk.toString());
@@ -33588,16 +34713,16 @@ var require_dist2 = __commonJS({
                   (t) => !isNonMain(t.title || "") && t.url?.includes("workbench.html") && !t.url?.includes("agent")
                 );
                 const fallbackPages = pages.filter((t) => !isNonMain(t.title || ""));
-                resolve12(mainPages.length > 0 ? mainPages : fallbackPages);
+                resolve15(mainPages.length > 0 ? mainPages : fallbackPages);
               } catch {
-                resolve12([]);
+                resolve15([]);
               }
             });
           });
-          req.on("error", () => resolve12([]));
+          req.on("error", () => resolve15([]));
           req.setTimeout(2e3, () => {
             req.destroy();
-            resolve12([]);
+            resolve15([]);
           });
         });
       }
@@ -33637,7 +34762,7 @@ var require_dist2 = __commonJS({
         }
       }
       findTargetOnPort(port) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve15) => {
           const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk.toString());
@@ -33648,7 +34773,7 @@ var require_dist2 = __commonJS({
                   (t) => (t.type === "page" || t.type === "browser" || t.type === "Page") && t.webSocketDebuggerUrl
                 );
                 if (pages.length === 0) {
-                  resolve12(targets.find((t) => t.webSocketDebuggerUrl) || null);
+                  resolve15(targets.find((t) => t.webSocketDebuggerUrl) || null);
                   return;
                 }
                 const titleFilteredPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
@@ -33667,25 +34792,25 @@ var require_dist2 = __commonJS({
                     this._targetId = selected.target.id;
                   }
                   this._pageTitle = selected.target.title || "";
-                  resolve12(selected.target);
+                  resolve15(selected.target);
                   return;
                 }
                 if (previousTargetId) {
                   this.log(`[CDP] Target ${previousTargetId} not found in page list`);
-                  resolve12(null);
+                  resolve15(null);
                   return;
                 }
                 this._pageTitle = list[0]?.title || "";
-                resolve12(list[0]);
+                resolve15(list[0]);
               } catch {
-                resolve12(null);
+                resolve15(null);
               }
             });
           });
-          req.on("error", () => resolve12(null));
+          req.on("error", () => resolve15(null));
           req.setTimeout(2e3, () => {
             req.destroy();
-            resolve12(null);
+            resolve15(null);
           });
         });
       }
@@ -33696,7 +34821,7 @@ var require_dist2 = __commonJS({
         this.extensionProviders = providers;
       }
       connectToTarget(wsUrl) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve15) => {
           this.ws = new import_ws2.default(wsUrl);
           this.ws.on("open", async () => {
             this._connected = true;
@@ -33706,17 +34831,17 @@ var require_dist2 = __commonJS({
             }
             this.connectBrowserWs().catch(() => {
             });
-            resolve12(true);
+            resolve15(true);
           });
           this.ws.on("message", (data) => {
             try {
               const msg = JSON.parse(data.toString());
               if (msg.id && this.pending.has(msg.id)) {
-                const { resolve: resolve13, reject } = this.pending.get(msg.id);
+                const { resolve: resolve16, reject } = this.pending.get(msg.id);
                 this.pending.delete(msg.id);
                 this.failureCount = 0;
                 if (msg.error) reject(new Error(msg.error.message));
-                else resolve13(msg.result);
+                else resolve16(msg.result);
               } else if (msg.method === "Runtime.executionContextCreated") {
                 this.contexts.add(msg.params.context.id);
               } else if (msg.method === "Runtime.executionContextDestroyed") {
@@ -33739,7 +34864,7 @@ var require_dist2 = __commonJS({
           this.ws.on("error", (err) => {
             this.log(`[CDP] WebSocket error: ${err.message}`);
             this._connected = false;
-            resolve12(false);
+            resolve15(false);
           });
         });
       }
@@ -33753,7 +34878,7 @@ var require_dist2 = __commonJS({
             return;
           }
           this.log(`[CDP] Connecting browser WS for target discovery...`);
-          await new Promise((resolve12, reject) => {
+          await new Promise((resolve15, reject) => {
             this.browserWs = new import_ws2.default(browserWsUrl);
             this.browserWs.on("open", async () => {
               this._browserConnected = true;
@@ -33763,16 +34888,16 @@ var require_dist2 = __commonJS({
               } catch (e) {
                 this.log(`[CDP] setDiscoverTargets failed: ${e.message}`);
               }
-              resolve12();
+              resolve15();
             });
             this.browserWs.on("message", (data) => {
               try {
                 const msg = JSON.parse(data.toString());
                 if (msg.id && this.browserPending.has(msg.id)) {
-                  const { resolve: resolve13, reject: reject2 } = this.browserPending.get(msg.id);
+                  const { resolve: resolve16, reject: reject2 } = this.browserPending.get(msg.id);
                   this.browserPending.delete(msg.id);
                   if (msg.error) reject2(new Error(msg.error.message));
-                  else resolve13(msg.result);
+                  else resolve16(msg.result);
                 }
               } catch {
               }
@@ -33792,31 +34917,31 @@ var require_dist2 = __commonJS({
         }
       }
       getBrowserWsUrl() {
-        return new Promise((resolve12) => {
+        return new Promise((resolve15) => {
           const req = http.get(`http://127.0.0.1:${this.port}/json/version`, (res) => {
             let data = "";
             res.on("data", (chunk) => data += chunk.toString());
             res.on("end", () => {
               try {
                 const info = JSON.parse(data);
-                resolve12(info.webSocketDebuggerUrl || null);
+                resolve15(info.webSocketDebuggerUrl || null);
               } catch {
-                resolve12(null);
+                resolve15(null);
               }
             });
           });
-          req.on("error", () => resolve12(null));
+          req.on("error", () => resolve15(null));
           req.setTimeout(3e3, () => {
             req.destroy();
-            resolve12(null);
+            resolve15(null);
           });
         });
       }
       sendBrowser(method, params = {}, timeoutMs = 15e3) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve15, reject) => {
           if (!this.browserWs || !this._browserConnected) return reject(new Error("Browser WS not connected"));
           const id = this.browserMsgId++;
-          this.browserPending.set(id, { resolve: resolve12, reject });
+          this.browserPending.set(id, { resolve: resolve15, reject });
           this.browserWs.send(JSON.stringify({ id, method, params }));
           setTimeout(() => {
             if (this.browserPending.has(id)) {
@@ -33856,11 +34981,11 @@ var require_dist2 = __commonJS({
       }
       // ─── CDP Protocol ────────────────────────────────────────
       sendInternal(method, params = {}, timeoutMs = 15e3) {
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve15, reject) => {
           if (!this.ws || !this._connected) return reject(new Error("CDP not connected"));
           if (this.ws.readyState !== import_ws2.default.OPEN) return reject(new Error("WebSocket not open"));
           const id = this.msgId++;
-          this.pending.set(id, { resolve: resolve12, reject });
+          this.pending.set(id, { resolve: resolve15, reject });
           this.ws.send(JSON.stringify({ id, method, params }));
           setTimeout(() => {
             if (this.pending.has(id)) {
@@ -34109,7 +35234,7 @@ var require_dist2 = __commonJS({
         const browserWs = this.browserWs;
         let msgId = this.browserMsgId;
         const sendWs = (method, params = {}, sessionId) => {
-          return new Promise((resolve12, reject) => {
+          return new Promise((resolve15, reject) => {
             const mid = msgId++;
             this.browserMsgId = msgId;
             const handler = (raw) => {
@@ -34118,7 +35243,7 @@ var require_dist2 = __commonJS({
                 if (msg.id === mid) {
                   browserWs.removeListener("message", handler);
                   if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-                  else resolve12(msg.result);
+                  else resolve15(msg.result);
                 }
               } catch {
               }
@@ -34319,14 +35444,14 @@ var require_dist2 = __commonJS({
         if (!ws2 || ws2.readyState !== import_ws2.default.OPEN) {
           throw new Error("CDP not connected");
         }
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve15, reject) => {
           const id = getNextId();
           pendingMap.set(id, {
             resolve: (result) => {
               if (result?.result?.subtype === "error") {
                 reject(new Error(result.result.description));
               } else {
-                resolve12(result?.result?.value);
+                resolve15(result?.result?.value);
               }
             },
             reject
@@ -34358,10 +35483,10 @@ var require_dist2 = __commonJS({
           throw new Error("CDP not connected");
         }
         const sendViaSession = (method, params = {}) => {
-          return new Promise((resolve12, reject) => {
+          return new Promise((resolve15, reject) => {
             const pendingMap = this._browserConnected ? this.browserPending : this.pending;
             const id = this._browserConnected ? this.browserMsgId++ : this.msgId++;
-            pendingMap.set(id, { resolve: resolve12, reject });
+            pendingMap.set(id, { resolve: resolve15, reject });
             ws2.send(JSON.stringify({ id, sessionId, method, params }));
             setTimeout(() => {
               if (pendingMap.has(id)) {
@@ -35095,10 +36220,10 @@ ${cleanBody}`;
       return cleanTitle || cleanBody;
     }
     var fs32 = __toESM2(require("fs"));
-    var path7 = __toESM2(require("path"));
+    var path10 = __toESM2(require("path"));
     var os52 = __toESM2(require("os"));
     init_chat_message_normalization();
-    var HISTORY_DIR = path7.join(os52.homedir(), ".adhdev", "history");
+    var HISTORY_DIR = path10.join(os52.homedir(), ".adhdev", "history");
     var RETAIN_DAYS = 30;
     var SAVED_HISTORY_INDEX_VERSION = 1;
     var SAVED_HISTORY_INDEX_FILE = ".saved-history-index.json";
@@ -35261,8 +36386,8 @@ ${cleanBody}`;
     function buildSavedHistoryFileSignatureMap(dir, files) {
       return new Map(files.map((file2) => {
         try {
-          const stat4 = fs32.statSync(path7.join(dir, file2));
-          return [file2, `${file2}:${stat4.size}:${Math.trunc(stat4.mtimeMs)}`];
+          const stat22 = fs32.statSync(path10.join(dir, file2));
+          return [file2, `${file2}:${stat22.size}:${Math.trunc(stat22.mtimeMs)}`];
         } catch {
           return [file2, `${file2}:missing`];
         }
@@ -35272,7 +36397,7 @@ ${cleanBody}`;
       return files.map((file2) => fileSignatures.get(file2) || `${file2}:missing`).join("|");
     }
     function getSavedHistoryIndexFilePath(dir) {
-      return path7.join(dir, SAVED_HISTORY_INDEX_FILE);
+      return path10.join(dir, SAVED_HISTORY_INDEX_FILE);
     }
     function getSavedHistoryIndexLockPath(dir) {
       return `${getSavedHistoryIndexFilePath(dir)}${SAVED_HISTORY_INDEX_LOCK_SUFFIX}`;
@@ -35325,8 +36450,8 @@ ${cleanBody}`;
         } catch (error48) {
           if (error48?.code !== "EEXIST") return null;
           try {
-            const stat4 = fs32.statSync(lockPath);
-            if (Date.now() - stat4.mtimeMs > SAVED_HISTORY_INDEX_LOCK_STALE_MS) {
+            const stat22 = fs32.statSync(lockPath);
+            if (Date.now() - stat22.mtimeMs > SAVED_HISTORY_INDEX_LOCK_STALE_MS) {
               fs32.rmSync(lockPath, { recursive: true, force: true });
               continue;
             }
@@ -35374,7 +36499,7 @@ ${cleanBody}`;
         }
         for (const file2 of Array.from(currentEntries.keys())) {
           if (incomingFiles.has(file2)) continue;
-          if (!fs32.existsSync(path7.join(dir, file2))) {
+          if (!fs32.existsSync(path10.join(dir, file2))) {
             currentEntries.delete(file2);
           }
         }
@@ -35389,8 +36514,8 @@ ${cleanBody}`;
     }
     function buildSavedHistoryIndexFileSignature(dir) {
       try {
-        const stat4 = fs32.statSync(getSavedHistoryIndexFilePath(dir));
-        return `index:${stat4.size}:${Math.trunc(stat4.mtimeMs)}`;
+        const stat22 = fs32.statSync(getSavedHistoryIndexFilePath(dir));
+        return `index:${stat22.size}:${Math.trunc(stat22.mtimeMs)}`;
       } catch {
         return "index:missing";
       }
@@ -35400,8 +36525,8 @@ ${cleanBody}`;
         const indexStat = fs32.statSync(getSavedHistoryIndexFilePath(dir));
         const files = listHistoryFiles(dir);
         for (const file2 of files) {
-          const stat4 = fs32.statSync(path7.join(dir, file2));
-          if (stat4.mtimeMs > indexStat.mtimeMs) return true;
+          const stat22 = fs32.statSync(path10.join(dir, file2));
+          if (stat22.mtimeMs > indexStat.mtimeMs) return true;
         }
         return false;
       } catch {
@@ -35410,14 +36535,14 @@ ${cleanBody}`;
     }
     function buildSavedHistoryFileSignature(dir, file2) {
       try {
-        const stat4 = fs32.statSync(path7.join(dir, file2));
-        return `${file2}:${stat4.size}:${Math.trunc(stat4.mtimeMs)}`;
+        const stat22 = fs32.statSync(path10.join(dir, file2));
+        return `${file2}:${stat22.size}:${Math.trunc(stat22.mtimeMs)}`;
       } catch {
         return `${file2}:missing`;
       }
     }
     function persistSavedHistoryFileSummaryEntry(agentType, dir, file2, updater) {
-      const filePath = path7.join(dir, file2);
+      const filePath = path10.join(dir, file2);
       const result = withLockedPersistedSavedHistoryIndex(dir, (entries) => {
         const currentEntry = entries.get(file2) || null;
         const nextSummary = updater(currentEntry?.summary || null);
@@ -35490,7 +36615,7 @@ ${cleanBody}`;
     function computeSavedHistoryFileSummary(dir, file2) {
       const historySessionId = extractSavedHistorySessionIdFromFile(file2);
       if (!historySessionId) return null;
-      const filePath = path7.join(dir, file2);
+      const filePath = path10.join(dir, file2);
       const content = fs32.readFileSync(filePath, "utf-8");
       const lines = content.split("\n").filter(Boolean);
       let messageCount = 0;
@@ -35577,7 +36702,7 @@ ${cleanBody}`;
       const summaryBySessionId = /* @__PURE__ */ new Map();
       const nextPersistedEntries = /* @__PURE__ */ new Map();
       for (const file2 of files.slice().sort()) {
-        const filePath = path7.join(dir, file2);
+        const filePath = path10.join(dir, file2);
         const signature = fileSignatures.get(file2) || `${file2}:missing`;
         const cached2 = savedHistoryFileSummaryCache.get(filePath);
         const persisted = persistedEntries.get(file2);
@@ -35697,12 +36822,12 @@ ${cleanBody}`;
             });
           }
           if (newMessages.length === 0) return;
-          const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+          const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
           fs32.mkdirSync(dir, { recursive: true });
           const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
           const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
           const fileName = `${filePrefix}${date5}.jsonl`;
-          const filePath = path7.join(dir, fileName);
+          const filePath = path10.join(dir, fileName);
           const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
           fs32.appendFileSync(filePath, lines, "utf-8");
           updateSavedHistoryIndexForAppendedMessages(agentType, dir, fileName, effectiveHistoryKey, newMessages);
@@ -35793,11 +36918,11 @@ ${cleanBody}`;
         const ws2 = String(workspace || "").trim();
         if (!id || !ws2) return;
         try {
-          const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+          const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
           fs32.mkdirSync(dir, { recursive: true });
           const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
           const fileName = `${this.sanitize(id)}_${date5}.jsonl`;
-          const filePath = path7.join(dir, fileName);
+          const filePath = path10.join(dir, fileName);
           const record2 = {
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             receivedAt: Date.now(),
@@ -35843,14 +36968,14 @@ ${cleanBody}`;
             this.lastSeenCounts.set(toDedupKey, Math.max(fromCount, this.lastSeenCounts.get(toDedupKey) || 0));
             this.lastSeenCounts.delete(fromDedupKey);
           }
-          const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+          const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
           if (!fs32.existsSync(dir)) return;
           const fromPrefix = `${this.sanitize(fromId)}_`;
           const toPrefix = `${this.sanitize(toId)}_`;
           const files = fs32.readdirSync(dir).filter((file2) => file2.startsWith(fromPrefix) && file2.endsWith(".jsonl"));
           for (const file2 of files) {
-            const sourcePath = path7.join(dir, file2);
-            const targetPath = path7.join(dir, `${toPrefix}${file2.slice(fromPrefix.length)}`);
+            const sourcePath = path10.join(dir, file2);
+            const targetPath = path10.join(dir, `${toPrefix}${file2.slice(fromPrefix.length)}`);
             const sourceLines = fs32.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
             const rewritten = sourceLines.map((line) => {
               try {
@@ -35884,13 +37009,13 @@ ${cleanBody}`;
         const sessionId = String(historySessionId || "").trim();
         if (!sessionId) return;
         try {
-          const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+          const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
           if (!fs32.existsSync(dir)) return;
           const prefix = `${this.sanitize(sessionId)}_`;
           const files = fs32.readdirSync(dir).filter((file2) => file2.startsWith(prefix) && file2.endsWith(".jsonl")).sort();
           const seen = /* @__PURE__ */ new Set();
           for (const file2 of files) {
-            const filePath = path7.join(dir, file2);
+            const filePath = path10.join(dir, file2);
             const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
             const next = [];
             for (const line of lines) {
@@ -35944,13 +37069,13 @@ ${cleanBody}`;
           const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1e3;
           const agentDirs = fs32.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
           for (const dir of agentDirs) {
-            const dirPath = path7.join(HISTORY_DIR, dir.name);
+            const dirPath = path10.join(HISTORY_DIR, dir.name);
             const files = fs32.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
             let removedAny = false;
             for (const file2 of files) {
-              const filePath = path7.join(dirPath, file2);
-              const stat4 = fs32.statSync(filePath);
-              if (stat4.mtimeMs < cutoff) {
+              const filePath = path10.join(dirPath, file2);
+              const stat22 = fs32.statSync(filePath);
+              if (stat22.mtimeMs < cutoff) {
                 fs32.unlinkSync(filePath);
                 removedAny = true;
               }
@@ -35998,13 +37123,13 @@ ${cleanBody}`;
     function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, excludeRecentCount = 0, historyBehavior) {
       try {
         const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-        const dir = path7.join(HISTORY_DIR, sanitized);
+        const dir = path10.join(HISTORY_DIR, sanitized);
         if (!fs32.existsSync(dir)) return { messages: [], hasMore: false };
         const files = listHistoryFiles(dir, historySessionId);
         const allMessages = [];
         const seen = /* @__PURE__ */ new Set();
         for (const file2 of files) {
-          const filePath = path7.join(dir, file2);
+          const filePath = path10.join(dir, file2);
           const content = fs32.readFileSync(filePath, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           for (let i = 0; i < lines.length; i++) {
@@ -36028,7 +37153,7 @@ ${cleanBody}`;
     function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
       try {
         const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-        const dir = path7.join(HISTORY_DIR, sanitized);
+        const dir = path10.join(HISTORY_DIR, sanitized);
         if (!fs32.existsSync(dir)) {
           savedHistorySessionCache.delete(sanitized);
           return { sessions: [], hasMore: false };
@@ -36089,11 +37214,11 @@ ${cleanBody}`;
     }
     function readExistingSessionStartRecord(agentType, historySessionId) {
       try {
-        const dir = path7.join(HISTORY_DIR, agentType);
+        const dir = path10.join(HISTORY_DIR, agentType);
         if (!fs32.existsSync(dir)) return null;
         const files = listHistoryFiles(dir, historySessionId).sort();
         for (const file2 of files) {
-          const lines = fs32.readFileSync(path7.join(dir, file2), "utf-8").split("\n").filter(Boolean);
+          const lines = fs32.readFileSync(path10.join(dir, file2), "utf-8").split("\n").filter(Boolean);
           for (const line of lines) {
             try {
               const parsed = JSON.parse(line);
@@ -36113,16 +37238,16 @@ ${cleanBody}`;
     function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
       if (records.length === 0) return false;
       try {
-        const dir = path7.join(HISTORY_DIR, agentType);
+        const dir = path10.join(HISTORY_DIR, agentType);
         fs32.mkdirSync(dir, { recursive: true });
         const prefix = `${historySessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
         for (const file2 of fs32.readdirSync(dir)) {
           if (file2.startsWith(prefix) && file2.endsWith(".jsonl")) {
-            fs32.unlinkSync(path7.join(dir, file2));
+            fs32.unlinkSync(path10.join(dir, file2));
           }
         }
         const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
-        const filePath = path7.join(dir, `${prefix}${targetDate}.jsonl`);
+        const filePath = path10.join(dir, `${prefix}${targetDate}.jsonl`);
         fs32.writeFileSync(filePath, `${records.map((record2) => JSON.stringify(record2)).join("\n")}
 `, "utf-8");
         invalidatePersistedSavedHistoryIndex(agentType, dir);
@@ -37966,6 +39091,10 @@ ${effect.notification.body || ""}`.trim();
     function shouldIncludeRuntimeMetadata(profile) {
       return true;
     }
+    function getGitSummaryForWorkspace(workspace, options) {
+      if (!workspace) return void 0;
+      return options.getGitSummaryForWorkspace?.(workspace) || void 0;
+    }
     function findCdpManager(cdpManagers, key) {
       const exact = cdpManagers.get(key);
       if (exact) return exact.isConnected ? exact : null;
@@ -38021,6 +39150,8 @@ ${effect.notification.body || ""}`.trim();
       const controlValues = normalizeProviderStateControlValues(state.controlValues);
       const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
       const includeSessionControls = shouldIncludeSessionControls(profile);
+      const workspace = state.workspace || null;
+      const git = getGitSummaryForWorkspace(workspace, options);
       const title = activeChat?.title || state.name;
       return {
         id: state.instanceId || state.type,
@@ -38033,7 +39164,8 @@ ${effect.notification.body || ""}`.trim();
           activeModal: activeChat?.activeModal || null
         }),
         title,
-        workspace: state.workspace || null,
+        workspace,
+        ...git && { git },
         activeChat,
         ...summaryMetadata && { summaryMetadata },
         ...includeSessionMetadata && { capabilities: state.sessionCapabilities || IDE_SESSION_CAPABILITIES },
@@ -38054,6 +39186,8 @@ ${effect.notification.body || ""}`.trim();
       const controlValues = normalizeProviderStateControlValues(ext.controlValues);
       const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
       const includeSessionControls = shouldIncludeSessionControls(profile);
+      const workspace = parent.workspace || null;
+      const git = getGitSummaryForWorkspace(workspace, options);
       return {
         id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
         parentId: parent.instanceId || parent.type,
@@ -38066,7 +39200,8 @@ ${effect.notification.body || ""}`.trim();
           activeModal: activeChat?.activeModal || null
         }),
         title: activeChat?.title || ext.name,
-        workspace: parent.workspace || null,
+        workspace,
+        ...git && { git },
         activeChat,
         ...summaryMetadata && { summaryMetadata },
         ...includeSessionMetadata && { capabilities: ext.sessionCapabilities || EXTENSION_SESSION_CAPABILITIES },
@@ -38102,6 +39237,8 @@ ${effect.notification.body || ""}`.trim();
       const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
       const includeRuntimeMetadata = shouldIncludeRuntimeMetadata(profile);
       const includeSessionControls = shouldIncludeSessionControls(profile);
+      const workspace = state.workspace || null;
+      const git = getGitSummaryForWorkspace(workspace, options);
       return {
         id: state.instanceId,
         parentId: null,
@@ -38114,7 +39251,8 @@ ${effect.notification.body || ""}`.trim();
           activeModal: activeChat?.activeModal || null
         }),
         title: activeChat?.title || state.name,
-        workspace: state.workspace || null,
+        workspace,
+        ...git && { git },
         ...includeRuntimeMetadata && {
           runtimeKey: state.runtime?.runtimeKey,
           runtimeDisplayName: state.runtime?.displayName,
@@ -38149,6 +39287,8 @@ ${effect.notification.body || ""}`.trim();
       const controlValues = normalizeProviderStateControlValues(state.controlValues);
       const includeSessionMetadata = shouldIncludeSessionMetadata(profile);
       const includeSessionControls = shouldIncludeSessionControls(profile);
+      const workspace = state.workspace || null;
+      const git = getGitSummaryForWorkspace(workspace, options);
       return {
         id: state.instanceId,
         parentId: null,
@@ -38160,7 +39300,8 @@ ${effect.notification.body || ""}`.trim();
           activeModal: activeChat?.activeModal || null
         }),
         title: activeChat?.title || state.name,
-        workspace: state.workspace || null,
+        workspace,
+        ...git && { git },
         activeChat,
         ...summaryMetadata && { summaryMetadata },
         ...includeSessionMetadata && { capabilities: ACP_SESSION_CAPABILITIES },
@@ -38271,7 +39412,7 @@ ${effect.notification.body || ""}`.trim();
     }
     var fs42 = __toESM2(require("fs"));
     var os62 = __toESM2(require("os"));
-    var path8 = __toESM2(require("path"));
+    var path11 = __toESM2(require("path"));
     var import_node_crypto = require("crypto");
     init_contracts();
     var VALID_INPUT_MEDIA_TYPES = /* @__PURE__ */ new Set(["text", "image", "audio", "video", "resource"]);
@@ -38954,7 +40095,7 @@ ${effect.notification.body || ""}`.trim();
     }
     function getChatDebugBundleDir() {
       const override = typeof process.env.ADHDEV_DEBUG_BUNDLE_DIR === "string" ? process.env.ADHDEV_DEBUG_BUNDLE_DIR.trim() : "";
-      return override || path8.join(os62.homedir(), ".adhdev", "debug-bundles", "chat");
+      return override || path11.join(os62.homedir(), ".adhdev", "debug-bundles", "chat");
     }
     function safeBundleIdSegment(value, fallback) {
       const normalized = String(value || fallback).trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
@@ -38987,7 +40128,7 @@ ${effect.notification.body || ""}`.trim();
       const bundleId = createChatDebugBundleId(targetSessionId);
       const dir = getChatDebugBundleDir();
       fs42.mkdirSync(dir, { recursive: true });
-      const savedPath = path8.join(dir, `${bundleId}.json`);
+      const savedPath = path11.join(dir, `${bundleId}.json`);
       const json2 = `${JSON.stringify(bundle, null, 2)}
 `;
       fs42.writeFileSync(savedPath, json2, { encoding: "utf8", mode: 384 });
@@ -39181,7 +40322,7 @@ ${effect.notification.body || ""}`.trim();
     async function getStableExtensionBaseline(h) {
       const first = await readExtensionChatState(h);
       if (getStateMessageCount(first) > 0 || getStateLastSignature(first)) return first;
-      await new Promise((resolve12) => setTimeout(resolve12, 150));
+      await new Promise((resolve15) => setTimeout(resolve15, 150));
       const second = await readExtensionChatState(h);
       return getStateMessageCount(second) >= getStateMessageCount(first) ? second : first;
     }
@@ -39189,7 +40330,7 @@ ${effect.notification.body || ""}`.trim();
       const beforeCount = getStateMessageCount(before);
       const beforeSignature = getStateLastSignature(before);
       for (let attempt = 0; attempt < 12; attempt += 1) {
-        await new Promise((resolve12) => setTimeout(resolve12, 250));
+        await new Promise((resolve15) => setTimeout(resolve15, 250));
         const state = await readExtensionChatState(h);
         if (state?.status === "waiting_approval") return true;
         const afterCount = getStateMessageCount(state);
@@ -40123,7 +41264,7 @@ ${effect.notification.body || ""}`.trim();
       return { success: false, error: "resolveAction script not available for this provider" };
     }
     var fs52 = __toESM2(require("fs"));
-    var path9 = __toESM2(require("path"));
+    var path12 = __toESM2(require("path"));
     var os7 = __toESM2(require("os"));
     var KEY_TO_VK = {
       Backspace: 8,
@@ -40380,25 +41521,25 @@ ${effect.notification.body || ""}`.trim();
       const inputPath = rawPath || ".";
       const home = os7.homedir();
       if (inputPath.startsWith("~")) {
-        return path9.resolve(path9.join(home, inputPath.slice(1)));
+        return path12.resolve(path12.join(home, inputPath.slice(1)));
       }
       if (process.platform === "win32") {
         const normalized = normalizeWindowsRequestedPath(inputPath);
-        if (path9.win32.isAbsolute(normalized)) {
-          return path9.win32.normalize(normalized);
+        if (path12.win32.isAbsolute(normalized)) {
+          return path12.win32.normalize(normalized);
         }
-        return path9.win32.resolve(normalized);
+        return path12.win32.resolve(normalized);
       }
-      if (path9.isAbsolute(inputPath)) {
-        return path9.normalize(inputPath);
+      if (path12.isAbsolute(inputPath)) {
+        return path12.normalize(inputPath);
       }
-      return path9.resolve(inputPath);
+      return path12.resolve(inputPath);
     }
     function listDirectoryEntriesSafe(dirPath) {
       const entries = fs52.readdirSync(dirPath, { withFileTypes: true });
       const files = [];
       for (const entry of entries) {
-        const entryPath = path9.join(dirPath, entry.name);
+        const entryPath = path12.join(dirPath, entry.name);
         try {
           if (entry.isDirectory()) {
             files.push({ name: entry.name, type: "directory" });
@@ -40414,11 +41555,11 @@ ${effect.notification.body || ""}`.trim();
             files.push({ name: entry.name, type: "file", size });
             continue;
           }
-          const stat4 = fs52.statSync(entryPath);
+          const stat22 = fs52.statSync(entryPath);
           files.push({
             name: entry.name,
-            type: stat4.isDirectory() ? "directory" : "file",
-            size: stat4.isFile() ? stat4.size : void 0
+            type: stat22.isDirectory() ? "directory" : "file",
+            size: stat22.isFile() ? stat22.size : void 0
           });
         } catch {
         }
@@ -40452,7 +41593,7 @@ ${effect.notification.body || ""}`.trim();
     async function handleFileWrite(h, args) {
       try {
         const filePath = resolveSafePath(args?.path);
-        fs52.mkdirSync(path9.dirname(filePath), { recursive: true });
+        fs52.mkdirSync(path12.dirname(filePath), { recursive: true });
         fs52.writeFileSync(filePath, args?.content || "", "utf-8");
         return { success: true, path: filePath };
       } catch (e) {
@@ -40793,7 +41934,7 @@ ${effect.notification.body || ""}`.trim();
             const enterCount = cliCommand.enterCount || 1;
             await adapter.writeRaw(cliCommand.text + "\r");
             for (let i = 1; i < enterCount; i += 1) {
-              await new Promise((resolve12) => setTimeout(resolve12, 50));
+              await new Promise((resolve15) => setTimeout(resolve15, 50));
               await adapter.writeRaw("\r");
             }
           }
@@ -41283,6 +42424,12 @@ ${effect.notification.body || ""}`.trim();
         this._currentRoute = this.resolveRoute(args);
         const startedAt = Date.now();
         this.logCommandStart(cmd, args);
+        let result;
+        if (isGitCommandName(cmd)) {
+          result = await handleGitCommand(cmd, args, this._ctx.gitCommandServices);
+          this.logCommandEnd(cmd, result, startedAt);
+          return result;
+        }
         const sessionScopedCommands = /* @__PURE__ */ new Set([
           "read_chat",
           "get_chat_debug_bundle",
@@ -41308,7 +42455,6 @@ ${effect.notification.body || ""}`.trim();
           this.logCommandEnd(cmd, result2, startedAt);
           return result2;
         }
-        let result;
         if (!this._currentRoute.session && !this._currentRoute.managerKey && !this._currentRoute.providerType) {
           const cdpCommands = ["send_chat", "read_chat", "list_chats", "new_chat", "switch_chat", "set_mode", "change_model", "set_thought_level", "resolve_action"];
           if (cdpCommands.includes(cmd)) {
@@ -41459,7 +42605,7 @@ ${effect.notification.body || ""}`.trim();
         try {
           const http3 = await import("http");
           const postData = JSON.stringify(body);
-          const result = await new Promise((resolve12, reject) => {
+          const result = await new Promise((resolve15, reject) => {
             const req = http3.request({
               hostname: "127.0.0.1",
               port: 19280,
@@ -41471,9 +42617,9 @@ ${effect.notification.body || ""}`.trim();
               res.on("data", (chunk) => data += chunk);
               res.on("end", () => {
                 try {
-                  resolve12(JSON.parse(data));
+                  resolve15(JSON.parse(data));
                 } catch {
-                  resolve12({ raw: data });
+                  resolve15({ raw: data });
                 }
               });
             });
@@ -41491,15 +42637,15 @@ ${effect.notification.body || ""}`.trim();
         if (!providerType) return { success: false, error: "providerType required" };
         try {
           const http3 = await import("http");
-          const result = await new Promise((resolve12, reject) => {
+          const result = await new Promise((resolve15, reject) => {
             http3.get(`http://127.0.0.1:19280/api/providers/${providerType}/${endpoint}`, (res) => {
               let data = "";
               res.on("data", (chunk) => data += chunk);
               res.on("end", () => {
                 try {
-                  resolve12(JSON.parse(data));
+                  resolve15(JSON.parse(data));
                 } catch {
-                  resolve12({ raw: data });
+                  resolve15({ raw: data });
                 }
               });
             }).on("error", reject);
@@ -41513,7 +42659,7 @@ ${effect.notification.body || ""}`.trim();
         try {
           const http3 = await import("http");
           const postData = JSON.stringify(args || {});
-          const result = await new Promise((resolve12, reject) => {
+          const result = await new Promise((resolve15, reject) => {
             const req = http3.request({
               hostname: "127.0.0.1",
               port: 19280,
@@ -41525,9 +42671,9 @@ ${effect.notification.body || ""}`.trim();
               res.on("data", (chunk) => data += chunk);
               res.on("end", () => {
                 try {
-                  resolve12(JSON.parse(data));
+                  resolve15(JSON.parse(data));
                 } catch {
-                  resolve12({ raw: data });
+                  resolve15({ raw: data });
                 }
               });
             });
@@ -41542,7 +42688,7 @@ ${effect.notification.body || ""}`.trim();
       }
     };
     var os13 = __toESM2(require("os"));
-    var path13 = __toESM2(require("path"));
+    var path16 = __toESM2(require("path"));
     var crypto4 = __toESM2(require("crypto"));
     var import_fs5 = require("fs");
     var import_child_process6 = require("child_process");
@@ -41550,7 +42696,7 @@ ${effect.notification.body || ""}`.trim();
     init_provider_cli_adapter();
     init_config();
     var os12 = __toESM2(require("os"));
-    var path12 = __toESM2(require("path"));
+    var path15 = __toESM2(require("path"));
     var crypto3 = __toESM2(require("crypto"));
     var fs6 = __toESM2(require("fs"));
     var import_node_module = require("module");
@@ -41607,7 +42753,7 @@ ${effect.notification.body || ""}`.trim();
     var CachedDatabaseSync = null;
     function getDatabaseSync() {
       if (CachedDatabaseSync) return CachedDatabaseSync;
-      const requireFn = typeof require === "function" ? require : (0, import_node_module.createRequire)(path12.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
+      const requireFn = typeof require === "function" ? require : (0, import_node_module.createRequire)(path15.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
       const sqliteModule = requireFn(`node:${"sqlite"}`);
       CachedDatabaseSync = sqliteModule.DatabaseSync;
       if (!CachedDatabaseSync) {
@@ -41645,7 +42791,7 @@ ${effect.notification.body || ""}`.trim();
         if (status === "stopped") {
           throw new Error("CLI runtime stopped before it became ready");
         }
-        await new Promise((resolve12) => setTimeout(resolve12, pollMs));
+        await new Promise((resolve15) => setTimeout(resolve15, pollMs));
       }
       throw new Error(`CLI runtime did not become ready within ${timeoutMs}ms`);
     }
@@ -41996,7 +43142,7 @@ ${effect.notification.body || ""}`.trim();
           const enterCount = cliCommand.enterCount || 1;
           await this.adapter.writeRaw(cliCommand.text + "\r");
           for (let i = 1; i < enterCount; i += 1) {
-            await new Promise((resolve12) => setTimeout(resolve12, 50));
+            await new Promise((resolve15) => setTimeout(resolve15, 50));
             await this.adapter.writeRaw("\r");
           }
         }
@@ -43108,13 +44254,13 @@ ${effect.notification.body || ""}`.trim();
             }
             this.currentStatus = "waiting_approval";
             this.detectStatusTransition();
-            const approved = await new Promise((resolve12) => {
-              this.permissionResolvers.push(resolve12);
+            const approved = await new Promise((resolve15) => {
+              this.permissionResolvers.push(resolve15);
               setTimeout(() => {
-                const idx = this.permissionResolvers.indexOf(resolve12);
+                const idx = this.permissionResolvers.indexOf(resolve15);
                 if (idx >= 0) {
                   this.permissionResolvers.splice(idx, 1);
-                  resolve12(false);
+                  resolve15(false);
                 }
               }, 3e5);
             });
@@ -43683,11 +44829,11 @@ ${rawInput}` : rawInput;
     }
     function isExplicitCommand(command) {
       const trimmed = command.trim();
-      return path13.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
+      return path16.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~");
     }
     function expandExecutable(command) {
       const trimmed = command.trim();
-      return trimmed.startsWith("~") ? path13.join(os13.homedir(), trimmed.slice(1)) : trimmed;
+      return trimmed.startsWith("~") ? path16.join(os13.homedir(), trimmed.slice(1)) : trimmed;
     }
     function commandExists(command) {
       const trimmed = command.trim();
@@ -43968,7 +45114,7 @@ ${rawInput}` : rawInput;
       async startSession(cliType, workingDir, cliArgs, initialModel, options) {
         const trimmed = (workingDir || "").trim();
         if (!trimmed) throw new Error("working directory required");
-        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os13.homedir()) : path13.resolve(trimmed);
+        const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os13.homedir()) : path16.resolve(trimmed);
         const normalizedType = this.providerLoader.resolveAlias(cliType);
         const rawProvider = this.providerLoader.getByAlias(cliType);
         const provider = rawProvider ? this.providerLoader.resolve(normalizedType) || rawProvider : void 0;
@@ -44467,9 +45613,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
     var import_child_process7 = require("child_process");
     var net3 = __toESM2(require("net"));
     var os15 = __toESM2(require("os"));
-    var path15 = __toESM2(require("path"));
+    var path18 = __toESM2(require("path"));
     var fs7 = __toESM2(require("fs"));
-    var path14 = __toESM2(require("path"));
+    var path17 = __toESM2(require("path"));
     var os14 = __toESM2(require("os"));
     var chokidar = __toESM2((init_chokidar(), __toCommonJS(chokidar_exports)));
     init_logger();
@@ -44730,7 +45876,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         try {
           if (!fs7.existsSync(candidate) || !fs7.statSync(candidate).isDirectory()) return false;
           return ["ide", "extension", "cli", "acp"].some(
-            (category) => fs7.existsSync(path14.join(candidate, category))
+            (category) => fs7.existsSync(path17.join(candidate, category))
           );
         } catch {
           return false;
@@ -44738,20 +45884,20 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       static hasProviderRootMarker(candidate) {
         try {
-          return fs7.existsSync(path14.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
+          return fs7.existsSync(path17.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
         } catch {
           return false;
         }
       }
       detectDefaultUserDir() {
-        const fallback = path14.join(os14.homedir(), ".adhdev", "providers");
+        const fallback = path17.join(os14.homedir(), ".adhdev", "providers");
         const envOptIn = process.env[_ProviderLoader.SIBLING_ENV_VAR] === "1";
         const visited = /* @__PURE__ */ new Set();
         for (const start of this.probeStarts) {
-          let current = path14.resolve(start);
+          let current = path17.resolve(start);
           while (!visited.has(current)) {
             visited.add(current);
-            const siblingCandidate = path14.join(path14.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
+            const siblingCandidate = path17.join(path17.dirname(current), _ProviderLoader.REPO_PROVIDER_DIRNAME);
             if (_ProviderLoader.looksLikeProviderRoot(siblingCandidate)) {
               const hasMarker = _ProviderLoader.hasProviderRootMarker(siblingCandidate);
               if (envOptIn || hasMarker) {
@@ -44773,7 +45919,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 return { path: siblingCandidate, source };
               }
             }
-            const parent = path14.dirname(current);
+            const parent = path17.dirname(current);
             if (parent === current) break;
             current = parent;
           }
@@ -44783,11 +45929,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
       constructor(options) {
         this.logFn = options?.logFn || LOG2.forComponent("Provider").asLogFn();
         this.probeStarts = options?.probeStarts ?? [process.cwd(), __dirname];
-        this.defaultProvidersDir = path14.join(os14.homedir(), ".adhdev", "providers");
+        this.defaultProvidersDir = path17.join(os14.homedir(), ".adhdev", "providers");
         const detected = this.detectDefaultUserDir();
         this.userDir = detected.path;
         this.userDirSource = detected.source;
-        this.upstreamDir = path14.join(this.defaultProvidersDir, ".upstream");
+        this.upstreamDir = path17.join(this.defaultProvidersDir, ".upstream");
         this.disableUpstream = false;
         this.applySourceConfig({
           userDir: options?.userDir,
@@ -44846,7 +45992,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           this.userDir = detected.path;
           this.userDirSource = detected.source;
         }
-        this.upstreamDir = path14.join(this.defaultProvidersDir, ".upstream");
+        this.upstreamDir = path17.join(this.defaultProvidersDir, ".upstream");
         this.disableUpstream = this.sourceMode === "no-upstream";
         if (this.explicitProviderDir) {
           this.log(`Config 'providerDir' applied: ${this.userDir}`);
@@ -44860,7 +46006,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       * Canonical provider directory shape for a given root.
       */
       getProviderDir(root, category, type) {
-        return path14.join(root, category, type);
+        return path17.join(root, category, type);
       }
       /**
       * Canonical user override directory for a provider.
@@ -44887,7 +46033,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       resolveProviderFile(type, ...segments) {
         const dir = this.findProviderDirInternal(type);
         if (!dir) return null;
-        return path14.join(dir, ...segments);
+        return path17.join(dir, ...segments);
       }
       /**
       * Load all providers (3-tier priority)
@@ -44926,7 +46072,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (!fs7.existsSync(this.upstreamDir)) return false;
         try {
           return fs7.readdirSync(this.upstreamDir).some(
-            (d) => fs7.statSync(path14.join(this.upstreamDir, d)).isDirectory()
+            (d) => fs7.statSync(path17.join(this.upstreamDir, d)).isDirectory()
           );
         } catch {
           return false;
@@ -45423,8 +46569,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   resolved._resolvedScriptDir = entry.scriptDir;
                   resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
                   if (providerDir) {
-                    const fullDir = path14.join(providerDir, entry.scriptDir);
-                    resolved._resolvedScriptsPath = fs7.existsSync(path14.join(fullDir, "scripts.js")) ? path14.join(fullDir, "scripts.js") : fullDir;
+                    const fullDir = path17.join(providerDir, entry.scriptDir);
+                    resolved._resolvedScriptsPath = fs7.existsSync(path17.join(fullDir, "scripts.js")) ? path17.join(fullDir, "scripts.js") : fullDir;
                   }
                   matched = true;
                 }
@@ -45439,8 +46585,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 resolved._resolvedScriptDir = base.defaultScriptDir;
                 resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
                 if (providerDir) {
-                  const fullDir = path14.join(providerDir, base.defaultScriptDir);
-                  resolved._resolvedScriptsPath = fs7.existsSync(path14.join(fullDir, "scripts.js")) ? path14.join(fullDir, "scripts.js") : fullDir;
+                  const fullDir = path17.join(providerDir, base.defaultScriptDir);
+                  resolved._resolvedScriptsPath = fs7.existsSync(path17.join(fullDir, "scripts.js")) ? path17.join(fullDir, "scripts.js") : fullDir;
                 }
               }
               resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -45457,8 +46603,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   resolved._resolvedScriptDir = dirOverride;
                   resolved._resolvedScriptsSource = `versions:${range}`;
                   if (providerDir) {
-                    const fullDir = path14.join(providerDir, dirOverride);
-                    resolved._resolvedScriptsPath = fs7.existsSync(path14.join(fullDir, "scripts.js")) ? path14.join(fullDir, "scripts.js") : fullDir;
+                    const fullDir = path17.join(providerDir, dirOverride);
+                    resolved._resolvedScriptsPath = fs7.existsSync(path17.join(fullDir, "scripts.js")) ? path17.join(fullDir, "scripts.js") : fullDir;
                   }
                 }
               } else if (override.scripts) {
@@ -45474,8 +46620,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
             resolved._resolvedScriptDir = base.defaultScriptDir;
             resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
             if (providerDir) {
-              const fullDir = path14.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs7.existsSync(path14.join(fullDir, "scripts.js")) ? path14.join(fullDir, "scripts.js") : fullDir;
+              const fullDir = path17.join(providerDir, base.defaultScriptDir);
+              resolved._resolvedScriptsPath = fs7.existsSync(path17.join(fullDir, "scripts.js")) ? path17.join(fullDir, "scripts.js") : fullDir;
             }
           }
         }
@@ -45507,14 +46653,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
           this.log(`  [loadScriptsFromDir] ${type}: providerDir not found`);
           return null;
         }
-        const dir = path14.join(providerDir, scriptDir);
+        const dir = path17.join(providerDir, scriptDir);
         if (!fs7.existsSync(dir)) {
           this.log(`  [loadScriptsFromDir] ${type}: dir not found: ${dir}`);
           return null;
         }
         const cached2 = this.scriptsCache.get(dir);
         if (cached2) return cached2;
-        const scriptsJs = path14.join(dir, "scripts.js");
+        const scriptsJs = path17.join(dir, "scripts.js");
         if (fs7.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
@@ -45556,7 +46702,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 return;
               }
               if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
-                this.log(`File changed: ${path14.basename(filePath)}, reloading...`);
+                this.log(`File changed: ${path17.basename(filePath)}, reloading...`);
                 this.reload();
               }
             };
@@ -45611,7 +46757,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         const https = require("https");
         const { execSync: execSync7 } = require("child_process");
-        const metaPath = path14.join(this.upstreamDir, _ProviderLoader.META_FILE);
+        const metaPath = path17.join(this.upstreamDir, _ProviderLoader.META_FILE);
         let prevEtag = "";
         let prevTimestamp = 0;
         try {
@@ -45628,7 +46774,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return { updated: false };
         }
         try {
-          const etag = await new Promise((resolve12, reject) => {
+          const etag = await new Promise((resolve15, reject) => {
             const options = {
               method: "HEAD",
               hostname: "github.com",
@@ -45646,7 +46792,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   headers: { "User-Agent": "adhdev-launcher" },
                   timeout: 1e4
                 }, (res2) => {
-                  resolve12(res2.headers.etag || res2.headers["last-modified"] || "");
+                  resolve15(res2.headers.etag || res2.headers["last-modified"] || "");
                 });
                 req2.on("error", reject);
                 req2.on("timeout", () => {
@@ -45655,7 +46801,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 });
                 req2.end();
               } else {
-                resolve12(res.headers.etag || res.headers["last-modified"] || "");
+                resolve15(res.headers.etag || res.headers["last-modified"] || "");
               }
             });
             req.on("error", reject);
@@ -45671,17 +46817,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
             return { updated: false };
           }
           this.log("Downloading latest providers from GitHub...");
-          const tmpTar = path14.join(os14.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
-          const tmpExtract = path14.join(os14.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
+          const tmpTar = path17.join(os14.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
+          const tmpExtract = path17.join(os14.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
           await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
           fs7.mkdirSync(tmpExtract, { recursive: true });
           execSync7(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
           const extracted = fs7.readdirSync(tmpExtract);
           const rootDir = extracted.find(
-            (d) => fs7.statSync(path14.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
+            (d) => fs7.statSync(path17.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
           );
           if (!rootDir) throw new Error("Unexpected tarball structure");
-          const sourceDir = path14.join(tmpExtract, rootDir);
+          const sourceDir = path17.join(tmpExtract, rootDir);
           const backupDir = this.upstreamDir + ".bak";
           if (fs7.existsSync(this.upstreamDir)) {
             if (fs7.existsSync(backupDir)) fs7.rmSync(backupDir, { recursive: true, force: true });
@@ -45719,7 +46865,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       downloadFile(url2, destPath) {
         const https = require("https");
         const http3 = require("http");
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve15, reject) => {
           const doRequest = (reqUrl, redirectCount = 0) => {
             if (redirectCount > 5) {
               reject(new Error("Too many redirects"));
@@ -45739,7 +46885,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               res.pipe(ws2);
               ws2.on("finish", () => {
                 ws2.close();
-                resolve12();
+                resolve15();
               });
               ws2.on("error", reject);
             });
@@ -45756,8 +46902,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
       copyDirRecursive(src, dest) {
         fs7.mkdirSync(dest, { recursive: true });
         for (const entry of fs7.readdirSync(src, { withFileTypes: true })) {
-          const srcPath = path14.join(src, entry.name);
-          const destPath = path14.join(dest, entry.name);
+          const srcPath = path17.join(src, entry.name);
+          const destPath = path17.join(dest, entry.name);
           if (entry.isDirectory()) {
             this.copyDirRecursive(srcPath, destPath);
           } else {
@@ -45768,7 +46914,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       /** .meta.json save */
       writeMeta(metaPath, etag, timestamp) {
         try {
-          fs7.mkdirSync(path14.dirname(metaPath), { recursive: true });
+          fs7.mkdirSync(path17.dirname(metaPath), { recursive: true });
           fs7.writeFileSync(metaPath, JSON.stringify({
             etag,
             timestamp,
@@ -45785,7 +46931,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const scan = (d) => {
           try {
             for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
-              if (entry.isDirectory()) scan(path14.join(d, entry.name));
+              if (entry.isDirectory()) scan(path17.join(d, entry.name));
               else if (entry.name === "provider.json") count++;
             }
           } catch {
@@ -46013,17 +47159,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
         for (const root of searchRoots) {
           if (!fs7.existsSync(root)) continue;
           const candidate = this.getProviderDir(root, cat, type);
-          if (fs7.existsSync(path14.join(candidate, "provider.json"))) return candidate;
-          const catDir = path14.join(root, cat);
+          if (fs7.existsSync(path17.join(candidate, "provider.json"))) return candidate;
+          const catDir = path17.join(root, cat);
           if (fs7.existsSync(catDir)) {
             try {
               for (const entry of fs7.readdirSync(catDir, { withFileTypes: true })) {
                 if (!entry.isDirectory()) continue;
-                const jsonPath = path14.join(catDir, entry.name, "provider.json");
+                const jsonPath = path17.join(catDir, entry.name, "provider.json");
                 if (fs7.existsSync(jsonPath)) {
                   try {
                     const data = JSON.parse(fs7.readFileSync(jsonPath, "utf-8"));
-                    if (data.type === type) return path14.join(catDir, entry.name);
+                    if (data.type === type) return path17.join(catDir, entry.name);
                   } catch {
                   }
                 }
@@ -46040,7 +47186,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * (template substitution is NOT applied here — scripts.js handles that)
        */
       buildScriptWrappersFromDir(dir) {
-        const scriptsJs = path14.join(dir, "scripts.js");
+        const scriptsJs = path17.join(dir, "scripts.js");
         if (fs7.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
@@ -46054,7 +47200,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           for (const file2 of fs7.readdirSync(dir)) {
             if (!file2.endsWith(".js")) continue;
             const scriptName = toCamel(file2.replace(".js", ""));
-            const filePath = path14.join(dir, file2);
+            const filePath = path17.join(dir, file2);
             result[scriptName] = (...args) => {
               try {
                 let content = fs7.readFileSync(filePath, "utf-8");
@@ -46114,7 +47260,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           }
           const hasJson = entries.some((e) => e.name === "provider.json");
           if (hasJson) {
-            const jsonPath = path14.join(d, "provider.json");
+            const jsonPath = path17.join(d, "provider.json");
             try {
               const raw = fs7.readFileSync(jsonPath, "utf-8");
               const mod = JSON.parse(raw);
@@ -46135,7 +47281,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 this.log(`\u26A0 Invalid provider at ${jsonPath}: ${validation.errors.join("; ")}`);
               } else {
                 const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
-                const scriptsPath = path14.join(d, "scripts.js");
+                const scriptsPath = path17.join(d, "scripts.js");
                 if (!hasCompatibility && fs7.existsSync(scriptsPath)) {
                   try {
                     delete require.cache[require.resolve(scriptsPath)];
@@ -46161,7 +47307,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               if (!entry.isDirectory()) continue;
               if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
               if (excludeDirs && d === dir && excludeDirs.includes(entry.name)) continue;
-              scan(path14.join(d, entry.name));
+              scan(path17.join(d, entry.name));
             }
           }
         };
@@ -46196,9 +47342,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
       }
       compareVersions(a, b2) {
-        const normalize3 = (v2) => v2.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
-        const pa2 = normalize3(a);
-        const pb = normalize3(b2);
+        const normalize4 = (v2) => v2.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
+        const pa2 = normalize4(a);
+        const pb = normalize4(b2);
         for (let i = 0; i < Math.max(pa2.length, pb.length); i++) {
           const va2 = pa2[i] || 0;
           const vb = pb[i] || 0;
@@ -46314,17 +47460,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
       throw new Error("No free port found");
     }
     function checkPortFree(port) {
-      return new Promise((resolve12) => {
+      return new Promise((resolve15) => {
         const server = net3.createServer();
         server.unref();
-        server.on("error", () => resolve12(false));
+        server.on("error", () => resolve15(false));
         server.listen(port, "127.0.0.1", () => {
-          server.close(() => resolve12(true));
+          server.close(() => resolve15(true));
         });
       });
     }
     async function isCdpActive(port) {
-      return new Promise((resolve12) => {
+      return new Promise((resolve15) => {
         const req = require("http").get(`http://127.0.0.1:${port}/json/version`, {
           timeout: 2e3
         }, (res) => {
@@ -46333,16 +47479,16 @@ Run 'adhdev doctor' for detailed diagnostics.`
           res.on("end", () => {
             try {
               const info = JSON.parse(data);
-              resolve12(!!info["WebKit-Version"] || !!info["Browser"]);
+              resolve15(!!info["WebKit-Version"] || !!info["Browser"]);
             } catch {
-              resolve12(false);
+              resolve15(false);
             }
           });
         });
-        req.on("error", () => resolve12(false));
+        req.on("error", () => resolve15(false));
         req.on("timeout", () => {
           req.destroy();
-          resolve12(false);
+          resolve15(false);
         });
       });
     }
@@ -46482,8 +47628,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
-            const storagePath = path15.join(
-              process.env.APPDATA || path15.join(os15.homedir(), "AppData", "Roaming"),
+            const storagePath = path18.join(
+              process.env.APPDATA || path18.join(os15.homedir(), "AppData", "Roaming"),
               appName,
               "storage.json"
             );
@@ -46657,9 +47803,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
     init_config();
     init_logger();
     var fs8 = __toESM2(require("fs"));
-    var path16 = __toESM2(require("path"));
+    var path19 = __toESM2(require("path"));
     var os16 = __toESM2(require("os"));
-    var LOG_DIR2 = process.platform === "win32" ? path16.join(process.env.LOCALAPPDATA || process.env.APPDATA || path16.join(os16.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path16.join(os16.homedir(), "Library", "Logs", "adhdev") : path16.join(os16.homedir(), ".local", "share", "adhdev", "logs");
+    var LOG_DIR2 = process.platform === "win32" ? path19.join(process.env.LOCALAPPDATA || process.env.APPDATA || path19.join(os16.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path19.join(os16.homedir(), "Library", "Logs", "adhdev") : path19.join(os16.homedir(), ".local", "share", "adhdev", "logs");
     var MAX_FILE_SIZE = 5 * 1024 * 1024;
     var MAX_DAYS = 7;
     try {
@@ -46697,13 +47843,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
       return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     }
     var currentDate2 = getDateStr2();
-    var currentFile = path16.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    var currentFile = path19.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
     var writeCount2 = 0;
     function checkRotation() {
       const today = getDateStr2();
       if (today !== currentDate2) {
         currentDate2 = today;
-        currentFile = path16.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+        currentFile = path19.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
         cleanOldFiles();
       }
     }
@@ -46717,7 +47863,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs8.unlinkSync(path16.join(LOG_DIR2, file2));
+              fs8.unlinkSync(path19.join(LOG_DIR2, file2));
             } catch {
             }
           }
@@ -46727,8 +47873,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function checkSize() {
       try {
-        const stat4 = fs8.statSync(currentFile);
-        if (stat4.size > MAX_FILE_SIZE) {
+        const stat22 = fs8.statSync(currentFile);
+        if (stat22.size > MAX_FILE_SIZE) {
           const backup = currentFile.replace(".jsonl", ".1.jsonl");
           try {
             fs8.unlinkSync(backup);
@@ -47010,12 +48156,18 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const unreadSourceSessions = buildSessionEntries(
         options.allStates,
         options.cdpManagers,
-        { profile: "full" }
+        {
+          profile: "full",
+          getGitSummaryForWorkspace: options.getGitSummaryForWorkspace
+        }
       );
       const sessions = profile === "full" ? unreadSourceSessions : profile === "live" ? unreadSourceSessions.map(projectLiveSessionFromFull) : buildSessionEntries(
         options.allStates,
         options.cdpManagers,
-        { profile }
+        {
+          profile,
+          getGitSummaryForWorkspace: options.getGitSummaryForWorkspace
+        }
       );
       const sessionsById = new Map(sessions.map((session) => [session.id, session]));
       for (const sourceSession of unreadSourceSessions) {
@@ -47107,13 +48259,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
     var import_child_process9 = require("child_process");
     var fs9 = __toESM2(require("fs"));
     var os18 = __toESM2(require("os"));
-    var path17 = __toESM2(require("path"));
+    var path20 = __toESM2(require("path"));
     var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
     function getUpgradeLogPath() {
       const home = os18.homedir();
-      const dir = path17.join(home, ".adhdev");
+      const dir = path20.join(home, ".adhdev");
       fs9.mkdirSync(dir, { recursive: true });
-      return path17.join(dir, "daemon-upgrade.log");
+      return path20.join(dir, "daemon-upgrade.log");
     }
     function appendUpgradeLog(message) {
       const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
@@ -47124,14 +48276,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
     }
     function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platform) {
-      const binDir = path17.dirname(nodeExecutable);
+      const binDir = path20.dirname(nodeExecutable);
       if (platform10 === "win32") {
-        const npmCliPath = path17.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
+        const npmCliPath = path20.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
         if (fs9.existsSync(npmCliPath)) {
           return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
         }
         for (const candidate of ["npm.exe", "npm"]) {
-          const candidatePath = path17.join(binDir, candidate);
+          const candidatePath = path20.join(binDir, candidate);
           if (fs9.existsSync(candidatePath)) {
             return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
           }
@@ -47139,7 +48291,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
       }
       for (const candidate of ["npm"]) {
-        const candidatePath = path17.join(binDir, candidate);
+        const candidatePath = path20.join(binDir, candidate);
         if (fs9.existsSync(candidatePath)) {
           return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
         }
@@ -47156,13 +48308,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
       let currentDir = resolvedPath;
       try {
         if (fs9.statSync(resolvedPath).isFile()) {
-          currentDir = path17.dirname(resolvedPath);
+          currentDir = path20.dirname(resolvedPath);
         }
       } catch {
-        currentDir = path17.dirname(resolvedPath);
+        currentDir = path20.dirname(resolvedPath);
       }
       while (true) {
-        const packageJsonPath = path17.join(currentDir, "package.json");
+        const packageJsonPath = path20.join(currentDir, "package.json");
         try {
           if (fs9.existsSync(packageJsonPath)) {
             const parsed = JSON.parse(fs9.readFileSync(packageJsonPath, "utf8"));
@@ -47173,7 +48325,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           }
         } catch {
         }
-        const parentDir = path17.dirname(currentDir);
+        const parentDir = path20.dirname(currentDir);
         if (parentDir === currentDir) {
           return null;
         }
@@ -47181,13 +48333,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
     }
     function resolveInstallPrefixFromPackageRoot(packageRoot, packageName) {
-      const nodeModulesDir = packageName.startsWith("@") ? path17.dirname(path17.dirname(packageRoot)) : path17.dirname(packageRoot);
-      if (path17.basename(nodeModulesDir) !== "node_modules") {
+      const nodeModulesDir = packageName.startsWith("@") ? path20.dirname(path20.dirname(packageRoot)) : path20.dirname(packageRoot);
+      if (path20.basename(nodeModulesDir) !== "node_modules") {
         return null;
       }
-      const maybeLibDir = path17.dirname(nodeModulesDir);
-      if (path17.basename(maybeLibDir) === "lib") {
-        return path17.dirname(maybeLibDir);
+      const maybeLibDir = path20.dirname(nodeModulesDir);
+      if (path20.basename(maybeLibDir) === "lib") {
+        return path20.dirname(maybeLibDir);
       }
       return maybeLibDir;
     }
@@ -47295,14 +48447,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
       while (Date.now() - start < timeoutMs) {
         try {
           process.kill(pid, 0);
-          await new Promise((resolve12) => setTimeout(resolve12, 250));
+          await new Promise((resolve15) => setTimeout(resolve15, 250));
         } catch {
           return;
         }
       }
     }
     function stopSessionHostProcesses(appName) {
-      const pidFile = path17.join(os18.homedir(), ".adhdev", `${appName}-session-host.pid`);
+      const pidFile = path20.join(os18.homedir(), ".adhdev", `${appName}-session-host.pid`);
       try {
         if (fs9.existsSync(pidFile)) {
           const pid = Number.parseInt(fs9.readFileSync(pidFile, "utf8").trim(), 10);
@@ -47319,7 +48471,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
     }
     function removeDaemonPidFile() {
-      const pidFile = path17.join(os18.homedir(), ".adhdev", "daemon.pid");
+      const pidFile = path20.join(os18.homedir(), ".adhdev", "daemon.pid");
       try {
         fs9.unlinkSync(pidFile);
       } catch {
@@ -47330,7 +48482,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const npmRoot = String(execNpmCommandSync(["root", "-g", ...prefixArgs], { encoding: "utf8" }, surface)).trim();
       if (!npmRoot) return;
       const npmPrefix = surface.installPrefix || String(execNpmCommandSync(["prefix", "-g", ...prefixArgs], { encoding: "utf8" }, surface)).trim();
-      const binDir = process.platform === "win32" ? npmPrefix : path17.join(npmPrefix, "bin");
+      const binDir = process.platform === "win32" ? npmPrefix : path20.join(npmPrefix, "bin");
       const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
       const binNames = /* @__PURE__ */ new Set([packageBaseName]);
       if (pkgName === "@adhdev/daemon-standalone") {
@@ -47338,25 +48490,25 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       if (pkgName.startsWith("@")) {
         const [scope, name] = pkgName.split("/");
-        const scopeDir = path17.join(npmRoot, scope);
+        const scopeDir = path20.join(npmRoot, scope);
         if (!fs9.existsSync(scopeDir)) return;
         for (const entry of fs9.readdirSync(scopeDir)) {
           if (!entry.startsWith(`.${name}-`)) continue;
-          fs9.rmSync(path17.join(scopeDir, entry), { recursive: true, force: true });
-          appendUpgradeLog(`Removed stale scoped staging dir: ${path17.join(scopeDir, entry)}`);
+          fs9.rmSync(path20.join(scopeDir, entry), { recursive: true, force: true });
+          appendUpgradeLog(`Removed stale scoped staging dir: ${path20.join(scopeDir, entry)}`);
         }
       } else {
         for (const entry of fs9.readdirSync(npmRoot)) {
           if (!entry.startsWith(`.${pkgName}-`)) continue;
-          fs9.rmSync(path17.join(npmRoot, entry), { recursive: true, force: true });
-          appendUpgradeLog(`Removed stale staging dir: ${path17.join(npmRoot, entry)}`);
+          fs9.rmSync(path20.join(npmRoot, entry), { recursive: true, force: true });
+          appendUpgradeLog(`Removed stale staging dir: ${path20.join(npmRoot, entry)}`);
         }
       }
       if (fs9.existsSync(binDir)) {
         for (const entry of fs9.readdirSync(binDir)) {
           if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
-          fs9.rmSync(path17.join(binDir, entry), { recursive: true, force: true });
-          appendUpgradeLog(`Removed stale bin staging entry: ${path17.join(binDir, entry)}`);
+          fs9.rmSync(path20.join(binDir, entry), { recursive: true, force: true });
+          appendUpgradeLog(`Removed stale bin staging entry: ${path20.join(binDir, entry)}`);
         }
       }
     }
@@ -47406,7 +48558,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         appendUpgradeLog(installOutput.trim());
       }
       if (process.platform === "win32") {
-        await new Promise((resolve12) => setTimeout(resolve12, 500));
+        await new Promise((resolve15) => setTimeout(resolve15, 500));
         cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
         appendUpgradeLog("Post-install staging cleanup complete");
       }
@@ -48786,7 +49938,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const beforeCount = this.messageCount(before);
         const beforeSignature = this.lastMessageSignature(before);
         for (let attempt = 0; attempt < 12; attempt += 1) {
-          await new Promise((resolve12) => setTimeout(resolve12, 250));
+          await new Promise((resolve15) => setTimeout(resolve15, 250));
           let state;
           try {
             state = await this.readChat(evaluate);
@@ -48808,7 +49960,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (this.messageCount(first) > 0 || this.lastMessageSignature(first)) {
           return first;
         }
-        await new Promise((resolve12) => setTimeout(resolve12, 150));
+        await new Promise((resolve15) => setTimeout(resolve15, 150));
         const second = await this.readChat(evaluate);
         return this.messageCount(second) >= this.messageCount(first) ? second : first;
       }
@@ -48959,7 +50111,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           if (typeof data.error === "string" && data.error.trim()) return false;
         }
         for (let attempt = 0; attempt < 6; attempt += 1) {
-          await new Promise((resolve12) => setTimeout(resolve12, 250));
+          await new Promise((resolve15) => setTimeout(resolve15, 250));
           const state = await this.readChat(evaluate);
           const title = this.getStateTitle(state);
           if (this.titlesMatch(title, sessionId)) return true;
@@ -49808,11 +50960,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
     init_io_contracts();
     init_chat_message_normalization();
     var fs11 = __toESM2(require("fs"));
-    var path18 = __toESM2(require("path"));
+    var path21 = __toESM2(require("path"));
     var os19 = __toESM2(require("os"));
     var import_child_process10 = require("child_process");
     var import_os3 = require("os");
-    var ARCHIVE_PATH = path18.join(os19.homedir(), ".adhdev", "version-history.json");
+    var ARCHIVE_PATH = path21.join(os19.homedir(), ".adhdev", "version-history.json");
     var MAX_ENTRIES_PER_PROVIDER = 20;
     var VersionArchive = class {
       history = {};
@@ -49859,7 +51011,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       save() {
         try {
-          fs11.mkdirSync(path18.dirname(ARCHIVE_PATH), { recursive: true });
+          fs11.mkdirSync(path21.dirname(ARCHIVE_PATH), { recursive: true });
           fs11.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
         } catch {
         }
@@ -49916,7 +51068,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       for (const p of paths) {
         if (p.includes("*")) {
           const home = os19.homedir();
-          const resolved = p.replace(/\*/g, home.split(path18.sep).pop() || "");
+          const resolved = p.replace(/\*/g, home.split(path21.sep).pop() || "");
           if (fs11.existsSync(resolved)) return resolved;
         } else {
           if (fs11.existsSync(p)) return p;
@@ -49926,7 +51078,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function getMacAppVersion(appPath) {
       if ((0, import_os3.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
-      const plistPath = path18.join(appPath, "Contents", "Info.plist");
+      const plistPath = path21.join(appPath, "Contents", "Info.plist");
       if (!fs11.existsSync(plistPath)) return null;
       const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
       return raw || null;
@@ -49952,7 +51104,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const cliBin = provider.cli ? findBinary2(provider.cli) : null;
           let resolvedBin = cliBin;
           if (!resolvedBin && appPath && currentOs === "darwin") {
-            const bundled = path18.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+            const bundled = path21.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
             if (provider.cli && fs11.existsSync(bundled)) resolvedBin = bundled;
           }
           info.installed = !!(appPath || resolvedBin);
@@ -49991,7 +51143,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     var http2 = __toESM2(require("http"));
     var fs15 = __toESM2(require("fs"));
-    var path222 = __toESM2(require("path"));
+    var path25 = __toESM2(require("path"));
     init_config();
     function generateFiles(type, name, category, opts = {}) {
       const { cdpPorts, cli, processName, installPath, binary, extensionId, version: version2 = "0.1" } = opts;
@@ -50336,7 +51488,7 @@ async (params) => {
     }
     init_logger();
     var fs12 = __toESM2(require("fs"));
-    var path19 = __toESM2(require("path"));
+    var path222 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
       const body = await ctx.readBody(req);
@@ -50515,17 +51667,17 @@ async (params) => {
         return;
       }
       let scriptsPath = "";
-      const directScripts = path19.join(dir, "scripts.js");
+      const directScripts = path222.join(dir, "scripts.js");
       if (fs12.existsSync(directScripts)) {
         scriptsPath = directScripts;
       } else {
-        const scriptsDir = path19.join(dir, "scripts");
+        const scriptsDir = path222.join(dir, "scripts");
         if (fs12.existsSync(scriptsDir)) {
           const versions = fs12.readdirSync(scriptsDir).filter((d) => {
-            return fs12.statSync(path19.join(scriptsDir, d)).isDirectory();
+            return fs12.statSync(path222.join(scriptsDir, d)).isDirectory();
           }).sort().reverse();
           for (const ver of versions) {
-            const p = path19.join(scriptsDir, ver, "scripts.js");
+            const p = path222.join(scriptsDir, ver, "scripts.js");
             if (fs12.existsSync(p)) {
               scriptsPath = p;
               break;
@@ -51352,7 +52504,7 @@ async (params) => {
       }
     }
     var fs13 = __toESM2(require("fs"));
-    var path20 = __toESM2(require("path"));
+    var path232 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
       return normalized || `fixture-${Date.now()}`;
@@ -51362,11 +52514,11 @@ async (params) => {
       if (!providerDir) {
         throw new Error(`Provider directory not found for '${type}'`);
       }
-      return path20.join(providerDir, "fixtures");
+      return path232.join(providerDir, "fixtures");
     }
     function readCliFixture(ctx, type, name) {
       const fixtureDir = getCliFixtureDir(ctx, type);
-      const filePath = path20.join(fixtureDir, `${name}.json`);
+      const filePath = path232.join(fixtureDir, `${name}.json`);
       if (!fs13.existsSync(filePath)) {
         throw new Error(`Fixture not found: ${filePath}`);
       }
@@ -51535,7 +52687,7 @@ async (params) => {
       return { target, instance, adapter };
     }
     function sleep(ms2) {
-      return new Promise((resolve12) => setTimeout(resolve12, ms2));
+      return new Promise((resolve15) => setTimeout(resolve15, ms2));
     }
     async function waitForCliReady(ctx, type, instanceId, timeoutMs) {
       const startedAt = Date.now();
@@ -51833,7 +52985,7 @@ async (params) => {
         return {
           mode: "fixture_replay_suite",
           pass: results.every((item) => item.pass),
-          failures: results.flatMap((item) => item.failures.map((failure) => `${item.fixtureName}: ${failure}`)),
+          failures: results.flatMap((item) => item.failures.map((failure2) => `${item.fixtureName}: ${failure2}`)),
           result: firstFailure.result,
           assertions: firstFailure.assertions,
           fixture: firstFailure.fixture,
@@ -52133,7 +53285,7 @@ async (params) => {
           },
           notes: typeof body?.notes === "string" ? body.notes : void 0
         };
-        const filePath = path20.join(fixtureDir, `${name}.json`);
+        const filePath = path232.join(fixtureDir, `${name}.json`);
         fs13.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
         ctx.json(res, 200, {
           saved: true,
@@ -52157,7 +53309,7 @@ async (params) => {
           return;
         }
         const fixtures = fs13.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b2) => b2.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
-          const fullPath = path20.join(fixtureDir, file2);
+          const fullPath = path232.join(fixtureDir, file2);
           try {
             const raw = JSON.parse(fs13.readFileSync(fullPath, "utf-8"));
             return {
@@ -52291,7 +53443,7 @@ async (params) => {
       }
     }
     var fs14 = __toESM2(require("fs"));
-    var path21 = __toESM2(require("path"));
+    var path24 = __toESM2(require("path"));
     var os20 = __toESM2(require("os"));
     function getAutoImplPid(ctx) {
       const pid = ctx.autoImplProcess?.pid;
@@ -52341,22 +53493,22 @@ async (params) => {
       if (!fs14.existsSync(scriptsDir)) return null;
       const versions = fs14.readdirSync(scriptsDir).filter((d) => {
         try {
-          return fs14.statSync(path21.join(scriptsDir, d)).isDirectory();
+          return fs14.statSync(path24.join(scriptsDir, d)).isDirectory();
         } catch {
           return false;
         }
       }).sort((a, b2) => b2.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
       if (versions.length === 0) return null;
-      return path21.join(scriptsDir, versions[0]);
+      return path24.join(scriptsDir, versions[0]);
     }
     function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
-      const canonicalUserDir = path21.resolve(ctx.providerLoader.getUserProviderDir(category, type));
-      const desiredDir = requestedDir ? path21.resolve(requestedDir) : canonicalUserDir;
-      const upstreamRoot = path21.resolve(ctx.providerLoader.getUpstreamDir());
-      if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path21.sep}`)) {
+      const canonicalUserDir = path24.resolve(ctx.providerLoader.getUserProviderDir(category, type));
+      const desiredDir = requestedDir ? path24.resolve(requestedDir) : canonicalUserDir;
+      const upstreamRoot = path24.resolve(ctx.providerLoader.getUpstreamDir());
+      if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path24.sep}`)) {
         return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
       }
-      if (path21.basename(desiredDir) !== type) {
+      if (path24.basename(desiredDir) !== type) {
         return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
       }
       const sourceDir = ctx.findProviderDir(type);
@@ -52364,11 +53516,11 @@ async (params) => {
         return { dir: null, reason: `Provider source directory not found for '${type}'` };
       }
       if (!fs14.existsSync(desiredDir)) {
-        fs14.mkdirSync(path21.dirname(desiredDir), { recursive: true });
+        fs14.mkdirSync(path24.dirname(desiredDir), { recursive: true });
         fs14.cpSync(sourceDir, desiredDir, { recursive: true });
         ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
       }
-      const providerJson = path21.join(desiredDir, "provider.json");
+      const providerJson = path24.join(desiredDir, "provider.json");
       if (!fs14.existsSync(providerJson)) {
         return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
       }
@@ -52379,13 +53531,13 @@ async (params) => {
       const refDir = ctx.findProviderDir(referenceType);
       if (!refDir || !fs14.existsSync(refDir)) return {};
       const referenceScripts = {};
-      const scriptsDir = path21.join(refDir, "scripts");
+      const scriptsDir = path24.join(refDir, "scripts");
       const latestDir = getLatestScriptVersionDir(scriptsDir);
       if (!latestDir) return referenceScripts;
       for (const file2 of fs14.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs14.readFileSync(path21.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs14.readFileSync(path24.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -52493,9 +53645,9 @@ async (params) => {
         });
         const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
         const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
-        const tmpDir = path21.join(os20.tmpdir(), "adhdev-autoimpl");
+        const tmpDir = path24.join(os20.tmpdir(), "adhdev-autoimpl");
         if (!fs14.existsSync(tmpDir)) fs14.mkdirSync(tmpDir, { recursive: true });
-        const promptFile = path21.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+        const promptFile = path24.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
         fs14.writeFileSync(promptFile, prompt, "utf-8");
         ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
         const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
@@ -52927,7 +54079,7 @@ async (params) => {
         setMode: "set_mode.js"
       };
       const targetFileNames = new Set(functions.map((fn2) => funcToFile[fn2]).filter(Boolean));
-      const scriptsDir = path21.join(providerDir, "scripts");
+      const scriptsDir = path24.join(providerDir, "scripts");
       const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
       if (latestScriptsDir) {
         lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -52938,7 +54090,7 @@ async (params) => {
         for (const file2 of fs14.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs14.readFileSync(path21.join(latestScriptsDir, file2), "utf-8");
+              const content = fs14.readFileSync(path24.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -52955,7 +54107,7 @@ async (params) => {
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs14.readFileSync(path21.join(latestScriptsDir, file2), "utf-8");
+              const content = fs14.readFileSync(path24.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -52996,10 +54148,10 @@ async (params) => {
           lines.push("");
         }
       }
-      const docsDir = path21.join(providerDir, "../../docs");
+      const docsDir = path24.join(providerDir, "../../docs");
       const loadGuide = (name) => {
         try {
-          const p = path21.join(docsDir, name);
+          const p = path24.join(docsDir, name);
           if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
         } catch {
         }
@@ -53236,7 +54388,7 @@ async (params) => {
         parseApproval: "parse_approval.js"
       };
       const targetFileNames = new Set(functions.map((fn2) => funcToFile[fn2]).filter(Boolean));
-      const scriptsDir = path21.join(providerDir, "scripts");
+      const scriptsDir = path24.join(providerDir, "scripts");
       const latestScriptsDir = getLatestScriptVersionDir(scriptsDir);
       if (latestScriptsDir) {
         lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -53248,7 +54400,7 @@ async (params) => {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs14.readFileSync(path21.join(latestScriptsDir, file2), "utf-8");
+            const content = fs14.readFileSync(path24.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -53264,7 +54416,7 @@ async (params) => {
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs14.readFileSync(path21.join(latestScriptsDir, file2), "utf-8");
+              const content = fs14.readFileSync(path24.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -53297,10 +54449,10 @@ async (params) => {
           lines.push("");
         }
       }
-      const docsDir = path21.join(providerDir, "../../docs");
+      const docsDir = path24.join(providerDir, "../../docs");
       const loadGuide = (name) => {
         try {
-          const p = path21.join(docsDir, name);
+          const p = path24.join(docsDir, name);
           if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
         } catch {
         }
@@ -53745,8 +54897,8 @@ data: ${JSON.stringify(msg.data)}
       }
       getEndpointList() {
         return this.routes.map((r) => {
-          const path232 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-          return `${r.method.padEnd(5)} ${path232}`;
+          const path26 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+          return `${r.method.padEnd(5)} ${path26}`;
         });
       }
       async start(port = DEV_SERVER_PORT) {
@@ -53777,15 +54929,15 @@ data: ${JSON.stringify(msg.data)}
             this.json(res, 500, { error: e.message });
           }
         });
-        return new Promise((resolve12, reject) => {
+        return new Promise((resolve15, reject) => {
           this.server.listen(port, "127.0.0.1", () => {
             this.log(`Dev server listening on http://127.0.0.1:${port}`);
-            resolve12();
+            resolve15();
           });
           this.server.on("error", (e) => {
             if (e.code === "EADDRINUSE") {
               this.log(`Port ${port} in use, skipping dev server`);
-              resolve12();
+              resolve15();
             } else {
               reject(e);
             }
@@ -53867,20 +55019,20 @@ data: ${JSON.stringify(msg.data)}
           child.stderr?.on("data", (d) => {
             stderr += d.toString().slice(0, 2e3);
           });
-          await new Promise((resolve12) => {
+          await new Promise((resolve15) => {
             const timer = setTimeout(() => {
               child.kill();
-              resolve12();
+              resolve15();
             }, 3e3);
             child.on("exit", () => {
               clearTimeout(timer);
-              resolve12();
+              resolve15();
             });
             child.stdout?.once("data", () => {
               setTimeout(() => {
                 child.kill();
                 clearTimeout(timer);
-                resolve12();
+                resolve15();
               }, 500);
             });
           });
@@ -54034,12 +55186,12 @@ data: ${JSON.stringify(msg.data)}
       // ─── DevConsole SPA ───
       getConsoleDistDir() {
         const candidates = [
-          path222.resolve(__dirname, "../../web-devconsole/dist"),
-          path222.resolve(__dirname, "../../../web-devconsole/dist"),
-          path222.join(process.cwd(), "packages/web-devconsole/dist")
+          path25.resolve(__dirname, "../../web-devconsole/dist"),
+          path25.resolve(__dirname, "../../../web-devconsole/dist"),
+          path25.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs15.existsSync(path222.join(dir, "index.html"))) return dir;
+          if (fs15.existsSync(path25.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -54049,7 +55201,7 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
           return;
         }
-        const htmlPath = path222.join(distDir, "index.html");
+        const htmlPath = path25.join(distDir, "index.html");
         try {
           const html = fs15.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
@@ -54074,15 +55226,15 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: "Not found" });
           return;
         }
-        const safePath = path222.normalize(pathname).replace(/^\.\.\//, "");
-        const filePath = path222.join(distDir, safePath);
+        const safePath = path25.normalize(pathname).replace(/^\.\.\//, "");
+        const filePath = path25.join(distDir, safePath);
         if (!filePath.startsWith(distDir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
         try {
           const content = fs15.readFileSync(filePath);
-          const ext = path222.extname(filePath);
+          const ext = path25.extname(filePath);
           const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
           res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
           res.end(content);
@@ -54195,10 +55347,10 @@ data: ${JSON.stringify(msg.data)}
               const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 files.push({ path: rel, size: 0, type: "dir" });
-                scan(path222.join(d, entry.name), rel);
+                scan(path25.join(d, entry.name), rel);
               } else {
-                const stat4 = fs15.statSync(path222.join(d, entry.name));
-                files.push({ path: rel, size: stat4.size, type: "file" });
+                const stat22 = fs15.statSync(path25.join(d, entry.name));
+                files.push({ path: rel, size: stat22.size, type: "file" });
               }
             }
           } catch {
@@ -54220,7 +55372,7 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider directory not found: ${type}` });
           return;
         }
-        const fullPath = path222.resolve(dir, path222.normalize(filePath));
+        const fullPath = path25.resolve(dir, path25.normalize(filePath));
         if (!fullPath.startsWith(dir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
@@ -54245,14 +55397,14 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider directory not found: ${type}` });
           return;
         }
-        const fullPath = path222.resolve(dir, path222.normalize(filePath));
+        const fullPath = path25.resolve(dir, path25.normalize(filePath));
         if (!fullPath.startsWith(dir)) {
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
         try {
           if (fs15.existsSync(fullPath)) fs15.copyFileSync(fullPath, fullPath + ".bak");
-          fs15.mkdirSync(path222.dirname(fullPath), { recursive: true });
+          fs15.mkdirSync(path25.dirname(fullPath), { recursive: true });
           fs15.writeFileSync(fullPath, content, "utf-8");
           this.log(`File saved: ${fullPath} (${content.length} chars)`);
           this.providerLoader.reload();
@@ -54269,7 +55421,7 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         for (const name of ["scripts.js", "provider.json"]) {
-          const p = path222.join(dir, name);
+          const p = path25.join(dir, name);
           if (fs15.existsSync(p)) {
             const source = fs15.readFileSync(p, "utf-8");
             this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
@@ -54290,8 +55442,8 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const target = fs15.existsSync(path222.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-        const targetPath = path222.join(dir, target);
+        const target = fs15.existsSync(path25.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const targetPath = path25.join(dir, target);
         try {
           if (fs15.existsSync(targetPath)) fs15.copyFileSync(targetPath, targetPath + ".bak");
           fs15.writeFileSync(targetPath, source, "utf-8");
@@ -54383,14 +55535,14 @@ data: ${JSON.stringify(msg.data)}
           child.stderr?.on("data", (d) => {
             stderr += d.toString();
           });
-          await new Promise((resolve12) => {
+          await new Promise((resolve15) => {
             const timer = setTimeout(() => {
               child.kill();
-              resolve12();
+              resolve15();
             }, timeout);
             child.on("exit", () => {
               clearTimeout(timer);
-              resolve12();
+              resolve15();
             });
           });
           const elapsed = Date.now() - start;
@@ -54438,7 +55590,7 @@ data: ${JSON.stringify(msg.data)}
         }
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type);
-        const jsonPath = path222.join(targetDir, "provider.json");
+        const jsonPath = path25.join(targetDir, "provider.json");
         if (fs15.existsSync(jsonPath)) {
           this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
           return;
@@ -54450,8 +55602,8 @@ data: ${JSON.stringify(msg.data)}
           const createdFiles = ["provider.json"];
           if (result.files) {
             for (const [relPath, content] of Object.entries(result.files)) {
-              const fullPath = path222.join(targetDir, relPath);
-              fs15.mkdirSync(path222.dirname(fullPath), { recursive: true });
+              const fullPath = path25.join(targetDir, relPath);
+              fs15.mkdirSync(path25.dirname(fullPath), { recursive: true });
               fs15.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
@@ -54504,22 +55656,22 @@ data: ${JSON.stringify(msg.data)}
         if (!fs15.existsSync(scriptsDir)) return null;
         const versions = fs15.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs15.statSync(path222.join(scriptsDir, d)).isDirectory();
+            return fs15.statSync(path25.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
         }).sort((a, b2) => b2.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
         if (versions.length === 0) return null;
-        return path222.join(scriptsDir, versions[0]);
+        return path25.join(scriptsDir, versions[0]);
       }
       resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-        const canonicalUserDir = path222.resolve(this.providerLoader.getUserProviderDir(category, type));
-        const desiredDir = requestedDir ? path222.resolve(requestedDir) : canonicalUserDir;
-        const upstreamRoot = path222.resolve(this.providerLoader.getUpstreamDir());
-        if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path222.sep}`)) {
+        const canonicalUserDir = path25.resolve(this.providerLoader.getUserProviderDir(category, type));
+        const desiredDir = requestedDir ? path25.resolve(requestedDir) : canonicalUserDir;
+        const upstreamRoot = path25.resolve(this.providerLoader.getUpstreamDir());
+        if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path25.sep}`)) {
           return { dir: null, reason: `Refusing to write into upstream provider directory: ${desiredDir}` };
         }
-        if (path222.basename(desiredDir) !== type) {
+        if (path25.basename(desiredDir) !== type) {
           return { dir: null, reason: `Requested writable provider directory must end with '${type}': ${desiredDir}` };
         }
         const sourceDir = this.findProviderDir(type);
@@ -54527,11 +55679,11 @@ data: ${JSON.stringify(msg.data)}
           return { dir: null, reason: `Provider source directory not found for '${type}'` };
         }
         if (!fs15.existsSync(desiredDir)) {
-          fs15.mkdirSync(path222.dirname(desiredDir), { recursive: true });
+          fs15.mkdirSync(path25.dirname(desiredDir), { recursive: true });
           fs15.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
-        const providerJson = path222.join(desiredDir, "provider.json");
+        const providerJson = path25.join(desiredDir, "provider.json");
         if (!fs15.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
@@ -54567,7 +55719,7 @@ data: ${JSON.stringify(msg.data)}
           setMode: "set_mode.js"
         };
         const targetFileNames = new Set(functions.map((fn2) => funcToFile[fn2]).filter(Boolean));
-        const scriptsDir = path222.join(providerDir, "scripts");
+        const scriptsDir = path25.join(providerDir, "scripts");
         const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
         if (latestScriptsDir) {
           lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -54578,7 +55730,7 @@ data: ${JSON.stringify(msg.data)}
           for (const file2 of fs15.readdirSync(latestScriptsDir)) {
             if (file2.endsWith(".js") && targetFileNames.has(file2)) {
               try {
-                const content = fs15.readFileSync(path222.join(latestScriptsDir, file2), "utf-8");
+                const content = fs15.readFileSync(path25.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -54595,7 +55747,7 @@ data: ${JSON.stringify(msg.data)}
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs15.readFileSync(path222.join(latestScriptsDir, file2), "utf-8");
+                const content = fs15.readFileSync(path25.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -54636,10 +55788,10 @@ data: ${JSON.stringify(msg.data)}
             lines.push("");
           }
         }
-        const docsDir = path222.join(providerDir, "../../docs");
+        const docsDir = path25.join(providerDir, "../../docs");
         const loadGuide = (name) => {
           try {
-            const p = path222.join(docsDir, name);
+            const p = path25.join(docsDir, name);
             if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
           } catch {
           }
@@ -54813,7 +55965,7 @@ data: ${JSON.stringify(msg.data)}
           parseApproval: "parse_approval.js"
         };
         const targetFileNames = new Set(functions.map((fn2) => funcToFile[fn2]).filter(Boolean));
-        const scriptsDir = path222.join(providerDir, "scripts");
+        const scriptsDir = path25.join(providerDir, "scripts");
         const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
         if (latestScriptsDir) {
           lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -54825,7 +55977,7 @@ data: ${JSON.stringify(msg.data)}
             if (!file2.endsWith(".js")) continue;
             if (!targetFileNames.has(file2)) continue;
             try {
-              const content = fs15.readFileSync(path222.join(latestScriptsDir, file2), "utf-8");
+              const content = fs15.readFileSync(path25.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -54841,7 +55993,7 @@ data: ${JSON.stringify(msg.data)}
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs15.readFileSync(path222.join(latestScriptsDir, file2), "utf-8");
+                const content = fs15.readFileSync(path25.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -54874,10 +56026,10 @@ data: ${JSON.stringify(msg.data)}
             lines.push("");
           }
         }
-        const docsDir = path222.join(providerDir, "../../docs");
+        const docsDir = path25.join(providerDir, "../../docs");
         const loadGuide = (name) => {
           try {
-            const p = path222.join(docsDir, name);
+            const p = path25.join(docsDir, name);
             if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
           } catch {
           }
@@ -55060,14 +56212,14 @@ data: ${JSON.stringify(msg.data)}
         res.end(JSON.stringify(data, null, 2));
       }
       async readBody(req) {
-        return new Promise((resolve12) => {
+        return new Promise((resolve15) => {
           let body = "";
           req.on("data", (chunk) => body += chunk);
           req.on("end", () => {
             try {
-              resolve12(JSON.parse(body));
+              resolve15(JSON.parse(body));
             } catch {
-              resolve12({});
+              resolve15({});
             }
           });
         });
@@ -55569,7 +56721,7 @@ data: ${JSON.stringify(msg.data)}
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
         if (await canConnect(endpoint)) return;
-        await new Promise((resolve12) => setTimeout(resolve12, STARTUP_POLL_MS));
+        await new Promise((resolve15) => setTimeout(resolve15, STARTUP_POLL_MS));
       }
       throw new Error(`Session host did not become ready within ${timeoutMs}ms`);
     }
@@ -55743,10 +56895,10 @@ data: ${JSON.stringify(msg.data)}
             const buffer = Buffer.from(await res.arrayBuffer());
             const fs16 = await import("fs");
             fs16.writeFileSync(vsixPath, buffer);
-            return new Promise((resolve12) => {
+            return new Promise((resolve15) => {
               const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
               (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
-                resolve12({
+                resolve15({
                   extensionId: extension.id,
                   marketplaceId: extension.marketplaceId,
                   success: !error48,
@@ -55759,11 +56911,11 @@ data: ${JSON.stringify(msg.data)}
         } catch (e) {
         }
       }
-      return new Promise((resolve12) => {
+      return new Promise((resolve15) => {
         const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
         (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, stdout, stderr) => {
           if (error48) {
-            resolve12({
+            resolve15({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
               success: false,
@@ -55771,7 +56923,7 @@ data: ${JSON.stringify(msg.data)}
               error: stderr || error48.message
             });
           } else {
-            resolve12({
+            resolve15({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
               success: true,
@@ -56881,6 +58033,8 @@ var StandaloneServer = class {
   wsSessionHostDiagnosticsSubscriptions = /* @__PURE__ */ new Map();
   wsSessionModalSubscriptions = /* @__PURE__ */ new Map();
   wsDaemonMetadataSubscriptions = /* @__PURE__ */ new Map();
+  wsGitSubscriptions = /* @__PURE__ */ new Map();
+  gitWorkspaceMonitor = (0, import_daemon_core2.createGitWorkspaceMonitor)();
   authToken = null;
   passwordConfigPath = getStandalonePasswordConfigPath();
   passwordConfig = null;
@@ -57146,6 +58300,7 @@ var StandaloneServer = class {
       void this.flushWsMachineRuntimeSubscriptions();
       void this.flushWsSessionHostDiagnosticsSubscriptions();
       void this.flushWsSessionModalSubscriptions();
+      if (this.hasWsGitSubscriptions()) void this.flushWsGitSubscriptions();
     }, STATUS_INTERVAL);
     this.running = true;
     await new Promise((resolve4) => {
@@ -57634,6 +58789,7 @@ var StandaloneServer = class {
     this.wsSessionHostDiagnosticsSubscriptions.set(ws2, /* @__PURE__ */ new Map());
     this.wsSessionModalSubscriptions.set(ws2, /* @__PURE__ */ new Map());
     this.wsDaemonMetadataSubscriptions.set(ws2, /* @__PURE__ */ new Map());
+    this.wsGitSubscriptions.set(ws2, /* @__PURE__ */ new Map());
     console.log(`[WS] Client connected (total: ${this.clients.size})`);
     const status = this.getWsStatus(this.buildSharedSnapshot("live"));
     this.lastWsStatusSignature = this.buildWsStatusSignature(status);
@@ -57677,6 +58833,7 @@ var StandaloneServer = class {
       this.wsSessionHostDiagnosticsSubscriptions.delete(ws2);
       this.wsSessionModalSubscriptions.delete(ws2);
       this.wsDaemonMetadataSubscriptions.delete(ws2);
+      this.clearWsGitSubscriptions(ws2);
       console.log(`[WS] Client disconnected (total: ${this.clients.size})`);
     });
     ws2.on("error", () => {
@@ -57686,8 +58843,19 @@ var StandaloneServer = class {
       this.wsSessionHostDiagnosticsSubscriptions.delete(ws2);
       this.wsSessionModalSubscriptions.delete(ws2);
       this.wsDaemonMetadataSubscriptions.delete(ws2);
+      this.clearWsGitSubscriptions(ws2);
     });
   }
+  clearWsGitSubscriptions(ws2) {
+    const subs = this.wsGitSubscriptions.get(ws2);
+    if (subs) {
+      subs.forEach((sub) => {
+        sub.subscription.dispose();
+      });
+      subs.clear();
+    }
+    this.wsGitSubscriptions.delete(ws2);
+  }
   async handleWsSubscribe(ws2, msg) {
     if (msg.topic === "session.chat_tail") {
       const params = msg.params;
@@ -57775,6 +58943,25 @@ var StandaloneServer = class {
         lastSentAt: 0
       });
       await this.flushWsDaemonMetadataSubscriptions(ws2);
+      return;
+    }
+    if (msg.topic === "workspace.git") {
+      const params = msg.params;
+      if (!params?.workspace) return;
+      const normalized = (0, import_daemon_core2.normalizeGitWorkspaceSubscriptionParams)(params);
+      const subs = this.wsGitSubscriptions.get(ws2) || /* @__PURE__ */ new Map();
+      this.wsGitSubscriptions.set(ws2, subs);
+      subs.get(msg.key)?.subscription.dispose();
+      subs.set(msg.key, {
+        request: {
+          ...msg,
+          topic: "workspace.git",
+          params: normalized
+        },
+        subscription: this.gitWorkspaceMonitor.createSubscription(normalized),
+        lastSentAt: 0
+      });
+      await this.flushWsGitSubscriptions(ws2);
     }
   }
   handleWsUnsubscribe(ws2, msg) {
@@ -57796,6 +58983,12 @@ var StandaloneServer = class {
     }
     if (msg.topic === "daemon.metadata") {
       this.wsDaemonMetadataSubscriptions.get(ws2)?.delete(msg.key);
+      return;
+    }
+    if (msg.topic === "workspace.git") {
+      const sub = this.wsGitSubscriptions.get(ws2)?.get(msg.key);
+      sub?.subscription.dispose();
+      this.wsGitSubscriptions.get(ws2)?.delete(msg.key);
     }
   }
   async buildChatTailUpdate(request, state, key) {
@@ -58019,6 +59212,45 @@ var StandaloneServer = class {
       }
     }
   }
+  hasWsGitSubscriptions(targetWs) {
+    const targets = targetWs ? [targetWs] : Array.from(this.clients);
+    for (const ws2 of targets) {
+      const subs = this.wsGitSubscriptions.get(ws2);
+      if (subs && subs.size > 0) return true;
+    }
+    return false;
+  }
+  async flushWsGitSubscriptions(targetWs) {
+    if (!this.hasWsGitSubscriptions(targetWs)) return;
+    const targets = targetWs ? [targetWs] : Array.from(this.clients);
+    const now = Date.now();
+    const tasks = [];
+    for (const ws2 of targets) {
+      if (ws2.readyState !== import_ws.WebSocket.OPEN) continue;
+      const subs = this.wsGitSubscriptions.get(ws2);
+      if (!subs || subs.size === 0) continue;
+      subs.forEach((sub, key) => {
+        const intervalMs = Math.max(1, Number(sub.subscription.params.intervalMs || sub.request.params.intervalMs || 0));
+        if (sub.lastSentAt > 0 && now - sub.lastSentAt < intervalMs) return;
+        tasks.push({ ws: ws2, key, sub });
+      });
+    }
+    await (0, import_daemon_core2.runAsyncBatch)(tasks, async ({ ws: ws2, key, sub }) => {
+      try {
+        const monitorUpdate = await sub.subscription.refresh();
+        const current = this.wsGitSubscriptions.get(ws2)?.get(key);
+        if (current !== sub || ws2.readyState !== import_ws.WebSocket.OPEN) return;
+        sub.lastSentAt = monitorUpdate.timestamp;
+        const update = {
+          ...monitorUpdate,
+          key
+        };
+        ws2.send(JSON.stringify({ type: "topic_update", update }));
+      } catch (error48) {
+        import_daemon_core2.LOG.warn("Standalone", `[workspace.git] skipped workspace=${sub.request.params.workspace} key=${key} error=${error48?.message || error48}`);
+      }
+    }, { concurrency: 2 });
+  }
   // ─── Core Logic ───
   buildSharedSnapshot(profile = "full") {
     const cfgSnap = (0, import_daemon_core2.loadConfig)();
@@ -58143,6 +59375,7 @@ var StandaloneServer = class {
     }
     if (type.startsWith("session_host_")) void this.flushWsSessionHostDiagnosticsSubscriptions();
     if (type === "resolve_action" || type === "send_chat" || type === "read_chat") void this.flushWsSessionModalSubscriptions();
+    if (type.startsWith("git_") && this.hasWsGitSubscriptions()) void this.flushWsGitSubscriptions();
     return result;
   }
   scheduleBroadcastStatus() {