harnery 0.30.0 → 0.31.1

package/src/core/agents/cli.ts

@@ -182,13 +182,13 @@ async function emitClaimRelease(
     const { emit } = await import("./events/emit.ts");
     const canonical = path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path;
     const platform = hb.platform;
-    const harness =
+    const adapter =
       platform === "cursor" ? "cursor" : platform === "codex" ? "codex" : "claude-code";
     emit(root, {
       event_type: "claim.release",
       instance_id: owner,
       session_id: hb.session_id ?? owner,
-      harness,
+      adapter,
       source: "agent-coord",
       data: { path: canonical, reason },
     });
@@ -291,16 +291,16 @@ async function handleStateAction(root: string, action: string, rest: string[]):
       return 0;
     }
     case "heal-heartbeat": {
-      // harness arrives as a `--harness=<h>` flag (not positional) so the live
+      // adapter arrives as a `--adapter=<h>` flag (not positional) so the live
       // tool.pre_use heal and the manual `harn agents heal` path (which pass
       // different positional counts) can both supply it without arg-order
       // fragility. Positionals (sessionId, model) stay as-is once flags are
       // filtered out.
-      const harness = args.find((a) => a.startsWith("--harness="))?.slice("--harness=".length);
+      const adapter = args.find((a) => a.startsWith("--adapter="))?.slice("--adapter=".length);
       const positional = args.filter((a) => !a.startsWith("--"));
       const sessionId = positional[0];
       const model = positional[1];
-      const hb = writer.healHeartbeat(root, owner, sessionId, model, harness);
+      const hb = writer.healHeartbeat(root, owner, sessionId, model, adapter);
       process.stdout.write(`${JSON.stringify({ instance_id: owner, recreated: !!hb })}\n`);
       return hb ? 0 : 1;
     }
@@ -324,19 +324,19 @@ async function handleStateAction(root: string, action: string, rest: string[]):
   }
 }
 
-async function handleScratchAction(root: string, action: string, rest: string[]): Promise<number> {
-  const scratch = await import("./state/scratch.ts");
+async function handleJournalAction(root: string, action: string, rest: string[]): Promise<number> {
+  const journal = await import("./state/journal.ts");
 
-  if (action === "append-scratch") {
+  if (action === "append-journal") {
     const [owner, category, ...bodyParts] = rest;
     const body = bodyParts.join(" ");
     if (!owner || !category || !body) {
-      process.stderr.write("agent-coord append-scratch <instance_id> <category> <body>\n");
+      process.stderr.write("agent-coord append-journal <instance_id> <category> <body>\n");
       return 2;
     }
-    const result = scratch.appendScratch(root, owner, category, body);
+    const result = journal.appendJournal(root, owner, category, body);
     if (!result.ok) {
-      process.stderr.write(`agent-coord append-scratch: ${result.reason}\n`);
+      process.stderr.write(`agent-coord append-journal: ${result.reason}\n`);
       return 1;
     }
     process.stdout.write(
@@ -345,24 +345,22 @@ async function handleScratchAction(root: string, action: string, rest: string[])
     return 0;
   }
 
-  if (action === "edit-scratchpad") {
+  if (action === "edit-journal") {
     const [owner, newBodyFile, ...summaryParts] = rest;
     const summary = summaryParts.join(" ");
     if (!owner || !newBodyFile) {
-      process.stderr.write(
-        "agent-coord edit-scratchpad <instance_id> <new-body-file> [<summary>]\n",
-      );
+      process.stderr.write("agent-coord edit-journal <instance_id> <new-body-file> [<summary>]\n");
       return 2;
     }
     if (!existsSync(newBodyFile)) {
-      process.stderr.write(`agent-coord edit-scratchpad: file not found: ${newBodyFile}\n`);
+      process.stderr.write(`agent-coord edit-journal: file not found: ${newBodyFile}\n`);
       return 2;
     }
     const { readFileSync } = await import("node:fs");
     const newBody = readFileSync(newBodyFile, "utf8");
-    const result = scratch.editScratchpad(root, owner, newBody, summary);
+    const result = journal.editJournal(root, owner, newBody, summary);
     if (!result.ok) {
-      process.stderr.write(`agent-coord edit-scratchpad: ${result.reason}\n`);
+      process.stderr.write(`agent-coord edit-journal: ${result.reason}\n`);
       return 1;
     }
     process.stdout.write(
@@ -371,7 +369,7 @@ async function handleScratchAction(root: string, action: string, rest: string[])
     return 0;
   }
 
-  process.stderr.write(`agent-coord: unknown scratch action ${action}\n`);
+  process.stderr.write(`agent-coord: unknown journal action ${action}\n`);
   return 2;
 }
 
@@ -566,7 +564,7 @@ async function handleShellMutationClaimLog(root: string, rest: string[]): Promis
   // in a log file; now a canonical decision.warn so the
   // signal survives in events.ndjson. (The blocking claim-conflict path is
   // separate: claim.conflict / verdict, and unaffected.)
-  const harness = platform === "cursor" ? "cursor" : platform === "codex" ? "codex" : "claude-code";
+  const adapter = platform === "cursor" ? "cursor" : platform === "codex" ? "codex" : "claude-code";
   const hb = owner ? readHeartbeat(root, owner) : null;
   for (const p of paths) {
     try {
@@ -574,7 +572,7 @@ async function handleShellMutationClaimLog(root: string, rest: string[]): Promis
         event_type: "decision.warn",
         instance_id: owner ?? "unknown",
         session_id: hb?.session_id ?? owner ?? "unknown",
-        harness,
+        adapter,
         data: {
           rule: "shell_mutation_candidate",
           reason: `path=${p} cmd=${truncated} platform=${platform}`,
@@ -612,10 +610,12 @@ async function handlePromptContext(root: string, rest: string[]): Promise<number
   const instanceId = args.instance;
   const sessionId = args.session ?? instanceId;
   const agentName = args.name;
+  const sessionNameNudge = args["session-name-nudge"] === "true";
   const taskNudge = args["task-nudge"] === "true";
+  const statusFooterNudge = args["status-footer-nudge"] === "true";
   if (!instanceId) {
     process.stderr.write(
-      "agent-coord prompt-context --instance <id> [--session <id>] [--name <agent-name>] [--task-nudge]\n",
+      "agent-coord prompt-context --instance <id> [--session <id>] [--name <agent-name>] [--session-name-nudge] [--task-nudge] [--status-footer-nudge]\n",
     );
     return 2;
   }
@@ -625,7 +625,9 @@ async function handlePromptContext(root: string, rest: string[]): Promise<number
     instanceId,
     sessionId: sessionId!,
     agentName,
+    sessionNameNudge,
     taskNudge,
+    statusFooterNudge,
   });
   process.stdout.write(text);
   return 0;
@@ -743,12 +745,12 @@ async function handleEmitEvent(root: string, rest: string[]): Promise<number> {
   const eventType = args.type;
   const instanceId = args.owner;
   const sessionId = args.session;
-  const harness = args.harness as "claude-code" | "cursor" | "codex" | undefined;
+  const adapter = args.adapter as "claude-code" | "cursor" | "codex" | undefined;
   const dataJson = args["data-json"] ?? "{}";
 
-  if (!eventType || !instanceId || !sessionId || !harness) {
+  if (!eventType || !instanceId || !sessionId || !adapter) {
     process.stderr.write(
-      "agent-coord emit-event --type <T> --owner <id> --session <id> --harness <h> [--data-json '<json>']\n",
+      "agent-coord emit-event --type <T> --owner <id> --session <id> --adapter <h> [--data-json '<json>']\n",
     );
     return 2;
   }
@@ -774,7 +776,7 @@ async function handleEmitEvent(root: string, rest: string[]): Promise<number> {
       event_type: eventType,
       instance_id: instanceId,
       session_id: sessionId,
-      harness,
+      adapter,
       turn_id: args["turn-id"],
       parent_session_id: args["parent-session-id"],
       parent_turn_id: args["parent-turn-id"],
@@ -822,8 +824,8 @@ async function main(): Promise<number> {
     return handleStateAction(root, subcommand, rest);
   }
 
-  if (subcommand === "append-scratch" || subcommand === "edit-scratchpad") {
-    return handleScratchAction(root, subcommand, rest);
+  if (subcommand === "append-journal" || subcommand === "edit-journal") {
+    return handleJournalAction(root, subcommand, rest);
   }
 
   if (

package/src/core/agents/codex-replay.ts

@@ -4,7 +4,7 @@
  * Production codex sessions emit canonical events from each `harn` invocation
  * via the in-process session-tee middleware (which calls `agent-coord
  * emit-event` for state.task_set / state.status_checked). But the codex
- * harness itself doesn't wire agent-hook on preToolUse, so user_prompt.submit
+ * adapter itself doesn't wire agent-hook on preToolUse, so user_prompt.submit
  * + tool.pre_use + turn.stop aren't emitted live.
  *
  * This module parses the Codex JSONL transcript at stop time and emits the
@@ -71,7 +71,7 @@ export function replayCodexJsonl(opts: CodexReplayOpts): { emitted: number } {
         event_type: "user_prompt.submit",
         instance_id: instanceId,
         session_id: sessionId,
-        harness: "codex",
+        adapter: "codex",
         ts,
         data: {
           prompt_text: clamp(entry.payload.message ?? "", 4000),
@@ -97,7 +97,7 @@ export function replayCodexJsonl(opts: CodexReplayOpts): { emitted: number } {
         event_type: "tool.pre_use",
         instance_id: instanceId,
         session_id: sessionId,
-        harness: "codex",
+        adapter: "codex",
         ts,
         data: {
           tool_name: name === "exec_command" ? "Bash" : name,
@@ -117,7 +117,7 @@ export function replayCodexJsonl(opts: CodexReplayOpts): { emitted: number } {
           event_type: "state.status_checked",
           instance_id: instanceId,
           session_id: sessionId,
-          harness: "codex",
+          adapter: "codex",
           ts,
           data: { source: "codex-replay" },
         });
@@ -128,7 +128,7 @@ export function replayCodexJsonl(opts: CodexReplayOpts): { emitted: number } {
           event_type: "state.task_set",
           instance_id: instanceId,
           session_id: sessionId,
-          harness: "codex",
+          adapter: "codex",
           ts,
           data: { source: "codex-replay" },
         });
@@ -145,7 +145,7 @@ export function replayCodexJsonl(opts: CodexReplayOpts): { emitted: number } {
     event_type: "turn.stop",
     instance_id: instanceId,
     session_id: sessionId,
-    harness: "codex",
+    adapter: "codex",
     data: {
       status_box_present: boxPresent,
       tool_call_count: -1,

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

@@ -0,0 +1,92 @@
+/**
+ * Locate harnery's own bundled coordination binaries (`agent-coord`,
+ * `agent-hook`, `harn`).
+ *
+ * Every coord-helper spawn used to build its path as
+ * `<coordRoot>/harnery/bin/<name>`, which only exists in one host layout: a
+ * superproject carrying harnery as a submodule at `harnery/`. That assumption
+ * was load-bearing in the worst way — because the path missed whenever the
+ * resolved root was anything else, root resolution itself was bent toward the
+ * git superproject to keep the spawns working, which is what split the CLI's
+ * root from the hook's and blocked end-of-turn rule 1/3. The same missing path
+ * also surfaced as a crash rather than an error: `spawnSync` on a nonexistent
+ * binary reports `status: null` and `stderr: null`, so a caller checking
+ * `status !== 0` then reading `stderr.trim()` threw "null is not an object".
+ *
+ * The binaries ship inside the harnery package, so the package is what knows
+ * where they are. Resolution walks up from this module to the package root,
+ * which covers every install shape: `src/` under Bun, `dist/` on Node, and
+ * `node_modules/harnery/`. The layout-specific paths remain as fallbacks so a
+ * host whose harnery copy is not the one executing (a vendored tree, a shim)
+ * still resolves.
+ */
+
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { coordEnv } from "../../lib/env.ts";
+
+export type CoordBinName = "agent-coord" | "agent-hook" | "harn";
+
+/**
+ * Absolute path to one of harnery's bundled binaries, or null when no candidate
+ * exists on disk. Callers must handle null — a missing helper is a real state
+ * (a partially installed package) and silently spawning a nonexistent path is
+ * what produced the null-deref crash above.
+ */
+export function coordBinPath(name: CoordBinName, coordRoot?: string | null): string | null {
+  for (const candidate of coordBinCandidates(name, coordRoot)) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+/** Candidate paths for `name`, in resolution order. Exported for tests. */
+export function coordBinCandidates(name: CoordBinName, coordRoot?: string | null): string[] {
+  const candidates: string[] = [];
+  const push = (value: string | null | undefined) => {
+    if (value && !candidates.includes(value)) candidates.push(value);
+  };
+
+  // Explicit pin, for a host that relocates the binaries.
+  const pinned = coordEnv("BIN_DIR");
+  if (pinned) push(join(pinned, name));
+
+  // The package this code is executing from.
+  const pkgRoot = packageRoot(name);
+  if (pkgRoot) push(join(pkgRoot, "bin", name));
+
+  if (coordRoot) {
+    // Host layouts, in decreasing specificity: harnery as a submodule, as an
+    // installed dependency, or the coord root being harnery's own checkout.
+    push(resolve(coordRoot, "harnery", "bin", name));
+    push(resolve(coordRoot, "node_modules", "harnery", "bin", name));
+    push(resolve(coordRoot, "bin", name));
+  }
+
+  return candidates;
+}
+
+/**
+ * Walk up from this module to the directory holding `bin/<name>`.
+ *
+ * The walk keys on the binary itself rather than on `package.json`, because
+ * both `src/core/agents/` and the built `dist/core/agents/` sit under the same
+ * package root and only the binary's presence proves we found the right level.
+ */
+function packageRoot(name: CoordBinName): string | null {
+  let dir: string;
+  try {
+    dir = dirname(fileURLToPath(import.meta.url));
+  } catch {
+    // No import.meta (a CJS transpile); the coordRoot fallbacks still apply.
+    return null;
+  }
+  for (let hop = 0; hop < 8; hop++) {
+    if (existsSync(join(dir, "bin", name))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}