plugnz 0.0.15 → 0.0.16

package/README.md

@@ -18,6 +18,8 @@ re-`add` from the source recorded in `state.json`, plus the pins that install
 carried. Both refuse rather than guess, and neither will touch a plugin this
 tool did not install. Details: `docs/pin-and-update.md`.
 
+**Portable context hooks:** `plugnz hooks build <plugin-dir> --target <host> --out <dir>` compiles session-start, stop, and pre/post-tool handlers for Claude Code, Codex, OMP, Pi v1, OpenCode, and ZCode. Handlers receive normalized JSON and return context; native adapters expose their delivery and continuation limits through `plugnz hooks targets`. See [the contract, usage, and native map](docs/hooks.md).
+
 Why another tool: `npx plugins` is closed-source and its Cursor target does not install into Cursor; nothing in the ecosystem checks that an installed plugin still *works*. See `docs/research/`.
 
 The published CLI runs under Node.js 22 or newer; `npx` needs npm, not Bun. `bunx` also works. Bun is used for development and building. `add` accepts a local plugin or marketplace directory as well as a Git URL. Native plugin targets currently include Claude Code, Codex, Kimi, Cursor, OMP, Hermes, Grok, DCode, and ZCode CLI. Run `plugnz targets --all` to see supported and unsupported capabilities for each host; standalone skill distribution is outside this CLI's scope.

package/dist/hook-runtime.mjs

@@ -0,0 +1,288 @@
+// src/hooks.ts
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+var HOOK_EVENTS = ["session.start", "turn.stop", "tool.before", "tool.after"];
+var HOOK_CONFIG_FILE = "plugnz.hooks.json";
+var DEFAULT_HOOK_TIMEOUT_MS = 1e4;
+var MAX_HOOK_TIMEOUT_MS = 60000;
+var MAX_HOOK_OUTPUT_BYTES = 1048576;
+function record(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error(label + " must be an object");
+  return value;
+}
+function keys(value, allowed, label) {
+  const unknown = Object.keys(value).find((key) => !allowed.includes(key));
+  if (unknown !== undefined)
+    throw new Error(label + ': unsupported field "' + unknown + '"');
+}
+function text(value, label, nonblank = true) {
+  if (typeof value !== "string" || value.includes("\x00") || nonblank && !value.trim())
+    throw new Error(label + " must be a nonblank string without NUL");
+  return value;
+}
+function optionalText(value, label) {
+  return value === undefined ? undefined : text(value, label, false);
+}
+function isHookEvent(value) {
+  return typeof value === "string" && HOOK_EVENTS.includes(value);
+}
+function validateHookConfig(value) {
+  const root = record(value, "Hook configuration");
+  keys(root, ["version", "hooks"], "Hook configuration");
+  if (root["version"] !== 1)
+    throw new Error("Hook configuration version must be 1");
+  const sourceHooks = record(root["hooks"], "hooks");
+  keys(sourceHooks, HOOK_EVENTS, "hooks");
+  const hooks = {};
+  for (const event of HOOK_EVENTS) {
+    const handlers = sourceHooks[event];
+    if (handlers === undefined)
+      continue;
+    if (!Array.isArray(handlers))
+      throw new Error(event + " handlers must be an array");
+    hooks[event] = handlers.map((value, index) => {
+      const label = event + "[" + index + "]";
+      const handler = record(value, label);
+      keys(handler, ["command", "tools", "timeoutMs"], label);
+      const command = handler["command"];
+      if (!Array.isArray(command) || command.length === 0)
+        throw new Error(label + ".command must be a nonempty argv array");
+      const argv = command.map((argument, i) => text(argument, label + ".command[" + i + "]", i === 0));
+      const filter = handler["tools"];
+      let tools;
+      if (filter !== undefined) {
+        if (event !== "tool.before" && event !== "tool.after")
+          throw new Error(label + ".tools is only valid for tool events");
+        if (!Array.isArray(filter))
+          throw new Error(label + ".tools must be an array of exact tool names");
+        tools = filter.map((name, i) => text(name, label + ".tools[" + i + "]"));
+      }
+      const timeout = handler["timeoutMs"];
+      if (timeout !== undefined && (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout < 1 || timeout > MAX_HOOK_TIMEOUT_MS)) {
+        throw new Error(label + ".timeoutMs must be an integer from 1 to " + MAX_HOOK_TIMEOUT_MS);
+      }
+      return { command: argv, ...tools === undefined ? {} : { tools }, ...timeout === undefined ? {} : { timeoutMs: timeout } };
+    });
+  }
+  return { version: 1, hooks };
+}
+function readHookConfig(pluginRoot) {
+  const path = join(pluginRoot, HOOK_CONFIG_FILE);
+  if (!existsSync(path))
+    return;
+  let value;
+  try {
+    value = JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    throw new Error("Cannot read " + HOOK_CONFIG_FILE + ": " + error.message);
+  }
+  return validateHookConfig(value);
+}
+function validateHookInput(value) {
+  const input = record(value, "Hook input");
+  keys(input, ["version", "event", "harness", "sessionId", "cwd", "reason", "tool", "stop"], "Hook input");
+  if (input["version"] !== 1)
+    throw new Error("Hook input version must be 1");
+  const event = input["event"];
+  if (!isHookEvent(event))
+    throw new Error("Hook input event is unsupported");
+  const harness = text(input["harness"], "Hook input harness");
+  const cwd = text(input["cwd"], "Hook input cwd");
+  if (!isAbsolute(cwd))
+    throw new Error("Hook input cwd must be absolute");
+  const sessionId = optionalText(input["sessionId"], "Hook input sessionId");
+  const reason = optionalText(input["reason"], "Hook input reason");
+  let tool;
+  if (input["tool"] !== undefined) {
+    const source = record(input["tool"], "Hook input tool");
+    keys(source, ["name", "id", "input", "output", "isError"], "Hook input tool");
+    const name = text(source["name"], "Hook input tool.name");
+    const id = optionalText(source["id"], "Hook input tool.id");
+    if (source["isError"] !== undefined && typeof source["isError"] !== "boolean")
+      throw new Error("Hook input tool.isError must be boolean");
+    tool = {
+      name,
+      ...id === undefined ? {} : { id },
+      ...source["input"] === undefined ? {} : { input: source["input"] },
+      ...source["output"] === undefined ? {} : { output: source["output"] },
+      ...source["isError"] === undefined ? {} : { isError: source["isError"] }
+    };
+  }
+  if ((event === "tool.before" || event === "tool.after") && tool === undefined)
+    throw new Error(event + " requires tool.name");
+  let stop;
+  if (input["stop"] !== undefined) {
+    const source = record(input["stop"], "Hook input stop");
+    keys(source, ["active"], "Hook input stop");
+    if (typeof source["active"] !== "boolean")
+      throw new Error("Hook input stop.active must be boolean");
+    stop = { active: source["active"] };
+  }
+  if (event === "turn.stop" && stop === undefined)
+    throw new Error("turn.stop requires stop.active");
+  return {
+    version: 1,
+    event,
+    harness,
+    cwd,
+    ...sessionId === undefined ? {} : { sessionId },
+    ...reason === undefined ? {} : { reason },
+    ...tool === undefined ? {} : { tool },
+    ...stop === undefined ? {} : { stop }
+  };
+}
+function validateHookResult(value, input) {
+  const result = record(value, "Hook result");
+  keys(result, ["context", "continue"], "Hook result");
+  if (result["context"] !== undefined && typeof result["context"] !== "string")
+    throw new Error("Hook result context must be a string");
+  if (result["continue"] !== undefined && typeof result["continue"] !== "boolean")
+    throw new Error("Hook result continue must be boolean");
+  const context = result["context"];
+  const shouldContinue = result["continue"];
+  const hasContext = context !== undefined && context.trim().length > 0;
+  if (shouldContinue === true) {
+    if (input.event !== "turn.stop")
+      throw new Error("continue:true is only valid for turn.stop");
+    if (!hasContext)
+      throw new Error("turn.stop continuation requires nonblank context");
+    if (input.stop?.active)
+      throw new Error("turn.stop cannot continue while stop.active is true");
+  }
+  if (input.event === "turn.stop" && hasContext && shouldContinue !== true) {
+    throw new Error("turn.stop context requires continue:true; return {} to let the turn settle");
+  }
+  return { ...hasContext ? { context } : {}, ...shouldContinue === undefined ? {} : { continue: shouldContinue } };
+}
+async function runHooks(configValue, inputValue, pluginRoot) {
+  const config = validateHookConfig(configValue);
+  const input = validateHookInput(inputValue);
+  const root = resolve(text(pluginRoot, "Plugin root"));
+  const contexts = [];
+  let requestedContinuation;
+  const handlers = config.hooks[input.event] ?? [];
+  for (let index = 0;index < handlers.length; index++) {
+    const handler = handlers[index];
+    if (handler.tools !== undefined && !handler.tools.includes(input.tool?.name ?? ""))
+      continue;
+    const label = input.event + "[" + index + "]";
+    try {
+      const stdout = await executeHandler(handler, input, root);
+      let raw = {};
+      if (stdout.trim()) {
+        try {
+          raw = JSON.parse(stdout);
+        } catch {
+          throw new Error("stdout must contain one JSON result object");
+        }
+      }
+      const result = validateHookResult(raw, input);
+      if (result.context !== undefined)
+        contexts.push(result.context);
+      if (result.continue !== undefined)
+        requestedContinuation = requestedContinuation === true || result.continue;
+    } catch (error) {
+      throw new Error(label + ": " + (error instanceof Error ? error.message : String(error)));
+    }
+  }
+  return {
+    ...contexts.length === 0 ? {} : { context: contexts.join(`
+
+`) },
+    ...requestedContinuation === undefined ? {} : { continue: requestedContinuation }
+  };
+}
+function decode(chunks) {
+  const result = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return new TextDecoder().decode(result);
+}
+function executeHandler(handler, input, pluginRoot) {
+  const token = "$" + "{PLUGIN_ROOT}";
+  const argv = handler.command.map((argument) => argument.replaceAll(token, pluginRoot));
+  const serialized = JSON.stringify(input) + `
+`;
+  const timeoutMs = handler.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS;
+  return new Promise((resolveResult, reject) => {
+    const child = spawn(argv[0], argv.slice(1), {
+      cwd: input.cwd,
+      env: process.env,
+      shell: false,
+      detached: process.platform !== "win32",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stdout = [];
+    const stderr = [];
+    let bytes = 0;
+    let settled = false;
+    let timer;
+    const kill = () => {
+      if (process.platform !== "win32" && child.pid !== undefined) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+          return;
+        } catch {}
+      }
+      child.kill("SIGKILL");
+    };
+    const finish = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (error !== undefined) {
+        child.stdin.destroy();
+        child.stdout.destroy();
+        child.stderr.destroy();
+        reject(error);
+      } else
+        resolveResult(decode(stdout));
+    };
+    const collect = (chunks) => (chunk) => {
+      if (settled)
+        return;
+      bytes += chunk.length;
+      if (bytes > MAX_HOOK_OUTPUT_BYTES) {
+        kill();
+        finish(new Error("handler output exceeded " + MAX_HOOK_OUTPUT_BYTES + " bytes"));
+      } else
+        chunks.push(chunk);
+    };
+    child.stdout.on("data", collect(stdout));
+    child.stderr.on("data", collect(stderr));
+    child.stdin.on("error", () => {});
+    child.once("error", (error) => finish(error));
+    child.once("close", (code, signal) => {
+      if (settled)
+        return;
+      if (code !== 0) {
+        const diagnostic = decode(stderr).trim().slice(0, 4096);
+        finish(new Error("handler exited " + (signal ?? String(code)) + (diagnostic ? ": " + diagnostic : "")));
+      } else
+        finish();
+    });
+    timer = setTimeout(() => {
+      kill();
+      finish(new Error("handler timed out after " + timeoutMs + "ms"));
+    }, timeoutMs);
+    child.stdin.end(serialized);
+  });
+}
+export {
+  DEFAULT_HOOK_TIMEOUT_MS,
+  HOOK_CONFIG_FILE,
+  HOOK_EVENTS,
+  MAX_HOOK_OUTPUT_BYTES,
+  MAX_HOOK_TIMEOUT_MS,
+  readHookConfig,
+  runHooks,
+  validateHookConfig,
+  validateHookInput,
+  validateHookResult
+};

package/dist/plugnz.mjs

@@ -1,6 +1,17 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // node_modules/yaml/dist/nodes/identity.js
@@ -6945,8 +6956,816 @@ var require_public_api = __commonJS(function(exports) {
   exports.stringify = stringify;
 });
 
+// src/hooks.ts
+import { existsSync as existsSync29, readFileSync as readFileSync31 } from "node:fs";
+import { isAbsolute as isAbsolute13, join as join39, resolve as resolve26 } from "node:path";
+function record3(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error(label + " must be an object");
+  return value;
+}
+function keys2(value, allowed, label) {
+  const unknown = Object.keys(value).find((key) => !allowed.includes(key));
+  if (unknown !== undefined)
+    throw new Error(label + ': unsupported field "' + unknown + '"');
+}
+function text3(value, label, nonblank = true) {
+  if (typeof value !== "string" || value.includes("\x00") || nonblank && !value.trim())
+    throw new Error(label + " must be a nonblank string without NUL");
+  return value;
+}
+function validateHookConfig(value) {
+  const root = record3(value, "Hook configuration");
+  keys2(root, ["version", "hooks"], "Hook configuration");
+  if (root["version"] !== 1)
+    throw new Error("Hook configuration version must be 1");
+  const sourceHooks = record3(root["hooks"], "hooks");
+  keys2(sourceHooks, HOOK_EVENTS, "hooks");
+  const hooks = {};
+  for (const event of HOOK_EVENTS) {
+    const handlers = sourceHooks[event];
+    if (handlers === undefined)
+      continue;
+    if (!Array.isArray(handlers))
+      throw new Error(event + " handlers must be an array");
+    hooks[event] = handlers.map((value, index) => {
+      const label = event + "[" + index + "]";
+      const handler = record3(value, label);
+      keys2(handler, ["command", "tools", "timeoutMs"], label);
+      const command = handler["command"];
+      if (!Array.isArray(command) || command.length === 0)
+        throw new Error(label + ".command must be a nonempty argv array");
+      const argv = command.map((argument, i) => text3(argument, label + ".command[" + i + "]", i === 0));
+      const filter = handler["tools"];
+      let tools;
+      if (filter !== undefined) {
+        if (event !== "tool.before" && event !== "tool.after")
+          throw new Error(label + ".tools is only valid for tool events");
+        if (!Array.isArray(filter))
+          throw new Error(label + ".tools must be an array of exact tool names");
+        tools = filter.map((name, i) => text3(name, label + ".tools[" + i + "]"));
+      }
+      const timeout = handler["timeoutMs"];
+      if (timeout !== undefined && (typeof timeout !== "number" || !Number.isInteger(timeout) || timeout < 1 || timeout > MAX_HOOK_TIMEOUT_MS)) {
+        throw new Error(label + ".timeoutMs must be an integer from 1 to " + MAX_HOOK_TIMEOUT_MS);
+      }
+      return { command: argv, ...tools === undefined ? {} : { tools }, ...timeout === undefined ? {} : { timeoutMs: timeout } };
+    });
+  }
+  return { version: 1, hooks };
+}
+function readHookConfig(pluginRoot) {
+  const path = join39(pluginRoot, HOOK_CONFIG_FILE);
+  if (!existsSync29(path))
+    return;
+  let value;
+  try {
+    value = JSON.parse(readFileSync31(path, "utf8"));
+  } catch (error) {
+    throw new Error("Cannot read " + HOOK_CONFIG_FILE + ": " + error.message);
+  }
+  return validateHookConfig(value);
+}
+var HOOK_EVENTS, HOOK_CONFIG_FILE = "plugnz.hooks.json", DEFAULT_HOOK_TIMEOUT_MS = 1e4, MAX_HOOK_TIMEOUT_MS = 60000;
+var init_hooks = __esm(() => {
+  HOOK_EVENTS = ["session.start", "turn.stop", "tool.before", "tool.after"];
+});
+
+// src/hosts/command-hooks.ts
+function commandHookAdapter(options) {
+  return {
+    id: options.id,
+    baselineVersion: options.baselineVersion,
+    capabilities: {
+      "session.start": { nativeEvent: options.nativeEvents["session.start"].join(" / "), context: true, continue: false, delivery: options.contextDelivery },
+      "tool.before": { nativeEvent: options.nativeEvents["tool.before"].join(" / "), context: true, continue: false, delivery: options.contextDelivery },
+      "tool.after": { nativeEvent: options.nativeEvents["tool.after"].join(" / "), context: true, continue: false, delivery: options.contextDelivery },
+      "turn.stop": { nativeEvent: options.nativeEvents["turn.stop"].join(" / "), context: true, continue: true, delivery: "with explicit continuation only" }
+    },
+    emit(config) {
+      const wrapperPath = `hooks/plugnz-${options.id}.mjs`;
+      const native = {};
+      const eventMap = {};
+      for (const [event, handlers] of Object.entries(config.hooks)) {
+        if (!handlers?.length)
+          continue;
+        for (const name of options.nativeEvents[event]) {
+          eventMap[name] = event;
+          const seconds = Math.ceil((handlers.reduce((sum, handler) => sum + (handler.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS), 0) + 1000) / 1000);
+          native[name] = [{ hooks: [{ type: "command", command: `node "\${CLAUDE_PLUGIN_ROOT}/${wrapperPath}"`, async: false, [options.timeoutKey ?? "timeout"]: seconds }] }];
+        }
+      }
+      const wrapper = `import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { runHooks } from '../hook-runtime.mjs';
+const config = ${JSON.stringify(config)};
+const events = ${JSON.stringify(eventMap)};
+const pluginRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+try {
+  let raw = '';
+  for await (const chunk of process.stdin) {
+    raw += chunk;
+    if (Buffer.byteLength(raw) > 1048576) throw new Error('Native hook input exceeds 1 MiB');
+  }
+  const native = JSON.parse(raw);
+  const nativeEvent = native.hook_event_name ?? native.hookEventName;
+  const event = events[nativeEvent];
+  if (!event) throw new Error('Unsupported native hook event: ' + nativeEvent);
+  const isTool = event === 'tool.before' || event === 'tool.after';
+  const input = {
+    version: 1, event, harness: ${JSON.stringify(options.id)},
+    cwd: native.cwd ?? process.cwd(),
+    ...(native.session_id ?? native.sessionId ? { sessionId: native.session_id ?? native.sessionId } : {}),
+    ...(native.source ?? native.reason ? { reason: native.source ?? native.reason } : {}),
+    ...(isTool ? { tool: {
+      name: native.tool_name ?? native.toolName,
+      ...(native.tool_use_id ?? native.tool_call_id ?? native.toolCallId ? { id: native.tool_use_id ?? native.tool_call_id ?? native.toolCallId } : {}),
+      input: native.tool_input ?? native.toolInput,
+      ...(event === 'tool.after' ? {
+        output: native.tool_response ?? native.toolResponse ?? native.error,
+        isError: nativeEvent === 'PostToolUseFailure' || native.is_error === true || native.isError === true,
+      } : {}),
+    } } : {}),
+    ...(event === 'turn.stop' ? { stop: { active: native.stop_hook_active === true || native.stopHookActive === true } } : {}),
+  };
+  const result = await runHooks(config, input, pluginRoot);
+  let output = {};
+  if (event === 'turn.stop') {
+    if (result.continue === true) output = ${options.stopOutputSource};
+  } else if (result.context !== undefined) {
+    output = { hookSpecificOutput: { hookEventName: nativeEvent, additionalContext: result.context } };
+  }
+  process.stdout.write(JSON.stringify(output) + '\\n');
+} catch (error) {
+  process.stderr.write('plugnz hook: ' + (error instanceof Error ? error.message : String(error)) + '\\n');
+  process.exitCode = 1;
+}
+`;
+      return { "hooks/hooks.json": JSON.stringify({ hooks: native }, null, 2) + `
+`, [wrapperPath]: wrapper };
+    }
+  };
+}
+var init_command_hooks = __esm(() => {
+  init_hooks();
+});
+
+// src/hosts/command-hook-manifest.ts
+import { existsSync as existsSync30, mkdirSync as mkdirSync15, readFileSync as readFileSync32, rmSync as rmSync16, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname19, join as join40 } from "node:path";
+function manifest(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync32(path, "utf8"));
+  } catch (error) {
+    throw new Error("Cannot read hook plugin manifest " + path + ": " + error.message);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error("Hook plugin manifest must be an object: " + path);
+  const value = parsed;
+  if (typeof value["name"] !== "string" || !/^[a-z0-9][a-z0-9._-]{0,127}$/.test(value["name"]))
+    throw new Error("Hook plugin manifest has an invalid native plugin name: " + path);
+  for (const field of ["version", "description"]) {
+    if (value[field] !== undefined && (typeof value[field] !== "string" || value[field].includes("\x00")))
+      throw new Error("Hook plugin manifest " + field + " must be a string: " + path);
+  }
+  return value;
+}
+function prepareCommandHookManifest(stagingRoot, relativeNativePath, removeRoot) {
+  const rootPath = join40(stagingRoot, "plugin.json");
+  const nativePath = join40(stagingRoot, relativeNativePath);
+  const root = existsSync30(rootPath) ? manifest(rootPath) : undefined;
+  if (root) {
+    const unsupported = Object.keys(root).find((key) => !IDENTITY_FIELDS.includes(key));
+    if (unsupported)
+      throw new Error('Hook build cannot project root plugin.json field "' + unsupported + '"; use an explicit native plugin manifest');
+  }
+  const native = existsSync30(nativePath) ? manifest(nativePath) : undefined;
+  if (!native && !root)
+    throw new Error("Hook build requires a plugin identity in plugin.json or " + relativeNativePath);
+  if (native) {
+    for (const key of IDENTITY_FIELDS) {
+      if (root?.[key] !== undefined && native[key] !== root[key])
+        throw new Error("Conflicting hook plugin manifest identity: " + key);
+    }
+    if (native["hooks"] !== undefined && native["hooks"] !== "./hooks/hooks.json" && native["hooks"] !== "hooks/hooks.json") {
+      throw new Error("Hook build cannot merge a custom native hooks route");
+    }
+  } else {
+    mkdirSync15(dirname19(nativePath), { recursive: true });
+    writeFileSync15(nativePath, JSON.stringify(root, null, 2) + `
+`);
+  }
+  if (removeRoot && root)
+    rmSync16(rootPath);
+}
+var IDENTITY_FIELDS;
+var init_command_hook_manifest = __esm(() => {
+  IDENTITY_FIELDS = ["name", "version", "description"];
+});
+
+// src/hosts/claude-code-hooks.ts
+function prepareHookPlugin(stagingRoot) {
+  prepareCommandHookManifest(stagingRoot, ".claude-plugin/plugin.json", false);
+}
+var adapter, hookAdapter;
+var init_claude_code_hooks = __esm(() => {
+  init_command_hooks();
+  init_command_hook_manifest();
+  adapter = commandHookAdapter({
+    id: "claude-code",
+    baselineVersion: "2.1.285",
+    nativeEvents: {
+      "session.start": ["SessionStart"],
+      "tool.before": ["PreToolUse"],
+      "tool.after": ["PostToolUse", "PostToolUseFailure"],
+      "turn.stop": ["Stop"]
+    },
+    contextDelivery: "native additionalContext; post success and executed failure",
+    stopOutputSource: "{ decision: 'block', reason: result.context }"
+  });
+  hookAdapter = { ...adapter, prepare: prepareHookPlugin };
+});
+
+// src/hosts/codex-hooks.ts
+function prepareHookPlugin2(stagingRoot) {
+  prepareCommandHookManifest(stagingRoot, ".codex-plugin/plugin.json", true);
+}
+var adapter2, hookAdapter2;
+var init_codex_hooks = __esm(() => {
+  init_command_hooks();
+  init_command_hook_manifest();
+  adapter2 = commandHookAdapter({
+    id: "codex",
+    baselineVersion: "0.161.0",
+    nativeEvents: {
+      "session.start": ["SessionStart"],
+      "tool.before": ["PreToolUse"],
+      "tool.after": ["PostToolUse"],
+      "turn.stop": ["Stop"]
+    },
+    contextDelivery: "developer context; post-success only on qualified native routes",
+    stopOutputSource: "{ decision: 'block', reason: result.context }"
+  });
+  hookAdapter2 = { ...adapter2, prepare: prepareHookPlugin2 };
+});
+
+// src/hosts/omp-hooks.ts
+var hookAdapter3;
+var init_omp_hooks = __esm(() => {
+  hookAdapter3 = {
+    id: "omp",
+    baselineVersion: "18.8.7",
+    capabilities: {
+      "session.start": { nativeEvent: "session_start", context: true, continue: false, delivery: "user message before the next prompt" },
+      "tool.before": { nativeEvent: "tool_call", context: true, continue: false, delivery: "native additional context after the tool batch" },
+      "tool.after": { nativeEvent: "tool_result", context: true, continue: false, delivery: "native additional context after the tool batch" },
+      "turn.stop": { nativeEvent: "session_stop", context: true, continue: true, delivery: "user message in one native session_stop continuation" }
+    },
+    emit(config) {
+      return {
+        "extension.mjs": `import { fileURLToPath } from 'node:url';
+import { runHooks } from './hook-runtime.mjs';
+
+const config = ${JSON.stringify(config)};
+const pluginRoot = fileURLToPath(new URL('.', import.meta.url));
+
+export default function (pi) {
+  const input = (event, ctx, extra = {}) => ({
+    version: 1, event, harness: 'omp', cwd: ctx.cwd,
+    sessionId: ctx.sessionManager.getSessionId(), ...extra,
+  });
+
+  if (config.hooks['session.start']?.length) {
+    pi.on('session_start', async (event, ctx) => {
+      const result = await runHooks(config, input('session.start', ctx, {
+        reason: event.reason,
+      }), pluginRoot);
+      if (result.context) {
+        pi.sendMessage({
+          customType: 'plugnz:session.start', content: result.context, display: false,
+        }, { deliverAs: 'nextTurn', triggerTurn: false });
+      }
+    });
+  }
+
+  if (config.hooks['tool.before']?.length) {
+    pi.on('tool_call', async (event, ctx) => {
+      const result = await runHooks(config, input('tool.before', ctx, {
+        tool: { name: event.toolName, id: event.toolCallId, input: event.input },
+      }), pluginRoot);
+      if (result.context) return { additionalContext: result.context };
+    });
+  }
+
+  if (config.hooks['tool.after']?.length) {
+    pi.on('tool_result', async (event, ctx) => {
+      const result = await runHooks(config, input('tool.after', ctx, {
+        tool: {
+          name: event.toolName, id: event.toolCallId, input: event.input,
+          output: { content: event.content, details: event.details },
+          isError: event.isError,
+        },
+      }), pluginRoot);
+      if (result.context) return { additionalContext: result.context };
+    });
+  }
+
+  if (config.hooks['turn.stop']?.length) {
+    pi.on('session_stop', async (event, ctx) => {
+      const result = await runHooks(config, input('turn.stop', ctx, {
+        stop: { active: event.stop_hook_active === true },
+      }), pluginRoot);
+      if (result.continue && result.context) {
+        return { continue: true, additionalContext: result.context };
+      }
+    });
+  }
+}
+`
+      };
+    }
+  };
+});
+
+// src/hosts/pi-hooks.ts
+var hookAdapter4;
+var init_pi_hooks = __esm(() => {
+  hookAdapter4 = {
+    id: "pi",
+    baselineVersion: "1.1.0",
+    capabilities: {
+      "session.start": { nativeEvent: "session_start", context: true, continue: false, delivery: "user message before the next prompt" },
+      "tool.before": { nativeEvent: "tool_call", context: true, continue: false, delivery: "user message after the tool batch" },
+      "tool.after": { nativeEvent: "tool_result", context: true, continue: false, delivery: "text appended to the native tool result" },
+      "turn.stop": { nativeEvent: "agent_before_settle", context: true, continue: true, delivery: "user message in one native agent_before_settle continuation" }
+    },
+    emit(config) {
+      return {
+        "extension.mjs": `import { fileURLToPath } from 'node:url';
+import { runHooks } from './hook-runtime.mjs';
+
+const config = ${JSON.stringify(config)};
+const pluginRoot = fileURLToPath(new URL('.', import.meta.url));
+
+export default function (pi) {
+  let stopActive = false;
+  const input = (event, ctx, extra = {}) => ({
+    version: 1, event, harness: 'pi', cwd: ctx.cwd,
+    sessionId: ctx.sessionManager.getSessionId(), ...extra,
+  });
+
+  if (config.hooks['session.start']?.length) {
+    pi.on('session_start', async (event, ctx) => {
+      const result = await runHooks(config, input('session.start', ctx, {
+        reason: event.reason,
+      }), pluginRoot);
+      if (result.context) {
+        pi.sendMessage({
+          customType: 'plugnz:session.start', content: result.context, display: false,
+        }, { deliverAs: 'nextTurn', triggerTurn: false });
+      }
+    });
+  }
+
+  if (config.hooks['tool.before']?.length) {
+    pi.on('tool_call', async (event, ctx) => {
+      const result = await runHooks(config, input('tool.before', ctx, {
+        tool: { name: event.toolName, id: event.toolCallId, input: event.input },
+      }), pluginRoot);
+      if (result.context) {
+        // Context-only messages flush after all results, preserving tool-call/result pairing.
+        pi.sendMessage({
+          customType: 'plugnz:tool.before', content: result.context, display: false,
+        }, { triggerTurn: false });
+      }
+    });
+  }
+
+  if (config.hooks['tool.after']?.length) {
+    pi.on('tool_result', async (event, ctx) => {
+      const result = await runHooks(config, input('tool.after', ctx, {
+        tool: {
+          name: event.toolName, id: event.toolCallId, input: event.input,
+          output: {
+            content: event.content, details: event.details,
+            structuredContent: event.structuredContent, usage: event.usage,
+          },
+          isError: event.isError,
+        },
+      }), pluginRoot);
+      if (result.context) {
+        // Pi clears structuredContent when content is replaced without returning it.
+        return {
+          content: [...event.content, { type: 'text', text: result.context }],
+          structuredContent: event.structuredContent,
+        };
+      }
+    });
+  }
+
+  if (config.hooks['turn.stop']?.length) {
+    // Native continuations do not rerun before_agent_start. A new user prompt does.
+    pi.on('before_agent_start', () => { stopActive = false; });
+    pi.on('agent_before_settle', async (event, ctx) => {
+      const result = await runHooks(config, input('turn.stop', ctx, {
+        stop: { active: stopActive },
+      }), pluginRoot);
+      if (result.continue && result.context) {
+        stopActive = true;
+        return {
+          entries: [...event.entries, {
+            type: 'custom_message', customType: 'plugnz:turn.stop',
+            content: result.context, display: false,
+          }],
+          continue: true,
+        };
+      }
+    });
+  }
+}
+`
+      };
+    }
+  };
+});
+
+// src/hosts/opencode-hooks.ts
+var hookAdapter5;
+var init_opencode_hooks = __esm(() => {
+  hookAdapter5 = {
+    id: "opencode",
+    baselineVersion: "1.19.0",
+    capabilities: {
+      "session.start": { nativeEvent: "experimental.chat.system.transform", context: true, continue: false, delivery: "Awaited before the first model request; cached per session in the plugin instance and included in its system context." },
+      "turn.stop": { nativeEvent: "session.idle", context: false, continue: false, delivery: "session.idle notification: checks only. Feedback and continuation are unsupported." },
+      "tool.before": { nativeEvent: "tool.execute.before", context: true, continue: false, delivery: "Handler runs before execution; context reaches the next model request with the tool result, or through system context when execution fails." },
+      "tool.after": { nativeEvent: "tool.execute.after", context: true, continue: false, delivery: "Append context to successful native or MCP tool results; preserve existing content and metadata." }
+    },
+    emit(config) {
+      return {
+        "plugin.mjs": `import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runHooks } from './hook-runtime.mjs';
+
+const config = ${JSON.stringify(config)};
+const pluginRoot = dirname(fileURLToPath(import.meta.url));
+
+export default async function plugnzHooks({ directory }) {
+  const starts = new Map();
+  const before = new Map();
+  const active = new Set();
+
+  const input = (event, sessionId, extra = {}) => ({
+    version: 1, event, harness: 'opencode', sessionId, cwd: directory, ...extra,
+  });
+  const report = (error) => {
+    console.error('[plugnz hooks: opencode] ' + (error instanceof Error ? error.message : String(error)));
+  };
+  const startup = (sessionId) => {
+    if (!starts.has(sessionId)) {
+      const pending = runHooks(config, input('session.start', sessionId, { reason: 'first-model-request' }), pluginRoot);
+      starts.set(sessionId, pending);
+      pending.catch(() => { if (starts.get(sessionId) === pending) starts.delete(sessionId); });
+    }
+    return starts.get(sessionId);
+  };
+  const pendingFor = (sessionId) => {
+    if (!before.has(sessionId)) before.set(sessionId, new Map());
+    return before.get(sessionId);
+  };
+
+  return {
+    'chat.message': async ({ sessionID }) => {
+      active.add(sessionID);
+    },
+    'experimental.chat.system.transform': async ({ sessionID }, output) => {
+      // Auxiliary model requests without a session do not start a conversation.
+      if (!sessionID) return;
+      const result = await startup(sessionID);
+      if (result.context) output.system.push(result.context);
+      // Failed tools may have no after callback. Deliver their pre-tool context
+      // at the next request instead of attaching it to another tool call.
+      const pending = before.get(sessionID);
+      if (pending?.size) {
+        for (const context of pending.values()) output.system.push(context);
+        pending.clear();
+      }
+    },
+    'tool.execute.before': async ({ tool, sessionID, callID }, output) => {
+      const result = await runHooks(config, input('tool.before', sessionID, {
+        tool: { name: tool, id: callID, input: output.args },
+      }), pluginRoot);
+      if (result.context) pendingFor(sessionID).set(callID, result.context);
+    },
+    'tool.execute.after': async ({ tool, sessionID, callID, args }, output) => {
+      const result = await runHooks(config, input('tool.after', sessionID, {
+        tool: {
+          name: tool, id: callID, input: args,
+          output: typeof output.output === 'string' ? output.output : output.content,
+          ...(typeof output.isError === 'boolean' ? { isError: output.isError } : {}),
+        },
+      }), pluginRoot);
+      const pending = before.get(sessionID);
+      const context = [pending?.get(callID), result.context].filter(Boolean).join('\\n\\n');
+      if (!context) return;
+      // Built-in tools and the MCP path pass different native result shapes.
+      if (typeof output.output === 'string') output.output += '\\n\\n' + context;
+      else if (Array.isArray(output.content)) output.content = [...output.content, { type: 'text', text: context }];
+      else throw new Error('plugnz hooks: unsupported OpenCode tool result shape; context was not delivered');
+      pending?.delete(callID);
+    },
+    event: async ({ event }) => {
+      const sessionId = event.properties?.sessionID ?? event.properties?.info?.id;
+      if (!sessionId) return;
+      if (event.type === 'session.deleted') {
+        starts.delete(sessionId);
+        before.delete(sessionId);
+        active.delete(sessionId);
+        return;
+      }
+      if (event.type === 'session.status' && event.properties.status?.type === 'busy') active.add(sessionId);
+      if (event.type !== 'session.idle' || !active.delete(sessionId)) return;
+      try {
+        const result = await runHooks(config, input('turn.stop', sessionId, { stop: { active: false } }), pluginRoot);
+        if (result.context || result.continue) {
+          throw new Error('OpenCode session.idle cannot deliver stop feedback or continue a turn; return {} from this check');
+        }
+      } catch (error) {
+        // The native event dispatcher does not await this callback.
+        // Catch explicitly to report failures without an unhandled rejection.
+        report(error);
+      }
+    },
+  };
+}
+`
+      };
+    }
+  };
+});
+
+// src/hosts/zcode-cli-hooks.ts
+function prepareHookPlugin3(stagingRoot) {
+  prepareCommandHookManifest(stagingRoot, ".zcode-plugin/plugin.json", false);
+}
+var adapter3, hookAdapter6;
+var init_zcode_cli_hooks = __esm(() => {
+  init_command_hooks();
+  init_command_hook_manifest();
+  adapter3 = commandHookAdapter({
+    id: "zcode-cli",
+    baselineVersion: "0.16.9",
+    nativeEvents: {
+      "session.start": ["SessionStart"],
+      "tool.before": ["PreToolUse"],
+      "tool.after": ["PostToolUse", "PostToolUseFailure"],
+      "turn.stop": ["Stop"]
+    },
+    contextDelivery: "startup user context; pre/post context appended to native tool result",
+    stopOutputSource: "{ continue: true, hookSpecificOutput: { hookEventName: 'Stop', additionalContext: result.context } }"
+  });
+  hookAdapter6 = { ...adapter3, prepare: prepareHookPlugin3 };
+});
+
+// src/hook-build.ts
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { cpSync as cpSync14, existsSync as existsSync31, lstatSync as lstatSync24, mkdirSync as mkdirSync16, mkdtempSync as mkdtempSync15, readFileSync as readFileSync33, readdirSync as readdirSync24, realpathSync as realpathSync7, renameSync as renameSync14, rmSync as rmSync17, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname20, isAbsolute as isAbsolute14, join as join41, relative as relative10, resolve as resolve27 } from "node:path";
+import { fileURLToPath } from "node:url";
+function hookRuntimeSource() {
+  const moduleDir = dirname20(fileURLToPath(import.meta.url));
+  const source = join41(moduleDir, "hooks.ts");
+  if (existsSync31(source) && process.versions["bun"]) {
+    if (developmentRuntime !== undefined)
+      return developmentRuntime;
+    const built = spawnSync6(process.execPath, ["build", source, "--target=node", "--format=esm"], {
+      encoding: "buffer",
+      timeout: 60000,
+      killSignal: "SIGKILL",
+      maxBuffer: 4 * 1024 * 1024
+    });
+    const output = new TextDecoder().decode(built.stdout);
+    if (built.status !== 0 || !output.trim()) {
+      throw new Error("Cannot bundle hook runtime: " + new TextDecoder().decode(built.stderr).trim());
+    }
+    developmentRuntime = output;
+    return output;
+  }
+  for (const path of [join41(moduleDir, RUNTIME_FILE), join41(moduleDir, "..", "dist", RUNTIME_FILE)]) {
+    if (existsSync31(path))
+      return readFileSync33(path, "utf8");
+  }
+  throw new Error("Hook runtime is missing from the distribution; rebuild with bun run build");
+}
+function entryExists(path) {
+  try {
+    lstatSync24(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function artifactPath(root, path) {
+  if (!path || isAbsolute14(path) || path.includes("\\") || path.includes("\x00") || path.split("/").some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error("Unsafe generated hook artifact path: " + path);
+  }
+  const file = join41(root, path);
+  let current = root;
+  for (const part of path.split("/").slice(0, -1)) {
+    current = join41(current, part);
+    if (entryExists(current) && (lstatSync24(current).isSymbolicLink() || !lstatSync24(current).isDirectory())) {
+      throw new Error("Generated hook artifact parent is not an owned directory: " + current);
+    }
+  }
+  return file;
+}
+function emitHooksToDirectory(adapter, configValue, stagingRoot) {
+  const config = validateHookConfig(configValue);
+  const root = resolve27(stagingRoot);
+  if (!existsSync31(root) || lstatSync24(root).isSymbolicLink() || !lstatSync24(root).isDirectory())
+    throw new Error("Hook staging root must be a directory");
+  adapter.prepare?.(root);
+  const artifacts = adapter.emit(config);
+  if (Object.prototype.hasOwnProperty.call(artifacts, RUNTIME_FILE))
+    throw new Error("Adapter cannot replace the shared hook runtime");
+  artifacts[RUNTIME_FILE] = hookRuntimeSource();
+  const paths = Object.keys(artifacts).sort();
+  for (const path of paths) {
+    if (typeof artifacts[path] !== "string")
+      throw new Error("Generated hook artifact must be text: " + path);
+    const file = artifactPath(root, path);
+    if (entryExists(file))
+      throw new Error("Refusing to overwrite authored hook artifact: " + file);
+    if (paths.some((other) => other !== path && other.startsWith(path + "/")))
+      throw new Error("Generated hook file conflicts with a directory: " + path);
+  }
+  for (const path of paths) {
+    const file = artifactPath(root, path);
+    mkdirSync16(dirname20(file), { recursive: true });
+    writeFileSync16(file, artifacts[path]);
+  }
+  return paths;
+}
+function copyAuthoredTree(source, destination, top = true) {
+  mkdirSync16(destination, { recursive: true });
+  for (const name of readdirSync24(source).sort()) {
+    if (name === ".git" || top && name === HOOK_CONFIG_FILE)
+      continue;
+    const from = join41(source, name);
+    const to = join41(destination, name);
+    const stat = lstatSync24(from);
+    if (stat.isSymbolicLink())
+      throw new Error("Hook source symlinks are unsupported: " + from);
+    if (stat.isDirectory())
+      copyAuthoredTree(from, to, false);
+    else if (stat.isFile())
+      cpSync14(from, to);
+    else
+      throw new Error("Hook source contains a non-file resource: " + from);
+  }
+}
+function prospectivePath(path) {
+  const suffix = [];
+  let parent = resolve27(path);
+  while (!existsSync31(parent)) {
+    const next = dirname20(parent);
+    if (next === parent)
+      throw new Error("Cannot resolve output ancestor: " + path);
+    suffix.unshift(relative10(next, parent));
+    parent = next;
+  }
+  return join41(realpathSync7(parent), ...suffix);
+}
+function buildHooks(pluginDir, targets, outputDir) {
+  const requestedSource = resolve27(pluginDir);
+  if (!existsSync31(requestedSource) || lstatSync24(requestedSource).isSymbolicLink() || !lstatSync24(requestedSource).isDirectory()) {
+    throw new Error("Hook source must be a directory: " + requestedSource);
+  }
+  const source = realpathSync7(requestedSource);
+  const config = readHookConfig(source);
+  if (config === undefined)
+    throw new Error("Hook source requires " + HOOK_CONFIG_FILE);
+  if (targets.length === 0)
+    throw new Error("hooks build requires at least one --target");
+  if (new Set(targets).size !== targets.length)
+    throw new Error("Duplicate hook target");
+  const adapters = targets.map((id) => {
+    const adapter = hookAdapters.find((item) => item.id === id);
+    if (adapter === undefined)
+      throw new Error("Unknown hook target: " + id);
+    if (!/^[a-z0-9][a-z0-9-]*$/u.test(adapter.id))
+      throw new Error("Unsafe hook target id");
+    return adapter;
+  });
+  const output = resolve27(outputDir);
+  const physicalOutput = prospectivePath(output);
+  if (physicalOutput === source || physicalOutput.startsWith(source + "/"))
+    throw new Error("Hook output must be outside the plugin source");
+  if (entryExists(output) && (lstatSync24(output).isSymbolicLink() || !lstatSync24(output).isDirectory() || readdirSync24(output).length !== 0)) {
+    throw new Error("Hook output must be absent or an empty directory: " + output);
+  }
+  mkdirSync16(dirname20(output), { recursive: true });
+  const stage = mkdtempSync15(join41(dirname20(output), ".plugnz-hooks-build-"));
+  try {
+    const built = [];
+    for (const adapter of adapters) {
+      const target = join41(stage, adapter.id);
+      copyAuthoredTree(source, target);
+      const files = emitHooksToDirectory(adapter, config, target);
+      built.push({ id: adapter.id, path: join41(output, adapter.id), files });
+    }
+    renameSync14(stage, output);
+    return { version: 1, outputDir: output, targets: built };
+  } finally {
+    rmSync17(stage, { recursive: true, force: true });
+  }
+}
+var hookAdapters, RUNTIME_FILE = "hook-runtime.mjs", developmentRuntime;
+var init_hook_build = __esm(() => {
+  init_hooks();
+  init_claude_code_hooks();
+  init_codex_hooks();
+  init_omp_hooks();
+  init_pi_hooks();
+  init_opencode_hooks();
+  init_zcode_cli_hooks();
+  hookAdapters = [hookAdapter, hookAdapter2, hookAdapter3, hookAdapter4, hookAdapter5, hookAdapter6];
+});
+
+// src/hook-cli.ts
+function runHookCli(args) {
+  try {
+    const verb = args[0];
+    if (verb === "--help" || verb === "-h" || verb === "help") {
+      console.log(USAGE);
+      return 0;
+    }
+    if (verb === "targets") {
+      if (args.length !== 1)
+        throw new Error("targets takes no arguments");
+      console.log(JSON.stringify({
+        version: 1,
+        targets: hookAdapters.map(({ id, baselineVersion, capabilities }) => ({ id, baselineVersion, capabilities }))
+      }, null, 2));
+      return 0;
+    }
+    if (verb !== "build")
+      throw new Error(USAGE);
+    let source;
+    let output;
+    const targets = [];
+    for (let index = 1;index < args.length; index++) {
+      const argument = args[index];
+      if (argument === "--target" || argument === "--out") {
+        const value = args[++index];
+        if (value === undefined || !value.trim() || value.startsWith("-"))
+          throw new Error(argument + " requires a value");
+        if (argument === "--target")
+          targets.push(value);
+        else {
+          if (output !== undefined)
+            throw new Error("--out accepts one directory");
+          output = value;
+        }
+      } else if (argument.startsWith("-"))
+        throw new Error("Unknown hooks build option: " + argument);
+      else {
+        if (source !== undefined)
+          throw new Error("hooks build accepts one plugin directory");
+        source = argument;
+      }
+    }
+    if (source === undefined || !source.trim())
+      throw new Error("hooks build requires a plugin directory");
+    if (output === undefined)
+      throw new Error("hooks build requires --out");
+    console.log(JSON.stringify(buildHooks(source, targets, output), null, 2));
+    return 0;
+  } catch (error) {
+    console.error("plugnz hooks: " + (error instanceof Error ? error.message : String(error)));
+    return 2;
+  }
+}
+var USAGE;
+var init_hook_cli = __esm(() => {
+  init_hook_build();
+  USAGE = [
+    "usage: plugnz hooks build <plugin-dir> --target <id>... --out <output-dir>",
+    "       plugnz hooks targets",
+    "",
+    "Builds one native artifact directory at <output-dir>/<target>.",
+    "The source must contain plugnz.hooks.json; source files are not changed.",
+    "The output must be absent or empty and outside the source directory.",
+    "Targets and build results are printed as JSON."
+  ].join(`
+`);
+});
+
 // src/cli.ts
-import { readFileSync as readFileSync31 } from "node:fs";
+import { readFileSync as readFileSync34 } from "node:fs";
 
 // src/hosts/claude-code.ts
 import { accessSync as accessSync2, constants as constants2, existsSync as existsSync2, statSync as statSync2 } from "node:fs";
@@ -14126,6 +14945,9 @@ class SemanticInventoryError extends Error {
 }
 function inventoryPackageSemantics(plugin) {
   const files = walkFiles(plugin.dir);
+  if (files.includes("plugnz.hooks.json")) {
+    invalid5("Portable hooks must be compiled before installation: use plugnz hooks build <source> --target <host> --out <directory>, then load the generated native package. add/sync do not execute an uncompiled plugnz.hooks.json.");
+  }
   const skills = files.filter((path) => path.startsWith("skills/") && path.endsWith("/SKILL.md"));
   const componentInventory = inventoryComponentRoots(plugin.dir);
   const commands = componentInventory.definitions.filter(({ kind }) => kind === "command").map(({ path }) => path).sort();
@@ -32462,7 +33284,7 @@ function legacyCommandAction(command) {
 // package.json
 var package_default = {
   name: "plugnz",
-  version: "0.0.15",
+  version: "0.0.16",
   description: "Install, diagnose and update agent plugins (Agent Plugins spec) and MCP configs across Claude Code, Codex, Cursor, Kimi and more",
   license: "MIT",
   type: "module",
@@ -32496,7 +33318,7 @@ var package_default = {
 };
 
 // src/cli.ts
-var USAGE = `plugnz — install, diagnose and update agent plugins and MCP configs
+var USAGE2 = `plugnz — install, diagnose and update agent plugins and MCP configs
 
 usage: plugnz <verb> [options]
 
@@ -32515,6 +33337,8 @@ verbs:
   retire-source <source-or-scope>   end one recorded scope [--target <host>] [--instance <id>] [--dry-run]
   scopes [source-or-scope]          read recorded scopes [--target <host>] [--instance <id>] [--json]
   targets [--all]                   list detected agent hosts; --all includes frozen consumer profiles
+  hooks build <dir> --target <id>... --out <dir>  compile portable hooks into native artifacts
+  hooks targets                    print portable hook capabilities as JSON
 
 mutation output:
   --json                            schema-v1 lifecycle report
@@ -33695,7 +34519,7 @@ async function runSync(argv, json) {
 async function runSyncManifest(manifestPath, dryRun, json) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync31(manifestPath, "utf8"));
+    parsed = JSON.parse(readFileSync34(manifestPath, "utf8"));
   } catch (error) {
     return emitValidatedReport(usageReport("sync", dryRun, unknownErrorDiagnostic(error)), json);
   }
@@ -33848,9 +34672,13 @@ async function main(argv) {
     return 0;
   }
   if (verb === undefined || verb === "help" || verb === "--help" || verb === "-h") {
-    console.log(USAGE);
+    console.log(USAGE2);
     return verb === undefined ? 2 : 0;
   }
+  if (verb === "hooks") {
+    await Promise.resolve().then(() => init_hook_cli());
+    return runHookCli(args.slice(1));
+  }
   if (verb === "doctor") {
     const flags = parseFlags(args.slice(1));
     if (rejectDisallowed(flags, new Set(["target"])) || flags.positionals.length > 0)
@@ -34525,7 +35353,7 @@ async function main(argv) {
     return runScopes(args.slice(1), wantsJson);
   fail4(`plugnz: unknown verb '${verb}'
 
-${USAGE}`, 2);
+${USAGE2}`, 2);
 }
 if (process.argv[1] !== undefined && process.argv[1].endsWith("cli.ts")) {
   main(process.argv.slice(2)).then((code) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugnz",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "Install, diagnose and update agent plugins (Agent Plugins spec) and MCP configs across Claude Code, Codex, Cursor, Kimi and more",
   "license": "MIT",
   "type": "module",