@trim21/personal-pi-extensions 0.1.489 → 0.1.491

package/src/lib/lsp/lsp.ts

@@ -18,14 +18,14 @@
 
 import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { extname, join, normalize, relative, sep } from "node:path";
 
 import type { ExtensionAPI, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import { minimatch } from "minimatch";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
-import type { WorkspaceEdit } from "vscode-languageserver-types";
+import type { Hover, WorkspaceEdit } from "vscode-languageserver-types";
 
 import { type LspServerAdapter } from "./adapter.js";
 import {
@@ -33,6 +33,8 @@ import {
   type CreateInput,
   type Diagnostic,
   type Info as LspClient,
+  type InspectLocation,
+  LspMethodNotSupportedError,
   RenameNotPossibleError,
   WATCH_KIND_CHANGE,
   WATCH_KIND_CREATE,
@@ -88,12 +90,19 @@ export type LspConfig = Static<typeof lspConfigSchema>;
 
 /** "500" → 500、"5s" → 5000、"1m" → 60000；无效字符串返回 NaN（由 toMs 过滤）。 */
 function parseTimeoutString(value: string): number {
-  const match = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/.exec(value.trim());
+  // 单位组永远参与匹配（缺省为空串），避免"可选捕获组在类型上不可空"的歧义
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|)\s*$/.exec(value.trim());
   if (!match) return NaN;
   const amount = Number(match[1]);
-  const unit = match[2] ?? "ms";
-  const factors: Record<string, number> = { ms: 1, s: 1_000, m: 60_000, h: 3_600_000 };
-  return amount * (factors[unit] ?? 1);
+  const factors: Record<string, number | undefined> = {
+    "": 1,
+    ms: 1,
+    s: 1_000,
+    m: 60_000,
+    h: 3_600_000,
+  };
+  const factor = factors[match[2]];
+  return amount * (factor ?? 1);
 }
 
 function toMs(value: number | string | undefined): number | undefined {
@@ -242,6 +251,16 @@ interface LspState {
 /** 渲染 LSP status 文本的回调（传入 undefined 表示清除）。 */
 export type StatusRenderer = (text: string | undefined) => void;
 
+export type LspInspectQuery = "definition" | "references" | "hover";
+
+/**
+ * 返回类型与 query 泛型关联：query 为 "hover" 时返回 hover 内容，否则返回
+ * 位置列表。实现内部用 cast 建立关联（TS 无法验证分支与泛型的对应关系）。
+ */
+export type LspInspectResult<Q extends LspInspectQuery = LspInspectQuery> = Q extends "hover"
+  ? { serverID: string; query: "hover"; hover: Hover | null }
+  : { serverID: string; query: "definition" | "references"; locations: InspectLocation[] };
+
 export interface LspRequestOptions {
   notify?: ExtensionUIContext["notify"];
   /** 中止时提前结束诊断等待（已中止时直接跳过诊断）。 */
@@ -288,6 +307,19 @@ export interface LspService {
     newName: string;
     options?: LspRequestOptions;
   }): Promise<{ serverID: string; edit: WorkspaceEdit; placeholder?: string }>;
+  /**
+   * 只读符号查询（definition / references / hover）：只面向 kind 为 "language"
+   * 的服务器，按配置顺序取第一个成功结果；服务器不支持该方法（MethodNotFound）
+   * 时跳过并尝试下一个，全部不支持时抛聚合错误。line / character 为 0-based。
+   */
+  inspect<Q extends LspInspectQuery>(request: {
+    file: string;
+    cwd: string;
+    line: number;
+    character: number;
+    query: Q;
+    options?: LspRequestOptions;
+  }): Promise<LspInspectResult<Q>>;
   shutdownAll(): Promise<void>;
   /** 停止全部服务器并禁用 LSP：之后工具调用不再 spawn，直到 start/reload。 */
   stop(): Promise<void>;
@@ -690,6 +722,56 @@ export function createLspService(
       : new Error(`LSP rename failed on all servers — ${detail}`);
   }
 
+  /** 只读符号查询：与 rename 同款多服务器策略，但 MethodNotFound 是"跳过"而非失败。 */
+  async function inspect<Q extends LspInspectQuery>(request: {
+    file: string;
+    cwd: string;
+    line: number;
+    character: number;
+    query: Q;
+    options?: LspRequestOptions;
+  }): Promise<LspInspectResult<Q>> {
+    const clients = await getClients(
+      request.file,
+      request.cwd,
+      request.options?.notify,
+      (adapter) => adapter.kind !== "linter",
+    );
+    if (clients.length === 0) {
+      throw new Error(
+        `no LSP language server available for ${request.file} (check lsp.json servers and kind)`,
+      );
+    }
+    const failures: { serverID: string; error: unknown }[] = [];
+    for (const client of clients) {
+      const position = { path: request.file, line: request.line, character: request.character };
+      try {
+        if (request.query === "hover") {
+          const hover = await client.hover(position);
+          return { serverID: client.serverID, query: "hover", hover } as LspInspectResult<Q>;
+        }
+        const locations =
+          request.query === "definition"
+            ? await client.definition(position)
+            : await client.references(position);
+        return {
+          serverID: client.serverID,
+          query: request.query,
+          locations,
+        } as LspInspectResult<Q>;
+      } catch (error) {
+        failures.push({ serverID: client.serverID, error });
+      }
+    }
+    const allNotSupported = failures.every((f) => f.error instanceof LspMethodNotSupportedError);
+    const detail = failures
+      .map((f) => `${f.serverID}: ${f.error instanceof Error ? f.error.message : String(f.error)}`)
+      .join("; ");
+    throw allNotSupported
+      ? new LspMethodNotSupportedError("all configured servers", `textDocument/${request.query}`)
+      : new Error(`LSP inspect failed on all servers — ${detail}`);
+  }
+
   /** 关闭全部 client 并清空缓存；closing 置 true 让 in-flight spawn 自行退出。 */
   async function closeAll(): Promise<void> {
     state.closing = true;
@@ -752,6 +834,7 @@ export function createLspService(
     diagnostics,
     lspDiagnosticsForFile,
     rename,
+    inspect,
     shutdownAll,
     stop,
     start,
@@ -767,71 +850,154 @@ export interface LspServiceOptions {
   globalConfigPath?: string;
 }
 
-/** 创建 LSP service 并注册 pi 的进程级清理生命周期。 */
-export function registerLsp(pi: ExtensionAPI, options?: LspServiceOptions): LspService {
-  const service = createLspService(options?.adapters, options?.globalConfigPath);
-  pi.on?.("session_shutdown", () => service.shutdownAll());
-  // session 开始是最早能拿到本地配置 cwd 的时机：预加载并校验，配置错误立即通知
-  pi.on?.("session_start", (_event, ctx) => {
-    void loadLspConfig(ctx.cwd, options?.globalConfigPath)
-      .then((config) => validateConfig(config, options?.adapters))
-      .catch((error: unknown) => {
-        if (error instanceof Error) ctx.ui.notify?.(error.message, "error");
+export interface LspManagerHooks {
+  /**
+   * session_start 校验通过且存在 enabled 服务器时调用（每实例至多一次）；
+   * LSP 专属工具（rename / inspect 族）在此注册，未配置时保持不可见。
+   */
+  onEnabled: (pi: ExtensionAPI, service: LspService) => void;
+}
+
+export interface LspManager {
+  /**
+   * 文件工具的 service 访问器：永不抛错。disabled / session_start 未运行时
+   * 返回共享 no-op service（诊断与文件事件通知为空操作）。
+   */
+  mustLazyGetService(): LspService;
+  /** 当前会话是否已创建 service（/lsp-stop 后仍为 true，内部 disabled 语义不变）。 */
+  haveEnabledLsp(): boolean;
+}
+
+/**
+ * no-op service 单例：空 adapter 列表 → getClients 永远返回空，任何请求都是
+ * 空操作。globalConfigPath 指向必然不存在的文件——真实全局配置若声明了
+ * `enabled`，createLspService 的建时校验会因空 adapter 集合而抛错。
+ */
+const noopServiceHolder: { service?: LspService } = {};
+function getNoopService(): LspService {
+  noopServiceHolder.service ??= createLspService(
+    [],
+    join(tmpdir(), ".pi-lsp-noop-global-does-not-exist.json"),
+  );
+  return noopServiceHolder.service;
+}
+
+/** 会话配置里生效（未被 enabled 白名单排除、未被 disabled）的服务器数量。 */
+function enabledServerCount(config: LspConfig, adapters?: LspServerAdapter[]): number {
+  const ids = adapters ? adapters.map((adapter) => adapter.id) : Object.keys(config.servers ?? {});
+  return ids.filter((id) => {
+    if (config.enabled && !config.enabled.includes(id)) return false;
+    if (config.disabled?.includes(id)) return false;
+    return true;
+  }).length;
+}
+
+/**
+ * 创建 LSP manager 并注册 pi 会话生命周期：
+ * - session_start（被 pi await）：加载并校验配置；存在 enabled 服务器才创建
+ *   service（进程仍首次工具调用才 spawn）并调用 onEnabled 注册 LSP 工具；
+ *   配置缺失或错误则保持 disabled（错误 notify 后降级，不阻断会话启动）。
+ * - session_shutdown：关闭全部服务器进程。
+ * 文件工具经 mustLazyGetService 访问，在任何状态下都能安全工作。
+ */
+export function createLspManager(
+  pi: ExtensionAPI,
+  hooks: LspManagerHooks,
+  options?: LspServiceOptions,
+): LspManager {
+  let service: LspService | undefined;
+
+  pi.on("session_start", async (_event, ctx) => {
+    // /reload 等路径可能对同一 runner 重发 session_start：先清掉旧实例再建
+    if (service !== undefined) {
+      // 旧实例关闭失败不阻断新会话构建
+      await service.shutdownAll().catch(() => {
+        /* noop */
       });
-    // footer status 显示当前所有 LSP server 状态（无 UI 时不显示）
-    service.attachStatus(
-      ctx.ui?.setStatus
-        ? (text) => ctx.ui.setStatus("lsp", text ? ctx.ui.theme.fg("accent", text) : undefined)
-        : undefined,
-    );
+      service = undefined;
+    }
+    try {
+      const config = await loadLspConfig(ctx.cwd, options?.globalConfigPath);
+      validateConfig(config, options?.adapters);
+      if (enabledServerCount(config, options?.adapters) === 0) return;
+      const next = createLspService(options?.adapters, options?.globalConfigPath);
+      // footer status 显示当前所有 LSP server 状态（无 UI 时不显示）
+      next.attachStatus((text) =>
+        ctx.ui.setStatus("lsp", text ? ctx.ui.theme.fg("accent", text) : undefined),
+      );
+      service = next;
+      hooks.onEnabled(pi, next);
+    } catch (error) {
+      service = undefined;
+      if (error instanceof Error) ctx.ui.notify(error.message, "error");
+    }
   });
+
+  pi.on("session_shutdown", () => {
+    void service?.shutdownAll();
+  });
+
   // agent 生命周期边界显式刷新 status：agent 运行中 LSP server 才被惰性
   // spawn（首次工具调用），start/end 时保证 footer 反映当前实际状态。
-  pi.on?.("agent_start", () => service.refreshStatus());
-  pi.on?.("agent_end", () => service.refreshStatus());
+  pi.on("agent_start", () => service?.refreshStatus());
+  pi.on("agent_end", () => service?.refreshStatus());
 
-  pi.registerCommand?.("lsp-stop", {
+  pi.registerCommand("lsp-stop", {
     description: "Stop all LSP servers and disable LSP until /lsp-start or /lsp-reload",
     handler: async (_args, ctx) => {
+      if (service === undefined) {
+        ctx.ui.notify("LSP not configured: nothing to stop", "warning");
+        return;
+      }
       await service.stop();
-      ctx.ui.notify?.("LSP disabled: all servers stopped", "info");
+      ctx.ui.notify("LSP disabled: all servers stopped", "info");
     },
   });
 
-  pi.registerCommand?.("lsp-start", {
+  pi.registerCommand("lsp-start", {
     description: "Re-enable LSP; servers start on the next tool call",
     handler: (_args, ctx) => {
+      if (service === undefined) {
+        ctx.ui.notify("LSP not configured: nothing to enable", "warning");
+        return Promise.resolve();
+      }
       service.start();
-      ctx.ui.notify?.("LSP enabled: servers will start on the next tool call", "info");
+      ctx.ui.notify("LSP enabled: servers will start on the next tool call", "info");
       return Promise.resolve();
     },
   });
 
-  pi.registerCommand?.("lsp-reload", {
+  pi.registerCommand("lsp-reload", {
     description: "Restart a specific LSP server: /lsp-reload <server-id>",
     getArgumentCompletions: (prefix) =>
-      service
-        .serverIDs()
+      (service?.serverIDs() ?? [])
         .toSorted()
         .filter((id) => id.startsWith(prefix))
         .map((id) => ({ value: id, label: id })),
     handler: async (args, ctx) => {
+      if (service === undefined) {
+        ctx.ui.notify("LSP not configured: nothing to reload", "warning");
+        return;
+      }
       const serverID = args.trim();
       const known = service.serverIDs().toSorted();
       if (!serverID) {
-        ctx.ui.notify?.(
+        ctx.ui.notify(
           `usage: /lsp-reload <server-id>${known.length > 0 ? ` (known: ${known.join(", ")})` : ""}`,
           "warning",
         );
         return;
       }
       await service.reload(serverID);
-      ctx.ui.notify?.(
+      ctx.ui.notify(
         `LSP server "${serverID}" reloaded: will restart on the next tool call`,
         "info",
       );
     },
   });
 
-  return service;
+  return {
+    mustLazyGetService: () => service ?? getNoopService(),
+    haveEnabledLsp: () => service !== undefined,
+  };
 }

package/src/lib/lsp/rename-tool.ts

@@ -150,7 +150,7 @@ export function registerLspRenameTool(
         { result: (typeof successes)[number]["result"]; candidates: typeof candidates }
       >();
       for (const [index, candidate] of candidates.entries()) {
-        const entry = successes[index];
+        const entry = successes.at(index);
         if (!entry) continue;
         const key = canonicalizeEdit(entry.result.edit);
         const group = groups.get(key);
@@ -172,7 +172,7 @@ export function registerLspRenameTool(
           `Ambiguous rename target on line ${params.line} of ${filePath}: several distinct symbols share the name "${params.symbol}". Retry with 'character' (1-based) to pick one:\n${listing}`,
         );
       }
-      const firstGroup = [...groups.values()][0];
+      const firstGroup = [...groups.values()].at(0);
       if (!firstGroup) throw new Error("LSP rename returned no target");
       const { result } = firstGroup;
 

package/src/lib/ui.ts

@@ -76,7 +76,7 @@ export async function selectMultiple(
   opts: { signal?: AbortSignal; doneLabel: string },
 ): Promise<string[]> {
   const selected: string[] = [];
-  while (true) {
+  for (;;) {
     const selectedSet = new Set(selected);
     const displayToLabel = new Map<string, string>();
     const round: SelectAction[] = [];
@@ -143,7 +143,7 @@ export async function selectCheckboxActions<T extends string>(
   opts: { signal?: AbortSignal } = {},
 ): Promise<CheckboxActionResult<T> | undefined> {
   const selected: string[] = [];
-  while (true) {
+  for (;;) {
     const selectedSet = new Set(selected);
     const displayToLabel = new Map<string, string>();
     const round: SelectAction[] = [];

package/src/lib/write-guard.ts

@@ -143,7 +143,7 @@ export async function guardWriteAccess(
     throw new Error(`Path "${absolutePath}" is outside workspace. No UI available for approval.`);
   }
 
-  while (true) {
+  for (;;) {
     const diffPreview = opts.change ? await buildDiffPreview(absolutePath, opts.change) : undefined;
     const title =
       `Model requests write access outside workspace:\n\n` +

package/src/openai-cost/config.ts

@@ -66,7 +66,7 @@ function nonEmpty(value: string | undefined): string | undefined {
 function normalizeModel(model: Static<typeof modelSchema>): OpenaiCostModelConfig | undefined {
   const id = nonEmpty(model.id);
   if (!id) return undefined;
-  const input = model.input?.filter((value) => value === "text" || value === "image") ?? [];
+  const input = model.input ?? [];
   return {
     id,
     name: nonEmpty(model.name) ?? id,

package/src/openai-cost/cost.ts

@@ -90,7 +90,7 @@ export async function scanSseCost(body: ReadableStream<Uint8Array>): Promise<num
   let buffer = "";
   let last: number | undefined;
   try {
-    while (true) {
+    for (;;) {
       const { done, value } = await reader.read();
       if (done) break;
       buffer += decoder.decode(value, { stream: true });

package/src/opencode/edit-engine.ts

@@ -372,7 +372,7 @@ const EscapeNormalizedReplacer: Replacer = function* (content, find) {
 
 const MultiOccurrenceReplacer: Replacer = function* (content, find) {
   let startIndex = 0;
-  while (true) {
+  for (;;) {
     const index = content.indexOf(find, startIndex);
     if (index === -1) break;
     yield find;

package/src/opencode/files.ts

@@ -30,7 +30,8 @@ import {
 import { Type } from "typebox";
 
 import { appendLspDiagnosticText } from "../lib/lsp/diagnostic.js";
-import { type LspService, registerLsp } from "../lib/lsp/lsp.js";
+import { registerLspInspectTools } from "../lib/lsp/inspect-tool.js";
+import { createLspManager, type LspService, type LspServiceOptions } from "../lib/lsp/lsp.js";
 import { registerLspRenameTool } from "../lib/lsp/rename-tool.js";
 import { formatSubtitlePath } from "../lib/path.js";
 import { guardWriteAccess } from "../lib/write-guard.js";
@@ -104,8 +105,8 @@ const IMAGE_SIGNATURES: {
       return (
         startsWithAscii(buf, 0, "BM") &&
         buf.length >= 30 &&
-        (buf[28] ?? 0) === 1 &&
-        [1, 4, 8, 16, 24, 32].includes(buf[28 + 1] ?? 0)
+        buf[28] === 1 &&
+        [1, 4, 8, 16, 24, 32].includes(buf[28 + 1])
       );
     },
     mimeType: "image/bmp",
@@ -294,7 +295,7 @@ async function formatDirectoryEntries(dirPath: string): Promise<string[]> {
   return results;
 }
 
-function registerReadTool(pi: ExtensionAPI, service: LspService): void {
+function registerReadTool(pi: ExtensionAPI, getService: () => LspService): void {
   pi.registerTool({
     name: "read",
     label: "read",
@@ -433,9 +434,11 @@ function registerReadTool(pi: ExtensionAPI, service: LspService): void {
       content = [{ type: "text", text: outputText }];
 
       // opencode: LSP 文件事件通知是后台任务，失败不影响读取（read 不驻留文档）
-      void service.notifyFile(absolutePath, ctx.cwd).catch(() => {
-        // 后台通知失败不影响读取
-      });
+      void getService()
+        .notifyFile(absolutePath, ctx.cwd)
+        .catch(() => {
+          // 后台通知失败不影响读取
+        });
 
       return {
         content,
@@ -461,7 +464,7 @@ const editSchema = Type.Object({
   ),
 });
 
-function registerEditTool(pi: ExtensionAPI, service: LspService): void {
+function registerEditTool(pi: ExtensionAPI, getService: () => LspService): void {
   pi.registerTool({
     name: "edit",
     label: "edit",
@@ -524,7 +527,7 @@ function registerEditTool(pi: ExtensionAPI, service: LspService): void {
               text: diagnosticText,
               errorCount,
               warningCount,
-            } = await service.lspDiagnosticsForFile(absolutePath, ctx.cwd, { signal });
+            } = await getService().lspDiagnosticsForFile(absolutePath, ctx.cwd, { signal });
             return [
               "Edit applied successfully.",
               { diff: "", patch: "", firstChangedLine: 0 },
@@ -566,7 +569,7 @@ function registerEditTool(pi: ExtensionAPI, service: LspService): void {
             text: diagnosticText,
             errorCount,
             warningCount,
-          } = await service.lspDiagnosticsForFile(absolutePath, ctx.cwd, { signal });
+          } = await getService().lspDiagnosticsForFile(absolutePath, ctx.cwd, { signal });
           return [
             "Edit applied successfully.",
             { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine },
@@ -614,7 +617,7 @@ export function resolveBom(
   return { bom: sourceBom || nextBom, text };
 }
 
-function registerWriteTool(pi: ExtensionAPI, service: LspService): void {
+function registerWriteTool(pi: ExtensionAPI, getService: () => LspService): void {
   pi.registerTool({
     name: "write",
     label: "write",
@@ -666,7 +669,7 @@ function registerWriteTool(pi: ExtensionAPI, service: LspService): void {
             text: diagnosticText,
             errorCount,
             warningCount,
-          } = await service.lspDiagnosticsForFile(absolutePath, ctx.cwd, { signal });
+          } = await getService().lspDiagnosticsForFile(absolutePath, ctx.cwd, { signal });
 
           return [
             "Wrote file successfully.",
@@ -693,17 +696,25 @@ function registerWriteTool(pi: ExtensionAPI, service: LspService): void {
 
 // ── 入口 ─────────────────────────────────────────────────────────────────────
 
-export function registerFileTools(pi: ExtensionAPI, service: LspService): void {
-  registerReadTool(pi, service);
-  registerEditTool(pi, service);
-  registerWriteTool(pi, service);
-  // 工具壳与 claude-code 共享（lib/lsp/rename-tool.ts）；opencode 不跟踪
-  // read-before-write 状态，不传 recordReads hook。
-  registerLspRenameTool(pi, service);
+export function registerFileTools(pi: ExtensionAPI, getService: () => LspService): void {
+  registerReadTool(pi, getService);
+  registerEditTool(pi, getService);
+  registerWriteTool(pi, getService);
+  // lsp-rename / inspect 工具由 manager 的 onEnabled 回调注册，不在这里注册。
 }
 
-/** 独立入口：创建 LSP service（闭包共享给三个工具）并注册。 */
-export default function opencodeFileTools(pi: ExtensionAPI): void {
-  const service = registerLsp(pi);
-  registerFileTools(pi, service);
+/** 独立入口：创建 LSP manager（session_start 时按配置启用）并注册文件工具。 */
+export default function opencodeFileTools(pi: ExtensionAPI, options?: LspServiceOptions): void {
+  const manager = createLspManager(
+    pi,
+    {
+      onEnabled: (pi, service) => {
+        registerLspRenameTool(pi, service);
+        registerLspInspectTools(pi, service);
+      },
+    },
+    options,
+  );
+  // 文件工具无条件注册；service 惰性获取，disabled 时为 no-op。
+  registerFileTools(pi, () => manager.mustLazyGetService());
 }

package/src/spawn-agent.ts

@@ -89,8 +89,8 @@ const SETTINGS_PATH = join(getAgentDir(), "settings.json");
  * implementation file (they share a read-snapshot state); the `tools`
  * allowlist still exposes only the declared subset. The opencode file tools
  * (read/edit/write) likewise share opencode/files.ts (they share the LSP
- * service instance); that file also registers the shared `lsp-rename` tool,
- * which stays hidden unless a subagent declares it.
+ * service instance); that file also registers the shared `lsp-rename` and
+ * LSP inspect tools, which stay hidden unless a subagent declares them.
  */
 const TOOL_EXTENSION_OVERRIDES: Record<string, string> = {
   read: "opencode/files.ts",

package/src/talk/index.ts

@@ -171,7 +171,7 @@ export default function talk(pi: ExtensionAPI) {
   // ── Lifecycle ──────────────────────────────────────────────────────────
 
   pi.on("session_start", (_event, ctx: ExtensionContext) => {
-    const cwd = ctx.sessionManager.getCwd() ?? ctx.cwd;
+    const cwd = ctx.sessionManager.getCwd();
     const now = Date.now();
     // A fork/branch/resume of a session that joined a group keeps that talk
     // identity (agentId); a fresh session gets the new session id.
@@ -463,13 +463,7 @@ export default function talk(pi: ExtensionAPI) {
 
   pi.registerMessageRenderer<DeliveryDetails>(DELIVERY_TYPE, (message, _options, theme) => {
     const d = message.details;
-    if (
-      !d ||
-      typeof d.id !== "string" ||
-      typeof d.ts !== "number" ||
-      typeof d.body !== "string" ||
-      !d.from
-    ) {
+    if (!d || typeof d.id !== "string" || typeof d.ts !== "number" || typeof d.body !== "string") {
       return; // pre-renderer entries: keep pi's default custom-message box
     }
     const idTail = d.id.slice(-8);

package/src/talk/registry.ts

@@ -164,7 +164,7 @@ function pidAlive(pid: number, pidStart?: number): boolean {
     process.kill(pid, 0);
   } catch (error) {
     // EPERM means the process exists but isn't ours — still alive
-    return (error as NodeJS.ErrnoException)?.code === "EPERM";
+    return (error as NodeJS.ErrnoException).code === "EPERM";
   }
   if (pidStart === undefined) return true;
   const start = readStartTime(pid);

package/src/vision-agent.ts

@@ -276,7 +276,7 @@ export async function callVision(
         messages: [{ role: "user", content, timestamp: Date.now() }],
       },
       {
-        maxTokens: model.maxTokens ?? DEFAULT_MAX_TOKENS,
+        maxTokens: model.maxTokens,
         signal: withTimeout(signal, REQUEST_TIMEOUT_MS),
       },
     );
@@ -290,7 +290,7 @@ export async function callVision(
     throw new Error("API 未返回内容");
   }
   const tokenStr =
-    typeof result.usage?.totalTokens === "number" ? String(result.usage.totalTokens) : "?";
+    typeof result.usage.totalTokens === "number" ? String(result.usage.totalTokens) : "?";
   const labels = loaded.map((l) => l.label).join(", ");
   return `[${labels}]\n${text}\n[模型: ${model.id}, tokens: ${tokenStr}]`;
 }