clikit-plugin 0.2.28 → 0.2.30

package/dist/index.js

@@ -3491,11 +3491,26 @@ var require_gray_matter = __commonJS((exports, module) => {
   module.exports = matter;
 });
 
+// src/index.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
 // src/agents/index.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
 import * as fs from "fs";
 import * as path from "path";
-var AGENTS_DIR = path.join(import.meta.dir, "../src/agents");
+var AGENTS_DIR_CANDIDATES = [
+  import.meta.dir,
+  path.join(import.meta.dir, "../../src/agents")
+];
+function resolveAgentsDir() {
+  for (const dir of AGENTS_DIR_CANDIDATES) {
+    if (fs.existsSync(dir)) {
+      return dir;
+    }
+  }
+  return AGENTS_DIR_CANDIDATES[0];
+}
 function parseAgentMarkdown(filePath) {
   try {
     const content = fs.readFileSync(filePath, "utf-8");
@@ -3526,13 +3541,14 @@ function parseAgentMarkdown(filePath) {
 }
 function loadAgents() {
   const agents = {};
-  if (!fs.existsSync(AGENTS_DIR)) {
+  const agentsDir = resolveAgentsDir();
+  if (!fs.existsSync(agentsDir)) {
     return agents;
   }
-  const files = fs.readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".md"));
+  const files = fs.readdirSync(agentsDir).filter((f) => f.endsWith(".md") && f !== "AGENTS.md").sort();
   for (const file of files) {
     const agentName = path.basename(file, ".md");
-    const agentPath = path.join(AGENTS_DIR, file);
+    const agentPath = path.join(agentsDir, file);
     const agent = parseAgentMarkdown(agentPath);
     if (agent) {
       agents[agentName] = agent;
@@ -3540,15 +3556,37 @@ function loadAgents() {
   }
   return agents;
 }
+var _cachedAgents = null;
+var _cachedAgentsMtime = 0;
 function getBuiltinAgents() {
-  return loadAgents();
+  try {
+    const mtime = fs.statSync(resolveAgentsDir()).mtimeMs;
+    if (_cachedAgents && _cachedAgentsMtime === mtime)
+      return _cachedAgents;
+    _cachedAgents = loadAgents();
+    _cachedAgentsMtime = mtime;
+    return _cachedAgents;
+  } catch {
+    return _cachedAgents ?? loadAgents();
+  }
 }
 
 // src/commands/index.ts
 var import_gray_matter2 = __toESM(require_gray_matter(), 1);
 import * as fs2 from "fs";
 import * as path2 from "path";
-var COMMANDS_DIR = path2.join(import.meta.dir, "../command");
+var COMMANDS_DIR_CANDIDATES = [
+  path2.join(import.meta.dir, "../../command"),
+  path2.join(import.meta.dir, "../../../command")
+];
+function resolveCommandsDir() {
+  for (const dir of COMMANDS_DIR_CANDIDATES) {
+    if (fs2.existsSync(dir)) {
+      return dir;
+    }
+  }
+  return COMMANDS_DIR_CANDIDATES[0];
+}
 function parseCommandMarkdown(filePath) {
   try {
     const content = fs2.readFileSync(filePath, "utf-8");
@@ -3574,13 +3612,14 @@ function parseCommandMarkdown(filePath) {
 }
 function loadCommands() {
   const commands = {};
-  if (!fs2.existsSync(COMMANDS_DIR)) {
+  const commandsDir = resolveCommandsDir();
+  if (!fs2.existsSync(commandsDir)) {
     return commands;
   }
-  const files = fs2.readdirSync(COMMANDS_DIR).filter((f) => f.endsWith(".md"));
+  const files = fs2.readdirSync(commandsDir).filter((f) => f.endsWith(".md")).sort();
   for (const file of files) {
     const commandName = path2.basename(file, ".md");
-    const commandPath = path2.join(COMMANDS_DIR, file);
+    const commandPath = path2.join(commandsDir, file);
     const command = parseCommandMarkdown(commandPath);
     if (command) {
       commands[commandName] = command;
@@ -3588,22 +3627,85 @@ function loadCommands() {
   }
   return commands;
 }
+var _cachedCommands = null;
+var _cachedCommandsMtime = 0;
 function getBuiltinCommands() {
-  return loadCommands();
+  try {
+    const mtime = fs2.statSync(resolveCommandsDir()).mtimeMs;
+    if (_cachedCommands && _cachedCommandsMtime === mtime)
+      return _cachedCommands;
+    _cachedCommands = loadCommands();
+    _cachedCommandsMtime = mtime;
+    return _cachedCommands;
+  } catch {
+    return _cachedCommands ?? loadCommands();
+  }
 }
 
-// src/config.ts
+// src/skills/index.ts
+var import_gray_matter3 = __toESM(require_gray_matter(), 1);
 import * as fs3 from "fs";
 import * as path3 from "path";
+var SKILLS_DIR_CANDIDATES = [
+  path3.join(import.meta.dir, "../../skill"),
+  path3.join(import.meta.dir, "../../../skill")
+];
+function resolveSkillsDir() {
+  for (const dir of SKILLS_DIR_CANDIDATES) {
+    if (fs3.existsSync(dir)) {
+      return dir;
+    }
+  }
+  return SKILLS_DIR_CANDIDATES[0];
+}
+function getBuiltinSkills() {
+  const skills = {};
+  const skillsDir = resolveSkillsDir();
+  if (!fs3.existsSync(skillsDir)) {
+    console.warn("[CliKit] Skills directory not found:", skillsDir);
+    return skills;
+  }
+  const skillDirs = fs3.readdirSync(skillsDir, { withFileTypes: true });
+  for (const dirent of skillDirs) {
+    if (!dirent.isDirectory())
+      continue;
+    const skillName = dirent.name;
+    const skillPath = path3.join(skillsDir, skillName);
+    const skillMdPath = path3.join(skillPath, "SKILL.md");
+    if (!fs3.existsSync(skillMdPath)) {
+      console.warn(`[CliKit] Missing SKILL.md for skill: ${skillName}`);
+      continue;
+    }
+    try {
+      const fileContent = fs3.readFileSync(skillMdPath, "utf-8");
+      const { data, content } = import_gray_matter3.default(fileContent);
+      skills[skillName] = {
+        name: data.name || skillName,
+        description: data.description || "",
+        content: content.trim(),
+        location: skillPath
+      };
+    } catch (err) {
+      console.warn(`[CliKit] Failed to parse skill ${skillName}:`, err);
+    }
+  }
+  return skills;
+}
+
+// src/config.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
 import * as os from "os";
 var DEFAULT_CONFIG = {
   disabled_agents: [],
   disabled_commands: [],
+  disabled_skills: [],
   agents: {},
   commands: {},
+  skills: {},
   lsp: {},
   hooks: {
-    session_logging: true,
+    session_logging: false,
     tool_logging: false,
     todo_enforcer: {
       enabled: true,
@@ -3611,7 +3713,7 @@ var DEFAULT_CONFIG = {
     },
     empty_message_sanitizer: {
       enabled: true,
-      log_empty: true,
+      log_empty: false,
       placeholder: "(No output)"
     },
     git_guard: {
@@ -3625,68 +3727,112 @@ var DEFAULT_CONFIG = {
     subagent_question_blocker: {
       enabled: true
     },
-    comment_checker: {
-      enabled: true,
-      threshold: 0.3
-    },
-    env_context: {
-      enabled: true,
-      include_git: true,
-      include_package: true,
-      include_structure: true,
-      max_depth: 2
-    },
-    auto_format: {
-      enabled: false,
-      log: true
-    },
-    typecheck_gate: {
-      enabled: false,
-      log: true,
-      block_on_error: false
-    },
-    session_notification: {
-      enabled: true,
-      on_idle: true,
-      on_error: true,
-      title_prefix: "OpenCode"
-    },
     truncator: {
       enabled: true,
       max_output_chars: 30000,
       max_output_lines: 500,
       preserve_head_lines: 50,
       preserve_tail_lines: 50,
-      log: true
-    },
-    compaction: {
-      enabled: true,
-      include_beads_state: true,
-      include_memory_refs: true,
-      include_todo_state: true,
-      max_state_chars: 5000
+      log: false
     },
     swarm_enforcer: {
       enabled: true,
       strict_file_locking: true,
       block_unreserved_edits: false,
-      log: true
+      log: false
+    },
+    memory_digest: {
+      enabled: true,
+      max_per_type: 10,
+      include_types: ["decision", "learning", "blocker", "progress", "handoff"],
+      log: false
+    },
+    todo_beads_sync: {
+      enabled: true,
+      close_missing: true,
+      log: false
     }
   }
 };
 function getUserConfigDir() {
   if (process.platform === "win32") {
-    return process.env.APPDATA || path3.join(os.homedir(), "AppData", "Roaming");
+    return process.env.APPDATA || path4.join(os.homedir(), "AppData", "Roaming");
+  }
+  return process.env.XDG_CONFIG_HOME || path4.join(os.homedir(), ".config");
+}
+function getOpenCodeConfigDir() {
+  if (process.env.OPENCODE_CONFIG_DIR) {
+    return process.env.OPENCODE_CONFIG_DIR;
   }
-  return process.env.XDG_CONFIG_HOME || path3.join(os.homedir(), ".config");
+  return path4.join(getUserConfigDir(), "opencode");
+}
+function stripJsonComments(content) {
+  let result = "";
+  let inString = false;
+  let inSingleLineComment = false;
+  let inMultiLineComment = false;
+  let escaped = false;
+  for (let i = 0;i < content.length; i += 1) {
+    const char = content[i];
+    const nextChar = content[i + 1];
+    if (inSingleLineComment) {
+      if (char === `
+`) {
+        inSingleLineComment = false;
+        result += char;
+      }
+      continue;
+    }
+    if (inMultiLineComment) {
+      if (char === "*" && nextChar === "/") {
+        inMultiLineComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      result += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      result += char;
+      continue;
+    }
+    if (char === "/" && nextChar === "/") {
+      inSingleLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (char === "/" && nextChar === "*") {
+      inMultiLineComment = true;
+      i += 1;
+      continue;
+    }
+    result += char;
+  }
+  return result;
 }
 function loadJsonFile(filePath) {
   try {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       return null;
     }
-    const content = fs3.readFileSync(filePath, "utf-8");
-    return JSON.parse(content);
+    const content = fs4.readFileSync(filePath, "utf-8");
+    try {
+      return JSON.parse(content);
+    } catch {
+      const withoutComments = stripJsonComments(content);
+      const withoutTrailingCommas = withoutComments.replace(/,\s*([}\]])/g, "$1");
+      return JSON.parse(withoutTrailingCommas);
+    }
   } catch (error) {
     console.warn(`[CliKit] Failed to load config from ${filePath}:`, error);
     return null;
@@ -3707,18 +3853,25 @@ function deepMerge(base, override) {
 }
 function loadCliKitConfig(projectDirectory) {
   const safeDir = typeof projectDirectory === "string" && projectDirectory ? projectDirectory : process.cwd();
-  const userConfigPath = path3.join(getUserConfigDir(), "opencode", "clikit.config.json");
-  const projectConfigPath = path3.join(safeDir, ".opencode", "clikit.config.json");
+  const userBaseDir = getOpenCodeConfigDir();
+  const projectBaseDir = path4.join(safeDir, ".opencode");
+  const configCandidates = ["clikit.jsonc", "clikit.json", "clikit.config.json"];
   let config = { ...DEFAULT_CONFIG };
-  const userConfig = loadJsonFile(userConfigPath);
-  if (userConfig) {
-    config = deepMerge(config, userConfig);
-    console.log(`[CliKit] Loaded user config from ${userConfigPath}`);
+  for (const candidate of configCandidates) {
+    const userConfigPath = path4.join(userBaseDir, candidate);
+    const userConfig = loadJsonFile(userConfigPath);
+    if (userConfig) {
+      config = deepMerge(config, userConfig);
+      break;
+    }
   }
-  const projectConfig = loadJsonFile(projectConfigPath);
-  if (projectConfig) {
-    config = deepMerge(config, projectConfig);
-    console.log(`[CliKit] Loaded project config from ${projectConfigPath}`);
+  for (const candidate of configCandidates) {
+    const projectConfigPath = path4.join(projectBaseDir, candidate);
+    const projectConfig = loadJsonFile(projectConfigPath);
+    if (projectConfig) {
+      config = deepMerge(config, projectConfig);
+      break;
+    }
   }
   return config;
 }
@@ -3763,6 +3916,53 @@ function filterCommands(commands, config) {
   }
   return filtered;
 }
+function isSkillsConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function filterSkills(skills, config) {
+  if (!config?.skills) {
+    return skills;
+  }
+  const skillsConfig = config.skills;
+  if (Array.isArray(skillsConfig)) {
+    return Object.fromEntries(Object.entries(skills).filter(([name]) => skillsConfig.includes(name)));
+  }
+  let enabledSet = null;
+  let disabledSet = new Set(config.disabled_skills || []);
+  let overrides = {};
+  if (isSkillsConfigObject(skillsConfig)) {
+    if (Array.isArray(skillsConfig.enable) && skillsConfig.enable.length > 0) {
+      enabledSet = new Set(skillsConfig.enable);
+    }
+    if (Array.isArray(skillsConfig.disable) && skillsConfig.disable.length > 0) {
+      disabledSet = new Set(skillsConfig.disable);
+    }
+    const { sources: _sources, enable: _enable, disable: _disable, ...rest } = skillsConfig;
+    overrides = rest;
+  }
+  const filtered = {};
+  for (const [name, skill] of Object.entries(skills)) {
+    if (enabledSet && !enabledSet.has(name)) {
+      continue;
+    }
+    if (disabledSet.has(name)) {
+      continue;
+    }
+    const override = overrides[name];
+    if (override === false) {
+      continue;
+    }
+    if (override && typeof override === "object") {
+      filtered[name] = {
+        ...skill,
+        ...override.description ? { description: override.description } : {}
+      };
+      continue;
+    }
+    filtered[name] = skill;
+  }
+  return filtered;
+}
 
 // src/hooks/todo-enforcer.ts
 var EMPTY_RESULT = {
@@ -4044,520 +4244,6 @@ function isSubagentTool(toolName) {
 function formatBlockerWarning() {
   return `[CliKit:subagent-blocker] Subagent attempted to ask clarifying questions. Subagents should execute autonomously.`;
 }
-// src/hooks/comment-checker.ts
-var EXCESSIVE_COMMENT_PATTERNS = [
-  /\/\/\s*TODO:?\s*$/i,
-  /\/\/\s*This (?:function|method|class|variable|constant)/i,
-  /\/\/\s*(?:Initialize|Create|Set up|Configure|Define|Declare) the/i,
-  /\/\/\s*(?:Import|Export|Return|Handle|Process|Get|Set|Update|Delete|Add|Remove) /i,
-  /\/\*\*?\s*\n\s*\*\s*(?:This|The|A|An) (?:function|method|class|component)/i,
-  /#\s*(?:This|The|A|An) (?:function|method|class|script)/i
-];
-function checkCommentDensity(content, threshold = 0.3) {
-  if (typeof content !== "string") {
-    return { excessive: false, count: 0, totalLines: 0, ratio: 0 };
-  }
-  const lines = content.split(`
-`);
-  const totalLines = lines.filter((l) => l.trim().length > 0).length;
-  if (totalLines === 0) {
-    return { excessive: false, count: 0, totalLines: 0, ratio: 0 };
-  }
-  let commentLines = 0;
-  let inBlockComment = false;
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (inBlockComment) {
-      commentLines++;
-      if (trimmed.includes("*/")) {
-        inBlockComment = false;
-      }
-      continue;
-    }
-    if (trimmed.startsWith("/*")) {
-      commentLines++;
-      if (!trimmed.includes("*/")) {
-        inBlockComment = true;
-      }
-      continue;
-    }
-    if (trimmed.startsWith("//")) {
-      commentLines++;
-    } else if (trimmed.startsWith("#") && !trimmed.startsWith("#!") && !trimmed.startsWith("# ")) {
-      const rest = trimmed.slice(1).trim();
-      if (rest.length > 0 && !rest.includes(":") && !rest.startsWith(" ") === false) {
-        commentLines++;
-      }
-    }
-  }
-  const ratio = commentLines / totalLines;
-  return {
-    excessive: ratio > threshold,
-    count: commentLines,
-    totalLines,
-    ratio
-  };
-}
-function hasExcessiveAIComments(content) {
-  if (typeof content !== "string") {
-    return false;
-  }
-  let matches = 0;
-  for (const pattern of EXCESSIVE_COMMENT_PATTERNS) {
-    const found = content.match(new RegExp(pattern, "gm"));
-    if (found) {
-      matches += found.length;
-    }
-  }
-  return matches >= 5;
-}
-function formatCommentWarning(result) {
-  const pct = (result.ratio * 100).toFixed(0);
-  return `[CliKit:comment-checker] ${result.count}/${result.totalLines} lines are comments (${pct}%). Reduce unnecessary comments \u2014 code should be self-documenting.`;
-}
-// src/hooks/env-context.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-import { execSync } from "child_process";
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function runSilent(cmd, cwd) {
-  try {
-    return execSync(cmd, { cwd, encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
-  } catch {
-    return null;
-  }
-}
-function getGitInfo(cwd) {
-  const branch = runSilent("git rev-parse --abbrev-ref HEAD", cwd);
-  if (!branch)
-    return;
-  const status = runSilent("git status --porcelain", cwd);
-  const remoteUrl = runSilent("git remote get-url origin", cwd);
-  const lastCommit = runSilent("git log -1 --format=%s", cwd);
-  return {
-    branch,
-    hasChanges: !!status && status.length > 0,
-    remoteUrl: remoteUrl || undefined,
-    lastCommit: lastCommit || undefined
-  };
-}
-function getPackageInfo(cwd) {
-  const pkgPath = path4.join(cwd, "package.json");
-  if (!fs4.existsSync(pkgPath))
-    return;
-  try {
-    const parsed = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
-    const pkg = isRecord(parsed) ? parsed : {};
-    const scriptsObj = isRecord(pkg.scripts) ? pkg.scripts : {};
-    const scripts = Object.keys(scriptsObj);
-    let packageManager;
-    if (fs4.existsSync(path4.join(cwd, "bun.lockb")) || fs4.existsSync(path4.join(cwd, "bun.lock"))) {
-      packageManager = "bun";
-    } else if (fs4.existsSync(path4.join(cwd, "pnpm-lock.yaml"))) {
-      packageManager = "pnpm";
-    } else if (fs4.existsSync(path4.join(cwd, "yarn.lock"))) {
-      packageManager = "yarn";
-    } else if (fs4.existsSync(path4.join(cwd, "package-lock.json"))) {
-      packageManager = "npm";
-    }
-    let framework;
-    const deps = isRecord(pkg.dependencies) ? pkg.dependencies : {};
-    const devDeps = isRecord(pkg.devDependencies) ? pkg.devDependencies : {};
-    const allDeps = { ...deps, ...devDeps };
-    if (allDeps["next"])
-      framework = "Next.js";
-    else if (allDeps["nuxt"])
-      framework = "Nuxt";
-    else if (allDeps["@angular/core"])
-      framework = "Angular";
-    else if (allDeps["svelte"])
-      framework = "Svelte";
-    else if (allDeps["vue"])
-      framework = "Vue";
-    else if (allDeps["react"])
-      framework = "React";
-    else if (allDeps["express"])
-      framework = "Express";
-    else if (allDeps["fastify"])
-      framework = "Fastify";
-    else if (allDeps["hono"])
-      framework = "Hono";
-    return {
-      name: typeof pkg.name === "string" ? pkg.name : undefined,
-      version: typeof pkg.version === "string" ? pkg.version : undefined,
-      packageManager,
-      scripts,
-      framework
-    };
-  } catch {
-    return;
-  }
-}
-function getTopLevelStructure(cwd, maxDepth = 2) {
-  const entries = [];
-  function walk(dir, depth, prefix) {
-    if (depth > maxDepth)
-      return;
-    try {
-      const items = fs4.readdirSync(dir, { withFileTypes: true });
-      const filtered = items.filter((i) => !i.name.startsWith(".") && i.name !== "node_modules" && i.name !== "dist" && i.name !== "__pycache__").sort((a, b) => {
-        if (a.isDirectory() && !b.isDirectory())
-          return -1;
-        if (!a.isDirectory() && b.isDirectory())
-          return 1;
-        return a.name.localeCompare(b.name);
-      });
-      for (const item of filtered.slice(0, 20)) {
-        const suffix = item.isDirectory() ? "/" : "";
-        entries.push(`${prefix}${item.name}${suffix}`);
-        if (item.isDirectory() && depth < maxDepth) {
-          walk(path4.join(dir, item.name), depth + 1, prefix + "  ");
-        }
-      }
-    } catch {}
-  }
-  walk(cwd, 1, "");
-  return entries;
-}
-function collectEnvInfo(cwd, config) {
-  const safeCwd = typeof cwd === "string" && cwd ? cwd : process.cwd();
-  const info = {
-    platform: process.platform,
-    nodeVersion: process.version,
-    cwd: safeCwd
-  };
-  if (config?.include_git !== false) {
-    info.git = getGitInfo(safeCwd);
-  }
-  if (config?.include_package !== false) {
-    info.package = getPackageInfo(safeCwd);
-  }
-  if (config?.include_structure !== false) {
-    info.structure = getTopLevelStructure(safeCwd, config?.max_depth ?? 2);
-  }
-  return info;
-}
-function buildEnvBlock(info) {
-  const lines = ["<env-context>"];
-  lines.push(`Platform: ${info.platform}`);
-  lines.push(`Node: ${info.nodeVersion}`);
-  lines.push(`CWD: ${info.cwd}`);
-  if (info.git) {
-    lines.push(`
-Git:`);
-    lines.push(`  Branch: ${info.git.branch}`);
-    lines.push(`  Dirty: ${info.git.hasChanges}`);
-    if (info.git.remoteUrl)
-      lines.push(`  Remote: ${info.git.remoteUrl}`);
-    if (info.git.lastCommit)
-      lines.push(`  Last commit: ${info.git.lastCommit}`);
-  }
-  if (info.package) {
-    lines.push(`
-Package:`);
-    if (info.package.name)
-      lines.push(`  Name: ${info.package.name}`);
-    if (info.package.version)
-      lines.push(`  Version: ${info.package.version}`);
-    if (info.package.packageManager)
-      lines.push(`  Package manager: ${info.package.packageManager}`);
-    if (info.package.framework)
-      lines.push(`  Framework: ${info.package.framework}`);
-    if (info.package.scripts?.length) {
-      lines.push(`  Scripts: ${info.package.scripts.join(", ")}`);
-    }
-  }
-  if (info.structure?.length) {
-    lines.push(`
-Project structure:`);
-    for (const entry of info.structure) {
-      lines.push(`  ${entry}`);
-    }
-  }
-  lines.push("</env-context>");
-  return lines.join(`
-`);
-}
-function formatEnvSummary(info) {
-  const parts = [`${info.platform}/${info.nodeVersion}`];
-  if (info.git)
-    parts.push(`branch:${info.git.branch}`);
-  if (info.package?.framework)
-    parts.push(info.package.framework);
-  if (info.package?.packageManager)
-    parts.push(info.package.packageManager);
-  return `[CliKit:env-context] ${parts.join(", ")}`;
-}
-// src/hooks/auto-format.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-import { execSync as execSync2 } from "child_process";
-var FORMATTERS = [
-  {
-    name: "prettier",
-    configFiles: [".prettierrc", ".prettierrc.json", ".prettierrc.js", ".prettierrc.cjs", ".prettierrc.yaml", ".prettierrc.yml", "prettier.config.js", "prettier.config.cjs"],
-    command: (file) => `npx prettier --write "${file}"`
-  },
-  {
-    name: "biome",
-    configFiles: ["biome.json", "biome.jsonc"],
-    command: (file) => `npx @biomejs/biome format --write "${file}"`
-  },
-  {
-    name: "dprint",
-    configFiles: ["dprint.json", ".dprint.json"],
-    command: (file) => `dprint fmt "${file}"`
-  }
-];
-var DEFAULT_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".json", ".css", ".scss", ".html", ".md", ".yaml", ".yml"];
-function detectFormatter(projectDir) {
-  const pkgPath = path5.join(projectDir, "package.json");
-  let pkgDeps = {};
-  try {
-    if (fs5.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
-      pkgDeps = { ...pkg.dependencies, ...pkg.devDependencies };
-    }
-  } catch {}
-  for (const formatter of FORMATTERS) {
-    for (const configFile of formatter.configFiles) {
-      if (fs5.existsSync(path5.join(projectDir, configFile))) {
-        return formatter;
-      }
-    }
-    if (pkgDeps[formatter.name] || pkgDeps[`@biomejs/${formatter.name}`]) {
-      return formatter;
-    }
-  }
-  return;
-}
-function shouldFormat(filePath, extensions) {
-  if (typeof filePath !== "string")
-    return false;
-  const ext = path5.extname(filePath).toLowerCase();
-  const allowedExts = extensions || DEFAULT_EXTENSIONS;
-  return allowedExts.includes(ext);
-}
-function runFormatter(filePath, projectDir, formatterOverride) {
-  const safePath = typeof filePath === "string" && filePath ? filePath : "";
-  const safeDir = typeof projectDir === "string" && projectDir ? projectDir : process.cwd();
-  const formatter = formatterOverride ? FORMATTERS.find((f) => f.name === formatterOverride) : detectFormatter(safeDir);
-  if (!formatter || !safePath) {
-    return {
-      formatted: false,
-      file: safePath,
-      formatter: "none",
-      error: formatter ? "No file path provided" : "No formatter detected"
-    };
-  }
-  try {
-    const cmd = formatter.command(safePath);
-    execSync2(cmd, {
-      cwd: safeDir,
-      timeout: 1e4,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return {
-      formatted: true,
-      file: safePath,
-      formatter: formatter.name
-    };
-  } catch (err) {
-    return {
-      formatted: false,
-      file: safePath,
-      formatter: formatter.name,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-}
-function formatAutoFormatLog(result) {
-  if (result.formatted) {
-    return `[CliKit:auto-format] Formatted ${result.file} with ${result.formatter}`;
-  }
-  return `[CliKit:auto-format] Failed to format ${result.file}: ${result.error}`;
-}
-// src/hooks/typecheck-gate.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
-import { execSync as execSync3 } from "child_process";
-function normalizeTypeCheckResult(result) {
-  if (!result || typeof result !== "object") {
-    return { clean: true, errors: [], checkedFile: "" };
-  }
-  const raw = result;
-  const errors = Array.isArray(raw.errors) ? raw.errors.filter((item) => !!item && typeof item === "object").map((item) => ({
-    file: typeof item.file === "string" ? item.file : "",
-    line: typeof item.line === "number" ? item.line : 0,
-    column: typeof item.column === "number" ? item.column : 0,
-    code: typeof item.code === "string" ? item.code : "TS0000",
-    message: typeof item.message === "string" ? item.message : "Unknown typecheck error"
-  })) : [];
-  const checkedFile = typeof raw.checkedFile === "string" ? raw.checkedFile : "";
-  const clean = typeof raw.clean === "boolean" ? raw.clean : errors.length === 0;
-  return { clean, errors, checkedFile };
-}
-var TS_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
-function isTypeScriptFile(filePath) {
-  if (typeof filePath !== "string")
-    return false;
-  return TS_EXTENSIONS.includes(path6.extname(filePath).toLowerCase());
-}
-function findTsConfig(projectDir, override) {
-  const safeDir = typeof projectDir === "string" && projectDir ? projectDir : process.cwd();
-  if (override) {
-    const overridePath = path6.resolve(safeDir, override);
-    return fs6.existsSync(overridePath) ? overridePath : undefined;
-  }
-  const candidates = ["tsconfig.json", "tsconfig.build.json"];
-  for (const candidate of candidates) {
-    const fullPath = path6.join(safeDir, candidate);
-    if (fs6.existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  return;
-}
-function runTypeCheck(filePath, projectDir, config) {
-  const safePath = typeof filePath === "string" && filePath ? filePath : "";
-  const safeDir = typeof projectDir === "string" && projectDir ? projectDir : process.cwd();
-  const tsConfig = findTsConfig(safeDir, config?.tsconfig);
-  if (!tsConfig) {
-    return { clean: true, errors: [], checkedFile: safePath };
-  }
-  try {
-    const tscCmd = `npx tsc --noEmit --pretty false -p "${tsConfig}"`;
-    execSync3(tscCmd, {
-      cwd: safeDir,
-      timeout: 30000,
-      stdio: ["pipe", "pipe", "pipe"],
-      encoding: "utf-8"
-    });
-    return { clean: true, errors: [], checkedFile: safePath };
-  } catch (err) {
-    const output = err instanceof Error && "stdout" in err ? String(err.stdout) : "";
-    const errors = parseTscOutput(output, safePath);
-    return {
-      clean: errors.length === 0,
-      errors,
-      checkedFile: safePath
-    };
-  }
-}
-function parseTscOutput(output, filterFile) {
-  if (typeof output !== "string")
-    return [];
-  const diagnostics = [];
-  const lines = output.split(`
-`);
-  const pattern = /^(.+?)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/;
-  for (const line of lines) {
-    const match = line.match(pattern);
-    if (match) {
-      const [, file, lineNum, col, code, message] = match;
-      const diagnostic = {
-        file: file.trim(),
-        line: parseInt(lineNum, 10),
-        column: parseInt(col, 10),
-        code,
-        message: message.trim()
-      };
-      if (filterFile) {
-        const normalizedFilter = path6.resolve(filterFile);
-        const normalizedDiag = path6.resolve(diagnostic.file);
-        if (normalizedDiag === normalizedFilter) {
-          diagnostics.push(diagnostic);
-        }
-      } else {
-        diagnostics.push(diagnostic);
-      }
-    }
-  }
-  return diagnostics;
-}
-function formatTypeCheckWarning(result) {
-  const safeResult = normalizeTypeCheckResult(result);
-  if (safeResult.clean) {
-    return `[CliKit:typecheck] ${safeResult.checkedFile} \u2014 no type errors`;
-  }
-  const lines = [`[CliKit:typecheck] ${safeResult.errors.length} type error(s) in ${safeResult.checkedFile}:`];
-  for (const err of safeResult.errors.slice(0, 10)) {
-    lines.push(`  ${err.file}:${err.line}:${err.column} ${err.code}: ${err.message}`);
-  }
-  if (safeResult.errors.length > 10) {
-    lines.push(`  ... and ${safeResult.errors.length - 10} more`);
-  }
-  return lines.join(`
-`);
-}
-// src/hooks/session-notification.ts
-import { execSync as execSync4 } from "child_process";
-function escapeSingleQuotes(str2) {
-  return str2.replace(/'/g, "'\\''");
-}
-function getNotifyCommand(payload) {
-  const { title, body, urgency } = payload;
-  const safeTitle = typeof title === "string" ? title : "Notification";
-  const safeBody = typeof body === "string" ? body : "";
-  const escapedTitle = safeTitle.replace(/"/g, "\\\"");
-  const escapedBody = safeBody.replace(/"/g, "\\\"");
-  switch (process.platform) {
-    case "linux":
-      return `notify-send "${escapedTitle}" "${escapedBody}" --urgency=${urgency || "normal"}`;
-    case "darwin":
-      return `osascript -e 'display notification "${escapedBody}" with title "${escapedTitle}"'`;
-    case "win32":
-      return `powershell -command "[void] [System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); $n = New-Object System.Windows.Forms.NotifyIcon; $n.Icon = [System.Drawing.SystemIcons]::Information; $n.Visible = $true; $n.ShowBalloonTip(5000, '${escapeSingleQuotes(safeTitle)}', '${escapeSingleQuotes(safeBody)}', [System.Windows.Forms.ToolTipIcon]::Info)"`;
-    default:
-      return null;
-  }
-}
-function sendNotification(payload) {
-  const cmd = getNotifyCommand(payload);
-  if (!cmd)
-    return false;
-  try {
-    execSync4(cmd, { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
-    return true;
-  } catch {
-    if (process.platform === "linux") {
-      try {
-        const wslTitle = escapeSingleQuotes(typeof payload.title === "string" ? payload.title : "Notification");
-        const wslBody = escapeSingleQuotes(typeof payload.body === "string" ? payload.body : "");
-        const wslCmd = `powershell.exe -command "[void] [System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); $n = New-Object System.Windows.Forms.NotifyIcon; $n.Icon = [System.Drawing.SystemIcons]::Information; $n.Visible = $true; $n.ShowBalloonTip(5000, '${wslTitle}', '${wslBody}', [System.Windows.Forms.ToolTipIcon]::Info)"`;
-        execSync4(wslCmd, { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return false;
-  }
-}
-function buildIdleNotification(sessionId, prefix) {
-  const titlePrefix = prefix || "OpenCode";
-  const sid = typeof sessionId === "string" ? sessionId : undefined;
-  return {
-    title: `${titlePrefix} \u2014 Task Complete`,
-    body: sid ? `Session ${sid.substring(0, 8)} is idle and waiting for input.` : "Session is idle and waiting for input.",
-    urgency: "normal"
-  };
-}
-function buildErrorNotification(error, sessionId, prefix) {
-  const titlePrefix = prefix || "OpenCode";
-  const errorStr = typeof error === "string" ? error : error instanceof Error ? error.message : String(error);
-  const sid = typeof sessionId === "string" ? sessionId : undefined;
-  return {
-    title: `${titlePrefix} \u2014 Error`,
-    body: sid ? `Session ${sid.substring(0, 8)}: ${errorStr.substring(0, 100)}` : errorStr.substring(0, 120),
-    urgency: "critical"
-  };
-}
-function formatNotificationLog(payload, sent) {
-  return sent ? `[CliKit:notification] Sent: "${payload.title}"` : `[CliKit:notification] Failed to send notification (platform: ${process.platform})`;
-}
 // src/hooks/truncator.ts
 var DEFAULT_MAX_CHARS = 30000;
 var DEFAULT_MAX_LINES = 500;
@@ -4665,266 +4351,422 @@ function formatTruncationLog(result) {
   const saved = result.originalLength - result.truncatedLength;
   return `[CliKit:truncator] Truncated output: ${result.originalLines} \u2192 ${result.truncatedLines} lines, saved ${(saved / 1024).toFixed(1)}KB`;
 }
-// src/hooks/compaction.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
-import { execSync as execSync5 } from "child_process";
-function isRecord2(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isTodoStatus(value) {
-  return value === "todo" || value === "in-progress" || value === "in_progress" || value === "completed";
-}
-function normalizeTodoEntries(todos) {
-  if (!Array.isArray(todos)) {
-    return [];
+// src/hooks/swarm-enforcer.ts
+import * as path5 from "path";
+function isFileInScope(filePath, scope) {
+  if (typeof filePath !== "string")
+    return false;
+  const normalizedPath = path5.resolve(filePath);
+  for (const reserved of scope.reservedFiles) {
+    const normalizedReserved = path5.resolve(reserved);
+    if (normalizedPath === normalizedReserved) {
+      return true;
+    }
   }
-  const normalized = [];
-  for (const entry of todos) {
-    if (!isRecord2(entry) || !isTodoStatus(entry.status)) {
-      continue;
+  if (scope.allowedPatterns) {
+    for (const pattern of scope.allowedPatterns) {
+      if (normalizedPath.includes(pattern) || normalizedPath.startsWith(path5.resolve(pattern))) {
+        return true;
+      }
     }
-    normalized.push({
-      id: typeof entry.id === "string" ? entry.id : "unknown",
-      content: typeof entry.content === "string" ? entry.content : "(no content)",
-      status: entry.status === "in_progress" ? "in-progress" : entry.status
-    });
   }
-  return normalized;
+  return false;
 }
-function readBeadsState(projectDir) {
-  if (typeof projectDir !== "string" || !projectDir) {
-    return;
+function checkEditPermission(filePath, scope, config) {
+  if (!scope) {
+    return { allowed: true };
   }
-  const beadsDir = path7.join(projectDir, ".beads");
-  if (!fs7.existsSync(beadsDir))
+  if (config?.strict_file_locking === false) {
+    return { allowed: true };
+  }
+  if (typeof filePath !== "string") {
+    return { allowed: false, reason: "Invalid file path" };
+  }
+  if (isFileInScope(filePath, scope)) {
+    return { allowed: true, file: filePath };
+  }
+  return {
+    allowed: false,
+    file: filePath,
+    reason: `File is not in task scope for task ${scope.taskId}`,
+    suggestion: `Reserve the file first using beads-village reserve, or ask the lead agent to reassign.`
+  };
+}
+function extractFileFromToolInput(toolName, input) {
+  if (typeof toolName !== "string")
     return;
-  const state = {};
-  try {
-    const metaPath = path7.join(beadsDir, "metadata.json");
-    if (!fs7.existsSync(metaPath))
+  switch (toolName.toLowerCase()) {
+    case "edit":
+    case "write":
+    case "read":
+      return input.filePath;
+    case "bash": {
+      const cmd = input.command;
+      if (!cmd)
+        return;
+      const writePatterns = [
+        />\s*["']?([^\s"'|&;]+)/,
+        /tee\s+["']?([^\s"'|&;]+)/,
+        /mv\s+\S+\s+["']?([^\s"'|&;]+)/,
+        /cp\s+\S+\s+["']?([^\s"'|&;]+)/
+      ];
+      for (const pattern of writePatterns) {
+        const match = cmd.match(pattern);
+        if (match)
+          return match[1];
+      }
       return;
-    const meta = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
-    if (!meta.database)
+    }
+    default:
       return;
+  }
+}
+function formatEnforcementWarning(result) {
+  if (result.allowed)
+    return "";
+  const lines = [`[CliKit:swarm-enforcer] BLOCKED edit to ${result.file}`];
+  if (result.reason)
+    lines.push(`  Reason: ${result.reason}`);
+  if (result.suggestion)
+    lines.push(`  Suggestion: ${result.suggestion}`);
+  return lines.join(`
+`);
+}
+// src/hooks/memory-digest.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import { Database } from "bun:sqlite";
+function parseJsonArray(value) {
+  if (typeof value !== "string" || !value.trim())
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
   } catch {
-    return;
+    return [];
   }
-  const reservationsDir = path7.join(projectDir, ".reservations");
-  if (fs7.existsSync(reservationsDir)) {
+}
+function formatDate(iso) {
+  try {
+    return iso.split("T")[0] || iso.substring(0, 10);
+  } catch {
+    return iso;
+  }
+}
+function generateMemoryDigest(projectDir, config) {
+  const result = { written: false, path: "", counts: {} };
+  if (typeof projectDir !== "string" || !projectDir)
+    return result;
+  const memoryDir = path6.join(projectDir, ".opencode", "memory");
+  const dbPath = path6.join(memoryDir, "memory.db");
+  if (!fs5.existsSync(dbPath)) {
+    return result;
+  }
+  const maxPerType = config?.max_per_type ?? 10;
+  const includeTypes = config?.include_types ?? [
+    "decision",
+    "learning",
+    "blocker",
+    "progress",
+    "handoff"
+  ];
+  let db;
+  try {
+    db = new Database(dbPath, { readonly: true });
+  } catch {
+    return result;
+  }
+  const sections = [];
+  sections.push("# Memory Digest");
+  sections.push("");
+  sections.push(`> Auto-generated on ${new Date().toISOString().split("T")[0]}. Read-only reference for agents.`);
+  sections.push(`> Source: \`.opencode/memory/memory.db\``);
+  sections.push("");
+  const typeLabels = {
+    decision: { heading: "Past Decisions", emoji: "\uD83D\uDD37" },
+    learning: { heading: "Learnings & Gotchas", emoji: "\uD83D\uDCA1" },
+    blocker: { heading: "Past Blockers", emoji: "\uD83D\uDEA7" },
+    progress: { heading: "Recent Progress", emoji: "\uD83D\uDCC8" },
+    handoff: { heading: "Session Handoffs", emoji: "\uD83D\uDD04" }
+  };
+  let totalCount = 0;
+  for (const type of includeTypes) {
     try {
-      const lockFiles = fs7.readdirSync(reservationsDir).filter((f) => f.endsWith(".lock"));
-      const reservedFiles = [];
-      for (const lockFile of lockFiles) {
-        try {
-          const raw = fs7.readFileSync(path7.join(reservationsDir, lockFile), "utf-8");
-          const lock = JSON.parse(raw);
-          if (isRecord2(lock) && typeof lock.path === "string") {
-            reservedFiles.push(lock.path);
-          }
-          if (isRecord2(lock) && typeof lock.agent === "string") {
-            state.agentId = lock.agent;
+      const rows = db.prepare(`SELECT * FROM observations WHERE type = ? ORDER BY created_at DESC LIMIT ?`).all(type, maxPerType);
+      if (rows.length === 0)
+        continue;
+      result.counts[type] = rows.length;
+      totalCount += rows.length;
+      const label = typeLabels[type] || { heading: type, emoji: "\uD83D\uDCCC" };
+      sections.push(`## ${label.emoji} ${label.heading}`);
+      sections.push("");
+      for (const row of rows) {
+        const date = formatDate(row.created_at);
+        const facts = parseJsonArray(row.facts);
+        const concepts = parseJsonArray(row.concepts);
+        const filesModified = parseJsonArray(row.files_modified);
+        sections.push(`### ${date} \u2014 ${row.narrative.split(`
+`)[0]}`);
+        if (row.confidence < 1) {
+          sections.push(`> Confidence: ${(row.confidence * 100).toFixed(0)}%`);
+        }
+        sections.push("");
+        if (row.narrative.includes(`
+`)) {
+          sections.push(row.narrative);
+          sections.push("");
+        }
+        if (facts.length > 0) {
+          sections.push("**Facts:**");
+          for (const fact of facts) {
+            sections.push(`- ${fact}`);
           }
-        } catch {}
-      }
-      if (reservedFiles.length > 0) {
-        state.reservedFiles = reservedFiles;
+          sections.push("");
+        }
+        if (filesModified.length > 0) {
+          sections.push(`**Files:** ${filesModified.map((f) => `\`${f}\``).join(", ")}`);
+          sections.push("");
+        }
+        if (concepts.length > 0) {
+          sections.push(`**Concepts:** ${concepts.join(", ")}`);
+          sections.push("");
+        }
+        if (row.bead_id) {
+          sections.push(`**Bead:** ${row.bead_id}`);
+          sections.push("");
+        }
+        sections.push("---");
+        sections.push("");
       }
     } catch {}
   }
   try {
-    const output = execSync5("bd ls --status in_progress --json 2>/dev/null", {
-      cwd: projectDir,
-      timeout: 5000,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    if (output.trim()) {
-      const tasks = JSON.parse(output);
-      if (Array.isArray(tasks) && tasks.length > 0) {
-        const first = tasks[0];
-        if (isRecord2(first)) {
-          const title = typeof first.title === "string" ? first.title : undefined;
-          const shortTitle = typeof first.t === "string" ? first.t : undefined;
-          const id = typeof first.id === "string" ? first.id : undefined;
-          if (title || shortTitle)
-            state.currentTask = title || shortTitle;
-          if (id)
-            state.taskId = id;
-        }
-        state.inProgressCount = tasks.length;
-      }
-    }
+    db.close();
   } catch {}
+  if (totalCount === 0) {
+    sections.push("*No observations found in memory database.*");
+    sections.push("");
+  }
+  const digestPath = path6.join(memoryDir, "_digest.md");
+  const content = sections.join(`
+`);
   try {
-    const output = execSync5("bd ls --status open --json 2>/dev/null", {
-      cwd: projectDir,
-      timeout: 5000,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    if (output.trim()) {
-      const tasks = JSON.parse(output);
-      if (Array.isArray(tasks)) {
-        state.openCount = tasks.length;
-      }
+    if (!fs5.existsSync(memoryDir)) {
+      fs5.mkdirSync(memoryDir, { recursive: true });
     }
+    fs5.writeFileSync(digestPath, content, "utf-8");
+    result.written = true;
+    result.path = digestPath;
   } catch {}
-  if (state.currentTask || state.reservedFiles?.length || state.agentId || state.inProgressCount || state.openCount) {
-    return state;
+  return result;
+}
+function formatDigestLog(result) {
+  if (!result.written) {
+    return "[CliKit:memory-digest] No digest generated (no DB or empty)";
   }
-  return;
+  const parts = Object.entries(result.counts).map(([type, count]) => `${count} ${type}s`).join(", ");
+  return `[CliKit:memory-digest] Generated digest: ${parts || "empty"}`;
 }
-function readMemoryRefs(projectDir, limit = 10) {
-  if (typeof projectDir !== "string" || !projectDir) {
-    return [];
+// src/hooks/todo-beads-sync.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+import { Database as Database2 } from "bun:sqlite";
+function mapTodoStatusToIssueStatus(status) {
+  const value = status.toLowerCase();
+  if (value === "completed" || value === "done" || value === "cancelled") {
+    return "closed";
   }
-  const memoryDir = path7.join(projectDir, ".opencode", "memory");
-  if (!fs7.existsSync(memoryDir))
-    return [];
-  const MEMORY_SUBDIRS = ["specs", "plans", "research", "reviews", "handoffs", "beads"];
-  const refs = [];
-  try {
-    for (const subdir of MEMORY_SUBDIRS) {
-      const subdirPath = path7.join(memoryDir, subdir);
-      if (!fs7.existsSync(subdirPath))
-        continue;
-      const files = fs7.readdirSync(subdirPath).filter((f) => f.endsWith(".md") || f.endsWith(".json")).sort();
-      for (const file of files) {
-        if (file === ".gitkeep")
-          continue;
-        try {
-          const fullPath = path7.join(subdirPath, file);
-          const stat = fs7.statSync(fullPath);
-          const raw = fs7.readFileSync(fullPath, "utf-8");
-          if (typeof raw !== "string" || !raw.trim())
-            continue;
-          let summary;
-          const ext = path7.extname(file);
-          if (ext === ".md") {
-            const headingMatch = raw.match(/^#\s+(.+)$/m);
-            summary = headingMatch ? headingMatch[1] : raw.substring(0, 100).trim();
-          } else if (ext === ".json") {
-            const parsed = JSON.parse(raw);
-            const safe = isRecord2(parsed) ? parsed : {};
-            const content = safe.content;
-            const summaryText = typeof safe.summary === "string" ? safe.summary : undefined;
-            const titleText = typeof safe.title === "string" ? safe.title : undefined;
-            const contentText = typeof content === "string" ? content.substring(0, 100) : "";
-            summary = summaryText || titleText || contentText || "";
-          } else {
-            summary = raw.substring(0, 100).trim();
-          }
-          refs.push({
-            key: path7.basename(file, ext),
-            summary,
-            timestamp: stat.mtimeMs,
-            category: subdir
-          });
-        } catch {}
-      }
-    }
-    return refs.sort((a, b) => b.timestamp - a.timestamp).slice(0, limit);
-  } catch {
-    return [];
+  if (value === "in_progress" || value === "in-progress") {
+    return "in_progress";
   }
+  return "open";
 }
-function buildCompactionBlock(payload, maxChars = 5000) {
-  const lines = ["<compaction-context>"];
-  if (payload.sessionSummary) {
-    lines.push(`
-Session Summary: ${payload.sessionSummary}`);
-  }
-  if (payload.beads) {
-    lines.push(`
-Beads State:`);
-    if (payload.beads.currentTask)
-      lines.push(`  Current task: ${payload.beads.currentTask}`);
-    if (payload.beads.taskId)
-      lines.push(`  Task ID: ${payload.beads.taskId}`);
-    if (payload.beads.agentId)
-      lines.push(`  Agent: ${payload.beads.agentId}`);
-    if (payload.beads.team)
-      lines.push(`  Team: ${payload.beads.team}`);
-    if (payload.beads.inProgressCount)
-      lines.push(`  In-progress tasks: ${payload.beads.inProgressCount}`);
-    if (payload.beads.openCount)
-      lines.push(`  Open tasks: ${payload.beads.openCount}`);
-    if (payload.beads.reservedFiles?.length) {
-      lines.push(`  Reserved files: ${payload.beads.reservedFiles.join(", ")}`);
-    }
-  }
-  const normalizedTodos = normalizeTodoEntries(payload.todos);
-  if (normalizedTodos.length) {
-    lines.push(`
-Todo State:`);
-    for (const todo of normalizedTodos) {
-      const icon = todo.status === "completed" ? "[x]" : todo.status === "in-progress" ? "[~]" : "[ ]";
-      lines.push(`  ${icon} ${todo.id}: ${todo.content}`);
-    }
-  }
-  if (payload.memories?.length) {
-    lines.push(`
-Recent Memory References:`);
-    for (const mem of payload.memories) {
-      lines.push(`  - [${mem.category}] ${mem.key}: ${mem.summary}`);
-    }
-  }
-  lines.push("</compaction-context>");
-  const block = lines.join(`
-`);
-  if (typeof block !== "string")
-    return `<compaction-context>
-</compaction-context>`;
-  if (block.length > maxChars) {
-    return block.substring(0, maxChars) + `
-... [compaction context truncated]
-</compaction-context>`;
-  }
-  return block;
+function mapTodoPriorityToIssuePriority(priority) {
+  const value = (priority || "").toLowerCase();
+  if (value === "high")
+    return 1;
+  if (value === "low")
+    return 3;
+  return 2;
 }
-function collectCompactionPayload(projectDir, config) {
-  const payload = {};
-  if (typeof projectDir !== "string" || !projectDir) {
-    return payload;
-  }
-  if (config?.include_beads_state !== false) {
-    payload.beads = readBeadsState(projectDir);
+function sanitizeId(value) {
+  const normalized = value.replace(/[^a-zA-Z0-9_-]/g, "-");
+  return normalized.length > 0 ? normalized : "unknown";
+}
+function buildIssueId(sessionID, todoID) {
+  const sessionPart = sanitizeId(sessionID).slice(0, 16);
+  const todoPart = sanitizeId(todoID).slice(0, 32);
+  return `oc-${sessionPart}-${todoPart}`;
+}
+function syncTodosToBeads(projectDirectory, sessionID, todos, config) {
+  const beadsDbPath = path7.join(projectDirectory, ".beads", "beads.db");
+  if (!fs6.existsSync(beadsDbPath)) {
+    return {
+      synced: false,
+      sessionID,
+      totalTodos: todos.length,
+      created: 0,
+      updated: 0,
+      closed: 0,
+      skippedReason: "No .beads/beads.db found"
+    };
   }
-  if (config?.include_memory_refs !== false) {
-    payload.memories = readMemoryRefs(projectDir);
+  const db = new Database2(beadsDbPath);
+  let created = 0;
+  let updated = 0;
+  let closed = 0;
+  try {
+    const prefix = `opencode:todo:${sessionID}:`;
+    const existingRows = db.query("SELECT external_ref, status FROM issues WHERE external_ref LIKE ?").all(`${prefix}%`);
+    const existingByRef = new Map(existingRows.map((row) => [row.external_ref, row.status]));
+    const activeRefs = new Set;
+    const upsertIssue = db.prepare(`
+      INSERT INTO issues (
+        id, title, description, status, priority, issue_type, external_ref, source_repo, updated_at, closed_at
+      ) VALUES (?, ?, ?, ?, ?, 'task', ?, '.', CURRENT_TIMESTAMP, CASE WHEN ? = 'closed' THEN CURRENT_TIMESTAMP ELSE NULL END)
+      ON CONFLICT(external_ref) DO UPDATE SET
+        title = excluded.title,
+        description = excluded.description,
+        status = excluded.status,
+        priority = excluded.priority,
+        updated_at = CURRENT_TIMESTAMP,
+        closed_at = CASE
+          WHEN excluded.status = 'closed' THEN COALESCE(issues.closed_at, CURRENT_TIMESTAMP)
+          ELSE NULL
+        END
+    `);
+    for (const todo of todos) {
+      const externalRef = `${prefix}${todo.id}`;
+      activeRefs.add(externalRef);
+      const mappedStatus = mapTodoStatusToIssueStatus(todo.status);
+      const issueId = buildIssueId(sessionID, todo.id);
+      const title = (todo.content || "Untitled todo").slice(0, 500);
+      const priority = mapTodoPriorityToIssuePriority(todo.priority);
+      const description = `Synced from OpenCode todo ${todo.id} (session ${sessionID}).`;
+      if (existingByRef.has(externalRef)) {
+        updated += 1;
+      } else {
+        created += 1;
+      }
+      upsertIssue.run(issueId, title, description, mappedStatus, priority, externalRef, mappedStatus);
+    }
+    if (config?.close_missing !== false) {
+      const closeIssue = db.prepare("UPDATE issues SET status = 'closed', closed_at = COALESCE(closed_at, CURRENT_TIMESTAMP), updated_at = CURRENT_TIMESTAMP WHERE external_ref = ? AND status != 'closed'");
+      for (const [externalRef, status] of existingByRef.entries()) {
+        if (!activeRefs.has(externalRef) && status !== "closed") {
+          closeIssue.run(externalRef);
+          closed += 1;
+        }
+      }
+    }
+    return {
+      synced: true,
+      sessionID,
+      totalTodos: todos.length,
+      created,
+      updated,
+      closed
+    };
+  } finally {
+    db.close();
   }
-  return payload;
 }
-function formatCompactionLog(payload) {
-  const parts = [];
-  if (payload.beads)
-    parts.push("beads-state");
-  if (payload.memories?.length)
-    parts.push(`${payload.memories.length} memories`);
-  if (payload.todos?.length)
-    parts.push(`${payload.todos.length} todos`);
-  return `[CliKit:compaction] Injected: ${parts.join(", ") || "nothing"}`;
+function formatTodoBeadsSyncLog(result) {
+  if (!result.synced) {
+    return `[CliKit:todo-beads-sync] skipped (${result.skippedReason || "unknown reason"})`;
+  }
+  return `[CliKit:todo-beads-sync] session=${result.sessionID} todos=${result.totalTodos} created=${result.created} updated=${result.updated} closed=${result.closed}`;
 }
-// src/hooks/ritual-enforcer.ts
-import * as path8 from "path";
-var RITUAL_FILE = path8.join(process.cwd(), ".opencode", "memory", "ritual-state.json");
 // src/index.ts
+var execFileAsync = promisify(execFile);
 var CliKitPlugin = async (ctx) => {
-  console.log("[CliKit] Plugin initializing...");
-  console.log("[CliKit] Context:", JSON.stringify({ directory: ctx?.directory, hasClient: !!ctx?.client }));
+  const todosBySession = new Map;
+  function getToolInput(args) {
+    return args && typeof args === "object" ? args : {};
+  }
+  function blockToolExecution(reason) {
+    throw new Error(`[CliKit] Blocked tool execution: ${reason}`);
+  }
+  async function showToast(message, variant, title = "CliKit") {
+    try {
+      await ctx.client.tui.showToast({
+        body: {
+          title,
+          message,
+          variant,
+          duration: 3500
+        }
+      });
+    } catch {}
+  }
+  function normalizeTodos(rawTodos) {
+    if (!Array.isArray(rawTodos)) {
+      return [];
+    }
+    const normalized = [];
+    for (const entry of rawTodos) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const record = entry;
+      const id = typeof record.id === "string" ? record.id : "";
+      const content = typeof record.content === "string" ? record.content : "";
+      const status = typeof record.status === "string" ? record.status : "todo";
+      const priority = typeof record.priority === "string" ? record.priority : undefined;
+      if (!id || !content) {
+        continue;
+      }
+      normalized.push({ id, content, status, priority });
+    }
+    return normalized;
+  }
+  async function getStagedFiles() {
+    try {
+      const { stdout } = await execFileAsync("git", ["diff", "--cached", "--name-only"], {
+        cwd: ctx.directory,
+        encoding: "utf-8"
+      });
+      return stdout.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+    } catch {
+      return [];
+    }
+  }
+  async function getStagedDiff() {
+    try {
+      const { stdout } = await execFileAsync("git", ["diff", "--cached", "--no-color"], {
+        cwd: ctx.directory,
+        encoding: "utf-8"
+      });
+      return stdout;
+    } catch {
+      return "";
+    }
+  }
   const pluginConfig = loadCliKitConfig(ctx.directory) ?? {};
+  const debugLogsEnabled = pluginConfig.hooks?.session_logging === true && process.env.CLIKIT_DEBUG === "1";
+  const toolLogsEnabled = pluginConfig.hooks?.tool_logging === true && process.env.CLIKIT_DEBUG === "1";
+  const DIGEST_THROTTLE_MS = 60000;
+  let lastDigestTime = 0;
+  let lastTodoHash = "";
   const builtinAgents = getBuiltinAgents();
   const builtinCommands = getBuiltinCommands();
+  const builtinSkills = getBuiltinSkills();
   const filteredAgents = filterAgents(builtinAgents, pluginConfig);
   const filteredCommands = filterCommands(builtinCommands, pluginConfig);
-  console.log(`[CliKit] Loaded ${Object.keys(filteredAgents).length}/${Object.keys(builtinAgents).length} agents`);
-  console.log(`[CliKit] Loaded ${Object.keys(filteredCommands).length}/${Object.keys(builtinCommands).length} commands`);
-  if (pluginConfig.disabled_agents?.length) {
-    console.log(`[CliKit] Disabled agents: ${pluginConfig.disabled_agents.join(", ")}`);
-  }
-  if (pluginConfig.disabled_commands?.length) {
-    console.log(`[CliKit] Disabled commands: ${pluginConfig.disabled_commands.join(", ")}`);
+  const filteredSkills = filterSkills(builtinSkills, pluginConfig);
+  if (debugLogsEnabled) {
+    console.log("[CliKit] Plugin initializing...");
+    console.log("[CliKit] Context:", JSON.stringify({ directory: ctx?.directory, hasClient: !!ctx?.client }));
+    console.log(`[CliKit] Loaded ${Object.keys(filteredAgents).length}/${Object.keys(builtinAgents).length} agents`);
+    console.log(`[CliKit] Loaded ${Object.keys(filteredCommands).length}/${Object.keys(builtinCommands).length} commands`);
+    console.log(`[CliKit] Loaded ${Object.keys(filteredSkills).length}/${Object.keys(builtinSkills).length} skills`);
+    if (pluginConfig.disabled_agents?.length) {
+      console.log(`[CliKit] Disabled agents: ${pluginConfig.disabled_agents.join(", ")}`);
+    }
+    if (pluginConfig.disabled_commands?.length) {
+      console.log(`[CliKit] Disabled commands: ${pluginConfig.disabled_commands.join(", ")}`);
+    }
   }
   return {
     config: async (config) => {
@@ -4948,7 +4790,9 @@ var CliKitPlugin = async (ctx) => {
             ...enabledLsp,
             ...config.lsp || {}
           };
-          console.log(`[CliKit] Injected ${Object.keys(enabledLsp).length} LSP server(s)`);
+          if (debugLogsEnabled) {
+            console.log(`[CliKit] Injected ${Object.keys(enabledLsp).length} LSP server(s)`);
+          }
         }
       }
     },
@@ -4956,68 +4800,78 @@ var CliKitPlugin = async (ctx) => {
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {
-        if (pluginConfig.hooks?.session_logging) {
-          const info = props?.info;
+        const info = props?.info;
+        if (debugLogsEnabled) {
           console.log(`[CliKit] Session created: ${info?.id || "unknown"}`);
         }
-        if (pluginConfig.hooks?.env_context?.enabled !== false) {
-          const envConfig = pluginConfig.hooks?.env_context;
-          const envInfo = collectEnvInfo(ctx.directory, envConfig);
-          const envBlock = buildEnvBlock(envInfo);
-          console.log(formatEnvSummary(envInfo));
-          input.__envBlock = envBlock;
+        if (pluginConfig.hooks?.memory_digest?.enabled !== false) {
+          const digestResult = generateMemoryDigest(ctx.directory, pluginConfig.hooks?.memory_digest);
+          lastDigestTime = Date.now();
+          if (pluginConfig.hooks?.memory_digest?.log !== false) {
+            console.log(formatDigestLog(digestResult));
+          }
         }
       }
       if (event.type === "session.error") {
         const error = props?.error;
-        if (pluginConfig.hooks?.session_logging) {
+        if (debugLogsEnabled) {
           console.error(`[CliKit] Session error:`, error);
         }
-        if (pluginConfig.hooks?.session_notification?.enabled !== false && pluginConfig.hooks?.session_notification?.on_error !== false) {
-          const notifConfig = pluginConfig.hooks?.session_notification;
-          const sessionId = props?.sessionID;
-          const payload = buildErrorNotification(error, sessionId, notifConfig?.title_prefix);
-          const sent = sendNotification(payload);
-          console.log(formatNotificationLog(payload, sent));
+      }
+      if (event.type === "todo.updated") {
+        const sessionID = props?.sessionID;
+        if (typeof sessionID === "string") {
+          const todos = normalizeTodos(props?.todos);
+          todosBySession.set(sessionID, todos);
+          const todoHash = JSON.stringify(todos.map((t) => `${t.id}:${t.status}`));
+          if (todoHash !== lastTodoHash) {
+            lastTodoHash = todoHash;
+            if (pluginConfig.hooks?.todo_beads_sync?.enabled !== false) {
+              const result = syncTodosToBeads(ctx.directory, sessionID, todos, pluginConfig.hooks?.todo_beads_sync);
+              if (pluginConfig.hooks?.todo_beads_sync?.log === true) {
+                console.log(formatTodoBeadsSyncLog(result));
+              }
+            }
+          }
         }
       }
       if (event.type === "session.idle") {
         const sessionID = props?.sessionID;
-        if (pluginConfig.hooks?.session_logging) {
+        const sessionTodos = sessionID ? todosBySession.get(sessionID) || [] : [];
+        if (debugLogsEnabled) {
           console.log(`[CliKit] Session idle: ${sessionID || "unknown"}`);
         }
         const todoConfig = pluginConfig.hooks?.todo_enforcer;
         if (todoConfig?.enabled !== false) {
-          const todos = props?.todos;
-          if (Array.isArray(todos) && todos.length > 0) {
-            const result = checkTodoCompletion(todos);
+          const todos = normalizeTodos(props?.todos);
+          const effectiveTodos = todos.length > 0 ? todos : sessionTodos;
+          if (effectiveTodos.length > 0) {
+            const result = checkTodoCompletion(effectiveTodos);
             if (!result.complete && todoConfig?.warn_on_incomplete !== false) {
               console.warn(formatIncompleteWarning(result, sessionID));
             }
           }
         }
-        if (pluginConfig.hooks?.session_notification?.enabled !== false && pluginConfig.hooks?.session_notification?.on_idle !== false) {
-          const notifConfig = pluginConfig.hooks?.session_notification;
-          const payload = buildIdleNotification(sessionID, notifConfig?.title_prefix);
-          const sent = sendNotification(payload);
-          console.log(formatNotificationLog(payload, sent));
-        }
-        if (pluginConfig.hooks?.compaction?.enabled !== false) {
-          const compConfig = pluginConfig.hooks?.compaction;
-          const compPayload = collectCompactionPayload(ctx.directory, compConfig);
-          if (compConfig?.include_todo_state !== false && props?.todos) {
-            compPayload.todos = props.todos;
+        if (pluginConfig.hooks?.memory_digest?.enabled !== false) {
+          const now = Date.now();
+          if (now - lastDigestTime >= DIGEST_THROTTLE_MS) {
+            generateMemoryDigest(ctx.directory, pluginConfig.hooks?.memory_digest);
+            lastDigestTime = now;
           }
-          const block = buildCompactionBlock(compPayload, compConfig?.max_state_chars);
-          console.log(formatCompactionLog(compPayload));
-          input.__compactionBlock = block;
+        }
+      }
+      if (event.type === "session.deleted") {
+        const info = props?.info;
+        const sessionID = info?.id;
+        if (sessionID) {
+          todosBySession.delete(sessionID);
         }
       }
     },
-    "tool.execute.before": async (input, _output) => {
+    "tool.execute.before": async (input, output) => {
       const toolName = input.tool;
-      const toolInput = input.input ?? {};
-      if (pluginConfig.hooks?.tool_logging) {
+      const toolInput = getToolInput(output.args);
+      if (toolLogsEnabled) {
         console.log(`[CliKit] Tool executing: ${toolName}`);
       }
       if (pluginConfig.hooks?.git_guard?.enabled !== false) {
@@ -5028,8 +4882,8 @@ var CliKitPlugin = async (ctx) => {
             const result = checkDangerousCommand(command, allowForceWithLease);
             if (result.blocked) {
               console.warn(formatBlockedWarning(result));
-              input.__blocked = true;
-              input.__blockReason = result.reason;
+              await showToast(result.reason || "Blocked dangerous git command", "warning", "CliKit Guard");
+              blockToolExecution(result.reason || "Dangerous git command");
             }
           }
         }
@@ -5040,26 +4894,45 @@ var CliKitPlugin = async (ctx) => {
           if (command && /git\s+(commit|add)/.test(command)) {
             const secConfig = pluginConfig.hooks?.security_check;
             let shouldBlock = false;
-            const files = toolInput.files;
-            if (files) {
-              for (const file of files) {
-                if (isSensitiveFile(file)) {
-                  console.warn(`[CliKit:security] Sensitive file staged: ${file}`);
-                  shouldBlock = true;
-                }
+            const [stagedFiles, stagedDiff] = await Promise.all([
+              getStagedFiles(),
+              getStagedDiff()
+            ]);
+            for (const file of stagedFiles) {
+              if (isSensitiveFile(file)) {
+                console.warn(`[CliKit:security] Sensitive file staged: ${file}`);
+                shouldBlock = true;
               }
             }
-            const content = toolInput.content;
-            if (content) {
-              const scanResult = scanContentForSecrets(content);
+            if (stagedDiff) {
+              const scanResult = scanContentForSecrets(stagedDiff);
               if (!scanResult.safe) {
                 console.warn(formatSecurityWarning(scanResult));
                 shouldBlock = true;
               }
             }
             if (shouldBlock && secConfig?.block_commits) {
-              input.__blocked = true;
-              input.__blockReason = "Sensitive data detected in commit";
+              await showToast("Blocked commit due to sensitive data", "error", "CliKit Security");
+              blockToolExecution("Sensitive data detected in commit");
+            }
+          }
+        }
+      }
+      if (pluginConfig.hooks?.swarm_enforcer?.enabled !== false) {
+        const editTools = ["edit", "Edit", "write", "Write", "bash", "Bash"];
+        if (editTools.includes(toolName)) {
+          const targetFile = extractFileFromToolInput(toolName, toolInput);
+          if (targetFile) {
+            const taskScope = toolInput.taskScope || input.__taskScope;
+            const enforcement = checkEditPermission(targetFile, taskScope, pluginConfig.hooks?.swarm_enforcer);
+            if (!enforcement.allowed) {
+              console.warn(formatEnforcementWarning(enforcement));
+              if (pluginConfig.hooks?.swarm_enforcer?.block_unreserved_edits) {
+                await showToast(enforcement.reason || "Edit blocked outside task scope", "warning", "CliKit Swarm");
+                blockToolExecution(enforcement.reason || "Edit outside reserved task scope");
+              }
+            } else if (pluginConfig.hooks?.swarm_enforcer?.log === true) {
+              console.log(`[CliKit:swarm-enforcer] Allowed edit: ${targetFile}`);
             }
           }
         }
@@ -5069,87 +4942,45 @@ var CliKitPlugin = async (ctx) => {
           const prompt = toolInput.prompt;
           if (prompt && containsQuestion(prompt)) {
             console.warn(formatBlockerWarning());
-            input.__blocked = true;
-            input.__blockReason = "Subagents should not ask questions";
+            await showToast("Subagent prompt blocked: avoid direct questions", "warning", "CliKit Guard");
+            blockToolExecution("Subagents should not ask questions");
           }
         }
       }
     },
     "tool.execute.after": async (input, output) => {
       const toolName = input.tool;
-      const toolInput = input.input ?? {};
-      const toolOutput = output;
-      if (pluginConfig.hooks?.tool_logging) {
+      const toolInput = getToolInput(input.args);
+      let toolOutputContent = output.output;
+      if (toolLogsEnabled) {
         console.log(`[CliKit] Tool completed: ${toolName} -> ${output.title}`);
       }
       const sanitizerConfig = pluginConfig.hooks?.empty_message_sanitizer;
       if (sanitizerConfig?.enabled !== false) {
-        if (toolOutput.content !== undefined && isEmptyContent(toolOutput.content)) {
+        if (isEmptyContent(toolOutputContent)) {
           const placeholder = sanitizerConfig?.placeholder || "(No output)";
-          if (sanitizerConfig?.log_empty !== false) {
+          if (sanitizerConfig?.log_empty === true) {
             console.log(`[CliKit] Empty output detected for tool: ${toolName}`);
           }
-          toolOutput.content = sanitizeContent(toolOutput.content, placeholder);
-        }
-      }
-      if (pluginConfig.hooks?.comment_checker?.enabled !== false) {
-        if (toolName === "edit" || toolName === "Edit" || toolName === "write" || toolName === "Write") {
-          const content = toolOutput.content;
-          if (typeof content === "string" && content.length > 100) {
-            const threshold = pluginConfig.hooks?.comment_checker?.threshold ?? 0.3;
-            const densityResult = checkCommentDensity(content, threshold);
-            if (densityResult.excessive) {
-              console.warn(formatCommentWarning(densityResult));
-            }
-            if (hasExcessiveAIComments(content)) {
-              console.warn("[CliKit:comment-checker] Detected AI-style boilerplate comments. Remove unnecessary comments.");
-            }
+          const sanitized = sanitizeContent(toolOutputContent, placeholder);
+          if (typeof sanitized === "string") {
+            toolOutputContent = sanitized;
+            output.output = sanitized;
           }
         }
       }
       if (pluginConfig.hooks?.truncator?.enabled !== false) {
-        if (typeof toolOutput.content === "string" && shouldTruncate(toolOutput.content, pluginConfig.hooks?.truncator)) {
-          const result = truncateOutput(toolOutput.content, pluginConfig.hooks?.truncator);
+        if (shouldTruncate(toolOutputContent, pluginConfig.hooks?.truncator)) {
+          const result = truncateOutput(toolOutputContent, pluginConfig.hooks?.truncator);
           if (result.truncated) {
-            toolOutput.content = result.content;
-            if (pluginConfig.hooks?.truncator?.log !== false) {
+            toolOutputContent = result.content;
+            output.output = result.content;
+            if (pluginConfig.hooks?.truncator?.log === true) {
               console.log(formatTruncationLog(result));
             }
           }
         }
       }
-      if (pluginConfig.hooks?.auto_format?.enabled) {
-        if (toolName === "edit" || toolName === "Edit" || toolName === "write" || toolName === "Write") {
-          const filePath = toolInput.filePath;
-          if (filePath) {
-            const fmtConfig = pluginConfig.hooks.auto_format;
-            if (shouldFormat(filePath, fmtConfig?.extensions)) {
-              const result = runFormatter(filePath, ctx.directory, fmtConfig?.formatter);
-              if (fmtConfig?.log !== false) {
-                console.log(formatAutoFormatLog(result));
-              }
-            }
-          }
-        }
-      }
-      if (pluginConfig.hooks?.typecheck_gate?.enabled) {
-        if (toolName === "edit" || toolName === "Edit" || toolName === "write" || toolName === "Write") {
-          const filePath = toolInput.filePath;
-          if (filePath && isTypeScriptFile(filePath)) {
-            const tcConfig = pluginConfig.hooks.typecheck_gate;
-            const result = runTypeCheck(filePath, ctx.directory, tcConfig);
-            if (!result.clean) {
-              console.warn(formatTypeCheckWarning(result));
-              if (tcConfig?.block_on_error) {
-                input.__blocked = true;
-                input.__blockReason = `Type errors in ${filePath}`;
-              }
-            } else if (tcConfig?.log !== false) {
-              console.log(formatTypeCheckWarning(result));
-            }
-          }
-        }
-      }
     }
   };
 };