jinzd-ai-cli 0.4.217 → 0.4.219

package/dist/{chunk-MGBMNCHG.js → chunk-GEN4O5QH.js}

@@ -1,14 +1,31 @@
 #!/usr/bin/env node
+import {
+  indexProject
+} from "./chunk-K3CF65QH.js";
 import {
   hasSemanticIndex,
   semanticSearch
 } from "./chunk-T2NL5ZIA.js";
 import {
   runTestsTool
-} from "./chunk-VTH7BLXK.js";
+} from "./chunk-64NUW3WL.js";
+import {
+  fileCheckpoints
+} from "./chunk-4BKXL7SM.js";
 import {
+  loadChatIndex,
+  searchChatMemory
+} from "./chunk-TB4W4Y4T.js";
+import {
+  DEFAULT_PATTERNS,
+  redactString
+} from "./chunk-SLSWPBK3.js";
+import {
+  getActivePluginAssets,
+  runHook,
+  runLifecycleHooks,
   runTool
-} from "./chunk-SNJAOXFT.js";
+} from "./chunk-GGKQHPB3.js";
 import {
   getDangerLevel,
   isFileWriteTool,
@@ -28,24 +45,10 @@ import {
   SUBAGENT_ALLOWED_TOOLS,
   SUBAGENT_DEFAULT_MAX_ROUNDS,
   SUBAGENT_MAX_ROUNDS_LIMIT
-} from "./chunk-XJGEQIYS.js";
+} from "./chunk-U7KVU25H.js";
 import {
   getGitRoot
 } from "./chunk-HOSJZMQS.js";
-import {
-  fileCheckpoints
-} from "./chunk-4BKXL7SM.js";
-import {
-  loadChatIndex,
-  searchChatMemory
-} from "./chunk-TB4W4Y4T.js";
-import {
-  DEFAULT_PATTERNS,
-  redactString
-} from "./chunk-SLSWPBK3.js";
-import {
-  indexProject
-} from "./chunk-K3CF65QH.js";
 import {
   loadIndex
 } from "./chunk-CKH4KQ4E.js";
@@ -1059,12 +1062,12 @@ ${content}`;
 };
 
 // src/tools/builtin/write-file.ts
-import { appendFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { appendFileSync, mkdirSync } from "fs";
 import { dirname as dirname2 } from "path";
 
 // src/tools/executor.ts
 import chalk3 from "chalk";
-import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { tmpdir } from "os";
 
 // src/core/readline-internal.ts
@@ -1270,184 +1273,6 @@ function simpleDiff(oldLines, newLines) {
   return result;
 }
 
-// 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";
-var TRUST_FILE = "hooks-trust.json";
-var DEFAULT_TIMEOUT_MS = 5e3;
-function asArray(entry) {
-  if (!entry) return [];
-  const raw = Array.isArray(entry) ? entry : [entry];
-  return raw.map((item) => typeof item === "string" ? { command: item } : item);
-}
-function hookTrustPath(configDir) {
-  return join(configDir, TRUST_FILE);
-}
-function loadHookTrustStore(configDir) {
-  const file = hookTrustPath(configDir);
-  if (!existsSync4(file)) return { records: [] };
-  try {
-    const parsed = JSON.parse(readFileSync3(file, "utf-8"));
-    return { records: Array.isArray(parsed.records) ? parsed.records : [] };
-  } catch {
-    return { records: [] };
-  }
-}
-function saveHookTrustStore(configDir, store) {
-  mkdirSync(configDir, { recursive: true });
-  atomicWriteFileSync(hookTrustPath(configDir), JSON.stringify(store, null, 2));
-}
-function hashHook(event, command) {
-  return createHash("sha256").update(`${event}
-${command}`, "utf-8").digest("hex");
-}
-function isTrusted(source, event, hash, store) {
-  if (source === "user" || source === "managed") return true;
-  return store.records.some((r) => r.source === source && r.event === event && r.hash === hash);
-}
-function listHooks(config, configDir) {
-  if (!config || config.enabled === false) return [];
-  const store = loadHookTrustStore(configDir);
-  const out = [];
-  const push = (event, hook, index) => {
-    if (!hook.command) return;
-    const source = hook.source ?? "user";
-    const hash = hashHook(event, hook.command);
-    out.push({
-      id: `${event}:${index}`,
-      event,
-      command: hook.command,
-      source,
-      hash,
-      trusted: isTrusted(source, event, hash, store),
-      disabled: hook.disabled === true,
-      description: hook.description
-    });
-  };
-  if (config.preToolExecution) push("PreToolUse", { command: config.preToolExecution }, 0);
-  if (config.postToolExecution) push("PostToolUse", { command: config.postToolExecution }, 0);
-  for (const [event, entry] of Object.entries(config.events ?? {})) {
-    asArray(entry).forEach((hook, i) => push(event, hook, i));
-  }
-  return out;
-}
-function trustHook(configDir, hook) {
-  const store = loadHookTrustStore(configDir);
-  const next = store.records.filter((r) => !(r.source === hook.source && r.event === hook.event && r.id === hook.id));
-  next.push({ id: hook.id, event: hook.event, source: hook.source, hash: hook.hash, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
-  saveHookTrustStore(configDir, { records: next });
-}
-function untrustHook(configDir, hook) {
-  const store = loadHookTrustStore(configDir);
-  saveHookTrustStore(configDir, {
-    records: store.records.filter((r) => !(r.source === hook.source && r.event === hook.event && r.hash === hook.hash))
-  });
-}
-function getPendingHookTrust(config, configDir) {
-  return listHooks(config, configDir).filter((h) => h.source === "project" && !h.disabled && !h.trusted);
-}
-function normalizeDecision(value, hook) {
-  if (!value || typeof value !== "object") return null;
-  const obj = value;
-  const action = obj.action;
-  if (action !== "allow" && action !== "deny" && action !== "ask") return null;
-  return {
-    action,
-    reason: typeof obj.reason === "string" ? obj.reason : void 0,
-    prompt: typeof obj.prompt === "string" ? obj.prompt : void 0,
-    contextAppend: typeof obj.contextAppend === "string" ? obj.contextAppend : void 0,
-    warning: typeof obj.warning === "string" ? obj.warning : void 0,
-    warnings: Array.isArray(obj.warnings) ? obj.warnings.filter((x) => typeof x === "string") : void 0,
-    hook
-  };
-}
-function runStructuredHook(hook, descriptor, payload) {
-  if (hook.disabled === true) return null;
-  const timeout = Math.max(100, Math.min(hook.timeoutMs ?? DEFAULT_TIMEOUT_MS, 3e4));
-  try {
-    const stdout = execSync(hook.command, {
-      timeout,
-      stdio: ["pipe", "pipe", "pipe"],
-      encoding: "utf-8",
-      env: {
-        ...process.env,
-        AICLI_HOOK_EVENT: payload.event,
-        AICLI_HOOK_EVENT_JSON: JSON.stringify(payload)
-      }
-    }).trim();
-    if (!stdout) return null;
-    return normalizeDecision(JSON.parse(stdout), descriptor);
-  } catch (err) {
-    process.stderr.write(`\u26A0 Hook failed: ${hook.command.slice(0, 100)}
-`);
-    if (hook.required) {
-      return { action: "deny", reason: err instanceof Error ? err.message : String(err), hook: descriptor };
-    }
-    return null;
-  }
-}
-function runLifecycleHooks(config, event, payload, opts) {
-  if (!config || config.enabled === false) return [];
-  const options = typeof opts === "string" ? { configDir: opts } : opts;
-  const store = loadHookTrustStore(options.configDir);
-  const hooks = asArray(config.events?.[event]);
-  const decisions = [];
-  for (let i = 0; i < hooks.length; i++) {
-    const hook = hooks[i];
-    if (!hook.command || hook.disabled) continue;
-    const source = hook.source ?? "user";
-    const hash = hashHook(event, hook.command);
-    const descriptor = {
-      id: `${event}:${i}`,
-      event,
-      command: hook.command,
-      source,
-      hash,
-      trusted: isTrusted(source, event, hash, store),
-      disabled: false,
-      description: hook.description
-    };
-    if (!descriptor.trusted) {
-      options.onSummary?.(`hook skipped: ${event} project hook requires trust (${hash.slice(0, 12)})`);
-      continue;
-    }
-    const decision = runStructuredHook(hook, descriptor, { event, ...payload });
-    if (decision) {
-      decisions.push(decision);
-      options.onSummary?.(`hook ${event}: ${decision.action}${decision.reason ? ` (${decision.reason})` : ""}`);
-    }
-  }
-  return decisions;
-}
-function rewriteTemplate(template, isWindows) {
-  const ref = (name) => isWindows ? `%${name}%` : `$${name}`;
-  return template.replace(/\{tool\}/g, ref("AICLI_HOOK_TOOL")).replace(/\{dangerLevel\}/g, ref("AICLI_HOOK_DANGER_LEVEL")).replace(/\{args\}/g, ref("AICLI_HOOK_ARGS")).replace(/\{status\}/g, ref("AICLI_HOOK_STATUS"));
-}
-function runHook(template, vars) {
-  if (!template) return;
-  const isWindows = process.platform === "win32";
-  const cmd = rewriteTemplate(template, isWindows);
-  try {
-    execSync(cmd, {
-      timeout: DEFAULT_TIMEOUT_MS,
-      stdio: ["pipe", "pipe", "pipe"],
-      encoding: "utf-8",
-      env: {
-        ...process.env,
-        AICLI_HOOK_TOOL: vars.tool,
-        AICLI_HOOK_DANGER_LEVEL: vars.dangerLevel ?? "",
-        AICLI_HOOK_ARGS: vars.args ?? "",
-        AICLI_HOOK_STATUS: vars.status ?? ""
-      }
-    });
-  } catch {
-    process.stderr.write(`\u26A0 Hook failed: ${cmd.slice(0, 100)}
-`);
-  }
-}
-
 // src/tools/permissions.ts
 import { isAbsolute, resolve as resolve3 } from "path";
 function checkPermission(toolName, args, dangerLevel, rules, defaultAction = "confirm") {
@@ -1870,8 +1695,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 existsSync4, readFileSync as readFileSync3 } from "fs";
+import { isAbsolute as isAbsolute2, join, resolve as resolve4 } from "path";
 var RECENT_DENIED_LIMIT = 50;
 var recentlyDenied = [];
 function recordRecentlyDeniedAutoAction(call, classification) {
@@ -1912,10 +1737,10 @@ function splitShellWords(command) {
   return out.filter(Boolean);
 }
 function readPackageManifest(root) {
-  const p = join2(root, "package.json");
-  if (!existsSync5(p)) return null;
+  const p = join(root, "package.json");
+  if (!existsSync4(p)) return null;
   try {
-    return JSON.parse(readFileSync4(p, "utf-8"));
+    return JSON.parse(readFileSync3(p, "utf-8"));
   } catch {
     return null;
   }
@@ -1931,10 +1756,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 = join(root, file);
+    if (!existsSync4(p)) continue;
     try {
-      if (readFileSync4(p, "utf-8").includes(name)) return true;
+      if (readFileSync3(p, "utf-8").includes(name)) return true;
     } catch {
     }
   }
@@ -2498,10 +2323,10 @@ var ToolExecutor = class {
       const filePath = String(call.arguments["path"] ?? "");
       const newContent = String(call.arguments["content"] ?? "");
       if (!filePath) return;
-      if (existsSync6(filePath)) {
+      if (existsSync5(filePath)) {
         let oldContent;
         try {
-          oldContent = readFileSync5(filePath, "utf-8");
+          oldContent = readFileSync4(filePath, "utf-8");
         } catch {
           return;
         }
@@ -2524,7 +2349,7 @@ var ToolExecutor = class {
       }
     } else if (call.name === "edit_file") {
       const filePath = String(call.arguments["path"] ?? "");
-      if (!filePath || !existsSync6(filePath)) return;
+      if (!filePath || !existsSync5(filePath)) return;
       const oldStr = call.arguments["old_str"];
       const newStr = call.arguments["new_str"];
       if (oldStr !== void 0) {
@@ -2551,7 +2376,7 @@ var ToolExecutor = class {
         const to = Number(call.arguments["delete_to_line"] ?? from);
         let fileContent;
         try {
-          fileContent = readFileSync5(filePath, "utf-8");
+          fileContent = readFileSync4(filePath, "utf-8");
         } catch {
           return;
         }
@@ -2786,7 +2611,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 });
+    mkdirSync(dirname2(filePath), { recursive: true });
     if (appendMode) {
       appendFileSync(filePath, content, encoding);
     } else {
@@ -2806,7 +2631,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 readFileSync5, existsSync as existsSync6 } from "fs";
 
 // src/tools/builtin/patch-apply.ts
 function parseUnifiedDiff(patch) {
@@ -3167,7 +2992,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 (!existsSync6(filePath)) throw new ToolError("edit_file", `File not found: ${filePath}`);
     const verdict = classifyWritePath(filePath);
     if (verdict.sensitive && subAgentGuard.active) {
       throw new ToolError(
@@ -3175,7 +3000,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 = readFileSync5(filePath, encoding);
     if (args["patch"] !== void 0) {
       const patchText = String(args["patch"] ?? "");
       const stopOnError = args["stop_on_error"] !== false;
@@ -3333,8 +3158,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 readdirSync3, statSync as statSync3, existsSync as existsSync7 } from "fs";
+import { join as join2, basename as basename3 } from "path";
 var listDirTool = {
   definition: {
     name: "list_dir",
@@ -3356,7 +3181,7 @@ var listDirTool = {
   async execute(args) {
     const dirPath = String(args["path"] ?? process.cwd());
     const recursive = Boolean(args["recursive"] ?? false);
-    if (!existsSync8(dirPath)) {
+    if (!existsSync7(dirPath)) {
       const targetName = basename3(dirPath).toLowerCase();
       const cwd = process.cwd();
       const suggestions = [];
@@ -3414,11 +3239,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(join2(basePath, entry.name), indent + "  ", true, lines);
       }
     } else {
       try {
-        const stat = statSync3(join3(basePath, entry.name));
+        const stat = statSync3(join2(basePath, entry.name));
         const size = formatSize(stat.size);
         lines.push(`${indent}\u{1F4C4} ${entry.name}  (${size})`);
       } catch {
@@ -3434,9 +3259,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 readdirSync4, readFileSync as readFileSync6, statSync as statSync4, existsSync as existsSync8 } from "fs";
 import { readFile } from "fs/promises";
-import { join as join4, relative } from "path";
+import { join as join3, relative } from "path";
 var grepFilesTool = {
   definition: {
     name: "grep_files",
@@ -3487,7 +3312,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 (!existsSync8(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.`);
@@ -3581,11 +3406,11 @@ 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(join3(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 = join3(dirPath, entry.name);
         try {
           if (statSync4(fullPath).size > 1e6) continue;
         } catch {
@@ -3640,7 +3465,7 @@ function searchInFile(fullPath, displayPath, regex, contextLines, maxResults, re
   }
   let content;
   try {
-    content = readFileSync7(fullPath, "utf-8");
+    content = readFileSync6(fullPath, "utf-8");
   } catch {
     return;
   }
@@ -3671,8 +3496,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 readdirSync5, statSync as statSync5, existsSync as existsSync9 } from "fs";
+import { join as join4, relative as relative2, basename as basename4 } from "path";
 var globFilesTool = {
   definition: {
     name: "glob_files",
@@ -3705,7 +3530,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 (!existsSync9(rootPath)) throw new ToolError("glob_files", `Path not found: ${rootPath}`);
     const regex = globToRegex(pattern);
     const matches = [];
     collectMatchingFiles(rootPath, rootPath, regex, matches, maxResults);
@@ -3782,7 +3607,7 @@ function collectMatchingFiles(dirPath, rootPath, regex, results, maxResults) {
   }
   for (const entry of entries) {
     if (results.length >= maxResults) break;
-    const fullPath = join5(dirPath, entry.name);
+    const fullPath = join4(dirPath, entry.name);
     if (entry.isDirectory()) {
       if (SKIP_DIRS2.has(entry.name) || entry.name.startsWith(".")) continue;
       collectMatchingFiles(fullPath, rootPath, regex, results, maxResults);
@@ -4522,7 +4347,7 @@ ${preamble}`;
 }
 
 // src/tools/builtin/save-last-response.ts
-import { mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, rmdirSync as rmdirSync2 } from "fs";
+import { mkdirSync as mkdirSync2, unlinkSync as unlinkSync2, rmdirSync as rmdirSync2 } from "fs";
 import { dirname as dirname3 } from "path";
 var lastResponseStore = { content: "" };
 function cleanupRejectedTeeFile(filePath) {
@@ -4572,7 +4397,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 });
+    mkdirSync2(dirname3(filePath), { recursive: true });
     atomicWriteFileSync(filePath, content);
     const lines = content.split("\n").length;
     return `File saved: ${filePath} (${lines} lines, ${content.length} bytes)`;
@@ -4580,18 +4405,18 @@ Any of these triggers means use save_last_response, NOT write_file:
 };
 
 // src/tools/builtin/save-memory.ts
-import { join as join7 } from "path";
+import { join as join6 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/memory/persistent-memory.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync8 } from "fs";
-import { randomUUID, createHash as createHash2 } from "crypto";
-import { dirname as dirname4, join as join6, resolve as resolve6 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync7 } from "fs";
+import { randomUUID, createHash } from "crypto";
+import { dirname as dirname4, join as join5, resolve as resolve6 } from "path";
 function memoryStorePath(configDir) {
-  return join6(configDir, MEMORY_STORE_FILE_NAME);
+  return join5(configDir, MEMORY_STORE_FILE_NAME);
 }
 function memoryMarkdownPath(configDir) {
-  return join6(configDir, MEMORY_FILE_NAME);
+  return join5(configDir, MEMORY_FILE_NAME);
 }
 function getProjectKey(cwd = process.cwd()) {
   return resolve6(getGitRoot(cwd) ?? cwd);
@@ -4627,8 +4452,8 @@ function normalizeEntry(value) {
 }
 function legacyEntriesFromMarkdown(configDir) {
   const file = memoryMarkdownPath(configDir);
-  if (!existsSync11(file)) return [];
-  const content = readFileSync8(file, "utf-8").trim();
+  if (!existsSync10(file)) return [];
+  const content = readFileSync7(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];
@@ -4637,15 +4462,15 @@ function legacyEntriesFromMarkdown(configDir) {
     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-" + createHash2("sha1").update(`${index}
+    const id = "legacy-" + createHash("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 (!existsSync11(file)) return legacyEntriesFromMarkdown(configDir);
-  const text = readFileSync8(file, "utf-8").trim();
+  if (!existsSync10(file)) return legacyEntriesFromMarkdown(configDir);
+  const text = readFileSync7(file, "utf-8").trim();
   if (!text) return [];
   const entries = [];
   for (const line of text.split("\n")) {
@@ -4660,7 +4485,7 @@ function loadMemoryEntries(configDir) {
   return entries;
 }
 function saveMemoryEntries(configDir, entries) {
-  mkdirSync4(configDir, { recursive: true });
+  mkdirSync3(configDir, { recursive: true });
   const jsonl = entries.map((entry) => JSON.stringify(entry)).join("\n");
   atomicWriteFileSync(memoryStorePath(configDir), jsonl ? jsonl + "\n" : "");
   syncLegacyMarkdown(configDir, entries);
@@ -4735,7 +4560,7 @@ function findUnique(entries, idPrefix) {
   return matches[0];
 }
 function syncLegacyMarkdown(configDir, entries = loadMemoryEntries(configDir)) {
-  mkdirSync4(dirname4(memoryMarkdownPath(configDir)), { recursive: true });
+  mkdirSync3(dirname4(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);
@@ -4778,7 +4603,7 @@ ${entry.content}`;
 
 // src/tools/builtin/save-memory.ts
 function getConfigDir() {
-  return join7(homedir3(), CONFIG_DIR_NAME);
+  return join6(homedir3(), CONFIG_DIR_NAME);
 }
 function parseScope(value) {
   return value === "personal" || value === "project" || value === "session" || value === "team" ? value : void 0;
@@ -5112,8 +4937,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 join8 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync8 } from "fs";
+import { join as join7 } from "path";
 import { homedir as homedir4 } from "os";
 var READ_ONLY_TOOLS2 = /* @__PURE__ */ new Set([
   "read_file",
@@ -5208,13 +5033,13 @@ function parseAgentConfig(raw, source, path3) {
   return cfg;
 }
 function loadAgentDir(dir, source) {
-  if (!existsSync12(dir)) return [];
+  if (!existsSync11(dir)) return [];
   const out = [];
   for (const file of readdirSync6(dir)) {
     if (!file.endsWith(".json")) continue;
-    const path3 = join8(dir, file);
+    const path3 = join7(dir, file);
     try {
-      const parsed = JSON.parse(readFileSync9(path3, "utf-8"));
+      const parsed = JSON.parse(readFileSync8(path3, "utf-8"));
       const cfg = parseAgentConfig(parsed, source, path3);
       if (cfg) out.push(cfg);
     } catch {
@@ -5224,8 +5049,8 @@ function loadAgentDir(dir, source) {
 }
 function getAgentDirs(configDir, cwd = process.cwd()) {
   return {
-    user: join8(configDir ?? join8(homedir4(), CONFIG_DIR_NAME), "agents"),
-    project: join8(cwd, CONFIG_DIR_NAME, "agents")
+    user: join7(configDir ?? join7(homedir4(), CONFIG_DIR_NAME), "agents"),
+    project: join7(cwd, CONFIG_DIR_NAME, "agents")
   };
 }
 function listAgentConfigs(configDir, cwd = process.cwd()) {
@@ -5233,6 +5058,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));
 }
@@ -5935,14 +5765,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 join9 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join8 } from "path";
 function assertGitRepo(cwd) {
   let dir = cwd;
   const root = dir.split(/[\\/]/)[0] + (dir.includes("\\") ? "\\" : "/");
   while (dir && dir !== root) {
-    if (existsSync13(join9(dir, ".git"))) return;
-    const parent = join9(dir, "..");
+    if (existsSync12(join8(dir, ".git"))) return;
+    const parent = join8(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -6207,7 +6037,7 @@ ${commitOutput.trim()}`;
 };
 
 // src/tools/builtin/notebook-edit.ts
-import { readFileSync as readFileSync10, existsSync as existsSync14 } from "fs";
+import { readFileSync as readFileSync9, existsSync as existsSync13 } from "fs";
 import { writeFile } from "fs/promises";
 import { resolve as resolve7, extname as extname2 } from "path";
 var notebookEditTool = {
@@ -6262,10 +6092,10 @@ var notebookEditTool = {
     if (extname2(absPath).toLowerCase() !== ".ipynb") {
       throw new ToolError("notebook_edit", "path must point to a .ipynb file");
     }
-    if (!existsSync14(absPath)) {
+    if (!existsSync13(absPath)) {
       throw new ToolError("notebook_edit", `Notebook not found: ${filePath}`);
     }
-    const raw = readFileSync10(absPath, "utf-8");
+    const raw = readFileSync9(absPath, "utf-8");
     const nb = parseNotebook(raw);
     const cellIdx0 = cellIndexRaw - 1;
     undoStack.push(absPath, `notebook_edit (${action}): ${filePath}`);
@@ -6682,8 +6512,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 join10 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync4, readdirSync as readdirSync7 } from "fs";
+import { join as join9 } from "path";
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   pluginToolNames = /* @__PURE__ */ new Set();
@@ -6844,9 +6674,9 @@ var ToolRegistry = class {
    * Returns the number of successfully loaded plugins.
    */
   async loadPlugins(pluginsDir, allowPlugins = false) {
-    if (!existsSync15(pluginsDir)) {
+    if (!existsSync14(pluginsDir)) {
       try {
-        mkdirSync5(pluginsDir, { recursive: true });
+        mkdirSync4(pluginsDir, { recursive: true });
       } catch {
       }
       return 0;
@@ -6870,12 +6700,12 @@ var ToolRegistry = class {
     process.stderr.write(
       `
 [plugins] \u26A0 Loading ${files.length} plugin(s) with FULL system privileges:
-` + files.map((f) => `  + ${join10(pluginsDir, f)}`).join("\n") + "\n\n"
+` + files.map((f) => `  + ${join9(pluginsDir, f)}`).join("\n") + "\n\n"
     );
     let loaded = 0;
     for (const file of files) {
       try {
-        const fileUrl = pathToFileURL(join10(pluginsDir, file)).href;
+        const fileUrl = pathToFileURL(join9(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) {
@@ -6907,12 +6737,6 @@ export {
   theme,
   undoStack,
   renderDiff,
-  listHooks,
-  trustHook,
-  untrustHook,
-  getPendingHookTrust,
-  runLifecycleHooks,
-  runHook,
   recordRecentlyDeniedAutoAction,
   getRecentlyDeniedAutoActions,
   clearRecentlyDeniedAutoActions,