harnery 0.8.0 → 0.10.0

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

@@ -24,6 +24,8 @@ export interface V2Heartbeat {
   platform?: string;
   subagent_call_id?: string;
   parent_session_id?: string;
+  /** Set iff this owner is a `workflow run` child (joins to the run journal). */
+  workflow_run_id?: string;
   started_at?: string;
   last_heartbeat: string;
   last_tool?: string;
@@ -144,7 +146,8 @@ function seed(ev: CanonicalEvent, coordRoot: string): V2Heartbeat {
     if (resolved) {
       hb.name = resolved.name;
       hb.kind = resolved.kind;
-      if (resolved.kind === "subagent") hb.agent_id = ev.instance_id;
+      hb.agent_id =
+        resolved.agent_id ?? (resolved.kind === "subagent" ? ev.instance_id : undefined);
     }
   } catch {
     /* name-history unavailable: seed stays nameless; sweep + render guards cope */
@@ -184,6 +187,8 @@ function apply(hb: V2Heartbeat, ev: CanonicalEvent, coordRoot: string): void {
         if (subagentCallId) hb.subagent_call_id = subagentCallId;
         const parentSession = pickStr(d, "parent_session_id");
         if (parentSession) hb.parent_session_id = parentSession;
+        const workflowRunId = pickStr(d, "workflow_run_id");
+        if (workflowRunId) hb.workflow_run_id = workflowRunId;
         if (!hb.files_touched) hb.files_touched = [];
       }
       break;
@@ -248,8 +253,15 @@ function apply(hb: V2Heartbeat, ev: CanonicalEvent, coordRoot: string): void {
       if (toolName === "Edit" || toolName === "Write" || toolName === "NotebookEdit") {
         const target = extractFilePath(d);
         if (target) {
+          // Canonicalize to repo-relative before storing: the claim guard
+          // writes canonical paths directly, so an absolute entry here would
+          // double-count the same file (inflated "N files" display) and
+          // defeat exact-match pruning on commit.
+          const canonical = target.startsWith(`${coordRoot}/`)
+            ? target.slice(coordRoot.length + 1)
+            : target;
           if (!hb.files_touched) hb.files_touched = [];
-          if (!hb.files_touched.includes(target)) hb.files_touched.push(target);
+          if (!hb.files_touched.includes(canonical)) hb.files_touched.push(canonical);
         }
       }
       break;
@@ -276,6 +288,14 @@ function apply(hb: V2Heartbeat, ev: CanonicalEvent, coordRoot: string): void {
       hb.last_status_at = ev.ts;
       break;
 
+    case "identity.assumed": {
+      const name = pickStr(d, "name");
+      const agentId = pickStr(d, "agent_id");
+      if (name) hb.name = name;
+      if (agentId) hb.agent_id = agentId;
+      break;
+    }
+
     case "state.presence_change": {
       const to = pickStr(d, "to");
       if (to === "mobile" || to === "office") hb.presence = to;
@@ -437,6 +457,7 @@ function writeHeartbeat(coordRoot: string, instanceId: string, hb: V2Heartbeat):
     setIfDefined(merged, "kind", hb.kind);
     setIfDefined(merged, "agent_id", hb.agent_id);
     setIfDefined(merged, "subagent_call_id", hb.subagent_call_id);
+    setIfDefined(merged, "workflow_run_id", hb.workflow_run_id);
     setIfDefined(merged, "model", hb.model);
     setIfDefined(merged, "platform", hb.platform);
     setIfDefined(merged, "started_at", hb.started_at);

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

@@ -184,20 +184,39 @@ export function releaseClaim(
   }));
 }
 
+/** A heartbeat that actually dropped a path during a group unclaim. */
+export interface GroupUnclaimHit {
+  instance_id: string;
+  session_id?: string;
+  platform?: string;
+}
+
 /**
  * Session-group-wide unclaim. Walks every heartbeat sharing `groupId`
  * (parent's session_id == group_id;
  * subagents inherit it) and removes the path from each one's files_touched.
- * Idempotent: heartbeats that don't hold the path are untouched.
+ * Idempotent: heartbeats that don't hold the path are untouched. Returns the
+ * heartbeats that actually dropped the path so the caller can emit the
+ * durable `claim.release` events — a file-only prune is silently reverted by
+ * the next projector replay.
+ *
+ * files_touched can hold either absolute-under-coordRoot or canonical
+ * repo-relative entries (legacy projections stored the raw tool_input path),
+ * so both sides are normalized before comparing — an exact-string match
+ * silently no-ops on the mixed-form case and the claim never releases.
  *
  * This is the Option B fix for post-commit's pid-map attribution hole: a
  * subagent-held claim that doesn't live on the parent's heartbeat still gets
  * pruned because the walk covers the whole group.
  */
-export function groupUnclaim(coordRoot: string, groupId: string, path: string): void {
-  if (!groupId || !path) return;
+export function groupUnclaim(coordRoot: string, groupId: string, path: string): GroupUnclaimHit[] {
+  const hits: GroupUnclaimHit[] = [];
+  if (!groupId || !path) return hits;
   const activeDir = join(coordRoot, ".harnery", "active");
-  if (!existsSync(activeDir)) return;
+  if (!existsSync(activeDir)) return hits;
+  const norm = (p: string): string =>
+    p.startsWith(`${coordRoot}/`) ? p.slice(coordRoot.length + 1) : p;
+  const target = norm(path);
   for (const f of readdirSync(activeDir)) {
     if (!f.endsWith(".json")) continue;
     const hbPath = join(activeDir, f);
@@ -211,17 +230,23 @@ export function groupUnclaim(coordRoot: string, groupId: string, path: string):
       (body.session_id as string | undefined) ?? (body.instance_id as string | undefined);
     if (peerSession !== groupId) continue;
     const files = (body.files_touched as string[] | undefined) ?? [];
-    const next = files.filter((p) => p !== path);
+    const next = files.filter((p) => norm(p) !== target);
     if (next.length === files.length) continue;
     body.files_touched = next;
     try {
       const tmp = `${hbPath}.tmp.${process.pid}`;
       writeFileSync(tmp, JSON.stringify(body, null, 2), "utf8");
       renameSync(tmp, hbPath);
+      hits.push({
+        instance_id: (body.instance_id as string | undefined) ?? f.replace(/\.json$/, ""),
+        session_id: body.session_id as string | undefined,
+        platform: body.platform as string | undefined,
+      });
     } catch {
       /* silent */
     }
   }
+  return hits;
 }
 
 export function killHeartbeat(coordRoot: string, instanceId: string): boolean {
@@ -286,8 +311,9 @@ export function healHeartbeat(
     if (resolved) {
       name = resolved.name;
       kind = resolved.kind;
-      // subagent kind: agent_id == instance_id. Else (session/transient): no id stamp.
-      if (resolved.kind === "subagent") agentId = instanceId;
+      // An explicitly assumed session carries its durable persona UUID in
+      // name-history. Native subagents continue to use instance_id.
+      agentId = resolved.agent_id ?? (resolved.kind === "subagent" ? instanceId : "");
     }
   } catch {
     /* names module unavailable, fall back to empty */

package/src/core/agents/state/names.ts

@@ -8,9 +8,14 @@
  * Durable persistence: `.harnery/.name-history` (JSONL, one row per assignment)
  * + `.harnery/.name-counter` (current counter, atomic temp+rename).
  *
- * Recreation rule (mirrors v1):
- *   1. Own instance_id in name-history → (original name, original kind)
- *   2. session_id in name-history (owner != session) → (parent's name, "transient")
+ * Recreation rule:
+ *   1. Own instance_id in name-history → latest (name, kind, agent_id)
+ *   2. session_id in name-history (owner != session) → latest parent's
+ *      (name, agent_id) with kind="transient"
+ *
+ * Multiple rows for one instance are intentional. `identity assume` appends a
+ * new binding instead of rewriting history; readers therefore resolve from the
+ * end of the file. Older one-row histories retain their original behavior.
  *   3. Else: new assignment, consume a counter slot.
  */
 
@@ -297,11 +302,16 @@ if (COORD_NAMES.length !== 260) {
 
 export type NameKind = "session" | "subagent" | "transient";
 
-interface NameHistoryRow {
+export interface NameHistoryRow {
   instance_id: string;
   name: string;
   kind: NameKind;
   ts: string;
+  /** Durable persona UUID. Present after `agents identity assume`. */
+  agent_id?: string;
+  /** Audit marker distinguishing an explicit role adoption from pool assignment. */
+  source?: "pool" | "identity.assume";
+  previous_name?: string;
 }
 
 function atomicWrite(path: string, content: string): void {
@@ -351,19 +361,29 @@ export function resolveName(
   coordRoot: string,
   instanceId: string,
   sessionId?: string,
-): { name: string; kind: NameKind } | null {
+): { name: string; kind: NameKind; agent_id?: string } | null {
   const history = readHistory(coordRoot);
 
-  for (const row of history) {
+  for (let i = history.length - 1; i >= 0; i--) {
+    const row = history[i]!;
     if (row.instance_id === instanceId) {
-      return { name: row.name, kind: row.kind };
+      return {
+        name: row.name,
+        kind: row.kind,
+        ...(row.agent_id ? { agent_id: row.agent_id } : {}),
+      };
     }
   }
 
   if (sessionId && sessionId !== instanceId) {
-    for (const row of history) {
+    for (let i = history.length - 1; i >= 0; i--) {
+      const row = history[i]!;
       if (row.instance_id === sessionId) {
-        return { name: row.name, kind: "transient" };
+        return {
+          name: row.name,
+          kind: "transient",
+          ...(row.agent_id ? { agent_id: row.agent_id } : {}),
+        };
       }
     }
   }
@@ -371,6 +391,44 @@ export function resolveName(
   return null;
 }
 
+export interface NameAssumptionResult {
+  changed: boolean;
+  previous: { name: string; kind: NameKind; agent_id?: string } | null;
+  current: { name: string; kind: NameKind; agent_id: string };
+}
+
+/**
+ * Append an explicit instance → durable-persona binding. Latest-row-wins makes
+ * this auditable and retry-safe without mutating prior assignment history.
+ */
+export function recordNameAssumption(
+  coordRoot: string,
+  instanceId: string,
+  name: string,
+  agentId: string,
+  kind: NameKind = "session",
+): NameAssumptionResult {
+  const previous = resolveName(coordRoot, instanceId);
+  const current = { name, kind, agent_id: agentId };
+  if (
+    previous?.name === current.name &&
+    previous.kind === current.kind &&
+    previous.agent_id === current.agent_id
+  ) {
+    return { changed: false, previous, current };
+  }
+  appendHistory(coordRoot, {
+    instance_id: instanceId,
+    name,
+    kind,
+    agent_id: agentId,
+    source: "identity.assume",
+    previous_name: previous?.name,
+    ts: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+  });
+  return { changed: true, previous, current };
+}
+
 /**
  * Assign a name to <instanceId> with the given <kind>. Counter-consuming when
  * the owner is new. Idempotent: returns existing name on resume.
@@ -393,6 +451,7 @@ export function assignName(coordRoot: string, instanceId: string, kind: NameKind
     instance_id: instanceId,
     name,
     kind,
+    source: "pool",
     ts: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
   });
   return name;

package/src/core/agents/state/pidmap.ts

@@ -1,5 +1,5 @@
 /**
- * Pid-map writer.
+ * Pid-map writer + liveness helpers.
  *
  * Per-harness pid-map at `.harnery/pid-map/<pid>` containing
  * `<instance_id>\t<platform>`. `harn agents whoami` walks ppid up 20 hops looking
@@ -8,7 +8,15 @@
  * Atomic temp+rename. Idempotent: re-writing the same row is a no-op.
  */
 
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { dirname, join } from "node:path";
 
 function atomicWrite(path: string, content: string): void {
@@ -36,3 +44,52 @@ export function writePidmapRow(
   }
   atomicWrite(path, row);
 }
+
+/** True when any pid-map row for `instanceId` still belongs to a live process. */
+export function instanceHasLivePid(coordRoot: string, instanceId: string): boolean {
+  const dir = join(coordRoot, ".harnery", "pid-map");
+  if (!existsSync(dir)) return false;
+  for (const f of readdirSync(dir)) {
+    let row = "";
+    try {
+      row = readFileSync(join(dir, f), "utf8").trim();
+    } catch {
+      continue;
+    }
+    const owner = row.split("\t")[0]?.trim() ?? "";
+    if (owner !== instanceId) continue;
+    const pid = Number.parseInt(f, 10);
+    if (!Number.isFinite(pid)) continue;
+    try {
+      process.kill(pid, 0); // signal 0 = liveness probe
+      return true;
+    } catch {
+      // ESRCH (no such process): pid-map entry is stale, keep scanning
+    }
+  }
+  return false;
+}
+
+/** Drop every pid-map row owned by `instanceId`. Returns how many files were removed. */
+export function removePidmapRowsForInstance(coordRoot: string, instanceId: string): number {
+  const dir = join(coordRoot, ".harnery", "pid-map");
+  if (!existsSync(dir)) return 0;
+  let removed = 0;
+  for (const f of readdirSync(dir)) {
+    let row = "";
+    try {
+      row = readFileSync(join(dir, f), "utf8").trim();
+    } catch {
+      continue;
+    }
+    const owner = row.split("\t")[0]?.trim() ?? "";
+    if (owner !== instanceId) continue;
+    try {
+      unlinkSync(join(dir, f));
+      removed += 1;
+    } catch {
+      /* best-effort cleanup */
+    }
+  }
+  return removed;
+}

package/src/core/agents/state/stale-sweep.ts

@@ -5,17 +5,16 @@
  * Fires at session.start to clean up crashed-peer detritus before the new
  * session's UX layer reads peer state.
  *
- * Freshness threshold defaults to 600s; configurable via
- * HARNERY_AGENT_COORD_FRESHNESS env var.
+ * Freshness threshold defaults to 600s; configurable via the
+ * HARNERY_AGENT_COORD_FRESHNESS env var or `.harnery/config.jsonc`
+ * `coord.freshness_seconds` (see `coordFreshnessSeconds`).
  */
 
 import { existsSync, readdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { coordEnv } from "../../../lib/env.ts";
+import { coordFreshnessSeconds } from "../../config.ts";
 import { emit } from "../events/emit.ts";
 
-const DEFAULT_FRESHNESS_SECS = 600;
-
 /** platform → harness, for the swept-event envelope (mirrors heartbeat-writer's harnessOf). */
 function harnessFromPlatform(platform: unknown): "claude-code" | "cursor" | "codex" {
   if (platform === "cursor") return "cursor";
@@ -65,13 +64,9 @@ export function staleSweep(coordRoot: string): {
   let pidmapsRemoved = 0;
   let peerHashesRemoved = 0;
 
-  const freshness = Number.parseInt(
-    coordEnv("AGENT_COORD_FRESHNESS") ?? String(DEFAULT_FRESHNESS_SECS),
-    10,
-  );
+  const freshness = coordFreshnessSeconds(coordRoot);
   const nowSec = Math.floor(Date.now() / 1000);
-  const cutoff =
-    nowSec - (Number.isFinite(freshness) && freshness > 0 ? freshness : DEFAULT_FRESHNESS_SECS);
+  const cutoff = nowSec - freshness;
 
   // 1. Prune stale heartbeats from the canonical `.harnery/active/` dir.
   //