@xbzbing/dsh-git-panel 1.5.3 → 1.5.4

package/lib/host/index.js

@@ -46,1678 +46,25 @@ var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-
-// src/host/index.ts
+var _version_dec, _suggest_dec, _query_dec, _run_dec, _snapshot_dec, _a, _init;
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import Schema from "@deepseek-ai/schemastery";
-import { readFile as readFile3, readdir, realpath, rm, stat } from "node:fs/promises";
-
-// src/host/git.ts
-import { readFile } from "node:fs/promises";
-function createGitRunner(subprocess, timeoutMs, maxBytes) {
-  const spillMaxBytes = maxBytes * 16;
-  return {
-    async run(argv, opts) {
-      const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), timeoutMs);
-      try {
-        const signal = opts.signal === void 0 ? controller.signal : AbortSignal.any([controller.signal, opts.signal]);
-        const handle = subprocess.spawn({
-          argv,
-          cwd: opts.cwd,
-          // Never let a network command (fetch/pull) block on an interactive
-          // credential or host-key prompt: with stdin ignored git would hang
-          // until the timeout. GIT_TERMINAL_PROMPT=0 makes it fail fast instead,
-          // and is harmless for the non-network commands that share this runner.
-          env: { GIT_TERMINAL_PROMPT: "0" },
-          stdio: {
-            stdin: opts.stdinData === void 0 ? "ignore" : { data: opts.stdinData },
-            stdout: { collect: { maxBytes, spill: { maxBytes: spillMaxBytes } } },
-            stderr: { collect: { maxBytes, spill: { maxBytes: spillMaxBytes } } }
-          },
-          graceMs: 200,
-          signal
-        });
-        let outcome;
-        try {
-          outcome = await handle.done;
-        } catch (error) {
-          const cancelled2 = opts.signal?.aborted === true && !controller.signal.aborted;
-          if (controller.signal.aborted || opts.signal?.aborted === true) {
-            return { exitCode: null, stdout: "", stderr: "", timedOut: !cancelled2, cancelled: cancelled2, stdoutLossy: false };
-          }
-          throw error;
-        }
-        const stdout = handle.collected.stdout?.readFrom(0);
-        const stderr = handle.collected.stderr?.readFrom(0);
-        const resolved = await resolveStdout(stdout);
-        const cancelled = opts.signal?.aborted === true && !controller.signal.aborted;
-        return {
-          exitCode: outcome.exitCode,
-          stdout: resolved.text,
-          stderr: stderr?.text ?? "",
-          timedOut: controller.signal.aborted,
-          cancelled,
-          stdoutLossy: resolved.lossy
-        };
-      } finally {
-        clearTimeout(timer);
-      }
-    }
-  };
-}
-async function resolveStdout(read) {
-  if (read === void 0) return { text: "", lossy: false };
-  if (!read.lossy || read.spillPath === void 0) return { text: read.text, lossy: read.lossy };
-  try {
-    return { text: await readFile(read.spillPath, "utf8"), lossy: false };
-  } catch {
-    return { text: read.text, lossy: true };
-  }
-}
-
-// src/host/core.ts
-import { dirname, join } from "node:path";
-
-// src/host/parser.ts
-function commitFromFields(parts) {
-  const hash = parts[0];
-  if (parts.length < 5 || hash === void 0 || hash === "") return null;
-  return {
-    hash,
-    shortHash: parts[1] ?? "",
-    subject: parts[2] ?? "",
-    author: parts[3] ?? "",
-    dateIso: parts[4] ?? ""
-  };
-}
-function statusOf(code) {
-  switch (code) {
-    case "A":
-      return "added";
-    case "M":
-      return "modified";
-    case "D":
-      return "deleted";
-    case "R":
-      return "renamed";
-    case "C":
-      return "added";
-    case "T":
-      return "typechange";
-    case "U":
-      return "conflicted";
-    case "?":
-      return "untracked";
-    default:
-      return "modified";
-  }
-}
-function parseStatus(stdout) {
-  const out = [];
-  const records = stdout.split("\0");
-  for (let i = 0; i < records.length; i++) {
-    const rec = records[i];
-    if (rec === void 0 || rec.length < 3) continue;
-    const x = rec[0];
-    const y = rec[1];
-    let path = rec.slice(3);
-    if (x === "R" || x === "C" || y === "R" || y === "C") {
-      i++;
-    }
-    const isDirectory = path.endsWith("/");
-    if (isDirectory) path = path.replace(/\/+$/, "");
-    if (x === "?" && y === "?") {
-      out.push({ path, status: "untracked", staged: false, isDirectory });
-      continue;
-    }
-    if (x === "U" || y === "U" || x === "A" && y === "A" || x === "D" && y === "D") {
-      out.push({ path, status: "conflicted", staged: false, isDirectory });
-      continue;
-    }
-    if (x !== " " && x !== "?") {
-      out.push({ path, status: statusOf(x), staged: true, isDirectory });
-    }
-    if (y !== " " && y !== "?") {
-      out.push({ path, status: statusOf(y), staged: false, isDirectory });
-    }
-  }
-  return out;
-}
-function parseGraphLog(stdout) {
-  const out = [];
-  for (const record of stdout.split("")) {
-    const rec = record.replace(/^\n+/, "");
-    if (rec.trim() === "") continue;
-    const parts = rec.split("");
-    if (parts.length < 7) continue;
-    const [hash, shortHash, parentsRaw, author, dateIso, decoration] = parts;
-    const subject = parts.slice(6).join("");
-    const parents = (parentsRaw ?? "").trim() === "" ? [] : parentsRaw.trim().split(/\s+/);
-    out.push({
-      hash: hash ?? "",
-      shortHash: shortHash ?? "",
-      subject,
-      author: author ?? "",
-      dateIso: dateIso ?? "",
-      parents,
-      refs: parseRefs(decoration ?? "")
-    });
-  }
-  return out;
-}
-function parseRefs(decoration) {
-  const refs = [];
-  for (const raw of decoration.split(",")) {
-    let token = raw.trim();
-    if (token === "") continue;
-    let head = false;
-    if (token.startsWith("HEAD -> ")) {
-      head = true;
-      token = token.slice("HEAD -> ".length).trim();
-    } else if (token === "HEAD") {
-      continue;
-    }
-    if (token.startsWith("tag: ")) {
-      refs.push({ kind: "tag", name: token.slice("tag: ".length).trim().replace(/^refs\/tags\//, ""), head: false });
-    } else if (token.startsWith("refs/tags/")) {
-      refs.push({ kind: "tag", name: token.slice("refs/tags/".length), head: false });
-    } else if (token.startsWith("refs/remotes/")) {
-      refs.push({ kind: "remote", name: token.slice("refs/remotes/".length), head });
-    } else if (token.startsWith("refs/heads/")) {
-      refs.push({ kind: "branch", name: token.slice("refs/heads/".length), head });
-    } else if (head) {
-      refs.push({ kind: "branch", name: token, head });
-    } else if (token.startsWith("origin/") || token.includes("/")) {
-      refs.push({ kind: "remote", name: token, head });
-    } else {
-      refs.push({ kind: "branch", name: token, head });
-    }
-  }
-  return refs;
-}
-function parseBranches(stdout) {
-  const out = [];
-  for (const line of stdout.split("\n")) {
-    if (line.trim() === "") continue;
-    const [name, shortHash = "", track = ""] = line.split("\0");
-    if (name === void 0 || name === "") continue;
-    const branch = {
-      name,
-      shortHash: shortHash === "" ? null : shortHash
-    };
-    const ahead = /ahead (\d+)/.exec(track);
-    const behind = /behind (\d+)/.exec(track);
-    if (ahead) branch.ahead = Number(ahead[1]);
-    if (behind) branch.behind = Number(behind[1]);
-    out.push(branch);
-  }
-  return out;
-}
-function parseTags(stdout) {
-  const out = [];
-  for (const line of stdout.split("\n")) {
-    if (line.trim() === "") continue;
-    const [name, shortHash = ""] = line.split("\0");
-    if (name) out.push({ name, shortHash: shortHash === "" ? null : shortHash });
-  }
-  return out;
-}
-function parseStashList(stdout) {
-  const out = [];
-  for (const record of stdout.split("\0")) {
-    if (record.trim() === "") continue;
-    const [selector = "", sha = "", subject = "", relTime = ""] = record.split("");
-    const idxMatch = /stash@\{(\d+)\}/.exec(selector);
-    if (idxMatch === null) continue;
-    const index = Number(idxMatch[1]);
-    let branch = null;
-    let message = subject;
-    const m = /^(?:WIP on|On) (.+?): (.*)$/s.exec(subject);
-    if (m !== null) {
-      branch = m[1] === "(no branch)" ? null : m[1] ?? null;
-      message = m[2] ?? "";
-    }
-    out.push({ index, sha: sha.trim(), message: message.trim(), branch, relTime: relTime.trim() });
-  }
-  return out;
-}
-function parseNameStatus(stdout) {
-  const out = [];
-  const tokens = stdout.split("\0");
-  let i = 0;
-  while (i < tokens.length) {
-    const tok = tokens[i];
-    if (tok === void 0 || tok === "") {
-      i += 1;
-      continue;
-    }
-    const code = tok[0];
-    if (code === void 0 || !/[AMDRCTU]/.test(code)) break;
-    if (code === "R" || code === "C") {
-      const newPath = tokens[i + 2];
-      if (newPath === void 0) break;
-      out.push({ path: newPath, status: statusOf(code) });
-      i += 3;
-    } else {
-      const path = tokens[i + 1];
-      if (path === void 0) break;
-      if (path !== "") out.push({ path, status: statusOf(code) });
-      i += 2;
-    }
-  }
-  return out;
-}
-function sumNumstat(stdout) {
-  let insertions = 0;
-  let deletions = 0;
-  for (const line of stdout.split("\n")) {
-    if (line.trim() === "") continue;
-    const parts = line.split("	");
-    if (parts.length < 2) continue;
-    const add = Number(parts[0]);
-    const del = Number(parts[1]);
-    if (Number.isFinite(add)) insertions += add;
-    if (Number.isFinite(del)) deletions += del;
-  }
-  return { insertions, deletions };
-}
-
-// src/host/remote.ts
-function classifyHost(host) {
-  const h = host.toLowerCase();
-  if (h === "github.com" || h.endsWith(".github.com")) return "github";
-  if (h === "gitlab.com" || h.endsWith(".gitlab.com")) return "gitlab";
-  if (h === "gitee.com" || h.endsWith(".gitee.com")) return "gitee";
-  if (h === "bitbucket.org" || h.endsWith(".bitbucket.org")) return "bitbucket";
-  return "other";
-}
-function normalizePath(path) {
-  return path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
-}
-function splitHostPath(raw) {
-  const url = raw.trim();
-  if (url === "") return null;
-  const scp = url.match(/^(?:[^@/]+@)?([^/:]+):(.+)$/);
-  if (scp !== null && !/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
-    const host = scp[1];
-    const path = normalizePath(scp[2]);
-    return host !== "" && path !== "" ? { host, path } : null;
-  }
-  const scheme = url.match(/^[a-z][a-z0-9+.-]*:\/\/([^/]+)\/(.+)$/i);
-  if (scheme !== null) {
-    let authority = scheme[1];
-    const at = authority.lastIndexOf("@");
-    if (at >= 0) authority = authority.slice(at + 1);
-    const host = authority.replace(/:\d+$/, "");
-    const path = normalizePath(scheme[2]);
-    return host !== "" && path !== "" ? { host, path } : null;
-  }
-  return null;
-}
-function parseRemote(name, url) {
-  const parsed = splitHostPath(url);
-  if (parsed === null) {
-    return { name, url, webUrl: null, host: null, hostKind: "other" };
-  }
-  return {
-    name,
-    url,
-    webUrl: `https://${parsed.host}/${parsed.path}`,
-    host: parsed.host,
-    hostKind: classifyHost(parsed.host)
-  };
-}
-
-// src/host/validate.ts
-import { isAbsolute, normalize } from "node:path";
-function isSafePath(path) {
-  if (path === "" || isAbsolute(path)) return false;
-  const norm = normalize(path);
-  if (norm === ".." || norm.startsWith("../") || norm.startsWith("..\\")) return false;
-  return true;
-}
-var REV_META = /[\x00-\x20\x7f~^:?*[\\]/;
-function isSafeRev(input) {
-  if (input === "" || input.startsWith("-")) return false;
-  if (REV_META.test(input)) return false;
-  if (input.includes("..") || input.includes("@{")) return false;
-  return true;
-}
-function isSafeBranchName(name) {
-  return isSafeRev(name) && !name.startsWith("/");
-}
-function isSafeRemoteName(name) {
-  return /^[A-Za-z0-9._][A-Za-z0-9._/-]*$/.test(name) && name.length <= 128;
-}
-
-// src/host/core.ts
-var DEFAULT_CONFIG = {
-  timeoutMs: 8e3,
-  maxBytes: 4 * 1024 * 1024,
-  maxChanges: 1e3,
-  refreshIntervalMs: 3e4,
-  showInputPill: true,
-  defaultDiffView: "unified",
-  graphStyle: "parallel",
-  suggestEnabled: true,
-  suggestMaxBytes: 64 * 1024,
-  suggestMaxOutputTokens: 200,
-  suggestTimeoutMs: 15e3
-};
-function normalizeConfig(raw) {
-  const c = raw ?? {};
-  const num = (v, d) => typeof v === "number" && Number.isFinite(v) && v >= 1 ? Math.floor(v) : d;
-  const hasProvider = typeof c.suggestProvider === "string" && c.suggestProvider !== "";
-  const hasModel = typeof c.suggestModel === "string" && c.suggestModel !== "";
-  const route = hasProvider && hasModel ? { suggestProvider: c.suggestProvider, suggestModel: c.suggestModel } : {};
-  return {
-    timeoutMs: num(c.timeoutMs, DEFAULT_CONFIG.timeoutMs),
-    maxBytes: num(c.maxBytes, DEFAULT_CONFIG.maxBytes),
-    maxChanges: num(c.maxChanges, DEFAULT_CONFIG.maxChanges),
-    refreshIntervalMs: num(c.refreshIntervalMs, DEFAULT_CONFIG.refreshIntervalMs),
-    showInputPill: readBool(c.showInputPill, DEFAULT_CONFIG.showInputPill),
-    defaultDiffView: readDiffView(c.defaultDiffView, DEFAULT_CONFIG.defaultDiffView),
-    graphStyle: readGraphStyle(c.graphStyle, DEFAULT_CONFIG.graphStyle),
-    suggestEnabled: readBool(c.suggestEnabled, DEFAULT_CONFIG.suggestEnabled),
-    suggestMaxBytes: num(c.suggestMaxBytes, DEFAULT_CONFIG.suggestMaxBytes),
-    suggestMaxOutputTokens: num(c.suggestMaxOutputTokens, DEFAULT_CONFIG.suggestMaxOutputTokens),
-    suggestTimeoutMs: num(c.suggestTimeoutMs, DEFAULT_CONFIG.suggestTimeoutMs),
-    ...route
-  };
-}
-function unwrapVolatile(value) {
-  return value !== null && typeof value === "object" && "get" in value && typeof value.get === "function" ? value.get() : value;
-}
-function readDiffView(value, fallback) {
-  const raw = unwrapVolatile(value);
-  return raw === "unified" || raw === "split" ? raw : fallback;
-}
-function readGraphStyle(value, fallback) {
-  const raw = unwrapVolatile(value);
-  return raw === "parallel" || raw === "compact" ? raw : fallback;
-}
-function readBool(value, fallback) {
-  const raw = unwrapVolatile(value);
-  return typeof raw === "boolean" ? raw : fallback;
-}
-var NEG_CACHE_MS = 15e3;
-function parsePrimaryRemote(stdout) {
-  const fetchUrls = /* @__PURE__ */ new Map();
-  const order = [];
-  for (const line of stdout.split("\n")) {
-    const m = line.match(/^(\S+)\t(\S+)\s+\(fetch\)$/);
-    if (m === null) continue;
-    const name2 = m[1];
-    if (!fetchUrls.has(name2)) {
-      fetchUrls.set(name2, m[2]);
-      order.push(name2);
-    }
-  }
-  if (order.length === 0) return null;
-  const name = fetchUrls.has("origin") ? "origin" : order[0];
-  return parseRemote(name, fetchUrls.get(name));
-}
-var STATS_FANOUT_LIMIT = 200;
-async function resolveBrowseRoot(deps, sessionId) {
-  const ws = await resolveWorkspace(deps, sessionId);
-  if (ws.ok) return { ok: true, root: ws.root, isGitRepo: true };
-  const err = ws.failure.error;
-  if ((err.code === "not-a-git-repo" || err.code === "git-unavailable") && "cwd" in err && err.cwd !== void 0 && err.cwd !== "") {
-    try {
-      return { ok: true, root: await deps.fs.realpath(err.cwd), isGitRepo: false };
-    } catch {
-      return { ok: false, error: { code: "git-error" } };
-    }
-  }
-  return { ok: false, error: mapWorkspaceFailure(ws.failure) };
-}
-async function resolveWorkspace(deps, sessionId) {
-  let cwd = deps.sessions.liveCwd(sessionId);
-  if (cwd === void 0 || cwd === "") {
-    const meta = await deps.sessions.persistedMeta(sessionId);
-    cwd = meta?.cwd;
-  }
-  if (cwd === void 0 || cwd === "") {
-    return { ok: false, failure: { ok: false, error: { code: "cwd-unavailable", sessionId } } };
-  }
-  const cached = deps.rootCache?.get(cwd);
-  if (cached !== void 0) return { ok: true, root: cached };
-  const negAt = deps.rootNegCache?.get(cwd);
-  if (negAt !== void 0) {
-    if (Date.now() < negAt) return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
-    deps.rootNegCache?.delete(cwd);
-  }
-  const top = await runCommand(deps.run, ["git", "rev-parse", "--show-toplevel"], cwd, "toplevel", deps.signal);
-  if ("failure" in top) {
-    return { ok: false, failure: { ok: false, error: { ...mapRunFailure(top.failure), cwd } } };
-  }
-  if (top.run.cancelled) return { ok: false, failure: { ok: false, error: { code: "cancelled" } } };
-  if (top.run.timedOut) return { ok: false, failure: { ok: false, error: { code: "timeout" } } };
-  if (top.run.exitCode !== 0) {
-    deps.rootNegCache?.set(cwd, Date.now() + NEG_CACHE_MS);
-    return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
-  }
-  const raw = top.run.stdout.trim();
-  if (raw === "") {
-    deps.rootNegCache?.set(cwd, Date.now() + NEG_CACHE_MS);
-    return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
-  }
-  let root = raw;
-  try {
-    root = await deps.fs.realpath(raw);
-  } catch {
-  }
-  deps.rootCache?.set(cwd, root);
-  return { ok: true, root };
-}
-async function runCommand(runner, argv, cwd, _label, signal, stdinData) {
-  try {
-    const run = await runner.run(argv, { cwd, ...signal ? { signal } : {}, ...stdinData !== void 0 ? { stdinData } : {} });
-    return { run };
-  } catch (error) {
-    return { failure: error };
-  }
-}
-function mapRunFailure(failure) {
-  const message = failure instanceof Error ? failure.message : String(failure);
-  return { code: "git-unavailable", detail: message };
-}
-async function detectGitRepo(deps, cwd) {
-  let dir;
-  try {
-    dir = await deps.fs.realpath(cwd);
-  } catch {
-    dir = cwd;
-  }
-  for (let i = 0; i < 100; i++) {
-    try {
-      await deps.fs.stat(join(dir, ".git"));
-      return true;
-    } catch {
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return false;
-}
-function mapWorkspaceFailure(failure) {
-  const error = failure.error;
-  const message = "detail" in error ? error.detail : void 0;
-  return { code: error.code, ...message !== void 0 ? { message } : {} };
-}
-async function snapshotForSession(deps, config, sessionId) {
-  const workspace = await resolveWorkspace(deps, sessionId);
-  if (!workspace.ok) {
-    const failure = workspace.failure;
-    if (failure.error.code === "not-a-git-repo") {
-      return { ok: false, error: { ...failure.error, showInputPill: config.showInputPill } };
-    }
-    if (failure.error.code === "git-unavailable") {
-      const cwd = failure.error.cwd;
-      const isGitRepo = cwd !== void 0 && cwd !== "" ? await detectGitRepo(deps, cwd) : false;
-      return { ok: false, error: { ...failure.error, isGitRepo } };
-    }
-    return failure;
-  }
-  const root = workspace.root;
-  const [branchRes, headRes, statusRes, aheadBehindRes, lastCommitRes, worktreeNumRes, stagedNumRes, remoteRes] = await Promise.all([
-    runCommand(deps.run, ["git", "symbolic-ref", "--quiet", "--short", "HEAD"], root, "branch", deps.signal),
-    runCommand(deps.run, ["git", "rev-parse", "--short", "HEAD"], root, "head", deps.signal),
-    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z"], root, "status", deps.signal),
-    runCommand(deps.run, ["git", "rev-list", "--count", "--left-right", "@{upstream}...HEAD"], root, "aheadBehind", deps.signal),
-    runCommand(deps.run, ["git", "log", "-1", "--format=%H%x1f%h%x1f%s%x1f%an%x1f%aI"], root, "lastCommit", deps.signal),
-    runCommand(deps.run, ["git", "diff", "--numstat"], root, "numstat-worktree", deps.signal),
-    runCommand(deps.run, ["git", "diff", "--numstat", "--cached"], root, "numstat-staged", deps.signal),
-    // `git remote -v` lists every remote's fetch/push URL; parsed into the
-    // primary remote (origin, else the first) for the left-column status bar.
-    runCommand(deps.run, ["git", "remote", "-v"], root, "remote", deps.signal)
-  ]);
-  const branch = "run" in branchRes && branchRes.run.exitCode === 0 ? branchRes.run.stdout.trim() || null : null;
-  const unborn = "run" in headRes && headRes.run.exitCode !== 0;
-  const head = "run" in headRes && headRes.run.exitCode === 0 ? headRes.run.stdout.trim() || null : null;
-  let allChanges = [];
-  let statusLossy = false;
-  if ("run" in statusRes && !statusRes.run.timedOut && statusRes.run.exitCode === 0) {
-    allChanges = parseStatus(statusRes.run.stdout);
-    statusLossy = statusRes.run.stdoutLossy;
-  }
-  const truncated = allChanges.length > config.maxChanges || statusLossy;
-  const changes = allChanges.length > config.maxChanges ? allChanges.slice(0, config.maxChanges) : allChanges;
-  let staged = 0;
-  let modified = 0;
-  let untracked = 0;
-  for (const c of allChanges) {
-    if (c.status === "untracked") untracked++;
-    else if (c.staged) staged++;
-    else modified++;
-  }
-  let ahead = 0;
-  let behind = 0;
-  const hasUpstream = "run" in aheadBehindRes && aheadBehindRes.run.exitCode === 0;
-  if (hasUpstream && "run" in aheadBehindRes) {
-    const parts = aheadBehindRes.run.stdout.trim().split(/\s+/);
-    behind = Number(parts[0]) || 0;
-    ahead = Number(parts[1]) || 0;
-  }
-  const remote = "run" in remoteRes && remoteRes.run.exitCode === 0 ? parsePrimaryRemote(remoteRes.run.stdout) : null;
-  let lastCommit = null;
-  if ("run" in lastCommitRes && lastCommitRes.run.exitCode === 0) {
-    lastCommit = commitFromFields(lastCommitRes.run.stdout.trim().split(""));
-  }
-  const wt = "run" in worktreeNumRes && worktreeNumRes.run.exitCode === 0 ? sumNumstat(worktreeNumRes.run.stdout) : { insertions: 0, deletions: 0 };
-  const stg = "run" in stagedNumRes && stagedNumRes.run.exitCode === 0 ? sumNumstat(stagedNumRes.run.stdout) : { insertions: 0, deletions: 0 };
-  const statsDetailed = allChanges.length <= STATS_FANOUT_LIMIT;
-  let untrackedInsertions = 0;
-  if (statsDetailed) {
-    const untrackedPaths = allChanges.filter((c) => c.status === "untracked" && !c.isDirectory).map((c) => c.path);
-    const safeUntracked = untrackedPaths.filter(isSafePath);
-    if (safeUntracked.length > 0) {
-      const perFile = await Promise.all(
-        safeUntracked.map((p) => runCommand(deps.run, ["git", "diff", "--numstat", "--no-index", "--", "/dev/null", p], root, "numstat-untracked", deps.signal))
-      );
-      for (const r of perFile) if ("run" in r) untrackedInsertions += sumNumstat(r.run.stdout).insertions;
-    }
-  }
-  const lastChangeAt = statsDetailed ? await maxChangeMtime(deps, root, allChanges) : null;
-  const distinct = new Set(allChanges.map((c) => c.path));
-  const stats = {
-    fileCount: distinct.size,
-    staged,
-    modified,
-    untracked,
-    insertions: wt.insertions + stg.insertions + untrackedInsertions,
-    deletions: wt.deletions + stg.deletions,
-    lastChangeAt,
-    headCommittedAt: lastCommit?.dateIso ?? null,
-    partial: !statsDetailed
-  };
-  const snapshot = {
-    root,
-    branch,
-    head,
-    unborn,
-    dirty: allChanges.length > 0,
-    staged,
-    modified,
-    untracked,
-    ahead,
-    behind,
-    hasUpstream,
-    remote,
-    lastCommit,
-    changes,
-    stats,
-    truncated,
-    refreshIntervalMs: config.refreshIntervalMs,
-    showInputPill: config.showInputPill,
-    defaultDiffView: config.defaultDiffView,
-    graphStyle: config.graphStyle,
-    suggestEnabled: config.suggestEnabled,
-    checkedAt: Date.now()
-  };
-  return { ok: true, value: snapshot };
-}
-async function maxChangeMtime(deps, root, changes, cap = 200) {
-  let max = null;
-  const slice = changes.slice(0, cap);
-  await Promise.all(slice.map(async (c) => {
-    if (c.isDirectory) return;
-    try {
-      const info = await deps.fs.stat(join(root, c.path));
-      if (Number.isFinite(info.mtimeMs)) {
-        max = max === null ? info.mtimeMs : Math.max(max, info.mtimeMs);
-      }
-    } catch {
-    }
-  }));
-  return max;
-}
-
-// src/host/actions.ts
-import { join as join2, sep } from "node:path";
-function withPaths(prefixes, paths) {
-  if (paths.length === 0) return { error: "invalid-path", message: "no paths given" };
-  for (const path of paths) {
-    if (!isSafePath(path)) return { error: "invalid-path", message: `unsafe path: ${path}` };
-  }
-  return { argv: prefixes.map((prefix) => [...prefix, ...paths]) };
-}
-function planAction(action, unborn) {
-  switch (action.kind) {
-    case "stage":
-      return withPaths([["git", "add", "--"]], action.paths);
-    case "stage-all":
-      return { argv: [["git", "add", "-A"]] };
-    case "unstage":
-      return unborn ? withPaths([["git", "rm", "--cached", "-r", "--"]], action.paths) : withPaths([["git", "restore", "--staged", "--"]], action.paths);
-    case "unstage-all":
-      return unborn ? { argv: [["git", "rm", "--cached", "-r", "--", "."]] } : { argv: [["git", "restore", "--staged", "--", "."]] };
-    case "discard":
-      return withPaths([["git", "restore", "--"]], action.paths);
-    case "commit": {
-      const message = action.message.trim();
-      const amend = action.amend === true;
-      if (message === "" && !amend) return { error: "empty-message" };
-      const amendFlag = amend ? ["--amend"] : [];
-      const msgArgs = message === "" ? ["--no-edit"] : ["-m", message];
-      if (action.paths === void 0 || action.paths.length === 0) {
-        return { argv: [["git", "commit", ...amendFlag, ...msgArgs]] };
-      }
-      const staged = withPaths([["git", "add", "--"]], action.paths);
-      if ("error" in staged) return staged;
-      const commitCmd = ["git", "commit", ...amendFlag, ...msgArgs, "--", ...action.paths];
-      return { argv: [...staged.argv, commitCmd] };
-    }
-    case "branch-checkout":
-      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe branch name: ${action.name}` };
-      return { argv: [["git", "checkout", "--end-of-options", action.name]] };
-    case "fetch":
-      return { argv: [["git", "fetch", "--all", "--prune"]] };
-    case "pull-ff":
-      return { argv: [["git", "pull", "--ff-only"]] };
-    case "push":
-      return { argv: [["git", "push"]] };
-    case "publish":
-      if (!isSafeRemoteName(action.remote)) return { error: "invalid-name", message: `unsafe remote name: ${action.remote}` };
-      return { argv: [["git", "push", "-u", action.remote, "HEAD"]] };
-    case "tag-create": {
-      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe tag name: ${action.name}` };
-      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
-      const msg = action.message?.trim() ?? "";
-      const flags = msg === "" ? [] : ["-a", "-m", msg];
-      return { argv: [["git", "tag", ...flags, "--end-of-options", action.name, action.commit]] };
-    }
-    case "tag-delete":
-      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe tag name: ${action.name}` };
-      return { argv: [["git", "tag", "-d", "--end-of-options", action.name]] };
-    case "stash-push": {
-      const msg = action.message?.trim() ?? "";
-      return { argv: [msg === "" ? ["git", "stash", "push"] : ["git", "stash", "push", "-m", msg]] };
-    }
-    case "stash-apply":
-    case "stash-pop":
-    case "stash-drop": {
-      if (!Number.isInteger(action.index) || action.index < 0) {
-        return { error: "invalid-index", message: `invalid stash index: ${action.index}` };
-      }
-      const verb = action.kind === "stash-apply" ? "apply" : action.kind === "stash-pop" ? "pop" : "drop";
-      return { argv: [["git", "stash", verb, "--end-of-options", `stash@{${action.index}}`]] };
-    }
-    case "revert": {
-      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
-      return { argv: [["git", "revert", "--no-edit", "--end-of-options", action.commit]] };
-    }
-    case "reset": {
-      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
-      if (action.mode !== "soft" && action.mode !== "mixed" && action.mode !== "hard") {
-        return { error: "invalid-name", message: `invalid reset mode: ${String(action.mode)}` };
-      }
-      return { argv: [["git", "reset", `--${action.mode}`, "--end-of-options", action.commit]] };
-    }
-  }
-}
-function isIndexBusy(outcome) {
-  if (!("run" in outcome) || outcome.run.exitCode === 0) return false;
-  return /index\.lock|Unable to create.*index|another git process/i.test(outcome.run.stderr + outcome.run.stdout);
-}
-function scrubCredentials(text) {
-  return text.replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s]*@/gi, "$1");
-}
-function classifyActionFailure(stdout, stderr, exitCode) {
-  const combined = stderr + stdout;
-  const err = scrubCredentials(stderr.trim());
-  if (/CONFLICT|Merge conflict|needs merge|could not restore untracked/i.test(combined)) {
-    return { code: "conflict", message: err || "merge conflict" };
-  }
-  if (/index\.lock|Unable to create.*index|another git process/i.test(combined)) {
-    return { code: "index-busy", message: err };
-  }
-  if (/nothing to commit|no changes added/i.test(combined)) {
-    return { code: "git-error", message: err || "nothing to commit" };
-  }
-  if (/No such ref|not a valid reference|is not a stash|no tag|tag .* not found|unknown revision|bad revision|Could not parse object|ambiguous argument/i.test(combined)) {
-    return { code: "not-found", message: err || "not found" };
-  }
-  if (/Authentication failed|could not read (Username|Password)|terminal prompts disabled|Permission denied \(publickey\)|Could not read from remote repository/i.test(combined)) {
-    return { code: "auth-failed", message: err || "authentication failed" };
-  }
-  if (/\[rejected\]|Updates were rejected|failed to push some refs|fetch first|tip of your current branch is behind/i.test(combined)) {
-    return { code: "push-rejected", message: err || "push rejected (remote has new commits; fetch first)" };
-  }
-  if (/Not possible to fast-forward|cannot fast-forward|not a fast-forward|Need to specify how to reconcile divergent branches/i.test(combined)) {
-    return { code: "not-ff", message: err || "cannot fast-forward (branches diverged)" };
-  }
-  if (/would be overwritten by (checkout|merge)|local changes|overwritten by merge|Your local changes/i.test(stderr)) {
-    return { code: "local-changes-block", message: err };
-  }
-  if (/is a merge but no -m|mainline parent/i.test(combined)) {
-    return { code: "revert-merge", message: err || "cannot revert a merge commit from the panel" };
-  }
-  return { code: "git-error", message: err || `git exited ${exitCode}` };
-}
-async function runAction(deps, config, request) {
-  const workspace = await resolveWorkspace(deps, request.sessionId);
-  if (!workspace.ok) return { ok: false, error: mapWorkspaceFailure(workspace.failure) };
-  const root = workspace.root;
-  const headProbe = await runCommand(deps.run, ["git", "rev-parse", "--verify", "HEAD"], root, "head-probe", deps.signal);
-  const unborn = !("run" in headProbe) || headProbe.run.exitCode !== 0;
-  const act = request.action;
-  if (act.kind === "stash-apply" || act.kind === "stash-pop" || act.kind === "stash-drop") {
-    if (!Number.isInteger(act.index) || act.index < 0) {
-      return { ok: false, error: { code: "invalid-index", message: `invalid stash index: ${act.index}` } };
-    }
-    const probe = await runCommand(deps.run, ["git", "rev-parse", "--verify", "--quiet", "--end-of-options", `stash@{${act.index}}`], root, "stash-verify", deps.signal);
-    const sha = "run" in probe && probe.run.exitCode === 0 ? probe.run.stdout.trim() : "";
-    if (sha === "" || sha !== act.sha) {
-      return { ok: false, error: { code: "not-found", message: "stash entry changed; refresh and retry" } };
-    }
-  }
-  if (request.action.kind === "discard") {
-    const removed = await discardUntracked(deps, config, root, request.sessionId, request.action.paths);
-    if (removed !== null) {
-      if (!removed.ok) return removed.result;
-      if (removed.remainingTracked.length === 0) {
-        const snapshot2 = await snapshotForSession(deps, config, request.sessionId);
-        if (!snapshot2.ok) return { ok: false, error: { code: "git-error", message: "snapshot after action failed" } };
-        return { ok: true, snapshot: snapshot2.value, output: "" };
-      }
-      request = { ...request, action: { kind: "discard", paths: removed.remainingTracked } };
-    }
-  }
-  const plan = planAction(request.action, unborn);
-  if ("error" in plan) return { ok: false, error: { code: plan.error, ...plan.message ? { message: plan.message } : {} } };
-  let lastOutput = "";
-  for (let step = 0; step < plan.argv.length; step += 1) {
-    const argv = plan.argv[step];
-    let outcome = await runCommand(deps.run, argv, root, "action", deps.signal);
-    if (isIndexBusy(outcome)) {
-      await new Promise((resolve) => setTimeout(resolve, 150));
-      outcome = await runCommand(deps.run, argv, root, "action-retry", deps.signal);
-    }
-    const where = plan.argv.length > 1 ? ` (step ${step + 1}/${plan.argv.length}: ${argv.join(" ")})` : "";
-    if ("failure" in outcome) {
-      const message = outcome.failure instanceof Error ? outcome.failure.message : String(outcome.failure);
-      return { ok: false, error: { code: "git-unavailable", message: message + where } };
-    }
-    if (outcome.run.cancelled) return { ok: false, error: { code: "cancelled" } };
-    if (outcome.run.timedOut) return { ok: false, error: { code: "timeout" } };
-    lastOutput = outcome.run.stdout || outcome.run.stderr;
-    if (outcome.run.exitCode !== 0) {
-      const failure = classifyActionFailure(outcome.run.stdout, outcome.run.stderr, outcome.run.exitCode ?? -1);
-      if (request.action.kind === "revert" && failure.code === "conflict") {
-        let abort = await runCommand(deps.run, ["git", "revert", "--abort"], root, "revert-abort", deps.signal);
-        if (isIndexBusy(abort)) {
-          await new Promise((resolve) => setTimeout(resolve, 150));
-          abort = await runCommand(deps.run, ["git", "revert", "--abort"], root, "revert-abort-retry", deps.signal);
-        }
-        const aborted = "run" in abort && abort.run.exitCode === 0;
-        return aborted ? { ok: false, error: { code: "revert-conflict", message: failure.message + where } } : { ok: false, error: { code: "revert-stuck", message: failure.message + where } };
-      }
-      return { ok: false, error: { code: failure.code, message: failure.message + where } };
-    }
-    if (request.action.kind === "stash-push" && /No local changes to save/i.test(outcome.run.stdout + outcome.run.stderr)) {
-      return { ok: false, error: { code: "git-error", message: (outcome.run.stdout.trim() || "No local changes to save") + where } };
-    }
-  }
-  const snapshot = await snapshotForSession(deps, config, request.sessionId);
-  if (!snapshot.ok) {
-    return { ok: false, error: { code: "git-error", message: "snapshot after action failed" } };
-  }
-  return { ok: true, snapshot: snapshot.value, output: lastOutput.trim() };
-}
-async function discardUntracked(deps, config, root, sessionId, paths) {
-  const snap = await snapshotForSession(deps, config, sessionId);
-  if (!snap.ok) return null;
-  const untrackedSet = new Set(snap.value.changes.filter((c) => c.status === "untracked").map((c) => c.path));
-  const untracked = paths.filter((p) => untrackedSet.has(p));
-  if (untracked.length === 0) return null;
-  const tracked = paths.filter((p) => !untrackedSet.has(p));
-  let rootReal;
-  try {
-    rootReal = await deps.fs.realpath(root);
-  } catch {
-    return { ok: false, result: { ok: false, error: { code: "git-error", message: "repository root unavailable" } } };
-  }
-  for (const path of untracked) {
-    if (!isSafePath(path)) return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `unsafe path: ${path}` } } };
-    const target = join2(root, path);
-    let targetReal;
-    try {
-      targetReal = await deps.fs.realpath(target);
-    } catch {
-      continue;
-    }
-    if (targetReal !== rootReal && !targetReal.startsWith(rootReal + sep)) {
-      return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `path escapes repository: ${path}` } } };
-    }
-    await deps.fs.remove(target).catch(() => {
-    });
-  }
-  return { ok: true, remainingTracked: tracked };
-}
-
-// src/host/queries.ts
-import { join as join3, sep as sep2 } from "node:path";
-
-// src/host/types.ts
-var IMAGE_MIME = {
-  png: "image/png",
-  jpg: "image/jpeg",
-  jpeg: "image/jpeg",
-  gif: "image/gif",
-  webp: "image/webp",
-  avif: "image/avif",
-  bmp: "image/bmp",
-  svg: "image/svg+xml",
-  ico: "image/x-icon",
-  tif: "image/tiff",
-  tiff: "image/tiff"
-};
-function imageMimeFor(path) {
-  const dot = path.lastIndexOf(".");
-  if (dot < 0) return null;
-  return IMAGE_MIME[path.slice(dot + 1).toLowerCase()] ?? null;
-}
-
-// src/host/queries.ts
-var GRAPH_FORMAT = "--format=%H%x1f%h%x1f%P%x1f%an%x1f%aI%x1f%D%x1f%s%x1e";
-var VISIBLE_REFS = ["--branches", "--remotes", "--tags", "HEAD"];
-function isHexLike(text) {
-  return /^[0-9a-fA-F]{7,40}$/.test(text.trim());
-}
-async function runQuery(deps, config, request) {
-  const q = request.query;
-  if (q.kind === "dir-list" || q.kind === "file-content") {
-    const browse = await resolveBrowseRoot(deps, request.sessionId);
-    if (!browse.ok) return { ok: false, error: browse.error };
-    try {
-      return q.kind === "dir-list" ? await queryDirList(deps, browse.root, q, browse.isGitRepo) : await queryFileContent(deps, config, browse.root, q);
-    } catch (error) {
-      return { ok: false, error: { code: "git-error", message: error instanceof Error ? error.message : String(error) } };
-    }
-  }
-  const workspace = await resolveWorkspace(deps, request.sessionId);
-  if (!workspace.ok) return { ok: false, error: mapWorkspaceFailure(workspace.failure) };
-  const root = workspace.root;
-  try {
-    switch (q.kind) {
-      case "history":
-        return await queryHistory(deps, root, q);
-      case "diff":
-        return await queryDiff(deps, root, q);
-      case "file-lines":
-        return await queryFileLines(deps, root, q);
-      case "image-diff":
-        return await queryImageDiff(deps, config, root, q);
-      case "show":
-        return await queryShow(deps, root, q.ref);
-      case "branches":
-        return await queryBranches(deps, root);
-      case "tags":
-        return await queryTags(deps, root);
-      case "stash-list":
-        return await queryStashList(deps, root);
-      case "authors":
-        return await queryAuthors(deps, root);
-      case "last-commit-message":
-        return await queryLastCommitMessage(deps, root);
-      case "worktree-stats":
-        return await queryWorktreeStats(deps, config, request.sessionId);
-      case "pull-preview":
-        return await queryPullPreview(deps, root);
-      case "push-preview":
-        return await queryPushPreview(deps, root);
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { ok: false, error: { code: "git-error", message } };
-  }
-}
-async function queryHistory(deps, root, q) {
-  const limit = Number.isFinite(q.limit) ? Math.min(500, Math.max(1, Math.trunc(q.limit))) : 100;
-  const skip = Number.isFinite(q.skip) ? Math.max(0, Math.trunc(q.skip)) : 0;
-  const args = ["git", "log", "--topo-order", "--decorate=full", GRAPH_FORMAT, `--max-count=${limit}`, `--skip=${skip}`];
-  const search = q.search?.trim() ?? "";
-  const hexJump = search !== "" && isHexLike(search);
-  const countArgs = ["git", "rev-list", "--count"];
-  if (!hexJump) {
-    const filters = [];
-    if (search !== "") filters.push("-i", "-E", `--grep=${search}`);
-    if (q.author !== void 0 && q.author !== "") filters.push(`--author=${q.author}`);
-    if (q.since !== void 0 && q.since !== "") filters.push(`--since=${q.since}`);
-    if (q.ref !== void 0 && q.ref !== "") {
-      if (!isSafeRev(q.ref)) return { ok: false, error: { code: "invalid-name", message: `unsafe ref: ${q.ref}` } };
-      filters.push("--end-of-options", q.ref);
-    } else {
-      filters.push(...VISIBLE_REFS);
-    }
-    args.push(...filters);
-    countArgs.push(...filters);
-  } else {
-    args.push("--end-of-options", search);
-  }
-  const [res, countRes] = await Promise.all([
-    runCommand(deps.run, args, root, "history", deps.signal),
-    hexJump ? Promise.resolve(null) : runCommand(deps.run, countArgs, root, "history-count", deps.signal)
-  ]);
-  if (!("run" in res)) return { ok: false, error: { code: "git-unavailable" } };
-  if (res.run.cancelled) return { ok: false, error: { code: "cancelled" } };
-  if (res.run.timedOut) return { ok: false, error: { code: "timeout" } };
-  if (res.run.exitCode !== 0) {
-    const stderr = res.run.stderr.trim();
-    if (hexJump || /unknown revision|bad revision|does not have any commits|ambiguous argument/i.test(stderr)) {
-      return { ok: true, value: { kind: "history", commits: [], total: 0 } };
-    }
-    return { ok: false, error: { code: "git-error", message: stderr || `git exited ${res.run.exitCode}` } };
-  }
-  const commits = parseGraphLog(res.run.stdout);
-  let total = -1;
-  if (!hexJump && countRes !== null && "run" in countRes && countRes.run.exitCode === 0) {
-    const n = Number(countRes.run.stdout.trim());
-    if (Number.isFinite(n)) total = n;
-  }
-  return { ok: true, value: { kind: "history", commits, total } };
-}
-async function queryDiff(deps, root, q) {
-  if (!isSafePath(q.path)) return { ok: false, error: { code: "invalid-path", message: q.path } };
-  const ctx = q.context !== void 0 && Number.isFinite(q.context) ? Math.max(0, Math.min(1e5, Math.floor(q.context))) : 3;
-  const unified = `-U${ctx}`;
-  let args;
-  if (q.base === "staged") {
-    args = ["git", "diff", unified, "--cached", "--", q.path];
-  } else if (q.base === "commit") {
-    if (!isSafeRev(q.commit)) return { ok: false, error: { code: "invalid-name", message: `unsafe commit: ${q.commit}` } };
-    args = ["git", "show", unified, "--end-of-options", q.commit, "--", q.path];
-  } else {
-    args = ["git", "diff", unified, "--", q.path];
-  }
-  const res = await runCommand(deps.run, args, root, "diff", deps.signal);
-  if (!("run" in res)) return { ok: false, error: { code: "git-unavailable" } };
-  if (res.run.cancelled) return { ok: false, error: { code: "cancelled" } };
-  if (res.run.timedOut) return { ok: false, error: { code: "timeout" } };
-  let text = res.run.stdout;
-  if (q.base === "worktree" && text.trim() === "") {
-    const tracked = await runCommand(deps.run, ["git", "ls-files", "--error-unmatch", "--", q.path], root, "diff-tracked-probe", deps.signal);
-    const isUntracked = !("run" in tracked) || tracked.run.exitCode !== 0;
-    if (isUntracked) {
-      const noIndex = await runCommand(deps.run, ["git", "diff", unified, "--no-index", "--", "/dev/null", q.path], root, "diff-untracked", deps.signal);
-      if ("run" in noIndex) text = noIndex.run.stdout;
-    }
-  }
-  return { ok: true, value: { kind: "diff", path: q.path, text } };
-}
-async function queryFileLines(deps, root, q) {
-  if (!isSafePath(q.path)) return { ok: false, error: { code: "invalid-path", message: q.path } };
-  const start = Number.isFinite(q.start) ? Math.max(1, Math.floor(q.start)) : 1;
-  const end = Number.isFinite(q.end) ? Math.max(start, Math.floor(q.end)) : start;
-  let args;
-  if (q.base === "commit") {
-    if (!isSafeRev(q.commit)) return { ok: false, error: { code: "invalid-name", message: `unsafe commit: ${q.commit}` } };
-    args = ["git", "show", "--end-of-options", `${q.commit}:${q.path}`];
-  } else {
-    args = ["git", "show", `--end-of-options`, `:${q.path}`];
-    if (q.base === "worktree") args = ["git", "cat-file", "-p", `:${q.path}`];
-  }
-  const res = await runCommand(deps.run, args, root, "file-lines", deps.signal);
-  if (!("run" in res)) return { ok: false, error: { code: "git-unavailable" } };
-  if (res.run.cancelled) return { ok: false, error: { code: "cancelled" } };
-  if (res.run.timedOut) return { ok: false, error: { code: "timeout" } };
-  if (res.run.exitCode !== 0) {
-    if (q.base === "worktree") {
-      const wt = await readWorktreeText(deps, root, q.path);
-      if (wt !== null) return sliceLines(q.path, wt, start, end);
-    }
-    return { ok: false, error: { code: "git-error", message: res.run.stderr.trim() || "no such blob" } };
-  }
-  return sliceLines(q.path, res.run.stdout, start, end);
-}
-async function readWorktreeText(deps, root, path) {
-  try {
-    const file = join3(root, path);
-    const real = await deps.fs.realpath(file);
-    const rootReal = await deps.fs.realpath(root);
-    if (real !== rootReal && !real.startsWith(rootReal + sep2)) return null;
-    const buf = await deps.fs.readFile(file);
-    return buf.toString("utf8");
-  } catch {
-    return null;
-  }
-}
-function sliceLines(path, content, start, end) {
-  const all = content.split("\n");
-  if (all[all.length - 1] === "") all.pop();
-  const from = Math.min(start, all.length + 1);
-  const to = Math.min(end, all.length);
-  const lines = from <= to ? all.slice(from - 1, to) : [];
-  const eof = to >= all.length;
-  return { ok: true, value: { kind: "file-lines", path, start: from, lines, eof } };
-}
-async function queryImageDiff(deps, config, root, q) {
-  if (!isSafePath(q.path)) return { ok: false, error: { code: "invalid-path", message: q.path } };
-  if (q.base === "commit" && !isSafeRev(q.commit)) return { ok: false, error: { code: "invalid-name", message: `unsafe commit: ${q.commit}` } };
-  const mime = imageMimeFor(q.path);
-  if (mime === null) return { ok: true, value: { kind: "image-diff", path: q.path, mime } };
-  const oldSpec = q.base === "staged" ? `HEAD:${q.path}` : q.base === "commit" ? `${q.commit}^1:${q.path}` : `:${q.path}`;
-  const newSpec = q.base === "staged" ? `:${q.path}` : q.base === "commit" ? `${q.commit}:${q.path}` : null;
-  const [oldOid, newOid] = await Promise.all([
-    resolveOid(deps, root, oldSpec),
-    newSpec === null ? Promise.resolve(void 0) : resolveOid(deps, root, newSpec)
-  ]);
-  const cap = config.maxBytes;
-  const gitDir = oldOid !== void 0 || newOid !== void 0 ? await absoluteGitDir(deps, root) : "";
-  const [oldSide, newSide] = await Promise.all([
-    oldOid === void 0 ? Promise.resolve(void 0) : blobSide(deps, gitDir, oldOid, cap),
-    newOid !== void 0 ? blobSide(deps, gitDir, newOid, cap) : q.base === "worktree" ? worktreeSide(deps, root, q.path, cap) : Promise.resolve(void 0)
-  ]);
-  const sides = [oldSide, newSide];
-  if (sides.some((s) => s !== void 0 && "tooLarge" in s)) {
-    return { ok: true, value: { kind: "image-diff", path: q.path, mime, tooLarge: true } };
-  }
-  const old64 = sides[0] !== void 0 && !("tooLarge" in sides[0]) ? sides[0].data : void 0;
-  const new64 = sides[1] !== void 0 && !("tooLarge" in sides[1]) ? sides[1].data : void 0;
-  return {
-    ok: true,
-    value: {
-      kind: "image-diff",
-      path: q.path,
-      mime,
-      ...old64 !== void 0 ? { old: `data:${mime};base64,${old64}` } : {},
-      ...new64 !== void 0 ? { new: `data:${mime};base64,${new64}` } : {}
-    }
-  };
-}
-async function resolveOid(deps, root, spec) {
-  const res = await runCommand(deps.run, ["git", "rev-parse", "--verify", "--quiet", spec], root, "image-oid", deps.signal);
-  if (!("run" in res) || res.run.exitCode !== 0) return void 0;
-  const oid = res.run.stdout.trim();
-  return /^[0-9a-f]{40}$|^[0-9a-f]{64}$/.test(oid) ? oid : void 0;
-}
-async function absoluteGitDir(deps, root) {
-  const res = await runCommand(deps.run, ["git", "rev-parse", "--absolute-git-dir"], root, "git-dir", deps.signal);
-  if (!("run" in res) || res.run.exitCode !== 0) throw new Error("git dir unavailable");
-  return res.run.stdout.trim();
-}
-async function blobSide(deps, gitDir, oid, cap) {
-  const sizeRes = await runCommand(deps.run, ["git", "cat-file", "-s", oid], gitDir, "image-size", deps.signal);
-  if (!("run" in sizeRes) || sizeRes.run.exitCode !== 0) return void 0;
-  const size = Number(sizeRes.run.stdout.trim());
-  if (!Number.isFinite(size)) return void 0;
-  if (size > cap) return { tooLarge: true };
-  const nameRes = await runCommand(deps.run, ["git", "unpack-file", oid], gitDir, "image-unpack", deps.signal);
-  if (!("run" in nameRes) || nameRes.run.exitCode !== 0) return void 0;
-  const name = nameRes.run.stdout.trim();
-  if (!/^[A-Za-z0-9._-]+$/.test(name)) return void 0;
-  const file = join3(gitDir, name);
-  try {
-    const buf = await deps.fs.readFile(file);
-    if (buf.length > cap) return { tooLarge: true };
-    return { data: buf.toString("base64") };
-  } catch {
-    return void 0;
-  } finally {
-    await deps.fs.remove(file).catch(() => {
-    });
-  }
-}
-async function worktreeSide(deps, root, path, cap) {
-  try {
-    const file = join3(root, path);
-    const real = await deps.fs.realpath(file);
-    const rootReal = await deps.fs.realpath(root);
-    if (real !== rootReal && !real.startsWith(rootReal + sep2)) return void 0;
-    const info = await deps.fs.stat(file);
-    if (info.size > cap) return { tooLarge: true };
-    const buf = await deps.fs.readFile(file);
-    if (buf.length > cap) return { tooLarge: true };
-    return { data: buf.toString("base64") };
-  } catch {
-    return void 0;
-  }
-}
-var DIR_ENTRY_CAP = 2e3;
-async function queryDirList(deps, root, q, isGitRepo) {
-  const rel = q.path;
-  if (rel !== "" && !isSafePath(rel) || hasGitSegment(rel)) return { ok: false, error: { code: "invalid-path", message: rel } };
-  const dir = rel === "" ? root : join3(root, rel);
-  const inside = await isInsideRoot(deps, root, dir, true);
-  if (!inside) return { ok: false, error: { code: "invalid-path", message: rel } };
-  let raw;
-  try {
-    raw = await deps.fs.readdir(dir);
-  } catch (error) {
-    return { ok: false, error: { code: "git-error", message: error instanceof Error ? error.message : "readdir failed" } };
-  }
-  const filtered = raw.filter((e) => e.name !== ".git");
-  filtered.sort((a, b) => a.isDirectory !== b.isDirectory ? a.isDirectory ? -1 : 1 : a.name.localeCompare(b.name));
-  const truncated = filtered.length > DIR_ENTRY_CAP;
-  const slice = truncated ? filtered.slice(0, DIR_ENTRY_CAP) : filtered;
-  const ignored = isGitRepo ? await ignoredEntries(deps, root, rel, slice.map((e) => e.name)) : /* @__PURE__ */ new Set();
-  const entries = await Promise.all(slice.map(async (e) => {
-    const ignoreFlag = ignored.has(e.name) ? { ignored: true } : {};
-    if (e.isDirectory) return { name: e.name, dir: true, ...ignoreFlag };
-    let size;
-    try {
-      size = (await deps.fs.stat(join3(dir, e.name))).size;
-    } catch {
-      size = void 0;
-    }
-    return { name: e.name, dir: false, ...size !== void 0 ? { size } : {}, ...ignoreFlag };
-  }));
-  const path = rel === "" ? "" : rel.replace(/\/+$/, "");
-  return { ok: true, value: { kind: "dir-list", path, entries, truncated } };
-}
-async function ignoredEntries(deps, root, parent, names) {
-  const ignored = /* @__PURE__ */ new Set();
-  const paths = names.map((name) => parent === "" ? name : `${parent}/${name}`);
-  for (let index = 0; index < paths.length; ) {
-    const batch = [];
-    let bytes = 0;
-    while (index < paths.length && batch.length < 128) {
-      const candidate = paths[index];
-      const size = Buffer.byteLength(candidate) + 1;
-      if (batch.length > 0 && bytes + size > 32 * 1024) break;
-      batch.push(candidate);
-      bytes += size;
-      index++;
-    }
-    const result = await runCommand(deps.run, ["git", "check-ignore", "-z", "--stdin"], root, "dir-ignore", deps.signal, `${batch.join("\0")}\0`);
-    if ("failure" in result || result.run.timedOut || result.run.cancelled || result.run.stdoutLossy || ![0, 1].includes(result.run.exitCode ?? -1)) continue;
-    const matches = new Set(result.run.stdout.split("\0"));
-    for (const path of batch) if (matches.has(path)) ignored.add(parent === "" ? path : path.slice(parent.length + 1));
-  }
-  return ignored;
-}
-async function queryFileContent(deps, config, root, q) {
-  if (!isSafePath(q.path) || hasGitSegment(q.path)) return { ok: false, error: { code: "invalid-path", message: q.path } };
-  const file = join3(root, q.path);
-  const inside = await isInsideRoot(deps, root, file, true);
-  if (!inside) return { ok: false, error: { code: "invalid-path", message: q.path } };
-  const cap = config.maxBytes;
-  let info;
-  try {
-    info = await deps.fs.stat(file);
-  } catch (error) {
-    return { ok: false, error: { code: "git-error", message: error instanceof Error ? error.message : "stat failed" } };
-  }
-  const mime = imageMimeFor(q.path);
-  const tooLarge = { ok: true, value: { kind: "file-content", path: q.path, variant: mime !== null ? "image" : "text", tooLarge: true } };
-  if (info.size > cap) return tooLarge;
-  let buf;
-  try {
-    buf = await deps.fs.readFile(file);
-  } catch (error) {
-    return { ok: false, error: { code: "git-error", message: error instanceof Error ? error.message : "read failed" } };
-  }
-  if (buf.length > cap) return tooLarge;
-  if (mime !== null) {
-    return { ok: true, value: { kind: "file-content", path: q.path, variant: "image", dataUrl: `data:${mime};base64,${buf.toString("base64")}` } };
-  }
-  if (isBinaryBuffer(buf)) return { ok: true, value: { kind: "file-content", path: q.path, variant: "binary" } };
-  const content = buf.toString("utf8");
-  const lines = content === "" ? 0 : content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
-  return { ok: true, value: { kind: "file-content", path: q.path, variant: "text", content, lines } };
-}
-function hasGitSegment(path) {
-  return path.split(/[\\/]/).includes(".git");
-}
-async function isInsideRoot(deps, root, path, hideGit = false) {
-  try {
-    const real = await deps.fs.realpath(path);
-    const rootReal = await deps.fs.realpath(root);
-    if (real !== rootReal && !real.startsWith(rootReal + sep2)) return false;
-    return !hideGit || !hasGitSegment(real.slice(rootReal.length + 1));
-  } catch {
-    return false;
-  }
-}
-function isBinaryBuffer(buf) {
-  const n = Math.min(buf.length, 8192);
-  for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
-  return false;
-}
-async function queryShow(deps, root, ref) {
-  if (!isSafeRev(ref)) return { ok: false, error: { code: "invalid-name", message: `unsafe ref: ${ref}` } };
-  const metaFormat = "--format=%H%x1f%h%x1f%s%x1f%an%x1f%aI%x1f%b";
-  const [metaRes, statRes, numstatRes] = await Promise.all([
-    runCommand(deps.run, ["git", "show", "-s", metaFormat, "--end-of-options", ref], root, "show-meta", deps.signal),
-    runCommand(deps.run, ["git", "show", "--name-status", "-z", "--format=", "--end-of-options", ref], root, "show-stat", deps.signal),
-    runCommand(deps.run, ["git", "show", "--numstat", "--format=", "--end-of-options", ref], root, "show-numstat", deps.signal)
-  ]);
-  if (!("run" in metaRes)) return { ok: false, error: { code: "git-unavailable" } };
-  if (metaRes.run.cancelled) return { ok: false, error: { code: "cancelled" } };
-  if (metaRes.run.timedOut) return { ok: false, error: { code: "timeout" } };
-  if (metaRes.run.exitCode !== 0) {
-    return { ok: false, error: { code: "git-error", message: metaRes.run.stderr.trim() || "unknown ref" } };
-  }
-  const parts = metaRes.run.stdout.split("");
-  const commit = commitFromFields(parts);
-  const body = commit === null ? "" : parts.slice(5).join("").trim();
-  const stats = "run" in statRes && statRes.run.exitCode === 0 ? parseNameStatus(statRes.run.stdout) : [];
-  const { insertions, deletions } = stats.length > 0 && "run" in numstatRes && numstatRes.run.exitCode === 0 ? sumNumstat(numstatRes.run.stdout) : { insertions: 0, deletions: 0 };
-  return { ok: true, value: { kind: "show", ref, commit, body, stats, insertions, deletions } };
-}
-async function queryBranches(deps, root) {
-  const fmt = "--format=%(refname:short)%00%(objectname:short)%00%(upstream:track)";
-  const [localRes, remoteRes, currentRes, defaultRes] = await Promise.all([
-    runCommand(deps.run, ["git", "for-each-ref", "--sort=-committerdate", fmt, "refs/heads"], root, "branches-local", deps.signal),
-    runCommand(deps.run, ["git", "for-each-ref", "--sort=-committerdate", fmt, "refs/remotes"], root, "branches-remote", deps.signal),
-    runCommand(deps.run, ["git", "symbolic-ref", "--quiet", "--short", "HEAD"], root, "branch-current", deps.signal),
-    runCommand(deps.run, ["git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], root, "branch-default", deps.signal)
-  ]);
-  const local = "run" in localRes && localRes.run.exitCode === 0 ? parseBranches(localRes.run.stdout) : [];
-  const remote = "run" in remoteRes && remoteRes.run.exitCode === 0 ? parseBranches(remoteRes.run.stdout).filter((b) => !b.name.endsWith("/HEAD")) : [];
-  const current = "run" in currentRes && currentRes.run.exitCode === 0 ? currentRes.run.stdout.trim() || null : null;
-  let defaultBranch = null;
-  if ("run" in defaultRes && defaultRes.run.exitCode === 0) {
-    const raw = defaultRes.run.stdout.trim();
-    defaultBranch = raw.replace(/^origin\//, "") || null;
-  }
-  return { ok: true, value: { kind: "branches", current, defaultBranch, local, remote } };
-}
-async function queryTags(deps, root) {
-  const res = await runCommand(deps.run, ["git", "for-each-ref", "--sort=-creatordate", "--format=%(refname:short)%00%(objectname:short)", "refs/tags"], root, "tags", deps.signal);
-  const tags = "run" in res && res.run.exitCode === 0 ? parseTags(res.run.stdout) : [];
-  return { ok: true, value: { kind: "tags", tags } };
-}
-async function queryStashList(deps, root) {
-  const res = await runCommand(deps.run, ["git", "stash", "list", "-z", "--format=%gd%x1f%H%x1f%gs%x1f%cr"], root, "stash-list", deps.signal);
-  const entries = "run" in res && res.run.exitCode === 0 ? parseStashList(res.run.stdout) : [];
-  return { ok: true, value: { kind: "stash-list", entries } };
-}
-async function queryAuthors(deps, root) {
-  const res = await runCommand(deps.run, ["git", "log", ...VISIBLE_REFS, "--format=%an", "--max-count=2000"], root, "authors", deps.signal);
-  const authors = "run" in res && res.run.exitCode === 0 ? [...new Set(res.run.stdout.split("\n").map((s) => s.trim()).filter((s) => s !== ""))].sort((a, b) => a.localeCompare(b)) : [];
-  return { ok: true, value: { kind: "authors", authors } };
-}
-async function queryLastCommitMessage(deps, root) {
-  const res = await runCommand(deps.run, ["git", "log", "-1", "--format=%B"], root, "last-message", deps.signal);
-  const message = "run" in res && res.run.exitCode === 0 ? res.run.stdout.replace(/\n+$/, "") : "";
-  return { ok: true, value: { kind: "last-commit-message", message } };
-}
-async function queryPullPreview(deps, root) {
-  const empty = { kind: "pull-preview", hasUpstream: false, commits: 0, files: 0, insertions: 0, deletions: 0 };
-  const commitsRes = await runCommand(deps.run, ["git", "rev-list", "--count", "--end-of-options", "HEAD..@{upstream}"], root, "pull-preview-count", deps.signal);
-  if (!("run" in commitsRes) || commitsRes.run.exitCode !== 0) return { ok: true, value: empty };
-  const commits = Number(commitsRes.run.stdout.trim()) || 0;
-  const diffRes = await runCommand(deps.run, ["git", "diff", "--numstat", "--end-of-options", "HEAD", "@{upstream}"], root, "pull-preview-diff", deps.signal);
-  let files = 0;
-  let insertions = 0;
-  let deletions = 0;
-  if ("run" in diffRes && diffRes.run.exitCode === 0) {
-    files = diffRes.run.stdout.split("\n").filter((l) => l.trim() !== "").length;
-    const sum = sumNumstat(diffRes.run.stdout);
-    insertions = sum.insertions;
-    deletions = sum.deletions;
-  }
-  return { ok: true, value: { kind: "pull-preview", hasUpstream: true, commits, files, insertions, deletions } };
-}
-async function queryPushPreview(deps, root) {
-  const empty = { kind: "push-preview", hasUpstream: false, commits: 0, files: 0, insertions: 0, deletions: 0 };
-  const commitsRes = await runCommand(deps.run, ["git", "rev-list", "--count", "--end-of-options", "@{upstream}..HEAD"], root, "push-preview-count", deps.signal);
-  if (!("run" in commitsRes) || commitsRes.run.exitCode !== 0) return { ok: true, value: empty };
-  const commits = Number(commitsRes.run.stdout.trim()) || 0;
-  const diffRes = await runCommand(deps.run, ["git", "diff", "--numstat", "--end-of-options", "@{upstream}", "HEAD"], root, "push-preview-diff", deps.signal);
-  let files = 0;
-  let insertions = 0;
-  let deletions = 0;
-  if ("run" in diffRes && diffRes.run.exitCode === 0) {
-    files = diffRes.run.stdout.split("\n").filter((l) => l.trim() !== "").length;
-    const sum = sumNumstat(diffRes.run.stdout);
-    insertions = sum.insertions;
-    deletions = sum.deletions;
-  }
-  return { ok: true, value: { kind: "push-preview", hasUpstream: true, commits, files, insertions, deletions } };
-}
-async function queryWorktreeStats(deps, config, sessionId) {
-  const snapshot = await snapshotForSession(deps, config, sessionId);
-  if (!snapshot.ok) return { ok: false, error: { code: "git-error", message: "snapshot failed" } };
-  return { ok: true, value: { kind: "worktree-stats", stats: snapshot.value.stats } };
-}
-
-// src/host/suggest.ts
-var SYSTEM_PROMPT = [
-  "You are an expert at writing concise, accurate git commit messages.",
-  "Given a repository\u2019s uncommitted changes, write ONE commit message for them.",
-  "The message must start with a short imperative subject line (72 chars max), optionally followed by a blank line and a brief body explaining what changed and why.",
-  "Return only the message text: no quotes, code fences, prefixes, bullet lists, or explanations.",
-  "Match the language and style of the recent commit message when one is provided; otherwise write in English.",
-  "Focus on the most important change; do not mechanically list every file."
-].join("\n");
-var UNTRACKED_FILE_CAP = 16;
-function resolveRoute(config, agentDefaultModel) {
-  if (config.suggestProvider !== void 0 && config.suggestModel !== void 0) {
-    return { provider: config.suggestProvider, model: config.suggestModel };
-  }
-  return agentDefaultModel?.currentSelection();
-}
-function withDeadline(timeoutMs, parent) {
-  const controller = new AbortController();
-  let timedOut = false;
-  const timer = setTimeout(() => {
-    timedOut = true;
-    controller.abort();
-  }, timeoutMs);
-  const onAbort = () => {
-    controller.abort();
-  };
-  if (parent !== void 0) {
-    if (parent.aborted) {
-      controller.abort();
-    } else parent.addEventListener("abort", onAbort, { once: true });
-  }
-  return {
-    signal: controller.signal,
-    expired: () => timedOut,
-    dispose: () => {
-      clearTimeout(timer);
-      parent?.removeEventListener("abort", onAbort);
-    }
-  };
-}
-function truncateUtf8(text, maxBytes) {
-  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
-  let lo = 0;
-  let hi = text.length;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) lo = mid;
-    else hi = mid - 1;
-  }
-  return text.slice(0, lo);
-}
-function frameChanges(files, diff, recentCommitMessage) {
-  return JSON.stringify({
-    files,
-    diff,
-    recentCommitMessage: recentCommitMessage === "" ? null : recentCommitMessage
-  });
-}
-function normalizeMessage(raw) {
-  let m = raw.trim();
-  if (m.startsWith("```")) {
-    const firstNl = m.indexOf("\n");
-    if (firstNl !== -1) {
-      m = m.slice(firstNl + 1);
-      m = m.endsWith("```") ? m.slice(0, -3) : m;
-      m = m.trim();
-    }
-  }
-  return m.replace(/\n---+\s*$/, "").trim();
-}
-function finishError(reason) {
-  if (reason === void 0 || reason.kind === "stop") return void 0;
-  if (reason.kind === "max-tokens") return { ok: false, error: { code: "llm-output", message: "model output hit the token limit" } };
-  if (reason.kind === "tool-calls") return { ok: false, error: { code: "llm-output", message: "model requested a tool instead of writing a message" } };
-  const failure = "failure" in reason ? reason.failure : void 0;
-  return { ok: false, error: { code: "llm-error", message: failure?.message ?? `model stream finished abnormally (${reason.kind})` } };
-}
-async function collectDiff(deps, root, hasHead, pathArgs) {
-  const cmds = hasHead ? [["git", "diff", "HEAD", ...pathArgs]] : [["git", "diff", "--cached", ...pathArgs], ["git", "diff", ...pathArgs]];
-  const runs = await Promise.all(cmds.map((argv) => runCommand(deps.run, argv, root, "suggest-diff", deps.signal)));
-  let diff = "";
-  for (const res of runs) {
-    if ("failure" in res) return { ok: false, error: { code: "git-unavailable", message: "diff failed" } };
-    if (res.run.cancelled) return { ok: false, error: { code: "cancelled" } };
-    if (res.run.timedOut) return { ok: false, error: { code: "timeout" } };
-    if (res.run.exitCode !== 0) {
-      return { ok: false, error: { code: "git-error", message: res.run.stderr.trim() || "git diff failed" } };
-    }
-    diff += res.run.stdout;
-  }
-  return diff;
-}
-async function appendUntracked(deps, root, files, diff, budget) {
-  let text = diff;
-  let truncated = false;
-  const candidates = files.filter((c) => c.status === "untracked" && !c.isDirectory && isSafePath(c.path));
-  for (const c of candidates.slice(0, UNTRACKED_FILE_CAP)) {
-    const remaining = budget - Buffer.byteLength(text, "utf8");
-    if (remaining <= 0) {
-      truncated = true;
-      break;
-    }
-    const res = await runCommand(deps.run, ["git", "diff", "--no-index", "--", "/dev/null", c.path], root, "suggest-untracked", deps.signal);
-    if ("failure" in res || res.run.cancelled || res.run.timedOut) continue;
-    const chunk = res.run.stdout;
-    if (chunk === "") continue;
-    if (Buffer.byteLength(chunk, "utf8") > remaining) {
-      text += truncateUtf8(chunk, remaining) + "\n... [diff truncated]";
-      truncated = true;
-      break;
-    }
-    text += chunk;
-  }
-  return { diff: text, truncated };
-}
-async function runSuggest(deps, config, request) {
-  if (!config.suggestEnabled) {
-    return { ok: false, error: { code: "suggest-disabled", message: "AI suggest is turned off in the plugin config" } };
-  }
-  const workspace = await resolveWorkspace(deps, request.sessionId);
-  if (!workspace.ok) return { ok: false, error: mapWorkspaceFailure(workspace.failure) };
-  const root = workspace.root;
-  const paths = request.paths ?? [];
-  for (const path of paths) {
-    if (!isSafePath(path)) return { ok: false, error: { code: "invalid-path", message: path } };
-  }
-  const pathArgs = paths.length > 0 ? ["--", ...paths] : [];
-  const pathSet = new Set(paths);
-  const [statusRes, headRes, lastRes] = await Promise.all([
-    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z"], root, "suggest-status", deps.signal),
-    runCommand(deps.run, ["git", "rev-parse", "--verify", "HEAD"], root, "suggest-head", deps.signal),
-    runCommand(deps.run, ["git", "log", "-1", "--format=%B"], root, "suggest-last", deps.signal)
-  ]);
-  if ("failure" in statusRes) return { ok: false, error: { code: "git-unavailable", message: "status failed" } };
-  if (statusRes.run.cancelled) return { ok: false, error: { code: "cancelled" } };
-  if (statusRes.run.timedOut) return { ok: false, error: { code: "timeout" } };
-  if (statusRes.run.exitCode !== 0) {
-    return { ok: false, error: { code: "git-error", message: statusRes.run.stderr.trim() || "git status failed" } };
-  }
-  const hasHead = "run" in headRes && headRes.run.exitCode === 0;
-  const recentCommitMessage = "run" in lastRes && lastRes.run.exitCode === 0 ? lastRes.run.stdout.replace(/\n+$/, "") : "";
-  const all = statusRes.run.stdoutLossy ? [] : parseStatus(statusRes.run.stdout);
-  const files = pathSet.size > 0 ? all.filter((c) => pathSet.has(c.path)) : all;
-  const collected = await collectDiff(deps, root, hasHead, pathArgs);
-  if (typeof collected !== "string") return collected;
-  if (files.length === 0 && collected.trim() === "") {
-    return { ok: false, error: { code: "empty-diff", message: "no uncommitted changes to summarize" } };
-  }
-  let diff = collected;
-  let truncated = false;
-  if (Buffer.byteLength(diff, "utf8") > config.suggestMaxBytes) {
-    diff = truncateUtf8(diff, config.suggestMaxBytes) + "\n... [diff truncated]";
-    truncated = true;
-  }
-  const untracked = await appendUntracked(deps, root, files, diff, config.suggestMaxBytes);
-  diff = untracked.diff;
-  truncated = truncated || untracked.truncated;
-  const llm = deps.getLlm?.();
-  const route = resolveRoute(config, deps.getAgentDefaultModel?.());
-  if (llm === void 0 || route === void 0) {
-    return { ok: false, error: { code: "llm-unavailable", message: "no model service or route is configured" } };
-  }
-  const frame = frameChanges(
-    files.map((c) => ({ path: c.path, status: c.status })),
-    diff,
-    recentCommitMessage
-  );
-  const deadline = withDeadline(config.suggestTimeoutMs, deps.signal);
-  const options = {
-    provider: route.provider,
-    model: route.model,
-    system: SYSTEM_PROMPT,
-    messages: [{
-      id: "git-panel-suggest",
-      role: "user",
-      content: [{ type: "text", text: frame }],
-      source: { kind: "user" }
-    }],
-    maxTokens: config.suggestMaxOutputTokens,
-    temperature: 0.3,
-    signal: deadline.signal
-  };
-  let output = "";
-  let finish;
-  try {
-    for await (const chunk of llm.stream(options)) {
-      if (chunk.type === "text-delta") output += chunk.text;
-      else if (chunk.type === "finish") finish = chunk.reason;
-    }
-  } catch (error) {
-    if (deps.signal?.aborted === true) return { ok: false, error: { code: "cancelled" } };
-    if (deadline.expired()) return { ok: false, error: { code: "llm-error", message: `model call timed out after ${config.suggestTimeoutMs}ms` } };
-    return { ok: false, error: { code: "llm-error", message: error instanceof Error ? error.message : "model stream failed" } };
-  } finally {
-    deadline.dispose();
-  }
-  if (deps.signal?.aborted === true) return { ok: false, error: { code: "cancelled" } };
-  if (deadline.expired()) return { ok: false, error: { code: "llm-error", message: `model call timed out after ${config.suggestTimeoutMs}ms` } };
-  const terminal = finishError(finish);
-  if (terminal !== void 0) return terminal;
-  const message = normalizeMessage(output);
-  if (message === "") return { ok: false, error: { code: "llm-output", message: "model produced no message text" } };
-  return {
-    ok: true,
-    value: {
-      message,
-      provider: route.provider,
-      model: route.model,
-      ...truncated ? { truncated: true } : {}
-    }
-  };
-}
-
-// src/host/version.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname2, join as join4 } from "node:path";
-import { fileURLToPath } from "node:url";
-function manifestPath() {
-  return join4(dirname2(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-}
-function stringField(value) {
-  return typeof value === "string" && value !== "" ? value : void 0;
-}
-function parseRepository(repository) {
-  const raw = typeof repository === "string" ? repository : typeof repository === "object" && repository !== null ? stringField(repository.url) : void 0;
-  if (raw === void 0) return void 0;
-  const fromHost = raw.match(/github\.com[/:]([^/]+)\/([^/]+?)(?:\.git)?(?:$|[/#?])/i);
-  if (fromHost !== null) return { owner: fromHost[1], repo: fromHost[2] };
-  const shorthand = raw.match(/^(?:github:)?([\w.-]+)\/([\w.-]+?)(?:\.git)?$/i);
-  if (shorthand !== null) return { owner: shorthand[1], repo: shorthand[2] };
-  return void 0;
-}
-function compareVersions(a, b) {
-  const split = (value) => {
-    const trimmed = value.trim().replace(/^v/i, "");
-    const [core, ...rest] = trimmed.split("-");
-    const preRaw = rest.join("-");
-    return {
-      core: core.split(".").map((part) => Number.parseInt(part, 10)).filter((part) => Number.isFinite(part)),
-      pre: preRaw === "" ? [] : preRaw.split(".")
-    };
-  };
-  const left = split(a);
-  const right = split(b);
-  const length = Math.max(left.core.length, right.core.length);
-  for (let index = 0; index < length; index += 1) {
-    const l = left.core[index] ?? 0;
-    const r = right.core[index] ?? 0;
-    if (l > r) return 1;
-    if (l < r) return -1;
-  }
-  if (left.pre.length === 0 && right.pre.length === 0) return 0;
-  if (left.pre.length === 0) return 1;
-  if (right.pre.length === 0) return -1;
-  const preLen = Math.max(left.pre.length, right.pre.length);
-  for (let i = 0; i < preLen; i += 1) {
-    const lp = left.pre[i];
-    const rp = right.pre[i];
-    if (lp === void 0) return -1;
-    if (rp === void 0) return 1;
-    const ln = Number.parseInt(lp, 10);
-    const rn = Number.parseInt(rp, 10);
-    const lNum = Number.isFinite(ln) && String(ln) === lp;
-    const rNum = Number.isFinite(rn) && String(rn) === rp;
-    if (lNum && rNum) {
-      if (ln !== rn) return ln > rn ? 1 : -1;
-    } else if (lp !== rp) return lp > rp ? 1 : -1;
-  }
-  return 0;
-}
-var manifestCache;
-async function readManifest(path) {
-  const raw = await readFile2(path, "utf8");
-  const parsed = JSON.parse(raw);
-  if (typeof parsed !== "object" || parsed === null) throw new Error("package.json is not an object");
-  return parsed;
-}
-async function loadManifest(path) {
-  if (path !== void 0) return readManifest(path);
-  if (manifestCache === void 0) manifestCache = await readManifest(manifestPath());
-  return manifestCache;
-}
-async function readVersionInfo(options = {}) {
-  const manifest = await loadManifest(options.manifestPath);
-  const current = stringField(manifest.version) ?? "0.0.0";
-  const repo = parseRepository(manifest.repository);
-  const repositoryUrl = repo === void 0 ? void 0 : `https://github.com/${repo.owner}/${repo.repo}`;
-  return {
-    current,
-    ...repositoryUrl ? { repositoryUrl } : {},
-    updateAvailable: false,
-    checkedRemote: false
-  };
-}
-function safeReleaseUrl(url) {
-  if (url === void 0) return void 0;
-  return /^https:\/\/github\.com\//i.test(url) ? url : void 0;
-}
-var REMOTE_CACHE_MS = 10 * 60 * 1e3;
-var remoteCache;
-async function checkLatestVersion(options = {}) {
-  if (options.manifestPath === void 0 && options.fetchFn === void 0 && remoteCache !== void 0 && Date.now() - remoteCache.at < REMOTE_CACHE_MS) {
-    return remoteCache.info;
-  }
-  const base = await readVersionInfo({ manifestPath: options.manifestPath });
-  const repo = parseRepository((await loadManifest(options.manifestPath)).repository);
-  if (repo === void 0) {
-    return { ...base, checkedRemote: false, error: "repository is not configured" };
-  }
-  const fetchFn = options.fetchFn ?? fetch;
-  try {
-    const response = await fetchFn(`https://api.github.com/repos/${repo.owner}/${repo.repo}/releases/latest`, {
-      headers: { accept: "application/vnd.github+json", "user-agent": "dsh-git-panel" },
-      signal: AbortSignal.timeout(5e3)
-    });
-    if (!response.ok) {
-      return { ...base, checkedRemote: true, error: `GitHub responded with ${response.status}` };
-    }
-    const body = await response.json();
-    const tag = typeof body === "object" && body !== null ? stringField(body.tag_name) : void 0;
-    const htmlUrl = typeof body === "object" && body !== null ? stringField(body.html_url) : void 0;
-    if (tag === void 0) {
-      return { ...base, checkedRemote: true, error: "GitHub response did not include a release tag" };
-    }
-    const latest = tag.replace(/^v/i, "");
-    const info = {
-      ...base,
-      checkedRemote: true,
-      latest,
-      updateAvailable: compareVersions(latest, base.current) > 0,
-      releaseUrl: safeReleaseUrl(htmlUrl) ?? (base.repositoryUrl !== void 0 ? `${base.repositoryUrl}/releases/latest` : void 0)
-    };
-    if (options.manifestPath === void 0 && options.fetchFn === void 0) remoteCache = { at: Date.now(), info };
-    return info;
-  } catch (error) {
-    return { ...base, checkedRemote: true, error: error instanceof Error ? error.message : "Unable to reach GitHub" };
-  }
-}
-
-// src/host/index.ts
-var _version_dec, _suggest_dec, _query_dec, _run_dec, _snapshot_dec, _a, _init;
-var GitPanelService = class extends (_a = TypertRemoteService, _snapshot_dec = [Remote("snapshot")], _run_dec = [Remote("run")], _query_dec = [Remote("query")], _suggest_dec = [Remote("suggest")], _version_dec = [Remote("version")], _a) {
+import { readFile, readdir, realpath, rm, stat } from "node:fs/promises";
+import { createGitRunner } from "./git.js";
+import { normalizeConfig, snapshotForSession } from "./core.js";
+import { runAction } from "./actions.js";
+import { runQuery } from "./queries.js";
+import { runSuggest } from "./suggest.js";
+import { checkLatestVersion, readVersionInfo } from "./version.js";
+import { normalizeConfig as normalizeConfig2, DEFAULT_CONFIG, snapshotForSession as snapshotForSession2, resolveWorkspace, parsePrimaryRemote } from "./core.js";
+import { createGitRunner as createGitRunner2 } from "./git.js";
+import { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashList, parseTags, sumNumstat } from "./parser.js";
+import { parseRemote, classifyHost } from "./remote.js";
+import { isSafePath, planAction, runAction as runAction2, classifyActionFailure } from "./actions.js";
+import { runQuery as runQuery2 } from "./queries.js";
+import { runSuggest as runSuggest2 } from "./suggest.js";
+import { readVersionInfo as readVersionInfo2, checkLatestVersion as checkLatestVersion2, compareVersions, parseRepository } from "./version.js";
+class GitPanelService extends (_a = TypertRemoteService, _snapshot_dec = [Remote("snapshot")], _run_dec = [Remote("run")], _query_dec = [Remote("query")], _suggest_dec = [Remote("suggest")], _version_dec = [Remote("version")], _a) {
   constructor(ctx, config) {
     super(ctx, "gitPanel");
     __runInitializers(_init, 5, this);
@@ -1735,7 +82,7 @@ var GitPanelService = class extends (_a = TypertRemoteService, _snapshot_dec = [
     const fs = {
       realpath,
       stat: async (p) => stat(p),
-      readFile: readFile3,
+      readFile,
       readdir: async (p) => (await readdir(p, { withFileTypes: true })).map((e) => ({ name: e.name, isDirectory: e.isDirectory() })),
       remove: async (p) => {
         await rm(p, { force: true });
@@ -1800,7 +147,7 @@ var GitPanelService = class extends (_a = TypertRemoteService, _snapshot_dec = [
     if (signal === void 0) return this.deps;
     return { ...this.deps, signal };
   }
-};
+}
 _init = __decoratorStart(_a);
 __decorateElement(_init, 1, "snapshot", _snapshot_dec, GitPanelService);
 __decorateElement(_init, 1, "run", _run_dec, GitPanelService);
@@ -1831,14 +178,14 @@ var index_default = GitPanelService;
 export {
   DEFAULT_CONFIG,
   GitPanelService,
-  checkLatestVersion,
+  checkLatestVersion2 as checkLatestVersion,
   classifyActionFailure,
   classifyHost,
   compareVersions,
-  createGitRunner,
+  createGitRunner2 as createGitRunner,
   index_default as default,
   isSafePath,
-  normalizeConfig,
+  normalizeConfig2 as normalizeConfig,
   parseBranches,
   parseGraphLog,
   parseNameStatus,
@@ -1849,11 +196,11 @@ export {
   parseStatus,
   parseTags,
   planAction,
-  readVersionInfo,
+  readVersionInfo2 as readVersionInfo,
   resolveWorkspace,
-  runAction,
-  runQuery,
-  runSuggest,
-  snapshotForSession,
+  runAction2 as runAction,
+  runQuery2 as runQuery,
+  runSuggest2 as runSuggest,
+  snapshotForSession2 as snapshotForSession,
   sumNumstat
 };