@xbzbing/dsh-git-panel 1.6.2 → 1.7.0

package/lib/host/actions.js

@@ -36,10 +36,10 @@ function planAction(action, unborn) {
     }
     case "branch-checkout": {
       if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe branch name: ${action.name}` };
-      let checkout = ["git", "checkout", "--end-of-options", action.name];
+      let checkout = ["git", "checkout", action.name];
       if (action.createFrom !== void 0) {
         if (!isSafeBranchName(action.createFrom)) return { error: "invalid-name", message: `unsafe tracking ref: ${action.createFrom}` };
-        checkout = ["git", "checkout", "-b", action.name, "--track", "--end-of-options", action.createFrom];
+        checkout = ["git", "checkout", "-b", action.name, "--track", action.createFrom];
       }
       const msg = action.stashMessage?.trim() ?? "";
       return { argv: msg === "" ? [checkout] : [["git", "stash", "push", "-u", "-m", msg], checkout] };
@@ -85,7 +85,7 @@ function planAction(action, unborn) {
       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]] };
+      return { argv: [["git", "reset", `--${action.mode}`, action.commit]] };
     }
   }
 }
@@ -211,6 +211,26 @@ async function runAction(deps, config, request) {
   }
   return { ok: true, snapshot: snapshot.value, output: lastOutput.trim() };
 }
+async function looksLikeRepository(deps, target) {
+  try {
+    await deps.fs.stat(join(target, ".git"));
+    return true;
+  } catch {
+  }
+  const head = await pathKind(deps, join(target, "HEAD"));
+  const refs = await pathKind(deps, join(target, "refs"));
+  const objects = await pathKind(deps, join(target, "objects"));
+  if (!head.present || head.directory === true) return false;
+  const directoryLike = (kind) => kind.present && kind.directory !== false;
+  return directoryLike(refs) && directoryLike(objects);
+}
+async function pathKind(deps, path) {
+  try {
+    return { present: true, directory: (await deps.fs.stat(path)).isDirectory() };
+  } catch {
+    return { present: await deps.fs.symlinkTarget(path) !== null, directory: null };
+  }
+}
 async function discardUntracked(deps, config, root, sessionId, paths) {
   const snap = await snapshotForSession(deps, config, sessionId);
   if (!snap.ok) return null;
@@ -218,12 +238,20 @@ async function discardUntracked(deps, config, root, sessionId, paths) {
   const untracked = paths.filter((p) => untrackedSet.has(p));
   if (untracked.length === 0) return null;
   const tracked = paths.filter((p) => !untrackedSet.has(p));
+  const directoryEntries = new Set(snap.value.changes.filter((c) => c.isDirectory === true).map((c) => c.path));
+  for (const path of untracked) {
+    if (!directoryEntries.has(path)) continue;
+    if (!await looksLikeRepository(deps, join(root, path))) continue;
+    return { ok: false, result: { ok: false, error: { code: "nested-repo", message: `repository directory: ${path}` } } };
+  }
   let rootReal;
   try {
     rootReal = await deps.fs.realpath(root);
   } catch {
     return { ok: false, result: { ok: false, error: { code: "git-error", message: "repository root unavailable" } } };
   }
+  const failures = [];
+  let removedCount = 0;
   for (const path of untracked) {
     if (!isSafePath(path)) return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `unsafe path: ${path}` } } };
     const target = join(root, path);
@@ -236,8 +264,24 @@ async function discardUntracked(deps, config, root, sessionId, paths) {
     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(() => {
-    });
+    if (await looksLikeRepository(deps, target)) {
+      const code = removedCount === 0 ? "nested-repo" : "nested-repo-partial";
+      const detail = removedCount === 0 ? "" : `; ${removedCount} path(s) already removed`;
+      return { ok: false, result: { ok: false, error: { code, message: `repository directory: ${path}${detail}` } } };
+    }
+    try {
+      await deps.fs.remove(target);
+      removedCount += 1;
+    } catch (e) {
+      failures.push(`${path}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  if (failures.length > 0) {
+    const skipped = tracked.length > 0 ? `; ${tracked.length} tracked path(s) not restored` : "";
+    return {
+      ok: false,
+      result: { ok: false, error: { code: "git-error", message: `could not discard ${failures.length} path(s): ${failures.join("; ")}${skipped}` } }
+    };
   }
   return { ok: true, remainingTracked: tracked };
 }

package/lib/host/core.d.ts

@@ -50,9 +50,11 @@ export interface SnapshotDeps {
     readonly run: GitRunner;
     readonly fs: {
         realpath(path: string): Promise<string>;
+        /** `isDirectory` reports the *resolved* type (symlinks are followed). */
         stat(path: string): Promise<{
             mtimeMs: number;
             size: number;
+            isDirectory(): boolean;
         }>;
         /** Raw bytes (no encoding) — image sides for the image-diff query. */
         readFile(path: string): Promise<Buffer>;
@@ -67,7 +69,7 @@ export interface SnapshotDeps {
             name: string;
             isDirectory: boolean;
         }>>;
-        /** Best-effort unlink (force) — temp-blob cleanup. */
+        /** Recursive remove (force) — untracked discards pass whole directories; temp-blob cleanup passes files. */
         remove(path: string): Promise<void>;
     };
     readonly sessions: {

package/lib/host/core.js

@@ -1,6 +1,7 @@
 import { dirname, join } from "node:path";
 import { commitFromFields, parseStatus, sumNumstat } from "./parser.js";
 import { parseRemote } from "./remote.js";
+import { snapshotFingerprint } from "./snapshot-fingerprint.js";
 import { isSafePath } from "./validate.js";
 import { SUGGEST_LANGUAGE_DEFAULT, SUGGEST_LANGUAGES, SUGGEST_LIMITS } from "./types.js";
 const DEFAULT_CONFIG = {
@@ -80,6 +81,7 @@ function parsePrimaryRemote(stdout) {
   return parseRemote(name, fetchUrls.get(name));
 }
 const STATS_FANOUT_LIMIT = 200;
+const UNTRACKED_NUMSTAT_LIMIT = 32;
 async function resolveBrowseRoot(deps, sessionId) {
   const ws = await resolveWorkspace(deps, sessionId);
   if (ws.ok) return { ok: true, root: ws.root, isGitRepo: true };
@@ -186,7 +188,7 @@ async function snapshotForSession(deps, config, sessionId) {
   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", "status", "--porcelain=v1", "-z", "--untracked-files=all"], 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),
@@ -204,7 +206,20 @@ async function snapshotForSession(deps, config, sessionId) {
     allChanges = parseStatus(statusRes.run.stdout);
     statusLossy = statusRes.run.stdoutLossy;
   }
+  let untrackedCollapsed = false;
+  const untrackedEntries = allChanges.filter((c) => c.status === "untracked");
+  const collapseCandidate = untrackedEntries.some((c) => c.path.includes("/"));
+  if (statusLossy || untrackedEntries.length > config.maxChanges && collapseCandidate) {
+    const collapsed = await runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--untracked-files=normal"], root, "status-collapsed", deps.signal);
+    if ("run" in collapsed && !collapsed.run.timedOut && collapsed.run.exitCode === 0) {
+      const list = parseStatus(collapsed.run.stdout);
+      untrackedCollapsed = list.some((c) => c.status === "untracked" && c.isDirectory);
+      allChanges = list;
+      statusLossy = collapsed.run.stdoutLossy;
+    }
+  }
   const truncated = allChanges.length > config.maxChanges || statusLossy;
+  const truncatedReason = statusLossy ? "lossy" : allChanges.length > config.maxChanges ? "cap" : void 0;
   const changes = allChanges.length > config.maxChanges ? allChanges.slice(0, config.maxChanges) : allChanges;
   let staged = 0;
   let modified = 0;
@@ -230,9 +245,10 @@ async function snapshotForSession(deps, config, sessionId) {
   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;
+  const untrackedPaths = allChanges.filter((c) => c.status === "untracked" && !c.isDirectory).map((c) => c.path);
+  const untrackedCountable = untrackedPaths.length <= UNTRACKED_NUMSTAT_LIMIT;
   let untrackedInsertions = 0;
-  if (statsDetailed) {
-    const untrackedPaths = allChanges.filter((c) => c.status === "untracked" && !c.isDirectory).map((c) => c.path);
+  if (untrackedCountable) {
     const safeUntracked = untrackedPaths.filter(isSafePath);
     if (safeUntracked.length > 0) {
       const perFile = await Promise.all(
@@ -252,7 +268,9 @@ async function snapshotForSession(deps, config, sessionId) {
     deletions: wt.deletions + stg.deletions,
     lastChangeAt,
     headCommittedAt: lastCommit?.dateIso ?? null,
-    partial: !statsDetailed
+    // Collapsed untracked directories have no per-file line counts and count as
+    // one entry each, so the stats are an explicit lower bound there too.
+    partial: !statsDetailed || !untrackedCountable || untrackedCollapsed
   };
   const snapshot = {
     root,
@@ -271,6 +289,8 @@ async function snapshotForSession(deps, config, sessionId) {
     changes,
     stats,
     truncated,
+    ...truncatedReason !== void 0 ? { truncatedReason } : {},
+    ...untrackedCollapsed ? { untrackedCollapsed: true } : {},
     refreshIntervalMs: config.refreshIntervalMs,
     showInputPill: config.showInputPill,
     defaultDiffView: config.defaultDiffView,
@@ -278,7 +298,7 @@ async function snapshotForSession(deps, config, sessionId) {
     suggestEnabled: config.suggestEnabled,
     checkedAt: Date.now()
   };
-  return { ok: true, value: snapshot };
+  return { ok: true, value: { ...snapshot, stateFingerprint: snapshotFingerprint(snapshot) } };
 }
 async function maxChangeMtime(deps, root, changes, cap = 200) {
   let max = null;

package/lib/host/fs-deps.d.ts

@@ -0,0 +1,2 @@
+import type { SnapshotDeps } from './core.js';
+export declare function createFsDeps(): SnapshotDeps['fs'];

package/lib/host/fs-deps.js

@@ -0,0 +1,25 @@
+import { lstat, readdir, readFile, readlink, realpath, rm, stat } from "node:fs/promises";
+function createFsDeps() {
+  return {
+    realpath,
+    stat: async (p) => stat(p),
+    readFile,
+    symlinkTarget: async (p) => {
+      try {
+        return (await lstat(p)).isSymbolicLink() ? await readlink(p) : null;
+      } catch {
+        return null;
+      }
+    },
+    readdir: async (p) => (await readdir(p, { withFileTypes: true })).map((e) => ({ name: e.name, isDirectory: e.isDirectory() })),
+    // Untracked entries include whole directories (porcelain collapses `?? dir/`
+    // into one entry) and a plain `rm` fails EISDIR on them; the caller
+    // realpath-contains every target inside the repo root before removing.
+    remove: async (p) => {
+      await rm(p, { recursive: true, force: true });
+    }
+  };
+}
+export {
+  createFsDeps
+};

package/lib/host/history-topology.d.ts

@@ -0,0 +1,25 @@
+import type { GitRunner } from './git.js';
+import type { GitGraphNode } from './types.js';
+/** Hard cap on the auxiliary walk: deep enough for a filtered page, bounded
+ * against a pathological DAG. */
+export declare const HISTORY_TOPOLOGY_LIMIT = 10000;
+/** Hard cap on the walk's stdout. The node cap alone does not bound a line: an
+ * octopus merge can list thousands of parents on one commit. Over budget the
+ * result is conservatively `[]` (an incomplete graph), never a partial parse. */
+export declare const HISTORY_TOPOLOGY_MAX_BYTES: number;
+/**
+ * Parse `git rev-list --parents` output: one `<hash> [<parent>…]` per line.
+ * Returns null whenever the capture cannot be trusted as a complete ancestry —
+ * a missing trailing newline (git always terminates each line, so a cut read can
+ * land exactly on a 40-char hash and otherwise read as a parentless root), any
+ * malformed line, or output past the node/byte budget. `[]` is a genuinely empty
+ * walk, never a degraded one.
+ */
+export declare function parseGraphNodes(stdout: string): GitGraphNode[] | null;
+/**
+ * Walk the page's raw ancestry. Seeds must already be full hashes; anything
+ * else is dropped rather than passed as argv. Resolves `[]` on every failure
+ * path (spawn throw, cancel, timeout, non-zero exit, lossy output, malformed
+ * output) so a filtered history page is never lost to this auxiliary command.
+ */
+export declare function walkHistoryTopology(runner: GitRunner, root: string, seeds: readonly string[], signal?: AbortSignal): Promise<GitGraphNode[]>;

package/lib/host/history-topology.js

@@ -0,0 +1,55 @@
+import { runCommand } from "./core.js";
+const HISTORY_TOPOLOGY_LIMIT = 1e4;
+const HISTORY_TOPOLOGY_MAX_BYTES = 2 * 1024 * 1024;
+const FULL_HASH = /^(?:[0-9a-fA-F]{40}|[0-9a-fA-F]{64})$/;
+function parseGraphNodes(stdout) {
+  if (stdout === "") return [];
+  if (Buffer.byteLength(stdout, "utf8") > HISTORY_TOPOLOGY_MAX_BYTES) return null;
+  if (!stdout.endsWith("\n")) return null;
+  const lines = [];
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (line !== "") lines.push(line);
+  }
+  if (lines.length > HISTORY_TOPOLOGY_LIMIT) return null;
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const fields = line.split(" ");
+    const hash = fields[0];
+    if (hash === void 0 || !FULL_HASH.test(hash)) return null;
+    const parents = [];
+    for (const parent of fields.slice(1)) {
+      if (!FULL_HASH.test(parent)) return null;
+      parents.push(parent);
+    }
+    if (seen.has(hash)) continue;
+    seen.add(hash);
+    nodes.push({ hash, parents });
+  }
+  return nodes;
+}
+async function walkHistoryTopology(runner, root, seeds, signal) {
+  const safeSeeds = seeds.filter((seed) => FULL_HASH.test(seed));
+  if (safeSeeds.length === 0) return [];
+  const argv = [
+    "git",
+    "rev-list",
+    "--parents",
+    `--max-count=${HISTORY_TOPOLOGY_LIMIT}`,
+    "--end-of-options",
+    ...safeSeeds
+  ];
+  const res = await runCommand(runner, argv, root, "history-topology", signal);
+  if (!("run" in res)) return [];
+  const { run } = res;
+  if (run.cancelled || run.timedOut || run.exitCode !== 0 || run.stdoutLossy) return [];
+  if (Buffer.byteLength(run.stdout, "utf8") > HISTORY_TOPOLOGY_MAX_BYTES) return [];
+  return parseGraphNodes(run.stdout) ?? [];
+}
+export {
+  HISTORY_TOPOLOGY_LIMIT,
+  HISTORY_TOPOLOGY_MAX_BYTES,
+  parseGraphNodes,
+  walkHistoryTopology
+};

package/lib/host/index.d.ts

@@ -17,7 +17,7 @@ export { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashL
 export { parseRemote, classifyHost } from './remote.js';
 export { isSafePath, planAction, runAction, classifyActionFailure } from './actions.js';
 export { runQuery } from './queries.js';
-export { runSuggest, resolveSuggestLanguage, parseStyleHistory, isCjkText } from './suggest.js';
+export { runSuggest, resolveSuggestLanguage, parseStyleHistory, isCjkText, compactLongLines, LONG_LINE_MAX_CHARS } from './suggest.js';
 export { readVersionInfo, checkLatestVersion, compareVersions, parseRepository } from './version.js';
 export declare class GitPanelService extends TypertRemoteService {
     static inject: string[];

package/lib/host/index.js

@@ -49,8 +49,8 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 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 { lstat, readFile, readdir, readlink, realpath, rm, stat } from "node:fs/promises";
 import { createGitRunner } from "./git.js";
+import { createFsDeps } from "./fs-deps.js";
 import { normalizeConfig, snapshotForSession, DEFAULT_CONFIG } from "./core.js";
 import { runAction } from "./actions.js";
 import { runQuery } from "./queries.js";
@@ -62,7 +62,7 @@ import { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashL
 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, resolveSuggestLanguage, parseStyleHistory, isCjkText } from "./suggest.js";
+import { runSuggest as runSuggest2, resolveSuggestLanguage, parseStyleHistory, isCjkText, compactLongLines, LONG_LINE_MAX_CHARS } 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) {
@@ -79,22 +79,7 @@ class GitPanelService extends (_a = TypertRemoteService, _snapshot_dec = [Remote
     const rootCache = /* @__PURE__ */ new Map();
     const rootNegCache = /* @__PURE__ */ new Map();
     const get = (key) => ctx.get(key);
-    const fs = {
-      realpath,
-      stat: async (p) => stat(p),
-      readFile,
-      symlinkTarget: async (p) => {
-        try {
-          return (await lstat(p)).isSymbolicLink() ? await readlink(p) : null;
-        } catch {
-          return null;
-        }
-      },
-      readdir: async (p) => (await readdir(p, { withFileTypes: true })).map((e) => ({ name: e.name, isDirectory: e.isDirectory() })),
-      remove: async (p) => {
-        await rm(p, { force: true });
-      }
-    };
+    const fs = createFsDeps();
     const subprocess = get("subprocess");
     const run = subprocess === void 0 ? { run: async () => {
       throw new Error("subprocess service unavailable");
@@ -195,9 +180,11 @@ var index_default = GitPanelService;
 export {
   DEFAULT_CONFIG2 as DEFAULT_CONFIG,
   GitPanelService,
+  LONG_LINE_MAX_CHARS,
   checkLatestVersion2 as checkLatestVersion,
   classifyActionFailure,
   classifyHost,
+  compactLongLines,
   compareVersions,
   createGitRunner2 as createGitRunner,
   index_default as default,

package/lib/host/queries.js

@@ -1,13 +1,12 @@
 import { join, sep } from "node:path";
 import { mapWorkspaceFailure, resolveBrowseRoot, resolveWorkspace, runCommand, snapshotForSession } from "./core.js";
 import { isSafePath, isSafeRev } from "./validate.js";
+import { walkHistoryTopology } from "./history-topology.js";
 import { commitFromFields, parseBranches, parseGraphLog, parseNameStatus, parseStashList, parseTags, sumNumstat } from "./parser.js";
-import { imageMimeFor, DIFF_CONTEXT_DEFAULT, DIFF_CONTEXT_MAX, DIFF_COUNT_READ_MAX } from "./types.js";
+import { imageMimeFor, isHistoryHashSearch, isHistoryFiltered, DIFF_CONTEXT_DEFAULT, DIFF_CONTEXT_MAX, DIFF_COUNT_READ_MAX, FILE_COPY_MAX_BYTES } from "./types.js";
 const GRAPH_FORMAT = "--format=%H%x1f%h%x1f%P%x1f%an%x1f%aI%x1f%D%x1f%s%x1e";
+const FIRST_PARENT_DIFF = "--diff-merges=first-parent";
 const 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") {
@@ -61,13 +60,19 @@ async function queryHistory(deps, root, q) {
   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 hexJump = isHistoryHashSearch(search);
+  const filtered = isHistoryFiltered(q);
+  const author = q.author ?? "";
+  const since = q.since ?? "";
+  const searchFilter = search !== "";
+  const authorFilter = author !== "";
+  const sinceFilter = since !== "";
   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 (searchFilter) filters.push("-i", "-E", `--grep=${search}`);
+    if (authorFilter) filters.push(`--author=${author}`);
+    if (sinceFilter) filters.push(`--since=${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);
@@ -89,7 +94,7 @@ async function queryHistory(deps, root, q) {
   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: true, value: { kind: "history", commits: [], total: 0, ...filtered ? { topology: [] } : {} } };
     }
     return { ok: false, error: { code: "git-error", message: stderr || `git exited ${res.run.exitCode}` } };
   }
@@ -99,7 +104,8 @@ async function queryHistory(deps, root, q) {
     const n = Number(countRes.run.stdout.trim());
     if (Number.isFinite(n)) total = n;
   }
-  return { ok: true, value: { kind: "history", commits, total } };
+  const topology = filtered ? commits.length === 0 ? [] : await walkHistoryTopology(deps.run, root, commits.map((c) => c.hash), deps.signal) : void 0;
+  return { ok: true, value: { kind: "history", commits, total, ...topology !== void 0 ? { topology } : {} } };
 }
 async function queryDiff(deps, root, q) {
   if (!isSafePath(q.path)) return { ok: false, error: { code: "invalid-path", message: q.path } };
@@ -110,7 +116,7 @@ async function queryDiff(deps, root, q) {
     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];
+    args = ["git", "show", unified, FIRST_PARENT_DIFF, "--end-of-options", q.commit, "--", q.path];
   } else {
     args = ["git", "diff", unified, "--", q.path];
   }
@@ -353,7 +359,6 @@ async function queryFileContent(deps, config, root, q) {
   const file = join(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);
@@ -361,6 +366,7 @@ async function queryFileContent(deps, config, root, q) {
     return { ok: false, error: { code: "git-error", message: error instanceof Error ? error.message : "stat failed" } };
   }
   const mime = imageMimeFor(q.path);
+  const cap = mime !== null ? config.maxBytes : Math.max(config.maxBytes, FILE_COPY_MAX_BYTES);
   const statFields = { size: info.size, mtimeMs: Math.round(info.mtimeMs) };
   const tooLarge = { ok: true, value: { kind: "file-content", path: q.path, variant: mime !== null ? "image" : "text", tooLarge: true, ...statFields } };
   if (info.size > cap) return tooLarge;
@@ -402,8 +408,8 @@ async function queryShow(deps, root, 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)
+    runCommand(deps.run, ["git", "show", FIRST_PARENT_DIFF, "--name-status", "-z", "--format=", "--end-of-options", ref], root, "show-stat", deps.signal),
+    runCommand(deps.run, ["git", "show", FIRST_PARENT_DIFF, "--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" } };

package/lib/host/snapshot-fingerprint.d.ts

@@ -0,0 +1,3 @@
+import type { GitSnapshot } from './types.js';
+/** Hash the final wire state; sampling time and the digest itself are not state. */
+export declare function snapshotFingerprint(snapshot: GitSnapshot): string;

package/lib/host/snapshot-fingerprint.js

@@ -0,0 +1,12 @@
+import { createHash } from "node:crypto";
+function snapshotFingerprint(snapshot) {
+  const { checkedAt: _checkedAt, stateFingerprint: _stateFingerprint, ...state } = snapshot;
+  const encoded = JSON.stringify(state, (_key, value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+  });
+  return createHash("sha256").update(encoded).digest("hex");
+}
+export {
+  snapshotFingerprint
+};

package/lib/host/suggest.d.ts

@@ -19,5 +19,18 @@ export declare function parseStyleHistory(stdout: string, ownEmail: string | und
  * neutral fallback.
  */
 export declare function resolveSuggestLanguage(setting: SuggestLanguage, samples: readonly string[]): ResolvedLanguage;
+/** A diff line longer than this is replaced by a one-line marker before the
+ * model-input budget is applied. Build output is minified into single lines (a
+ * bundled `lib/client.js` line can be hundreds of KB), so shipping it verbatim
+ * spends the whole `suggestMaxBytes` budget on one line and cuts off the hunks
+ * that actually describe the change. Line count and the diff prefix are kept,
+ * so `@@` headers still describe the same regions. */
+export declare const LONG_LINE_MAX_CHARS = 400;
+/** Fold over-long lines into `<prefix>… [long line: N chars omitted]`.
+ * `N` counts UTF-16 code units (what `String.length` reports), not bytes. */
+export declare function compactLongLines(text: string, maxChars?: number): {
+    text: string;
+    folded: number;
+};
 /** Generate a commit message for the session's uncommitted changes. */
 export declare function runSuggest(deps: SnapshotDeps, config: GitPanelConfig, request: GitSuggestRequest): Promise<GitSuggestResult>;

package/lib/host/suggest.js

@@ -59,6 +59,7 @@ function systemPrompt(language) {
   ].join("\n");
 }
 const UNTRACKED_FILE_CAP = 16;
+const PROMPT_FILE_CAP = 200;
 function resolveRoute(config, agentDefaultModel) {
   if (config.suggestProvider !== void 0 && config.suggestModel !== void 0) {
     return { provider: config.suggestProvider, model: config.suggestModel };
@@ -100,9 +101,23 @@ function truncateUtf8(text, maxBytes) {
   }
   return text.slice(0, lo);
 }
-function frameChanges(files, diff, styleSamples) {
+const LONG_LINE_MAX_CHARS = 400;
+const STRUCTURAL_LINE = /^(?:@@|diff --git |index |--- (?:a\/|\/dev\/null)|\+\+\+ (?:b\/|\/dev\/null)|new file mode |deleted file mode |old mode |new mode |similarity index |dissimilarity index |rename from |rename to |copy from |copy to |Binary files |GIT binary patch|literal |delta |\\ )/;
+function compactLongLines(text, maxChars = LONG_LINE_MAX_CHARS) {
+  if (maxChars <= 0) return { text, folded: 0 };
+  let folded = 0;
+  const lines = text.split("\n").map((line) => {
+    if (line.length <= maxChars || STRUCTURAL_LINE.test(line)) return line;
+    folded += 1;
+    const prefix = line[0] === "+" || line[0] === "-" || line[0] === " " || line[0] === "\\" ? line[0] : "";
+    return `${prefix}\u2026 [long line: ${line.length} chars omitted]`;
+  });
+  return { text: lines.join("\n"), folded };
+}
+function frameChanges(files, filesOmitted, diff, styleSamples) {
   return JSON.stringify({
     files,
+    ...filesOmitted > 0 ? { filesOmitted } : {},
     diff,
     commitStyleSamples: styleSamples.length === 0 ? null : styleSamples
   });
@@ -160,7 +175,7 @@ async function appendUntracked(deps, root, files, diff, budget) {
     }
     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;
+    const chunk = compactLongLines(res.run.stdout).text;
     if (chunk === "") continue;
     const lossy = res.run.stdoutLossy;
     if (lossy || Buffer.byteLength(chunk, "utf8") > remaining) {
@@ -186,7 +201,7 @@ async function runSuggest(deps, config, request) {
   const pathArgs = paths.length > 0 ? ["--", ...paths] : [];
   const pathSet = new Set(paths);
   const [statusRes, headRes, logRes, emailRes] = await Promise.all([
-    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z"], root, "suggest-status", deps.signal),
+    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--untracked-files=all"], root, "suggest-status", deps.signal),
     runCommand(deps.run, ["git", "rev-parse", "--verify", "HEAD"], root, "suggest-head", deps.signal),
     runCommand(deps.run, ["git", "log", `-n${HISTORY_SCAN}`, "-z", "--format=%ae%s"], root, "suggest-log", deps.signal),
     runCommand(deps.run, ["git", "config", "user.email"], root, "suggest-email", deps.signal)
@@ -201,13 +216,19 @@ async function runSuggest(deps, config, request) {
   const styleSamples = "run" in logRes && logRes.run.exitCode === 0 ? parseStyleHistory(logRes.run.stdout, "run" in emailRes && emailRes.run.exitCode === 0 ? emailRes.run.stdout.trim() : void 0) : [];
   const language = resolveSuggestLanguage(config.suggestLanguage, styleSamples);
   const all = statusRes.run.stdoutLossy ? [] : parseStatus(statusRes.run.stdout);
-  const files = pathSet.size > 0 ? all.filter((c) => pathSet.has(c.path)) : all;
+  const files = pathSet.size > 0 ? all.filter((c) => {
+    if (pathSet.has(c.path)) return true;
+    for (let slash = c.path.indexOf("/"); slash !== -1; slash = c.path.indexOf("/", slash + 1)) {
+      if (pathSet.has(c.path.slice(0, slash))) return true;
+    }
+    return false;
+  }) : all;
   const collected = await collectDiff(deps, root, hasHead, pathArgs);
   if (!("diff" in collected)) return collected;
   if (files.length === 0 && collected.diff.trim() === "") {
     return { ok: false, error: { code: "empty-diff", message: "no uncommitted changes to summarize" } };
   }
-  let diff = collected.diff;
+  let diff = compactLongLines(collected.diff).text;
   let truncated = collected.lossy;
   if (Buffer.byteLength(diff, "utf8") > config.suggestMaxBytes) {
     diff = truncateUtf8(diff, config.suggestMaxBytes) + "\n... [diff truncated]";
@@ -222,7 +243,8 @@ async function runSuggest(deps, config, request) {
     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 })),
+    files.slice(0, PROMPT_FILE_CAP).map((c) => ({ path: c.path, status: c.status })),
+    Math.max(0, files.length - PROMPT_FILE_CAP),
     diff,
     styleSamples
   );
@@ -275,6 +297,8 @@ async function runSuggest(deps, config, request) {
   };
 }
 export {
+  LONG_LINE_MAX_CHARS,
+  compactLongLines,
   isCjkText,
   parseStyleHistory,
   resolveSuggestLanguage,