@xbzbing/dsh-git-panel 1.5.4 → 1.6.1

package/lib/host/actions.d.ts

@@ -22,7 +22,9 @@ export declare function scrubCredentials(text: string): string;
  *    rule below (git keeps the stash entry on conflict → recoverable).
  *  - index.lock busy (another process holds the lock).
  *  - nothing-to-commit / no changes added (a real commit no-op).
- *  - not-found (missing ref / tag / stash).
+ *  - not-found (missing ref / tag / stash, or a checkout target that resolves
+ *    to neither a ref nor a path).
+ *  - branch-in-use (the target branch is checked out in another worktree).
  *  - local-changes-block (a dirty-worktree refusal; neutral wording covers both
  *    `git checkout` and `git stash apply`).
  *  - revert-merge (reverting a merge commit without a mainline parent — git

package/lib/host/actions.js

@@ -34,9 +34,16 @@ function planAction(action, unborn) {
       const commitCmd = ["git", "commit", ...amendFlag, ...msgArgs, "--", ...action.paths];
       return { argv: [...staged.argv, commitCmd] };
     }
-    case "branch-checkout":
+    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]] };
+      let checkout = ["git", "checkout", "--end-of-options", 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];
+      }
+      const msg = action.stashMessage?.trim() ?? "";
+      return { argv: msg === "" ? [checkout] : [["git", "stash", "push", "-u", "-m", msg], checkout] };
+    }
     case "fetch":
       return { argv: [["git", "fetch", "--all", "--prune"]] };
     case "pull-ff":
@@ -101,9 +108,12 @@ function classifyActionFailure(stdout, stderr, exitCode) {
   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)) {
+  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|did not match any file\(s\) known to git/i.test(combined)) {
     return { code: "not-found", message: err || "not found" };
   }
+  if (/is already used by worktree|already checked out at/i.test(combined)) {
+    return { code: "branch-in-use", message: err || "branch is checked out in another worktree" };
+  }
   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" };
   }
@@ -152,6 +162,7 @@ async function runAction(deps, config, request) {
   }
   const plan = planAction(request.action, unborn);
   if ("error" in plan) return { ok: false, error: { code: plan.error, ...plan.message ? { message: plan.message } : {} } };
+  const stashing = request.action.kind === "branch-checkout" && (request.action.stashMessage?.trim() ?? "") !== "";
   let lastOutput = "";
   for (let step = 0; step < plan.argv.length; step += 1) {
     const argv = plan.argv[step];
@@ -161,15 +172,23 @@ async function runAction(deps, config, request) {
       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(" ")})` : "";
+    const stashChangedWorkTree = stashing && step > 0;
     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 } };
+      return { ok: false, error: { code: stashChangedWorkTree ? "stash-switch-failed" : "git-unavailable", message: message + where } };
+    }
+    if (outcome.run.cancelled) {
+      return { ok: false, error: stashChangedWorkTree ? { code: "stash-switch-failed", message: "cancelled" + where } : { code: "cancelled" } };
+    }
+    if (outcome.run.timedOut) {
+      return { ok: false, error: stashChangedWorkTree ? { code: "stash-switch-failed", message: "timed out" + where } : { code: "timeout" } };
     }
-    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 (stashChangedWorkTree) {
+        return { ok: false, error: { code: "stash-switch-failed", message: failure.message + where } };
+      }
       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)) {
@@ -181,8 +200,9 @@ async function runAction(deps, config, request) {
       }
       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 } };
+    if ((request.action.kind === "stash-push" || stashing) && /No local changes to save/i.test(outcome.run.stdout + outcome.run.stderr)) {
+      const message = (outcome.run.stdout.trim() || "No local changes to save") + where;
+      return { ok: false, error: { code: stashing ? "local-changes-block" : "git-error", message } };
     }
   }
   const snapshot = await snapshotForSession(deps, config, request.sessionId);

package/lib/host/core.d.ts

@@ -15,9 +15,11 @@ export interface GitPanelConfig {
     readonly graphStyle: GraphStyle;
     /** Whether the "AI suggest" button shows in the commit box. */
     readonly suggestEnabled: boolean;
-    /** Max diff bytes sent to the model; beyond this the diff is truncated. */
+    /** Max diff bytes sent to the model; beyond this the diff is truncated. Range 16–512 KiB. */
     readonly suggestMaxBytes: number;
+    /** Model output token budget (reasoning tokens count against it on thinking models). Range 256–16384. */
     readonly suggestMaxOutputTokens: number;
+    /** Timeout for one suggest call. Range 5–120 s. */
     readonly suggestTimeoutMs: number;
     /** Optional provider/model route override; absent → the agent default. */
     readonly suggestProvider?: string;
@@ -46,6 +48,12 @@ export interface SnapshotDeps {
         }>;
         /** Raw bytes (no encoding) — image sides for the image-diff query. */
         readFile(path: string): Promise<Buffer>;
+        /**
+         * A symlink's target text, else null. git stores the LINK as the worktree
+         * blob (mode 120000), so the diff's new side is the target string, not the
+         * file it points at — following the link would describe a different file.
+         */
+        symlinkTarget(path: string): Promise<string | null>;
         /** One directory's entries (name + is-directory) — the file browser. */
         readdir(path: string): Promise<ReadonlyArray<{
             name: string;

package/lib/host/core.js

@@ -2,6 +2,7 @@ import { dirname, join } from "node:path";
 import { commitFromFields, parseStatus, sumNumstat } from "./parser.js";
 import { parseRemote } from "./remote.js";
 import { isSafePath } from "./validate.js";
+import { SUGGEST_LIMITS } from "./types.js";
 const DEFAULT_CONFIG = {
   timeoutMs: 8e3,
   maxBytes: 4 * 1024 * 1024,
@@ -11,13 +12,17 @@ const DEFAULT_CONFIG = {
   defaultDiffView: "unified",
   graphStyle: "parallel",
   suggestEnabled: true,
-  suggestMaxBytes: 64 * 1024,
-  suggestMaxOutputTokens: 200,
-  suggestTimeoutMs: 15e3
+  suggestMaxBytes: SUGGEST_LIMITS.maxBytes.default,
+  suggestMaxOutputTokens: SUGGEST_LIMITS.maxOutputTokens.default,
+  suggestTimeoutMs: SUGGEST_LIMITS.timeoutMs.default
 };
 function normalizeConfig(raw) {
   const c = raw ?? {};
   const num = (v, d) => typeof v === "number" && Number.isFinite(v) && v >= 1 ? Math.floor(v) : d;
+  const clampLimit = (v, limit) => {
+    const raw2 = unwrapVolatile(v);
+    return typeof raw2 === "number" && Number.isFinite(raw2) ? Math.min(limit.max, Math.max(limit.min, Math.floor(raw2))) : limit.default;
+  };
   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 } : {};
@@ -30,9 +35,9 @@ function normalizeConfig(raw) {
     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),
+    suggestMaxBytes: clampLimit(c.suggestMaxBytes, SUGGEST_LIMITS.maxBytes),
+    suggestMaxOutputTokens: clampLimit(c.suggestMaxOutputTokens, SUGGEST_LIMITS.maxOutputTokens),
+    suggestTimeoutMs: clampLimit(c.suggestTimeoutMs, SUGGEST_LIMITS.timeoutMs),
     ...route
   };
 }

package/lib/host/index.d.ts

@@ -22,21 +22,27 @@ export { readVersionInfo, checkLatestVersion, compareVersions, parseRepository }
 export declare class GitPanelService extends TypertRemoteService {
     static inject: string[];
     /**
-     * Config schema surfaced on the plugin detail page. `showInputPill` and
-     * `defaultDiffView` are `.volatile()`, so the settings host renders them as
-     * live-editable controls; the operational limits stay profile-only and out
-     * of the UI form.
+     * Config schema surfaced on the plugin detail page. `showInputPill`,
+     * `defaultDiffView`, `graphStyle` and the suggest fields are `.volatile()`,
+     * so the settings host renders them as live-editable controls; the
+     * operational limits stay profile-only and out of the UI form.
      */
     static Config: Schema<Schemastery.ObjectS<NoInfer<{
         showInputPill: Schema<boolean, boolean, "volatile-defined">;
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
         graphStyle: Schema<"compact" | "parallel", "compact" | "parallel", "volatile-defined">;
         suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
+        suggestMaxBytes: Schema<number, number, "volatile-defined">;
+        suggestMaxOutputTokens: Schema<number, number, "volatile-defined">;
+        suggestTimeoutMs: Schema<number, number, "volatile-defined">;
     }>>, Schemastery.ObjectT<NoInfer<{
         showInputPill: Schema<boolean, boolean, "volatile-defined">;
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
         graphStyle: Schema<"compact" | "parallel", "compact" | "parallel", "volatile-defined">;
         suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
+        suggestMaxBytes: Schema<number, number, "volatile-defined">;
+        suggestMaxOutputTokens: Schema<number, number, "volatile-defined">;
+        suggestTimeoutMs: Schema<number, number, "volatile-defined">;
     }>>, "plain">;
     private readonly deps;
     private config;

package/lib/host/index.js

@@ -49,14 +49,14 @@ 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 { readFile, readdir, realpath, rm, stat } from "node:fs/promises";
+import { lstat, readFile, readdir, readlink, realpath, rm, stat } from "node:fs/promises";
 import { createGitRunner } from "./git.js";
-import { normalizeConfig, snapshotForSession } from "./core.js";
+import { normalizeConfig, snapshotForSession, DEFAULT_CONFIG } 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 { normalizeConfig as normalizeConfig2, DEFAULT_CONFIG as DEFAULT_CONFIG2, 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";
@@ -83,6 +83,13 @@ class GitPanelService extends (_a = TypertRemoteService, _snapshot_dec = [Remote
       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 });
@@ -157,10 +164,10 @@ __decorateElement(_init, 1, "version", _version_dec, GitPanelService);
 __decoratorMetadata(_init, GitPanelService);
 __publicField(GitPanelService, "inject", ["subprocess", "sessions", "sessionPersistence"]);
 /**
- * Config schema surfaced on the plugin detail page. `showInputPill` and
- * `defaultDiffView` are `.volatile()`, so the settings host renders them as
- * live-editable controls; the operational limits stay profile-only and out
- * of the UI form.
+ * Config schema surfaced on the plugin detail page. `showInputPill`,
+ * `defaultDiffView`, `graphStyle` and the suggest fields are `.volatile()`,
+ * so the settings host renders them as live-editable controls; the
+ * operational limits stay profile-only and out of the UI form.
  */
 __publicField(GitPanelService, "Config", Schema.object({
   showInputPill: Schema.boolean().default(true).volatile().description("\u663E\u793A\u8F93\u5165\u6846\u7684 Git \u5206\u652F\u6807\u8BB0"),
@@ -172,11 +179,16 @@ __publicField(GitPanelService, "Config", Schema.object({
     Schema.const("parallel").description("\u5E73\u884C\u7EBF\uFF08VSCode \u98CE\u683C\uFF0C\u5206\u652F\u5404\u5360\u4E00\u5217\uFF09"),
     Schema.const("compact").description("\u7D27\u51D1\uFF08git log \u98CE\u683C\uFF0C\u5171\u4EAB\u7956\u5148\u5408\u5E76\u4E3A\u4E00\u5217\uFF09")
   ]).default("parallel").volatile().description("\u63D0\u4EA4\u5386\u53F2\u56FE\u7EBF\u6761\u6837\u5F0F"),
-  suggestEnabled: Schema.boolean().default(true).volatile().description("\u63D0\u4EA4\u6846\u663E\u793A AI \u751F\u6210\u6309\u94AE")
+  suggestEnabled: Schema.boolean().default(true).volatile().description("\u63D0\u4EA4\u6846\u663E\u793A AI \u751F\u6210\u6309\u94AE"),
+  // Defaults come from DEFAULT_CONFIG (which itself reads SUGGEST_LIMITS) —
+  // a literal here could silently drift from what normalizeConfig enforces.
+  suggestMaxBytes: Schema.number().default(DEFAULT_CONFIG.suggestMaxBytes).volatile().description("AI \u751F\u6210\u8F93\u5165\u9884\u7B97\uFF08diff \u5B57\u8282\u4E0A\u9650\uFF0C16\u2013512 KiB\uFF09"),
+  suggestMaxOutputTokens: Schema.number().default(DEFAULT_CONFIG.suggestMaxOutputTokens).volatile().description("AI \u751F\u6210\u8F93\u51FA\u4E0A\u9650\uFF08tokens\uFF0C256\u201316384\uFF09"),
+  suggestTimeoutMs: Schema.number().default(DEFAULT_CONFIG.suggestTimeoutMs).volatile().description("AI \u751F\u6210\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF0C5\u2013120 \u79D2\uFF09")
 }));
 var index_default = GitPanelService;
 export {
-  DEFAULT_CONFIG,
+  DEFAULT_CONFIG2 as DEFAULT_CONFIG,
   GitPanelService,
   checkLatestVersion2 as checkLatestVersion,
   classifyActionFailure,

package/lib/host/queries.js

@@ -2,7 +2,7 @@ import { join, sep } from "node:path";
 import { mapWorkspaceFailure, resolveBrowseRoot, resolveWorkspace, runCommand, snapshotForSession } from "./core.js";
 import { isSafePath, isSafeRev } from "./validate.js";
 import { commitFromFields, parseBranches, parseGraphLog, parseNameStatus, parseStashList, parseTags, sumNumstat } from "./parser.js";
-import { imageMimeFor } from "./types.js";
+import { imageMimeFor, DIFF_CONTEXT_DEFAULT, DIFF_CONTEXT_MAX, DIFF_COUNT_READ_MAX } from "./types.js";
 const GRAPH_FORMAT = "--format=%H%x1f%h%x1f%P%x1f%an%x1f%aI%x1f%D%x1f%s%x1e";
 const VISIBLE_REFS = ["--branches", "--remotes", "--tags", "HEAD"];
 function isHexLike(text) {
@@ -103,7 +103,7 @@ async function queryHistory(deps, root, q) {
 }
 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 ctx = q.context !== void 0 && Number.isFinite(q.context) ? Math.max(0, Math.min(DIFF_CONTEXT_MAX, Math.floor(q.context))) : DIFF_CONTEXT_DEFAULT;
   const unified = `-U${ctx}`;
   let args;
   if (q.base === "staged") {
@@ -118,41 +118,80 @@ async function queryDiff(deps, root, q) {
   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 truncated = res.run.stdoutLossy;
   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;
+      if ("run" in noIndex) {
+        truncated = truncated || noIndex.run.stdoutLossy;
+        text = noIndex.run.stdout;
+      }
     }
   }
-  return { ok: true, value: { kind: "diff", path: q.path, text } };
+  return {
+    ok: true,
+    value: {
+      kind: "diff",
+      path: q.path,
+      text,
+      newLines: await countNewSideLines(deps, root, q, text),
+      ...truncated ? { truncated: true } : {}
+    }
+  };
+}
+async function countNewSideLines(deps, root, q, diffText) {
+  if (!diffText.includes("@@")) return 0;
+  const side = await readNewSide(deps, root, q, { worktreeMaxBytes: DIFF_COUNT_READ_MAX });
+  if (!side.ok || side.text === null) return 0;
+  return countLines(side.text);
+}
+function countLines(content) {
+  if (content === "") return 0;
+  let lines = 1;
+  for (let at = content.indexOf("\n"); at !== -1; at = content.indexOf("\n", at + 1)) lines++;
+  return content.endsWith("\n") ? lines - 1 : lines;
+}
+function splitLines(content) {
+  const all = content.split("\n");
+  if (all[all.length - 1] === "") all.pop();
+  return all;
 }
 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" } };
+  const side = await readNewSide(deps, root, q);
+  if (!side.ok) return { ok: false, error: { code: side.code, message: side.message } };
+  return sliceLines(q.path, side.text ?? "", start, end);
+}
+const ABSENT_SIDE_RE = /does not exist in|exists on disk, but not in the index|no such path/i;
+async function readNewSide(deps, root, q, opts) {
+  if (q.base === "worktree") return { ok: true, text: await readWorktreeSide(deps, root, q.path, opts?.worktreeMaxBytes) };
+  if (q.base === "commit" && !isSafeRev(q.commit)) return { ok: false, code: "invalid-name", message: `unsafe commit: ${q.commit}` };
+  const spec = q.base === "commit" ? `${q.commit}:${q.path}` : `:${q.path}`;
+  const res = await runCommand(deps.run, ["git", "show", "--end-of-options", spec], root, "new-side", deps.signal);
+  if (!("run" in res)) return { ok: false, code: "git-unavailable", message: "git unavailable" };
+  if (res.run.cancelled) return { ok: false, code: "cancelled", message: "cancelled" };
+  if (res.run.timedOut) return { ok: false, code: "timeout", message: "timed out" };
   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 ABSENT_SIDE_RE.test(res.run.stderr) ? { ok: true, text: null } : { ok: false, code: "git-error", message: res.run.stderr.trim() || "git show failed" };
+  }
+  if (res.run.stdoutLossy) return { ok: false, code: "git-error", message: "git show output exceeded the output cap" };
+  return { ok: true, text: res.run.stdout };
+}
+async function readWorktreeSide(deps, root, path, maxBytes) {
+  const file = join(root, path);
+  const link = await deps.fs.symlinkTarget(file);
+  if (link !== null) return link;
+  if (maxBytes !== void 0) {
+    const size = await deps.fs.stat(file).catch(() => null);
+    if (size === null || size.size > maxBytes) return null;
   }
-  return sliceLines(q.path, res.run.stdout, start, end);
+  const text = await readWorktreeText(deps, root, path);
+  return text === null ? null : text.replace(/\r\n/g, "\n");
 }
 async function readWorktreeText(deps, root, path) {
   try {
@@ -167,8 +206,7 @@ async function readWorktreeText(deps, root, path) {
   }
 }
 function sliceLines(path, content, start, end) {
-  const all = content.split("\n");
-  if (all[all.length - 1] === "") all.pop();
+  const all = splitLines(content);
   const from = Math.min(start, all.length + 1);
   const to = Math.min(end, all.length);
   const lines = from <= to ? all.slice(from - 1, to) : [];
@@ -323,7 +361,8 @@ 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 tooLarge = { ok: true, value: { kind: "file-content", path: q.path, variant: mime !== null ? "image" : "text", tooLarge: true } };
+  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;
   let buf;
   try {
@@ -333,12 +372,12 @@ async function queryFileContent(deps, config, root, q) {
   }
   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")}` } };
+    return { ok: true, value: { kind: "file-content", path: q.path, variant: "image", dataUrl: `data:${mime};base64,${buf.toString("base64")}`, ...statFields } };
   }
-  if (isBinaryBuffer(buf)) return { ok: true, value: { kind: "file-content", path: q.path, variant: "binary" } };
+  if (isBinaryBuffer(buf)) return { ok: true, value: { kind: "file-content", path: q.path, variant: "binary", ...statFields } };
   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 } };
+  return { ok: true, value: { kind: "file-content", path: q.path, variant: "text", content, lines, ...statFields } };
 }
 function hasGitSegment(path) {
   return path.split(/[\\/]/).includes(".git");

package/lib/host/suggest.js

@@ -81,6 +81,7 @@ 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 = "";
+  let lossy = false;
   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" } };
@@ -88,9 +89,10 @@ async function collectDiff(deps, root, hasHead, pathArgs) {
     if (res.run.exitCode !== 0) {
       return { ok: false, error: { code: "git-error", message: res.run.stderr.trim() || "git diff failed" } };
     }
+    if (res.run.stdoutLossy) lossy = true;
     diff += res.run.stdout;
   }
-  return diff;
+  return { diff, lossy };
 }
 async function appendUntracked(deps, root, files, diff, budget) {
   let text = diff;
@@ -106,7 +108,8 @@ async function appendUntracked(deps, root, files, diff, budget) {
     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) {
+    const lossy = res.run.stdoutLossy;
+    if (lossy || Buffer.byteLength(chunk, "utf8") > remaining) {
       text += truncateUtf8(chunk, remaining) + "\n... [diff truncated]";
       truncated = true;
       break;
@@ -144,12 +147,12 @@ async function runSuggest(deps, config, request) {
   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() === "") {
+  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;
-  let truncated = false;
+  let diff = collected.diff;
+  let truncated = collected.lossy;
   if (Buffer.byteLength(diff, "utf8") > config.suggestMaxBytes) {
     diff = truncateUtf8(diff, config.suggestMaxBytes) + "\n... [diff truncated]";
     truncated = true;

package/lib/host/types.d.ts

@@ -9,6 +9,26 @@ export type DiffViewMode = 'unified' | 'split';
  * lane (git log --graph); `parallel` = keep each merge's first parent in its
  * own lane, converging only at the ancestor (VSCode / GUI tools). */
 export type GraphStyle = 'compact' | 'parallel';
+/**
+ * Diff context (-U) values shared by both halves. `DEFAULT` matches git's own
+ * default and is what the host applies when a request omits `context`.
+ * `MAX` is the host's clamp ceiling. `EXPAND` is what the "expand all" button
+ * asks for: deliberately bounded, because a -U window wide enough to cover a
+ * huge file makes the host emit that whole file as one hunk — megabytes of
+ * text, and past the runner's stdout cap a silently truncated diff. Whatever
+ * the window does not reach stays a collapsed gap the view reveals on demand.
+ */
+export declare const DIFF_CONTEXT_DEFAULT = 3;
+export declare const DIFF_CONTEXT_MAX = 100000;
+export declare const DIFF_EXPAND_CONTEXT = 2000;
+/**
+ * Ceiling for the working-file read taken only to count the diff's new-side
+ * lines. That count decides whether hidden context follows the last hunk, so it
+ * is read on every diff query — including the changes tab's poll while a diff is
+ * open — while `file-lines` (the on-demand expansion) stays uncapped. Above this
+ * size the count reports 0 (unknown) and no trailing control is offered.
+ */
+export declare const DIFF_COUNT_READ_MAX: number;
 /** Wire request: the browser sends only session identity, never a path. */
 export interface GitSnapshotRequest {
     readonly sessionId: string;
@@ -145,6 +165,8 @@ export type GitAction = {
 } | {
     readonly kind: 'branch-checkout';
     readonly name: string;
+    readonly createFrom?: string;
+    readonly stashMessage?: string;
 } | {
     readonly kind: 'fetch';
 } | {
@@ -188,7 +210,7 @@ export type GitAction = {
 /** `git reset` modes, from least to most destructive. Single source so the
  * client dialog and the command builder cannot drift. */
 export type ResetMode = 'soft' | 'mixed' | 'hard';
-export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'not-ff' | 'push-rejected' | 'auth-failed' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'index-busy' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
+export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'not-ff' | 'push-rejected' | 'auth-failed' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'branch-in-use' | 'stash-switch-failed' | 'index-busy' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
 export type GitActionResult = {
     readonly ok: true;
     readonly snapshot: GitSnapshot;
@@ -335,10 +357,32 @@ export type GitQueryResult = {
     readonly kind: 'history';
     readonly commits: readonly GraphCommit[];
     readonly total: number;
-} | {
+}
+/**
+ * Unified diff text plus the new-side line count. The count is the fact the
+ * view needs to decide whether hidden context can follow the LAST hunk: git
+ * caps trailing context at -U, so a full trailing run is ambiguous from the
+ * text alone (it may be mid-file, or the file may end exactly there), while
+ * `newLines` makes it provable.
+ *
+ * 0 means "no trailing control is possible, or the count is not trustworthy":
+ * the side does not exist (a deleted file), the read failed or was truncated,
+ * the diff has no hunk at all, or the working file is above
+ * DIFF_COUNT_READ_MAX. The view treats all of those the same way — no
+ * trailing gap rather than a speculative one.
+ *
+ * `truncated` marks the one case where the text itself is incomplete: the
+ * runner dropped output at its collect/spill ceiling, so `text` is a prefix
+ * that still parses like a real diff. It is flagged rather than refused —
+ * the partial hunks stay readable — but the view must say so, because line
+ * numbers and +/- counts past the cut are simply wrong.
+ */
+ | {
     readonly kind: 'diff';
     readonly path: string;
     readonly text: string;
+    readonly newLines: number;
+    readonly truncated?: true;
 } | {
     readonly kind: 'file-lines';
     readonly path: string;
@@ -429,6 +473,10 @@ export type GitQueryResult = {
     readonly dataUrl?: string;
     /** The file exceeded the byte cap, so no content is returned. */
     readonly tooLarge?: true;
+    /** Byte size from the stat the read already performs (all variants). */
+    readonly size?: number;
+    /** Modification time (epoch ms) from the same stat (all variants). */
+    readonly mtimeMs?: number;
 };
 export type GitQueryResponse = {
     readonly ok: true;
@@ -444,6 +492,31 @@ export interface GitQueryRequest {
     readonly sessionId: string;
     readonly query: GitQuery;
 }
+/**
+ * Suggest-limit ranges and defaults, in host storage units (bytes / tokens /
+ * ms) — the single source shared by both plugin halves (the client bundle
+ * imports this value, like imageMimeFor below): the host's DEFAULT_CONFIG and
+ * normalizeConfig clamp every read into [min, max], and the detail-page form
+ * derives its display units from it (the /1024 and /1000 divisions are exact
+ * and guarded by test).
+ */
+export declare const SUGGEST_LIMITS: {
+    readonly maxBytes: {
+        readonly min: number;
+        readonly max: number;
+        readonly default: number;
+    };
+    readonly maxOutputTokens: {
+        readonly min: 256;
+        readonly max: 16384;
+        readonly default: 4096;
+    };
+    readonly timeoutMs: {
+        readonly min: 5000;
+        readonly max: 120000;
+        readonly default: 15000;
+    };
+};
 /**
  * Wire request for the suggest endpoint: ask the configured model to write a
  * commit message from the repository's uncommitted changes. `paths` restricts
@@ -462,7 +535,8 @@ export type GitSuggestResult = {
         /** Actual provider/model route used (display only). */
         readonly provider?: string;
         readonly model?: string;
-        /** The diff exceeded the model input cap and was truncated. */
+        /** The diff reached the model truncated: over the input cap, or cut
+         * by the per-command runner stdout cap before it. */
         readonly truncated?: boolean;
     };
 } | {

package/lib/host/types.js

@@ -1,3 +1,12 @@
+const DIFF_CONTEXT_DEFAULT = 3;
+const DIFF_CONTEXT_MAX = 1e5;
+const DIFF_EXPAND_CONTEXT = 2e3;
+const DIFF_COUNT_READ_MAX = 8 * 1024 * 1024;
+const SUGGEST_LIMITS = {
+  maxBytes: { min: 16 * 1024, max: 512 * 1024, default: 128 * 1024 },
+  maxOutputTokens: { min: 256, max: 16384, default: 4096 },
+  timeoutMs: { min: 5e3, max: 12e4, default: 15e3 }
+};
 const IMAGE_MIME = {
   png: "image/png",
   jpg: "image/jpeg",
@@ -17,6 +26,11 @@ function imageMimeFor(path) {
   return IMAGE_MIME[path.slice(dot + 1).toLowerCase()] ?? null;
 }
 export {
+  DIFF_CONTEXT_DEFAULT,
+  DIFF_CONTEXT_MAX,
+  DIFF_COUNT_READ_MAX,
+  DIFF_EXPAND_CONTEXT,
   IMAGE_MIME,
+  SUGGEST_LIMITS,
   imageMimeFor
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbzbing/dsh-git-panel",
-  "version": "1.5.4",
+  "version": "1.6.1",
   "description": "DeepSeek Harness (dsh) plugin: an IDE-style Git panel in the Web GUI — branch/history overview, uncommitted changes with commit & amend, diff stats, and a zsh-style branch marker in the input bar.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "build": "node build.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:unit": "node build.mjs && node --test --test-force-exit test/unit/*.test.mjs",
-    "test:e2e": "node build.mjs && node test/e2e/setup.mjs && node test/e2e/run.mjs && node test/e2e/run2.mjs && node test/e2e/run3.mjs",
+    "test:e2e": "node build.mjs && node test/e2e/setup.mjs && node test/e2e/run.mjs && node test/e2e/run2.mjs && node test/e2e/run3.mjs && node test/e2e/run4.mjs && node test/e2e/run5.mjs",
     "test": "npm run test:unit && npm run test:e2e",
     "check": "npm run typecheck && npm run test && git diff --exit-code -- lib/"
   },