teamai-cli 0.16.6 → 0.16.7

package/dist/index.js

@@ -128,11 +128,6 @@ function getStatePath(scope, projectRoot) {
 function getPushignorePath() {
   return path2.join(process.env.HOME ?? "", ".teamai", "pushignore");
 }
-function isWikiEnabled() {
-  if (process.env.TEAMAI_WIKI_DISABLED === "1" || process.env.TEAMAI_WIKI_DISABLED === "true") return false;
-  if (process.env.TEAMAI_WIKI_ENABLED === "0" || process.env.TEAMAI_WIKI_ENABLED === "false") return false;
-  return true;
-}
 var ToolPathsSchema, ScopeEnum, SharingConfigSchema, SourceConfigSchema, SOURCE_PULL_TTL_MS, TEAMAI_SOURCES_DIR, TeamaiConfigSchema, MemberConfigSchema, LocalConfigSchema, StateSchema, TEAMAI_HOME, TEAMAI_CONFIG_PATH, TEAMAI_STATE_PATH, TEAMAI_TOKEN_PATH, TEAMAI_UPDATE_LOCK_PATH, TEAMAI_RULES_START, TEAMAI_RULES_END, TEAMAI_HOOK_DESCRIPTION_PREFIX, TEAMAI_ENV_START, TEAMAI_ENV_END, TEAMAI_CULTURE_START, TEAMAI_CULTURE_END, TEAMAI_CLAUDEMD_START, TEAMAI_CLAUDEMD_END, SKILL_NAME_REGEX, TEAMAI_USAGE_PATH, TEAMAI_KNOWN_SKILLS_PATH, TEAMAI_PUSHIGNORE_PATH, TEAMAI_SESSIONS_DIR, UsageEventSchema, DASHBOARD_EVENTS_DIR, DASHBOARD_EVENTS_PATH, DASHBOARD_DEFAULT_PORT, DASHBOARD_IDLE_TIMEOUT_MS, DASHBOARD_STALE_TIMEOUT_MS, DASHBOARD_COMPACTION_THRESHOLD, DASHBOARD_STOPPED_DISPLAY_MS, DASHBOARD_PID_CHECK_INTERVAL_MS, CONTRIBUTE_BASE_THRESHOLD, CONTRIBUTE_SMART_THRESHOLD, CONTRIBUTE_SCORE_CACHE_MS, CONTRIBUTE_SESSIONS_DIR, LEARNINGS_LOCAL_DIR, SEARCH_INDEX_PATH, VOTES_LOCAL_DIR, CultureCompanySchema, CultureTeamSchema, CultureFrontmatterSchema;
 var init_types = __esm({
   "src/types.ts"() {
@@ -812,119 +807,80 @@ var init_config = __esm({
 });
 
 // src/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  CLAUDE_TO_CURSOR_EVENTS: () => CLAUDE_TO_CURSOR_EVENTS,
+  TEAMAI_HOOK_SUBCOMMANDS: () => TEAMAI_HOOK_SUBCOMMANDS,
+  TEAMAI_LEGACY_HOOK_SUBCOMMANDS: () => TEAMAI_LEGACY_HOOK_SUBCOMMANDS,
+  injectHooks: () => injectHooks,
+  injectHooksToAllTools: () => injectHooksToAllTools,
+  removeHooks: () => removeHooks
+});
 import path6 from "path";
-function getTrackCommand(tool) {
-  return `bash -lc "teamai track --stdin --tool ${tool} 2>/dev/null" || true`;
-}
-function getTrackSlashCommand(tool) {
-  return `bash -lc "teamai track-slash --stdin --tool ${tool} 2>/dev/null" || true`;
-}
-function getDashboardReportCommand(tool) {
-  return `bash -lc "teamai dashboard-report --stdin --tool ${tool} 2>/dev/null" || true`;
-}
-function getAutoRecallCommand(tool) {
-  return `bash -lc "teamai auto-recall --stdin 2>/dev/null" || true`;
-}
-function getContributeCheckCommand(tool) {
-  return `bash -lc "teamai contribute-check --stdin --tool ${tool} 2>/dev/null" || true`;
+function getDispatchCommand(event, tool, matcher) {
+  const matcherArg = matcher && matcher !== "*" ? ` --matcher ${matcher}` : "";
+  return `bash -lc "teamai hook-dispatch ${event} --tool ${tool}${matcherArg} 2>/dev/null" || true`;
 }
 function getClaudeHooks(tool) {
   return [
+    // ─── SessionStart: single dispatcher handles pull + dashboard-report ────
     {
       eventType: "SessionStart",
-      descriptionKeyword: "Auto-pull",
+      descriptionKeyword: "Hook dispatch session-start",
       hook: {
         matcher: "*",
-        hooks: [{ type: "command", command: TEAMAI_PULL_COMMAND }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Auto-pull team resources on session start`
+        hooks: [{ type: "command", command: getDispatchCommand("session-start", tool) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch session-start`
       }
     },
+    // ─── Stop: single dispatcher handles update + contribute-check + dashboard-report ────
     {
       eventType: "Stop",
-      descriptionKeyword: "Auto-update",
+      descriptionKeyword: "Hook dispatch stop",
       hook: {
         matcher: "*",
-        // 10s timeout: npm registry call typically <5s; cap at 10s so a stalled
-        // call cannot delay session shutdown by the default 60s.
-        hooks: [{ type: "command", command: TEAMAI_UPDATE_COMMAND, timeout: 10 }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Auto-update on session end`
+        hooks: [{ type: "command", command: getDispatchCommand("stop", tool) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch stop`
       }
     },
-    // ─── Contribute check (smart threshold hint at session end) ────────
+    // ─── PostToolUse (*): dashboard-report ────
     {
-      eventType: "Stop",
-      descriptionKeyword: "Contribute check",
+      eventType: "PostToolUse",
+      descriptionKeyword: "Hook dispatch post-tool-use wildcard",
       hook: {
         matcher: "*",
-        hooks: [{ type: "command", command: getContributeCheckCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Contribute check on session end`
+        hooks: [{ type: "command", command: getDispatchCommand("post-tool-use", tool) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch post-tool-use wildcard`
       }
     },
+    // ─── PostToolUse (Skill): track ────
     {
       eventType: "PostToolUse",
-      descriptionKeyword: "Track skill",
+      descriptionKeyword: "Hook dispatch post-tool-use Skill",
       hook: {
         matcher: "Skill",
-        hooks: [{ type: "command", command: getTrackCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Track skill usage`
+        hooks: [{ type: "command", command: getDispatchCommand("post-tool-use", tool, "Skill") }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch post-tool-use Skill`
       }
     },
-    {
-      eventType: "UserPromptSubmit",
-      descriptionKeyword: "Track slash",
-      hook: {
-        matcher: "*",
-        hooks: [{ type: "command", command: getTrackSlashCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Track slash command usage`
-      }
-    },
-    // ─── Auto-recall (search knowledge base on search tools + Bash errors) ────────
-    // Split into 4 precise matchers to avoid spawning a process for tools that
-    // would immediately exit (auto-recall only handles Bash/Grep/WebSearch/WebFetch).
+    // ─── PostToolUse (Bash/Grep/WebSearch/WebFetch): auto-recall ────
     ...["Bash", "Grep", "WebSearch", "WebFetch"].map((matcher) => ({
       eventType: "PostToolUse",
-      descriptionKeyword: `Auto-recall ${matcher}`,
+      descriptionKeyword: `Hook dispatch post-tool-use ${matcher}`,
       hook: {
         matcher,
-        hooks: [{ type: "command", command: getAutoRecallCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Auto-recall on ${matcher}`
+        hooks: [{ type: "command", command: getDispatchCommand("post-tool-use", tool, matcher) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch post-tool-use ${matcher}`
       }
     })),
-    // ─── Dashboard hooks (independent from tracking) ────────
-    {
-      eventType: "SessionStart",
-      descriptionKeyword: "Dashboard report",
-      hook: {
-        matcher: "*",
-        hooks: [{ type: "command", command: getDashboardReportCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Dashboard report on session start`
-      }
-    },
-    {
-      eventType: "Stop",
-      descriptionKeyword: "Dashboard stop",
-      hook: {
-        matcher: "*",
-        hooks: [{ type: "command", command: getDashboardReportCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Dashboard report on session stop`
-      }
-    },
-    {
-      eventType: "PostToolUse",
-      descriptionKeyword: "Dashboard tool",
-      hook: {
-        matcher: "*",
-        hooks: [{ type: "command", command: getDashboardReportCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Dashboard report on tool use`
-      }
-    },
+    // ─── UserPromptSubmit: track-slash + dashboard-report ────
     {
       eventType: "UserPromptSubmit",
-      descriptionKeyword: "Dashboard prompt",
+      descriptionKeyword: "Hook dispatch prompt-submit",
       hook: {
         matcher: "*",
-        hooks: [{ type: "command", command: getDashboardReportCommand(tool) }],
-        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Dashboard report on prompt submit`
+        hooks: [{ type: "command", command: getDispatchCommand("prompt-submit", tool) }],
+        description: `${TEAMAI_HOOK_DESCRIPTION_PREFIX} Hook dispatch prompt-submit`
       }
     }
   ];
@@ -932,26 +888,22 @@ function getClaudeHooks(tool) {
 function buildCursorHooks(tool) {
   return {
     sessionStart: [
-      { command: TEAMAI_PULL_COMMAND, timeout: 30 },
-      { command: getDashboardReportCommand(tool), timeout: 10 }
+      { command: getDispatchCommand("session-start", tool), timeout: 60 }
     ],
     stop: [
-      { command: TEAMAI_UPDATE_COMMAND, timeout: 10 },
-      { command: getDashboardReportCommand(tool), timeout: 10 },
-      { command: getContributeCheckCommand(tool), timeout: 10 }
+      { command: getDispatchCommand("stop", tool), timeout: 15 }
     ],
     postToolUse: [
-      { command: getTrackCommand(tool), timeout: 10, matcher: "Skill" },
-      { command: getDashboardReportCommand(tool), timeout: 10 },
+      { command: getDispatchCommand("post-tool-use", tool), timeout: 10 },
+      { command: getDispatchCommand("post-tool-use", tool, "Skill"), timeout: 10, matcher: "Skill" },
       ...["Bash", "Grep", "WebSearch", "WebFetch"].map((matcher) => ({
-        command: getAutoRecallCommand(tool),
-        timeout: 3,
+        command: getDispatchCommand("post-tool-use", tool, matcher),
+        timeout: 10,
         matcher
       }))
     ],
     beforeSubmitPrompt: [
-      { command: getTrackSlashCommand(tool), timeout: 10 },
-      { command: getDashboardReportCommand(tool), timeout: 10 }
+      { command: getDispatchCommand("prompt-submit", tool), timeout: 10 }
     ]
   };
 }
@@ -1068,6 +1020,22 @@ async function injectCursorHooks(hooksPath, tool) {
   }
   const desiredHooks = buildCursorHooks(tool);
   let changed = false;
+  for (const event of Object.keys(hooksJson.hooks)) {
+    const entries = hooksJson.hooks[event];
+    const filtered = entries.filter((h) => {
+      if (!isTeamaiHookCommand(h.command)) return true;
+      const subcmd = extractTeamaiSubcommand(h.command);
+      return subcmd === "hook-dispatch";
+    });
+    if (filtered.length !== entries.length) {
+      changed = true;
+      if (filtered.length === 0) {
+        delete hooksJson.hooks[event];
+      } else {
+        hooksJson.hooks[event] = filtered;
+      }
+    }
+  }
   const desiredEvents = new Set(Object.keys(desiredHooks));
   for (const event of Object.keys(hooksJson.hooks)) {
     if (desiredEvents.has(event)) continue;
@@ -1161,16 +1129,21 @@ async function injectHooksToAllTools(toolPaths, baseDir) {
     }
   }
 }
-var TEAMAI_PULL_COMMAND, TEAMAI_UPDATE_COMMAND, TEAMAI_HOOK_SUBCOMMANDS, CURSOR_TOOLS, TEAMAI_COMMAND_MARKERS;
+var TEAMAI_HOOK_SUBCOMMANDS, TEAMAI_LEGACY_HOOK_SUBCOMMANDS, CLAUDE_TO_CURSOR_EVENTS, CURSOR_TOOLS, TEAMAI_COMMAND_MARKERS;
 var init_hooks = __esm({
   "src/hooks.ts"() {
     "use strict";
     init_fs();
     init_logger();
     init_types();
-    TEAMAI_PULL_COMMAND = 'bash -lc "teamai pull 2>/dev/null" || true';
-    TEAMAI_UPDATE_COMMAND = 'bash -lc "teamai update 2>/dev/null" || true';
-    TEAMAI_HOOK_SUBCOMMANDS = ["pull", "update", "track", "track-slash", "dashboard-report", "contribute-check", "auto-recall"];
+    TEAMAI_HOOK_SUBCOMMANDS = ["hook-dispatch"];
+    TEAMAI_LEGACY_HOOK_SUBCOMMANDS = ["pull", "update", "track", "track-slash", "dashboard-report", "contribute-check", "auto-recall"];
+    CLAUDE_TO_CURSOR_EVENTS = {
+      SessionStart: "sessionStart",
+      Stop: "stop",
+      PostToolUse: "postToolUse",
+      UserPromptSubmit: "beforeSubmitPrompt"
+    };
     CURSOR_TOOLS = /* @__PURE__ */ new Set(["cursor"]);
     TEAMAI_COMMAND_MARKERS = [
       "teamai pull",
@@ -2401,6 +2374,10 @@ async function init(options) {
   if (options.scope === "project" || options.scope === "user") {
     scope = options.scope;
   } else {
+    const userPath = getTeamaiHome("user");
+    const projectPath = getTeamaiHome("project", process.cwd());
+    log.info(`  user    \u2192 ${userPath}/`);
+    log.info(`  project \u2192 ${projectPath}/`);
     const scopeAnswer = await askQuestion("Scope [user/project] (default: user): ", "user");
     if (scopeAnswer.toLowerCase() === "project") {
       scope = "project";
@@ -2935,7 +2912,7 @@ function getBuiltinSkillsDir() {
   const distDir = path12.dirname(new URL(import.meta.url).pathname);
   return path12.join(distDir, "..", "skills");
 }
-async function deployBuiltinSkills(teamConfig, localConfig, options) {
+async function deployBuiltinSkills(teamConfig, localConfig) {
   const builtinDir = getBuiltinSkillsDir();
   if (!await pathExists(builtinDir)) {
     log.debug("No built-in skills directory found, skipping deployment");
@@ -2955,8 +2932,6 @@ async function deployBuiltinSkills(teamConfig, localConfig, options) {
     }
   }
   if (skillNames.length === 0) return 0;
-  const filteredSkills = options?.skipWiki ? skillNames.filter((name) => name !== "teamai-wiki") : skillNames;
-  if (filteredSkills.length === 0) return 0;
   const baseDir = localConfig ? resolveBaseDir(localConfig) : process.env.HOME ?? "";
   let deployed = 0;
   for (const [tool, toolPath] of Object.entries(teamConfig.toolPaths)) {
@@ -2966,7 +2941,7 @@ async function deployBuiltinSkills(teamConfig, localConfig, options) {
       continue;
     }
     const targetSkillsDir = path12.join(baseDir, toolPath.skills);
-    for (const skillName of filteredSkills) {
+    for (const skillName of skillNames) {
       const srcDir = path12.join(builtinDir, skillName);
       const destDir = path12.join(targetSkillsDir, skillName);
       try {
@@ -4709,7 +4684,7 @@ async function push(options) {
     log.debug(`Pre-push sync skipped: ${e.message}`);
   }
   const spin = spinner("Scanning local resources...").start();
-  const pushableTypes = isWikiEnabled() ? ["skills", "rules", "env", "wiki"] : ["skills", "rules", "env"];
+  const pushableTypes = ["skills", "rules", "env", "wiki"];
   const allItems = [];
   for (const type of pushableTypes) {
     const handler = getHandler(type);
@@ -4987,7 +4962,6 @@ var init_push = __esm({
     init_logger();
     init_resources();
     init_skills();
-    init_types();
     init_roles();
     init_prompt();
     init_fs();
@@ -6023,8 +5997,7 @@ async function pullForScope(localConfig, options) {
   }
   const tagsConfig = await loadTagsConfig(localConfig.repo.localPath);
   const subscribedTags = localConfig.subscribedTags;
-  const wikiEnabled = isWikiEnabled();
-  const resourceTypes = wikiEnabled ? ["skills", "rules", "docs", "env", "wiki"] : ["skills", "rules", "docs", "env"];
+  const resourceTypes = ["skills", "rules", "docs", "env", "wiki"];
   let totalSynced = 0;
   let desiredSkillNames = null;
   let knownRepoSkillNames = null;
@@ -6287,7 +6260,7 @@ async function pullForScope(localConfig, options) {
   if (!options.dryRun) {
     try {
       const { deployBuiltinSkills: deployBuiltinSkills2 } = await Promise.resolve().then(() => (init_builtin_skills(), builtin_skills_exports));
-      const deployed = await deployBuiltinSkills2(freshConfig, localConfig, { skipWiki: !wikiEnabled });
+      const deployed = await deployBuiltinSkills2(freshConfig, localConfig);
       if (deployed > 0) {
         log.debug(`[${scopeLabel}] Deployed ${deployed} built-in skill(s)`);
       }
@@ -6423,7 +6396,27 @@ async function collectClaudemdFiles(repoPath, roleContext) {
   }
   return contents;
 }
+async function autoMigrateHooksIfNeeded() {
+  const home = process.env.HOME ?? "";
+  const primarySettings = path26.join(home, ".claude", "settings.json");
+  if (!await pathExists(primarySettings)) return;
+  const content = await readFileSafe(primarySettings);
+  if (!content) return;
+  if (content.includes("hook-dispatch")) return;
+  if (!content.includes("teamai")) return;
+  log.debug("Auto-migrating hooks to dispatch format...");
+  const { autoDetectInit: autoDetectInit2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { injectHooksToAllTools: injectHooksToAllTools2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+  const { localConfig, teamConfig } = await autoDetectInit2();
+  const baseDir = resolveBaseDir(localConfig);
+  await injectHooksToAllTools2(teamConfig.toolPaths, baseDir);
+  log.debug("Hooks migrated to dispatch format");
+}
 async function pull(options) {
+  try {
+    await autoMigrateHooksIfNeeded();
+  } catch {
+  }
   let userConfig = null;
   try {
     userConfig = await loadLocalConfigForScope("user");
@@ -6745,10 +6738,6 @@ async function status(options) {
   for (const [type, count] of Object.entries(counts)) {
     console.log(`  ${type}: ${count}`);
   }
-  if (!isWikiEnabled()) {
-    console.log("");
-    log.info("\u2139 Wiki: disabled (TEAMAI_WIKI_DISABLED=1) \u2014 wiki routing handled by external plugin");
-  }
   console.log("");
   log.info("Local resources not yet pushed:");
   let anyNew = false;
@@ -6915,7 +6904,6 @@ var init_status = __esm({
     init_skills();
     init_known_agents();
     init_agent_skills();
-    init_types();
   }
 });
 
@@ -11081,6 +11069,252 @@ var init_auto_recall = __esm({
   }
 });
 
+// src/hook-dispatch.ts
+function withTimeout(promise, ms, handlerName) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`Handler "${handlerName}" exceeded timeout of ${ms}ms`));
+    }, ms);
+    promise.then(
+      (val) => {
+        clearTimeout(timer);
+        resolve(val);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+function createDispatcher(config) {
+  return {
+    async dispatch(event, matcher, stdin, tool) {
+      const matched = config.handlers.filter((reg) => {
+        if (reg.event !== event) return false;
+        return reg.matcher === "*" || reg.matcher === matcher;
+      });
+      const settled = await Promise.allSettled(
+        matched.map((reg) => {
+          const timeoutMs = reg.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+          return withTimeout(reg.handler.execute(stdin, tool), timeoutMs, reg.handler.name);
+        })
+      );
+      let output = null;
+      const errors = [];
+      for (let i = 0; i < settled.length; i++) {
+        const result = settled[i];
+        const handlerName = matched[i].handler.name;
+        if (result.status === "rejected") {
+          errors.push({
+            handlerName,
+            error: result.reason instanceof Error ? result.reason : new Error(String(result.reason))
+          });
+        } else if (result.status === "fulfilled" && result.value != null) {
+          if (output === null) {
+            output = result.value;
+          }
+        }
+      }
+      return { output, errors };
+    }
+  };
+}
+var DEFAULT_TIMEOUT_MS;
+var init_hook_dispatch = __esm({
+  "src/hook-dispatch.ts"() {
+    "use strict";
+    DEFAULT_TIMEOUT_MS = 6e4;
+  }
+});
+
+// src/hook-handlers.ts
+function buildHandlerRegistry() {
+  return [
+    // ─── SessionStart ─────────────────────────────────
+    { event: "session-start", matcher: "*", handler: pullHandler, timeoutMs: PULL_TIMEOUT_MS },
+    { event: "session-start", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS },
+    // ─── Stop ─────────────────────────────────────────
+    { event: "stop", matcher: "*", handler: updateHandler, timeoutMs: UPDATE_TIMEOUT_MS },
+    { event: "stop", matcher: "*", handler: contributeCheckHandler, timeoutMs: CONTRIBUTE_CHECK_TIMEOUT_MS },
+    { event: "stop", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS },
+    // ─── PostToolUse ──────────────────────────────────
+    { event: "post-tool-use", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS },
+    { event: "post-tool-use", matcher: "Skill", handler: trackHandler, timeoutMs: TRACK_TIMEOUT_MS },
+    ...["Bash", "Grep", "WebSearch", "WebFetch"].map((m) => ({
+      event: "post-tool-use",
+      matcher: m,
+      handler: autoRecallHandler,
+      timeoutMs: AUTO_RECALL_TIMEOUT_MS
+    })),
+    // ─── UserPromptSubmit ─────────────────────────────
+    { event: "prompt-submit", matcher: "*", handler: trackSlashHandler, timeoutMs: TRACK_TIMEOUT_MS },
+    { event: "prompt-submit", matcher: "*", handler: dashboardReportHandler, timeoutMs: DASHBOARD_TIMEOUT_MS }
+  ];
+}
+var PULL_TIMEOUT_MS, UPDATE_TIMEOUT_MS, TRACK_TIMEOUT_MS, DASHBOARD_TIMEOUT_MS, CONTRIBUTE_CHECK_TIMEOUT_MS, AUTO_RECALL_TIMEOUT_MS, pullHandler, updateHandler, dashboardReportHandler, trackHandler, trackSlashHandler, contributeCheckHandler, autoRecallHandler;
+var init_hook_handlers = __esm({
+  "src/hook-handlers.ts"() {
+    "use strict";
+    PULL_TIMEOUT_MS = 6e4;
+    UPDATE_TIMEOUT_MS = 1e4;
+    TRACK_TIMEOUT_MS = 5e3;
+    DASHBOARD_TIMEOUT_MS = 5e3;
+    CONTRIBUTE_CHECK_TIMEOUT_MS = 1e4;
+    AUTO_RECALL_TIMEOUT_MS = 1e4;
+    pullHandler = {
+      name: "pull",
+      async execute(_stdin, _tool) {
+        const { pull: pull2 } = await Promise.resolve().then(() => (init_pull(), pull_exports));
+        await pull2({ silent: true });
+        return null;
+      }
+    };
+    updateHandler = {
+      name: "update",
+      async execute(_stdin, _tool) {
+        const { doUpdate: doUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
+        await doUpdate2();
+        return null;
+      }
+    };
+    dashboardReportHandler = {
+      name: "dashboard-report",
+      async execute(stdin, tool) {
+        const { parseHookEvent: parseHookEvent2, appendEvent: appendEvent2, compactEvents: compactEvents2 } = await Promise.resolve().then(() => (init_dashboard_collector(), dashboard_collector_exports));
+        const raw = JSON.stringify(stdin);
+        const event = await parseHookEvent2(raw, tool);
+        if (event) {
+          await appendEvent2(event);
+          compactEvents2().catch(() => {
+          });
+        }
+        return null;
+      }
+    };
+    trackHandler = {
+      name: "track",
+      async execute(stdin, tool) {
+        const { extractSkillName: extractSkillName2, isValidSkillName: isValidSkillName2, appendUsageEvent: appendUsageEvent2, updateKnownSkills: updateKnownSkills2 } = await Promise.resolve().then(() => (init_usage_tracker(), usage_tracker_exports));
+        const toolName = stdin.tool_name;
+        if (typeof toolName !== "string") return null;
+        const toolInput = stdin.tool_input;
+        if (!toolInput || typeof toolInput !== "object") return null;
+        let skillName = null;
+        let toolSource = tool;
+        if (toolName === "Skill") {
+          skillName = extractSkillName2(toolInput);
+        } else if (toolName === "Read") {
+          const filePath = (typeof toolInput.file_path === "string" ? toolInput.file_path : null) ?? (typeof toolInput.path === "string" ? toolInput.path : null);
+          if (typeof filePath === "string" && /\/SKILL\.md$/i.test(filePath)) {
+            skillName = extractSkillName2({ skill: filePath });
+            toolSource = "cursor";
+          }
+        } else {
+          return null;
+        }
+        if (!skillName || !isValidSkillName2(skillName)) return null;
+        await appendUsageEvent2({ skill: skillName, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool: toolSource });
+        await updateKnownSkills2(skillName);
+        return null;
+      }
+    };
+    trackSlashHandler = {
+      name: "track-slash",
+      async execute(stdin, tool) {
+        const { extractSkillName: extractSkillName2, isValidSkillName: isValidSkillName2, appendUsageEvent: appendUsageEvent2, updateKnownSkills: updateKnownSkills2 } = await Promise.resolve().then(() => (init_usage_tracker(), usage_tracker_exports));
+        const prompt = stdin.prompt;
+        if (typeof prompt !== "string" || !prompt.startsWith("/")) return null;
+        const match = prompt.match(/^\/([\w-]+)/);
+        if (!match) return null;
+        const skillName = match[1];
+        if (!isValidSkillName2(skillName)) return null;
+        await appendUsageEvent2({ skill: skillName, timestamp: (/* @__PURE__ */ new Date()).toISOString(), tool });
+        await updateKnownSkills2(skillName);
+        return null;
+      }
+    };
+    contributeCheckHandler = {
+      name: "contribute-check",
+      async execute(stdin, _tool) {
+        const { contributeCheckForSession: contributeCheckForSession2 } = await Promise.resolve().then(() => (init_contribute_check(), contribute_check_exports));
+        const sessionId = typeof stdin.session_id === "string" ? stdin.session_id : null;
+        if (!sessionId) return null;
+        const { hint } = await contributeCheckForSession2(sessionId);
+        if (hint) {
+          return JSON.stringify({ stopReason: hint });
+        }
+        return null;
+      }
+    };
+    autoRecallHandler = {
+      name: "auto-recall",
+      async execute(stdin, _tool) {
+        const { autoRecall: autoRecall2 } = await Promise.resolve().then(() => (init_auto_recall(), auto_recall_exports));
+        let capturedOutput = null;
+        const originalWrite = process.stdout.write.bind(process.stdout);
+        process.stdout.write = ((chunk) => {
+          if (typeof chunk === "string") {
+            capturedOutput = chunk;
+          } else if (Buffer.isBuffer(chunk)) {
+            capturedOutput = chunk.toString();
+          }
+          return true;
+        });
+        try {
+          await autoRecall2();
+        } finally {
+          process.stdout.write = originalWrite;
+        }
+        return capturedOutput;
+      }
+    };
+  }
+});
+
+// src/hook-dispatch-cli.ts
+var hook_dispatch_cli_exports = {};
+__export(hook_dispatch_cli_exports, {
+  hookDispatchCli: () => hookDispatchCli
+});
+async function readStdin4() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function hookDispatchCli(event, tool, matcher) {
+  const raw = await readStdin4();
+  let stdin = {};
+  if (raw.trim()) {
+    try {
+      stdin = JSON.parse(raw);
+    } catch {
+      log.debug(`hook-dispatch: failed to parse STDIN JSON for event=${event}`);
+      return;
+    }
+  }
+  const registry = buildHandlerRegistry();
+  const dispatcher = createDispatcher({ handlers: registry });
+  const result = await dispatcher.dispatch(event, matcher, stdin, tool);
+  for (const err of result.errors) {
+    log.debug(`hook-dispatch: handler "${err.handlerName}" failed: ${err.error.message}`);
+  }
+  if (result.output) {
+    process.stdout.write(result.output);
+  }
+}
+var init_hook_dispatch_cli = __esm({
+  "src/hook-dispatch-cli.ts"() {
+    "use strict";
+    init_hook_dispatch();
+    init_hook_handlers();
+    init_logger();
+  }
+});
+
 // src/index.ts
 init_logger();
 import { createRequire as createRequire2 } from "module";
@@ -11357,5 +11591,9 @@ program.command("auto-recall").description("Auto-recall team knowledge on tool e
     await autoRecall2();
   }
 });
+program.command("hook-dispatch <event>").description("Unified hook dispatcher \u2014 handles all teamai hooks for a given event in one process").option("--tool <name>", "Tool identifier (e.g. claude, claude-internal, cursor)").option("--matcher <matcher>", "Hook matcher for PostToolUse (e.g. Skill, Bash)").action(async (event, cmdOpts) => {
+  const { hookDispatchCli: hookDispatchCli2 } = await Promise.resolve().then(() => (init_hook_dispatch_cli(), hook_dispatch_cli_exports));
+  await hookDispatchCli2(event, cmdOpts.tool ?? "claude", cmdOpts.matcher ?? "*");
+});
 program.parse();
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamai-cli",
-  "version": "0.16.6",
+  "version": "0.16.7",
   "description": "TeamAI — the team harness for AI agents (skill sync + shared knowledge base, powered by Git)",
   "type": "module",
   "bin": {