@minidoll/agentkit-dsh-plugin 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,667 @@
+// src/index.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute as isAbsolute2, join as join6 } from "node:path";
+
+// ../core/dist/config.js
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var CONFIG_CANDIDATES = [".agent/hooks/hooks.json", ".claude/settings.json", ".claude/hooks.json"];
+var DEFAULT_TIMEOUT_MS = 6e5;
+function loadHooks(projectRoot) {
+  const errors = [];
+  for (const rel of CONFIG_CANDIDATES) {
+    const abs = join(projectRoot, rel);
+    if (!existsSync(abs))
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(abs, "utf8"));
+    } catch (err) {
+      errors.push(`${abs}: \u4E0D\u662F\u5408\u6CD5 JSON \u2014 ${err.message}`);
+      return { hooks: [], source: abs, errors };
+    }
+    return { ...parseEntries(parsed, rel), source: abs };
+  }
+  return { hooks: [], source: null, errors };
+}
+function parseEntries(doc, where) {
+  const errors = [];
+  const hooks = [];
+  const raw = doc?.hooks;
+  if (!Array.isArray(raw)) {
+    errors.push(`${where}: \u9876\u5C42\u7F3A\u5C11 hooks \u6570\u7EC4`);
+    return { hooks, errors };
+  }
+  for (const [i, entry] of raw.entries()) {
+    const e = entry;
+    const command = typeof e?.command === "string" ? e.command : "";
+    if (command === "") {
+      errors.push(`${where}: \u7B2C ${i + 1} \u6761\u7F3A command \u2014\u2014 \u8DF3\u8FC7`);
+      continue;
+    }
+    const event = e?.event === "PostToolUse" ? "PostToolUse" : "PreToolUse";
+    const matcher = e?.matcher?.tool;
+    hooks.push({
+      id: typeof e?.id === "string" ? e.id : `hook-${i + 1}`,
+      event,
+      ...typeof matcher === "string" ? { tool: matcher } : {},
+      command,
+      timeoutMs: typeof e?.timeoutMs === "number" ? e.timeoutMs : DEFAULT_TIMEOUT_MS
+    });
+  }
+  return { hooks, errors };
+}
+function matches(hook, toolName) {
+  if (hook.tool === void 0)
+    return true;
+  try {
+    return new RegExp(hook.tool, "i").test(toolName);
+  } catch {
+    return false;
+  }
+}
+function exitCodeBlocks(hook, exitCode) {
+  return hook.event === "PreToolUse" && exitCode !== 0;
+}
+
+// ../core/dist/match-project.js
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+function isProject(dir) {
+  return existsSync2(join2(dir, ".agent", "protocol.yml")) || existsSync2(join2(dir, ".agent", "board.json"));
+}
+function declaredName(dir) {
+  try {
+    const text = readFileSync2(join2(dir, ".agent", "protocol.yml"), "utf8");
+    const m = /^meta:\s*\n(?:[\s\S]*?)\s+name:\s*([A-Za-z0-9._-]+)/m.exec(text);
+    return m?.[1];
+  } catch {
+    return void 0;
+  }
+}
+function listProjects(containerDir, maxChildren = 64) {
+  if (!existsSync2(containerDir))
+    return [];
+  let names = [];
+  try {
+    names = readdirSync(containerDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name).slice(0, maxChildren);
+  } catch {
+    return [];
+  }
+  return names.map((name) => {
+    const dir = join2(containerDir, name);
+    if (!isProject(dir))
+      return null;
+    const declared = declaredName(dir);
+    return { name, dir, ...declared !== void 0 ? { declaredName: declared } : {} };
+  }).filter((x) => x !== null);
+}
+function matchProjectByName(text, containerDir) {
+  const all = listProjects(containerDir);
+  if (all.length === 0) {
+    return { root: null, matched: [], scanned: all, reason: `${containerDir} \u4E0B\u6CA1\u6709\u5E26 .agent/ \u7684\u9879\u76EE` };
+  }
+  if (text.trim() === "") {
+    return { root: null, matched: [], scanned: all, reason: "\u6CA1\u6709\u53EF\u5339\u914D\u7684\u6587\u672C" };
+  }
+  const matched = all.filter((p) => {
+    const names = [p.name, ...p.declaredName !== void 0 ? [p.declaredName] : []];
+    return names.some((n) => new RegExp(`(^|[^A-Za-z0-9_-])${escapeRe(n)}([^A-Za-z0-9_-]|$)`).test(text));
+  });
+  if (matched.length === 1) {
+    return { root: matched[0].dir, matched, scanned: all, reason: `\u6587\u672C\u63D0\u5230\u9879\u76EE ${matched[0].name}` };
+  }
+  if (matched.length === 0) {
+    return { root: null, matched: [], scanned: all, reason: "\u6587\u672C\u6CA1\u6709\u63D0\u5230\u4EFB\u4F55\u5DF2\u77E5\u9879\u76EE" };
+  }
+  return {
+    root: null,
+    matched,
+    scanned: all,
+    reason: `\u6587\u672C\u540C\u65F6\u63D0\u5230\u591A\u4E2A\u9879\u76EE\uFF08${matched.map((m) => m.name).join(", ")}\uFF09\u2014\u2014 \u4E0D\u9009`
+  };
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ../core/dist/resolve.js
+import { existsSync as existsSync3, statSync } from "node:fs";
+import { dirname, isAbsolute, join as join3 } from "node:path";
+var WORKSPACE_MARKERS = [".agent"];
+function resolveProjectRoot(opts) {
+  const sessionCwd = opts.sessionCwd;
+  const raw = opts.targetPath;
+  if (raw === void 0 || raw.trim() === "")
+    return sessionCwd;
+  const abs = isAbsolute(raw) ? raw : join3(sessionCwd, raw);
+  let dir = abs;
+  try {
+    if (!statSync(abs).isDirectory())
+      dir = dirname(abs);
+  } catch {
+    dir = dirname(abs);
+  }
+  const limit = opts.maxDepth ?? 24;
+  const home = process.env.HOME ?? "";
+  for (let i = 0; i < limit; i++) {
+    if (home !== "" && dir === home)
+      break;
+    if (dir === dirname(dir))
+      break;
+    if (WORKSPACE_MARKERS.some((m) => existsSync3(join3(dir, m)))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return sessionCwd;
+}
+function findProjectRoot(candidates, sessionCwd) {
+  const tried = [];
+  for (const cand of candidates) {
+    const resolved = resolveProjectRoot({ targetPath: cand, sessionCwd });
+    const hit = existsSync3(join3(resolved, ".agent"));
+    tried.push({ path: cand, resolved, hit });
+    if (hit)
+      return { root: resolved, tried };
+  }
+  return { root: null, tried };
+}
+
+// src/inject.ts
+import { randomUUID } from "node:crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+var MAX_CONTEXT_BYTES = 900;
+var factoryLoader = null;
+async function loadFactory() {
+  factoryLoader ??= (async () => {
+    try {
+      const pkg = "@deepseek-ai/dsh-llm";
+      const mod = await import(pkg);
+      return typeof mod.createUserMessage === "function" ? mod.createUserMessage : null;
+    } catch {
+      return null;
+    }
+  })();
+  return factoryLoader;
+}
+function handcraft(text) {
+  return {
+    role: "user",
+    id: randomUUID(),
+    content: [{ type: "text", text }],
+    source: { kind: "user" }
+  };
+}
+function assertUserMessage(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const m = value;
+  if (m.role !== "user") return false;
+  if (typeof m.id !== "string" || m.id === "") return false;
+  const src = m.source;
+  if (src === void 0 || src.kind !== "user") return false;
+  const content = m.content;
+  if (!Array.isArray(content) || content.length === 0) return false;
+  return content.every((b) => {
+    const blk = b;
+    return blk.type === "text" && typeof blk.text === "string" && blk.text.length > 0;
+  });
+}
+var INJECT_CONFIG_REL = ".agent/inject.json";
+function injectEnabled(root) {
+  if (process.env.AGENTKIT_CONTEXT_INJECT === "1") return true;
+  if (root === void 0 || root === "") return false;
+  try {
+    const f = join4(root, INJECT_CONFIG_REL);
+    if (!existsSync4(f)) return false;
+    const doc = JSON.parse(readFileSync3(f, "utf8"));
+    return doc.enabled === true;
+  } catch {
+    return false;
+  }
+}
+var injected = /* @__PURE__ */ new Set();
+var PATH_RULES = [
+  { pattern: /^contracts\//, hint: "\u5951\u7EA6\u53D8\u66F4\uFF1A\u5B9E\u73B0\u5FC5\u987B\u540C\u6B65\uFF08AGENTS \u94C1\u5F8B\uFF09\uFF0C\u5E76\u5728\u4EA4\u63A5\u5355\u58F0\u660E\u5951\u7EA6\u5F71\u54CD\u4E0E\u8BC1\u636E\u7EA7\u522B L1-L4" },
+  { pattern: /^docs\/rules\//, hint: "\u89C4\u5219\u6587\u6863\uFF1A\u6539\u5B83\u7B49\u4E8E\u6539\u6240\u6709\u4EBA\u7684\u884C\u4E3A\u7EA6\u675F \u2014\u2014 \u5148\u786E\u8BA4\u4E0E protocol.yml / AGENTS.md \u4E0D\u51B2\u7A81" },
+  { pattern: /^docs\/design\//, hint: '\u8BBE\u8BA1\u6587\u6863\uFF1A\u9700\u4E0E codemap \u91CC\u7684\u6A21\u5757\u5BF9\u5E94\uFF08M4 \u4F1A\u6821\u9A8C"\u6587\u6863\u63D0\u5230\u8BE5\u6A21\u5757"\uFF09' },
+  { pattern: /^\.agent\/decisions\/\d{4}-/, hint: "ADR\uFF1Aaccepted \u7684\u6709\u7EA6\u675F\u529B \u2014\u2014 \u8981\u63A8\u7FFB\u5148\u5199\u65B0 ADR \u6807 superseded\uFF0C\u4E0D\u8981\u76F4\u63A5\u6539\u65E7\u7ED3\u8BBA" },
+  { pattern: /^AGENTS\.md$/, hint: "AGENTS.md \u662F\u6D3E\u751F\u6587\u4EF6\uFF08\u7531 protocol.yml \u751F\u6210\uFF09\u2014\u2014 \u6539\u5B83\u8BF7\u6539 protocol.yml \u518D akit sync" }
+];
+function buildInjectText(input) {
+  const lines = [];
+  const rels = [];
+  if (input.filePath !== void 0 && input.filePath !== "") rels.push(input.filePath);
+  for (const p of input.extraPaths ?? []) if (p !== "") rels.push(p);
+  for (const raw of rels) {
+    const rel = String(raw).replace(/\\/g, "/").replace(/^\.\//, "");
+    for (const rule of PATH_RULES) {
+      if (rule.pattern.test(rel)) {
+        lines.push(`- \u7EAA\u5F8B\uFF1A${rule.hint}`);
+        break;
+      }
+    }
+    if (lines.length > 0) break;
+  }
+  for (const raw of rels) {
+    const rel = String(raw).replace(/\\/g, "/").replace(/^\.\//, "");
+    try {
+      const cm = join4(input.root, ".agent", "codemap.json");
+      if (!existsSync4(cm)) break;
+      const map = JSON.parse(readFileSync3(cm, "utf8"));
+      const mod = (map.modules ?? []).find((m) => String(m.path ?? "").replace(/^\.\//, "") === rel);
+      if (mod !== void 0) {
+        if (mod.purpose !== void 0 && mod.purpose !== "") lines.push(`- \u6A21\u5757\u804C\u8D23\uFF08codemap\uFF09\uFF1A${mod.purpose}`);
+        if (mod.doc !== void 0 && mod.doc !== "") lines.push(`- \u8BBE\u8BA1\u6587\u6863\uFF1A${mod.doc}`);
+        break;
+      }
+    } catch {
+    }
+  }
+  for (const raw of rels) {
+    if (lines.length >= 4) break;
+    const rel = String(raw).replace(/\\/g, "/");
+    const stem = rel.split("/").pop()?.replace(/\.(ts|mjs|java|kt|py|go|md)$/, "") ?? "";
+    if (stem.length < 3) continue;
+    try {
+      const dir = join4(input.root, ".agent", "decisions");
+      if (!existsSync4(dir)) continue;
+      for (const name of readdirSync2(dir).sort()) {
+        if (!/^\d{4}-.*\.md$/.test(name)) continue;
+        const body = readFileSync3(join4(dir, name), "utf8");
+        if (!body.includes(stem) && !body.includes(rel)) continue;
+        const title = /^#\s+(.+)$/m.exec(body)?.[1] ?? name;
+        const status = /-?\s*\*\*状态\*\*[:：]\s*(.+)/.exec(body)?.[1] ?? "";
+        lines.push(`- \u76F8\u5173\u51B3\u7B56\uFF1A${name.replace(/\.md$/, "")} ${title}${status ? `\uFF08${status}\uFF09` : ""}`);
+        if (lines.length >= 4) break;
+      }
+    } catch {
+    }
+  }
+  if (lines.length === 0) return null;
+  let text = ["<!-- agentkit: \u6309\u9700\u4E0A\u4E0B\u6587\uFF08\u53EA\u8BFB\uFF0C\u6765\u81EA codemap/ADR\uFF09 -->", ...lines].join("\n");
+  if (text.length > MAX_CONTEXT_BYTES) text = `${text.slice(0, MAX_CONTEXT_BYTES - 20)}
+\u2026\uFF08\u5DF2\u622A\u65AD\uFF09`;
+  return text;
+}
+async function buildAdditionalContexts(input) {
+  try {
+    if (!injectEnabled(input.root)) {
+      input.trace?.("inject skipped: disabled (no .agent/inject.json / env)");
+      return { ok: false, reason: "inject disabled (no .agent/inject.json / env)" };
+    }
+    const key = `${input.sessionId ?? ""}|${input.filePath ?? ""}`;
+    if (injected.has(key)) {
+      input.trace?.("inject skipped: already injected for this session+file");
+      return { ok: false, reason: "already injected for this session+file" };
+    }
+    const text = buildInjectText({
+      root: input.root,
+      ...input.filePath !== void 0 ? { filePath: input.filePath } : {},
+      ...input.extraPaths !== void 0 ? { extraPaths: input.extraPaths } : {}
+    });
+    if (text === null) {
+      input.trace?.("inject skipped: nothing to inject for this path");
+      return { ok: false, reason: "nothing to inject for this path" };
+    }
+    const factory = await loadFactory();
+    const msg = factory !== null ? factory({ content: [{ type: "text", text }], source: { kind: "user" } }) : handcraft(text);
+    if (!assertUserMessage(msg)) {
+      input.trace?.(`inject rejected: shape check failed (${factory !== null ? "factory" : "handcraft"})`);
+      return { ok: false, reason: "shape check failed" };
+    }
+    injected.add(key);
+    input.trace?.(
+      `inject ok: ${String(text.length)}B via ${factory !== null ? "factory" : "handcraft"}`
+    );
+    return { ok: true, messages: [msg] };
+  } catch (err) {
+    input.trace?.(`inject skipped: ${err.message}`);
+    return { ok: false, reason: err.message };
+  }
+}
+
+// src/payload.ts
+import { existsSync as existsSync5 } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
+function buildPayload(input) {
+  return {
+    event: input.event,
+    hookId: input.hookId,
+    toolName: input.toolName,
+    args: input.args,
+    sessionId: input.sessionId,
+    cwd: input.cwd ?? null
+  };
+}
+function payloadStdin(payload) {
+  return `${JSON.stringify(payload)}
+`;
+}
+function hookEnv(cwd, hookId, sessionId) {
+  const nodeDir = nodeBinDir() ?? dirname2(process.execPath);
+  const hostPath = process.env.PATH;
+  return {
+    CLAUDE_PROJECT_DIR: cwd,
+    DSH_HOOK_ID: hookId,
+    DSH_SESSION_ID: sessionId ?? "",
+    // PATH = node 所在目录 + 宿主 PATH（node 目录放最前，保证 `node` 可解析）
+    PATH: [nodeDir, hostPath ?? "/usr/local/bin:/usr/bin:/bin"].filter((p) => p !== "").join(":")
+  };
+}
+function nodeBinDir() {
+  const candidates = [dirname2(process.execPath)];
+  for (const dir of (process.env.PATH ?? "").split(":")) if (dir !== "") candidates.push(dir);
+  candidates.push("/usr/local/bin", "/usr/bin", "/bin");
+  for (const dir of candidates) {
+    try {
+      if (existsSync5(join5(dir, "node"))) return dir;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/execute.ts
+import { spawnSync } from "node:child_process";
+async function runHookCommand(req, shell) {
+  if (shell !== void 0 && typeof shell.run === "function" && typeof shell.resolve === "function") {
+    try {
+      const resolved = shell.resolve({
+        command: req.command,
+        workdir: req.cwd,
+        timeoutMs: req.timeoutMs,
+        stdin: req.stdin,
+        env: req.env
+      });
+      const r2 = await shell.run(resolved);
+      return { exitCode: r2.exitCode };
+    } catch (err) {
+      return { exitCode: 1, error: `ctx.shell failure: ${err.message}` };
+    }
+  }
+  const r = spawnSync("sh", ["-c", req.command], {
+    cwd: req.cwd,
+    timeout: req.timeoutMs,
+    input: req.stdin,
+    env: { ...process.env, ...req.env },
+    encoding: "utf8"
+  });
+  return { exitCode: r.status ?? 1, ...r.status === null ? { error: `signal: ${String(r.signal)}` } : {} };
+}
+function safeShell(ctx) {
+  try {
+    const shell = ctx?.shell;
+    return shell !== void 0 && typeof shell.run === "function" && typeof shell.resolve === "function" ? shell : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/index.ts
+function extractCandidatePaths(exec) {
+  const args = exec.arguments;
+  if (args === void 0 || args === null || typeof args !== "object") return [];
+  const out = [];
+  for (const key of ["file_path", "path", "notebook_path", "target_file"]) {
+    const v = args[key];
+    if (typeof v === "string" && v !== "") out.push(v);
+  }
+  const cmd = typeof args.command === "string" ? args.command : "";
+  if (cmd === "") return out;
+  const cdTargets = [];
+  const cdRe = /\bcd\s+([^\s;&|'"]+)/g;
+  let m;
+  while ((m = cdRe.exec(cmd)) !== null) {
+    const raw = m[1];
+    cdTargets.push(isAbsolute2(raw) ? raw : join6(process.cwd(), raw));
+  }
+  const absTargets = [];
+  const absRe = /(?<=^|[\s'"=(])(\/[^\s'";&|)]+)/g;
+  while ((m = absRe.exec(cmd)) !== null) {
+    const raw = m[1];
+    if (!absTargets.includes(raw)) absTargets.push(raw);
+  }
+  for (const t of [...out, ...cdTargets, ...absTargets]) {
+    if (!out.includes(t)) out.push(t);
+  }
+  return [...new Set(out)];
+}
+function trace(dshHome, line) {
+  try {
+    mkdirSync(dshHome, { recursive: true });
+    appendFileSync(join6(dshHome, ".agentkit-plugin.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+`, "utf8");
+  } catch {
+  }
+}
+var ALLOW = { kind: "allow" };
+var PLUGIN_MARK = "v2";
+function observeOnly() {
+  return process.env.AGENTKIT_HOOKS_ENFORCE !== "1";
+}
+var RECENT_CAP = 20;
+function createProjectHooksPlugin(ctx) {
+  const state = { runs: [] };
+  const shell = safeShell(ctx);
+  const note = (text) => {
+    try {
+      ctx.write?.(text);
+    } catch {
+    }
+  };
+  const record = (run) => {
+    state.runs = [run, ...state.runs].slice(0, RECENT_CAP);
+  };
+  const recordEvent = (root, event) => {
+    try {
+      const dir = join6(root, ".agent", "audit");
+      mkdirSync(dir, { recursive: true });
+      const shard = process.env.AGENTKIT_EVENT_SHARD ?? `pid-${process.pid}`;
+      const file = join6(dir, `events.${String(shard).replace(/[^A-Za-z0-9._-]/g, "_")}.jsonl`);
+      appendFileSync(file, `${JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...event })}
+`, "utf8");
+    } catch (err) {
+      trace(
+        process.env.DSH_HOME ?? join6(homedir(), ".dsh"),
+        `event write skipped: ${err.message}`
+      );
+    }
+  };
+  const recordPersistent = (root, run) => {
+    try {
+      const dir = join6(root, ".agent", "audit");
+      mkdirSync(dir, { recursive: true });
+      const row = {
+        ts: new Date(run.at).toISOString(),
+        hookId: run.hookId,
+        event: run.event,
+        tool: run.toolName,
+        exitCode: run.exitCode,
+        client: "dsh",
+        ...run.sessionId !== void 0 && run.sessionId !== null ? { sessionId: run.sessionId } : {},
+        ...run.skill !== void 0 ? { skill: run.skill } : {},
+        ...run.error !== void 0 ? { error: run.error } : {}
+      };
+      appendFileSync(join6(dir, "hooks.jsonl"), `${JSON.stringify(row)}
+`, "utf8");
+    } catch (err) {
+      trace(
+        process.env.DSH_HOME ?? join6(homedir(), ".dsh"),
+        `audit write skipped: ${err.message}`
+      );
+    }
+  };
+  const tryInjectContext = async (exec) => {
+    try {
+      const sessionCwd = exec.agent?.session?.header?.cwd ?? process.cwd();
+      const candidates = extractCandidatePaths(exec);
+      const found = findProjectRoot(candidates, sessionCwd);
+      if (found.root === null) return null;
+      const root = found.root;
+      const inside = candidates.filter((c) => {
+        const abs = isAbsolute2(c) ? c : join6(sessionCwd, c);
+        return abs === root || abs.startsWith(root + "/");
+      });
+      const filePath = inside[0];
+      const sessionId = exec.agent?.session?.id ?? null;
+      const r = await buildAdditionalContexts({
+        root,
+        ...filePath !== void 0 ? { filePath } : {},
+        ...sessionId !== null ? { sessionId } : {},
+        trace: (line) => trace(process.env.DSH_HOME ?? join6(homedir(), ".dsh"), line)
+      });
+      return r.ok && r.messages !== void 0 ? r.messages : null;
+    } catch (err) {
+      trace(
+        process.env.DSH_HOME ?? join6(homedir(), ".dsh"),
+        `inject outer failed (ignored): ${err.message}`
+      );
+      return null;
+    }
+  };
+  const handle = async (event, exec) => {
+    try {
+      const decision = await runHooks(event, exec);
+      if (event === "PostToolUse" && decision.kind === "allow") {
+        const injected2 = await tryInjectContext(exec);
+        if (injected2 !== null) return { kind: "accept", additionalContexts: injected2 };
+      }
+      return decision;
+    } catch (err) {
+      trace(process.env.DSH_HOME ?? join6(homedir(), ".dsh"), `internal error (allowing call): ${err.message}`);
+      note(`project-hooks: internal error (allowing call): ${err.message}
+`);
+      return ALLOW;
+    }
+  };
+  const runHooks = async (event, exec) => {
+    const sessionCwd = exec.agent?.session?.header?.cwd ?? process.cwd();
+    const candidates = extractCandidatePaths(exec);
+    const targetPath = candidates[0];
+    const found = findProjectRoot(candidates, sessionCwd);
+    const cwd = found.root ?? sessionCwd;
+    trace(
+      process.env.DSH_HOME ?? join6(homedir(), ".dsh"),
+      found.root !== null ? `root resolve: hit ${found.root}\uFF08\u5019\u9009 ${String(candidates.length)} \u4E2A\uFF09` : `root resolve: miss\uFF08\u5019\u9009 ${candidates.length ? candidates.join(", ") : "(none)"}\uFF09\u2192 sessionCwd`
+    );
+    const sessionId = exec.agent?.session?.id ?? null;
+    let pendingSkillLoad = null;
+    const toolName = String(exec.name ?? "");
+    const args = exec.arguments ?? {};
+    trace(process.env.DSH_HOME ?? join6(homedir(), ".dsh"), `run ${event} ${toolName} root=${cwd}`);
+    if (event === "PostToolUse" && toolName === "skill") {
+      const asked = args.name;
+      pendingSkillLoad = {
+        hookId: "(skill-load)",
+        event: "PostToolUse",
+        toolName: "skill",
+        exitCode: 0,
+        at: Date.now(),
+        sessionId,
+        ...typeof asked === "string" ? { skill: asked } : {}
+      };
+      trace(process.env.DSH_HOME ?? join6(homedir(), ".dsh"), `skill-load ${typeof asked === "string" ? asked : "(unnamed)"}`);
+    }
+    const dshHome = process.env.DSH_HOME ?? join6(homedir(), ".dsh");
+    let effectiveCwd = cwd;
+    let hookLoad = loadHooks(effectiveCwd);
+    if (hookLoad.source === null) {
+      const cmdText = typeof args.command === "string" ? args.command : "";
+      const byName = matchProjectByName(cmdText, cwd);
+      if (byName.root !== null) {
+        effectiveCwd = byName.root;
+        hookLoad = loadHooks(effectiveCwd);
+        trace(dshHome, `project root by name: ${effectiveCwd}\uFF08${byName.reason}\uFF09`);
+      } else if (cmdText !== "") {
+        trace(dshHome, `no project root: ${byName.reason}`);
+      }
+    }
+    const { hooks, source, errors } = hookLoad;
+    for (const e of errors) note(`project-hooks: ${e}
+`);
+    if (pendingSkillLoad !== null && source !== null) {
+      recordPersistent(effectiveCwd, pendingSkillLoad);
+      trace(dshHome, `skill-load ${pendingSkillLoad.skill ?? "(unnamed)"}`);
+      pendingSkillLoad = null;
+    }
+    if (event === "PostToolUse" && source !== null) {
+      recordEvent(effectiveCwd, {
+        kind: "tool",
+        tool: toolName,
+        status: "ok",
+        files: targetPath !== void 0 && targetPath !== "" ? [targetPath] : [],
+        client: "dsh"
+      });
+    }
+    if (source === null) {
+      trace(dshHome, `no hooks config found under ${cwd}`);
+      return ALLOW;
+    }
+    const applicable = hooks.filter((h) => h.event === event && matches(h, toolName));
+    if (applicable.length === 0) {
+      trace(
+        process.env.DSH_HOME ?? join6(homedir(), ".dsh"),
+        `no applicable hooks (loaded=${String(hooks.length)} tool=${toolName})`
+      );
+      return ALLOW;
+    }
+    let decision = ALLOW;
+    for (const hook of applicable) {
+      trace(dshHome, `start ${hook.id} cmd=${hook.command.slice(0, 60)}`);
+      const payload = buildPayload({ event, hookId: hook.id, toolName, args, sessionId, cwd });
+      const { exitCode, error } = await runHookCommand(
+        {
+          command: hook.command,
+          cwd,
+          timeoutMs: hook.timeoutMs,
+          stdin: payloadStdin(payload),
+          env: hookEnv(cwd, hook.id, sessionId)
+        },
+        shell
+      );
+      const run = {
+        hookId: hook.id,
+        event,
+        toolName,
+        exitCode,
+        at: Date.now(),
+        ...error !== void 0 ? { error } : {}
+      };
+      record(run);
+      recordPersistent(effectiveCwd, { ...run, sessionId });
+      trace(
+        process.env.DSH_HOME ?? join6(homedir(), ".dsh"),
+        `hook ${hook.id} exit=${exitCode}${error === void 0 ? "" : ` error=${error}`}`
+      );
+      if (error !== void 0) note(`project-hooks: ${hook.id}: ${error}
+`);
+      if (exitCodeBlocks(hook, exitCode)) {
+        decision = {
+          kind: "deny",
+          reason: `project-hooks: ${hook.id} exited ${exitCode}${error === void 0 ? "" : ` (${error})`}`
+        };
+      }
+    }
+    if (decision.kind === "deny" && observeOnly()) {
+      note(`project-hooks: observe mode \u2014 would deny via ${decision.reason ?? "(no reason)"}
+`);
+      return ALLOW;
+    }
+    return decision;
+  };
+  ctx.on("tools/pre-execute", (exec) => handle("PreToolUse", exec));
+  ctx.on("tools/post-execute", (exec) => handle("PostToolUse", exec));
+  return state;
+}
+function apply(ctx) {
+  const home = process.env.DSH_HOME ?? join6(homedir(), ".dsh");
+  trace(home, `apply registered seams v${PLUGIN_MARK} (observe=${String(observeOnly())})`);
+  return createProjectHooksPlugin(ctx);
+}
+export {
+  apply,
+  createProjectHooksPlugin
+};