@wellgrow/cli 0.1.3 → 0.2.0

package/dist/index.js

@@ -50,9 +50,6 @@ var wellGrowConfigSchema = z.object({
   mcp: z.object({
     paths: z.array(z.string())
   }),
-  hooks: z.object({
-    paths: z.array(z.string())
-  }),
   user: z.object({
     name: z.string().optional()
   }).optional(),
@@ -104,9 +101,6 @@ var DEFAULT_CONFIG = {
   mcp: {
     paths: []
   },
-  hooks: {
-    paths: []
-  },
   logging: {
     verbose: false,
     log_dir: "~/.wellgrow/logs"
@@ -505,15 +499,9 @@ function updateToolPart(parts, toolCallId, state, output, errorText) {
     parts[idx] = { ...part, state, output, errorText };
   }
 }
-function approvalDecisionToToolDecision(ad) {
-  if (ad.action === "allow") {
-    return { decision: "allow" };
-  }
-  return { decision: "deny", reason: "\u30E6\u30FC\u30B6\u30FC\u304C\u30C4\u30FC\u30EB\u306E\u5B9F\u884C\u3092\u62D2\u5426\u3057\u307E\u3057\u305F" };
-}
 async function requestApproval(tc, meta, pipeline, callbacks) {
   if (!callbacks.onApprovalRequest) {
-    return { decision: "allow" };
+    return true;
   }
   const decision = await callbacks.onApprovalRequest({
     toolCallId: tc.toolCallId,
@@ -530,7 +518,7 @@ async function requestApproval(tc, meta, pipeline, callbacks) {
       });
     }
   }
-  return approvalDecisionToToolDecision(decision);
+  return decision.action === "allow";
 }
 function toToolOutput(value) {
   if (typeof value === "string") {
@@ -539,7 +527,7 @@ function toToolOutput(value) {
   return { type: "json", value };
 }
 async function executeSingleTool(tc, parts, config, callbacks, needsApproval) {
-  const { registry, pipeline, executionHooks } = config;
+  const { registry, pipeline } = config;
   const handler = registry.handlers[tc.toolName];
   if (!handler) {
     const errorMsg = `\u4E0D\u660E\u306A\u30C4\u30FC\u30EB: ${tc.toolName}`;
@@ -552,72 +540,18 @@ async function executeSingleTool(tc, parts, config, callbacks, needsApproval) {
       output: { type: "error-text", value: `Error: ${errorMsg}` }
     };
   }
-  const meta = registry.getMeta(tc.toolName);
-  const metaInfo = {
-    category: meta?.category ?? "execute",
-    source: meta?.source ?? "builtin"
-  };
-  if (executionHooks?.beforeExecute) {
-    const hookResult = await executionHooks.beforeExecute(tc, metaInfo);
-    if (hookResult.decision === "deny") {
-      updateToolPart(
-        parts,
-        tc.toolCallId,
-        "output-denied",
-        void 0,
-        hookResult.reason
-      );
-      callbacks.onMessageUpdate([...parts]);
-      return pipeline.createDeniedResult(
-        tc.toolCallId,
-        tc.toolName,
-        hookResult.reason
-      );
-    }
-    if (hookResult.decision === "ask") {
-      needsApproval = true;
-    }
-    if (hookResult.decision === "allow" && hookResult.updatedInput) {
-      tc = { ...tc, args: { ...tc.args, ...hookResult.updatedInput } };
-    }
-  }
   if (needsApproval) {
-    let approved = false;
-    if (executionHooks?.onPermissionRequest) {
-      const hookDecision = await executionHooks.onPermissionRequest(
-        tc,
-        metaInfo
-      );
-      if (hookDecision) {
-        if (hookDecision.behavior === "deny") {
-          const reason = "\u30D5\u30C3\u30AF\u306B\u3088\u308A\u62D2\u5426\u3055\u308C\u307E\u3057\u305F";
-          updateToolPart(parts, tc.toolCallId, "output-denied", void 0, reason);
-          callbacks.onMessageUpdate([...parts]);
-          return pipeline.createDeniedResult(tc.toolCallId, tc.toolName, reason);
-        }
-        if (hookDecision.updatedInput) {
-          tc = { ...tc, args: { ...tc.args, ...hookDecision.updatedInput } };
-        }
-        approved = true;
-      }
-    }
+    const meta = registry.getMeta(tc.toolName);
+    const metaInfo = {
+      category: meta?.category ?? "execute",
+      source: meta?.source ?? "builtin"
+    };
+    const approved = await requestApproval(tc, metaInfo, pipeline, callbacks);
     if (!approved) {
-      const approval = await requestApproval(tc, metaInfo, pipeline, callbacks);
-      if (approval.decision === "deny") {
-        updateToolPart(
-          parts,
-          tc.toolCallId,
-          "output-denied",
-          void 0,
-          approval.reason
-        );
-        callbacks.onMessageUpdate([...parts]);
-        return pipeline.createDeniedResult(
-          tc.toolCallId,
-          tc.toolName,
-          approval.reason
-        );
-      }
+      const reason = "\u30E6\u30FC\u30B6\u30FC\u304C\u30C4\u30FC\u30EB\u306E\u5B9F\u884C\u3092\u62D2\u5426\u3057\u307E\u3057\u305F";
+      updateToolPart(parts, tc.toolCallId, "output-denied", void 0, reason);
+      callbacks.onMessageUpdate([...parts]);
+      return pipeline.createDeniedResult(tc.toolCallId, tc.toolName, reason);
     }
   }
   try {
@@ -631,6 +565,7 @@ async function executeSingleTool(tc, parts, config, callbacks, needsApproval) {
       abortSignal: config.abortSignal
     };
     const resultPromise = handler(tc.args, handlerCtx);
+    const meta = registry.getMeta(tc.toolName);
     const uiHooks = meta?.uiHooks;
     const startEvent = uiHooks?.onStart?.(tc.args, tc.toolCallId);
     if (startEvent && callbacks.onToolUIEvent) {
@@ -646,46 +581,21 @@ async function executeSingleTool(tc, parts, config, callbacks, needsApproval) {
     if (completeEvent && callbacks.onToolUIEvent) {
       callbacks.onToolUIEvent(completeEvent);
     }
-    const afterResult = await executionHooks?.afterExecute?.(tc, {
-      success: true,
-      output: toolResult
-    });
-    const output = toToolOutput(toolResult);
-    if (afterResult?.feedback) {
-      const feedbackOutput = toToolOutput(
-        `${typeof toolResult === "string" ? toolResult : JSON.stringify(toolResult)}
-
-[Hook feedback]: ${afterResult.feedback}`
-      );
-      return {
-        type: "tool-result",
-        toolCallId: tc.toolCallId,
-        toolName: tc.toolName,
-        output: feedbackOutput
-      };
-    }
     return {
       type: "tool-result",
       toolCallId: tc.toolCallId,
       toolName: tc.toolName,
-      output
+      output: toToolOutput(toolResult)
     };
   } catch (error) {
     const errorMsg = formatToolError(error);
     updateToolPart(parts, tc.toolCallId, "output-error", void 0, errorMsg);
     callbacks.onMessageUpdate([...parts]);
-    const afterResult = await executionHooks?.afterExecute?.(tc, {
-      success: false,
-      error: errorMsg
-    });
-    const errorOutput = afterResult?.feedback ? `${errorMsg}
-
-[Hook feedback]: ${afterResult.feedback}` : errorMsg;
     return {
       type: "tool-result",
       toolCallId: tc.toolCallId,
       toolName: tc.toolName,
-      output: { type: "error-text", value: errorOutput }
+      output: { type: "error-text", value: errorMsg }
     };
   }
 }
@@ -749,17 +659,6 @@ async function runAgentLoop(messages, config, callbacks) {
     const turnResult = await executeTurn(messages, config, callbacks, parts);
     fullText += turnResult.text;
     if (turnResult.finishReason !== "tool-calls") {
-      if (config.onStop) {
-        const stopResult = await config.onStop(turnResult.text);
-        if (stopResult.blocked && stopResult.reason) {
-          messages.push({
-            role: "user",
-            content: stopResult.reason
-          });
-          turnsUsed++;
-          continue;
-        }
-      }
       break;
     }
     const toolResults = await executeToolCalls(
@@ -1089,7 +988,7 @@ function createSessionContext() {
 }
 
 // src/agents/resolver.ts
-import { join as join10 } from "path";
+import { join as join9 } from "path";
 
 // src/agents/loader.ts
 import { readFile as readFile2, readdir } from "fs/promises";
@@ -1116,9 +1015,6 @@ var agentConfigSchema = z3.object({
   }).optional(),
   skills: z3.object({
     paths: z3.array(z3.string()).optional()
-  }).optional(),
-  hooks: z3.object({
-    paths: z3.array(z3.string()).optional()
   }).optional()
 });
 
@@ -1621,10 +1517,8 @@ var backgroundProcesses = /* @__PURE__ */ new Set();
 var isShuttingDown = false;
 var lastSigintTime = 0;
 var activeCtx = null;
-var activeHookEngine = null;
-function setActiveSession(ctx, hookEngine) {
+function setActiveSession(ctx) {
   activeCtx = ctx;
-  activeHookEngine = hookEngine;
 }
 function registerShutdownHandler(handler) {
   shutdownHandlers.push(handler);
@@ -1683,23 +1577,11 @@ async function cleanupMcpClients() {
   } catch {
   }
 }
-async function fireSessionEndHook(reason) {
-  if (!activeHookEngine) return;
-  try {
-    await Promise.race([
-      activeHookEngine.fire("SessionEnd", { reason }),
-      new Promise((r) => setTimeout(r, 5e3))
-    ]);
-  } catch {
-  }
-}
 async function gracefulShutdown(_reason) {
   if (isShuttingDown) {
     process.exit(1);
   }
   isShuttingDown = true;
-  const hookReason = _reason === "sigint" || _reason === "sigint_double" ? "prompt_input_exit" : "other";
-  await fireSessionEndHook(hookReason);
   for (const handler of shutdownHandlers) {
     try {
       await Promise.race([handler(), new Promise((r) => setTimeout(r, 5e3))]);
@@ -3099,455 +2981,6 @@ async function discoverSkills(paths) {
   return skills;
 }
 
-// src/extensions/hook-engine.ts
-import { readFile as readFile9, readdir as readdir4, stat as stat3 } from "fs/promises";
-import { join as join9 } from "path";
-import { homedir as homedir9 } from "os";
-import { spawn as spawn2 } from "child_process";
-import { z as z11 } from "zod";
-import { generateText } from "ai";
-var hookDefinitionSchema = z11.discriminatedUnion("type", [
-  z11.object({
-    type: z11.literal("command"),
-    command: z11.string(),
-    timeout: z11.number().positive().optional(),
-    async: z11.boolean().optional(),
-    statusMessage: z11.string().optional()
-  }),
-  z11.object({
-    type: z11.literal("prompt"),
-    prompt: z11.string(),
-    model: z11.string().optional(),
-    timeout: z11.number().positive().optional()
-  })
-]);
-var hookGroupSchema = z11.object({
-  matcher: z11.string().optional(),
-  hooks: z11.array(hookDefinitionSchema)
-});
-var hooksFileConfigSchema = z11.object({
-  hooks: z11.record(z11.array(hookGroupSchema)).default({})
-});
-var DEFAULT_HOOK_MODEL = "claude-haiku-4-5-20251001";
-var DEFAULT_COMMAND_TIMEOUT_SEC = 30;
-var MAX_HOOK_OUTPUT_BYTES = 1024 * 1024;
-function expandTilde2(p) {
-  return p.startsWith("~") ? join9(homedir9(), p.slice(1)) : p;
-}
-function hookKey(hook) {
-  switch (hook.type) {
-    case "command":
-      return `command:${hook.command}:async=${hook.async ?? false}`;
-    case "prompt":
-      return `prompt:${hook.prompt}:${hook.model ?? "default"}`;
-  }
-}
-function warnHook(message) {
-  process.stderr.write(`[hooks] ${message}
-`);
-}
-async function loadHooksFile(filePath) {
-  let content;
-  try {
-    content = await readFile9(expandTilde2(filePath), "utf-8");
-  } catch {
-    return { hooks: {} };
-  }
-  let raw;
-  try {
-    raw = JSON.parse(content);
-  } catch (error) {
-    warnHook(
-      `${filePath} \u306EJSON\u89E3\u6790\u306B\u5931\u6557: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return { hooks: {} };
-  }
-  const result = hooksFileConfigSchema.safeParse(raw);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
-    warnHook(`${filePath} \u306E\u30B9\u30AD\u30FC\u30DE\u304C\u4E0D\u6B63: ${issues}`);
-    return { hooks: {} };
-  }
-  return { hooks: result.data.hooks };
-}
-async function resolveHookFiles(pathInput) {
-  const resolvedPath = expandTilde2(pathInput);
-  let stats;
-  try {
-    stats = await stat3(resolvedPath);
-  } catch {
-    return [];
-  }
-  if (stats.isFile()) {
-    return [resolvedPath];
-  }
-  if (!stats.isDirectory()) {
-    return [];
-  }
-  let entries;
-  try {
-    entries = await readdir4(resolvedPath, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => join9(resolvedPath, entry.name)).sort((a, b) => a.localeCompare(b));
-}
-function mergeHooksConfig(target, source) {
-  const events = Object.keys(source.hooks);
-  for (const event of events) {
-    const sourceGroups = source.hooks[event] ?? [];
-    const currentGroups = target.hooks[event] ?? [];
-    target.hooks[event] = [...currentGroups, ...sourceGroups];
-  }
-}
-async function loadHooksConfig(pathsOrGlobalPath, agentPath) {
-  const pathList = Array.isArray(pathsOrGlobalPath) ? pathsOrGlobalPath : [pathsOrGlobalPath, ...agentPath ? [agentPath] : []];
-  const merged = { hooks: {} };
-  for (const pathEntry of pathList) {
-    const files = await resolveHookFiles(pathEntry);
-    for (const filePath of files) {
-      const config = await loadHooksFile(filePath);
-      mergeHooksConfig(merged, config);
-    }
-  }
-  return merged;
-}
-var regexCache = /* @__PURE__ */ new Map();
-function getCachedRegex(pattern) {
-  const cached = regexCache.get(pattern);
-  if (cached !== void 0) return cached;
-  try {
-    const regex = new RegExp(`^(?:${pattern})$`);
-    regexCache.set(pattern, regex);
-    return regex;
-  } catch {
-    regexCache.set(pattern, null);
-    return null;
-  }
-}
-function matchesTarget(matcher, target) {
-  if (!matcher || matcher === "" || matcher === "*") return true;
-  if (target === null) return true;
-  const regex = getCachedRegex(matcher);
-  if (regex) return regex.test(target);
-  return matcher === target;
-}
-function getMatchTarget(event, input) {
-  switch (event) {
-    case "PreToolUse":
-    case "PostToolUse":
-    case "PostToolUseFailure":
-    case "PermissionRequest":
-      return input.tool_name ?? null;
-    case "SessionStart":
-      return input.source ?? null;
-    case "SessionEnd":
-      return input.reason ?? null;
-    case "UserPromptSubmit":
-    case "Stop":
-      return null;
-  }
-}
-function executeCommandHook(hook, input) {
-  return new Promise((resolve5) => {
-    const timeoutMs = (hook.timeout ?? DEFAULT_COMMAND_TIMEOUT_SEC) * 1e3;
-    const command = expandTilde2(hook.command);
-    const child = spawn2("sh", ["-c", command], {
-      env: { ...process.env },
-      timeout: timeoutMs,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (data) => {
-      if (stdout.length < MAX_HOOK_OUTPUT_BYTES) {
-        stdout += data.toString();
-      }
-    });
-    child.stderr.on("data", (data) => {
-      if (stderr.length < MAX_HOOK_OUTPUT_BYTES) {
-        stderr += data.toString();
-      }
-    });
-    child.stdin.on("error", () => {
-    });
-    child.stdin.write(JSON.stringify(input));
-    child.stdin.end();
-    child.on("close", (code) => {
-      resolve5({ stdout, stderr, exitCode: code ?? 1 });
-    });
-    child.on("error", (err) => {
-      warnHook(`\u30B3\u30DE\u30F3\u30C9hook\u5B9F\u884C\u30A8\u30E9\u30FC (${hook.command}): ${err.message}`);
-      resolve5({ stdout, stderr, exitCode: 1 });
-    });
-  });
-}
-async function executeLLMHook(hook, input, resolveModel) {
-  const prompt = hook.prompt.replace(/\$ARGUMENTS/g, JSON.stringify(input));
-  const model = resolveModel(hook.model);
-  try {
-    const result = await generateText({
-      model,
-      prompt,
-      maxOutputTokens: 500,
-      ...hook.timeout ? { abortSignal: AbortSignal.timeout(hook.timeout * 1e3) } : {}
-    });
-    const text = result.text.trim();
-    try {
-      const parsed = JSON.parse(text);
-      return { ok: parsed.ok !== false, reason: parsed.reason };
-    } catch {
-      warnHook(
-        `Prompt hook\u306E\u30EC\u30B9\u30DD\u30F3\u30B9\u304CJSON\u5F62\u5F0F\u3067\u306F\u3042\u308A\u307E\u305B\u3093: ${text.slice(0, 200)}`
-      );
-      return { ok: true };
-    }
-  } catch (error) {
-    warnHook(
-      `Prompt hook\u5B9F\u884C\u30A8\u30E9\u30FC: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return { ok: true };
-  }
-}
-function normalizeCommandOutput(event, stdout, stderr, exitCode) {
-  if (exitCode === 2) {
-    return {
-      blocked: true,
-      reason: stderr.trim() || "\u30D5\u30C3\u30AF\u306B\u3088\u308A\u30D6\u30ED\u30C3\u30AF\u3055\u308C\u307E\u3057\u305F",
-      feedback: stderr.trim() || void 0
-    };
-  }
-  if (exitCode !== 0) {
-    return { blocked: false };
-  }
-  const trimmed = stdout.trim();
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    if (event === "SessionStart" && trimmed) {
-      return { blocked: false, additionalContext: trimmed };
-    }
-    return { blocked: false };
-  }
-  const hso = parsed.hookSpecificOutput;
-  switch (event) {
-    case "PreToolUse": {
-      const decision = hso?.permissionDecision;
-      if (decision === "deny") {
-        return {
-          blocked: true,
-          reason: hso?.permissionDecisionReason ?? "\u30D5\u30C3\u30AF\u306B\u3088\u308A\u30D6\u30ED\u30C3\u30AF\u3055\u308C\u307E\u3057\u305F"
-        };
-      }
-      if (decision === "ask") {
-        return { blocked: false, askUser: true };
-      }
-      return {
-        blocked: false,
-        updatedInput: hso?.updatedInput,
-        additionalContext: hso?.additionalContext
-      };
-    }
-    case "PermissionRequest": {
-      const decision = hso?.decision;
-      if (decision?.behavior === "deny") {
-        return { blocked: true, reason: "\u30D5\u30C3\u30AF\u306B\u3088\u308A\u62D2\u5426\u3055\u308C\u307E\u3057\u305F" };
-      }
-      if (decision?.behavior === "allow") {
-        return { blocked: false, updatedInput: decision.updatedInput };
-      }
-      return { blocked: false };
-    }
-    case "Stop": {
-      if (parsed.decision === "block") {
-        return {
-          blocked: true,
-          stopDecision: "block",
-          reason: parsed.reason ?? "\u30D5\u30C3\u30AF\u306B\u3088\u308A\u7D9A\u884C\u304C\u8981\u6C42\u3055\u308C\u307E\u3057\u305F"
-        };
-      }
-      return { blocked: false, stopDecision: "approve" };
-    }
-    case "SessionStart": {
-      const ctx = hso?.additionalContext ?? trimmed;
-      return { blocked: false, additionalContext: ctx || void 0 };
-    }
-    default:
-      return { blocked: false };
-  }
-}
-function normalizePromptOutput(ok, reason) {
-  if (!ok) {
-    return {
-      blocked: true,
-      reason: reason ?? "\u30D5\u30C3\u30AF\u306B\u3088\u308A\u30D6\u30ED\u30C3\u30AF\u3055\u308C\u307E\u3057\u305F"
-    };
-  }
-  return { blocked: false };
-}
-function mergeResults(results) {
-  const merged = { blocked: false };
-  for (const r of results) {
-    if (r.blocked) {
-      merged.blocked = true;
-      merged.reason = r.reason ?? merged.reason;
-    }
-    if (r.stopDecision) merged.stopDecision = r.stopDecision;
-    if (r.askUser) merged.askUser = true;
-    if (r.feedback) {
-      merged.feedback = merged.feedback ? `${merged.feedback}
-${r.feedback}` : r.feedback;
-    }
-    if (r.additionalContext) {
-      merged.additionalContext = merged.additionalContext ? `${merged.additionalContext}
-${r.additionalContext}` : r.additionalContext;
-    }
-    if (r.updatedInput) {
-      merged.updatedInput = { ...merged.updatedInput, ...r.updatedInput };
-    }
-  }
-  return merged;
-}
-var HookEngine = class {
-  hooksConfig;
-  options;
-  _hasHooks;
-  constructor(hooksConfig, options) {
-    this.hooksConfig = hooksConfig;
-    this.options = options;
-    this._hasHooks = Object.keys(hooksConfig.hooks).length > 0;
-  }
-  get hasHooks() {
-    return this._hasHooks;
-  }
-  async fire(event, eventInput = {}) {
-    const groups = this.hooksConfig.hooks[event];
-    if (!groups || groups.length === 0) {
-      return { blocked: false };
-    }
-    const input = {
-      session_id: this.options.sessionId,
-      cwd: this.options.cwd,
-      hook_event_name: event,
-      ...eventInput
-    };
-    const matchTarget = getMatchTarget(event, input);
-    const matchingGroups = groups.filter(
-      (g) => matchesTarget(g.matcher, matchTarget)
-    );
-    if (matchingGroups.length === 0) {
-      return { blocked: false };
-    }
-    const seen = /* @__PURE__ */ new Set();
-    const syncHooks = [];
-    const asyncHooks = [];
-    for (const group of matchingGroups) {
-      for (const hook of group.hooks) {
-        const key = hookKey(hook);
-        if (seen.has(key)) continue;
-        seen.add(key);
-        if (hook.type === "command" && hook.async) {
-          asyncHooks.push(hook);
-        } else {
-          syncHooks.push(hook);
-        }
-      }
-    }
-    for (const hook of asyncHooks) {
-      this.executeOne(hook, event, input).catch((error) => {
-        warnHook(
-          `\u975E\u540C\u671Fhook\u5B9F\u884C\u30A8\u30E9\u30FC (${hook.command}): ${error instanceof Error ? error.message : String(error)}`
-        );
-      });
-    }
-    if (syncHooks.length === 0) {
-      return { blocked: false };
-    }
-    const results = await Promise.all(
-      syncHooks.map((hook) => this.executeOne(hook, event, input))
-    );
-    return mergeResults(results);
-  }
-  // ----- Bridge to ToolExecutionHooks (agent-loop.ts) -----
-  createToolExecutionHooks() {
-    return {
-      beforeExecute: async (toolCall, _meta) => {
-        const result = await this.fire("PreToolUse", {
-          tool_name: toolCall.toolName,
-          tool_input: toolCall.args,
-          tool_use_id: toolCall.toolCallId
-        });
-        if (result.blocked) {
-          return {
-            decision: "deny",
-            reason: result.reason ?? "\u30D5\u30C3\u30AF\u306B\u3088\u308A\u30D6\u30ED\u30C3\u30AF\u3055\u308C\u307E\u3057\u305F"
-          };
-        }
-        if (result.askUser) {
-          return { decision: "ask" };
-        }
-        return {
-          decision: "allow",
-          updatedInput: result.updatedInput,
-          additionalContext: result.additionalContext
-        };
-      },
-      afterExecute: async (toolCall, result) => {
-        const event = result.success ? "PostToolUse" : "PostToolUseFailure";
-        const hookResult = await this.fire(event, {
-          tool_name: toolCall.toolName,
-          tool_input: toolCall.args,
-          tool_use_id: toolCall.toolCallId,
-          ...result.success ? { tool_response: result.output } : { error: result.error }
-        });
-        if (hookResult.feedback) {
-          return { feedback: hookResult.feedback };
-        }
-      },
-      onPermissionRequest: async (toolCall, _meta) => {
-        const result = await this.fire("PermissionRequest", {
-          tool_name: toolCall.toolName,
-          tool_input: toolCall.args
-        });
-        if (result.blocked) {
-          return { behavior: "deny" };
-        }
-        if (result.updatedInput !== void 0) {
-          return {
-            behavior: "allow",
-            updatedInput: result.updatedInput
-          };
-        }
-        return null;
-      }
-    };
-  }
-  // ----- Private helpers -----
-  async executeOne(hook, event, input) {
-    switch (hook.type) {
-      case "command": {
-        const { stdout, stderr, exitCode } = await executeCommandHook(
-          hook,
-          input
-        );
-        return normalizeCommandOutput(event, stdout, stderr, exitCode);
-      }
-      case "prompt": {
-        const { ok, reason } = await executeLLMHook(
-          hook,
-          input,
-          (id) => this.resolveModel(id)
-        );
-        return normalizePromptOutput(ok, reason);
-      }
-    }
-  }
-  resolveModel(modelId) {
-    return getModel(modelId ?? DEFAULT_HOOK_MODEL, this.options.config);
-  }
-};
-
 // src/agents/resolver.ts
 async function resolveAgent(options, sessionCtx) {
   const config = options.config ?? await loadConfig();
@@ -3576,7 +3009,7 @@ async function resolveAgent(options, sessionCtx) {
     environment
   });
   const skillPaths = [
-    join10(agentDir, "skills"),
+    join9(agentDir, "skills"),
     ...config.skills.paths,
     ...agentConfig.skills?.paths ?? []
   ];
@@ -3620,19 +3053,6 @@ async function resolveAgent(options, sessionCtx) {
     mode,
     allowedMcps: config.permissions.allowed_mcps
   });
-  const hookPaths = [
-    ...config.hooks.paths,
-    ...agentConfig.hooks?.paths ?? []
-  ];
-  const hooksConfig = await loadHooksConfig(hookPaths);
-  let hookEngine = null;
-  if (Object.keys(hooksConfig.hooks).length > 0) {
-    hookEngine = new HookEngine(hooksConfig, {
-      sessionId: sessionCtx.sessionId,
-      cwd: sessionCtx.cwd,
-      config
-    });
-  }
   let finalSystemPrompt = systemPrompt;
   if (mcpFailures.length > 0) {
     finalSystemPrompt += `
@@ -3652,7 +3072,6 @@ ${mcpFailures.map((f) => `- ${f}`).join("\n")}
     registry,
     pipeline,
     mcpManager,
-    hookEngine,
     maxTurns
   };
 }
@@ -3672,19 +3091,9 @@ async function createSession(options) {
     },
     ctx
   );
-  if (agent.hookEngine) {
-    await agent.hookEngine.fire("SessionStart", {
-      source: options.sessionStartSource ?? "startup"
-    });
-  }
   return { ctx, messages: [], agent };
 }
 async function switchAgent(session, newAgentName, options) {
-  if (session.agent.hookEngine) {
-    await session.agent.hookEngine.fire("SessionEnd", {
-      reason: "agent_switch"
-    });
-  }
   if (session.agent.mcpManager) {
     await session.agent.mcpManager.disconnectAll();
     session.ctx.mcpManager = null;
@@ -3702,30 +3111,7 @@ async function switchAgent(session, newAgentName, options) {
   );
 }
 async function sendMessage(session, userMessage, callbacks, options) {
-  const hookEngine = session.agent.hookEngine;
-  if (hookEngine) {
-    const submitResult = await hookEngine.fire("UserPromptSubmit", {
-      prompt: userMessage
-    });
-    if (submitResult.blocked) {
-      return {
-        fullText: submitResult.reason ?? "",
-        parts: []
-      };
-    }
-  }
   session.messages.push({ role: "user", content: userMessage });
-  const executionHooks = hookEngine?.createToolExecutionHooks();
-  const onStop = hookEngine ? async (lastMessage) => {
-    const result = await hookEngine.fire("Stop", {
-      stop_hook_active: true,
-      last_assistant_message: lastMessage
-    });
-    return {
-      blocked: result.blocked,
-      reason: result.reason
-    };
-  } : void 0;
   return runAgentLoop(
     session.messages,
     {
@@ -3733,8 +3119,6 @@ async function sendMessage(session, userMessage, callbacks, options) {
       system: session.agent.systemPrompt,
       registry: session.agent.registry,
       pipeline: session.agent.pipeline,
-      executionHooks,
-      onStop,
       abortSignal: options?.abortSignal,
       maxTurns: options?.maxTurns ?? session.agent.maxTurns,
       maxRetries: options?.maxRetries,
@@ -3747,16 +3131,16 @@ async function sendMessage(session, userMessage, callbacks, options) {
 }
 
 // src/core/history.ts
-import { appendFile as appendFile3, readFile as readFile10, mkdir as mkdir6, readdir as readdir5 } from "fs/promises";
-import { join as join11 } from "path";
-import { homedir as homedir10 } from "os";
+import { appendFile as appendFile3, readFile as readFile9, mkdir as mkdir6, readdir as readdir4 } from "fs/promises";
+import { join as join10 } from "path";
+import { homedir as homedir9 } from "os";
 import { randomUUID as randomUUID3 } from "crypto";
-var WELLGROW_DIR = join11(homedir10(), ".wellgrow");
-var HISTORY_FILE = join11(WELLGROW_DIR, "history.jsonl");
+var WELLGROW_DIR = join10(homedir9(), ".wellgrow");
+var HISTORY_FILE = join10(WELLGROW_DIR, "history.jsonl");
 async function createSessionRecorder(model, agent) {
   const sessionId = randomUUID3();
   const now = /* @__PURE__ */ new Date();
-  const dateDir = join11(
+  const dateDir = join10(
     WELLGROW_DIR,
     "sessions",
     String(now.getFullYear()),
@@ -3764,7 +3148,7 @@ async function createSessionRecorder(model, agent) {
     String(now.getDate()).padStart(2, "0")
   );
   await mkdir6(dateDir, { recursive: true });
-  const sessionFile = join11(dateDir, `${sessionId}.jsonl`);
+  const sessionFile = join10(dateDir, `${sessionId}.jsonl`);
   let firstUserMessage = "";
   const meta = JSON.stringify({
     type: "meta",
@@ -3810,7 +3194,7 @@ async function createSessionRecorder(model, agent) {
 }
 async function listHistory(limit = 20) {
   try {
-    const content = await readFile10(HISTORY_FILE, "utf-8");
+    const content = await readFile9(HISTORY_FILE, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     return lines.map((line) => JSON.parse(line)).reverse().slice(0, limit);
   } catch {
@@ -3818,18 +3202,18 @@ async function listHistory(limit = 20) {
   }
 }
 async function getSessionContent(sessionId) {
-  const sessionsDir = join11(WELLGROW_DIR, "sessions");
+  const sessionsDir = join10(WELLGROW_DIR, "sessions");
   try {
-    const years = await readdir5(sessionsDir);
+    const years = await readdir4(sessionsDir);
     for (const year of years) {
-      const months = await readdir5(join11(sessionsDir, year));
+      const months = await readdir4(join10(sessionsDir, year));
       for (const month of months) {
-        const days = await readdir5(join11(sessionsDir, year, month));
+        const days = await readdir4(join10(sessionsDir, year, month));
         for (const day of days) {
-          const files = await readdir5(join11(sessionsDir, year, month, day));
+          const files = await readdir4(join10(sessionsDir, year, month, day));
           const match = files.find((f) => f.startsWith(sessionId));
           if (match) {
-            return readFile10(join11(sessionsDir, year, month, day, match), "utf-8");
+            return readFile9(join10(sessionsDir, year, month, day, match), "utf-8");
           }
         }
       }
@@ -4522,7 +3906,7 @@ function useChatSession({
       setCurrentAgentName(s.agent.name);
       setCurrentAgentIcon(s.agent.icon);
       setAgents(agentList);
-      setActiveSession(s.ctx, s.agent.hookEngine);
+      setActiveSession(s.ctx);
       registerShutdownHandler(async () => {
         if (recorderRef.current) {
           await recorderRef.current.finalize(messageCountRef.current);
@@ -4580,7 +3964,7 @@ function useChatSession({
         setCurrentModelName(getModelDisplayName(session.agent.modelId));
         setCurrentAgentName(session.agent.name);
         setCurrentAgentIcon(session.agent.icon);
-        setActiveSession(session.ctx, session.agent.hookEngine);
+        setActiveSession(session.ctx);
         recorderRef.current = await createSessionRecorder(
           getModelDisplayName(session.agent.modelId),
           newAgentName
@@ -4602,9 +3986,6 @@ function useChatSession({
   const resetSession = useCallback2(async () => {
     const session = sessionRef.current;
     if (!session) return;
-    if (session.agent.hookEngine) {
-      await session.agent.hookEngine.fire("SessionEnd", { reason: "clear" });
-    }
     if (recorderRef.current) {
       await recorderRef.current.finalize(messageCountRef.current);
     }
@@ -4612,8 +3993,7 @@ function useChatSession({
     const newSession = await createSession({
       agentName: currentAgentId,
       modelOverride,
-      modeOverride: mode,
-      sessionStartSource: "clear"
+      modeOverride: mode
     });
     if (verbose) {
       newSession.ctx.logFile = await initLogger(
@@ -4626,7 +4006,7 @@ function useChatSession({
     setCurrentModelName(getModelDisplayName(newSession.agent.modelId));
     setCurrentAgentName(newSession.agent.name);
     setCurrentAgentIcon(newSession.agent.icon);
-    setActiveSession(newSession.ctx, newSession.agent.hookEngine);
+    setActiveSession(newSession.ctx);
     recorderRef.current = await createSessionRecorder(
       getModelDisplayName(newSession.agent.modelId),
       currentAgentId
@@ -4815,10 +4195,6 @@ function useAskUserQueue(getAskUserState) {
 async function handleSlashCommand(text, ctx) {
   if (text === "exit" || text === "quit") {
     ctx.cancelAllAskUser();
-    if (ctx.session.agent.hookEngine) {
-      await ctx.session.agent.hookEngine.fire("SessionEnd", { reason: "prompt_input_exit" }).catch(() => {
-      });
-    }
     if (ctx.recorder) {
       await ctx.recorder.finalize(ctx.messageCountRef.current);
     }
@@ -5413,22 +4789,22 @@ function registerDoctorCommand(program2) {
 
 // src/commands/skills.ts
 import {
-  readFile as readFile11,
-  readdir as readdir6,
+  readFile as readFile10,
+  readdir as readdir5,
   mkdir as mkdir7,
   cp,
   rm as rm2,
   mkdtemp,
-  stat as stat4
+  stat as stat3
 } from "fs/promises";
-import { join as join12, resolve as resolve4 } from "path";
-import { homedir as homedir11, tmpdir } from "os";
+import { join as join11, resolve as resolve4 } from "path";
+import { homedir as homedir10, tmpdir } from "os";
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify4 } from "util";
 import matter2 from "gray-matter";
 var execFileAsync4 = promisify4(execFile4);
-var WELLGROW_HOME2 = join12(homedir11(), ".wellgrow");
-var SKILLS_DIR = join12(WELLGROW_HOME2, "skills");
+var WELLGROW_HOME2 = join11(homedir10(), ".wellgrow");
+var SKILLS_DIR = join11(WELLGROW_HOME2, "skills");
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".github", ".husky"]);
 function parseSource(source) {
   if (source.startsWith("./") || source.startsWith("../")) {
@@ -5457,7 +4833,7 @@ async function discoverSkillsInRepo(dir) {
   async function scan(currentDir, depth) {
     if (depth > 3) return;
     try {
-      const content = await readFile11(join12(currentDir, "SKILL.md"), "utf-8");
+      const content = await readFile10(join11(currentDir, "SKILL.md"), "utf-8");
       const { data } = matter2(content);
       if (data.name && data.description && !seen.has(data.name)) {
         seen.add(data.name);
@@ -5471,10 +4847,10 @@ async function discoverSkillsInRepo(dir) {
     } catch {
     }
     try {
-      const entries = await readdir6(currentDir, { withFileTypes: true });
+      const entries = await readdir5(currentDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) continue;
-        await scan(join12(currentDir, entry.name), depth + 1);
+        await scan(join11(currentDir, entry.name), depth + 1);
       }
     } catch {
     }
@@ -5487,7 +4863,7 @@ async function fetchSource(source) {
   if (!parsed.url.startsWith("https://") && !parsed.url.startsWith("git@")) {
     return { dir: parsed.url, isTemp: false };
   }
-  const tmpDir = await mkdtemp(join12(tmpdir(), "wellgrow-skills-"));
+  const tmpDir = await mkdtemp(join11(tmpdir(), "wellgrow-skills-"));
   const args = ["clone", "--depth", "1"];
   if (parsed.ref) {
     args.push("--branch", parsed.ref);
@@ -5559,7 +4935,7 @@ ${toInstall.length} \u500B\u306E\u30B9\u30AD\u30EB\u3092\u30A4\u30F3\u30B9\u30C8
 `
       );
       for (const skill of toInstall) {
-        const dest = join12(SKILLS_DIR, skill.name);
+        const dest = join11(SKILLS_DIR, skill.name);
         await cp(skill.sourceDir, dest, { recursive: true, force: true });
         process.stdout.write(`  \u2713 ${skill.name}
 `);
@@ -5587,7 +4963,7 @@ ${toInstall.length} \u500B\u306E\u30B9\u30AD\u30EB\u3092\u30A4\u30F3\u30B9\u30C8
   skills.command("list").alias("ls").description("\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u6E08\u307F\u30B9\u30AD\u30EB\u3092\u4E00\u89A7\u8868\u793A").action(async () => {
     let dirs;
     try {
-      const entries = await readdir6(SKILLS_DIR, { withFileTypes: true });
+      const entries = await readdir5(SKILLS_DIR, { withFileTypes: true });
       dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
     } catch {
       dirs = [];
@@ -5602,8 +4978,8 @@ ${dirs.length} \u500B\u306E\u30B9\u30AD\u30EB (${SKILLS_DIR}):
 `);
     for (const name of dirs) {
       try {
-        const content = await readFile11(
-          join12(SKILLS_DIR, name, "SKILL.md"),
+        const content = await readFile10(
+          join11(SKILLS_DIR, name, "SKILL.md"),
           "utf-8"
         );
         const { data } = matter2(content);
@@ -5622,9 +4998,9 @@ ${dirs.length} \u500B\u306E\u30B9\u30AD\u30EB (${SKILLS_DIR}):
     }
   });
   skills.command("remove <name>").alias("rm").description("\u30B9\u30AD\u30EB\u3092\u524A\u9664").action(async (name) => {
-    const skillDir = join12(SKILLS_DIR, name);
+    const skillDir = join11(SKILLS_DIR, name);
     try {
-      await stat4(skillDir);
+      await stat3(skillDir);
     } catch {
       process.stderr.write(`\u30B9\u30AD\u30EB "${name}" \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002
 `);
@@ -5969,7 +5345,7 @@ Error: ${formatErrorMessage(error)}
   }
 }
 var program = new Command();
-program.name("wellgrow").description("WellGrow CLI \u2014 AI chat assistant").version("0.1.3").argument("[prompt]", "\u30EF\u30F3\u30B7\u30E7\u30C3\u30C8\u8CEA\u554F\uFF08\u7701\u7565\u3067\u30A4\u30F3\u30BF\u30E9\u30AF\u30C6\u30A3\u30D6\u30E2\u30FC\u30C9\uFF09").option("--model <model>", "\u4F7F\u7528\u3059\u308B\u30E2\u30C7\u30EB").option("-a, --agent <agent>", "\u4F7F\u7528\u3059\u308B\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8").option(
+program.name("wellgrow").description("WellGrow CLI \u2014 AI chat assistant").version("0.2.0").argument("[prompt]", "\u30EF\u30F3\u30B7\u30E7\u30C3\u30C8\u8CEA\u554F\uFF08\u7701\u7565\u3067\u30A4\u30F3\u30BF\u30E9\u30AF\u30C6\u30A3\u30D6\u30E2\u30FC\u30C9\uFF09").option("--model <model>", "\u4F7F\u7528\u3059\u308B\u30E2\u30C7\u30EB").option("-a, --agent <agent>", "\u4F7F\u7528\u3059\u308B\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8").option(
   "--mode <mode>",
   "\u30E2\u30FC\u30C9 (plan, auto)"
 ).option("--verbose", "\u8A73\u7D30\u30ED\u30B0\u3092\u51FA\u529B").option("-p, --pipe", "\u30D1\u30A4\u30D7\u5165\u529B\u30E2\u30FC\u30C9\uFF08stdin\u304B\u3089\u306E\u5165\u529B\u3092\u53D7\u3051\u4ED8\u3051\u308B\uFF09").action(async (prompt, opts) => {