harnery 0.33.0 → 0.34.0

package/dist/core/hooks/adapter/wiring.js

@@ -11,7 +11,7 @@
  * — there's exactly one definition of the `agent-hook <subcommand>` match.
  */
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ADAPTER_SPECS, } from "./events.js";
 /** Build a hook entry in the adapter's shape. */
@@ -29,28 +29,73 @@ export function groupCommands(group) {
 }
 /**
  * Whether a hook command string wires the given agent-hook subcommand. The
- * trailing space is load-bearing: it keeps `stop` from matching `stop-failure`.
+ * token boundary keeps `stop` from matching `stop-failure`, while accepting a
+ * minimal command that ends immediately after the subcommand.
  */
 export function commandWiresSubcommand(command, subcommand) {
-    return command.includes(`agent-hook ${subcommand} `);
+    const escaped = subcommand.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:^|[\\/\\s])agent-hook\\s+${escaped}(?:\\s|$)`).test(command);
 }
 /** Pull the agent-hook subcommand out of a command string, or null if none. */
 function commandSubcommand(command) {
-    const m = command.match(/agent-hook\s+([a-z][a-z-]*)\s/);
+    const m = command.match(/(?:^|[/\s])agent-hook\s+([a-z][a-z-]*)(?:\s|$)/);
     return m ? m[1] : null;
 }
+/** Whether a command invokes Harnery's agent-hook binary at all. */
+export function isAgentHookCommand(command) {
+    return commandSubcommand(command) !== null;
+}
+/** The canonical command installed for one adapter event. */
+export function hookCommand(spec, agentHookPath, subcommand, adapter) {
+    if (agentHookPath === "agent-hook") {
+        return `agent-hook ${subcommand} --adapter ${adapter}`;
+    }
+    const anchor = spec.projectDirEnv ? `"\${${spec.projectDirEnv}:-.}"/` : "";
+    return `bash ${anchor}${agentHookPath} ${subcommand} --adapter ${adapter}`;
+}
+/**
+ * Pick a committed hook target that survives cloning the consumer elsewhere.
+ * Projects that contain Harnery can use its repo-relative launcher. Standalone
+ * consumers use the package's installed `agent-hook` executable from PATH
+ * instead of recording a relative path back into one developer's package tree.
+ */
+export function agentHookPathForProject(projectRoot, packageRoot) {
+    const hook = join(packageRoot, "bin", "agent-hook");
+    const candidate = relative(projectRoot, hook);
+    if (candidate === ".." || candidate.startsWith(`..${sep}`) || isAbsolute(candidate)) {
+        return "agent-hook";
+    }
+    return candidate;
+}
 /**
  * Pure diff of one settings object against one adapter spec. Read-only inverse
  * of `wireHooks`; no fs, so it's unit-testable.
  */
-export function diffWiring(settings, spec) {
+export function diffWiring(settings, spec, expected) {
     const missing = [];
     const present = [];
+    const duplicates = [];
+    const misplaced = [];
+    const stale = [];
     const hooks = settings.hooks ?? {};
     for (const event of spec.events) {
         const groups = hooks[event.settingsKey] ?? [];
-        const wired = groups.some((g) => groupCommands(g).some((c) => commandWiresSubcommand(c, event.subcommand)));
-        (wired ? present : missing).push(event);
+        const commands = groups
+            .flatMap(groupCommands)
+            .filter((c) => commandWiresSubcommand(c, event.subcommand));
+        (commands.length > 0 ? present : missing).push(event);
+        if (commands.length > 1)
+            duplicates.push(event);
+        if (expected && commands.length > 0) {
+            const canonical = hookCommand(spec, expected.agentHookPath, event.subcommand, expected.adapter);
+            if (commands.some((command) => command !== canonical))
+                stale.push(event);
+        }
+        const wrongKey = Object.entries(hooks).some(([key, otherGroups]) => key !== event.settingsKey &&
+            Array.isArray(otherGroups) &&
+            otherGroups.some((group) => groupCommands(group).some((command) => commandWiresSubcommand(command, event.subcommand))));
+        if (wrongKey)
+            misplaced.push(event);
     }
     const specSubcommands = new Set(spec.events.map((e) => e.subcommand));
     const orphans = new Set();
@@ -79,6 +124,9 @@ export function diffWiring(settings, spec) {
         missing,
         present,
         orphans: [...orphans].sort(),
+        duplicates,
+        misplaced,
+        stale,
         invalidTopLevelKeys,
         invalidEventKeys,
     };
@@ -110,17 +158,29 @@ export function loadAdapterWiring(projectRoot) {
                 settingsFile: spec.settingsFile,
                 missing: [],
                 orphans: [],
+                duplicates: [],
+                misplaced: [],
+                stale: [],
                 invalidTopLevelKeys: [],
                 invalidEventKeys: [],
                 parseError: error.message,
             });
             continue;
         }
-        const diff = diffWiring(settings, spec);
+        const packageRoot = harneryPackageRoot();
+        const diff = diffWiring(settings, spec, packageRoot
+            ? {
+                agentHookPath: agentHookPathForProject(projectRoot, packageRoot),
+                adapter: id,
+            }
+            : undefined);
         if (diff.present.length === 0)
             continue; // not opted in → not drift
         if (diff.missing.length === 0 &&
             diff.orphans.length === 0 &&
+            diff.duplicates.length === 0 &&
+            diff.misplaced.length === 0 &&
+            diff.stale.length === 0 &&
             diff.invalidTopLevelKeys.length === 0 &&
             diff.invalidEventKeys.length === 0) {
             continue; // current
@@ -130,6 +190,9 @@ export function loadAdapterWiring(projectRoot) {
             settingsFile: spec.settingsFile,
             missing: diff.missing,
             orphans: diff.orphans,
+            duplicates: diff.duplicates,
+            misplaced: diff.misplaced,
+            stale: diff.stale,
             invalidTopLevelKeys: diff.invalidTopLevelKeys,
             invalidEventKeys: diff.invalidEventKeys,
         });
@@ -174,13 +237,28 @@ export function summarizeAdapterWiring(projectRoot) {
  * from `dist/`). Returns "" if unresolved — callers omit it from the message.
  */
 export function harneryVersion() {
+    const root = harneryPackageRoot();
+    if (!root)
+        return "";
+    try {
+        const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+        if (pkg.name === "harnery" && typeof pkg.version === "string")
+            return pkg.version;
+    }
+    catch {
+        /* unreadable package metadata */
+    }
+    return "";
+}
+/** Resolve the package root from either src/ (Bun) or dist/ (Node). */
+export function harneryPackageRoot() {
     try {
         let dir = dirname(fileURLToPath(import.meta.url));
         for (let i = 0; i < 8; i++) {
             try {
                 const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-                if (pkg.name === "harnery" && typeof pkg.version === "string")
-                    return pkg.version;
+                if (pkg.name === "harnery")
+                    return dir;
             }
             catch {
                 /* no package.json here, or not ours; keep walking up */
@@ -194,5 +272,5 @@ export function harneryVersion() {
     catch {
         /* import.meta.url unavailable or fs error */
     }
-    return "";
+    return null;
 }

package/dist/core/hooks/cli.d.ts

@@ -8,7 +8,7 @@
  *   4. Resolve instance_id (env → payload → pid-map walk).
  *   5. Map event-name → canonical event_type.
  *   6. Build event data from payload + resolvers (intent, transcript scan).
- *   7. Append envelope to .harnery/events.ndjson via emit() under flock.
+ *   7. Record the normalized observation in the canonical V3 ledger.
  *   8. (Still also writes a debug breadcrumb to .harnery/debug/ for visibility.)
  *
  * Phase 2 ship criterion: confirms parser correctness across thousands of