harnery 0.3.1 → 0.4.0

package/dist/core/hooks/resolve/owner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"owner.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/resolve/owner.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,GAAG,SAAS,GAAG,aAAa,GAAG,iBAAiB,CAAA;CAAE,GAAG,IAAI,CA+ChG;AAmBD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ7E;AAED,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUxF;AAED,2DAA2D;AAC3D,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAgBnF"}
+{"version":3,"file":"owner.d.ts","sourceRoot":"","sources":["../../../../src/core/hooks/resolve/owner.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,GAAG,SAAS,GAAG,aAAa,GAAG,iBAAiB,CAAA;CAAE,GAAG,IAAI,CA+ChG;AA2BD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ7E;AAED,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUxF;AAED,2DAA2D;AAC3D,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAgBnF"}

package/dist/core/hooks/resolve/owner.js

@@ -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.js";
@@ -67,19 +68,30 @@ export function resolveOwner(opts) {
     return null;
 }
 function readPpid(pid) {
-    // 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnery",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Multi-agent coordination + harness adapters + portable CLI utilities for Claude Code / Cursor / Codex.",
   "license": "MIT",
   "author": "Ryan Kelly",

package/schemas/config.schema.json

@@ -19,6 +19,10 @@
       "default": "harn",
       "description": "Host CLI bin name used in agent-facing strings (council prompts, end-of-turn nudges, command help). The coord binaries + web UI run as harnery and read this back since they can't see a consumer CLI's name. Stamped by `harn init` for a consumer. Resolution: HARNERY_BIN env -> this field -> 'harn'."
     },
+    "hooksSetupHint": {
+      "type": "string",
+      "description": "Host-specific command that (re)installs the project's git hooks (e.g. 'scripts/setup-hooks.sh'). Surfaced verbatim in the SessionStart 'commit guard not wired' nudge. 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. Unset -> a generic, host-agnostic hint."
+    },
     "coord": {
       "type": "object",
       "additionalProperties": false,

package/src/commander.ts

@@ -27,6 +27,7 @@ import { registerCompletionCommand } from "./commands/completion.ts";
 import { registerConfigGetCommand } from "./commands/config-get.ts";
 import { registerContextCommand } from "./commands/context.ts";
 import { registerCookiesCommand } from "./commands/cookies.ts";
+import { registerDeinitCommand } from "./commands/deinit.ts";
 import { registerDocsCommand } from "./commands/docs.ts";
 import { registerDoctorCommand } from "./commands/doctor.ts";
 import { registerEditBatchCommand } from "./commands/edit-batch.ts";
@@ -45,7 +46,6 @@ import { registerSyncCommand } from "./commands/sync.ts";
 import { registerSectionCommand, registerTocCommand } from "./commands/toc.ts";
 import { registerTokensCommand } from "./commands/tokens.ts";
 import { registerTunnelCommand } from "./commands/tunnel.ts";
-import { registerUninstallCommand } from "./commands/uninstall.ts";
 import { registerWebCommand } from "./commands/web.ts";
 
 export interface HarneryContextOpts {
@@ -230,7 +230,7 @@ export function createHarneryProgram(opts: HarneryContextOpts = {}): Command {
   registerAgentsCommand(program, emit);
   registerDoctorCommand(program, emit);
   registerInitCommand(program, emit, opts.binName);
-  registerUninstallCommand(program, emit);
+  registerDeinitCommand(program, emit, opts.binName);
   registerBackupCommand(program, emit);
   registerSyncCommand(program, emit);
   if (include("web")) registerWebCommand(program, emit);

package/src/commands/agents.ts

@@ -38,6 +38,7 @@ import {
   resolveOwnerWithSource,
 } from "../core/agents/index.ts";
 import { resolveBinName } from "../core/config.ts";
+import { parsePsChainLine } from "../core/hooks/resolve/anchor.ts";
 import {
   buildCouncilId,
   buildInviteMarkdown,
@@ -2692,13 +2693,25 @@ function runHarnessProbe(
   for (let hops = 0; hops < 20; hops++) {
     let comm = "?";
     let ppid = 0;
+    let got = false;
     try {
       comm = readFileSync(`/proc/${walkPid}/comm`, "utf8").trim() || "?";
       const status = readFileSync(`/proc/${walkPid}/status`, "utf8");
       const m = status.match(/^PPid:\s+(\d+)/m);
       ppid = m ? Number(m[1]) : 0;
+      got = true;
     } catch {
-      // non-Linux (no /proc) or the pid is gone: stop walking.
+      // non-Linux (no /proc): fall through to the portable ps walk below.
+    }
+    if (!got) {
+      const out = spawnSync("ps", ["-o", "ppid=,comm=", "-p", String(walkPid)], {
+        encoding: "utf8",
+      });
+      const parsed = out.status === 0 ? parsePsChainLine(out.stdout) : null;
+      if (parsed) {
+        comm = parsed.comm || "?";
+        ppid = parsed.ppid;
+      }
     }
     chainParts.push(`${walkPid}:${comm}`);
     if (!anchorPid && anchorTokens.has(comm)) anchorPid = String(walkPid);

package/src/commands/{uninstall.ts → deinit.ts}

@@ -1,5 +1,5 @@
 /**
- * `harn uninstall`: reverse what `harn init` wired into a project.
+ * `harn deinit`: 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
@@ -9,42 +9,60 @@
  *      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
+ * `deinit` 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`.
+ *
+ * For standalone `harn` on a terminal it also handles the destructive extra
+ * conversationally: when `--purge-state` wasn't passed and `.harnery/` exists, it
+ * asks before deleting it, and afterward it prints how to remove the harnery CLI
+ * itself (which a running process can't do to its own package). Both are gated to
+ * standalone harn — an embedding host routes output through its own emit and owns
+ * its install lifecycle — and the prompt never fires off a TTY, so scripted / CI
+ * runs keep the flag-driven behavior untouched. The shell wrapper `scripts/teardown.sh`
+ * is the fuller mirror (it also unlinks the PATH bins and can delete the clone).
  */
 
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { relative, resolve } from "node:path";
+import { createInterface } from "node:readline";
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
+import { DEFAULT_BIN_NAME } from "../core/config.ts";
 import { HARNESS_SPECS, type HarnessId } from "../core/hooks/harness/events.ts";
 import { type SettingsFile, unwireHooks } from "./init.ts";
 
-interface UninstallOpts {
+interface DeinitOpts {
   harness: string;
   dryRun?: boolean;
   projectRoot?: string;
   purgeState?: boolean;
 }
 
-export function registerUninstallCommand(program: Command, emit: EmitContext): void {
+export function registerDeinitCommand(program: Command, emit: EmitContext, binName?: string): void {
+  // The interactive prompt + engine-removal hint are standalone-harn niceties.
+  // An embedding host routes output through its own emit and owns its install
+  // lifecycle, so for a host (binName set + non-default) deinit stays strictly
+  // flag-driven and says nothing about removing "the package".
+  const standalone = !binName || binName === DEFAULT_BIN_NAME;
+
   program
-    .command("uninstall")
+    .command("deinit")
     .description(
       "Reverse `harn init`: remove harnery's hook entries from the harness " +
         "settings file (keeps any others). Pass --purge-state to also delete the " +
-        ".harnery/ coord root. Idempotent; use --dry-run to preview.",
+        ".harnery/ coord root (on a terminal it asks first). Idempotent; use " +
+        "--dry-run to preview.",
     )
     .option("--harness <id>", "claude-code | cursor | codex", "claude-code")
     .option("--dry-run", "Show what would change without writing")
     .option("--project-root <path>", "Project root (default: git toplevel, else cwd)")
     .option("--purge-state", "Also delete the .harnery/ coord root (runtime state, destructive)")
-    .action((opts: UninstallOpts) => {
+    .action(async (opts: DeinitOpts) => {
       const harness = opts.harness as HarnessId;
       const spec = HARNESS_SPECS[harness];
       if (!spec) {
@@ -55,8 +73,24 @@ export function registerUninstallCommand(program: Command, emit: EmitContext): v
 
       const projectRoot = resolve(opts.projectRoot ?? gitTopLevel() ?? process.cwd());
       const dryRun = opts.dryRun === true;
+      const coordDir = resolve(projectRoot, ".harnery");
+      const coordExists = existsSync(coordDir);
+      let purgeState = opts.purgeState === true;
       const actions: string[] = [];
 
+      // ── 0. interactive: offer to delete .harnery/ (standalone harn, TTY) ───
+      if (
+        shouldPromptForState({
+          standalone,
+          interactive: process.stdin.isTTY === true,
+          dryRun,
+          purgeState,
+          coordExists,
+        })
+      ) {
+        purgeState = await confirmDeleteState(coordDir);
+      }
+
       // ── 1. unwire harness hooks ────────────────────────────────────────────
       const settingsPath = resolve(projectRoot, spec.settingsFile);
       if (!existsSync(settingsPath)) {
@@ -100,9 +134,8 @@ export function registerUninstallCommand(program: Command, emit: EmitContext): v
       }
 
       // ── 2. coord root (opt-in; destructive) ────────────────────────────────
-      const coordDir = resolve(projectRoot, ".harnery");
-      if (opts.purgeState) {
-        if (!existsSync(coordDir)) {
+      if (purgeState) {
+        if (!coordExists) {
           actions.push("· .harnery/ doesn't exist; nothing to purge");
         } else if (dryRun) {
           actions.push("+ would delete .harnery/ and all coord state (events, councils, scratch)");
@@ -110,12 +143,65 @@ export function registerUninstallCommand(program: Command, emit: EmitContext): v
           rmSync(coordDir, { recursive: true, force: true });
           actions.push("+ deleted .harnery/ and all coord state");
         }
-      } else if (existsSync(coordDir)) {
+      } else if (coordExists) {
         actions.push("· left .harnery/ coord root in place (pass --purge-state to delete it)");
       }
 
-      emit.text(render(projectRoot, dryRun, actions));
+      const hint = standalone && !dryRun ? engineRemovalHint() : null;
+      emit.text(render(projectRoot, dryRun, actions, hint));
+    });
+}
+
+/**
+ * Whether to interactively ask before deleting `.harnery/`. True only for
+ * standalone harn on a TTY, when the user didn't already answer with
+ * --purge-state, it isn't a dry run, and there's actually a coord root to
+ * delete. Pure so the gating is unit-testable without a terminal.
+ */
+export function shouldPromptForState(o: {
+  standalone: boolean;
+  interactive: boolean;
+  dryRun: boolean;
+  purgeState: boolean;
+  coordExists: boolean;
+}): boolean {
+  return o.standalone && o.interactive && !o.dryRun && !o.purgeState && o.coordExists;
+}
+
+/**
+ * The "harnery itself is still installed" line shown to standalone-harn users
+ * after a real deinit. `harn deinit` can't remove the package it's running
+ * from, so it points at the two ways to finish the job. Pure + exported for the
+ * test.
+ */
+export function engineRemovalHint(): string {
+  return (
+    "harnery itself is still installed. To remove the CLI too: `npm rm -g harnery` " +
+    "(if you installed it with npm/bun); from a git clone, " +
+    "`scripts/teardown.sh --remove-clone` removes the checkout."
+  );
+}
+
+/** Mirror scripts/teardown.sh's wording: explain what .harnery/ holds, then ask. */
+function confirmDeleteState(coordDir: string): Promise<boolean> {
+  process.stdout.write(
+    "\nharnery saved this project's coordination history in .harnery/\n" +
+      "(its event log, councils, agent identities, and scratchpads):\n" +
+      `    ${coordDir}\n` +
+      "Unwiring leaves that in place. Deleting it can't be undone.\n",
+  );
+  return confirm("Delete this project's harnery history too? [y/N]");
+}
+
+/** Read one y/N answer from the TTY. Yes only on an explicit y / yes. */
+function confirm(question: string): Promise<boolean> {
+  return new Promise((resolveAnswer) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${question} `, (answer) => {
+      rl.close();
+      resolveAnswer(/^y(es)?$/i.test(answer.trim()));
     });
+  });
 }
 
 /** True when an unwired settings object holds nothing but (optionally) `version`. */
@@ -124,12 +210,18 @@ function harnessOnly(settings: SettingsFile): boolean {
   return keys.length === 0 || (keys.length === 1 && keys[0] === "version");
 }
 
-function render(projectRoot: string, dryRun: boolean, actions: string[]): string {
-  const head = dryRun ? "harn uninstall (dry run): no changes written" : "harn uninstall";
+function render(
+  projectRoot: string,
+  dryRun: boolean,
+  actions: string[],
+  hint: string | null,
+): string {
+  const head = dryRun ? "harn deinit (dry run): no changes written" : "harn deinit";
   const tail = dryRun
     ? "\nRe-run without --dry-run to apply."
     : "\nDone. harnery hooks are unwired; restart your harness session to drop them.";
-  return `${head}\n  root: ${projectRoot}\n${actions.map((a) => `  ${a}`).join("\n")}${tail}`;
+  const hintBlock = hint ? `\n\n${hint}` : "";
+  return `${head}\n  root: ${projectRoot}\n${actions.map((a) => `  ${a}`).join("\n")}${tail}${hintBlock}`;
 }
 
 function gitTopLevel(): string | null {

package/src/commands/doctor.ts

@@ -17,6 +17,8 @@ import os from "node:os";
 import path from "node:path";
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
+import { resolveBinName } from "../core/config.ts";
+import { loadHarnessWiring } from "../core/hooks/harness/wiring.ts";
 
 type Severity = "ok" | "warn" | "fail";
 
@@ -79,6 +81,7 @@ export function runChecks(): Check[] {
     checkGit(),
     checkBun(),
     checkHarneryDir(),
+    checkHarnessHooks(),
     checkRestic(),
     checkRclone(),
     checkPlaywright(),
@@ -203,21 +206,23 @@ function checkPython(): Check {
   return { name: "python3", severity: "ok", detail: r.out };
 }
 
-function checkHarneryDir(): Check {
-  // Walk up from cwd looking for .harnery/.
+/** Walk up from cwd to the nearest dir containing `.harnery/`; null if none. */
+function findCoordProjectRoot(): string | null {
   let dir = process.cwd();
   for (let i = 0; i < 8; i++) {
-    if (existsSync(path.join(dir, ".harnery"))) {
-      return {
-        name: ".harnery/",
-        severity: "ok",
-        detail: path.join(dir, ".harnery"),
-      };
-    }
+    if (existsSync(path.join(dir, ".harnery"))) return dir;
     const parent = path.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
+  return null;
+}
+
+function checkHarneryDir(): Check {
+  const root = findCoordProjectRoot();
+  if (root) {
+    return { name: ".harnery/", severity: "ok", detail: path.join(root, ".harnery") };
+  }
   return {
     name: ".harnery/",
     severity: "warn",
@@ -226,6 +231,39 @@ function checkHarneryDir(): Check {
   };
 }
 
+/**
+ * Compare the project's wired harness hooks against HARNESS_SPECS. Catches the
+ * post-upgrade case where a harnery release added (or renamed) a hook event but
+ * the consumer's settings file hasn't been re-wired. Only fires for a harness
+ * the project has opted into (≥1 harnery hook already wired) — see
+ * loadHarnessWiring — so a bare settings file never false-warns. The remedy is
+ * always the same: re-run `<bin> init` (idempotent, additive).
+ */
+function checkHarnessHooks(): Check {
+  const root = findCoordProjectRoot();
+  if (!root) {
+    return { name: "harness hooks", severity: "ok", detail: "n/a (no .harnery/ above cwd)" };
+  }
+  const drift = loadHarnessWiring(root);
+  if (drift.length === 0) {
+    return { name: "harness hooks", severity: "ok", detail: "wired + current" };
+  }
+  const bin = resolveBinName(root);
+  const parts = drift.map((d) => {
+    const bits: string[] = [];
+    if (d.missing.length > 0) {
+      bits.push(`${d.missing.length} missing (${d.missing.map((m) => m.subcommand).join(", ")})`);
+    }
+    if (d.orphans.length > 0) bits.push(`${d.orphans.length} orphaned (${d.orphans.join(", ")})`);
+    return `${d.settingsFile}: ${bits.join("; ")}`;
+  });
+  const hasOrphans = drift.some((d) => d.orphans.length > 0);
+  const hint = hasOrphans
+    ? `run \`${bin} init\` to wire missing hooks; remove orphaned entries (renamed/dropped events) with \`${bin} deinit\` then \`${bin} init\``
+    : `run \`${bin} init\` to wire the new hook(s) (idempotent)`;
+  return { name: "harness hooks", severity: "warn", detail: parts.join("  |  "), hint };
+}
+
 function macOrLinux(mac: string, linux: string): string {
   return os.platform() === "darwin" ? mac : linux;
 }

package/src/commands/init.ts

@@ -23,12 +23,18 @@ import { fileURLToPath } from "node:url";
 import type { Command } from "commander";
 import type { EmitContext } from "../commander.ts";
 import { DEFAULT_BIN_NAME, stripJsonComments } from "../core/config.ts";
+import { HARNESS_SPECS, type HarnessId, type HarnessSpec } from "../core/hooks/harness/events.ts";
 import {
-  HARNESS_SPECS,
-  type HarnessId,
-  type HarnessSpec,
-  type HookEntryShape,
-} from "../core/hooks/harness/events.ts";
+  commandWiresSubcommand,
+  groupCommands,
+  type HookGroup,
+  makeEntry,
+  type SettingsFile,
+} from "../core/hooks/harness/wiring.ts";
+
+// Re-exported for back-compat: callers (deinit, tests) import these names
+// from init.ts. The definitions now live in core/hooks/harness/wiring.ts.
+export type { HookGroup, SettingsFile };
 
 // This file is src/commands/init.ts → harnery package root is two levels up.
 const HARNERY_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
@@ -39,25 +45,6 @@ interface InitOpts {
   projectRoot?: string;
 }
 
-/** Claude Code + Codex entry: `{ hooks: [{ type, command }] }`. */
-interface ClaudeHookGroup {
-  matcher?: string;
-  hooks: { type: string; command: string }[];
-}
-/** Cursor entry: a flat `{ command }`. */
-interface CursorHookGroup {
-  command: string;
-  type?: string;
-  matcher?: string;
-}
-type HookGroup = ClaudeHookGroup | CursorHookGroup;
-
-export interface SettingsFile {
-  version?: number;
-  hooks?: Record<string, HookGroup[]>;
-  [k: string]: unknown;
-}
-
 export function registerInitCommand(program: Command, emit: EmitContext, binName?: string): void {
   program
     .command("init")
@@ -173,7 +160,7 @@ export function wireHooks(
     const command = `bash ${agentHookPath} ${subcommand} --harness ${harness}`;
     const groups = settings.hooks[settingsKey] ?? [];
     const present = groups.some((g) =>
-      groupCommands(g).some((c) => c.includes(`agent-hook ${subcommand} `)),
+      groupCommands(g).some((c) => commandWiresSubcommand(c, subcommand)),
     );
     if (present) {
       already++;
@@ -217,20 +204,6 @@ export function unwireHooks(settings: SettingsFile): { removed: number; remainin
   return { removed, remaining };
 }
 
-/** Build a hook entry in the harness's shape. */
-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. */
-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 [];
-}
-
 /**
  * Idempotently record `binName` in `.harnery/config.jsonc`, preserving any
  * existing JSONC comments and the `files` section. Returns an action line, or

package/src/core/agents/coord-client.ts

@@ -361,13 +361,26 @@ export function selfDisplayName(): string {
 }
 
 function readPpid(pid: number): number | null {
+  // Linux/WSL fast path: /proc/<pid>/status carries `PPid:`.
   try {
     const status = readFileSync(`/proc/${pid}/status`, "utf8");
     const m = status.match(/^PPid:\s+(\d+)/m);
-    if (!m) return null;
-    const parsed = Number.parseInt(m[1]!, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+    if (m) {
+      const parsed = Number.parseInt(m[1]!, 10);
+      if (Number.isFinite(parsed) && parsed > 0) return parsed;
+    }
   } catch {
-    return null;
+    // 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 parsed = Number.parseInt(out.stdout.trim(), 10);
+      if (Number.isFinite(parsed) && parsed > 0) return parsed;
+    }
+  } catch {
+    // ps unavailable — give up
+  }
+  return null;
 }