decorated-pi 0.7.1 → 0.7.3

package/hooks/smart-at.ts

@@ -5,6 +5,14 @@
  * FFF maintains an in-memory index, scores files by fuzzy match +
  * frecency + git status, and returns ranked results. We create one
  * FileFinder per session and query it directly for every @ prefix.
+ *
+ * KNOWN FFF LIMITATION (v0.9.4):
+ * FFF only returns directories that directly contain files. Intermediate
+ * folders that only hold subdirectories (e.g. product/module/apmanage/ where
+ * all files live in product/module/apmanage/deep/) will not appear in
+ * mixedSearch/directorySearch results, even though the files underneath do.
+ * We intentionally do NOT synthesize these directories on the TypeScript side
+ * to avoid extra complexity/cost; the fix belongs upstream.
  */
 
 import { FileFinder, type MixedItem } from "@ff-labs/fff-node";
@@ -85,7 +93,15 @@ export const smartAtModule: Module = {
     session_start: [
       async (_event: any, ctx: ExtensionContext) => {
         const cwd = String(ctx.cwd || "").trim();
-        const created = FileFinder.create({ basePath: cwd || "." });
+        // Always opt in to home/root scanning. These flags are opt-in guards
+        // in FFF — when cwd is a normal project, they're no-ops; when cwd
+        // IS $HOME or /, they let FFF index it. Without them, create() fails
+        // outright when cwd is a home/root, leaving the user without @-search.
+        const created = FileFinder.create({
+          basePath: cwd || ".",
+          enableHomeDirScanning: true,
+          enableFsRootScanning: true,
+        });
         if (!created.ok) {
           // FFF not available on this platform; silently skip.
           return;
@@ -94,11 +110,18 @@ export const smartAtModule: Module = {
         const finder = created.value;
         currentFinder = finder;
 
+        let scanWidgetVisible = false;
+
         // Start the scan in the background. We don't wait for it here so
-        // session_start returns immediately; the provider queries the
-        // (possibly partial) index and FFF returns whatever it has indexed
-        // so far. Full results appear as the scan progresses.
-        void finder.waitForScan(60_000);
+        // session_start returns immediately. If a scanning status was shown,
+        // clear it when the scan finishes even if no new autocomplete request
+        // is triggered afterwards.
+        void finder.waitForScan(60_000).then(() => {
+          if (currentFinder === finder && !finder.isDestroyed && scanWidgetVisible) {
+            scanWidgetVisible = false;
+            ctx.ui.setWidget("smart-at", undefined);
+          }
+        });
 
         ctx.ui.addAutocompleteProvider((orig: any) => ({
           getSuggestions: (
@@ -134,18 +157,47 @@ export const smartAtModule: Module = {
               return null;
             }
 
+            // 0 items during the initial scan means FFF is not ready yet.
+            // Autocomplete has no non-selectable dropdown state: returning an
+            // item would force SelectList to render a selectable "→ ..." row.
+            // So use a static below-editor widget while scanning, and clear it
+            // once the scan completes (see waitForScan above). After scanning,
+            // 0 items just means "no match".
+            if (r.value.items.length === 0) {
+              if (finder.isScanning()) {
+                scanWidgetVisible = true;
+                ctx.ui.setWidget(
+                  "smart-at",
+                  ["⏳ scanning…  (indexing files, please wait)"],
+                  { placement: "belowEditor" },
+                );
+              } else {
+                scanWidgetVisible = false;
+                ctx.ui.setWidget("smart-at", undefined);
+              }
+              return null;
+            }
+
             const result = buildResult(r.value.items, lowerQuery);
             if (!result) {
               ctx.ui.setWidget("smart-at", undefined);
               return null;
             }
 
+            scanWidgetVisible = false;
             ctx.ui.setWidget("smart-at", [WIDGET_FOOTER]);
             return Promise.resolve({ ...result, prefix });
           },
-          applyCompletion: (...args: any[]) => {
+          applyCompletion: (
+            lines: string[],
+            cl: number,
+            cc: number,
+            item: { value: string; label: string },
+            prefix: string,
+          ) => {
+            scanWidgetVisible = false;
             ctx.ui.setWidget("smart-at", undefined);
-            return orig.applyCompletion.apply(orig, args);
+            return orig.applyCompletion(lines, cl, cc, item, prefix);
           },
           shouldTriggerFileCompletion:
             orig.shouldTriggerFileCompletion?.bind(orig),

package/hooks/wakatime.ts

@@ -6,10 +6,11 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { execFile, execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { resolveDependency } from "../settings.js";
 import { fileURLToPath } from "node:url";
 import type { Module, Skeleton } from "./skeleton.js";
 
@@ -122,36 +123,21 @@ export function buildPluginString(version = PACKAGE_VERSION): string {
   return `pi/${version} pi/${version}`;
 }
 
+export function wakatimeDependencyExtendPath(): string[] {
+  return [path.join(os.homedir(), ".wakatime")];
+}
+
 function findWakatimeCliOnPath(): string | null {
-  try {
-    if (process.platform === "win32") {
-      const output = execFileSync("where", ["wakatime-cli"], { encoding: "utf-8" }).trim();
-      const first = output.split(/\r?\n/)[0]?.trim();
-      return first ? path.resolve(first) : null;
-    }
-    const shell = process.env.SHELL || "sh";
-    const output = execFileSync(shell, ["-lc", "command -v wakatime-cli"], { encoding: "utf-8" }).trim();
-    return output ? path.resolve(output) : null;
-  } catch {
-    return null;
-  }
+  return resolveDependency("wakatime-cli", { extendPath: wakatimeDependencyExtendPath() });
 }
 
 export function findWakatimeCli(options: {
   probePath?: () => string | null;
-  exists?: (candidate: string) => boolean;
-  fallbackPath?: string;
 } = {}): string | null {
   if (cachedWakatimeCliPath !== undefined) return cachedWakatimeCliPath;
   const probePath = options.probePath ?? findWakatimeCliOnPath;
-  const exists = options.exists ?? fs.existsSync;
-  const fromPath = probePath();
-  if (fromPath) {
-    cachedWakatimeCliPath = path.resolve(fromPath);
-    return cachedWakatimeCliPath;
-  }
-  const fallback = path.resolve(options.fallbackPath ?? WAKATIME_CLI_FALLBACK);
-  cachedWakatimeCliPath = exists(fallback) ? fallback : null;
+  const found = probePath();
+  cachedWakatimeCliPath = found ? path.resolve(found) : null;
   return cachedWakatimeCliPath;
 }
 
@@ -342,11 +328,13 @@ export function setupWakatimeWithApiKey(
 export function setupWakatime(sk: Skeleton, pi: ExtensionAPI): void {
   const apiKey = readWakatimeCfgApiKey();
   const cliPath = findWakatimeCli();
-  sk.declareDependency({
-    label: "wakatime-cli",
-    check: () => findWakatimeCli() !== null,
-    hint: "Install wakatime-cli to track coding activity.",
-  });
+  if (!cliPath) {
+    sk.declareMissing({
+      name: "wakatime-cli",
+      module: "wakatime",
+      hint: "Install wakatime-cli to track coding activity.",
+    });
+  }
   if (!apiKey || !cliPath) return;
 
   const sendHeartbeat: HeartbeatSender = (hb, cwd) => sendHeartbeatViaCli(hb, apiKey, cliPath, cwd);

package/index.ts

@@ -16,6 +16,7 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { fileURLToPath } from "node:url";
 
 import { createSkeleton } from "./hooks/skeleton.js";
 
@@ -36,8 +37,9 @@ import { setupRtk } from "./hooks/rtk.js";
 import { registerPatchTool } from "./tools/patch/index.js";
 import { registerLspTools } from "./tools/lsp/tools.js";
 import { LspServerManager } from "./tools/lsp/manager.js";
+import { collectLspDependencyStatuses } from "./tools/lsp/servers.js";
 import { registerAskTool } from "./tools/ask/index.js";
-import { resolveMcpConfigs, migrateLegacyGlobalMcpConfig } from "./tools/mcp/config.js";
+import { resolveMcpConfigs, migrateLegacyGlobalMcpConfig, collectMcpDependencyStatuses } from "./tools/mcp/config.js";
 import { ensureMcpServerReady } from "./hooks/mcp.js";
 
 import { registerDpModelCommand } from "./commands/dp-model.js";
@@ -65,6 +67,71 @@ const BASE_GUIDANCE = [
   "- CAUTION: Do not perform write operations in the following directories unless explicitly instructed: `node_modules`, `venv`, `env`, `__pycache__`, `.git` or any other hidden directories.",
 ].join("\n");
 
+/** Remove the injected Pi documentation block from the base system prompt.
+ *  Matches a line containing "Pi documentation" and deletes it plus all
+ *  following non-empty lines, stopping at the first blank line. */
+export function stripPiDocsBlock(prompt: string): string {
+  const lines = prompt.split("\n");
+  const out: string[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.includes("Pi documentation")) {
+      i++;
+      while (i < lines.length && lines[i].trim() !== "") i++;
+      // Drop the terminating blank line as well so we don't leave orphan whitespace.
+      if (i < lines.length && lines[i].trim() === "") i++;
+      continue;
+    }
+    out.push(line);
+    i++;
+  }
+  return out.join("\n");
+}
+
+/** Sort the <available_skills> block in the system prompt by skill name.
+ *  Pi core appends extension-provided skills after user/project skills and does
+ *  not sort the XML; this makes the final prompt stable and cache-friendly. */
+export function sortSkillsInSystemPrompt(prompt: string): string {
+  const startMarker = "\n<available_skills>";
+  const endMarker = "</available_skills>";
+  const startIdx = prompt.indexOf(startMarker);
+  if (startIdx === -1) return prompt;
+  const endIdx = prompt.indexOf(endMarker, startIdx);
+  if (endIdx === -1) return prompt;
+
+  const before = prompt.slice(0, startIdx + startMarker.length);
+  const after = prompt.slice(endIdx);
+  const inner = prompt.slice(startIdx + startMarker.length, endIdx);
+
+  const chunks: string[][] = [];
+  let current: string[] = [];
+  for (const line of inner.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "<skill>") {
+      current = [line];
+    } else if (trimmed === "</skill>") {
+      current.push(line);
+      chunks.push(current);
+      current = [];
+    } else if (current.length > 0) {
+      current.push(line);
+    }
+  }
+
+  const nameOf = (chunk: string[]) => {
+    const line = chunk.find((l) => l.trim().startsWith("<name>"));
+    if (!line) return "";
+    const t = line.trim();
+    return t.slice(6, t.indexOf("</name>"));
+  };
+
+  chunks.sort((a, b) => nameOf(a).localeCompare(nameOf(b)));
+
+  const sortedInner = "\n" + chunks.map((chunk) => chunk.join("\n")).join("\n") + "\n";
+  return before + sortedInner + after;
+}
+
 /** Build the list of guideline strings to inject, in prompt order.
  *  Always-on rules first, then per-module guidelines. REDACT_GUIDANCE is
  *  gated by the secretRedaction module; CodeGraph guidance follows the MCP
@@ -80,6 +147,26 @@ function buildGuidelines(): string[] {
   return out;
 }
 
+function canRegisterMcpServer(config: { name: string; command?: string }, deps: Array<{ module: string; state: string }>): boolean {
+  if (!config.command) return true;
+  const dep = deps.find((d) => d.module === `mcp:${config.name}`);
+  return dep ? dep.state === "ok" : true;
+}
+
+/** Absolute path to the plugin's builtin skills directory.
+ *  Used by `resources_discover` so the skill travels with the plugin
+ *  regardless of which project pi is running in. */
+export function getBuiltinSkillPaths(): string[] {
+  return [fileURLToPath(new URL("./skills", import.meta.url))];
+}
+
+/** Register the plugin's builtin skill paths with Pi core. */
+function installBuiltinSkills(pi: ExtensionAPI): void {
+  pi.on("resources_discover", async (_event: any) => ({
+    skillPaths: getBuiltinSkillPaths(),
+  }));
+}
+
 /** Install a single before_agent_start handler that appends every
  *  guideline in order, stripping the volatile "Current date: …" line
  *  for cache stability. Idempotent — re-injection is a no-op via marker. */
@@ -90,7 +177,9 @@ function installGuidelines(pi: ExtensionAPI): void {
 
   pi.on("before_agent_start", async (event: any) => {
     if (!event.systemPrompt) return undefined;
-    let prompt: string = event.systemPrompt.replace(/\nCurrent date: \d{4}-\d{2}-\d{2}/, "");
+    let prompt: string = stripPiDocsBlock(event.systemPrompt);
+    prompt = sortSkillsInSystemPrompt(prompt);
+    prompt = prompt.replace(/\nCurrent date: \d{4}-\d{2}-\d{2}/, "");
     if (prompt.includes(marker)) return undefined; // already injected this turn
     return { systemPrompt: `${prompt}\n\n${joined}` };
   });
@@ -125,12 +214,26 @@ export default async function (pi: ExtensionAPI) {
 
   // Compaction + RTK (these also install their own pi.on via setup<>()).
   setupCompaction(sk);
-  if (isModuleEnabled("rtk")) setupRtk(sk, pi);
+  if (isModuleEnabled("rtk")) setupRtk(sk);
   if (isModuleEnabled("wakatime")) setupWakatime(sk, pi);
 
   // ── Tools (conditional on module switches) ────────────────────────────
   if (isModuleEnabled("patchOverrideEdit")) registerPatchTool(pi);
-  if (isModuleEnabled("lsp")) registerLspTools(pi, new LspServerManager());
+  if (isModuleEnabled("lsp")) {
+    const lspDeps = collectLspDependencyStatuses(process.cwd());
+    if (lspDeps.some((d) => d.state === "ok")) {
+      registerLspTools(pi, new LspServerManager());
+    }
+    for (const dep of lspDeps) {
+      if (dep.state !== "ok") {
+        sk.declareMissing({
+          name: dep.label,
+          module: "lsp",
+          hint: dep.detail,
+        });
+      }
+    }
+  }
   if (isModuleEnabled("ask")) registerAskTool(pi);
 
   // MCP: hook, tools, and /mcp command are gated together. Disabling the
@@ -142,16 +245,31 @@ export default async function (pi: ExtensionAPI) {
     // explicitly here so `loadGlobalMcpConfigs` stays pure.
     migrateLegacyGlobalMcpConfig();
     sk.register(mcpModule);
+    const mcpDeps = collectMcpDependencyStatuses(process.cwd());
+    for (const dep of mcpDeps) {
+      if (dep.state !== "ok") {
+        sk.declareMissing({
+          name: dep.label,  // binary name (e.g. "codegraph")
+          module: "mcp",
+          hint: dep.detail,
+        });
+      }
+    }
     const configs = resolveMcpConfigs(process.cwd()).filter(s => s.enabled);
     // Per-server readiness: cache hit → register from cache (fast).
     // Cache miss → connect synchronously, write cache, then register
     // live tools. This blocks startup only for cache-miss servers.
+    // Skip servers whose binary is missing (dependency not met).
     for (const config of configs) {
+      if (!canRegisterMcpServer(config, mcpDeps)) continue;
       await ensureMcpServerReady(pi, config, process.cwd());
     }
     registerMcpStatusCommand(pi);
   }
 
+  // ── Builtin skills (travel with the plugin in every project) ─────────────
+  installBuiltinSkills(pi);
+
   // ── System-prompt guidelines (single handler, array order = prompt order) ──
   installGuidelines(pi);
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decorated-pi",
-    "version": "0.7.1",
+    "version": "0.7.3",
     "description": "decorated-pi is a practical enhancement pack for pi coding agent — token-efficient workflow, cache-friendly design, and smarter tools.",
     "keywords": [
         "pi",
@@ -14,9 +14,7 @@
         "secret-redaction",
         "codegraph",
         "fff",
-        "smart-at",
-        "fuzzy-search",
-        "file-finder"
+        "fuzzy-search"
     ],
     "license": "MIT",
     "repository": {

package/settings.ts

@@ -7,6 +7,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import type { Model } from "@earendil-works/pi-ai";
+import { which } from "./utils/which.js";
 
 const CONFIG_DIR = path.join(os.homedir(), ".pi", "agent");
 const CONFIG_FILE = path.join(CONFIG_DIR, "decorated-pi.json");
@@ -69,22 +70,55 @@ export interface UsageIndexEntry {
   mtime: number;
 }
 
+/** Per-binary dependency override.
+ *
+ *  Keyed by binary name (e.g. "rtk", "wakatime-cli", "gopls",
+ *  "codegraph"). `path` injects an extra search location into which();
+ *  `dontBother` silences missing-dependency notifications for this binary. */
+export interface DependencySettings {
+  /** Absolute path to the binary (file) or a directory to search. Injected
+   *  into which()'s extendPath, so it's tried before $PATH. */
+  path?: string;
+  /** When true, skeleton's missing-dependency notification skips this
+   *  binary. Use for binaries the user doesn't care about. */
+  dontBother?: boolean;
+}
+
+export interface DependencyView extends DependencySettings {
+  /** Runtime-only shadow value: what the resolver actually found.
+   *  Not persisted to decorated-pi.json and not written by /dp-settings. */
+  resolvedPath?: string;
+  /** Runtime-only shadow value: whether the resolver checked/found it. */
+  resolvedState?: "ok" | "missing";
+}
+
 export interface DecoratedPiConfig {
   imageModelKey?: string | null;
   compactModelKey?: string | null;
+  dependencies?: Record<string, DependencySettings>;
   providers?: Record<string, ProviderCache>;
   modules?: ModuleSettings;
   mcpServers?: Record<string, McpServerEntry>;
   usageIndex?: Record<string, UsageIndexEntry>;
 }
 
+/** Runtime view = real config plus in-memory shadow fields. The shadow has
+ *  the same top-level shape as config, but may enrich selected leaves with
+ *  runtime-only data. It is never persisted and /dp-settings writes only the
+ *  real config through setter functions. */
+export interface DecoratedPiConfigView extends Omit<DecoratedPiConfig, "dependencies"> {
+  dependencies?: Record<string, DependencyView>;
+}
+
 export function loadConfig(): DecoratedPiConfig {
   try {
     if (fs.existsSync(CONFIG_FILE)) {
       const config = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8")) as DecoratedPiConfig;
-      if (migrateModuleSettings(config)) {
-        saveConfig(config);
-      }
+      // Mutate in place. Do NOT call saveConfig here — saveConfig calls
+      // loadConfig first, which would re-trigger the migration (and the
+      // file on disk hasn't been written yet), causing deep recursion.
+      // The migrated shape is persisted on the next explicit saveConfig.
+      migrateModuleSettings(config);
       return config;
     }
   } catch {}
@@ -97,6 +131,11 @@ export function saveConfig(config: Partial<DecoratedPiConfig>) {
   fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...config }, null, 2), "utf-8");
 }
 
+// Runtime-only shadow for the whole config. It mirrors DecoratedPiConfig's
+// top-level shape but is never persisted; runtime modules update it, and
+// /dp-settings reads the merged view for display only.
+const configShadow: DecoratedPiConfigView = {};
+
 // ─── 辅助 ──────────────────────────────────────────────────────────────────
 
 export function formatModelKey(m: Model<any>): string {
@@ -163,6 +202,77 @@ export function getCompactModelKey(): string | null {
   return loadConfig().compactModelKey ?? null;
 }
 
+/** Look up a binary's configured path override. Returns null when not set. */
+export function getDependencyPath(name: string): string | null {
+  return loadConfig().dependencies?.[name]?.path ?? null;
+}
+
+/** Whether missing-dependency notifications are silenced for this binary. */
+export function isDontBother(name: string): boolean {
+  return loadConfig().dependencies?.[name]?.dontBother === true;
+}
+
+export function getConfigView(): DecoratedPiConfigView {
+  const real = loadConfig();
+  const dependencyNames = new Set([
+    ...Object.keys(real.dependencies ?? {}),
+    ...Object.keys(configShadow.dependencies ?? {}),
+  ]);
+  const dependencies: Record<string, DependencyView> = {};
+  for (const name of dependencyNames) {
+    dependencies[name] = {
+      ...(real.dependencies?.[name] ?? {}),
+      ...(configShadow.dependencies?.[name] ?? {}),
+    };
+  }
+  return {
+    ...real,
+    ...configShadow,
+    dependencies: Object.keys(dependencies).length ? dependencies : undefined,
+  };
+}
+
+export function getDependencyView(name: string): DependencyView {
+  return getConfigView().dependencies?.[name] ?? {};
+}
+
+export function listDependencyViewNames(extraNames: string[] = []): string[] {
+  return [...new Set([
+    ...extraNames,
+    ...Object.keys(getConfigView().dependencies ?? {}),
+  ])].sort();
+}
+
+export function recordDependencyResolution(name: string, resolvedPath: string | null): void {
+  if (!configShadow.dependencies) configShadow.dependencies = {};
+  configShadow.dependencies[name] = {
+    ...(configShadow.dependencies[name] ?? {}),
+    ...(resolvedPath
+      ? { resolvedState: "ok" as const, resolvedPath }
+      : { resolvedState: "missing" as const, resolvedPath: undefined }),
+  };
+}
+
+/** Resolve a binary using dependency config plus caller-specific search
+ *  locations. Modules call this at startup/runtime; it records a shadow
+ *  view for /dp-settings but does not persist anything.
+ *
+ *  Order:
+ *    1. dependencies[name].path (file or directory)
+ *    2. opts.extendPath entries (file or directory)
+ *    3. $PATH
+ */
+export function resolveDependency(name: string, opts?: { extendPath?: string[] }): string | null {
+  const override = getDependencyPath(name);
+  const extendPath = [
+    ...(override ? [override] : []),
+    ...(opts?.extendPath ?? []),
+  ];
+  const resolved = which(name, { extendPath });
+  recordDependencyResolution(name, resolved);
+  return resolved;
+}
+
 // ─── Setter ─────────────────────────────────────────────────────────────────
 
 export function setImageModelKey(key: string | null) {
@@ -173,6 +283,47 @@ export function setCompactModelKey(key: string | null) {
   saveConfig({ compactModelKey: key });
 }
 
+/** Set or clear a binary's path override. Pass null to remove the path.
+ *  Preserves any dontBother flag on the same entry (精准修改不覆盖). */
+export function setDependencyPath(name: string, path: string | null) {
+  const current = loadConfig();
+  const deps = { ...(current.dependencies ?? {}) };
+  const existing = deps[name] ?? {};
+  if (path === null) {
+    const { path: _drop, ...rest } = existing;
+    if (Object.keys(rest).length === 0) {
+      delete deps[name];
+    } else {
+      deps[name] = rest;
+    }
+  } else {
+    deps[name] = { ...existing, path };
+  }
+  // Path edits are config writes; invalidate runtime-only resolution for
+  // this binary so /dp-settings never shows a stale pre-edit shadow path.
+  if (configShadow.dependencies?.[name]) delete configShadow.dependencies[name];
+  saveConfig({ dependencies: deps });
+}
+
+/** Set or clear a binary's dontBother flag. Pass false to re-enable
+ *  missing-dependency notifications. Preserves any path override. */
+export function setDontBother(name: string, dontBother: boolean) {
+  const current = loadConfig();
+  const deps = { ...(current.dependencies ?? {}) };
+  const existing = deps[name] ?? {};
+  if (dontBother) {
+    deps[name] = { ...existing, dontBother: true };
+  } else {
+    const { dontBother: _drop, ...rest } = existing;
+    if (Object.keys(rest).length === 0) {
+      delete deps[name];
+    } else {
+      deps[name] = rest;
+    }
+  }
+  saveConfig({ dependencies: deps });
+}
+
 // ─── Module Switches ──────────────────────────────────────────────────────────
 
 const DEFAULT_MODULES: Required<ModuleSettings> = {
@@ -319,14 +470,23 @@ export function getAllModuleSettings(): Required<ModuleSettings> {
  * reload is actually necessary.
  */
 let loadedModuleSnapshot: Required<ModuleSettings> | null = null;
+let loadedDependenciesSnapshot: Record<string, DependencySettings> | null = null;
 
 export function captureModuleSnapshot(): void {
   loadedModuleSnapshot = getAllModuleSettings();
+  loadedDependenciesSnapshot = loadConfig().dependencies ?? {};
 }
 
 export function moduleSnapshotChanged(): boolean {
   if (!loadedModuleSnapshot) return true;
-  return JSON.stringify(loadedModuleSnapshot) !== JSON.stringify(getAllModuleSettings());
+  if (JSON.stringify(loadedModuleSnapshot) !== JSON.stringify(getAllModuleSettings())) return true;
+  // Dependencies changes don't strictly require reload (which() reads the
+  // config file on every call), but prompt for consistency — the user
+  // might be mid-session and expect the new path to be picked up by hooks
+  // that captured the binary path at startup (rtk/wakatime).
+  const currentDeps = loadConfig().dependencies ?? {};
+  if (JSON.stringify(loadedDependenciesSnapshot) !== JSON.stringify(currentDeps)) return true;
+  return false;
 }
 
 // ─── Usage index (增量同步元数据) ─────────────────────────────────────────────

package/skills/pi-docs/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: pi-docs
+description: pi docs resources
+---
+
+Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
+- Main documentation: /home/liuchang/.local/share/fnm/node-versions/v24.14.0/installation/lib/node_modules/@earendil-works/pi-coding-agent/README.md
+- Additional docs: /home/liuchang/.local/share/fnm/node-versions/v24.14.0/installation/lib/node_modules/@earendil-works/pi-coding-agent/docs
+- Examples: /home/liuchang/.local/share/fnm/node-versions/v24.14.0/installation/lib/node_modules/@earendil-works/pi-coding-agent/examples (extensions, custom tools, SDK)
+- When reading pi docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory
+- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md)
+- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing
+- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)

package/tools/ask/index.ts

@@ -19,9 +19,6 @@ const askQuestionSchema = Type.Object({
   question: Type.String({ description: "Question text shown to the user." }),
   options: Type.Optional(Type.Array(Type.String(), { description: "Options for single or multi choice." })),
   default: Type.Optional(Type.String({ description: "Default answer. For multi, comma-separated values." })),
-  allowCustom: Type.Optional(Type.Boolean({
-    description: "For single/multi: append an \"Other\" row that toggles into a free-text input. Lets the user enter a custom answer not in the preset list.",
-  })),
 });
 
 function formatAnswer(q: AskQuestion, value: string | string[]): string {