harnery 0.3.1 → 0.4.0

package/src/core/agents/render/session-context.ts

@@ -10,7 +10,8 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { resolveBinName } from "../../config.ts";
+import { resolveBinName, resolveHooksSetupHint } from "../../config.ts";
+import { harneryVersion, loadHarnessWiring } from "../../hooks/harness/wiring.ts";
 
 interface HeartbeatRow {
   instance_id?: string;
@@ -69,13 +70,40 @@ export function renderSessionContext(opts: RenderOpts): string {
     if (councilMsg) messages.push(councilMsg);
   }
 
-  // 4. Wiring check
+  // 4. Commit-guard wiring check
   const wiringIssues = checkWiring(coordRoot);
   if (wiringIssues.length > 0) {
-    const wiringSummary = `Coordination hooks are NOT wired: the E-guard will not block conflicting commits, and post-commit claim pruning will not run. Run \`scripts/setup-hooks.sh\` to fix. Detected:\n${wiringIssues.map((i) => `  - ${i}`).join("\n")}`;
+    const hint = resolveHooksSetupHint(coordRoot);
+    const fix = hint
+      ? `Run \`${hint}\` to install them.`
+      : "Wire each repo's pre-commit hook to invoke `agent-coord verdict --rule=commit` (harnery's commit guard).";
+    const wiringSummary = `Coordination hooks are NOT wired: the E-guard will not block conflicting commits, and post-commit claim pruning will not run. ${fix} Detected:\n${wiringIssues.map((i) => `  - ${i}`).join("\n")}`;
     messages.push(wiringSummary);
   }
 
+  // 5. Harness-hook drift: a harnery upgrade changed the hook set, but this
+  // project's settings file hasn't been re-wired. Only fires for a harness the
+  // project already opted into (≥1 hook wired), so it never nags a project that
+  // simply has a settings file. Remedy is always `<bin> init` (idempotent).
+  const drift = loadHarnessWiring(coordRoot);
+  if (drift.length > 0) {
+    const bin = resolveBinName(coordRoot);
+    const ver = harneryVersion();
+    const verPart = ver ? ` (harnery ${ver})` : "";
+    const lines = drift.map((d) => {
+      const bits: string[] = [];
+      if (d.missing.length > 0)
+        bits.push(`missing: ${d.missing.map((m) => m.subcommand).join(", ")}`);
+      if (d.orphans.length > 0) bits.push(`orphaned: ${d.orphans.join(", ")}`);
+      return `  - ${d.settingsFile} — ${bits.join("; ")}`;
+    });
+    messages.push(
+      `Harnery hook wiring is out of date${verPart}: an upgrade changed the hook set but the harness ` +
+        `settings file hasn't been re-wired, so the new hook(s) won't fire. Run \`${bin} init\` to wire them ` +
+        `(idempotent, additive).\n${lines.join("\n")}`,
+    );
+  }
+
   return messages.join("\n\n");
 }
 
@@ -198,19 +226,25 @@ function fmtAge(secs: number): string {
 }
 
 /**
- * Returns a list of wiring issues (empty when everything's wired). Checks
- * parent core.hooksPath + one representative submodule.
+ * Returns a list of commit-guard wiring issues (empty when wired). Portable
+ * across host projects: it asserts the FUNCTIONAL property ("does this repo's
+ * pre-commit invoke harnery's guard?") rather than any path convention. For
+ * each repo it resolves the EFFECTIVE git-hooks dir via
+ * `git rev-parse --git-path hooks` (which already honors `core.hooksPath`,
+ * linked worktrees, and submodule gitdirs) and checks whether the `pre-commit`
+ * there calls `agent-coord` / `agent-hook`. Checks the parent repo + one
+ * representative submodule (others almost always share the same setup).
+ *
+ * harnery does not install git hooks itself — each host wires its own
+ * pre-commit to invoke the guard — so the remediation command is host-specific
+ * and supplied via `hooksSetupHint` in `.harnery/config.jsonc` (see the caller).
  */
 export function checkWiring(coordRoot: string): string[] {
-  const expected = join(coordRoot, "scripts", "hooks");
   const issues: string[] = [];
 
-  // Parent repo
-  const parentHp = gitConfig(coordRoot, "core.hooksPath");
-  const parentResolved = resolveHooksPath(coordRoot, parentHp);
-  if (parentResolved !== expected) {
+  if (!preCommitInvokesGuard(coordRoot)) {
     issues.push(
-      `parent core.hooksPath=${parentHp || "<unset>"} (resolves to ${parentResolved}, expected ${expected})`,
+      "parent repo: pre-commit hook is missing or doesn't invoke the harnery commit guard",
     );
   }
 
@@ -220,15 +254,10 @@ export function checkWiring(coordRoot: string): string[] {
     const sampleSub = extractFirstSubmodule(gitmodules);
     if (sampleSub) {
       const subPath = join(coordRoot, sampleSub);
-      const subGitDir = join(subPath, ".git");
-      if (existsSync(subGitDir)) {
-        const subHp = gitConfig(subPath, "core.hooksPath");
-        const subResolved = resolveSubmoduleHooksPath(coordRoot, sampleSub, subHp);
-        if (subResolved !== expected) {
-          issues.push(
-            `submodule ${sampleSub} core.hooksPath=${subHp || "<unset>"} (resolves to ${subResolved}; other submodules likely affected too)`,
-          );
-        }
+      if (existsSync(join(subPath, ".git")) && !preCommitInvokesGuard(subPath)) {
+        issues.push(
+          `submodule ${sampleSub}: pre-commit hook doesn't invoke the harnery commit guard (other submodules likely affected too)`,
+        );
       }
     }
   }
@@ -236,22 +265,33 @@ export function checkWiring(coordRoot: string): string[] {
   return issues;
 }
 
-function gitConfig(cwd: string, key: string): string {
-  const result = spawnSync("git", ["-C", cwd, "config", "--get", key], { encoding: "utf8" });
-  if (result.status !== 0) return "";
-  return result.stdout.trim();
-}
-
-function resolveHooksPath(root: string, hp: string): string {
-  if (!hp) return join(root, ".git", "hooks");
-  if (hp.startsWith("/")) return hp.replace(/\/$/, "");
-  return join(root, hp).replace(/\/$/, "");
+/**
+ * Whether the repo at `repoDir` has a pre-commit hook — at its effective,
+ * `core.hooksPath`-aware location — that invokes harnery's commit guard.
+ * Fully portable: no assumption about WHERE the host keeps its hooks.
+ */
+function preCommitInvokesGuard(repoDir: string): boolean {
+  const hooksDir = gitHooksDir(repoDir);
+  if (!hooksDir) return false;
+  const preCommit = join(hooksDir, "pre-commit");
+  if (!existsSync(preCommit)) return false;
+  try {
+    return /agent-(coord|hook)\b/.test(readFileSync(preCommit, "utf8"));
+  } catch {
+    return false;
+  }
 }
 
-function resolveSubmoduleHooksPath(root: string, sub: string, hp: string): string {
-  if (!hp) return join(root, sub, ".git", "hooks");
-  if (hp.startsWith("/")) return hp.replace(/\/$/, "");
-  return join(root, sub, hp).replace(/\/$/, "");
+/** Resolve a repo's effective git-hooks directory (absolute), or null. */
+function gitHooksDir(repoDir: string): string | null {
+  const r = spawnSync("git", ["-C", repoDir, "rev-parse", "--git-path", "hooks"], {
+    encoding: "utf8",
+  });
+  if (r.status !== 0) return null;
+  const p = r.stdout.trim();
+  if (!p) return null;
+  // `--git-path` prints relative to repoDir (we passed -C); absolutize.
+  return p.startsWith("/") ? p : join(repoDir, p);
 }
 
 function extractFirstSubmodule(gitmodulesPath: string): string | null {

package/src/core/agents/rules/claim-conflict.ts

@@ -102,14 +102,28 @@ export function evaluateClaim(coordRoot: string, req: ClaimRequest): VerdictResu
     (p) => isFresh(p.last_heartbeat) && p.files_touched.length > 0,
   );
   if (hasFreshPeers && myPeer && myPeer.files_touched.length > 0) {
-    const highest = [...myPeer.files_touched].sort().at(-1)!;
-    if (req.path < highest) {
-      return {
-        allow: false,
-        exit_code: 2,
-        rule: "claim.ordering_violation",
-        reason: `Cannot acquire ${req.path} while holding ${highest} (claim ordering rule: paths must be acquired in sorted order). Release the higher claim first.`,
-      };
+    // Only ACTIVE (uncommitted) edits should constrain lock ordering. A claim on
+    // a committed-clean file is a finished edit, not a held lock, so it must not
+    // wall off a lower-sorted acquisition. Without this, a long session
+    // accumulates committed claims that block every earlier-sorted path — pure
+    // friction, no deadlock risk (the file isn't being touched). Mirrors the
+    // peer stale-claim self-heal above. The git probes run only on the
+    // would-block path (claims sorting after req.path), staying off the hot path.
+    const blockers = myPeer.files_touched.filter((p) => req.path < p);
+    if (blockers.length > 0) {
+      const activeBlockers = blockers.filter((p) => !isFileCommittedClean(coordRoot, p));
+      if (activeBlockers.length > 0) {
+        const highest = [...activeBlockers].sort().at(-1)!;
+        return {
+          allow: false,
+          exit_code: 2,
+          rule: "claim.ordering_violation",
+          reason: `Cannot acquire ${req.path} while holding ${highest} (claim ordering rule: paths must be acquired in sorted order). Release the higher claim first.`,
+        };
+      }
+      // Every blocker is a finished (committed-clean) edit: prune them so they
+      // stop constraining future acquisitions, then fall through to allow.
+      for (const p of blockers) pruneClaimFromPeer(coordRoot, req.instance_id, p);
     }
   }
 
@@ -240,16 +254,19 @@ function isFresh(lastHeartbeat: string): boolean {
  *  - diff shows non-empty output (genuinely dirty)
  */
 function isFileCommittedClean(coordRoot: string, relPath: string): boolean {
-  const abs = join(coordRoot, relPath);
+  // Tolerate either path form: files_touched can hold absolute-under-coordRoot
+  // entries (legacy file-tracking) or canonical monorepo-relative ones.
+  const rel = relPath.startsWith(`${coordRoot}/`) ? relPath.slice(coordRoot.length + 1) : relPath;
+  const abs = join(coordRoot, rel);
   if (!existsSync(abs)) return false;
   try {
-    const tracked = spawnSync("git", ["ls-files", "--error-unmatch", "--", relPath], {
+    const tracked = spawnSync("git", ["ls-files", "--error-unmatch", "--", rel], {
       cwd: coordRoot,
       encoding: "utf8",
       timeout: 2000,
     });
     if (tracked.status !== 0) return false;
-    const result = spawnSync("git", ["diff", "--quiet", "HEAD", "--", relPath], {
+    const result = spawnSync("git", ["diff", "--quiet", "HEAD", "--", rel], {
       cwd: coordRoot,
       encoding: "utf8",
       timeout: 2000,

package/src/core/agents/state/heartbeat-writer.ts

@@ -171,9 +171,16 @@ export function releaseClaim(
   instanceId: string,
   path: string,
 ): Heartbeat | null {
+  // files_touched can hold either absolute-under-coordRoot or canonical
+  // monorepo-relative entries; normalize both sides so release matches
+  // regardless of the form the caller passes (the old exact-string filter
+  // silently no-op'd on a form mismatch).
+  const norm = (p: string): string =>
+    p.startsWith(`${coordRoot}/`) ? p.slice(coordRoot.length + 1) : p;
+  const target = norm(path);
   return mutate(coordRoot, instanceId, (hb) => ({
     ...hb,
-    files_touched: (hb.files_touched ?? []).filter((p) => p !== path),
+    files_touched: (hb.files_touched ?? []).filter((p) => norm(p) !== target),
   }));
 }
 

package/src/core/config.ts

@@ -25,6 +25,14 @@ export const DEFAULT_BIN_NAME = "harn";
 interface HarneryConfig {
   /** Host CLI bin name, stamped by `harn init` for a consumer (e.g. "bp"). */
   binName?: string;
+  /**
+   * Host-specific command that (re)installs the project's git hooks, surfaced
+   * verbatim in the "commit guard not wired" nudge. Optional: harnery doesn't
+   * own git-hook installation (each host wires its own pre-commit to invoke
+   * `agent-coord verdict`), and the path/command is host-specific, so the host
+   * declares it here (e.g. "scripts/setup-hooks.sh"). Unset → a generic hint.
+   */
+  hooksSetupHint?: string;
   [k: string]: unknown;
 }
 
@@ -109,3 +117,16 @@ export function resolveBinName(coordRoot?: string | null): string {
   }
   return DEFAULT_BIN_NAME;
 }
+
+/**
+ * The host's git-hook (re)install command, for the "commit guard not wired"
+ * nudge. Returns the configured `hooksSetupHint` (e.g. "scripts/setup-hooks.sh")
+ * or null when unset — callers fall back to a generic, host-agnostic message.
+ * `coordRoot` is resolved via `findCoordRoot()` when not passed.
+ */
+export function resolveHooksSetupHint(coordRoot?: string | null): string | null {
+  const root = coordRoot ?? findCoordRoot();
+  if (!root) return null;
+  const hint = readConfig(root).hooksSetupHint;
+  return typeof hint === "string" && hint.trim() ? hint.trim() : null;
+}

package/src/core/hooks/cli.ts

@@ -51,7 +51,7 @@ import {
   type ParsedPayload,
   parsePayload,
 } from "./harness/parse.ts";
-import { selectAnchorPid } from "./resolve/anchor.ts";
+import { parsePsChainLine, selectAnchorPid } from "./resolve/anchor.ts";
 import { findCoordRoot } from "./resolve/coord-root.ts";
 import { extractIntentComment, resolveIntent } from "./resolve/intent.ts";
 import { resolveOwner } from "./resolve/owner.ts";
@@ -908,10 +908,10 @@ function healHeartbeatViaCli(
  * the next tool call rather than going invisible until SessionStart fires
  * again, which it may never do.
  *
- * Returns undefined on macOS (no /proc) or when no anchor is found; callers
- * fall back to `process.ppid` (the bash wrapper's parent, which is usually
- * the harness binary itself). `HARNERY_AGENT_COORD_TEST_ANCHOR_PID` overrides
- * everything so the test sandbox can pin a deterministic PID.
+ * Returns undefined only when no anchor is found; callers fall back to
+ * `process.ppid` (the bash wrapper's parent, which is usually the harness binary
+ * itself). `HARNERY_AGENT_COORD_TEST_ANCHOR_PID` overrides everything so the
+ * test sandbox can pin a deterministic PID.
  */
 function findHarnessAnchorPid(harness?: Harness): number | undefined {
   const override = coordEnv("AGENT_COORD_TEST_ANCHOR_PID");
@@ -919,27 +919,31 @@ function findHarnessAnchorPid(harness?: Harness): number | undefined {
     const n = Number(override);
     if (Number.isFinite(n) && n > 0) return n;
   }
-  // Build the ppid chain (nearest → root, up to 20 hops) from /proc, then hand
-  // it to the pure selector. Splitting the /proc walk (untestable off a live
-  // box) from the comm-matching (unit-tested against the real Phase 0 chains in
-  // resolve/anchor.ts) keeps the cursor `node`-fallback logic verifiable.
+  // Build the ppid chain (nearest → root, up to 20 hops), then hand it to the
+  // pure selector. Linux/WSL reads /proc; macOS/BSD (no /proc) falls back to
+  // `ps -o ppid=,comm=` parsed by the unit-tested `parsePsChainLine`. Splitting
+  // the walk (untestable off a live box) from the comm-matching keeps the
+  // cursor `node`-fallback logic verifiable.
   const chain: Array<{ pid: number; comm: string }> = [];
   let pid = process.pid;
   for (let hops = 0; hops < 20; hops++) {
-    let comm: string;
-    let status: string;
+    let hop: { comm: string; ppid: number } | null = null;
     try {
-      comm = readFileSync(`/proc/${pid}/comm`, "utf8").trim();
-      status = readFileSync(`/proc/${pid}/status`, "utf8");
+      const comm = readFileSync(`/proc/${pid}/comm`, "utf8").trim();
+      const status = readFileSync(`/proc/${pid}/status`, "utf8");
+      const m = status.match(/^PPid:\s+(\d+)/m);
+      hop = { comm, ppid: m ? Number(m[1]) : 0 };
     } catch {
-      break;
+      // no /proc (macOS/BSD) — fall through to ps
     }
-    chain.push({ pid, comm });
-    const m = status.match(/^PPid:\s+(\d+)/m);
-    if (!m) break;
-    const ppid = Number(m[1]);
-    if (!Number.isFinite(ppid) || ppid === 0 || ppid === 1) break;
-    pid = ppid;
+    if (!hop) {
+      const out = spawnSync("ps", ["-o", "ppid=,comm=", "-p", String(pid)], { encoding: "utf8" });
+      if (out.status === 0) hop = parsePsChainLine(out.stdout);
+    }
+    if (!hop) break;
+    chain.push({ pid, comm: hop.comm });
+    if (!Number.isFinite(hop.ppid) || hop.ppid === 0 || hop.ppid === 1) break;
+    pid = hop.ppid;
   }
   return selectAnchorPid(chain, harness);
 }

package/src/core/hooks/harness/wiring.ts

@@ -0,0 +1,185 @@
+/**
+ * Read-only harness-hook wiring inspection — the inverse of `harn init`'s
+ * writer (commands/init.ts `wireHooks`). Compares what `init` would wire
+ * (HARNESS_SPECS) against what's actually present in a project's harness
+ * settings file, so `harn doctor` and the SessionStart nudge can tell an agent
+ * when a harnery upgrade changed the hook set but the project hasn't been
+ * re-wired yet.
+ *
+ * The shared types + matcher live here (not in init.ts) so the writer, the
+ * doctor check, and the session-start renderer all agree on what "wired" means
+ * — 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 { fileURLToPath } from "node:url";
+import {
+  HARNESS_SPECS,
+  type HarnessId,
+  type HarnessSpec,
+  type HookEntryShape,
+  type HookEvent,
+} from "./events.ts";
+
+/** Claude Code + Codex entry: `{ hooks: [{ type, command }] }`. */
+export interface ClaudeHookGroup {
+  matcher?: string;
+  hooks: { type: string; command: string }[];
+}
+/** Cursor entry: a flat `{ command }`. */
+export interface CursorHookGroup {
+  command: string;
+  type?: string;
+  matcher?: string;
+}
+export type HookGroup = ClaudeHookGroup | CursorHookGroup;
+
+export interface SettingsFile {
+  version?: number;
+  hooks?: Record<string, HookGroup[]>;
+  [k: string]: unknown;
+}
+
+/** Build a hook entry in the harness's shape. */
+export function makeEntry(shape: HookEntryShape, command: string): HookGroup {
+  return shape === "cursor" ? { command } : { hooks: [{ type: "command", command }] };
+}
+
+/** Pull every command string out of a hook entry, regardless of shape. */
+export function groupCommands(group: HookGroup): string[] {
+  if ("command" in group && typeof group.command === "string") return [group.command];
+  if ("hooks" in group && Array.isArray(group.hooks)) {
+    return group.hooks.map((h) => h.command).filter((c): c is string => typeof c === "string");
+  }
+  return [];
+}
+
+/**
+ * Whether a hook command string wires the given agent-hook subcommand. The
+ * trailing space is load-bearing: it keeps `stop` from matching `stop-failure`.
+ */
+export function commandWiresSubcommand(command: string, subcommand: string): boolean {
+  return command.includes(`agent-hook ${subcommand} `);
+}
+
+/** Pull the agent-hook subcommand out of a command string, or null if none. */
+function commandSubcommand(command: string): string | null {
+  const m = command.match(/agent-hook\s+([a-z][a-z-]*)\s/);
+  return m ? m[1]! : null;
+}
+
+export interface WiringDiff {
+  /** Spec events not wired in the settings file. */
+  missing: HookEvent[];
+  /** Spec events already wired. */
+  present: HookEvent[];
+  /**
+   * agent-hook subcommands wired in the file that are NOT in the current spec
+   * (e.g. an event renamed/removed by an upgrade). Additive re-init won't clean
+   * these — they need explicit removal — so they're surfaced separately.
+   */
+  orphans: string[];
+}
+
+/**
+ * Pure diff of one settings object against one harness spec. Read-only inverse
+ * of `wireHooks`; no fs, so it's unit-testable.
+ */
+export function diffWiring(settings: SettingsFile, spec: HarnessSpec): WiringDiff {
+  const missing: HookEvent[] = [];
+  const present: HookEvent[] = [];
+  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 specSubcommands = new Set(spec.events.map((e) => e.subcommand));
+  const orphans = new Set<string>();
+  for (const groups of Object.values(hooks)) {
+    if (!Array.isArray(groups)) continue;
+    for (const g of groups) {
+      for (const c of groupCommands(g)) {
+        const sub = commandSubcommand(c);
+        if (sub && !specSubcommands.has(sub)) orphans.add(sub);
+      }
+    }
+  }
+
+  return { missing, present, orphans: [...orphans].sort() };
+}
+
+export interface HarnessWiringStatus {
+  harness: HarnessId;
+  /** Settings file path, relative to the project root. */
+  settingsFile: string;
+  missing: HookEvent[];
+  orphans: string[];
+}
+
+/**
+ * Inspect every harness whose settings file exists under `projectRoot` and
+ * return only those with *drift*. Read-only; never writes.
+ *
+ * Drift is reported only for a harness the project has **already opted into** —
+ * i.e. at least one harnery hook is already wired. A settings file with zero
+ * harnery hooks just means this harness isn't harnery-wired here (a bare
+ * `.claude/settings.json` is a generic Claude Code file); that's `harn init`'s
+ * job to surface on first run, not drift to nag about every session. A harness
+ * with no settings file at all, or an unparseable one, is skipped.
+ */
+export function loadHarnessWiring(projectRoot: string): HarnessWiringStatus[] {
+  const out: HarnessWiringStatus[] = [];
+  for (const [id, spec] of Object.entries(HARNESS_SPECS) as [HarnessId, HarnessSpec][]) {
+    const settingsPath = resolve(projectRoot, spec.settingsFile);
+    if (!existsSync(settingsPath)) continue;
+    let settings: SettingsFile;
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8")) as SettingsFile;
+    } catch {
+      // Unparseable settings file: can't tell opt-in from noise, and the
+      // harness itself will complain about its own malformed config. Skip.
+      continue;
+    }
+    const diff = diffWiring(settings, spec);
+    if (diff.present.length === 0) continue; // not opted in → not drift
+    if (diff.missing.length === 0 && diff.orphans.length === 0) continue; // current
+    out.push({
+      harness: id,
+      settingsFile: spec.settingsFile,
+      missing: diff.missing,
+      orphans: diff.orphans,
+    });
+  }
+  return out;
+}
+
+/**
+ * Resolve the harnery package version for context in nudges/checks. Walks up
+ * from this module to the package root (works under Bun from `src/` and Node
+ * from `dist/`). Returns "" if unresolved — callers omit it from the message.
+ */
+export function harneryVersion(): string {
+  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;
+      } catch {
+        /* no package.json here, or not ours; keep walking up */
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    /* import.meta.url unavailable or fs error */
+  }
+  return "";
+}

package/src/core/hooks/resolve/anchor.ts

@@ -49,3 +49,24 @@ export function selectAnchorPid(
   }
   return undefined;
 }
+
+/**
+ * Parse one `ps -o ppid=,comm= -p <pid>` line into the same `{ ppid, comm }`
+ * shape the `/proc` fast path produces, for the macOS/BSD branch of the anchor
+ * walk. `ps` prints `comm` as a full executable path (and some Apple helper
+ * names contain spaces, e.g. `Code Helper (Plugin)`), so the comm is reduced to
+ * its basename to match the harness comm tokens the way Linux's `/proc/<pid>/comm`
+ * basename does. Returns null when the line has no leading numeric ppid.
+ *
+ * Pure (no I/O) so the parsing — the error-prone part — is unit-testable
+ * without a live process tree; the caller owns the `ps` spawn.
+ */
+export function parsePsChainLine(line: string): { ppid: number; comm: string } | null {
+  const m = line.trim().match(/^(\d+)\s+(.*)$/);
+  if (!m) return null;
+  const ppid = Number.parseInt(m[1]!, 10);
+  if (!Number.isFinite(ppid)) return null;
+  const commPath = m[2]!.trim();
+  const comm = commPath.split("/").pop() || commPath;
+  return { ppid, comm };
+}

package/src/core/hooks/resolve/owner.ts

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { coordEnv } from "../../../lib/env.ts";
@@ -73,18 +74,26 @@ export function resolveOwner(opts: {
 }
 
 function readPpid(pid: number): number | null {
-  // Linux/WSL: /proc/<pid>/status carries `PPid:`. Falls back to null on
-  // macOS or any read failure; ancestor walk just terminates.
+  // Linux/WSL fast path: /proc/<pid>/status carries `PPid:`.
   try {
     const status = readFileSync(`/proc/${pid}/status`, "utf8");
-    for (const line of status.split("\n")) {
-      if (line.startsWith("PPid:")) {
-        const n = Number(line.split(/\s+/)[1]);
-        return Number.isFinite(n) ? n : null;
-      }
+    const m = status.match(/^PPid:\s+(\d+)/m);
+    if (m) {
+      const n = Number.parseInt(m[1]!, 10);
+      if (Number.isFinite(n) && n > 0) return n;
+    }
+  } catch {
+    /* no /proc (macOS/BSD) — fall through to ps */
+  }
+  // Portable fallback: `ps -o ppid= -p <pid>` works on macOS/BSD/Linux.
+  try {
+    const out = spawnSync("ps", ["-o", "ppid=", "-p", String(pid)], { encoding: "utf8" });
+    if (out.status === 0) {
+      const n = Number.parseInt(out.stdout.trim(), 10);
+      if (Number.isFinite(n) && n > 0) return n;
     }
   } catch {
-    /* fallthrough */
+    /* ps unavailable — give up */
   }
   return null;
 }

package/dist/commands/uninstall.d.ts

@@ -1,22 +0,0 @@
-/**
- * `harn uninstall`: reverse what `harn init` wired into a project.
- *
- * `init` makes two kinds of change outside the harnery package:
- *   1. Merges `agent-hook` entries into the harness settings file
- *      (Claude Code `.claude/settings.json`, Cursor `.cursor/hooks.json`, or
- *      Codex `.codex/hooks.json`).
- *   2. Creates the `.harnery/` coord root (runtime state: events, councils,
- *      identities, scratch) and stamps the host bin name into
- *      `.harnery/config.jsonc`.
- *
- * `uninstall` undoes (1) by default: it removes only harnery's hook entries from
- * the settings file, preserving any other hooks the consumer added, and deletes
- * the settings file outright when it's left harnery-only. It does NOT touch the
- * `.harnery/` coord root unless `--purge-state` is passed, because that directory
- * holds session history a consumer may want to keep. Idempotent + `--dry-run`,
- * mirroring `init`.
- */
-import type { Command } from "commander";
-import type { EmitContext } from "../commander.js";
-export declare function registerUninstallCommand(program: Command, emit: EmitContext): void;
-//# sourceMappingURL=uninstall.d.ts.map

package/dist/commands/uninstall.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"uninstall.d.ts","sourceRoot":"","sources":["../../src/commands/uninstall.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAWnD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAoFlF"}