@hasna/skills 0.9.13 → 0.9.15

package/bin/mcp.js

@@ -20019,7 +20019,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@hasna/skills",
-    version: "0.9.13",
+    version: "0.9.15",
     description: "Skills library for AI coding agents",
     type: "module",
     bin: {
@@ -47083,7 +47083,7 @@ function canonical2(value) {
 function inferencePreference(key, child) {
   if (key === "skipDangerousModePermissionPrompt") {
     need2(child.kind === "literal" && (child.value === "true" || child.value === "false"), "contains an invalid dialog acknowledgment");
-    return true;
+    return false;
   }
   if (key === "effortLevel") {
     need2(child.kind === "string" && PERSISTED_EFFORT_LEVELS.has(child.value), "contains an invalid persisted effort level");
@@ -48796,13 +48796,24 @@ var init_codex_hook_trust_files = () => {};
 // src/lib/codex-hook-trust-layout.ts
 var init_codex_hook_trust_layout = () => {};
 
+// src/lib/codex-hook-additions-review.ts
+var events, matchedEvents, proofs;
+var init_codex_hook_additions_review = __esm(() => {
+  init_codex_hook_trust_files();
+  init_codex_hook_trust_layout();
+  events = { UserPromptSubmit: ["userPromptSubmit", "user_prompt_submit"], SessionStart: ["sessionStart", "session_start"], SubagentStart: ["subagentStart", "subagent_start"] };
+  matchedEvents = { ...events, PreToolUse: ["preToolUse", "pre_tool_use"] };
+  proofs = new WeakMap;
+});
+
 // src/lib/codex-hook-discovery-recovery.ts
 import { createHash as createHash13 } from "crypto";
 function assertCodexHookDiscoveryRecovery(binding, witness) {
-  const proof = proofs.get(witness);
+  const proof = proofs2.get(witness);
   need4(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   unchanged2(proof.before);
   unchanged2(proof.current);
+  proof.recheckAdditions();
 }
 function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witness) {
   if (!witness || source.path !== witness.configPath || source.hashMode !== "bytes")
@@ -48811,11 +48822,12 @@ function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witnes
   need4(source.sha256 === witness.beforeSha256 && currentDigest === witness.currentSha256, "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   return true;
 }
-var sha = (text2) => createHash13("sha256").update(text2).digest("hex"), proofs;
+var sha = (text2) => createHash13("sha256").update(text2).digest("hex"), proofs2;
 var init_codex_hook_discovery_recovery = __esm(() => {
   init_codex_hook_trust_files();
   init_codex_hook_trust_layout();
-  proofs = new WeakMap;
+  init_codex_hook_additions_review();
+  proofs2 = new WeakMap;
 });
 
 // src/lib/agent-discovery.ts
@@ -59783,17 +59795,17 @@ var WSContext = class {
     if (typeof args[0] === "function") {
       const [createEvents, options] = args;
       return async function upgradeWebSocket(c, next) {
-        const events = await createEvents(c);
-        const result = await handler(c, events, options);
+        const events2 = await createEvents(c);
+        const result = await handler(c, events2, options);
         if (result) {
           return result;
         }
         await next();
       };
     } else {
-      const [c, events, options] = args;
+      const [c, events2, options] = args;
       return (async () => {
-        const upgraded = await handler(c, events, options);
+        const upgraded = await handler(c, events2, options);
         if (!upgraded) {
           throw new Error("Failed to upgrade WebSocket");
         }
@@ -60990,7 +61002,7 @@ var init_dist2 = __esm(() => {
     "sec-websocket-extensions",
     "sec-websocket-protocol"
   ]);
-  upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
+  upgradeWebSocket = defineWebSocketHelper(async (c, events2, options) => {
     if (c.req.header("upgrade")?.toLowerCase() !== "websocket")
       return;
     const env = c.env;
@@ -61027,7 +61039,7 @@ var init_dist2 = __esm(() => {
         url: new URL(c.req.url)
       };
       try {
-        events?.onOpen?.(new Event("open"), ctx);
+        events2?.onOpen?.(new Event("open"), ctx);
       } catch (e2) {
         (options?.onError ?? console.error)(e2);
       }
@@ -61035,7 +61047,7 @@ var init_dist2 = __esm(() => {
         const datas = Array.isArray(data) ? data : [data];
         for (const data2 of datas)
           try {
-            events?.onMessage?.(new MessageEvent("message", { data: isBinary ? data2 instanceof ArrayBuffer ? data2 : data2.buffer.slice(data2.byteOffset, data2.byteOffset + data2.byteLength) : typeof data2 === "string" ? data2 : Buffer.from(data2).toString("utf-8") }), ctx);
+            events2?.onMessage?.(new MessageEvent("message", { data: isBinary ? data2 instanceof ArrayBuffer ? data2 : data2.buffer.slice(data2.byteOffset, data2.byteOffset + data2.byteLength) : typeof data2 === "string" ? data2 : Buffer.from(data2).toString("utf-8") }), ctx);
           } catch (e2) {
             (options?.onError ?? console.error)(e2);
           }
@@ -61048,7 +61060,7 @@ var init_dist2 = __esm(() => {
       });
       ws.on("close", (code2, reason) => {
         try {
-          events?.onClose?.(new CloseEvent("close", {
+          events2?.onClose?.(new CloseEvent("close", {
             code: code2,
             reason: reason.toString()
           }), ctx);
@@ -61058,7 +61070,7 @@ var init_dist2 = __esm(() => {
       });
       ws.on("error", (error61) => {
         try {
-          events?.onError?.(new ErrorEvent("error", { error: error61 }), ctx);
+          events2?.onError?.(new ErrorEvent("error", { error: error61 }), ctx);
         } catch (e2) {
           (options?.onError ?? console.error)(e2);
         }

package/bin/migrate.js

@@ -7,7 +7,7 @@ import { join as join5 } from "path";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.9.13",
+  version: "0.9.15",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {

package/bin/server.js

@@ -24122,7 +24122,7 @@ var init_dist_es9 = __esm(() => {
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.9.13",
+  version: "0.9.15",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {

package/bin/worker.js

@@ -24125,7 +24125,7 @@ import { randomUUID as randomUUID6 } from "crypto";
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.9.13",
+  version: "0.9.15",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {

package/dist/index.d.ts

@@ -60,7 +60,7 @@ export type { SkillSelection, SkillProfile, ResolvedSkillSelection, ResolvedSkil
 export { buildSkillContext } from "./lib/skill-context.js";
 export { syncSelectionProfile } from "./lib/selection-resolver.js";
 export { inspectSkillSession, reconcileSkillSession, type SessionReconciliationInput, type SessionReconciliationOptions } from "./lib/session-reconciliation.js";
-export { planAgentIntegration, planClaudeStopHookUpdate, applyAgentIntegration, inventoryNativeSkills, archiveNativeSkills } from "./lib/agent-integration.js";
+export { planAgentIntegration, planClaudeStopHookUpdate, planClaudePreToolUseHookUpdate, planClaudeHookEventsUpdate, applyAgentIntegration, inventoryNativeSkills, archiveNativeSkills } from "./lib/agent-integration.js";
 export { captureDiscoveryDirectories, captureDiscoveryByteSources, captureDiscoveryPathSources, type DiscoveryDirectory, type DiscoverySource } from "./lib/agent-discovery.js";
 export { captureClaudeMarketplaceRegistry, captureClaudeMarketplaceRegistryV2 } from "./lib/claude-marketplace-registry.js";
 export { captureClaudeSettings, captureClaudeSettingsV2 } from "./lib/claude-settings-witness.js";
@@ -69,3 +69,4 @@ export { planPluginAdmission, admitPlugin, resolveAdmittedPlugin, pluginResolver
 export { captureManagedPluginRegistry, type ManagedPluginRegistrationWitness } from "./lib/plugin-discovery.js";
 export type { RemoteCreditCheckoutOptions, RemoteCreditCheckout, RemoteCreditCheckoutErrorCode } from "./lib/remote-credit-checkout.js";
 export { assertPortableAuthoringPath, type PortableAuthoringPathOptions } from "./lib/authoring-path.js";
+export { CLAUDE_COORDINATED_HOOK_EVENTS, type ClaudeCoordinatedHookEvent } from "./lib/claude-settings-witness.js";

package/dist/index.js

@@ -9610,7 +9610,7 @@ import { isAbsolute as isAbsolute11, join as join23, resolve as resolve11 } from
 // package.json
 var package_default = {
   name: "@hasna/skills",
-  version: "0.9.13",
+  version: "0.9.15",
   description: "Skills library for AI coding agents",
   type: "module",
   bin: {
@@ -12846,32 +12846,37 @@ function canonical2(value) {
     return { kind: "array", items: value.items.map(canonical2) };
   return value;
 }
-function assertClaudeStopHookReplacement(before, replacement) {
+var CLAUDE_COORDINATED_HOOK_EVENTS = ["PreToolUse", "PostToolUse", "Stop", "Notification", "SessionStart", "SessionEnd", "UserPromptSubmit", "SubagentStart"];
+function assertClaudeHookEventsReplacement(before, replacement, events) {
+  need2(Array.isArray(events) && events.length > 0 && events.length <= CLAUDE_COORDINATED_HOOK_EVENTS.length && new Set(events).size === events.length && events.every((event) => CLAUDE_COORDINATED_HOOK_EVENTS.includes(event)), "requires explicit supported hook events");
+  const label = events.join(",");
   function bounded(text2) {
-    need2(typeof text2 === "string" && Buffer.byteLength(text2) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "Stop update exceeds its byte limit");
+    need2(typeof text2 === "string" && Buffer.byteLength(text2) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, `${label} update exceeds its byte limit`);
     return parse3(text2);
   }
   const original = bounded(before ?? "{}"), next = bounded(replacement);
   const hadHooks = original.entries.some(([key]) => key === "hooks");
-  function withoutStop(value) {
+  function withoutOwnedEvents(value) {
     const hooks = value.entries.find(([key]) => key === "hooks")?.[1];
     if (hooks !== undefined) {
-      need2(hooks.kind === "object", "Stop update requires an object of hooks");
-      const stop = hooks.entries.find(([key]) => key === "Stop")?.[1];
-      need2(stop === undefined || stop.kind === "array", "Stop update requires a Stop array");
-      hooks.entries = hooks.entries.filter(([key]) => key !== "Stop");
+      need2(hooks.kind === "object", `${label} update requires an object of hooks`);
+      for (const event of events) {
+        const selected = hooks.entries.find(([key]) => key === event)?.[1];
+        need2(selected === undefined || selected.kind === "array", `${event} update requires a ${event} array`);
+      }
+      hooks.entries = hooks.entries.filter(([key]) => !events.includes(key));
       if (!hadHooks && hooks.entries.length === 0)
         value.entries = value.entries.filter(([key]) => key !== "hooks");
     }
     return canonical2(value);
   }
-  need2(JSON.stringify(withoutStop(original)) === JSON.stringify(withoutStop(next)), "Stop update changed settings outside hooks.Stop");
+  need2(JSON.stringify(withoutOwnedEvents(original)) === JSON.stringify(withoutOwnedEvents(next)), `${label} update changed settings outside hooks.${label}`);
 }
 var PERSISTED_EFFORT_LEVELS = new Set(["low", "medium", "high", "xhigh"]);
 function inferencePreference(key, child) {
   if (key === "skipDangerousModePermissionPrompt") {
     need2(child.kind === "literal" && (child.value === "true" || child.value === "false"), "contains an invalid dialog acknowledgment");
-    return true;
+    return false;
   }
   if (key === "effortLevel") {
     need2(child.kind === "string" && PERSISTED_EFFORT_LEVELS.has(child.value), "contains an invalid persisted effort level");
@@ -13452,6 +13457,34 @@ function planAgentIntegration(options) {
   return { dataDir: dataDir2, profileId, changes, nativeSkills, observedPolicy: { path: policyPath, before: previousPolicy }, discoveryBefore: discoveries, discoveryAfter, ...aliases.length ? { rootAliases: aliases } : {} };
 }
 function planClaudeStopHookUpdate(options) {
+  return planClaudeHookEventsUpdate({ ...options, events: ["Stop"] });
+}
+function planClaudePreToolUseHookUpdate(options) {
+  return planClaudeHookEventsUpdate({ ...options, events: ["PreToolUse"] });
+}
+function claudeSettingsConsumers(home, path, discoveries, aliases) {
+  const canonical3 = (value) => canonicalAgentPath(value, aliases);
+  const containsSettings = (root) => {
+    const distance = relative4(canonical3(root), path);
+    return distance === "" || distance !== ".." && !distance.startsWith(`..${sep4}`) && !isAbsolute9(distance);
+  };
+  return discoveries.filter((binding) => binding.agent === "claude" || binding.agent === "opencode" || canonical3(join16(home, AGENT_ADAPTERS[binding.agent].config)) === path || binding.sources.some((source) => canonical3(source.path) === path) || binding.roots.some(containsSettings) || binding.directories?.some((directory) => containsSettings(directory.path))).map((binding) => binding.agent);
+}
+function verifyCoordinatedDiscovery(binding, home, aliases) {
+  try {
+    if (binding.method !== "automatic" && binding.method !== "reviewed")
+      throw new Error("Invalid managed discovery method");
+    verifyAgentDiscovery(binding);
+    if (binding.method === "automatic") {
+      const current = resolveAgentDiscovery({ home, agent: binding.agent, canonical: (path) => canonicalAgentPath(path, aliases) });
+      if (JSON.stringify(current) !== JSON.stringify(binding))
+        throw new Error("Configured native discovery roots changed during Claude update");
+    }
+  } catch (error) {
+    throw new Error(`NATIVE_SKILL_DRIFT: ${error.message}`);
+  }
+}
+function planClaudeHookEventsUpdate(options) {
   const home = resolve9(options.home ?? homedir2()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
   const policyPath = join16(dataDir2, "agent-policy.json");
   assertSafePath(policyPath);
@@ -13469,31 +13502,42 @@ function planClaudeStopHookUpdate(options) {
   const before = lstatSync14(path, { throwIfNoEntry: false }) ? new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(readNativeBytes(path, 1024 * 1024)) : null;
   if ((before === null ? "absent" : sha(before)) !== options.expectedSettingsSha256)
     throw new Error("Claude settings preimage changed");
-  assertClaudeStopHookReplacement(before, options.replacement);
+  assertClaudeHookEventsReplacement(before, options.replacement, options.events);
   const agents = bridge.agents;
   const discoveries = Object.entries(bridge.discovery).map(([agent, binding]) => {
-    if (!agents.includes(agent) || binding?.agent !== agent)
-      throw new Error("Invalid managed discovery owner");
+    if (!agents.includes(agent) || binding?.agent !== agent || typeof bridge.commands?.[agent] !== "string" || typeof bridge.profiles?.[agent] !== "string")
+      throw new Error("Invalid managed discovery owner or command/profile binding");
     return binding;
   });
-  if (discoveries.length !== agents.length)
-    throw new Error("Missing managed discovery coverage");
-  for (const agent of agents)
+  if (discoveries.length !== agents.length || !agents.includes("claude"))
+    throw new Error("Missing managed Claude discovery coverage");
+  for (const binding of discoveries)
+    verifyCoordinatedDiscovery(binding, home, aliases);
+  const consumers = claudeSettingsConsumers(home, path, discoveries, aliases);
+  for (const agent of consumers)
     assertManagedAgentBridge(agent, { home, dataDir: dataDir2, projectDir: home });
   const replacements = new Map(before === options.replacement ? [] : [[path, options.replacement]]);
-  const discoveryAfter = discoveries.map((binding) => rebindAgentDiscovery(binding, replacements));
+  const discoveryAfter = discoveries.map((binding) => {
+    const next = rebindAgentDiscovery(binding, replacements);
+    for (const [index, source] of binding.sources.entries()) {
+      if (source.path !== path && JSON.stringify(next.sources[index]) !== JSON.stringify(source)) {
+        throw new Error(`Unrelated native discovery input changed during Claude update: ${source.path}`);
+      }
+    }
+    return JSON.stringify(next) === JSON.stringify(binding) ? binding : next;
+  });
   const nextPolicy = { ...policy, bridge: { ...bridge, discovery: Object.fromEntries(discoveryAfter.map((binding) => [binding.agent, binding])) } };
   const changes = before === options.replacement ? [] : [{ path, before, after: options.replacement }];
   if (JSON.stringify(nextPolicy) !== JSON.stringify(policy))
     changes.push({ path: policyPath, before: snapshot.text, after: serializeManagedSkillPolicy(nextPolicy) });
   recheckRootAliases(aliases);
   const nativeSkills = inventoryNativeSkills(home, {
-    agents,
+    agents: consumers,
     projectDir: home,
     includeVendor: true,
-    guardHermes: agents.includes("hermes"),
+    guardHermes: consumers.includes("hermes"),
     allowRootAliases: aliases.length > 0,
-    agentRoots: discoveries.flatMap((binding) => binding.roots.map((path2) => ({ agent: binding.agent, path: path2 })))
+    agentRoots: discoveries.filter((binding) => consumers.includes(binding.agent)).flatMap((binding) => binding.roots.map((path2) => ({ agent: binding.agent, path: path2 })))
   });
   return {
     dataDir: dataDir2,
@@ -13504,7 +13548,7 @@ function planClaudeStopHookUpdate(options) {
     discoveryBefore: discoveries,
     discoveryAfter,
     rootAliases: aliases,
-    managedAgentChecks: { home, agents: [...agents] }
+    managedAgentChecks: { home, agents: consumers }
   };
 }
 function atomicWrite2(path, content) {
@@ -13531,8 +13575,12 @@ function applyAgentIntegration(plan) {
   recheckRootAliases(aliases);
   for (const agent of plan.managedAgentChecks?.agents ?? [])
     assertManagedAgentBridge(agent, { home: plan.managedAgentChecks.home, dataDir: plan.dataDir, projectDir: plan.managedAgentChecks.home });
-  for (const binding of plan.discoveryBefore ?? [])
-    verifyAgentDiscovery(binding);
+  for (const binding of plan.discoveryBefore ?? []) {
+    if (plan.managedAgentChecks)
+      verifyCoordinatedDiscovery(binding, plan.managedAgentChecks.home, aliases);
+    else
+      verifyAgentDiscovery(binding);
+  }
   if (plan.observedPolicy && currentText(plan.observedPolicy.path) !== plan.observedPolicy.before)
     throw new Error("Agent policy changed after planning");
   for (const change of plan.changes)
@@ -13564,8 +13612,12 @@ function applyAgentIntegration(plan) {
       written.push({ path: change.path, before: change.before, after });
     }
     recheckRootAliases(aliases);
-    for (const binding of plan.discoveryAfter ?? [])
-      verifyAgentDiscovery(binding);
+    for (const binding of plan.discoveryAfter ?? []) {
+      if (plan.managedAgentChecks)
+        verifyCoordinatedDiscovery(binding, plan.managedAgentChecks.home, aliases);
+      else
+        verifyAgentDiscovery(binding);
+    }
     for (const agent of plan.managedAgentChecks?.agents ?? [])
       assertManagedAgentBridge(agent, { home: plan.managedAgentChecks.home, dataDir: plan.dataDir, projectDir: plan.managedAgentChecks.home });
     atomicWrite2(join16(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha(change.before), afterHash: sha(change.after) })), backups, ...aliases.length ? { rootAliases: aliases } : {} }) + `
@@ -16387,14 +16439,20 @@ function unchanged2(before) {
   need4(sameStat(before.stat, after.stat) && after.sha256 === before.sha256, "INPUT_CHANGED");
 }
 
+// src/lib/codex-hook-additions-review.ts
+var events = { UserPromptSubmit: ["userPromptSubmit", "user_prompt_submit"], SessionStart: ["sessionStart", "session_start"], SubagentStart: ["subagentStart", "subagent_start"] };
+var matchedEvents = { ...events, PreToolUse: ["preToolUse", "pre_tool_use"] };
+var proofs = new WeakMap;
+
 // src/lib/codex-hook-discovery-recovery.ts
 var sha2 = (text2) => createHash15("sha256").update(text2).digest("hex");
-var proofs = new WeakMap;
+var proofs2 = new WeakMap;
 function assertCodexHookDiscoveryRecovery(binding, witness) {
-  const proof = proofs.get(witness);
+  const proof = proofs2.get(witness);
   need4(!!proof && binding.agent === "codex" && witness.discoverySha256 === sha2(JSON.stringify(binding)), "RECONCILE_DISCOVERY_RECOVERY_CHANGED");
   unchanged2(proof.before);
   unchanged2(proof.current);
+  proof.recheckAdditions();
 }
 function verifiesCodexHookDiscoverySource(binding, source, currentDigest, witness) {
   if (!witness || source.path !== witness.configPath || source.hashMode !== "bytes")
@@ -43658,6 +43716,8 @@ export {
   planSkillsS3SnapshotUpload,
   planPluginAdmission,
   planClaudeStopHookUpdate,
+  planClaudePreToolUseHookUpdate,
+  planClaudeHookEventsUpdate,
   planAgentIntegration,
   pinSkill,
   pinProjectSkill,
@@ -43861,6 +43921,7 @@ export {
   DEFAULT_EXPORT_DIR,
   ContentHashInputError,
   CONTENT_HASH_LIMITS,
+  CLAUDE_COORDINATED_HOOK_EVENTS,
   CATEGORIES,
   BASIC_SKILL_NAMES,
   ARTICLE_GENERATION_SLUG,

package/dist/lib/agent-codex-trust.d.ts

@@ -71,7 +71,8 @@ export declare function reconcileCodexNativeHooks(options: CodexNativeHookReconc
                 hooksPath: string;
                 hooksSha256: string;
             };
-            additions: any[];
+            additions: any;
+            version?: number | undefined;
         } | undefined;
         configDiscoveryRecovery?: import("./codex-hook-discovery-recovery.js").CodexHookDiscoveryRecovery | undefined;
         version: number;

package/dist/lib/agent-integration.d.ts

@@ -1,6 +1,7 @@
 import { type AgentDiscoveryBinding, type ReviewedDiscoveryInputs } from "./agent-discovery.js";
 import { type IntegrationAgent } from "./agent-adapters.js";
 import type { CodexHookDiscoveryRecovery } from "./codex-hook-discovery-recovery.js";
+import { type ClaudeCoordinatedHookEvent } from "./claude-settings-witness.js";
 export type { IntegrationAgent } from "./agent-adapters.js";
 export type ContextHookEvent = "UserPromptSubmit" | "SessionStart" | "SubagentStart";
 export interface AgentRootAlias {
@@ -96,11 +97,18 @@ export declare function planAgentIntegration(options: {
  * every other settings change and owns discovery witnesses and guarded writes.
  * No policy means this installer has no Skills integration to update.
  */
-export declare function planClaudeStopHookUpdate(options: {
+export interface ClaudeHookUpdateOptions {
     home?: string;
     dataDir?: string;
     expectedSettingsSha256: string;
     replacement: string;
+}
+export declare function planClaudeStopHookUpdate(options: ClaudeHookUpdateOptions): AgentIntegrationPlan | null;
+/** Cooperating safety installers may replace only PreToolUse. The caller owns
+ * its exact hook authorization; Skills retains discovery and native guards. */
+export declare function planClaudePreToolUseHookUpdate(options: ClaudeHookUpdateOptions): AgentIntegrationPlan | null;
+export declare function planClaudeHookEventsUpdate(options: ClaudeHookUpdateOptions & {
+    events: readonly ClaudeCoordinatedHookEvent[];
 }): AgentIntegrationPlan | null;
 export declare function applyAgentIntegration(plan: AgentIntegrationPlan): {
     changed: string[];

package/dist/lib/claude-settings-witness.d.ts

@@ -9,12 +9,16 @@ export declare const CLAUDE_SETTINGS_WITNESS_LIMITS: Readonly<{
 export interface ClaudeSettingsWitnessBudget {
     remaining: number;
 }
-/** Cooperating installers may replace Stop only. Compare the strict syntax
+/** Cooperating installers may replace only their explicitly selected event. Compare the strict syntax
  * trees, not JSON.parse values or the preference-tolerant witness digest: all
  * other hooks, discovery settings, unknown values and number spellings remain
  * identical. Whitespace and object-key order have no configuration meaning.
  */
+export declare const CLAUDE_COORDINATED_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "Stop", "Notification", "SessionStart", "SessionEnd", "UserPromptSubmit", "SubagentStart"];
+export type ClaudeCoordinatedHookEvent = typeof CLAUDE_COORDINATED_HOOK_EVENTS[number];
+export declare function assertClaudeHookEventsReplacement(before: string | null, replacement: string, events: readonly ClaudeCoordinatedHookEvent[]): void;
 export declare function assertClaudeStopHookReplacement(before: string | null, replacement: string): void;
+export declare function assertClaudePreToolUseHookReplacement(before: string | null, replacement: string): void;
 /** Hash only reviewed installer-rendered settings after the disk preimage has been verified. */
 export declare function hashClaudeSettingsReplacement(text: string, budget: ClaudeSettingsWitnessBudget): string;
 /** Explicit capture never converts a stored legacy raw witness or changes settings. */

package/dist/lib/codex-hook-additions-review.d.ts

@@ -4,6 +4,25 @@ export interface NativeHookAdditionsRecovery {
     path: string;
     reviewedPlanDigest?: string;
 }
+/** Internal capability, not a caller-supplied config override. */
+export interface ReviewedNativeHookAdditions {
+    readonly reviewSha256: string;
+}
+type JournalHook = {
+    key: string;
+    currentHash: string;
+};
+type TrustState = Readonly<{
+    trusted_hash: string;
+    enabled?: true;
+}>;
+type AddedTrustState = Readonly<{
+    key: string;
+    state: TrustState;
+}>;
+/** Rebind the proof to this exact journal transition and recheck every source.
+ * A serialized/cloned receipt can never create a discovery exception. */
+export declare function readReviewedAdditionTrustStates(proof: ReviewedNativeHookAdditions, before: Snapshot, current: Snapshot, journalHooks: JournalHook[]): readonly AddedTrustState[];
 /** An explicit, private review of a later producer's append-only hook change.
  * The producer backups must themselves describe exactly the completed journal
  * operation. Neither a claimed receipt nor a matching raw hash grants authority
@@ -25,6 +44,7 @@ export declare function reviewNativeHookAdditions(options: {
 }): {
     hooks: any[];
     recheck: () => void;
+    trustProof: ReviewedNativeHookAdditions;
     receipt: {
         reviewPath: string;
         reviewSha256: string;
@@ -36,7 +56,8 @@ export declare function reviewNativeHookAdditions(options: {
             hooksPath: string;
             hooksSha256: string;
         };
-        additions: any[];
+        additions: any;
+        version?: number | undefined;
     };
 };
 export {};

package/dist/lib/codex-hook-discovery-recovery.d.ts

@@ -1,5 +1,6 @@
 import type { AgentDiscoveryBinding, DiscoverySource } from "./agent-discovery.js";
 import { type snapshot } from "./codex-hook-trust-files.js";
+import { type ReviewedNativeHookAdditions } from "./codex-hook-additions-review.js";
 type Snapshot = ReturnType<typeof snapshot>;
 /** A receipt projection, not an override supplied by a CLI caller. Only this
  * module can create the in-memory proof used by discovery verification. */
@@ -17,7 +18,7 @@ export interface CodexHookDiscoveryRecovery {
 export declare function createCodexHookDiscoveryRecovery(binding: AgentDiscoveryBinding, before: Snapshot, current: Snapshot, hooks: Array<{
     key: string;
     currentHash: string;
-}>): CodexHookDiscoveryRecovery | undefined;
+}>, additions?: ReviewedNativeHookAdditions): CodexHookDiscoveryRecovery | undefined;
 export declare function assertCodexHookDiscoveryRecovery(binding: AgentDiscoveryBinding, witness: CodexHookDiscoveryRecovery): void;
 /** Verify this one historical byte witness using the already-validated native
  * transition. Every other source still uses its ordinary current-file hash. */