jinzd-ai-cli 0.4.216 → 0.4.218

package/dist/{chunk-TCOC4AUI.js → chunk-GX3HSGJX.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-T2NL5ZIA.js";
 import {
   runTestsTool
-} from "./chunk-VW7Y27WW.js";
+} from "./chunk-VGFTM3XT.js";
 import {
   runTool
-} from "./chunk-77HDCGTN.js";
+} from "./chunk-MWKE2TNS.js";
 import {
   getDangerLevel,
   isFileWriteTool,
@@ -23,10 +23,16 @@ import {
   CONFIG_DIR_NAME,
   DEFAULT_MAX_TOOL_OUTPUT_CHARS_CAP,
   MEMORY_FILE_NAME,
+  MEMORY_MAX_CHARS,
+  MEMORY_STORE_FILE_NAME,
+  PLUGINS_DIR_NAME,
   SUBAGENT_ALLOWED_TOOLS,
   SUBAGENT_DEFAULT_MAX_ROUNDS,
   SUBAGENT_MAX_ROUNDS_LIMIT
-} from "./chunk-7YWS3JLU.js";
+} from "./chunk-NTCB7CMT.js";
+import {
+  getGitRoot
+} from "./chunk-HOSJZMQS.js";
 import {
   fileCheckpoints
 } from "./chunk-4BKXL7SM.js";
@@ -34,6 +40,10 @@ import {
   loadChatIndex,
   searchChatMemory
 } from "./chunk-TB4W4Y4T.js";
+import {
+  DEFAULT_PATTERNS,
+  redactString
+} from "./chunk-SLSWPBK3.js";
 import {
   indexProject
 } from "./chunk-K3CF65QH.js";
@@ -44,14 +54,295 @@ import {
   atomicWriteFileSync
 } from "./chunk-IW3Q7AE5.js";
 
+// src/plugins/plugin-manager.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, cpSync, rmSync, statSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+import { createHash } from "crypto";
+import { z } from "zod";
+var MANIFEST_RELATIVE = ".aicli-plugin/plugin.json";
+var STATE_FILE = "plugin-state.json";
+var HookCommandSchema = z.union([
+  z.string(),
+  z.object({
+    command: z.string(),
+    source: z.enum(["user", "project", "managed"]).optional(),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+    timeoutMs: z.number().int().min(100).max(3e4).optional(),
+    disabled: z.boolean().optional()
+  }),
+  z.array(z.union([
+    z.string(),
+    z.object({
+      command: z.string(),
+      source: z.enum(["user", "project", "managed"]).optional(),
+      description: z.string().optional(),
+      required: z.boolean().optional(),
+      timeoutMs: z.number().int().min(100).max(3e4).optional(),
+      disabled: z.boolean().optional()
+    })
+  ]))
+]);
+var HookEventNameSchema = z.enum([
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PermissionRequest",
+  "PostToolUse",
+  "PreCompact",
+  "PostCompact",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop"
+]);
+var McpServerSchema = z.object({
+  command: z.string(),
+  args: z.array(z.string()).default([]),
+  env: z.record(z.string()).optional(),
+  timeout: z.number().default(3e4)
+});
+var PluginManifestSchema = z.object({
+  name: z.string().regex(/^[a-zA-Z0-9._-]{1,80}$/),
+  version: z.string().min(1),
+  description: z.string().optional(),
+  skills: z.array(z.string()).default([]),
+  hooks: z.object({
+    enabled: z.boolean().optional(),
+    events: z.record(HookEventNameSchema, HookCommandSchema).default({})
+  }).default({ events: {} }),
+  commands: z.array(z.string()).default([]),
+  mcpServers: z.record(McpServerSchema).default({}),
+  agents: z.array(z.string()).default([]),
+  permissionHints: z.array(z.string()).default([])
+}).strict();
+function pluginRoot(configDir) {
+  return join(configDir, PLUGINS_DIR_NAME);
+}
+function pluginManifestPath(pluginDir) {
+  return join(pluginDir, MANIFEST_RELATIVE);
+}
+function statePath(configDir) {
+  return join(pluginRoot(configDir), STATE_FILE);
+}
+function loadState(configDir) {
+  const file = statePath(configDir);
+  if (!existsSync(file)) return { version: 1, plugins: [] };
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf-8"));
+    return { version: 1, plugins: Array.isArray(parsed.plugins) ? parsed.plugins : [] };
+  } catch {
+    return { version: 1, plugins: [] };
+  }
+}
+function saveState(configDir, state) {
+  mkdirSync(pluginRoot(configDir), { recursive: true });
+  atomicWriteFileSync(statePath(configDir), JSON.stringify(state, null, 2));
+}
+function hashPluginManifest(manifestPath) {
+  return createHash("sha256").update(readFileSync(manifestPath)).digest("hex");
+}
+function readPluginManifest(manifestPath) {
+  return PluginManifestSchema.parse(JSON.parse(readFileSync(manifestPath, "utf-8")));
+}
+function findPluginSourceDir(inputPath) {
+  const abs = resolve(inputPath);
+  const direct = statSync(abs).isDirectory() ? abs : dirname(abs);
+  if (existsSync(pluginManifestPath(direct))) return direct;
+  const nested = join(direct, ".aicli-plugin");
+  if (existsSync(join(nested, "plugin.json"))) return direct;
+  throw new Error(`plugin manifest not found: ${MANIFEST_RELATIVE}`);
+}
+function installPlugin(configDir, inputPath) {
+  const sourceDir = findPluginSourceDir(inputPath);
+  const manifest = readPluginManifest(pluginManifestPath(sourceDir));
+  const targetDir = join(pluginRoot(configDir), manifest.name);
+  mkdirSync(pluginRoot(configDir), { recursive: true });
+  if (existsSync(targetDir)) rmSync(targetDir, { recursive: true, force: true });
+  cpSync(sourceDir, targetDir, { recursive: true });
+  const manifestPath = pluginManifestPath(targetDir);
+  const hash = hashPluginManifest(manifestPath);
+  const state = loadState(configDir);
+  const previous = state.plugins.find((p) => p.name === manifest.name);
+  const next = {
+    name: manifest.name,
+    enabled: previous?.enabled ?? false,
+    trusted: false,
+    hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  state.plugins = [...state.plugins.filter((p) => p.name !== manifest.name), next];
+  saveState(configDir, state);
+  return { name: manifest.name, dir: targetDir, manifestPath, manifest, hash, enabled: next.enabled, trusted: false, valid: true };
+}
+function setPluginEnabled(configDir, name, enabled) {
+  const plugin = getInstalledPlugin(configDir, name);
+  if (!plugin.valid) throw new Error(plugin.error ?? `invalid plugin: ${name}`);
+  const state = loadState(configDir);
+  const current = state.plugins.find((p) => p.name === plugin.name) ?? {
+    name: plugin.name,
+    enabled: false,
+    trusted: false,
+    hash: plugin.hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const next = { ...current, enabled, hash: plugin.hash, enabledAt: enabled ? (/* @__PURE__ */ new Date()).toISOString() : current.enabledAt };
+  state.plugins = [...state.plugins.filter((p) => p.name !== plugin.name), next];
+  saveState(configDir, state);
+  return next;
+}
+function trustPlugin(configDir, name) {
+  const plugin = getInstalledPlugin(configDir, name);
+  if (!plugin.valid) throw new Error(plugin.error ?? `invalid plugin: ${name}`);
+  const state = loadState(configDir);
+  const current = state.plugins.find((p) => p.name === plugin.name) ?? {
+    name: plugin.name,
+    enabled: false,
+    trusted: false,
+    hash: plugin.hash,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const next = { ...current, trusted: true, hash: plugin.hash, trustedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  state.plugins = [...state.plugins.filter((p) => p.name !== plugin.name), next];
+  saveState(configDir, state);
+  return next;
+}
+function getInstalledPlugin(configDir, name) {
+  const plugins = listInstalledPlugins(configDir);
+  const matches = plugins.filter((p) => p.name === name || p.name.startsWith(name));
+  if (matches.length === 0) throw new Error(`plugin not found: ${name}`);
+  if (matches.length > 1) throw new Error(`plugin name is ambiguous: ${name}`);
+  return matches[0];
+}
+function listInstalledPlugins(configDir) {
+  const root = pluginRoot(configDir);
+  if (!existsSync(root)) return [];
+  const state = loadState(configDir);
+  const out = [];
+  for (const entry of readdirSync(root)) {
+    const dir = join(root, entry);
+    try {
+      if (!statSync(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const manifestPath = pluginManifestPath(dir);
+    if (!existsSync(manifestPath)) continue;
+    try {
+      const manifest = readPluginManifest(manifestPath);
+      const hash = hashPluginManifest(manifestPath);
+      const st = state.plugins.find((p) => p.name === manifest.name);
+      const trusted = st?.trusted === true && st.hash === hash;
+      out.push({
+        name: manifest.name,
+        dir,
+        manifestPath,
+        manifest,
+        hash,
+        enabled: st?.enabled === true,
+        trusted,
+        valid: true
+      });
+    } catch (err) {
+      out.push({
+        name: entry,
+        dir,
+        manifestPath,
+        manifest: { name: entry, version: "invalid", skills: [], commands: [], agents: [], hooks: { events: {} }, mcpServers: {}, permissionHints: [] },
+        hash: "",
+        enabled: false,
+        trusted: false,
+        valid: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function activePlugins(configDir) {
+  return listInstalledPlugins(configDir).filter((p) => p.valid && p.enabled && p.trusted);
+}
+function uniqueDirs(plugin, rels) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const rel of rels) {
+    const abs = resolve(plugin.dir, rel);
+    if (!abs.startsWith(resolve(plugin.dir))) continue;
+    if (existsSync(abs)) dirs.add(statSync(abs).isDirectory() ? abs : dirname(abs));
+  }
+  return [...dirs];
+}
+function prefixCommand(plugin, command) {
+  return command.replaceAll("{pluginDir}", plugin.dir).replaceAll("$PLUGIN_DIR", plugin.dir);
+}
+function pluginHooks(plugin) {
+  const events = plugin.manifest.hooks?.events ?? {};
+  const out = {};
+  for (const [event, raw] of Object.entries(events)) {
+    const normalize = (item) => {
+      if (typeof item === "string") return { command: prefixCommand(plugin, item), source: "project", description: `plugin:${plugin.name}` };
+      if (item && typeof item === "object") {
+        const obj = item;
+        return { ...obj, command: prefixCommand(plugin, String(obj.command ?? "")), source: "project", description: obj.description ?? `plugin:${plugin.name}` };
+      }
+      return item;
+    };
+    out[event] = Array.isArray(raw) ? raw.map(normalize) : normalize(raw);
+  }
+  return Object.keys(out).length > 0 ? { enabled: plugin.manifest.hooks?.enabled ?? true, events: out } : void 0;
+}
+function mergePluginHooks(base, configDir) {
+  const plugins = activePlugins(configDir);
+  if (plugins.length === 0) return base;
+  const merged = { ...base ?? {}, enabled: base?.enabled ?? true, events: { ...base?.events ?? {} } };
+  for (const plugin of plugins) {
+    const hooks = pluginHooks(plugin);
+    if (!hooks?.events) continue;
+    for (const [event, entry] of Object.entries(hooks.events)) {
+      const key = event;
+      const existing = merged.events?.[key];
+      const existingItems = existing === void 0 ? [] : Array.isArray(existing) ? existing : [existing];
+      const newItems = Array.isArray(entry) ? entry : [entry];
+      merged.events[key] = [...existingItems, ...newItems];
+    }
+  }
+  return merged;
+}
+function getActivePluginAssets(configDir) {
+  const plugins = activePlugins(configDir);
+  const mcpServers = {};
+  const skillDirs = [];
+  const commandDirs = [];
+  const agentDirs = [];
+  for (const plugin of plugins) {
+    skillDirs.push(...uniqueDirs(plugin, plugin.manifest.skills));
+    commandDirs.push(...uniqueDirs(plugin, plugin.manifest.commands));
+    agentDirs.push(...uniqueDirs(plugin, plugin.manifest.agents));
+    for (const [serverName, server] of Object.entries(plugin.manifest.mcpServers)) {
+      mcpServers[`plugin_${plugin.name}_${serverName}`] = server;
+    }
+  }
+  return { plugins, skillDirs, commandDirs, agentDirs, hooks: mergePluginHooks(void 0, configDir), mcpServers };
+}
+function describePlugin(plugin) {
+  const m = plugin.manifest;
+  return [
+    `${plugin.name}@${m.version}`,
+    `  status: ${plugin.enabled ? "enabled" : "disabled"} \xB7 ${plugin.trusted ? "trusted" : "untrusted"}${plugin.valid ? "" : " \xB7 invalid"}`,
+    `  dir: ${plugin.dir}`,
+    m.description ? `  description: ${m.description}` : void 0,
+    `  assets: ${m.skills.length} skill(s), ${m.commands.length} command(s), ${m.agents.length} agent(s), ${Object.keys(m.mcpServers).length} MCP server(s), ${Object.keys(m.hooks?.events ?? {}).length} hook event(s)`,
+    m.permissionHints.length ? `  permission hints: ${m.permissionHints.join("; ")}` : void 0,
+    plugin.error ? `  error: ${plugin.error}` : void 0
+  ].filter((line) => Boolean(line));
+}
+
 // src/tools/builtin/bash.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { platform as platform2 } from "os";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 
 // src/tools/undo-stack.ts
-import { readFileSync, writeFileSync, unlinkSync, rmdirSync, existsSync } from "fs";
+import { readFileSync as readFileSync2, writeFileSync, unlinkSync, rmdirSync, existsSync as existsSync2 } from "fs";
 var MAX_UNDO_DEPTH = 20;
 var UndoStack = class {
   stack = [];
@@ -62,9 +353,9 @@ var UndoStack = class {
    */
   push(filePath, description) {
     let previousContent = null;
-    if (existsSync(filePath)) {
+    if (existsSync2(filePath)) {
       try {
-        previousContent = readFileSync(filePath, "utf-8");
+        previousContent = readFileSync2(filePath, "utf-8");
       } catch {
         return;
       }
@@ -118,7 +409,7 @@ var UndoStack = class {
     try {
       if (entry.previousContent === null) {
         if (entry.isDirectory) {
-          if (existsSync(entry.filePath)) {
+          if (existsSync2(entry.filePath)) {
             try {
               rmdirSync(entry.filePath);
               return { entry, result: `Removed newly created directory: ${entry.filePath}` };
@@ -128,7 +419,7 @@ var UndoStack = class {
           }
           return { entry, result: `Directory already removed: ${entry.filePath}` };
         } else {
-          if (existsSync(entry.filePath)) {
+          if (existsSync2(entry.filePath)) {
             unlinkSync(entry.filePath);
           }
           return { entry, result: `Deleted newly created file: ${entry.filePath}` };
@@ -287,7 +578,7 @@ Important rules:
       throw new ToolError("bash", blockingHint);
     }
     let currentCwd = getCwd();
-    if (!existsSync2(currentCwd)) {
+    if (!existsSync3(currentCwd)) {
       const fallback = process.cwd();
       process.stderr.write(
         `[bash] Previous cwd "${currentCwd}" no longer exists, reset to "${fallback}"
@@ -298,8 +589,8 @@ Important rules:
     }
     let effectiveCwd = currentCwd;
     if (cwdArg) {
-      const resolved = resolve(currentCwd, cwdArg);
-      if (!existsSync2(resolved)) {
+      const resolved = resolve2(currentCwd, cwdArg);
+      if (!existsSync3(resolved)) {
         throw new ToolError(
           "bash",
           `cwd directory does not exist: "${resolved}". Create it first (e.g. mkdir -p "${resolved}") before specifying it as cwd.`
@@ -319,7 +610,7 @@ Important rules:
     const parsedTargets = parseCreationTargets(command, effectiveCwd);
     const parsedTargetsBefore = /* @__PURE__ */ new Map();
     for (const t of parsedTargets) {
-      parsedTargetsBefore.set(t, existsSync2(t));
+      parsedTargetsBefore.set(t, existsSync3(t));
     }
     try {
       const { stdout, stderr, status, signal, timedOut, aborted } = await runShell(
@@ -499,7 +790,7 @@ Then poll readiness with SHORT bash calls (these DO exit), e.g.:
 }
 function snapshotDir(dir) {
   try {
-    return new Set(readdirSync(dir).map((name) => resolve(dir, name)));
+    return new Set(readdirSync2(dir).map((name) => resolve2(dir, name)));
   } catch {
     return /* @__PURE__ */ new Set();
   }
@@ -507,25 +798,25 @@ function snapshotDir(dir) {
 function parseCreationTargets(command, cwd) {
   const targets = [];
   for (const m of command.matchAll(/(?:echo|cat|printf)\s+[^>]*>\s*(['"]?)([^\s;&|'"]+)\1/g)) {
-    if (m[2]) targets.push(resolve(cwd, m[2]));
+    if (m[2]) targets.push(resolve2(cwd, m[2]));
   }
   for (const m of command.matchAll(/\btouch\s+((?:['"]?[^\s;&|'"]+['"]?\s*)+)/g)) {
     for (const f of m[1].trim().split(/\s+/)) {
       const clean = f.replace(/^['"]|['"]$/g, "");
-      if (clean && !clean.startsWith("-")) targets.push(resolve(cwd, clean));
+      if (clean && !clean.startsWith("-")) targets.push(resolve2(cwd, clean));
     }
   }
   for (const m of command.matchAll(/\bmkdir\s+(?:-\w+\s+)*((?:['"]?[^\s;&|'"]+['"]?\s*)+)/g)) {
     for (const d of m[1].trim().split(/\s+/)) {
       const clean = d.replace(/^['"]|['"]$/g, "");
-      if (clean && !clean.startsWith("-")) targets.push(resolve(cwd, clean));
+      if (clean && !clean.startsWith("-")) targets.push(resolve2(cwd, clean));
     }
   }
   for (const m of command.matchAll(/\bcp\s+(?:-\w+\s+)*['"]?[^\s;&|'"]+['"]?\s+(['"]?)([^\s;&|'"]+)\1/g)) {
-    if (m[2]) targets.push(resolve(cwd, m[2]));
+    if (m[2]) targets.push(resolve2(cwd, m[2]));
   }
   for (const m of command.matchAll(/\bNew-Item\s+(?:-(?:Path|ItemType)\s+\w+\s+)*['"]?([^\s;&|'"]+)['"]?/gi)) {
-    if (m[1] && !m[1].startsWith("-")) targets.push(resolve(cwd, m[1]));
+    if (m[1] && !m[1].startsWith("-")) targets.push(resolve2(cwd, m[1]));
   }
   return [...new Set(targets)];
 }
@@ -535,7 +826,7 @@ function pushBashUndoEntries(beforeSnapshot, parsedTargetsBefore, cwd) {
   for (const absPath of afterSnapshot) {
     if (!beforeSnapshot.has(absPath)) {
       try {
-        const st = statSync(absPath);
+        const st = statSync2(absPath);
         if (st.isDirectory()) {
           undoStack.pushNewDir(absPath, `bash (new dir): ${absPath}`);
         } else {
@@ -547,9 +838,9 @@ function pushBashUndoEntries(beforeSnapshot, parsedTargetsBefore, cwd) {
     }
   }
   for (const [target, existedBefore] of parsedTargetsBefore) {
-    if (!existedBefore && !tracked.has(target) && existsSync2(target)) {
+    if (!existedBefore && !tracked.has(target) && existsSync3(target)) {
       try {
-        const st = statSync(target);
+        const st = statSync2(target);
         if (st.isDirectory()) {
           undoStack.pushNewDir(target, `bash (new dir): ${target}`);
         } else {
@@ -659,8 +950,8 @@ function updateCwdFromCommand(command, baseCwd) {
   const target = lastMatch?.[2];
   if (!target || target.startsWith("$") || target === "~") return;
   try {
-    const newDir = resolve(baseCwd, target);
-    if (existsSync2(newDir)) {
+    const newDir = resolve2(baseCwd, target);
+    if (existsSync3(newDir)) {
       setCwd(newDir);
     }
   } catch {
@@ -668,9 +959,9 @@ function updateCwdFromCommand(command, baseCwd) {
 }
 
 // src/tools/builtin/read-file.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, statSync as statSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync3, readdirSync as readdirSync3 } from "fs";
 import { execFileSync } from "child_process";
-import { extname, resolve as resolve2, basename, sep, dirname } from "path";
+import { extname, resolve as resolve3, basename as basename2, sep, dirname as dirname2 } from "path";
 import { homedir } from "os";
 
 // src/tools/builtin/notebook-utils.ts
@@ -780,7 +1071,7 @@ var MAX_FILE_BYTES = 10 * 1024 * 1024;
 function getHardRefusal(normalizedPath) {
   const home2 = homedir();
   const p = normalizedPath.toLowerCase();
-  const base = basename(normalizedPath).toLowerCase();
+  const base = basename2(normalizedPath).toLowerCase();
   if (normalizedPath.startsWith(home2) && p.includes(".aicli") && base === "config.json") {
     return `[Refused] Reading ${normalizedPath} is blocked because it contains all of your provider API keys.
 If you genuinely need to inspect or edit it, open it manually outside ai-cli (e.g. via your editor).
@@ -794,7 +1085,7 @@ For programmatic access, use \`aicli config\` or \`aicli config get <key>\` whic
 function getSensitiveWarning(normalizedPath) {
   const home2 = homedir();
   const p = normalizedPath.toLowerCase();
-  const base = basename(normalizedPath).toLowerCase();
+  const base = basename2(normalizedPath).toLowerCase();
   if (normalizedPath.startsWith(home2) && p.includes(".aicli") && base === "config.json") {
     return "[\u26A0 Security Warning: This file contains API keys. Be careful not to share this content.]\n\n";
   }
@@ -857,19 +1148,19 @@ function isBinaryBuffer(buf) {
   return nullCount / sample.length > 0.1;
 }
 function findSimilarFiles(filePath) {
-  const targetName = basename(filePath).toLowerCase();
+  const targetName = basename2(filePath).toLowerCase();
   if (!targetName) return [];
   const cwd = process.cwd();
   const candidates = [];
   try {
-    for (const entry of readdirSync2(cwd, { withFileTypes: true })) {
+    for (const entry of readdirSync3(cwd, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.toLowerCase() === targetName) {
         candidates.push(entry.name);
       }
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         try {
-          const subDir = resolve2(cwd, entry.name);
-          for (const sub of readdirSync2(subDir, { withFileTypes: true })) {
+          const subDir = resolve3(cwd, entry.name);
+          for (const sub of readdirSync3(subDir, { withFileTypes: true })) {
             if (sub.isFile() && sub.name.toLowerCase() === targetName) {
               candidates.push(`${entry.name}/${sub.name}`);
             }
@@ -942,10 +1233,10 @@ var readFileTool = {
     const offsetLine = typeof rawOffset === "number" && Number.isFinite(rawOffset) && rawOffset > 0 ? Math.floor(rawOffset) : void 0;
     const limitLines = typeof rawLimit === "number" && Number.isFinite(rawLimit) && rawLimit > 0 ? Math.floor(rawLimit) : void 0;
     if (!filePath) throw new ToolError("read_file", "path is required");
-    const normalizedPath = resolve2(filePath);
+    const normalizedPath = resolve3(filePath);
     const refusal = getHardRefusal(normalizedPath);
     if (refusal) return refusal;
-    if (!existsSync3(normalizedPath)) {
+    if (!existsSync4(normalizedPath)) {
       const suggestions = findSimilarFiles(filePath);
       if (suggestions.length > 0) {
         throw new ToolError(
@@ -964,7 +1255,7 @@ Current working directory: ${process.cwd()}
 Please use list_dir to verify the file path and retry.`
       );
     }
-    const { size } = statSync2(normalizedPath);
+    const { size } = statSync3(normalizedPath);
     if (size > MAX_FILE_BYTES) {
       const mb = (size / 1024 / 1024).toFixed(1);
       return `[File too large: ${filePath} (${mb} MB)]
@@ -984,13 +1275,13 @@ Use the bash tool to read in segments, e.g.:
 
 ${pdfText}`;
       }
-      const dir = dirname(normalizedPath);
-      const nameNoExt = basename(normalizedPath, ext);
-      const textAlts = [".md", ".txt", ".html"].map((e) => resolve2(dir, nameNoExt + e)).filter(existsSync3);
+      const dir = dirname2(normalizedPath);
+      const nameNoExt = basename2(normalizedPath, ext);
+      const textAlts = [".md", ".txt", ".html"].map((e) => resolve3(dir, nameNoExt + e)).filter(existsSync4);
       if (textAlts.length > 0) {
         return `[PDF file: ${filePath}]
 Cannot extract text from this PDF, but found alternative text versions:
-` + textAlts.map((p) => `  \u2192 ${basename(p)}`).join("\n") + `
+` + textAlts.map((p) => `  \u2192 ${basename2(p)}`).join("\n") + `
 Please use read_file to read the above files.`;
       }
       return `[PDF file: ${filePath}]
@@ -999,7 +1290,7 @@ Suggestion: read existing text versions (.md / .txt) in the project, or install
     }
     if (ext === ".ipynb") {
       try {
-        const raw = readFileSync2(normalizedPath, "utf-8");
+        const raw = readFileSync3(normalizedPath, "utf-8");
         const nb = parseNotebook(raw);
         return renderNotebookAsText(nb, filePath);
       } catch (err) {
@@ -1012,7 +1303,7 @@ ${err.message}`;
 This is a binary file and cannot be read as text. If there is a text version (.md / .txt) in the project, please read that instead.`;
     }
     const { readFile: readFile2 } = await import("fs/promises");
-    const buf = size > 1048576 ? await readFile2(normalizedPath) : readFileSync2(normalizedPath);
+    const buf = size > 1048576 ? await readFile2(normalizedPath) : readFileSync3(normalizedPath);
     if (encoding === "base64") {
       return `[File: ${filePath} | base64]
 
@@ -1050,12 +1341,12 @@ ${content}`;
 };
 
 // src/tools/builtin/write-file.ts
-import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
+import { appendFileSync, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname3 } from "path";
 
 // src/tools/executor.ts
 import chalk3 from "chalk";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
 import { tmpdir } from "os";
 
 // src/core/readline-internal.ts
@@ -1263,9 +1554,9 @@ function simpleDiff(oldLines, newLines) {
 
 // src/tools/hooks.ts
 import { execSync } from "child_process";
-import { createHash } from "crypto";
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3 } from "fs";
-import { join } from "path";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
+import { join as join2 } from "path";
 var TRUST_FILE = "hooks-trust.json";
 var DEFAULT_TIMEOUT_MS = 5e3;
 function asArray(entry) {
@@ -1274,24 +1565,24 @@ function asArray(entry) {
   return raw.map((item) => typeof item === "string" ? { command: item } : item);
 }
 function hookTrustPath(configDir) {
-  return join(configDir, TRUST_FILE);
+  return join2(configDir, TRUST_FILE);
 }
 function loadHookTrustStore(configDir) {
   const file = hookTrustPath(configDir);
-  if (!existsSync4(file)) return { records: [] };
+  if (!existsSync5(file)) return { records: [] };
   try {
-    const parsed = JSON.parse(readFileSync3(file, "utf-8"));
+    const parsed = JSON.parse(readFileSync4(file, "utf-8"));
     return { records: Array.isArray(parsed.records) ? parsed.records : [] };
   } catch {
     return { records: [] };
   }
 }
 function saveHookTrustStore(configDir, store) {
-  mkdirSync(configDir, { recursive: true });
+  mkdirSync2(configDir, { recursive: true });
   atomicWriteFileSync(hookTrustPath(configDir), JSON.stringify(store, null, 2));
 }
 function hashHook(event, command) {
-  return createHash("sha256").update(`${event}
+  return createHash2("sha256").update(`${event}
 ${command}`, "utf-8").digest("hex");
 }
 function isTrusted(source, event, hash, store) {
@@ -1440,7 +1731,7 @@ function runHook(template, vars) {
 }
 
 // src/tools/permissions.ts
-import { isAbsolute, resolve as resolve3 } from "path";
+import { isAbsolute, resolve as resolve4 } from "path";
 function checkPermission(toolName, args, dangerLevel, rules, defaultAction = "confirm") {
   for (const rule of rules) {
     if (rule.tool !== "*" && rule.tool !== toolName) continue;
@@ -1486,8 +1777,8 @@ function normalizePathForPermission(value) {
   return value.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
 }
 function isInsidePath(root, target) {
-  const absoluteTarget = isAbsolute(target) ? target : resolve3(root, target);
-  const r = normalizePathForPermission(resolve3(root));
+  const absoluteTarget = isAbsolute(target) ? target : resolve4(root, target);
+  const r = normalizePathForPermission(resolve4(root));
   const t = normalizePathForPermission(absoluteTarget);
   return t === r || t.startsWith(`${r}/`);
 }
@@ -1861,8 +2152,8 @@ var theme = new Proxy(DARK_THEME, {
 });
 
 // src/tools/action-classifier.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { isAbsolute as isAbsolute2, join as join2, resolve as resolve4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { isAbsolute as isAbsolute2, join as join3, resolve as resolve5 } from "path";
 var RECENT_DENIED_LIMIT = 50;
 var recentlyDenied = [];
 function recordRecentlyDeniedAutoAction(call, classification) {
@@ -1885,8 +2176,8 @@ function normalizePath(value) {
   return value.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
 }
 function isInside(root, target) {
-  const absoluteRoot = resolve4(root);
-  const absoluteTarget = isAbsolute2(target) ? target : resolve4(root, target);
+  const absoluteRoot = resolve5(root);
+  const absoluteTarget = isAbsolute2(target) ? target : resolve5(root, target);
   const base = normalizePath(absoluteRoot);
   const t = normalizePath(absoluteTarget);
   return t === base || t.startsWith(base + "/");
@@ -1903,10 +2194,10 @@ function splitShellWords(command) {
   return out.filter(Boolean);
 }
 function readPackageManifest(root) {
-  const p = join2(root, "package.json");
-  if (!existsSync5(p)) return null;
+  const p = join3(root, "package.json");
+  if (!existsSync6(p)) return null;
   try {
-    return JSON.parse(readFileSync4(p, "utf-8"));
+    return JSON.parse(readFileSync5(p, "utf-8"));
   } catch {
     return null;
   }
@@ -1922,10 +2213,10 @@ function manifestHasDependency(root, name) {
 }
 function lockfileMentions(root, name) {
   for (const file of ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]) {
-    const p = join2(root, file);
-    if (!existsSync5(p)) continue;
+    const p = join3(root, file);
+    if (!existsSync6(p)) continue;
     try {
-      if (readFileSync4(p, "utf-8").includes(name)) return true;
+      if (readFileSync5(p, "utf-8").includes(name)) return true;
     } catch {
     }
   }
@@ -2412,7 +2703,7 @@ var ToolExecutor = class {
     rl.resume();
     process.stdout.write(prompt);
     this.confirming = true;
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       let completed = false;
       const cleanup = (result) => {
         if (completed) return;
@@ -2422,7 +2713,7 @@ var ToolExecutor = class {
         rl.pause();
         rlAny.output = savedOutput;
         this.confirming = false;
-        resolve7(result);
+        resolve9(result);
       };
       const onLine = (line) => {
         const trimmed = line.trim();
@@ -2489,10 +2780,10 @@ var ToolExecutor = class {
       const filePath = String(call.arguments["path"] ?? "");
       const newContent = String(call.arguments["content"] ?? "");
       if (!filePath) return;
-      if (existsSync6(filePath)) {
+      if (existsSync7(filePath)) {
         let oldContent;
         try {
-          oldContent = readFileSync5(filePath, "utf-8");
+          oldContent = readFileSync6(filePath, "utf-8");
         } catch {
           return;
         }
@@ -2515,7 +2806,7 @@ var ToolExecutor = class {
       }
     } else if (call.name === "edit_file") {
       const filePath = String(call.arguments["path"] ?? "");
-      if (!filePath || !existsSync6(filePath)) return;
+      if (!filePath || !existsSync7(filePath)) return;
       const oldStr = call.arguments["old_str"];
       const newStr = call.arguments["new_str"];
       if (oldStr !== void 0) {
@@ -2542,7 +2833,7 @@ var ToolExecutor = class {
         const to = Number(call.arguments["delete_to_line"] ?? from);
         let fileContent;
         try {
-          fileContent = readFileSync5(filePath, "utf-8");
+          fileContent = readFileSync6(filePath, "utf-8");
         } catch {
           return;
         }
@@ -2596,7 +2887,7 @@ var ToolExecutor = class {
     rl.resume();
     process.stdout.write(color("Proceed? [y/N] (type y + Enter to confirm) "));
     this.confirming = true;
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       let completed = false;
       const cleanup = (answer) => {
         if (completed) return;
@@ -2606,7 +2897,7 @@ var ToolExecutor = class {
         rl.pause();
         rlAny.output = savedOutput;
         this.confirming = false;
-        resolve7(answer === "y");
+        resolve9(answer === "y");
       };
       const onLine = (line) => {
         const trimmed = line.trim();
@@ -2634,11 +2925,11 @@ var ToolExecutor = class {
 };
 
 // src/tools/sensitive-paths.ts
-import { resolve as resolve5, sep as sep2, basename as basename2 } from "path";
+import { resolve as resolve6, sep as sep2, basename as basename3 } from "path";
 import { homedir as homedir2 } from "os";
 var home = homedir2();
 function norm(p) {
-  const abs = resolve5(p);
+  const abs = resolve6(p);
   return process.platform === "win32" ? abs.toLowerCase() : abs;
 }
 function homeRel(p) {
@@ -2653,7 +2944,7 @@ function homeRel(p) {
 function classifyWritePath(path3) {
   if (!path3) return { sensitive: false };
   const abs = norm(path3);
-  const base = basename2(abs);
+  const base = basename3(abs);
   const rel = homeRel(path3);
   if (rel) {
     const shellRc = /* @__PURE__ */ new Set([
@@ -2777,7 +3068,7 @@ Do NOT split a long document into many write_file(append=true) calls. That patte
     }
     undoStack.push(filePath, `write_file${appendMode ? " (append)" : ""}: ${filePath}`);
     fileCheckpoints.snapshot(filePath, ToolExecutor.currentMessageIndex);
-    mkdirSync2(dirname2(filePath), { recursive: true });
+    mkdirSync3(dirname3(filePath), { recursive: true });
     if (appendMode) {
       appendFileSync(filePath, content, encoding);
     } else {
@@ -2797,7 +3088,7 @@ Do NOT split a long document into many write_file(append=true) calls. That patte
 };
 
 // src/tools/builtin/edit-file.ts
-import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
 
 // src/tools/builtin/patch-apply.ts
 function parseUnifiedDiff(patch) {
@@ -3158,7 +3449,7 @@ Note: Path can be absolute or relative to cwd.`,
     const filePath = String(args["path"] ?? "");
     const encoding = args["encoding"] ?? "utf-8";
     if (!filePath) throw new ToolError("edit_file", "path is required");
-    if (!existsSync7(filePath)) throw new ToolError("edit_file", `File not found: ${filePath}`);
+    if (!existsSync8(filePath)) throw new ToolError("edit_file", `File not found: ${filePath}`);
     const verdict = classifyWritePath(filePath);
     if (verdict.sensitive && subAgentGuard.active) {
       throw new ToolError(
@@ -3166,7 +3457,7 @@ Note: Path can be absolute or relative to cwd.`,
         `Refused: sub-agents cannot edit sensitive paths \u2014 ${verdict.reason}. If this is genuinely needed, ask the parent agent to perform the edit so the user can approve it.`
       );
     }
-    const original = readFileSync6(filePath, encoding);
+    const original = readFileSync7(filePath, encoding);
     if (args["patch"] !== void 0) {
       const patchText = String(args["patch"] ?? "");
       const stopOnError = args["stop_on_error"] !== false;
@@ -3324,8 +3615,8 @@ function truncatePreview(str, maxLen = 80) {
 }
 
 // src/tools/builtin/list-dir.ts
-import { readdirSync as readdirSync3, statSync as statSync3, existsSync as existsSync8 } from "fs";
-import { join as join3, basename as basename3 } from "path";
+import { readdirSync as readdirSync4, statSync as statSync4, existsSync as existsSync9 } from "fs";
+import { join as join4, basename as basename4 } from "path";
 var listDirTool = {
   definition: {
     name: "list_dir",
@@ -3347,12 +3638,12 @@ var listDirTool = {
   async execute(args) {
     const dirPath = String(args["path"] ?? process.cwd());
     const recursive = Boolean(args["recursive"] ?? false);
-    if (!existsSync8(dirPath)) {
-      const targetName = basename3(dirPath).toLowerCase();
+    if (!existsSync9(dirPath)) {
+      const targetName = basename4(dirPath).toLowerCase();
       const cwd = process.cwd();
       const suggestions = [];
       try {
-        for (const entry of readdirSync3(cwd, { withFileTypes: true })) {
+        for (const entry of readdirSync4(cwd, { withFileTypes: true })) {
           if (entry.isDirectory() && entry.name.toLowerCase() === targetName) {
             suggestions.push(entry.name);
           }
@@ -3385,7 +3676,7 @@ Please use list_dir (without path) to see the current directory structure first.
 function listRecursive(basePath, indent, recursive, lines) {
   let entries;
   try {
-    entries = readdirSync3(basePath, { withFileTypes: true });
+    entries = readdirSync4(basePath, { withFileTypes: true });
   } catch {
     lines.push(`${indent}(permission denied)`);
     return;
@@ -3405,11 +3696,11 @@ function listRecursive(basePath, indent, recursive, lines) {
     if (entry.isDirectory()) {
       lines.push(`${indent}\u{1F4C1} ${entry.name}/`);
       if (recursive) {
-        listRecursive(join3(basePath, entry.name), indent + "  ", true, lines);
+        listRecursive(join4(basePath, entry.name), indent + "  ", true, lines);
       }
     } else {
       try {
-        const stat = statSync3(join3(basePath, entry.name));
+        const stat = statSync4(join4(basePath, entry.name));
         const size = formatSize(stat.size);
         lines.push(`${indent}\u{1F4C4} ${entry.name}  (${size})`);
       } catch {
@@ -3425,9 +3716,9 @@ function formatSize(bytes) {
 }
 
 // src/tools/builtin/grep-files.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync4, existsSync as existsSync9 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5, existsSync as existsSync10 } from "fs";
 import { readFile } from "fs/promises";
-import { join as join4, relative } from "path";
+import { join as join5, relative } from "path";
 var grepFilesTool = {
   definition: {
     name: "grep_files",
@@ -3478,7 +3769,7 @@ Supports regex. Automatically skips node_modules, dist, .git directories.`,
     const contextLines = Math.max(0, Number(args["context_lines"] ?? 0));
     const maxResults = Math.max(1, Number(args["max_results"] ?? 50));
     if (!pattern) throw new ToolError("grep_files", "pattern is required");
-    if (!existsSync9(rootPath)) throw new ToolError("grep_files", `Path not found: ${rootPath}`);
+    if (!existsSync10(rootPath)) throw new ToolError("grep_files", `Path not found: ${rootPath}`);
     const MAX_PATTERN_LENGTH = 1e3;
     if (pattern.length > MAX_PATTERN_LENGTH) {
       throw new ToolError("grep_files", `Pattern too long (${pattern.length} chars, max ${MAX_PATTERN_LENGTH}). Use a shorter pattern.`);
@@ -3491,7 +3782,7 @@ Supports regex. Automatically skips node_modules, dist, .git directories.`,
       regex = new RegExp(escaped, ignoreCase ? "gi" : "g");
     }
     const results = [];
-    const stat = statSync4(rootPath);
+    const stat = statSync5(rootPath);
     if (stat.isFile()) {
       searchInFile(rootPath, rootPath, regex, contextLines, maxResults, results);
     } else {
@@ -3564,7 +3855,7 @@ function collectFilePaths(rootPath, filePattern, maxFiles) {
     if (paths.length >= maxFiles) return;
     let entries;
     try {
-      entries = readdirSync4(dirPath, { withFileTypes: true });
+      entries = readdirSync5(dirPath, { withFileTypes: true });
     } catch {
       return;
     }
@@ -3572,13 +3863,13 @@ function collectFilePaths(rootPath, filePattern, maxFiles) {
       if (paths.length >= maxFiles) return;
       if (entry.isDirectory()) {
         if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
-        walk(join4(dirPath, entry.name));
+        walk(join5(dirPath, entry.name));
       } else if (entry.isFile()) {
         if (isBinary(entry.name)) continue;
         if (filePattern && !matchesFilePattern(entry.name, filePattern)) continue;
-        const fullPath = join4(dirPath, entry.name);
+        const fullPath = join5(dirPath, entry.name);
         try {
-          if (statSync4(fullPath).size > 1e6) continue;
+          if (statSync5(fullPath).size > 1e6) continue;
         } catch {
           continue;
         }
@@ -3624,14 +3915,14 @@ async function searchInFileAsync(fullPath, displayPath, regex, contextLines, max
 }
 function searchInFile(fullPath, displayPath, regex, contextLines, maxResults, results) {
   try {
-    const stat = statSync4(fullPath);
+    const stat = statSync5(fullPath);
     if (stat.size > 1e6) return;
   } catch {
     return;
   }
   let content;
   try {
-    content = readFileSync7(fullPath, "utf-8");
+    content = readFileSync8(fullPath, "utf-8");
   } catch {
     return;
   }
@@ -3662,8 +3953,8 @@ function searchInFile(fullPath, displayPath, regex, contextLines, maxResults, re
 }
 
 // src/tools/builtin/glob-files.ts
-import { readdirSync as readdirSync5, statSync as statSync5, existsSync as existsSync10 } from "fs";
-import { join as join5, relative as relative2, basename as basename4 } from "path";
+import { readdirSync as readdirSync6, statSync as statSync6, existsSync as existsSync11 } from "fs";
+import { join as join6, relative as relative2, basename as basename5 } from "path";
 var globFilesTool = {
   definition: {
     name: "glob_files",
@@ -3696,7 +3987,7 @@ Results sorted by most recent modification time. Automatically skips node_module
     const rootPath = String(args["path"] ?? process.cwd());
     const maxResults = Math.max(1, Number(args["max_results"] ?? 100));
     if (!pattern) throw new ToolError("glob_files", "pattern is required");
-    if (!existsSync10(rootPath)) throw new ToolError("glob_files", `Path not found: ${rootPath}`);
+    if (!existsSync11(rootPath)) throw new ToolError("glob_files", `Path not found: ${rootPath}`);
     const regex = globToRegex(pattern);
     const matches = [];
     collectMatchingFiles(rootPath, rootPath, regex, matches, maxResults);
@@ -3767,21 +4058,21 @@ function collectMatchingFiles(dirPath, rootPath, regex, results, maxResults) {
   if (results.length >= maxResults) return;
   let entries;
   try {
-    entries = readdirSync5(dirPath, { withFileTypes: true });
+    entries = readdirSync6(dirPath, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (results.length >= maxResults) break;
-    const fullPath = join5(dirPath, entry.name);
+    const fullPath = join6(dirPath, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".")) continue;
       collectMatchingFiles(fullPath, rootPath, regex, results, maxResults);
     } else if (entry.isFile()) {
       const relPath = relative2(rootPath, fullPath).replace(/\\/g, "/");
-      if (regex.test(relPath) || regex.test(basename4(relPath))) {
+      if (regex.test(relPath) || regex.test(basename5(relPath))) {
         try {
-          const stat = statSync5(fullPath);
+          const stat = statSync6(fullPath);
           results.push({ relPath, absPath: fullPath, mtime: stat.mtimeMs });
         } catch {
           results.push({ relPath, absPath: fullPath, mtime: 0 });
@@ -3855,7 +4146,7 @@ var runInteractiveTool = {
       PYTHONDONTWRITEBYTECODE: "1"
     };
     const prefixWarnings = [argsTypeWarning, stdinTypeWarning].filter(Boolean).join("");
-    return new Promise((resolve7) => {
+    return new Promise((resolve9) => {
       const child = spawn2(executable, cmdArgs.map(String), {
         cwd: process.cwd(),
         env,
@@ -3888,22 +4179,22 @@ var runInteractiveTool = {
       setTimeout(writeNextLine, 400);
       const timer = setTimeout(() => {
         child.kill();
-        resolve7(`${prefixWarnings}[Timeout after ${timeout}ms]
+        resolve9(`${prefixWarnings}[Timeout after ${timeout}ms]
 ${buildOutput(stdout, stderr)}`);
       }, timeout);
       child.on("close", (code) => {
         clearTimeout(timer);
         const output = buildOutput(stdout, stderr);
         if (code !== 0 && code !== null) {
-          resolve7(`${prefixWarnings}Exit code ${code}:
+          resolve9(`${prefixWarnings}Exit code ${code}:
 ${output}`);
         } else {
-          resolve7(`${prefixWarnings}${output || "(no output)"}`);
+          resolve9(`${prefixWarnings}${output || "(no output)"}`);
         }
       });
       child.on("error", (err) => {
         clearTimeout(timer);
-        resolve7(
+        resolve9(
           `${prefixWarnings}Failed to start process "${executable}": ${err.message}
 Hint: On Windows, use the full path to the executable, e.g.:
   C:\\Users\\Jinzd\\anaconda3\\envs\\python312\\python.exe`
@@ -4513,8 +4804,8 @@ ${preamble}`;
 }
 
 // src/tools/builtin/save-last-response.ts
-import { mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, rmdirSync as rmdirSync2 } from "fs";
-import { dirname as dirname3 } from "path";
+import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync2, rmdirSync as rmdirSync2 } from "fs";
+import { dirname as dirname4 } from "path";
 var lastResponseStore = { content: "" };
 function cleanupRejectedTeeFile(filePath) {
   try {
@@ -4522,7 +4813,7 @@ function cleanupRejectedTeeFile(filePath) {
   } catch {
   }
   try {
-    rmdirSync2(dirname3(filePath));
+    rmdirSync2(dirname4(filePath));
   } catch {
   }
 }
@@ -4563,7 +4854,7 @@ Any of these triggers means use save_last_response, NOT write_file:
       throw new ToolError("save_last_response", "No content to save: AI has not produced any response yet, or the last response was empty.");
     }
     undoStack.push(filePath, `save_last_response: ${filePath}`);
-    mkdirSync3(dirname3(filePath), { recursive: true });
+    mkdirSync4(dirname4(filePath), { recursive: true });
     atomicWriteFileSync(filePath, content);
     const lines = content.split("\n").length;
     return `File saved: ${filePath} (${lines} lines, ${content.length} bytes)`;
@@ -4571,26 +4862,236 @@ Any of these triggers means use save_last_response, NOT write_file:
 };
 
 // src/tools/builtin/save-memory.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8, statSync as statSync6, mkdirSync as mkdirSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import { homedir as homedir3 } from "os";
-function getMemoryFilePath() {
-  return join6(homedir3(), CONFIG_DIR_NAME, MEMORY_FILE_NAME);
+
+// src/memory/persistent-memory.ts
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync9 } from "fs";
+import { randomUUID, createHash as createHash3 } from "crypto";
+import { dirname as dirname5, join as join7, resolve as resolve7 } from "path";
+function memoryStorePath(configDir) {
+  return join7(configDir, MEMORY_STORE_FILE_NAME);
 }
-function formatTimestamp() {
-  const now = /* @__PURE__ */ new Date();
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+function memoryMarkdownPath(configDir) {
+  return join7(configDir, MEMORY_FILE_NAME);
+}
+function getProjectKey(cwd = process.cwd()) {
+  return resolve7(getGitRoot(cwd) ?? cwd);
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isValidScope(value) {
+  return value === "personal" || value === "project" || value === "session" || value === "team";
+}
+function isValidSensitivity(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+function normalizeEntry(value) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  const content = typeof raw.content === "string" ? raw.content.trim() : "";
+  if (!content) return null;
+  const createdAt = typeof raw.createdAt === "string" ? raw.createdAt : nowIso();
+  return {
+    id: typeof raw.id === "string" && raw.id ? raw.id : randomUUID(),
+    content,
+    scope: isValidScope(raw.scope) ? raw.scope : "personal",
+    sourceSession: typeof raw.sourceSession === "string" && raw.sourceSession ? raw.sourceSession : void 0,
+    sourceProject: typeof raw.sourceProject === "string" && raw.sourceProject ? raw.sourceProject : void 0,
+    createdAt,
+    updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : createdAt,
+    expiresAt: typeof raw.expiresAt === "string" && raw.expiresAt ? raw.expiresAt : void 0,
+    sensitivity: isValidSensitivity(raw.sensitivity) ? raw.sensitivity : "low",
+    approved: raw.approved === true,
+    redactedKinds: Array.isArray(raw.redactedKinds) ? raw.redactedKinds.filter((x) => typeof x === "string") : void 0
+  };
+}
+function legacyEntriesFromMarkdown(configDir) {
+  const file = memoryMarkdownPath(configDir);
+  if (!existsSync12(file)) return [];
+  const content = readFileSync9(file, "utf-8").trim();
+  if (!content) return [];
+  const parts = content.split(/\n(?=##\s+\d{4}-\d{2}-\d{2})/g);
+  const chunks = parts.length > 1 ? parts : [content];
+  return chunks.map((chunk, index) => {
+    const match = chunk.match(/^##\s+([^\n]+)\n([\s\S]*)$/);
+    const body = (match ? match[2] : chunk).trim();
+    const parsed = match ? Date.parse(match[1].replace(" ", "T")) : NaN;
+    const createdAt = Number.isFinite(parsed) ? new Date(parsed).toISOString() : nowIso();
+    const id = "legacy-" + createHash3("sha1").update(`${index}
+${chunk}`).digest("hex").slice(0, 12);
+    return normalizeEntry({ id, content: body, scope: "personal", createdAt, updatedAt: createdAt, sensitivity: "low", approved: true });
+  }).filter((entry) => Boolean(entry));
+}
+function loadMemoryEntries(configDir) {
+  const file = memoryStorePath(configDir);
+  if (!existsSync12(file)) return legacyEntriesFromMarkdown(configDir);
+  const text = readFileSync9(file, "utf-8").trim();
+  if (!text) return [];
+  const entries = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = normalizeEntry(JSON.parse(trimmed));
+      if (entry) entries.push(entry);
+    } catch {
+    }
+  }
+  return entries;
+}
+function saveMemoryEntries(configDir, entries) {
+  mkdirSync5(configDir, { recursive: true });
+  const jsonl = entries.map((entry) => JSON.stringify(entry)).join("\n");
+  atomicWriteFileSync(memoryStorePath(configDir), jsonl ? jsonl + "\n" : "");
+  syncLegacyMarkdown(configDir, entries);
+}
+function isMemoryExpired(entry, at = /* @__PURE__ */ new Date()) {
+  return Boolean(entry.expiresAt && Date.parse(entry.expiresAt) <= at.getTime());
+}
+function isMemoryVisibleInProject(entry, cwd = process.cwd()) {
+  if (entry.scope !== "project") return true;
+  return entry.sourceProject === getProjectKey(cwd);
+}
+function listMemoryEntries(configDir, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  return loadMemoryEntries(configDir).filter((entry) => options.includeRejected || entry.approved).filter((entry) => options.includeExpired || !isMemoryExpired(entry)).filter((entry) => isMemoryVisibleInProject(entry, cwd));
+}
+function addMemoryEntry(configDir, content, options = {}) {
+  const original = content.trim();
+  if (!original) throw new Error("memory content is required");
+  const redact = options.redact ?? true;
+  const redacted = redact ? redactString(original, { enabled: true, patterns: options.patterns ?? DEFAULT_PATTERNS, customRegexes: options.customPatterns }) : { redacted: original, hits: [] };
+  const sensitivity = options.sensitivity ?? (redacted.hits.length > 0 ? "high" : "low");
+  const approved = options.approved ?? (sensitivity === "low" && redacted.hits.length === 0);
+  const scope = options.scope ?? "personal";
+  const timestamp = nowIso();
+  const entry = {
+    id: randomUUID(),
+    content: redacted.redacted.trim(),
+    scope,
+    sourceSession: options.sourceSession,
+    sourceProject: scope === "project" ? getProjectKey(options.cwd) : void 0,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    expiresAt: options.expiresAt,
+    sensitivity,
+    approved,
+    redactedKinds: [...new Set(redacted.hits.map((hit) => hit.kind))]
+  };
+  const entries = loadMemoryEntries(configDir);
+  entries.push(entry);
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function updateMemoryApproval(configDir, idPrefix, approved) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  entry.approved = approved;
+  entry.updatedAt = nowIso();
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function deleteMemoryEntry(configDir, idPrefix) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  saveMemoryEntries(configDir, entries.filter((candidate) => candidate.id !== entry.id));
+  return entry;
+}
+function expireMemoryEntry(configDir, idPrefix, expiresAt = nowIso()) {
+  const entries = loadMemoryEntries(configDir);
+  const entry = findUnique(entries, idPrefix);
+  entry.expiresAt = expiresAt;
+  entry.updatedAt = nowIso();
+  saveMemoryEntries(configDir, entries);
+  return entry;
+}
+function exportMemoryEntries(configDir, cwd = process.cwd()) {
+  return JSON.stringify(listMemoryEntries(configDir, { cwd, includeExpired: true, includeRejected: true }), null, 2);
+}
+function findUnique(entries, idPrefix) {
+  const matches = entries.filter((entry) => entry.id.startsWith(idPrefix));
+  if (matches.length === 0) throw new Error(`memory id not found: ${idPrefix}`);
+  if (matches.length > 1) throw new Error(`memory id is ambiguous: ${idPrefix}`);
+  return matches[0];
+}
+function syncLegacyMarkdown(configDir, entries = loadMemoryEntries(configDir)) {
+  mkdirSync5(dirname5(memoryMarkdownPath(configDir)), { recursive: true });
+  const active = entries.filter((entry) => entry.approved && !isMemoryExpired(entry));
+  const markdown = active.map((entry) => {
+    const date = entry.createdAt.replace("T", " ").slice(0, 19);
+    const source = [
+      `id:${entry.id.slice(0, 8)}`,
+      `scope:${entry.scope}`,
+      entry.sourceSession ? `session:${entry.sourceSession.slice(0, 8)}` : "",
+      entry.sourceProject ? `project:${entry.sourceProject}` : "",
+      `sensitivity:${entry.sensitivity}`
+    ].filter(Boolean).join(" \xB7 ");
+    return `## ${date}
+<!-- ${source} -->
+${entry.content}
+`;
+  }).join("\n");
+  atomicWriteFileSync(memoryMarkdownPath(configDir), markdown);
+}
+function formatMemoryForPrompt(configDir, cwd = process.cwd()) {
+  const entries = listMemoryEntries(configDir, { cwd }).filter((entry) => entry.approved && !isMemoryExpired(entry));
+  if (entries.length === 0) return null;
+  let content = entries.map((entry) => {
+    const source = [
+      `id ${entry.id.slice(0, 8)}`,
+      `scope ${entry.scope}`,
+      entry.sourceSession ? `source session ${entry.sourceSession.slice(0, 8)}` : "source manual/tool",
+      entry.sourceProject ? `project ${entry.sourceProject}` : "",
+      `sensitivity ${entry.sensitivity}`
+    ].filter(Boolean).join(" \xB7 ");
+    return `## ${entry.createdAt.replace("T", " ").slice(0, 19)}
+Source: ${source}
+${entry.content}`;
+  }).join("\n\n");
+  if (content.length > MEMORY_MAX_CHARS) {
+    content = content.slice(-MEMORY_MAX_CHARS);
+    const firstEntry = content.indexOf("\n## ");
+    if (firstEntry !== -1) content = content.slice(firstEntry + 1);
+  }
+  return { content, entryCount: entries.length };
+}
+
+// src/tools/builtin/save-memory.ts
+function getConfigDir() {
+  return join8(homedir3(), CONFIG_DIR_NAME);
+}
+function parseScope(value) {
+  return value === "personal" || value === "project" || value === "session" || value === "team" ? value : void 0;
+}
+function parseSensitivity(value) {
+  return value === "low" || value === "medium" || value === "high" ? value : void 0;
 }
 var saveMemoryTool = {
   definition: {
     name: "save_memory",
-    description: "Save important information to persistent memory that survives across sessions. Use this to remember: user preferences, coding style, project architecture decisions, recurring patterns, key findings, or any knowledge worth preserving. Keep each memory entry concise (1-3 sentences). The content will be automatically timestamped.",
+    description: "Save important information to governed persistent memory. Low-risk memories are approved automatically; sensitive entries are stored as pending and require /memory approve <id>. Use concise entries for user preferences, project decisions, recurring patterns, and key findings.",
     parameters: {
       content: {
         type: "string",
         description: "The information to save to persistent memory. Keep it concise and actionable.",
         required: true
+      },
+      scope: {
+        type: "string",
+        description: "Memory scope: personal, project, session, or team. Defaults to personal. Project memories are only injected in the same project.",
+        required: false
+      },
+      sensitivity: {
+        type: "string",
+        description: "Sensitivity: low, medium, or high. Low-risk entries may be auto-approved; medium/high remain pending unless explicitly approved.",
+        required: false
+      },
+      expiresAt: {
+        type: "string",
+        description: "Optional ISO timestamp after which this memory should no longer be injected.",
+        required: false
       }
     },
     dangerous: false
@@ -4598,20 +5099,16 @@ var saveMemoryTool = {
   async execute(args) {
     const content = String(args["content"] ?? "").trim();
     if (!content) throw new ToolError("save_memory", "content is required");
-    const memoryPath = getMemoryFilePath();
-    const configDir = join6(homedir3(), CONFIG_DIR_NAME);
-    if (!existsSync11(configDir)) {
-      mkdirSync4(configDir, { recursive: true });
-    }
-    const timestamp = formatTimestamp();
-    const entry = `
-## ${timestamp}
-${content}
-`;
-    const previous = existsSync11(memoryPath) ? readFileSync8(memoryPath, "utf-8") : "";
-    atomicWriteFileSync(memoryPath, previous + entry);
-    const byteSize = statSync6(memoryPath).size;
-    return `Memory saved successfully. File size: ${byteSize} bytes in ${MEMORY_FILE_NAME}`;
+    const entry = addMemoryEntry(getConfigDir(), content, {
+      scope: parseScope(args["scope"]) ?? "personal",
+      sensitivity: parseSensitivity(args["sensitivity"]),
+      expiresAt: typeof args["expiresAt"] === "string" ? args["expiresAt"] : void 0,
+      cwd: process.cwd(),
+      redact: true
+    });
+    const status = entry.approved ? "approved and active" : "pending approval";
+    const redacted = entry.redactedKinds?.length ? ` Redacted: ${entry.redactedKinds.join(", ")}.` : "";
+    return `Memory saved (${status}). id=${entry.id.slice(0, 8)} scope=${entry.scope} sensitivity=${entry.sensitivity}.${redacted}`;
   }
 };
 
@@ -4655,7 +5152,7 @@ function promptUser(rl, question) {
   console.log();
   console.log(chalk4.cyan("\u2753 ") + chalk4.bold(question));
   process.stdout.write(chalk4.cyan("> "));
-  return new Promise((resolve7) => {
+  return new Promise((resolve9) => {
     let completed = false;
     const cleanup = (answer) => {
       if (completed) return;
@@ -4665,7 +5162,7 @@ function promptUser(rl, question) {
       rl.pause();
       rlAny.output = savedOutput;
       askUserContext.prompting = false;
-      resolve7(answer);
+      resolve9(answer);
     };
     const onLine = (line) => {
       cleanup(line);
@@ -4897,8 +5394,8 @@ function formatResults2(query, data, _requested) {
 }
 
 // src/agents/agent-config.ts
-import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync7, readFileSync as readFileSync10 } from "fs";
+import { join as join9 } from "path";
 import { homedir as homedir4 } from "os";
 var READ_ONLY_TOOLS2 = /* @__PURE__ */ new Set([
   "read_file",
@@ -4993,13 +5490,13 @@ function parseAgentConfig(raw, source, path3) {
   return cfg;
 }
 function loadAgentDir(dir, source) {
-  if (!existsSync12(dir)) return [];
+  if (!existsSync13(dir)) return [];
   const out = [];
-  for (const file of readdirSync6(dir)) {
+  for (const file of readdirSync7(dir)) {
     if (!file.endsWith(".json")) continue;
-    const path3 = join7(dir, file);
+    const path3 = join9(dir, file);
     try {
-      const parsed = JSON.parse(readFileSync9(path3, "utf-8"));
+      const parsed = JSON.parse(readFileSync10(path3, "utf-8"));
       const cfg = parseAgentConfig(parsed, source, path3);
       if (cfg) out.push(cfg);
     } catch {
@@ -5009,8 +5506,8 @@ function loadAgentDir(dir, source) {
 }
 function getAgentDirs(configDir, cwd = process.cwd()) {
   return {
-    user: join7(configDir ?? join7(homedir4(), CONFIG_DIR_NAME), "agents"),
-    project: join7(cwd, CONFIG_DIR_NAME, "agents")
+    user: join9(configDir ?? join9(homedir4(), CONFIG_DIR_NAME), "agents"),
+    project: join9(cwd, CONFIG_DIR_NAME, "agents")
   };
 }
 function listAgentConfigs(configDir, cwd = process.cwd()) {
@@ -5018,6 +5515,11 @@ function listAgentConfigs(configDir, cwd = process.cwd()) {
   const byName = /* @__PURE__ */ new Map();
   for (const cfg of BUILTIN_AGENTS) byName.set(normalizeName(cfg.name), { ...cfg });
   for (const cfg of loadAgentDir(dirs.user, "user")) byName.set(normalizeName(cfg.name), cfg);
+  if (configDir) {
+    for (const dir of getActivePluginAssets(configDir).agentDirs) {
+      for (const cfg of loadAgentDir(dir, "plugin")) byName.set(normalizeName(cfg.name), cfg);
+    }
+  }
   for (const cfg of loadAgentDir(dirs.project, "project")) byName.set(normalizeName(cfg.name), cfg);
   return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -5052,7 +5554,7 @@ var nextId = 1;
 var preferredAgentName = "worker";
 var runs = [];
 var MAX_RUNS = 50;
-function nowIso() {
+function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function startAgentRun(input) {
@@ -5061,7 +5563,7 @@ function startAgentRun(input) {
     agentName: input.agentName,
     task: input.task,
     status: "running",
-    startedAt: nowIso(),
+    startedAt: nowIso2(),
     toolNames: [],
     agentIndex: input.agentIndex,
     stopRequested: false
@@ -5079,7 +5581,7 @@ function finishAgentRun(runId, status, summary, error) {
   const run = runs.find((r) => r.id === runId);
   if (!run) return;
   run.status = status;
-  run.finishedAt = nowIso();
+  run.finishedAt = nowIso2();
   if (summary) run.summary = summary;
   if (error) run.error = error;
 }
@@ -5505,7 +6007,7 @@ var spawnAgentTool = {
 
 // src/tools/builtin/task-manager.ts
 import { spawn as spawn3 } from "child_process";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { platform as platform4 } from "os";
 var MAX_OUTPUT_CHARS = 1e4;
 var MAX_OUTPUT_BYTES = 64 * 1024;
@@ -5538,7 +6040,7 @@ function createTask(command, description) {
       }
     }
   }
-  const id = randomUUID().slice(0, 8);
+  const id = randomUUID2().slice(0, 8);
   const { shell, args } = shellInvocation(command);
   const proc = spawn3(shell, args, {
     stdio: ["ignore", "pipe", "pipe"],
@@ -5720,14 +6222,14 @@ var taskStopTool = {
 
 // src/tools/builtin/git-tools.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync13 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join10 } from "path";
 function assertGitRepo(cwd) {
   let dir = cwd;
   const root = dir.split(/[\\/]/)[0] + (dir.includes("\\") ? "\\" : "/");
   while (dir && dir !== root) {
-    if (existsSync13(join8(dir, ".git"))) return;
-    const parent = join8(dir, "..");
+    if (existsSync14(join10(dir, ".git"))) return;
+    const parent = join10(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -5992,9 +6494,9 @@ ${commitOutput.trim()}`;
 };
 
 // src/tools/builtin/notebook-edit.ts
-import { readFileSync as readFileSync10, existsSync as existsSync14 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync15 } from "fs";
 import { writeFile } from "fs/promises";
-import { resolve as resolve6, extname as extname2 } from "path";
+import { resolve as resolve8, extname as extname2 } from "path";
 var notebookEditTool = {
   definition: {
     name: "notebook_edit",
@@ -6043,14 +6545,14 @@ var notebookEditTool = {
     if (!Number.isInteger(cellIndexRaw) || cellIndexRaw < 1) {
       throw new ToolError("notebook_edit", "cell_index must be a positive integer (1-based)");
     }
-    const absPath = resolve6(filePath);
+    const absPath = resolve8(filePath);
     if (extname2(absPath).toLowerCase() !== ".ipynb") {
       throw new ToolError("notebook_edit", "path must point to a .ipynb file");
     }
-    if (!existsSync14(absPath)) {
+    if (!existsSync15(absPath)) {
       throw new ToolError("notebook_edit", `Notebook not found: ${filePath}`);
     }
-    const raw = readFileSync10(absPath, "utf-8");
+    const raw = readFileSync11(absPath, "utf-8");
     const nb = parseNotebook(raw);
     const cellIdx0 = cellIndexRaw - 1;
     undoStack.push(absPath, `notebook_edit (${action}): ${filePath}`);
@@ -6467,8 +6969,8 @@ function estimateToolDefinitionTokens(def) {
 
 // src/tools/registry.ts
 import { pathToFileURL } from "url";
-import { existsSync as existsSync15, mkdirSync as mkdirSync5, readdirSync as readdirSync7 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync6, readdirSync as readdirSync8 } from "fs";
+import { join as join11 } from "path";
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   pluginToolNames = /* @__PURE__ */ new Set();
@@ -6629,16 +7131,16 @@ var ToolRegistry = class {
    * Returns the number of successfully loaded plugins.
    */
   async loadPlugins(pluginsDir, allowPlugins = false) {
-    if (!existsSync15(pluginsDir)) {
+    if (!existsSync16(pluginsDir)) {
       try {
-        mkdirSync5(pluginsDir, { recursive: true });
+        mkdirSync6(pluginsDir, { recursive: true });
       } catch {
       }
       return 0;
     }
     let files;
     try {
-      files = readdirSync7(pluginsDir).filter((f) => f.endsWith(".js"));
+      files = readdirSync8(pluginsDir).filter((f) => f.endsWith(".js"));
     } catch {
       return 0;
     }
@@ -6655,12 +7157,12 @@ var ToolRegistry = class {
     process.stderr.write(
       `
 [plugins] \u26A0 Loading ${files.length} plugin(s) with FULL system privileges:
-` + files.map((f) => `  + ${join9(pluginsDir, f)}`).join("\n") + "\n\n"
+` + files.map((f) => `  + ${join11(pluginsDir, f)}`).join("\n") + "\n\n"
     );
     let loaded = 0;
     for (const file of files) {
       try {
-        const fileUrl = pathToFileURL(join9(pluginsDir, file)).href;
+        const fileUrl = pathToFileURL(join11(pluginsDir, file)).href;
         const mod = await import(fileUrl);
         const tool = mod.tool ?? mod.default?.tool ?? mod.default;
         if (!tool || typeof tool.execute !== "function" || !tool.definition?.name) {
@@ -6702,6 +7204,25 @@ export {
   getRecentlyDeniedAutoActions,
   clearRecentlyDeniedAutoActions,
   defaultActionClassifier,
+  pluginRoot,
+  installPlugin,
+  setPluginEnabled,
+  trustPlugin,
+  getInstalledPlugin,
+  listInstalledPlugins,
+  mergePluginHooks,
+  getActivePluginAssets,
+  describePlugin,
+  memoryStorePath,
+  memoryMarkdownPath,
+  isMemoryExpired,
+  listMemoryEntries,
+  addMemoryEntry,
+  updateMemoryApproval,
+  deleteMemoryEntry,
+  expireMemoryEntry,
+  exportMemoryEntries,
+  formatMemoryForPrompt,
   isInterrupted,
   requestInterrupt,
   resetInterrupt,