@xbzbing/dsh-git-panel 1.7.0 → 1.8.1

package/lib/host/actions.js

@@ -1,5 +1,6 @@
 import { join, sep } from "node:path";
 import { mapWorkspaceFailure, resolveWorkspace, runCommand, snapshotForSession } from "./core.js";
+import { parseStatus } from "./parser.js";
 import { isSafeBranchName, isSafePath, isSafeRemoteName, isSafeRev } from "./validate.js";
 function withPaths(prefixes, paths) {
   if (paths.length === 0) return { error: "invalid-path", message: "no paths given" };
@@ -20,6 +21,8 @@ function planAction(action, unborn) {
       return unborn ? { argv: [["git", "rm", "--cached", "-r", "--", "."]] } : { argv: [["git", "restore", "--staged", "--", "."]] };
     case "discard":
       return withPaths([["git", "restore", "--"]], action.paths);
+    case "discard-all":
+      return { error: "invalid-path", message: "discard-all must be resolved to paths before planning" };
     case "commit": {
       const message = action.message.trim();
       const amend = action.amend === true;
@@ -93,6 +96,14 @@ function isIndexBusy(outcome) {
   if (!("run" in outcome) || outcome.run.exitCode === 0) return false;
   return /index\.lock|Unable to create.*index|another git process/i.test(outcome.run.stderr + outcome.run.stdout);
 }
+function probeFailure(outcome) {
+  if ("failure" in outcome) {
+    return { ok: false, error: { code: "git-unavailable", message: outcome.failure instanceof Error ? outcome.failure.message : String(outcome.failure) } };
+  }
+  if (outcome.run.cancelled) return { ok: false, error: { code: "cancelled" } };
+  if (outcome.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  return null;
+}
 function scrubCredentials(text) {
   return text.replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s]*@/gi, "$1");
 }
@@ -105,8 +116,8 @@ function classifyActionFailure(stdout, stderr, exitCode) {
   if (/index\.lock|Unable to create.*index|another git process/i.test(combined)) {
     return { code: "index-busy", message: err };
   }
-  if (/nothing to commit|no changes added/i.test(combined)) {
-    return { code: "git-error", message: err || "nothing to commit" };
+  if (/nothing to commit|nothing added to commit|no changes added/i.test(combined)) {
+    return { code: "nothing-to-commit", message: err };
   }
   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" };
@@ -137,6 +148,16 @@ async function runAction(deps, config, request) {
   const root = workspace.root;
   const headProbe = await runCommand(deps.run, ["git", "rev-parse", "--verify", "HEAD"], root, "head-probe", deps.signal);
   const unborn = !("run" in headProbe) || headProbe.run.exitCode !== 0;
+  if (request.action.kind === "publish") {
+    const headBroke = probeFailure(headProbe);
+    if (headBroke !== null) return headBroke;
+    if (unborn) return { ok: false, error: { code: "no-branch", message: "no commits to publish" } };
+    const branchProbe = await runCommand(deps.run, ["git", "symbolic-ref", "--quiet", "--short", "HEAD"], root, "publish-branch", deps.signal);
+    const branchBroke = probeFailure(branchProbe);
+    if (branchBroke !== null) return branchBroke;
+    const branch = "run" in branchProbe && branchProbe.run.exitCode === 0 ? branchProbe.run.stdout.trim() : "";
+    if (branch === "") return { ok: false, error: { code: "no-branch", message: "detached HEAD: no branch to publish" } };
+  }
   const act = request.action;
   if (act.kind === "stash-apply" || act.kind === "stash-pop" || act.kind === "stash-drop") {
     if (!Number.isInteger(act.index) || act.index < 0) {
@@ -148,6 +169,27 @@ async function runAction(deps, config, request) {
       return { ok: false, error: { code: "not-found", message: "stash entry changed; refresh and retry" } };
     }
   }
+  if (request.action.kind === "discard-all") {
+    const status = await runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--untracked-files=all"], root, "discard-all-status", deps.signal);
+    if ("failure" in status) return { ok: false, error: { code: "git-unavailable", message: status.failure instanceof Error ? status.failure.message : String(status.failure) } };
+    if (status.run.cancelled) return { ok: false, error: { code: "cancelled" } };
+    if (status.run.timedOut) return { ok: false, error: { code: "timeout" } };
+    if (status.run.exitCode !== 0) {
+      const failure = classifyActionFailure(status.run.stdout, status.run.stderr, status.run.exitCode ?? -1);
+      return { ok: false, error: failure };
+    }
+    if (status.run.stdoutLossy) {
+      return { ok: false, error: { code: "status-lossy", message: "status output was clipped; refusing to discard an incomplete change set" } };
+    }
+    const all = parseStatus(status.run.stdout);
+    const paths = [...new Set(all.filter((c) => !c.staged).map((c) => c.path))].sort();
+    if (paths.length === 0) {
+      const snapshot2 = await snapshotForSession(deps, config, request.sessionId);
+      if (!snapshot2.ok) return { ok: false, error: { code: "git-error", message: "snapshot after action failed" } };
+      return { ok: true, snapshot: snapshot2.value, output: "" };
+    }
+    request = { ...request, action: { kind: "discard", paths } };
+  }
   if (request.action.kind === "discard") {
     const removed = await discardUntracked(deps, config, root, request.sessionId, request.action.paths);
     if (removed !== null) {

package/lib/host/core.d.ts

@@ -1,6 +1,6 @@
 import type { GitRunner } from './git.js';
-import type { AgentDefaultModelFace, LlmFace } from './llm-face.js';
-import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult, SuggestLanguage } from './types.js';
+import type { AgentDefaultModelFace, LlmFace, SessionModelSelection } from './llm-face.js';
+import type { DiffViewMode, FontDelta, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult, SuggestLanguage } from './types.js';
 export interface GitPanelConfig {
     readonly timeoutMs: number;
     /** Per-command stdout cap; also the per-side image-diff payload cap. */
@@ -13,6 +13,8 @@ export interface GitPanelConfig {
     readonly defaultDiffView: DiffViewMode;
     /** Commit-graph line style (parallel = VSCode-like, compact = git log). */
     readonly graphStyle: GraphStyle;
+    /** Panel font-size step: -1 / 0 / +1. */
+    readonly fontDelta: FontDelta;
     /** Whether the "AI suggest" button shows in the commit box. */
     readonly suggestEnabled: boolean;
     /** Language the generated message is written in; `auto` follows repo history. */
@@ -26,6 +28,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;
@@ -33,6 +38,8 @@ export declare function normalizeConfig(raw: unknown): GitPanelConfig;
 export declare function readDiffView(value: unknown, fallback: DiffViewMode): DiffViewMode;
 /** Read the commit-graph style field, unwrapping a schemastery volatile ref. */
 export declare function readGraphStyle(value: unknown, fallback: GraphStyle): GraphStyle;
+/** Read the panel font-size step, unwrapping a schemastery volatile ref. */
+export declare function readFontDelta(value: unknown): FontDelta;
 /**
  * Read the commit-message language field, unwrapping a schemastery volatile
  * ref. An unknown string (a hand-edited profile, or a value from a newer
@@ -94,14 +101,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.
@@ -156,6 +166,8 @@ export declare function mapWorkspaceFailure(failure: GitSnapshotResult & {
     message?: string;
 };
 /** Produce a full snapshot for a session. */
-export declare function snapshotForSession(deps: SnapshotDeps, config: GitPanelConfig, sessionId: string): Promise<GitSnapshotResult>;
+export declare function snapshotForSession(deps: SnapshotDeps, config: GitPanelConfig, sessionId: string, opts?: {
+    readonly fullChanges?: boolean;
+}): Promise<GitSnapshotResult>;
 /** Max mtime among changed files (epoch ms), capped for large sets. */
 export declare function maxChangeMtime(deps: SnapshotDeps, root: string, changes: readonly GitChange[], cap?: number): Promise<number | null>;

package/lib/host/core.js

@@ -3,7 +3,7 @@ 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";
+import { SUGGEST_LANGUAGE_DEFAULT, SUGGEST_LANGUAGES, SUGGEST_LIMITS, FULL_CHANGES_MAX } from "./types.js";
 const DEFAULT_CONFIG = {
   timeoutMs: 8e3,
   maxBytes: 4 * 1024 * 1024,
@@ -12,6 +12,7 @@ const DEFAULT_CONFIG = {
   showInputPill: true,
   defaultDiffView: "unified",
   graphStyle: "parallel",
+  fontDelta: 0,
   suggestEnabled: true,
   suggestLanguage: SUGGEST_LANGUAGE_DEFAULT,
   suggestMaxBytes: SUGGEST_LIMITS.maxBytes.default,
@@ -25,9 +26,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),
@@ -36,6 +42,7 @@ function normalizeConfig(raw) {
     showInputPill: readBool(c.showInputPill, DEFAULT_CONFIG.showInputPill),
     defaultDiffView: readDiffView(c.defaultDiffView, DEFAULT_CONFIG.defaultDiffView),
     graphStyle: readGraphStyle(c.graphStyle, DEFAULT_CONFIG.graphStyle),
+    fontDelta: readFontDelta(c.fontDelta),
     suggestEnabled: readBool(c.suggestEnabled, DEFAULT_CONFIG.suggestEnabled),
     suggestLanguage: readSuggestLanguage(c.suggestLanguage, DEFAULT_CONFIG.suggestLanguage),
     suggestMaxBytes: clampLimit(c.suggestMaxBytes, SUGGEST_LIMITS.maxBytes),
@@ -55,6 +62,10 @@ function readGraphStyle(value, fallback) {
   const raw = unwrapVolatile(value);
   return raw === "parallel" || raw === "compact" ? raw : fallback;
 }
+function readFontDelta(value) {
+  const raw = unwrapVolatile(value);
+  return raw === -1 || raw === 1 ? raw : 0;
+}
 function readSuggestLanguage(value, fallback) {
   const raw = unwrapVolatile(value);
   return typeof raw === "string" && SUGGEST_LANGUAGES.includes(raw) ? raw : fallback;
@@ -170,7 +181,8 @@ function mapWorkspaceFailure(failure) {
   const message = "detail" in error ? error.detail : void 0;
   return { code: error.code, ...message !== void 0 ? { message } : {} };
 }
-async function snapshotForSession(deps, config, sessionId) {
+async function snapshotForSession(deps, config, sessionId, opts) {
+  const changeLimit = opts?.fullChanges === true ? Math.max(config.maxChanges, FULL_CHANGES_MAX) : config.maxChanges;
   const workspace = await resolveWorkspace(deps, sessionId);
   if (!workspace.ok) {
     const failure = workspace.failure;
@@ -209,7 +221,7 @@ async function snapshotForSession(deps, config, sessionId) {
   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) {
+  if (statusLossy || untrackedEntries.length > changeLimit && 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);
@@ -218,9 +230,9 @@ async function snapshotForSession(deps, config, sessionId) {
       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;
+  const truncated = allChanges.length > changeLimit || statusLossy;
+  const truncatedReason = statusLossy ? "lossy" : allChanges.length > changeLimit ? "cap" : void 0;
+  const changes = allChanges.length > changeLimit ? allChanges.slice(0, changeLimit) : allChanges;
   let staged = 0;
   let modified = 0;
   let untracked = 0;
@@ -295,6 +307,7 @@ async function snapshotForSession(deps, config, sessionId) {
     showInputPill: config.showInputPill,
     defaultDiffView: config.defaultDiffView,
     graphStyle: config.graphStyle,
+    fontDelta: config.fontDelta,
     suggestEnabled: config.suggestEnabled,
     checkedAt: Date.now()
   };
@@ -323,6 +336,7 @@ export {
   parsePrimaryRemote,
   readBool,
   readDiffView,
+  readFontDelta,
   readGraphStyle,
   readSuggestLanguage,
   resolveBrowseRoot,

package/lib/host/index.d.ts

@@ -9,13 +9,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';
+import type { GitActionRequest, GitActionResult, GitOpenFileRequest, GitOpenFileResult, 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, GitOpenFileRequest, GitOpenFileResult, 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 { openerArgv, canOpenWithSystem, openWithSystem } from './open-file.js';
 export { runQuery } from './queries.js';
 export { runSuggest, resolveSuggestLanguage, parseStyleHistory, isCjkText, compactLongLines, LONG_LINE_MAX_CHARS } from './suggest.js';
 export { readVersionInfo, checkLatestVersion, compareVersions, parseRepository } from './version.js';
@@ -31,20 +32,28 @@ export declare class GitPanelService extends TypertRemoteService {
         showInputPill: Schema<boolean, boolean, "volatile-defined">;
         defaultDiffView: Schema<"split" | "unified", "split" | "unified", "volatile-defined">;
         graphStyle: Schema<"compact" | "parallel", "compact" | "parallel", "volatile-defined">;
+        fontDelta: Schema<0 | 1 | -1, 0 | 1 | -1, "volatile-defined">;
         suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
         suggestLanguage: Schema<"auto" | "zh" | "en", "auto" | "zh" | "en", "volatile-defined">;
         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">;
         graphStyle: Schema<"compact" | "parallel", "compact" | "parallel", "volatile-defined">;
+        fontDelta: Schema<0 | 1 | -1, 0 | 1 | -1, "volatile-defined">;
         suggestEnabled: Schema<boolean, boolean, "volatile-defined">;
         suggestLanguage: Schema<"auto" | "zh" | "en", "auto" | "zh" | "en", "volatile-defined">;
         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;
@@ -57,6 +66,9 @@ export declare class GitPanelService extends TypertRemoteService {
     suggest(request: GitSuggestRequest, signal?: AbortSignal): Promise<GitSuggestResult>;
     version(request: GitVersionRequest): Promise<GitVersionInfo>;
     /** Re-read config so a live-edited volatile field (showInputPill) is current. */
+    /** Runs one OS-opener argv; null when the host has no subprocess service. */
+    private spawnOpener;
+    openFile(request: GitOpenFileRequest): Promise<GitOpenFileResult>;
     private liveConfig;
     private withSignal;
 }

package/lib/host/index.js

@@ -46,12 +46,13 @@ var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _version_dec, _suggest_dec, _query_dec, _run_dec, _snapshot_dec, _a, _init;
+var _openFile_dec, _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 { createGitRunner } from "./git.js";
 import { createFsDeps } from "./fs-deps.js";
-import { normalizeConfig, snapshotForSession, DEFAULT_CONFIG } from "./core.js";
+import { normalizeConfig, resolveBrowseRoot, snapshotForSession, DEFAULT_CONFIG } from "./core.js";
+import { canOpenWithSystem, openWithSystem } from "./open-file.js";
 import { runAction } from "./actions.js";
 import { runQuery } from "./queries.js";
 import { runSuggest } from "./suggest.js";
@@ -61,16 +62,38 @@ import { createGitRunner as createGitRunner2 } from "./git.js";
 import { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashList, parseTags, sumNumstat } from "./parser.js";
 import { parseRemote, classifyHost } from "./remote.js";
 import { isSafePath, planAction, runAction as runAction2, classifyActionFailure } from "./actions.js";
+import { openerArgv, canOpenWithSystem as canOpenWithSystem2, openWithSystem as openWithSystem2 } from "./open-file.js";
 import { runQuery as runQuery2 } from "./queries.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) {
+async function spawnDetached(subprocess, argv) {
+  try {
+    const handle = subprocess.spawn({
+      argv,
+      cwd: process.cwd(),
+      stdio: {
+        stdin: "ignore",
+        stdout: { collect: { maxBytes: 4096 } },
+        stderr: { collect: { maxBytes: 4096 } }
+      },
+      graceMs: 200
+    });
+    const outcome = await handle.done;
+    return outcome.exitCode;
+  } catch {
+    return null;
+  }
+}
+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")], _openFile_dec = [Remote("openFile")], _a) {
   constructor(ctx, config) {
     super(ctx, "gitPanel");
     __runInitializers(_init, 5, this);
     __publicField(this, "deps");
     __publicField(this, "config");
     __publicField(this, "rawConfig");
+    /** Re-read config so a live-edited volatile field (showInputPill) is current. */
+    /** Runs one OS-opener argv; null when the host has no subprocess service. */
+    __publicField(this, "spawnOpener", null);
     this.rawConfig = config;
     this.config = normalizeConfig(config);
     this.deps = this.buildDeps(ctx, this.config);
@@ -84,8 +107,10 @@ class GitPanelService extends (_a = TypertRemoteService, _snapshot_dec = [Remote
     const run = subprocess === void 0 ? { run: async () => {
       throw new Error("subprocess service unavailable");
     } } : createGitRunner(subprocess, config.timeoutMs, config.maxBytes);
+    this.spawnOpener = subprocess === void 0 ? null : (argv) => spawnDetached(subprocess, argv);
     const sessions = get("sessions");
     const persistence = get("sessionPersistence");
+    const projections = get("sessionProjections");
     return {
       run,
       fs,
@@ -108,11 +133,29 @@ 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) {
-    return snapshotForSession(this.withSignal(signal), this.liveConfig(), request.sessionId);
+    return snapshotForSession(this.withSignal(signal), this.liveConfig(), request.sessionId, { fullChanges: request.fullChanges === true });
   }
   async run(request, signal) {
     return runAction(this.withSignal(signal), this.liveConfig(), request);
@@ -130,7 +173,21 @@ class GitPanelService extends (_a = TypertRemoteService, _snapshot_dec = [Remote
       return { current: "0.0.0", updateAvailable: false, checkedRemote: false, error: error instanceof Error ? error.message : "version unavailable" };
     }
   }
-  /** Re-read config so a live-edited volatile field (showInputPill) is current. */
+  async openFile(request) {
+    if (!canOpenWithSystem(process.platform)) {
+      return { ok: false, error: { code: "git-error", message: "this host cannot open files in a desktop application" } };
+    }
+    if (this.spawnOpener === null) {
+      return { ok: false, error: { code: "git-error", message: "subprocess service unavailable" } };
+    }
+    const browse = await resolveBrowseRoot(this.withSignal(void 0), request.sessionId);
+    if (!browse.ok) return { ok: false, error: browse.error };
+    try {
+      return await openWithSystem(this.deps, browse.root, request.path, this.spawnOpener);
+    } catch (error) {
+      return { ok: false, error: { code: "git-error", message: error instanceof Error ? error.message : String(error) } };
+    }
+  }
   liveConfig() {
     this.config = normalizeConfig(this.rawConfig);
     return this.config;
@@ -146,6 +203,7 @@ __decorateElement(_init, 1, "run", _run_dec, GitPanelService);
 __decorateElement(_init, 1, "query", _query_dec, GitPanelService);
 __decorateElement(_init, 1, "suggest", _suggest_dec, GitPanelService);
 __decorateElement(_init, 1, "version", _version_dec, GitPanelService);
+__decorateElement(_init, 1, "openFile", _openFile_dec, GitPanelService);
 __decoratorMetadata(_init, GitPanelService);
 __publicField(GitPanelService, "inject", ["subprocess", "sessions", "sessionPersistence"]);
 /**
@@ -164,6 +222,11 @@ __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"),
+  fontDelta: Schema.union([
+    Schema.const(-1).description("\u8F83\u5C0F"),
+    Schema.const(0).description("\u9ED8\u8BA4"),
+    Schema.const(1).description("\u8F83\u5927")
+  ]).default(0).volatile().description("\u9762\u677F\u5B57\u53F7"),
   suggestEnabled: Schema.boolean().default(true).volatile().description("\u63D0\u4EA4\u6846\u663E\u793A AI \u751F\u6210\u6309\u94AE"),
   suggestLanguage: Schema.union([
     Schema.const("auto").description("\u81EA\u52A8\u8DDF\u968F\u4ED3\u5E93\u5386\u53F2\u63D0\u4EA4\u7684\u8BED\u8A00"),
@@ -174,13 +237,20 @@ __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,
+  canOpenWithSystem2 as canOpenWithSystem,
   checkLatestVersion2 as checkLatestVersion,
   classifyActionFailure,
   classifyHost,
@@ -191,6 +261,8 @@ export {
   isCjkText,
   isSafePath,
   normalizeConfig2 as normalizeConfig,
+  openWithSystem2 as openWithSystem,
+  openerArgv,
   parseBranches,
   parseGraphLog,
   parseNameStatus,

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;
+}

package/lib/host/open-file.d.ts

@@ -0,0 +1,16 @@
+import type { SnapshotDeps } from './core.js';
+import type { GitOpenFileResult } from './types.js';
+/** Platform argv that opens one file with its default handler. */
+export declare function openerArgv(platform: string, target: string): readonly string[] | null;
+/** Whether this host can hand a file to the desktop at all. */
+export declare function canOpenWithSystem(platform: string): boolean;
+/**
+ * Resolve `path` inside `root` and open it with the OS default application.
+ *
+ * @param deps Host fs face (realpath containment).
+ * @param root Browse root for the session.
+ * @param path Browse-root-relative path from the client (untrusted).
+ * @param spawn Runs one argv and resolves with its exit code, or null on failure.
+ * @returns The absolute path on success, a typed failure otherwise.
+ */
+export declare function openWithSystem(deps: SnapshotDeps, root: string, path: string, spawn: (argv: readonly string[]) => Promise<number | null>, platform?: string): Promise<GitOpenFileResult>;

package/lib/host/open-file.js

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import { isSafePath } from "./validate.js";
+import { isInsideRoot } from "./queries.js";
+function openerArgv(platform, target) {
+  if (platform === "darwin") return ["open", target];
+  if (platform === "win32") return ["rundll32", "url.dll,FileProtocolHandler", target];
+  if (platform === "linux") return ["xdg-open", target];
+  return null;
+}
+function canOpenWithSystem(platform) {
+  return openerArgv(platform, "x") !== null;
+}
+async function openWithSystem(deps, root, path, spawn, platform = process.platform) {
+  if (!isSafePath(path)) return { ok: false, error: { code: "invalid-path", message: path } };
+  const file = join(root, path);
+  const inside = await isInsideRoot(deps, root, file, true);
+  if (inside === "missing") return { ok: false, error: { code: "file-not-found", message: path } };
+  if (inside !== "inside") return { ok: false, error: { code: "invalid-path", message: path } };
+  const argv = openerArgv(platform, file);
+  if (argv === null) return { ok: false, error: { code: "git-error", message: "no system opener on this platform" } };
+  const code = await spawn(argv);
+  if (code !== 0) return { ok: false, error: { code: "git-error", message: `the system opener exited ${String(code)}` } };
+  return { ok: true, absolutePath: file };
+}
+export {
+  canOpenWithSystem,
+  openWithSystem,
+  openerArgv
+};

package/lib/host/queries.d.ts

@@ -1,3 +1,11 @@
 import type { SnapshotDeps, GitPanelConfig } from './core.js';
 import type { GitQueryRequest, GitQueryResponse } from './types.js';
 export declare function runQuery(deps: SnapshotDeps, config: GitPanelConfig, request: GitQueryRequest): Promise<GitQueryResponse>;
+/** Whether a path resolves inside the browse root, outside its .git tree, or
+ * is absent (a deleted entry still listed by a stale tree). */
+export type PathState = 'inside' | 'outside' | 'missing';
+/**
+ * Where `path` sits relative to `root` after symlinks are followed: the one
+ * containment check shared by every endpoint that touches a browsable file.
+ */
+export declare function isInsideRoot(deps: SnapshotDeps, root: string, path: string, hideGit?: boolean): Promise<PathState>;