@xbzbing/dsh-git-panel 1.6.2 → 1.8.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

@@ -1,5 +1,5 @@
 import type { GitRunner } from './git.js';
-import type { AgentDefaultModelFace, LlmFace } from './llm-face.js';
+import type { AgentDefaultModelFace, LlmFace, SessionModelSelection } from './llm-face.js';
 import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult, SuggestLanguage } from './types.js';
 export interface GitPanelConfig {
     readonly timeoutMs: number;
@@ -26,6 +26,9 @@ export interface GitPanelConfig {
     /** Optional provider/model route override; absent → the agent default. */
     readonly suggestProvider?: string;
     readonly suggestModel?: string;
+    /** Adapter-owned effort for the fixed route; absent → omit from the request
+     * (the model / adapter default applies). Ignored when the route is not fixed. */
+    readonly suggestReasoningEffort?: string;
 }
 export declare const DEFAULT_CONFIG: GitPanelConfig;
 export declare function normalizeConfig(raw: unknown): GitPanelConfig;
@@ -50,9 +53,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 +72,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: {
@@ -92,14 +97,17 @@ export interface SnapshotDeps {
      */
     readonly rootNegCache?: Map<string, number>;
     /**
-     * Optional per-request resolvers for the host `llm` and `agentDefaultModel`
-     * services (see llm-face.ts). Resolved on every suggest call — never frozen
-     * at construction — so a provider fiber that activates late or restarts is
+     * Optional per-request resolvers for the host model services (see
+     * llm-face.ts). Resolved on every suggest call — never frozen at
+     * construction — so a provider fiber that activates late or restarts is
      * picked up. Absent in deployments without a model backend; the suggest
      * endpoint then reports `llm-unavailable` instead of failing activation.
      */
     readonly getLlm?: () => LlmFace | undefined;
     readonly getAgentDefaultModel?: () => AgentDefaultModelFace | undefined;
+    /** The session's durable model selection (projection next); undefined when
+     * the session has never selected a model. */
+    readonly getSessionModel?: (sessionId: string) => SessionModelSelection | undefined;
 }
 /**
  * Pick the primary remote from `git remote -v` output and parse its fetch URL.

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 = {
@@ -24,9 +25,14 @@ function normalizeConfig(raw) {
     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 } : {};
+  const provider = unwrapVolatile(c.suggestProvider);
+  const model = unwrapVolatile(c.suggestModel);
+  const effort = unwrapVolatile(c.suggestReasoningEffort);
+  const route = typeof provider === "string" && provider !== "" && typeof model === "string" && model !== "" ? {
+    suggestProvider: provider,
+    suggestModel: model,
+    ...typeof effort === "string" && effort !== "" ? { suggestReasoningEffort: effort } : {}
+  } : {};
   return {
     timeoutMs: num(c.timeoutMs, DEFAULT_CONFIG.timeoutMs),
     maxBytes: num(c.maxBytes, DEFAULT_CONFIG.maxBytes),
@@ -80,6 +86,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 +193,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 +211,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 +250,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 +273,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 +294,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 +303,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

@@ -10,14 +10,14 @@ import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 import type { GitActionRequest, GitActionResult, GitQueryRequest, GitQueryResponse, GitSnapshotRequest, GitSnapshotResult, GitSuggestRequest, GitSuggestResult, GitVersionInfo, GitVersionRequest } from './types.js';
-export type { GitSnapshot, GitSnapshotResult, GitSnapshotRequest, GitFailure, GitCommit, GraphCommit, GitRef, GitChange, GitChangeStatus, GitAction, GitActionRequest, GitActionResult, GitErrorCode, GitQuery, GitQueryRequest, GitQueryResponse, GitQueryResult, GitBranch, GitFileStat, WorktreeStats, StashEntry, GitVersionRequest, GitVersionInfo, DiffViewMode, GraphStyle, DirEntry, ResetMode, GitSuggestRequest, GitSuggestResult, GitRemote, RemoteHostKind, SuggestLanguage, ResolvedLanguage, } from './types.js';
+export type { GitSnapshot, GitSnapshotResult, GitSnapshotRequest, GitFailure, GitCommit, GraphCommit, GitRef, GitChange, GitChangeStatus, GitAction, GitActionRequest, GitActionResult, GitErrorCode, GitQuery, GitQueryRequest, GitQueryResponse, GitQueryResult, GitBranch, GitFileStat, WorktreeStats, StashEntry, GitVersionRequest, GitVersionInfo, DiffViewMode, GraphStyle, DirEntry, ResetMode, GitSuggestRequest, GitSuggestResult, GitRemote, RemoteHostKind, SuggestLanguage, ResolvedLanguage, ModelCatalogGroup, ModelCatalogModel, ModelCatalogEffort, ModelCatalogFailure, } from './types.js';
 export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace, parsePrimaryRemote, readSuggestLanguage } from './core.js';
 export { createGitRunner } from './git.js';
 export { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashList, parseTags, sumNumstat } from './parser.js';
 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[];
@@ -36,6 +36,9 @@ export declare class GitPanelService extends TypertRemoteService {
         suggestMaxBytes: Schema<number, number, "volatile-defined">;
         suggestMaxOutputTokens: Schema<number, number, "volatile-defined">;
         suggestTimeoutMs: Schema<number, number, "volatile-defined">;
+        suggestProvider: Schema<string, string, "volatile">;
+        suggestModel: Schema<string, string, "volatile">;
+        suggestReasoningEffort: Schema<string, string, "volatile">;
     }>>, Schemastery.ObjectT<NoInfer<{
         showInputPill: Schema<boolean, boolean, "volatile-defined">;
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
@@ -45,6 +48,9 @@ export declare class GitPanelService extends TypertRemoteService {
         suggestMaxBytes: Schema<number, number, "volatile-defined">;
         suggestMaxOutputTokens: Schema<number, number, "volatile-defined">;
         suggestTimeoutMs: Schema<number, number, "volatile-defined">;
+        suggestProvider: Schema<string, string, "volatile">;
+        suggestModel: Schema<string, string, "volatile">;
+        suggestReasoningEffort: Schema<string, string, "volatile">;
     }>>, "plain">;
     private readonly deps;
     private config;

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,28 +79,14 @@ 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");
     } } : createGitRunner(subprocess, config.timeoutMs, config.maxBytes);
     const sessions = get("sessions");
     const persistence = get("sessionPersistence");
+    const projections = get("sessionProjections");
     return {
       run,
       fs,
@@ -123,7 +109,25 @@ class GitPanelService extends (_a = TypertRemoteService, _snapshot_dec = [Remote
       // a model backend, where the suggest endpoint reports `llm-unavailable`
       // rather than failing activation (kept out of `static inject` on purpose).
       getLlm: () => get("llm"),
-      getAgentDefaultModel: () => get("agentDefaultModel")
+      getAgentDefaultModel: () => get("agentDefaultModel"),
+      // Session model selection: projection `next` is pending ?? lastUsed —
+      // the route the next prompt in this session would use.
+      getSessionModel: (sessionId) => {
+        const session = sessions?.get(sessionId);
+        if (session === void 0 || projections === void 0) return void 0;
+        try {
+          const next = projections.snapshot(session, ["modelSelection"]).values?.modelSelection?.next;
+          if (next == null || typeof next.provider !== "string" || typeof next.model !== "string") return void 0;
+          if (next.provider === "" || next.model === "") return void 0;
+          return {
+            provider: next.provider,
+            model: next.model,
+            ...typeof next.reasoningEffort === "string" && next.reasoningEffort !== "" ? { reasoningEffort: next.reasoningEffort } : {}
+          };
+        } catch {
+          return void 0;
+        }
+      }
     };
   }
   async snapshot(request, signal) {
@@ -189,15 +193,23 @@ __publicField(GitPanelService, "Config", Schema.object({
   // 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")
+  suggestTimeoutMs: Schema.number().default(DEFAULT_CONFIG.suggestTimeoutMs).volatile().description("AI \u751F\u6210\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF0C5\u2013120 \u79D2\uFF09"),
+  // Fixed model route: both halves of the pair must be non-empty to take
+  // effect (normalizeConfig); effort is omitted from the request when blank.
+  // No .default(): without one the field stays optional in the object schema.
+  suggestProvider: Schema.string().volatile().description("AI \u751F\u6210\u56FA\u5B9A\u6A21\u578B\u7684 provider\uFF08\u7559\u7A7A = \u8DDF\u968F\u4F1A\u8BDD\u9ED8\u8BA4\uFF09"),
+  suggestModel: Schema.string().volatile().description("AI \u751F\u6210\u56FA\u5B9A\u6A21\u578B\u7684 model id\uFF08\u987B\u4E0E provider \u6210\u5BF9\uFF09"),
+  suggestReasoningEffort: Schema.string().volatile().description("AI \u751F\u6210\u56FA\u5B9A\u6A21\u578B\u7684\u63A8\u7406\u5F3A\u5EA6\uFF08\u7559\u7A7A = \u4E0D\u8BBE\u7F6E\uFF0C\u7528\u6A21\u578B\u9ED8\u8BA4\uFF09")
 }));
 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/llm-face.d.ts

@@ -16,7 +16,22 @@ export interface LlmFace {
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
     listProviders?(): readonly {
         readonly id: string;
+        readonly name?: string;
     }[];
+    /** Adapter-advertised models for one provider; optional on the wire. */
+    listModels?(provider: string): Promise<readonly {
+        readonly id: string;
+        readonly name?: string;
+    }[]>;
+    /** Exact-route metadata (reasoning efforts etc.); optional on the wire. */
+    resolveModelInfo?(provider: string, model: string, signal?: AbortSignal): Promise<{
+        readonly reasoning?: {
+            readonly efforts: readonly {
+                readonly id: string;
+                readonly name: string;
+            }[];
+        };
+    }>;
 }
 /** Minimal face of the host `agentDefaultModel` service. */
 export interface AgentDefaultModelFace {
@@ -25,3 +40,9 @@ export interface AgentDefaultModelFace {
         readonly model: string;
     } | undefined;
 }
+/** One session's durable model selection (projection `next`: pending, else lastUsed). */
+export interface SessionModelSelection {
+    readonly provider: string;
+    readonly model: string;
+    readonly reasoningEffort?: string;
+}