@hasna/skills 0.9.13 → 0.9.15

package/dist/sdk/index.js

@@ -31310,17 +31310,17 @@ class JsonEventsStore {
   }
   async appendEvent(event) {
     await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    events.push(event);
-    await this.writeJson(this.eventsPath, events);
+    const events2 = await this.readJson(this.eventsPath, []);
+    events2.push(event);
+    await this.writeJson(this.eventsPath, events2);
     return event;
   }
   async appendEventOnce(event, options = {}) {
     await this.init();
-    const events = await this.readJson(this.eventsPath, []);
+    const events2 = await this.readJson(this.eventsPath, []);
     const dedupe = options.dedupe !== false;
     if (dedupe) {
-      const existing = findEventByIdentity(events, { id: event.id, dedupeKey: event.dedupeKey });
+      const existing = findEventByIdentity(events2, { id: event.id, dedupeKey: event.dedupeKey });
       if (existing) {
         return {
           event: existing,
@@ -31330,8 +31330,8 @@ class JsonEventsStore {
         };
       }
     }
-    events.push(event);
-    await this.writeJson(this.eventsPath, events);
+    events2.push(event);
+    await this.writeJson(this.eventsPath, events2);
     return {
       event,
       stored: true,
@@ -31341,13 +31341,13 @@ class JsonEventsStore {
   }
   async listEvents(options = {}) {
     await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    return queryEvents(events, options);
+    const events2 = await this.readJson(this.eventsPath, []);
+    return queryEvents(events2, options);
   }
   async listEventsPage(options = {}) {
     await this.init();
-    const events = await this.readJson(this.eventsPath, []);
-    const queried = queryEvents(events, {
+    const events2 = await this.readJson(this.eventsPath, []);
+    const queried = queryEvents(events2, {
       eventId: options.eventId,
       source: options.source,
       type: options.type
@@ -31365,8 +31365,8 @@ class JsonEventsStore {
     };
   }
   async findEventByIdentity(identity3) {
-    const events = await this.listEvents();
-    return findEventByIdentity(events, identity3);
+    const events2 = await this.listEvents();
+    return findEventByIdentity(events2, identity3);
   }
   async appendDelivery(result) {
     await this.init();
@@ -31471,8 +31471,8 @@ function normalizeEventPageLimit(limit) {
     throw new Error(`Event page limit must be a positive integer, got ${limit}`);
   return Math.min(limit, MAX_EVENT_PAGE_LIMIT);
 }
-function queryEvents(events, options) {
-  let rows = events;
+function queryEvents(events2, options) {
+  let rows = events2;
   if (options.eventId)
     rows = rows.filter((event) => event.id === options.eventId);
   if (options.source)
@@ -31491,8 +31491,8 @@ function assertCursorFilter(name, cursorValue, optionValue) {
   if (cursorValue !== optionValue)
     throw new Error(`Local JSON event cursor ${name} filter mismatch`);
 }
-function findEventByIdentity(events, identity3) {
-  return events.find((event) => identity3.id !== undefined && event.id === identity3.id || identity3.dedupeKey !== undefined && event.dedupeKey === identity3.dedupeKey);
+function findEventByIdentity(events2, identity3) {
+  return events2.find((event) => identity3.id !== undefined && event.id === identity3.id || identity3.dedupeKey !== undefined && event.dedupeKey === identity3.dedupeKey);
 }
 function buildSignatureBase(timestamp, body4) {
   return `${timestamp}.${body4}`;
@@ -32125,16 +32125,16 @@ class EventsClient {
   async listEventsPage(options = {}) {
     if (this.store.listEventsPage)
       return this.store.listEventsPage(options);
-    const events = queryClientEvents(await this.store.listEvents(), {
+    const events2 = queryClientEvents(await this.store.listEvents(), {
       eventId: options.eventId,
       source: options.source,
       type: options.type
     });
     const offset = decodeLocalJsonEventCursor(options.cursor, options);
     const limit = normalizeEventPageLimit(options.limit);
-    const pageEvents = events.slice(offset, offset + limit);
+    const pageEvents = events2.slice(offset, offset + limit);
     const nextOffset = offset + pageEvents.length;
-    const hasMore = nextOffset < events.length;
+    const hasMore = nextOffset < events2.length;
     return {
       events: pageEvents,
       cursor: options.cursor,
@@ -32265,8 +32265,8 @@ class EventsClient {
     return createDeliveryResult(event, channel, attempts);
   }
 }
-function queryClientEvents(events, options) {
-  let rows = events;
+function queryClientEvents(events2, options) {
+  let rows = events2;
   if (options.eventId)
     rows = rows.filter((event) => event.id === options.eventId);
   if (options.source)
@@ -32373,7 +32373,7 @@ var init_event_sink = __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: {
@@ -40126,32 +40126,37 @@ function canonical3(value) {
     return { kind: "array", items: value.items.map(canonical3) };
   return value;
 }
-function assertClaudeStopHookReplacement(before, replacement) {
+var CLAUDE_COORDINATED_HOOK_EVENTS = ["PreToolUse", "PostToolUse", "Stop", "Notification", "SessionStart", "SessionEnd", "UserPromptSubmit", "SubagentStart"];
+function assertClaudeHookEventsReplacement(before, replacement, events) {
+  need3(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) {
-    need3(typeof text2 === "string" && Buffer.byteLength(text2) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, "Stop update exceeds its byte limit");
+    need3(typeof text2 === "string" && Buffer.byteLength(text2) <= CLAUDE_SETTINGS_WITNESS_LIMITS.bytes, `${label} update exceeds its byte limit`);
     return parse6(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) {
-      need3(hooks.kind === "object", "Stop update requires an object of hooks");
-      const stop = hooks.entries.find(([key]) => key === "Stop")?.[1];
-      need3(stop === undefined || stop.kind === "array", "Stop update requires a Stop array");
-      hooks.entries = hooks.entries.filter(([key]) => key !== "Stop");
+      need3(hooks.kind === "object", `${label} update requires an object of hooks`);
+      for (const event of events) {
+        const selected = hooks.entries.find(([key]) => key === event)?.[1];
+        need3(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 canonical3(value);
   }
-  need3(JSON.stringify(withoutStop(original)) === JSON.stringify(withoutStop(next)), "Stop update changed settings outside hooks.Stop");
+  need3(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") {
     need3(child.kind === "literal" && (child.value === "true" || child.value === "false"), "contains an invalid dialog acknowledgment");
-    return true;
+    return false;
   }
   if (key === "effortLevel") {
     need3(child.kind === "string" && PERSISTED_EFFORT_LEVELS.has(child.value), "contains an invalid persisted effort level");
@@ -40262,14 +40267,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 sha = (text2) => createHash14("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 === 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")
@@ -41301,6 +41312,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 canonical4 = (value) => canonicalAgentPath(value, aliases);
+  const containsSettings = (root2) => {
+    const distance = relative3(canonical4(root2), path);
+    return distance === "" || distance !== ".." && !distance.startsWith(`..${sep4}`) && !isAbsolute15(distance);
+  };
+  return discoveries.filter((binding) => binding.agent === "claude" || binding.agent === "opencode" || canonical4(join21(home, AGENT_ADAPTERS[binding.agent].config)) === path || binding.sources.some((source) => canonical4(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 = resolve14(options.home ?? homedir3()), dataDir2 = options.dataDir ?? getDataDirReadOnly();
   const policyPath = join21(dataDir2, "agent-policy.json");
   assertSafePath(policyPath);
@@ -41318,31 +41357,42 @@ function planClaudeStopHookUpdate(options) {
   const before = lstatSync18(path, { throwIfNoEntry: false }) ? new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(readNativeBytes(path, 1024 * 1024)) : null;
   if ((before === null ? "absent" : sha2(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: snapshot2.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,
@@ -41353,7 +41403,7 @@ function planClaudeStopHookUpdate(options) {
     discoveryBefore: discoveries,
     discoveryAfter,
     rootAliases: aliases,
-    managedAgentChecks: { home, agents: [...agents] }
+    managedAgentChecks: { home, agents: consumers }
   };
 }
 function atomicWrite2(path, content) {
@@ -41380,8 +41430,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)
@@ -41413,8 +41467,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(join21(backupRoot, "receipt.json"), JSON.stringify({ version: 1, changes: written.map((change) => ({ path: change.path, beforeHash: change.before === null ? null : sha2(change.before), afterHash: sha2(change.after) })), backups, ...aliases.length ? { rootAliases: aliases } : {} }) + `

package/docs/plugin-admission.md

@@ -294,9 +294,11 @@ addition to the v1 display/model selections, it tolerates the documented
 persisted effort values `low`, `medium`, `high`, and `xhigh`, both at the top
 level and in known built-in model entries whose only property is `effortLevel`.
 Custom model entries and entries with any other property remain fully bound.
-The boolean `skipDangerousModePermissionPrompt` is Claude's saved dialog
-acknowledgment; it does not select a permission mode. Permission settings,
-plugins, hooks, environment, ultracode and unknown configuration remain bound.
+The boolean `skipDangerousModePermissionPrompt` remains bound: Claude also uses
+this saved acceptance in bypass-mode and pending project MCP approval decisions.
+Permission settings, plugins, hooks, environment, ultracode and unknown
+configuration remain bound. Version 0.9.14 corrects the 0.9.13 normalization of
+this flag; an existing v2 review containing it must be explicitly reviewed again.
 Invalid recognized preference types are refused.
 
 `captureClaudeMarketplaceRegistryV2(path)` creates a
@@ -322,3 +324,25 @@ preference: its owning installer must coordinate a guarded settings/policy
 update, or it needs a fresh explicit review.
 
 The effort schema follows [Claude's model configuration documentation](https://code.claude.com/docs/en/model-config#adjust-effort-level).
+
+Cooperating installers can use `planClaudeHookEventsUpdate` with an explicit
+selection of supported Claude hook events. `planClaudePreToolUseHookUpdate` and
+`planClaudeStopHookUpdate` are single-event convenience wrappers. Supported events
+are `PreToolUse`, `PostToolUse`, `Stop`, `Notification`, `SessionStart`, `SessionEnd`
+`UserPromptSubmit` and `SubagentStart`. The transaction requires the exact settings SHA-256
+preimage and preserves every field outside the selected events, including other
+hooks. Apply the returned plan through `applyAgentIntegration`; this validates
+existing managed discovery and native guards, writes settings and policy with
+precondition checks, and retains recovery backups. An invalid policy or existing
+drift is a refusal, never permission to use an uncoordinated writer. A null plan
+means no managed Skills policy exists. These APIs do not authorize the hook's
+behavior or turn a configuration-changing hook into a preference.
+
+The transaction verifies every agent's discovery sources, directories and
+automatic discovery closure. Native runtime and trust checks cover Claude and
+the declared consumers of the settings path, including containing roots or
+directories and OpenCode's Claude compatibility surface. Unrelated agents keep
+their exact witnesses and trust state; they must still pass their own consumer
+checks before use. The plan's `managedAgentChecks.agents` and `nativeSkills`
+describe this scoped runtime check, not a fleet health result. A path-identity
+witness intersecting the write still refuses instead of adopting a new inode.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/skills",
-  "version": "0.9.13",
+  "version": "0.9.15",
   "description": "Skills library for AI coding agents",
   "type": "module",
   "bin": {