@adhdev/daemon-core 0.9.53 → 0.9.54

package/dist/index.mjs

@@ -265,7 +265,7 @@ var init_config = __esm({
 
 // src/logging/logger.ts
 import * as fs2 from "fs";
-import * as path6 from "path";
+import * as path9 from "path";
 import * as os4 from "os";
 function setLogLevel(level) {
   currentLevel = level;
@@ -281,13 +281,13 @@ function getDaemonLogDir() {
   return LOG_DIR;
 }
 function getCurrentDaemonLogPath(date = /* @__PURE__ */ new Date()) {
-  return path6.join(LOG_DIR, `daemon-${date.toISOString().slice(0, 10)}.log`);
+  return path9.join(LOG_DIR, `daemon-${date.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();
   }
 }
@@ -301,7 +301,7 @@ function cleanOldLogs() {
       const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs2.unlinkSync(path6.join(LOG_DIR, file));
+          fs2.unlinkSync(path9.join(LOG_DIR, file));
         } catch {
         }
       }
@@ -311,8 +311,8 @@ function cleanOldLogs() {
 }
 function rotateSizeIfNeeded() {
   try {
-    const stat = fs2.statSync(currentLogFile);
-    if (stat.size > MAX_LOG_SIZE) {
+    const stat2 = fs2.statSync(currentLogFile);
+    if (stat2.size > MAX_LOG_SIZE) {
       const backup = currentLogFile.replace(".log", ".1.log");
       try {
         fs2.unlinkSync(backup);
@@ -424,7 +424,7 @@ var init_logger = __esm({
     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(os4.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path6.join(os4.homedir(), "Library", "Logs", "adhdev") : path6.join(os4.homedir(), ".local", "share", "adhdev", "logs");
+    LOG_DIR = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || process.env.APPDATA || path9.join(os4.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path9.join(os4.homedir(), "Library", "Logs", "adhdev") : path9.join(os4.homedir(), ".local", "share", "adhdev", "logs");
     MAX_LOG_SIZE = 5 * 1024 * 1024;
     MAX_LOG_DAYS = 7;
     try {
@@ -432,16 +432,16 @@ var init_logger = __esm({
     } 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 (fs2.existsSync(oldLog)) {
-        const stat = fs2.statSync(oldLog);
-        const oldDate = stat.mtime.toISOString().slice(0, 10);
-        fs2.renameSync(oldLog, path6.join(LOG_DIR, `daemon-${oldDate}.log`));
+        const stat2 = fs2.statSync(oldLog);
+        const oldDate = stat2.mtime.toISOString().slice(0, 10);
+        fs2.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 (fs2.existsSync(oldLogBackup)) {
         fs2.unlinkSync(oldLogBackup);
       }
@@ -473,7 +473,7 @@ var init_logger = __esm({
       }
     };
     interceptorInstalled = false;
-    LOG_PATH = path6.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+    LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
   }
 });
 
@@ -1380,8 +1380,8 @@ var init_pty_transport = __esm({
         if (cwd) {
           try {
             const fs16 = __require("fs");
-            const stat = fs16.statSync(cwd);
-            if (!stat.isDirectory()) cwd = os8.homedir();
+            const stat2 = fs16.statSync(cwd);
+            if (!stat2.isDirectory()) cwd = os8.homedir();
           } catch {
             cwd = os8.homedir();
           }
@@ -1401,7 +1401,7 @@ var init_pty_transport = __esm({
 
 // src/cli-adapters/provider-cli-shared.ts
 import * as os9 from "os";
-import * as path10 from "path";
+import * as path13 from "path";
 import { execSync as execSync3 } from "child_process";
 function stripAnsi(str) {
   return str.replace(/\x1B\][^\x07]*\x07/g, "").replace(/\x1B\][\s\S]*?\x1B\\/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B\[\d*[A-HJKSTfG]/g, " ").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/  +/g, " ");
@@ -1466,9 +1466,9 @@ function buildCliScreenSnapshot(text) {
 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 {
@@ -1484,7 +1484,7 @@ function findBinary(name) {
   }
 }
 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);
@@ -1500,7 +1500,7 @@ function isScriptBinary(binaryPath) {
   }
 }
 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);
@@ -1961,7 +1961,7 @@ var init_provider_cli_config = __esm({
 
 // src/cli-adapters/provider-cli-runtime.ts
 import * as os10 from "os";
-import * as path11 from "path";
+import * as path14 from "path";
 import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from "@adhdev/session-host-core";
 function resolveCliSpawnPlan(options) {
   const { provider, runtimeSettings, workingDir, extraArgs } = options;
@@ -1972,9 +1972,9 @@ function resolveCliSpawnPlan(options) {
   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";
@@ -2851,7 +2851,7 @@ var init_provider_cli_adapter = __esm({
               `[${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() || "";
         LOG.warn(
@@ -4039,7 +4039,7 @@ var init_provider_cli_adapter = __esm({
           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) {
@@ -4120,13 +4120,13 @@ var init_provider_cli_adapter = __esm({
         }
         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: (error) => {
               if (resolved) return;
@@ -4288,17 +4288,17 @@ var init_provider_cli_adapter = __esm({
         }
       }
       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);
         });
@@ -4524,20 +4524,1137 @@ var init_provider_cli_adapter = __esm({
   }
 });
 
+// src/git/git-executor.ts
+import { execFile } from "child_process";
+import { constants } from "fs";
+import { access, realpath, stat } from "fs/promises";
+import * as path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(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 = path.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 realpath(repo.repoRoot);
+  const canonicalCwd = await 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 = path.relative(path.resolve(parent), path.resolve(child));
+  return relative3 === "" || !relative3.startsWith("..") && !path.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 (!path.isAbsolute(workspace)) {
+    throw new GitCommandError("invalid_args", "Workspace must be an absolute path", { cwd: workspace });
+  }
+  const normalizedWorkspace = path.resolve(workspace);
+  try {
+    const info = await stat(normalizedWorkspace);
+    if (!info.isDirectory()) {
+      throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
+        cwd: normalizedWorkspace
+      });
+    }
+    await access(normalizedWorkspace, constants.R_OK);
+  } catch (error) {
+    if (error instanceof GitCommandError) throw error;
+    throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
+      cwd: normalizedWorkspace,
+      cause: error
+    });
+  }
+  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 (error) {
+    throw mapExecError(error, cwd, argv, behavior);
+  }
+}
+function mapExecError(error, cwd, argv, behavior) {
+  const execError = error;
+  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: error
+    });
+  }
+  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: error
+    });
+  }
+  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: error
+    });
+  }
+  return new GitCommandError("git_command_failed", message || "Git command failed", {
+    stdout,
+    stderr,
+    exitCode: code,
+    signal,
+    argv,
+    cwd,
+    cause: error
+  });
+}
+
+// src/git/git-status.ts
+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 (error) {
+    if (error instanceof GitCommandError) {
+      return emptyStatus(workspace, lastCheckedAt, error);
+    }
+    return emptyStatus(
+      workspace,
+      lastCheckedAt,
+      new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error })
+    );
+  }
+}
+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, error) {
+  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: error.stderr || error.message,
+    reason: error.reason
+  };
+}
+
+// src/git/git-diff.ts
+import { readFile, realpath as realpath2 } from "fs/promises";
+import * as path2 from "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, file) => sum + file.insertions, 0),
+      totalDeletions: files.reduce((sum, file) => sum + file.deletions, 0),
+      truncated,
+      lastCheckedAt
+    };
+  } catch (error) {
+    const gitError = error instanceof GitCommandError ? error : new GitCommandError("git_command_failed", "Failed to read Git diff summary", { cause: error });
+    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 realpath2(repoRoot).catch(() => path2.resolve(repoRoot));
+  const absolutePath = path2.isAbsolute(filePath) ? path2.resolve(filePath) : path2.resolve(repoRoot, filePath);
+  const checkPath = await realpath2(absolutePath).catch(() => absolutePath);
+  const relativeBase = isPathInside(canonicalRepoRoot, checkPath) ? canonicalRepoRoot : path2.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 = path2.relative(relativeBase, checkPath).split(path2.sep).join("/");
+  if (!relativePath || relativePath.startsWith("..") || path2.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 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);
+}
+
+// src/git/git-summary.ts
+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;
+
+// src/git/git-snapshot-store.ts
+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(file) {
+  return `${file.oldPath ?? ""}\0${file.path}`;
+}
+function uniqueSorted(values) {
+  return Array.from(new Set(Array.from(values).filter(Boolean))).sort((a, b) => a.localeCompare(b));
+}
+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((file) => !beforeFileKeys.has(changedFileKey(file)));
+  const addedFiles = [];
+  const modifiedFiles = [];
+  const deletedFiles = [];
+  const renamedFiles = [];
+  const untrackedFiles = [];
+  const conflictFilesFromDiff = [];
+  let totalInsertions = 0;
+  let totalDeletions = 0;
+  for (const file of changedAfterFiles) {
+    totalInsertions += file.insertions;
+    totalDeletions += file.deletions;
+    switch (file.status) {
+      case "added":
+      case "copied":
+        addedFiles.push(file.path);
+        break;
+      case "modified":
+        modifiedFiles.push(file.path);
+        break;
+      case "deleted":
+        deletedFiles.push(file.path);
+        break;
+      case "renamed":
+        renamedFiles.push({ oldPath: file.oldPath ?? file.path, path: file.path });
+        break;
+      case "untracked":
+        untrackedFiles.push(file.path);
+        break;
+      case "conflict":
+        conflictFilesFromDiff.push(file.path);
+        break;
+    }
+  }
+  renamedFiles.sort((a, b) => `${a.oldPath}\0${a.path}`.localeCompare(`${b.oldPath}\0${b.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);
+}
+
+// src/git/git-monitor.ts
+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 normalizeGitWorkspaceSubscriptionParams(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 normalizeGitWorkspaceSubscriptionParams(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 createGitWorkspaceMonitor(options = {}) {
+  return new GitWorkspaceMonitor(options);
+}
+
+// src/git/git-commands.ts
+import * as path3 from "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, error) {
+  return { success: false, reason, error };
+}
+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 || !path3.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(error) {
+  return typeof error?.reason === "string" && FAILURE_REASONS.has(error.reason) ? error.reason : "git_command_failed";
+}
+async function runService(fn) {
+  try {
+    return await fn();
+  } catch (error) {
+    return failure(failureReasonFromError(error), error?.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 (path3.isAbsolute(filePath)) {
+    throw new GitCommandError("invalid_args", "path must be repository-relative");
+  }
+  const normalized = path3.normalize(filePath).split(path3.sep).join("/");
+  const absolutePath = path3.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;
+}
+
 // src/index.ts
 init_config();
 
 // src/config/workspaces.ts
 import * as fs from "fs";
 import * as os from "os";
-import * as path from "path";
+import * as path4 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var MAX_WORKSPACES = 50;
 function expandPath(p) {
   const t = (p || "").trim();
   if (!t) return "";
-  if (t.startsWith("~")) return path.join(os.homedir(), t.slice(1).replace(/^\//, ""));
-  return path.resolve(t);
+  if (t.startsWith("~")) return path4.join(os.homedir(), t.slice(1).replace(/^\//, ""));
+  return path4.resolve(t);
 }
 function validateWorkspacePath(absPath) {
   try {
@@ -4551,7 +5668,7 @@ function validateWorkspacePath(absPath) {
   }
 }
 function defaultWorkspaceLabel(absPath) {
-  const base = path.basename(absPath) || absPath;
+  const base = path4.basename(absPath) || absPath;
   return base;
 }
 function getDefaultWorkspacePath(config) {
@@ -4642,9 +5759,9 @@ function resolveIdeLaunchWorkspace(args, config) {
   return getDefaultWorkspacePath(config) || void 0;
 }
 function findWorkspaceByPath(config, rawPath) {
-  const abs = path.resolve(expandPath(rawPath));
+  const abs = path4.resolve(expandPath(rawPath));
   if (!abs) return void 0;
-  return (config.workspaces || []).find((w) => path.resolve(expandPath(w.path)) === abs);
+  return (config.workspaces || []).find((w) => path4.resolve(expandPath(w.path)) === abs);
 }
 function addWorkspaceEntry(config, rawPath, label, options) {
   const abs = expandPath(rawPath);
@@ -4660,7 +5777,7 @@ function addWorkspaceEntry(config, rawPath, label, options) {
   const v = validateWorkspacePath(abs);
   if (!v.ok) return { error: v.error };
   const list = [...config.workspaces || []];
-  if (list.some((w) => path.resolve(w.path) === abs)) {
+  if (list.some((w) => path4.resolve(w.path) === abs)) {
     return { error: "Workspace already in list" };
   }
   if (list.length >= MAX_WORKSPACES) {
@@ -4694,7 +5811,7 @@ function setDefaultWorkspaceId(config, id) {
 }
 
 // src/config/recent-activity.ts
-import * as path2 from "path";
+import * as path5 from "path";
 
 // src/providers/summary-metadata.ts
 function normalizeSummaryItem(item) {
@@ -4763,9 +5880,9 @@ var MAX_ACTIVITY = 30;
 function normalizeWorkspace(workspace) {
   if (!workspace) return "";
   try {
-    return path2.resolve(expandPath(workspace));
+    return path5.resolve(expandPath(workspace));
   } catch {
-    return path2.resolve(workspace);
+    return path5.resolve(workspace);
   }
 }
 function buildRecentActivityKey(entry) {
@@ -4933,14 +6050,14 @@ function markSessionSeen(state, sessionId, seenAt = Date.now(), completionMarker
 }
 
 // src/config/saved-sessions.ts
-import * as path3 from "path";
+import * as path6 from "path";
 var MAX_SAVED_SESSIONS = 500;
 function normalizeWorkspace2(workspace) {
   if (!workspace) return "";
   try {
-    return path3.resolve(expandPath(workspace));
+    return path6.resolve(expandPath(workspace));
   } catch {
-    return path3.resolve(workspace);
+    return path6.resolve(workspace);
   }
 }
 function buildSavedProviderSessionKey(providerSessionId) {
@@ -5059,7 +6176,7 @@ function resetState() {
 import { execSync } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { platform, homedir as homedir3 } from "os";
-import * as path4 from "path";
+import * as path7 from "path";
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -5078,9 +6195,9 @@ function getMergedDefinitions() {
 function findCliCommand(command) {
   const trimmed = String(command || "").trim();
   if (!trimmed) return null;
-  if (path4.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
-    const candidate = trimmed.startsWith("~") ? path4.join(homedir3(), trimmed.slice(1)) : trimmed;
-    const resolved = path4.isAbsolute(candidate) ? candidate : path4.resolve(candidate);
+  if (path7.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
+    const candidate = trimmed.startsWith("~") ? path7.join(homedir3(), trimmed.slice(1)) : trimmed;
+    const resolved = path7.isAbsolute(candidate) ? candidate : path7.resolve(candidate);
     return existsSync4(resolved) ? resolved : null;
   }
   try {
@@ -5108,7 +6225,7 @@ function getIdeVersion(cliCommand) {
 function checkPathExists(paths) {
   const home = homedir3();
   for (const p of paths) {
-    const normalized = p.startsWith("~") ? path4.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);
@@ -5166,7 +6283,7 @@ async function detectIDEs(providerLoader) {
 // src/detection/cli-detector.ts
 import { exec } from "child_process";
 import * as os2 from "os";
-import * as path5 from "path";
+import * as path8 from "path";
 import { existsSync as existsSync5 } from "fs";
 function parseVersion(raw) {
   const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
@@ -5179,36 +6296,36 @@ function shellQuote(value) {
 function expandHome(value) {
   const trimmed = value.trim();
   if (!trimmed.startsWith("~")) return trimmed;
-  return path5.join(os2.homedir(), trimmed.slice(1));
+  return path8.join(os2.homedir(), trimmed.slice(1));
 }
 function isExplicitCommandPath(command) {
   const trimmed = command.trim();
-  return path5.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 = path5.isAbsolute(expanded) ? expanded : path5.resolve(expanded);
+    const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
     return existsSync5(candidate) ? candidate : null;
   }
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve15) => {
     const child = 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) {
@@ -5573,7 +6690,7 @@ var DaemonCdpManager = class {
   * 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());
@@ -5589,16 +6706,16 @@ var DaemonCdpManager = class {
               (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([]);
       });
     });
   }
@@ -5638,7 +6755,7 @@ var DaemonCdpManager = class {
     }
   }
   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());
@@ -5649,7 +6766,7 @@ var DaemonCdpManager = class {
               (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 || ""));
@@ -5668,25 +6785,25 @@ var DaemonCdpManager = class {
                 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);
       });
     });
   }
@@ -5697,7 +6814,7 @@ var DaemonCdpManager = class {
     this.extensionProviders = providers;
   }
   connectToTarget(wsUrl) {
-    return new Promise((resolve12) => {
+    return new Promise((resolve15) => {
       this.ws = new WebSocket(wsUrl);
       this.ws.on("open", async () => {
         this._connected = true;
@@ -5707,17 +6824,17 @@ var DaemonCdpManager = class {
         }
         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") {
@@ -5740,7 +6857,7 @@ var DaemonCdpManager = class {
       this.ws.on("error", (err) => {
         this.log(`[CDP] WebSocket error: ${err.message}`);
         this._connected = false;
-        resolve12(false);
+        resolve15(false);
       });
     });
   }
@@ -5754,7 +6871,7 @@ var DaemonCdpManager = class {
         return;
       }
       this.log(`[CDP] Connecting browser WS for target discovery...`);
-      await new Promise((resolve12, reject) => {
+      await new Promise((resolve15, reject) => {
         this.browserWs = new WebSocket(browserWsUrl);
         this.browserWs.on("open", async () => {
           this._browserConnected = true;
@@ -5764,16 +6881,16 @@ var DaemonCdpManager = class {
           } 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 {
           }
@@ -5793,31 +6910,31 @@ var DaemonCdpManager = class {
     }
   }
   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)) {
@@ -5857,11 +6974,11 @@ var DaemonCdpManager = class {
   }
   // ─── 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 !== WebSocket.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)) {
@@ -6110,7 +7227,7 @@ var DaemonCdpManager = class {
     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) => {
@@ -6119,7 +7236,7 @@ var DaemonCdpManager = class {
             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 {
           }
@@ -6320,14 +7437,14 @@ var DaemonCdpManager = class {
     if (!ws || ws.readyState !== WebSocket.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
@@ -6359,10 +7476,10 @@ var DaemonCdpManager = class {
       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 });
         ws.send(JSON.stringify({ id, sessionId, method, params }));
         setTimeout(() => {
           if (pendingMap.has(id)) {
@@ -7109,9 +8226,9 @@ ${cleanBody}`;
 // src/config/chat-history.ts
 init_chat_message_normalization();
 import * as fs3 from "fs";
-import * as path7 from "path";
+import * as path10 from "path";
 import * as os5 from "os";
-var HISTORY_DIR = path7.join(os5.homedir(), ".adhdev", "history");
+var HISTORY_DIR = path10.join(os5.homedir(), ".adhdev", "history");
 var RETAIN_DAYS = 30;
 var SAVED_HISTORY_INDEX_VERSION = 1;
 var SAVED_HISTORY_INDEX_FILE = ".saved-history-index.json";
@@ -7274,8 +8391,8 @@ function extractSavedHistorySessionIdFromFile(file) {
 function buildSavedHistoryFileSignatureMap(dir, files) {
   return new Map(files.map((file) => {
     try {
-      const stat = fs3.statSync(path7.join(dir, file));
-      return [file, `${file}:${stat.size}:${Math.trunc(stat.mtimeMs)}`];
+      const stat2 = fs3.statSync(path10.join(dir, file));
+      return [file, `${file}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`];
     } catch {
       return [file, `${file}:missing`];
     }
@@ -7285,7 +8402,7 @@ function buildSavedHistoryCacheSignature(files, fileSignatures) {
   return files.map((file) => fileSignatures.get(file) || `${file}: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}`;
@@ -7338,8 +8455,8 @@ function acquireSavedHistoryIndexLock(dir) {
     } catch (error) {
       if (error?.code !== "EEXIST") return null;
       try {
-        const stat = fs3.statSync(lockPath);
-        if (Date.now() - stat.mtimeMs > SAVED_HISTORY_INDEX_LOCK_STALE_MS) {
+        const stat2 = fs3.statSync(lockPath);
+        if (Date.now() - stat2.mtimeMs > SAVED_HISTORY_INDEX_LOCK_STALE_MS) {
           fs3.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
@@ -7387,7 +8504,7 @@ function savePersistedSavedHistoryIndex(dir, entries) {
     }
     for (const file of Array.from(currentEntries.keys())) {
       if (incomingFiles.has(file)) continue;
-      if (!fs3.existsSync(path7.join(dir, file))) {
+      if (!fs3.existsSync(path10.join(dir, file))) {
         currentEntries.delete(file);
       }
     }
@@ -7402,8 +8519,8 @@ function invalidatePersistedSavedHistoryIndex(agentType, dir) {
 }
 function buildSavedHistoryIndexFileSignature(dir) {
   try {
-    const stat = fs3.statSync(getSavedHistoryIndexFilePath(dir));
-    return `index:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+    const stat2 = fs3.statSync(getSavedHistoryIndexFilePath(dir));
+    return `index:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`;
   } catch {
     return "index:missing";
   }
@@ -7413,8 +8530,8 @@ function historyDirectoryHasFilesNewerThanIndex(dir) {
     const indexStat = fs3.statSync(getSavedHistoryIndexFilePath(dir));
     const files = listHistoryFiles(dir);
     for (const file of files) {
-      const stat = fs3.statSync(path7.join(dir, file));
-      if (stat.mtimeMs > indexStat.mtimeMs) return true;
+      const stat2 = fs3.statSync(path10.join(dir, file));
+      if (stat2.mtimeMs > indexStat.mtimeMs) return true;
     }
     return false;
   } catch {
@@ -7423,14 +8540,14 @@ function historyDirectoryHasFilesNewerThanIndex(dir) {
 }
 function buildSavedHistoryFileSignature(dir, file) {
   try {
-    const stat = fs3.statSync(path7.join(dir, file));
-    return `${file}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+    const stat2 = fs3.statSync(path10.join(dir, file));
+    return `${file}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`;
   } catch {
     return `${file}:missing`;
   }
 }
 function persistSavedHistoryFileSummaryEntry(agentType, dir, file, updater) {
-  const filePath = path7.join(dir, file);
+  const filePath = path10.join(dir, file);
   const result = withLockedPersistedSavedHistoryIndex(dir, (entries) => {
     const currentEntry = entries.get(file) || null;
     const nextSummary = updater(currentEntry?.summary || null);
@@ -7503,7 +8620,7 @@ function updateSavedHistoryIndexForAppendedMessages(agentType, dir, file, histor
 function computeSavedHistoryFileSummary(dir, file) {
   const historySessionId = extractSavedHistorySessionIdFromFile(file);
   if (!historySessionId) return null;
-  const filePath = path7.join(dir, file);
+  const filePath = path10.join(dir, file);
   const content = fs3.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter(Boolean);
   let messageCount = 0;
@@ -7590,7 +8707,7 @@ function computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatur
   const summaryBySessionId = /* @__PURE__ */ new Map();
   const nextPersistedEntries = /* @__PURE__ */ new Map();
   for (const file of files.slice().sort()) {
-    const filePath = path7.join(dir, file);
+    const filePath = path10.join(dir, file);
     const signature = fileSignatures.get(file) || `${file}:missing`;
     const cached = savedHistoryFileSummaryCache.get(filePath);
     const persisted = persistedEntries.get(file);
@@ -7710,12 +8827,12 @@ var ChatHistoryWriter = class {
         });
       }
       if (newMessages.length === 0) return;
-      const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
       fs3.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
       const fileName = `${filePrefix}${date}.jsonl`;
-      const filePath = path7.join(dir, fileName);
+      const filePath = path10.join(dir, fileName);
       const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
       fs3.appendFileSync(filePath, lines, "utf-8");
       updateSavedHistoryIndexForAppendedMessages(agentType, dir, fileName, effectiveHistoryKey, newMessages);
@@ -7806,11 +8923,11 @@ var ChatHistoryWriter = class {
     const ws = String(workspace || "").trim();
     if (!id || !ws) return;
     try {
-      const dir = path7.join(HISTORY_DIR, this.sanitize(agentType));
+      const dir = path10.join(HISTORY_DIR, this.sanitize(agentType));
       fs3.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const fileName = `${this.sanitize(id)}_${date}.jsonl`;
-      const filePath = path7.join(dir, fileName);
+      const filePath = path10.join(dir, fileName);
       const record = {
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         receivedAt: Date.now(),
@@ -7856,14 +8973,14 @@ var ChatHistoryWriter = class {
         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 (!fs3.existsSync(dir)) return;
       const fromPrefix = `${this.sanitize(fromId)}_`;
       const toPrefix = `${this.sanitize(toId)}_`;
       const files = fs3.readdirSync(dir).filter((file) => file.startsWith(fromPrefix) && file.endsWith(".jsonl"));
       for (const file of files) {
-        const sourcePath = path7.join(dir, file);
-        const targetPath = path7.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
+        const sourcePath = path10.join(dir, file);
+        const targetPath = path10.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
         const sourceLines = fs3.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
         const rewritten = sourceLines.map((line) => {
           try {
@@ -7897,13 +9014,13 @@ var ChatHistoryWriter = class {
     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 (!fs3.existsSync(dir)) return;
       const prefix = `${this.sanitize(sessionId)}_`;
       const files = fs3.readdirSync(dir).filter((file) => file.startsWith(prefix) && file.endsWith(".jsonl")).sort();
       const seen = /* @__PURE__ */ new Set();
       for (const file of files) {
-        const filePath = path7.join(dir, file);
+        const filePath = path10.join(dir, file);
         const lines = fs3.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
         const next = [];
         for (const line of lines) {
@@ -7957,13 +9074,13 @@ var ChatHistoryWriter = class {
       const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1e3;
       const agentDirs = fs3.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 = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
         let removedAny = false;
         for (const file of files) {
-          const filePath = path7.join(dirPath, file);
-          const stat = fs3.statSync(filePath);
-          if (stat.mtimeMs < cutoff) {
+          const filePath = path10.join(dirPath, file);
+          const stat2 = fs3.statSync(filePath);
+          if (stat2.mtimeMs < cutoff) {
             fs3.unlinkSync(filePath);
             removedAny = true;
           }
@@ -8011,13 +9128,13 @@ function pageHistoryRecords(agentType, records, offset = 0, limit = 30, excludeR
 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 (!fs3.existsSync(dir)) return { messages: [], hasMore: false };
     const files = listHistoryFiles(dir, historySessionId);
     const allMessages = [];
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
-      const filePath = path7.join(dir, file);
+      const filePath = path10.join(dir, file);
       const content = fs3.readFileSync(filePath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
       for (let i = 0; i < lines.length; i++) {
@@ -8041,7 +9158,7 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, ex
 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 (!fs3.existsSync(dir)) {
       savedHistorySessionCache.delete(sanitized);
       return { sessions: [], hasMore: false };
@@ -8102,11 +9219,11 @@ function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
 }
 function readExistingSessionStartRecord(agentType, historySessionId) {
   try {
-    const dir = path7.join(HISTORY_DIR, agentType);
+    const dir = path10.join(HISTORY_DIR, agentType);
     if (!fs3.existsSync(dir)) return null;
     const files = listHistoryFiles(dir, historySessionId).sort();
     for (const file of files) {
-      const lines = fs3.readFileSync(path7.join(dir, file), "utf-8").split("\n").filter(Boolean);
+      const lines = fs3.readFileSync(path10.join(dir, file), "utf-8").split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const parsed = JSON.parse(line);
@@ -8126,16 +9243,16 @@ function readExistingSessionStartRecord(agentType, historySessionId) {
 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);
     fs3.mkdirSync(dir, { recursive: true });
     const prefix = `${historySessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
     for (const file of fs3.readdirSync(dir)) {
       if (file.startsWith(prefix) && file.endsWith(".jsonl")) {
-        fs3.unlinkSync(path7.join(dir, file));
+        fs3.unlinkSync(path10.join(dir, file));
       }
     }
     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`);
     fs3.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join("\n")}
 `, "utf-8");
     invalidatePersistedSavedHistoryIndex(agentType, dir);
@@ -10007,6 +11124,10 @@ function shouldIncludeSessionMetadata(profile) {
 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;
@@ -10062,6 +11183,8 @@ function buildIdeWorkspaceSession(state, cdpManagers, options) {
   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,
@@ -10074,7 +11197,8 @@ function buildIdeWorkspaceSession(state, cdpManagers, options) {
       activeModal: activeChat?.activeModal || null
     }),
     title,
-    workspace: state.workspace || null,
+    workspace,
+    ...git && { git },
     activeChat,
     ...summaryMetadata && { summaryMetadata },
     ...includeSessionMetadata && { capabilities: state.sessionCapabilities || IDE_SESSION_CAPABILITIES },
@@ -10095,6 +11219,8 @@ function buildExtensionAgentSession(parent, ext, options) {
   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,
@@ -10107,7 +11233,8 @@ function buildExtensionAgentSession(parent, ext, options) {
       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 },
@@ -10143,6 +11270,8 @@ function buildCliSession(state, options) {
   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,
@@ -10155,7 +11284,8 @@ function buildCliSession(state, options) {
       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,
@@ -10190,6 +11320,8 @@ function buildAcpSession(state, options) {
   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,
@@ -10201,7 +11333,8 @@ function buildAcpSession(state, options) {
       activeModal: activeChat?.activeModal || null
     }),
     title: activeChat?.title || state.name,
-    workspace: state.workspace || null,
+    workspace,
+    ...git && { git },
     activeChat,
     ...summaryMetadata && { summaryMetadata },
     ...includeSessionMetadata && { capabilities: ACP_SESSION_CAPABILITIES },
@@ -10321,7 +11454,7 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
 init_contracts();
 import * as fs4 from "fs";
 import * as os6 from "os";
-import * as path8 from "path";
+import * as path11 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/providers/provider-input-support.ts
@@ -11013,7 +12146,7 @@ function buildDebugBundleText(bundle) {
 }
 function getChatDebugBundleDir() {
   const override = typeof process.env.ADHDEV_DEBUG_BUNDLE_DIR === "string" ? process.env.ADHDEV_DEBUG_BUNDLE_DIR.trim() : "";
-  return override || path8.join(os6.homedir(), ".adhdev", "debug-bundles", "chat");
+  return override || path11.join(os6.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);
@@ -11046,7 +12179,7 @@ function storeChatDebugBundleOnDaemon(bundle, targetSessionId) {
   const bundleId = createChatDebugBundleId(targetSessionId);
   const dir = getChatDebugBundleDir();
   fs4.mkdirSync(dir, { recursive: true });
-  const savedPath = path8.join(dir, `${bundleId}.json`);
+  const savedPath = path11.join(dir, `${bundleId}.json`);
   const json = `${JSON.stringify(bundle, null, 2)}
 `;
   fs4.writeFileSync(savedPath, json, { encoding: "utf8", mode: 384 });
@@ -11240,7 +12373,7 @@ function getCliVisibleTranscriptCount(adapter) {
 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;
 }
@@ -11248,7 +12381,7 @@ async function verifyExtensionSendObserved(h, before) {
   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);
@@ -12184,7 +13317,7 @@ async function handleResolveAction(h, args) {
 
 // src/commands/cdp-commands.ts
 import * as fs5 from "fs";
-import * as path9 from "path";
+import * as path12 from "path";
 import * as os7 from "os";
 var KEY_TO_VK = {
   Backspace: 8,
@@ -12441,25 +13574,25 @@ function resolveSafePath(requestedPath) {
   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 = fs5.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" });
@@ -12475,11 +13608,11 @@ function listDirectoryEntriesSafe(dirPath) {
         files.push({ name: entry.name, type: "file", size });
         continue;
       }
-      const stat = fs5.statSync(entryPath);
+      const stat2 = fs5.statSync(entryPath);
       files.push({
         name: entry.name,
-        type: stat.isDirectory() ? "directory" : "file",
-        size: stat.isFile() ? stat.size : void 0
+        type: stat2.isDirectory() ? "directory" : "file",
+        size: stat2.isFile() ? stat2.size : void 0
       });
     } catch {
     }
@@ -12513,7 +13646,7 @@ async function handleFileRead(h, args) {
 async function handleFileWrite(h, args) {
   try {
     const filePath = resolveSafePath(args?.path);
-    fs5.mkdirSync(path9.dirname(filePath), { recursive: true });
+    fs5.mkdirSync(path12.dirname(filePath), { recursive: true });
     fs5.writeFileSync(filePath, args?.content || "", "utf-8");
     return { success: true, path: filePath };
   } catch (e) {
@@ -12862,7 +13995,7 @@ async function executeProviderScript(h, args, scriptName) {
         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");
         }
       }
@@ -13356,6 +14489,12 @@ var DaemonCommandHandler = class {
     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",
@@ -13381,7 +14520,6 @@ var DaemonCommandHandler = class {
       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)) {
@@ -13532,7 +14670,7 @@ var DaemonCommandHandler = class {
     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,
@@ -13544,9 +14682,9 @@ var DaemonCommandHandler = class {
           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 });
             }
           });
         });
@@ -13564,15 +14702,15 @@ var DaemonCommandHandler = class {
     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);
@@ -13586,7 +14724,7 @@ var DaemonCommandHandler = class {
     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,
@@ -13598,9 +14736,9 @@ var DaemonCommandHandler = class {
           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 });
             }
           });
         });
@@ -13618,7 +14756,7 @@ var DaemonCommandHandler = class {
 // src/commands/cli-manager.ts
 init_provider_cli_adapter();
 import * as os13 from "os";
-import * as path13 from "path";
+import * as path16 from "path";
 import * as crypto4 from "crypto";
 import { existsSync as existsSync10 } from "fs";
 import { execFileSync } from "child_process";
@@ -13628,7 +14766,7 @@ init_config();
 // src/providers/cli-provider-instance.ts
 init_contracts();
 import * as os12 from "os";
-import * as path12 from "path";
+import * as path15 from "path";
 import * as crypto3 from "crypto";
 import * as fs6 from "fs";
 import { createRequire } from "module";
@@ -13688,7 +14826,7 @@ function buildIncrementalHistoryAppendMessages(previousMessages, currentMessages
 var CachedDatabaseSync = null;
 function getDatabaseSync() {
   if (CachedDatabaseSync) return CachedDatabaseSync;
-  const requireFn = typeof __require === "function" ? __require : createRequire(path12.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
+  const requireFn = typeof __require === "function" ? __require : createRequire(path15.join(process.cwd(), "__adhdev_sqlite_loader__.js"));
   const sqliteModule = requireFn(`node:${"sqlite"}`);
   CachedDatabaseSync = sqliteModule.DatabaseSync;
   if (!CachedDatabaseSync) {
@@ -13726,7 +14864,7 @@ async function waitForCliAdapterReady(adapter, options) {
     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`);
 }
@@ -14077,7 +15215,7 @@ var CliProviderInstance = class {
       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");
       }
     }
@@ -15196,13 +16334,13 @@ var AcpProviderInstance = class {
         }
         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);
         });
@@ -15777,11 +16915,11 @@ function shouldRestoreHostedRuntime(record, managerTag) {
 // src/commands/cli-manager.ts
 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();
@@ -16062,7 +17200,7 @@ var DaemonCliManager = class {
   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;
@@ -16563,11 +17701,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
 import { execSync as execSync4, spawn as spawn2 } from "child_process";
 import * as net from "net";
 import * as os15 from "os";
-import * as path15 from "path";
+import * as path18 from "path";
 
 // src/providers/provider-loader.ts
 import * as fs7 from "fs";
-import * as path14 from "path";
+import * as path17 from "path";
 import * as os14 from "os";
 import * as chokidar from "chokidar";
 init_logger();
@@ -16832,7 +17970,7 @@ var ProviderLoader = class _ProviderLoader {
     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;
@@ -16840,20 +17978,20 @@ var ProviderLoader = class _ProviderLoader {
   }
   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) {
@@ -16875,7 +18013,7 @@ var ProviderLoader = class _ProviderLoader {
             return { path: siblingCandidate, source };
           }
         }
-        const parent = path14.dirname(current);
+        const parent = path17.dirname(current);
         if (parent === current) break;
         current = parent;
       }
@@ -16885,11 +18023,11 @@ var ProviderLoader = class _ProviderLoader {
   constructor(options) {
     this.logFn = options?.logFn || LOG.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,
@@ -16948,7 +18086,7 @@ var ProviderLoader = class _ProviderLoader {
       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}`);
@@ -16962,7 +18100,7 @@ var ProviderLoader = class _ProviderLoader {
   * 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.
@@ -16989,7 +18127,7 @@ var ProviderLoader = class _ProviderLoader {
   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)
@@ -17028,7 +18166,7 @@ var ProviderLoader = class _ProviderLoader {
     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;
@@ -17525,8 +18663,8 @@ var ProviderLoader = class _ProviderLoader {
               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;
             }
@@ -17541,8 +18679,8 @@ var ProviderLoader = class _ProviderLoader {
             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.`;
@@ -17559,8 +18697,8 @@ var ProviderLoader = class _ProviderLoader {
               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) {
@@ -17576,8 +18714,8 @@ var ProviderLoader = class _ProviderLoader {
         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;
         }
       }
     }
@@ -17609,14 +18747,14 @@ var ProviderLoader = class _ProviderLoader {
       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 cached = this.scriptsCache.get(dir);
     if (cached) return cached;
-    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)];
@@ -17658,7 +18796,7 @@ var ProviderLoader = class _ProviderLoader {
             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();
           }
         };
@@ -17713,7 +18851,7 @@ var ProviderLoader = class _ProviderLoader {
     }
     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 {
@@ -17730,7 +18868,7 @@ var ProviderLoader = class _ProviderLoader {
       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",
@@ -17748,7 +18886,7 @@ var ProviderLoader = class _ProviderLoader {
               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", () => {
@@ -17757,7 +18895,7 @@ var ProviderLoader = class _ProviderLoader {
             });
             req2.end();
           } else {
-            resolve12(res.headers.etag || res.headers["last-modified"] || "");
+            resolve15(res.headers.etag || res.headers["last-modified"] || "");
           }
         });
         req.on("error", reject);
@@ -17773,17 +18911,17 @@ var ProviderLoader = class _ProviderLoader {
         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 });
@@ -17821,7 +18959,7 @@ var ProviderLoader = class _ProviderLoader {
   downloadFile(url, 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"));
@@ -17841,7 +18979,7 @@ var ProviderLoader = class _ProviderLoader {
           res.pipe(ws);
           ws.on("finish", () => {
             ws.close();
-            resolve12();
+            resolve15();
           });
           ws.on("error", reject);
         });
@@ -17858,8 +18996,8 @@ var ProviderLoader = class _ProviderLoader {
   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 {
@@ -17870,7 +19008,7 @@ var ProviderLoader = class _ProviderLoader {
   /** .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,
@@ -17887,7 +19025,7 @@ var ProviderLoader = class _ProviderLoader {
     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 {
@@ -18115,17 +19253,17 @@ var ProviderLoader = class _ProviderLoader {
     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 {
               }
             }
@@ -18142,7 +19280,7 @@ var ProviderLoader = class _ProviderLoader {
    * (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)];
@@ -18156,7 +19294,7 @@ var ProviderLoader = class _ProviderLoader {
       for (const file of fs7.readdirSync(dir)) {
         if (!file.endsWith(".js")) continue;
         const scriptName = toCamel(file.replace(".js", ""));
-        const filePath = path14.join(dir, file);
+        const filePath = path17.join(dir, file);
         result[scriptName] = (...args) => {
           try {
             let content = fs7.readFileSync(filePath, "utf-8");
@@ -18216,7 +19354,7 @@ var ProviderLoader = class _ProviderLoader {
       }
       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);
@@ -18237,7 +19375,7 @@ var ProviderLoader = class _ProviderLoader {
             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)];
@@ -18263,7 +19401,7 @@ var ProviderLoader = class _ProviderLoader {
           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));
         }
       }
     };
@@ -18298,9 +19436,9 @@ var ProviderLoader = class _ProviderLoader {
     }
   }
   compareVersions(a, b) {
-    const normalize3 = (v) => v.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
-    const pa = normalize3(a);
-    const pb = normalize3(b);
+    const normalize4 = (v) => v.split(/[-_+]/)[0].split(".").map((x) => parseInt(x, 10) || 0);
+    const pa = normalize4(a);
+    const pb = normalize4(b);
     for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
       const va = pa[i] || 0;
       const vb = pb[i] || 0;
@@ -18420,17 +19558,17 @@ async function findFreePort(ports) {
   throw new Error("No free port found");
 }
 function checkPortFree(port) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve15) => {
     const server = net.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) => {
@@ -18439,16 +19577,16 @@ async function isCdpActive(port) {
       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);
     });
   });
 }
@@ -18588,8 +19726,8 @@ function detectCurrentWorkspace(ideId) {
       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"
         );
@@ -18767,9 +19905,9 @@ init_logger();
 
 // src/logging/command-log.ts
 import * as fs8 from "fs";
-import * as path16 from "path";
+import * as path19 from "path";
 import * as os16 from "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 {
@@ -18807,13 +19945,13 @@ function getDateStr2() {
   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();
   }
 }
@@ -18827,7 +19965,7 @@ function cleanOldFiles() {
       const dateMatch = file.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs8.unlinkSync(path16.join(LOG_DIR2, file));
+          fs8.unlinkSync(path19.join(LOG_DIR2, file));
         } catch {
         }
       }
@@ -18837,8 +19975,8 @@ function cleanOldFiles() {
 }
 function checkSize() {
   try {
-    const stat = fs8.statSync(currentFile);
-    if (stat.size > MAX_FILE_SIZE) {
+    const stat2 = fs8.statSync(currentFile);
+    if (stat2.size > MAX_FILE_SIZE) {
       const backup = currentFile.replace(".jsonl", ".1.jsonl");
       try {
         fs8.unlinkSync(backup);
@@ -19124,12 +20262,18 @@ function buildStatusSnapshot(options) {
   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) {
@@ -19223,13 +20367,13 @@ import { execFileSync as execFileSync2 } from "child_process";
 import { spawn as spawn3 } from "child_process";
 import * as fs9 from "fs";
 import * as os18 from "os";
-import * as path17 from "path";
+import * as path20 from "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}
@@ -19240,14 +20384,14 @@ function appendUpgradeLog(message) {
   }
 }
 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) };
       }
@@ -19255,7 +20399,7 @@ function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platfo
     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) };
     }
@@ -19272,13 +20416,13 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   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"));
@@ -19289,7 +20433,7 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
       }
     } catch {
     }
-    const parentDir = path17.dirname(currentDir);
+    const parentDir = path20.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -19297,13 +20441,13 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   }
 }
 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;
 }
@@ -19411,14 +20555,14 @@ async function waitForPidExit(pid, timeoutMs) {
   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);
@@ -19435,7 +20579,7 @@ function stopSessionHostProcesses(appName) {
   }
 }
 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 {
@@ -19446,7 +20590,7 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   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") {
@@ -19454,25 +20598,25 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   }
   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)}`);
     }
   }
 }
@@ -19522,7 +20666,7 @@ async function runDaemonUpgradeHelper(payload) {
     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");
   }
@@ -20916,7 +22060,7 @@ var ProviderStreamAdapter = class {
     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);
@@ -20938,7 +22082,7 @@ var ProviderStreamAdapter = class {
     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;
   }
@@ -21089,7 +22233,7 @@ var ProviderStreamAdapter = class {
       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;
@@ -21950,11 +23094,11 @@ init_chat_message_normalization();
 
 // src/providers/version-archive.ts
 import * as fs11 from "fs";
-import * as path18 from "path";
+import * as path21 from "path";
 import * as os19 from "os";
 import { execSync as execSync5 } from "child_process";
 import { platform as platform8 } from "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 = {};
@@ -22001,7 +23145,7 @@ var VersionArchive = class {
   }
   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 {
     }
@@ -22058,7 +23202,7 @@ function checkPathExists2(paths) {
   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;
@@ -22068,7 +23212,7 @@ function checkPathExists2(paths) {
 }
 function getMacAppVersion(appPath) {
   if (platform8() !== "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;
@@ -22094,7 +23238,7 @@ async function detectAllVersions(loader, archive) {
       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);
@@ -22135,7 +23279,7 @@ async function detectAllVersions(loader, archive) {
 // src/daemon/dev-server.ts
 import * as http2 from "http";
 import * as fs15 from "fs";
-import * as path22 from "path";
+import * as path25 from "path";
 init_config();
 
 // src/daemon/scaffold-template.ts
@@ -22487,7 +23631,7 @@ init_logger();
 // src/daemon/dev-cdp-handlers.ts
 init_logger();
 import * as fs12 from "fs";
-import * as path19 from "path";
+import * as path22 from "path";
 async function handleCdpEvaluate(ctx, req, res) {
   const body = await ctx.readBody(req);
   const { expression, timeout, ideType } = body;
@@ -22665,17 +23809,17 @@ async function handleScriptHints(ctx, type, _req, res) {
     return;
   }
   let scriptsPath = "";
-  const directScripts = path19.join(dir, "scripts.js");
+  const directScripts = path22.join(dir, "scripts.js");
   if (fs12.existsSync(directScripts)) {
     scriptsPath = directScripts;
   } else {
-    const scriptsDir = path19.join(dir, "scripts");
+    const scriptsDir = path22.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(path22.join(scriptsDir, d)).isDirectory();
       }).sort().reverse();
       for (const ver of versions) {
-        const p = path19.join(scriptsDir, ver, "scripts.js");
+        const p = path22.join(scriptsDir, ver, "scripts.js");
         if (fs12.existsSync(p)) {
           scriptsPath = p;
           break;
@@ -23504,7 +24648,7 @@ async function handleDomContext(ctx, type, req, res) {
 
 // src/daemon/dev-cli-debug.ts
 import * as fs13 from "fs";
-import * as path20 from "path";
+import * as path23 from "path";
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || `fixture-${Date.now()}`;
@@ -23514,11 +24658,11 @@ function getCliFixtureDir(ctx, type) {
   if (!providerDir) {
     throw new Error(`Provider directory not found for '${type}'`);
   }
-  return path20.join(providerDir, "fixtures");
+  return path23.join(providerDir, "fixtures");
 }
 function readCliFixture(ctx, type, name) {
   const fixtureDir = getCliFixtureDir(ctx, type);
-  const filePath = path20.join(fixtureDir, `${name}.json`);
+  const filePath = path23.join(fixtureDir, `${name}.json`);
   if (!fs13.existsSync(filePath)) {
     throw new Error(`Fixture not found: ${filePath}`);
   }
@@ -23687,7 +24831,7 @@ function getCliTargetBundle(ctx, type, instanceId) {
   return { target, instance, adapter };
 }
 function sleep(ms) {
-  return new Promise((resolve12) => setTimeout(resolve12, ms));
+  return new Promise((resolve15) => setTimeout(resolve15, ms));
 }
 async function waitForCliReady(ctx, type, instanceId, timeoutMs) {
   const startedAt = Date.now();
@@ -23985,7 +25129,7 @@ async function runCliAutoImplVerification(ctx, type, verification) {
     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,
@@ -24285,7 +25429,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       },
       notes: typeof body?.notes === "string" ? body.notes : void 0
     };
-    const filePath = path20.join(fixtureDir, `${name}.json`);
+    const filePath = path23.join(fixtureDir, `${name}.json`);
     fs13.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
     ctx.json(res, 200, {
       saved: true,
@@ -24309,7 +25453,7 @@ async function handleCliFixtureList(ctx, type, _req, res) {
       return;
     }
     const fixtures = fs13.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
-      const fullPath = path20.join(fixtureDir, file);
+      const fullPath = path23.join(fixtureDir, file);
       try {
         const raw = JSON.parse(fs13.readFileSync(fullPath, "utf-8"));
         return {
@@ -24445,7 +25589,7 @@ async function handleCliRaw(ctx, req, res) {
 
 // src/daemon/dev-auto-implement.ts
 import * as fs14 from "fs";
-import * as path21 from "path";
+import * as path24 from "path";
 import * as os20 from "os";
 function getAutoImplPid(ctx) {
   const pid = ctx.autoImplProcess?.pid;
@@ -24495,22 +25639,22 @@ function getLatestScriptVersionDir(scriptsDir) {
   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, b) => b.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);
@@ -24518,11 +25662,11 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
     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}` };
   }
@@ -24533,13 +25677,13 @@ function loadAutoImplReferenceScripts(ctx, referenceType) {
   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 file of fs14.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs14.readFileSync(path21.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs14.readFileSync(path24.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -24647,9 +25791,9 @@ async function handleAutoImplement(ctx, type, req, res) {
     });
     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);
@@ -25081,7 +26225,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     setMode: "set_mode.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).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}\``);
@@ -25092,7 +26236,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     for (const file of fs14.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs14.readFileSync(path21.join(latestScriptsDir, file), "utf-8");
+          const content = fs14.readFileSync(path24.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -25109,7 +26253,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs14.readFileSync(path21.join(latestScriptsDir, file), "utf-8");
+          const content = fs14.readFileSync(path24.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -25150,10 +26294,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
       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 {
     }
@@ -25390,7 +26534,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     parseApproval: "parse_approval.js"
   };
   const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).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}\``);
@@ -25402,7 +26546,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs14.readFileSync(path21.join(latestScriptsDir, file), "utf-8");
+        const content = fs14.readFileSync(path24.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -25418,7 +26562,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       lines.push("");
       for (const file of refFiles) {
         try {
-          const content = fs14.readFileSync(path21.join(latestScriptsDir, file), "utf-8");
+          const content = fs14.readFileSync(path24.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -25451,10 +26595,10 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       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 {
     }
@@ -25901,8 +27045,8 @@ var DevServer = class _DevServer {
   }
   getEndpointList() {
     return this.routes.map((r) => {
-      const path23 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-      return `${r.method.padEnd(5)} ${path23}`;
+      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) {
@@ -25933,15 +27077,15 @@ var DevServer = class _DevServer {
         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);
         }
@@ -26023,20 +27167,20 @@ var DevServer = class _DevServer {
       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);
         });
       });
@@ -26190,12 +27334,12 @@ var DevServer = class _DevServer {
   // ─── DevConsole SPA ───
   getConsoleDistDir() {
     const candidates = [
-      path22.resolve(__dirname, "../../web-devconsole/dist"),
-      path22.resolve(__dirname, "../../../web-devconsole/dist"),
-      path22.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(path22.join(dir, "index.html"))) return dir;
+      if (fs15.existsSync(path25.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -26205,7 +27349,7 @@ var DevServer = class _DevServer {
       this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
       return;
     }
-    const htmlPath = path22.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" });
@@ -26230,15 +27374,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: "Not found" });
       return;
     }
-    const safePath = path22.normalize(pathname).replace(/^\.\.\//, "");
-    const filePath = path22.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 = path22.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);
@@ -26351,10 +27495,10 @@ var DevServer = class _DevServer {
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
-            scan(path22.join(d, entry.name), rel);
+            scan(path25.join(d, entry.name), rel);
           } else {
-            const stat = fs15.statSync(path22.join(d, entry.name));
-            files.push({ path: rel, size: stat.size, type: "file" });
+            const stat2 = fs15.statSync(path25.join(d, entry.name));
+            files.push({ path: rel, size: stat2.size, type: "file" });
           }
         }
       } catch {
@@ -26376,7 +27520,7 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path22.resolve(dir, path22.normalize(filePath));
+    const fullPath = path25.resolve(dir, path25.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
@@ -26401,14 +27545,14 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path22.resolve(dir, path22.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(path22.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();
@@ -26425,7 +27569,7 @@ var DevServer = class _DevServer {
       return;
     }
     for (const name of ["scripts.js", "provider.json"]) {
-      const p = path22.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 });
@@ -26446,8 +27590,8 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs15.existsSync(path22.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-    const targetPath = path22.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");
@@ -26539,14 +27683,14 @@ var DevServer = class _DevServer {
       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;
@@ -26594,7 +27738,7 @@ var DevServer = class _DevServer {
     }
     let targetDir;
     targetDir = this.providerLoader.getUserProviderDir(category, type);
-    const jsonPath = path22.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;
@@ -26606,8 +27750,8 @@ var DevServer = class _DevServer {
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
-          const fullPath = path22.join(targetDir, relPath);
-          fs15.mkdirSync(path22.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);
         }
@@ -26660,22 +27804,22 @@ var DevServer = class _DevServer {
     if (!fs15.existsSync(scriptsDir)) return null;
     const versions = fs15.readdirSync(scriptsDir).filter((d) => {
       try {
-        return fs15.statSync(path22.join(scriptsDir, d)).isDirectory();
+        return fs15.statSync(path25.join(scriptsDir, d)).isDirectory();
       } catch {
         return false;
       }
     }).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" }));
     if (versions.length === 0) return null;
-    return path22.join(scriptsDir, versions[0]);
+    return path25.join(scriptsDir, versions[0]);
   }
   resolveAutoImplWritableProviderDir(category, type, requestedDir) {
-    const canonicalUserDir = path22.resolve(this.providerLoader.getUserProviderDir(category, type));
-    const desiredDir = requestedDir ? path22.resolve(requestedDir) : canonicalUserDir;
-    const upstreamRoot = path22.resolve(this.providerLoader.getUpstreamDir());
-    if (desiredDir === upstreamRoot || desiredDir.startsWith(`${upstreamRoot}${path22.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 (path22.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);
@@ -26683,11 +27827,11 @@ var DevServer = class _DevServer {
       return { dir: null, reason: `Provider source directory not found for '${type}'` };
     }
     if (!fs15.existsSync(desiredDir)) {
-      fs15.mkdirSync(path22.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 = path22.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}` };
     }
@@ -26723,7 +27867,7 @@ var DevServer = class _DevServer {
       setMode: "set_mode.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path22.join(providerDir, "scripts");
+    const scriptsDir = path25.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -26734,7 +27878,7 @@ var DevServer = class _DevServer {
       for (const file of fs15.readdirSync(latestScriptsDir)) {
         if (file.endsWith(".js") && targetFileNames.has(file)) {
           try {
-            const content = fs15.readFileSync(path22.join(latestScriptsDir, file), "utf-8");
+            const content = fs15.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -26751,7 +27895,7 @@ var DevServer = class _DevServer {
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs15.readFileSync(path22.join(latestScriptsDir, file), "utf-8");
+            const content = fs15.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -26792,10 +27936,10 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path22.join(providerDir, "../../docs");
+    const docsDir = path25.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path22.join(docsDir, name);
+        const p = path25.join(docsDir, name);
         if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
       } catch {
       }
@@ -26969,7 +28113,7 @@ var DevServer = class _DevServer {
       parseApproval: "parse_approval.js"
     };
     const targetFileNames = new Set(functions.map((fn) => funcToFile[fn]).filter(Boolean));
-    const scriptsDir = path22.join(providerDir, "scripts");
+    const scriptsDir = path25.join(providerDir, "scripts");
     const latestScriptsDir = this.getLatestScriptVersionDir(scriptsDir);
     if (latestScriptsDir) {
       lines.push(`Scripts version directory: \`${latestScriptsDir}\``);
@@ -26981,7 +28125,7 @@ var DevServer = class _DevServer {
         if (!file.endsWith(".js")) continue;
         if (!targetFileNames.has(file)) continue;
         try {
-          const content = fs15.readFileSync(path22.join(latestScriptsDir, file), "utf-8");
+          const content = fs15.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -26997,7 +28141,7 @@ var DevServer = class _DevServer {
         lines.push("");
         for (const file of refFiles) {
           try {
-            const content = fs15.readFileSync(path22.join(latestScriptsDir, file), "utf-8");
+            const content = fs15.readFileSync(path25.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -27030,10 +28174,10 @@ var DevServer = class _DevServer {
         lines.push("");
       }
     }
-    const docsDir = path22.join(providerDir, "../../docs");
+    const docsDir = path25.join(providerDir, "../../docs");
     const loadGuide = (name) => {
       try {
-        const p = path22.join(docsDir, name);
+        const p = path25.join(docsDir, name);
         if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
       } catch {
       }
@@ -27216,14 +28360,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({});
         }
       });
     });
@@ -27738,7 +28882,7 @@ async function waitForReady(endpoint, timeoutMs = STARTUP_TIMEOUT_MS) {
   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`);
 }
@@ -27916,10 +29060,10 @@ async function installExtension(ide, extension) {
         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`;
           exec2(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
-            resolve12({
+            resolve15({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
               success: !error,
@@ -27932,11 +29076,11 @@ async function installExtension(ide, extension) {
     } catch (e) {
     }
   }
-  return new Promise((resolve12) => {
+  return new Promise((resolve15) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
     exec2(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
-        resolve12({
+        resolve15({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: false,
@@ -27944,7 +29088,7 @@ async function installExtension(ide, extension) {
           error: stderr || error.message
         });
       } else {
-        resolve12({
+        resolve15({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: true,
@@ -28273,6 +29417,7 @@ export {
   DEFAULT_CDP_SCAN_INTERVAL_MS,
   DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS,
   DEFAULT_DAEMON_PORT,
+  DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS,
   DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   DEFAULT_SESSION_HOST_APP_NAME,
   DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
@@ -28291,8 +29436,12 @@ export {
   DaemonCommandRouter,
   DaemonStatusReporter,
   DevServer,
+  GitCommandError,
+  GitWorkspaceMonitor,
   IdeProviderInstance,
+  InMemoryGitSnapshotStore,
   LOG,
+  MIN_GIT_WORKSPACE_POLL_INTERVAL_MS,
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   NodePtyTransportFactory,
@@ -28320,9 +29469,14 @@ export {
   buildUserChatMessage,
   classifyHotChatSessionsForSubscriptionFlush,
   clearDebugTrace,
+  compareGitSnapshots,
   configureDebugTraceStore,
   connectCdpManager,
   createDebugTraceStore,
+  createDefaultGitCommandServices,
+  createGitCompactSummary,
+  createGitSnapshotStore,
+  createGitWorkspaceMonitor,
   createInteractionId,
   detectAllVersions,
   detectCLIs,
@@ -28337,6 +29491,9 @@ export {
   getCurrentDaemonLogPath,
   getDaemonLogDir,
   getDebugRuntimeConfig,
+  getGitDiffSummary,
+  getGitFileDiff,
+  getGitRepoStatus,
   getHostMemorySnapshot,
   getLogLevel,
   getNpmExecOptions,
@@ -28348,6 +29505,7 @@ export {
   getSessionHostRecoveryLabel,
   getSessionHostSurfaceKind,
   getWorkspaceState,
+  handleGitCommand,
   hasCdpManager,
   hashSignatureParts,
   initDaemonComponents,
@@ -28356,9 +29514,11 @@ export {
   isBuiltinChatMessageKind,
   isCdpConnected,
   isExtensionInstalled,
+  isGitCommandName,
   isIdeRunning,
   isManagedStatusWaiting,
   isManagedStatusWorking,
+  isPathInside,
   isSessionHostLiveRuntime,
   isSessionHostRecoverySnapshot,
   isSetupComplete,
@@ -28376,10 +29536,13 @@ export {
   normalizeChatMessageKind,
   normalizeChatMessages,
   normalizeChatTailActiveModal,
+  normalizeGitOutput,
+  normalizeGitWorkspaceSubscriptionParams,
   normalizeInputEnvelope,
   normalizeManagedStatus,
   normalizeMessageParts,
   normalizeSessionModalFields,
+  parsePorcelainV2Status,
   parseProviderSourceConfigUpdate,
   partitionSessionHostDiagnosticsSessions,
   partitionSessionHostRecords,
@@ -28395,9 +29558,11 @@ export {
   resolveChatMessageKind,
   resolveCurrentGlobalInstallSurface,
   resolveDebugRuntimeConfig,
+  resolveGitRepository,
   resolveSessionHostAppName,
   resolveSessionHostAppNameResolution,
   runAsyncBatch,
+  runGit,
   saveConfig,
   saveState,
   setDebugRuntimeConfig,
@@ -28408,6 +29573,7 @@ export {
   shutdownDaemonComponents,
   spawnDetachedDaemonUpgradeHelper,
   startDaemonDevSupport,
+  summarizeGitStatus,
   updateConfig,
   upsertSavedProviderSession
 };