harnery 0.31.6 → 0.33.0

package/src/core/agents/git-hook.ts

@@ -0,0 +1,126 @@
+/**
+ * Git-plumbing collection for `agent-coord git-hook <event>` — the in-process
+ * replacement for the bash that host pre-commit / post-commit / post-checkout
+ * hooks used to carry.
+ *
+ * Everything here is a port of hook logic that lived in host repos as shell:
+ * staged-path collection with rename handling, submodule canonicalization,
+ * the gitlink probe, and the clean-in-worktree checks that gate claim pruning.
+ * Owning it here means a harnery upgrade upgrades the behavior; the host hook
+ * file keeps only a stable managed region that invokes `git-hook <event>`.
+ *
+ * All functions take an explicit cwd and return data — no printing, no
+ * process.exit — so they unit-test against a temp repo.
+ */
+
+import { spawnSync } from "node:child_process";
+
+export type GitHookEvent = "pre-commit" | "post-commit" | "post-checkout";
+
+function git(args: string[], cwd: string): string {
+  const r = spawnSync("git", args, { cwd, encoding: "utf8", timeout: 5000 });
+  return r.status === 0 ? (r.stdout ?? "") : "";
+}
+
+/**
+ * The coordination root for a hook firing in `cwd`: the superproject when the
+ * repo is a submodule, else the repo's own toplevel. Pinning to the
+ * superproject matters because some submodules carry a config-only `.harnery/`
+ * that a cwd walk would land on, running the check against an empty claims dir.
+ */
+export function discoverCoordRoot(cwd: string): string | null {
+  const superproject = git(["rev-parse", "--show-superproject-working-tree"], cwd).trim();
+  if (superproject) return superproject;
+  const toplevel = git(["rev-parse", "--show-toplevel"], cwd).trim();
+  return toplevel || null;
+}
+
+/** Monorepo-relative prefix when `cwd` is inside a submodule ("" in the parent). */
+export function submodulePrefix(cwd: string): string {
+  const superproject = git(["rev-parse", "--show-superproject-working-tree"], cwd).trim();
+  if (!superproject) return "";
+  const toplevel = git(["rev-parse", "--show-toplevel"], cwd).trim();
+  if (!toplevel.startsWith(`${superproject}/`)) return "";
+  return toplevel.slice(superproject.length + 1);
+}
+
+/**
+ * Parse `--name-status -M` output into repo-local paths. Renames/copies emit
+ * BOTH sides so the source's claim releases too; plain statuses emit one.
+ */
+export function parseNameStatus(output: string): string[] {
+  const paths: string[] = [];
+  for (const line of output.split("\n")) {
+    if (!line.trim()) continue;
+    const parts = line.split("\t");
+    const status = parts[0] ?? "";
+    if (/^[RC]/.test(status)) {
+      if (parts[1]) paths.push(parts[1]);
+      if (parts[2]) paths.push(parts[2]);
+    } else if (parts[1]) {
+      paths.push(parts[1]);
+    }
+  }
+  return paths;
+}
+
+function canonicalize(paths: string[], prefix: string): string[] {
+  return prefix ? paths.map((p) => `${prefix}/${p}`) : [...paths];
+}
+
+/** Is this repo-local path a submodule gitlink (mode 160000) in the index? */
+function isGitlink(path: string, cwd: string): boolean {
+  return git(["ls-files", "--stage", "--", path], cwd).startsWith("160000 ");
+}
+
+/** Is this repo-local path clean in the worktree (no unstaged residue)? */
+function isCleanInWorktree(path: string, cwd: string): boolean {
+  return git(["status", "--porcelain", "--", path], cwd).trim() === "";
+}
+
+/**
+ * pre-commit: staged paths (canonical, monorepo-relative) plus which of them
+ * are submodule gitlinks — a parent-repo pointer bump is not a claim on the
+ * submodule's contents, and the conflict rule's prefix matcher needs to know.
+ */
+export function collectStaged(cwd: string): { staged: string[]; gitlinks: string[] } {
+  const out = git(["diff", "--cached", "--name-status", "-M"], cwd);
+  const local = parseNameStatus(out);
+  const prefix = submodulePrefix(cwd);
+  const staged = canonicalize(local, prefix);
+  const gitlinks: string[] = [];
+  for (let i = 0; i < local.length; i++) {
+    const l = local[i]!;
+    if (isGitlink(l, cwd)) gitlinks.push(staged[i]!);
+  }
+  return { staged, gitlinks };
+}
+
+/**
+ * post-commit: paths the just-landed HEAD commit touched that are now clean in
+ * the worktree. A path with unstaged residue keeps its claim — the agent is
+ * still mid-work on it.
+ */
+export function collectCommitted(cwd: string): string[] {
+  // --root: a repo's first commit has no parent; without it diff-tree emits
+  // nothing and the root commit's claims never prune (a bash-era blind spot).
+  const out = git(
+    ["diff-tree", "--no-commit-id", "--name-status", "-M", "-r", "--root", "HEAD"],
+    cwd,
+  );
+  const local = parseNameStatus(out).filter((p) => isCleanInWorktree(p, cwd));
+  return canonicalize(local, submodulePrefix(cwd));
+}
+
+/**
+ * post-checkout: paths the ref move rewrote that are now clean — a checkout
+ * that discarded an agent's edits should release its claims so a peer's later
+ * Edit isn't falsely blocked. `oldRef`/`newRef` are the hook's $1/$2.
+ */
+export function collectCheckoutRemoved(cwd: string, oldRef: string, newRef: string): string[] {
+  const from = oldRef || "0000000000000000000000000000000000000000";
+  const to = newRef || "HEAD";
+  const out = git(["diff", "--name-status", "-M", from, to], cwd);
+  const local = parseNameStatus(out).filter((p) => isCleanInWorktree(p, cwd));
+  return canonicalize(local, submodulePrefix(cwd));
+}

package/src/core/agents/index.ts

@@ -12,3 +12,4 @@
 export * from "./canonical-emit.js";
 export * from "./coord-client.js";
 export * from "./session-events.js";
+export * from "./state/session-state.js";

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

@@ -12,11 +12,12 @@
  *      + sorted(files_touched) + platform, sorted by instance_id).
  *   2. Council pending: pending open-council IDs hashed; re-emits when the
  *      ID set changes.
- *   3. Focus nudge. Before the first set-task in a human-facing session, tells
- *      every adapter to reproduce set-task's suggested session name in a fenced
- *      code block. Cursor/Codex additionally get the existing unset/stale-task
- *      reminder because their Stop hooks do not enforce task declarations as
- *      reliably as Claude Code's.
+ *   3. Focus nudge. Until the session has produced its suggested name (first
+ *      non-empty set-task), tells every adapter — on every prompt, undeduped —
+ *      to reproduce set-task's suggested session name in a fenced code block.
+ *      Cursor/Codex additionally get the existing unset/stale-task reminder
+ *      because their Stop hooks do not enforce task declarations as reliably
+ *      as Claude Code's.
  *   4. Codex status footer: a non-deduplicated reminder to put the live status
  *      box after the substantive answer. Stop stays observe-only, so missing the
  *      footer can never trigger a replacement response.
@@ -42,8 +43,9 @@ import {
 import { join } from "node:path";
 
 import { coordEnv } from "../../../lib/env.ts";
-import { resolveBinName } from "../../config.ts";
+import { endOfTurnStatusCommand, resolveBinName } from "../../config.ts";
 import { type RemoteMachine, readRemoteMachines } from "../../presence/index.ts";
+import type { AgentActivity, TaskState } from "../state/session-state.ts";
 import { formatPendingCouncils } from "./session-context.ts";
 
 interface HeartbeatRow {
@@ -58,7 +60,12 @@ interface HeartbeatRow {
   files_touched?: string[];
   platform?: string;
   task?: string;
+  activity?: AgentActivity;
+  task_state?: TaskState;
+  task_state_reason?: string;
   task_updated_at?: string;
+  suggested_session_name?: string;
+  session_name_seen_for?: string;
   turn_summary?: string;
   workflow_run_id?: string;
 }
@@ -77,6 +84,12 @@ export interface PromptContextOpts {
   /** When true, append the non-deduplicated Codex status-footer reminder.
    * The caller enables this only for human-facing Codex sessions. */
   statusFooterNudge?: boolean;
+  /** Adapter id whose Stop hook ENFORCES the end-of-turn ritual (task_set +
+   * status check). When set, append a fresh per-prompt reminder of that
+   * contract so the model satisfies it before ending the turn instead of
+   * being bounced into a retry. Not hash-deduped, same rationale as the
+   * status footer. */
+  turnRitualNudge?: string;
 }
 
 /**
@@ -96,6 +109,7 @@ export function renderPromptContext(opts: PromptContextOpts): string {
     sessionNameNudge,
     taskNudge,
     statusFooterNudge,
+    turnRitualNudge,
   } = opts;
   const sections: string[] = [];
 
@@ -128,17 +142,50 @@ export function renderPromptContext(opts: PromptContextOpts): string {
     if (statusMsg) sections.push(statusMsg);
   }
 
+  // 5. Adapters whose Stop hook ENFORCES the turn ritual get a fresh reminder
+  // on every prompt. Reminding before the reply is drafted is far cheaper than
+  // the bounce-and-retry the Stop hook otherwise forces: enforcement-only
+  // compliance was measured missing on a double-digit share of turns. Not
+  // hash-deduped for the same reason as the Codex footer.
+  if (turnRitualNudge) {
+    const ritualMsg = renderTurnRitualReminder(coordRoot, instanceId, turnRitualNudge);
+    if (ritualMsg) sections.push(ritualMsg);
+  }
+
   return sections.join("\n\n");
 }
 
-function renderStatusFooterReminder(coordRoot: string, selfInstanceId: string): string {
+function renderTurnRitualReminder(
+  coordRoot: string,
+  selfInstanceId: string,
+  adapter: string,
+): string {
   const hb = readHeartbeat(join(coordRoot, ".harnery", "active", `${selfInstanceId}.json`));
   if (!hb || hb.kind === "subagent" || hb.kind === "transient" || hb.workflow_run_id) return "";
 
   const bin = resolveBinName(coordRoot);
+  const statusCommand = endOfTurnStatusCommand(coordRoot);
+  // Claude Code renders the status box only if the reply carries it; Cursor
+  // shows the box inline on its own, so it is never asked for a second copy.
+  const paste =
+    adapter === "claude-code"
+      ? " and paste its output verbatim in a fenced code block at the end of your reply"
+      : "";
+  return (
+    `Turn ritual (Stop-enforced): on any turn that uses tools, run \`${bin} agents set-task "<short focus>"\` at some point during the turn (required every turn, even when the focus is unchanged; pass an empty string when there is no meaningful focus), then make \`${statusCommand}\` your final tool call${paste}. ` +
+    "A turn that ends without these is bounced by the Stop hook and costs a retry."
+  );
+}
+
+function renderStatusFooterReminder(coordRoot: string, selfInstanceId: string): string {
+  const hb = readHeartbeat(join(coordRoot, ".harnery", "active", `${selfInstanceId}.json`));
+  if (!hb || hb.kind === "subagent" || hb.kind === "transient" || hb.workflow_run_id) return "";
+
+  const statusCommand = endOfTurnStatusCommand(coordRoot);
   return (
     "Codex status footer: complete the user's request first. " +
-    `Then run \`${bin} agents status\` as your final shell call and append its stdout verbatim in a fenced code block at the bottom of the same substantive reply. ` +
+    `Then run \`${statusCommand}\` as your final shell call and append its stdout verbatim in a fenced code block at the bottom of the same substantive reply. ` +
+    "If it fails, finish the owned Git work and rerun it before replying. " +
     "Keep the answer intact. If the footer is missed, do not retry or replace the reply; the Stop hook is observe-only."
   );
 }
@@ -176,13 +223,21 @@ function computeFocusNudgeIfChanged(
   let message = "";
   let nudgeKind = "";
 
-  if (opts.sessionNameNudge && !hb.task_updated_at) {
+  if (
+    opts.sessionNameNudge &&
+    (!hb.suggested_session_name ||
+      (hb.session_name_seen_for !== undefined &&
+        hb.suggested_session_name !== hb.session_name_seen_for))
+  ) {
+    // Keyed on "a name was ever produced", not task_updated_at: a bare clear
+    // as the first declaration must not end the naming window.
     needsNudge = true;
     nudgeKind = "session-name";
-    message =
-      `New session: run \`${bin} agents set-task "<2-5 word session topic>"\` as your first tool call. ` +
-      "When it returns `first_of_session: true`, reproduce its `suggested_session_name` value by itself inside a fenced code block at the very top of your reply so the operator can one-click-copy it as the session/tab title. " +
-      "Then continue with the task; that first `set-task` also satisfies this turn's focus declaration.";
+    message = hb.suggested_session_name
+      ? `This session's lifecycle changed its suggested name. Reproduce this value by itself inside a fenced code block at the very top of your reply so the operator can one-click-copy it as the session/tab title: ${hb.suggested_session_name}`
+      : `This session has no name yet: run \`${bin} agents set-task "<2-5 word session topic>"\` as your first tool call. ` +
+        "When it returns `first_of_session: true`, reproduce its `suggested_session_name` value by itself inside a fenced code block at the very top of your reply so the operator can one-click-copy it as the session/tab title. " +
+        "Then continue with the task; that `set-task` also satisfies this turn's focus declaration.";
   } else if (opts.taskNudge && !taskValue) {
     needsNudge = true;
     nudgeKind = "task-unset";
@@ -207,8 +262,18 @@ function computeFocusNudgeIfChanged(
     return "";
   }
 
-  // Dedup on kind + task state so the first-session reminder does not turn into
-  // a generic "task unset" reminder on the next prompt before set-task runs.
+  // The session-name reminder is deliberately NOT deduped: it re-emits on
+  // every prompt until a name is produced, because the "still unnamed" state
+  // is the failure state — deduping it erases the only reminder after one
+  // ignored prompt (the miss mode operators reported). Bounded in practice:
+  // Stop rule 3/3 forces a set-task on the first tool-using turn.
+  if (nudgeKind === "session-name") {
+    clearHashFile(hashFile);
+    return message;
+  }
+
+  // Dedup the task-unset/stale reminders on kind + task state so a repeat
+  // prompt in the same state stays quiet.
   const state = `${nudgeKind}|task=${taskValue}|updated=${hb.task_updated_at ?? ""}|threshold=${threshold}`;
   const newHash = sha256Hex16(state);
   const oldHash = safeRead(hashFile);
@@ -254,6 +319,9 @@ function computePeerTableIfChanged(
       started_at: p.started_at ?? null,
       files_touched: Array.from(p.files_touched ?? []).sort(),
       platform: p.platform ?? null,
+      activity: p.activity ?? "unknown",
+      task_state: p.task_state ?? "active",
+      task_state_reason: p.task_state_reason ?? null,
     }))
     .sort((a, b) => (a.instance_id ?? "").localeCompare(b.instance_id ?? ""));
   // Remote basis: machine + per-agent identity/task/files (published_at is
@@ -264,6 +332,9 @@ function computePeerTableIfChanged(
       instance_id: a.instance_id,
       name: a.name ?? null,
       task: a.task ?? null,
+      activity: a.activity,
+      task_state: a.task_state,
+      task_state_reason: a.task_state_reason ?? null,
       files_touched: Array.from(a.files_touched ?? []).sort(),
     })),
   }));
@@ -478,6 +549,7 @@ function renderSubtable(
 
 function formatRow(r: HeartbeatRow & { display_files: string[] }, nowSec: number): string {
   const taskPart = r.task ? ` "${r.task.slice(0, 60)}"` : "";
+  const statePart = formatState(r);
   // Fall back started_at → last_heartbeat; if neither is a valid timestamp,
   // show "age unknown" rather than the epoch-derived "20608d ago" ghost.
   const startedSec = parseIsoSec(r.started_at) ?? parseIsoSec(r.last_heartbeat);
@@ -488,7 +560,15 @@ function formatRow(r: HeartbeatRow & { display_files: string[] }, nowSec: number
   // Prefer a short instance_id over a bare "unknown" so an incomplete row is
   // still identifiable.
   const label = r.name ?? (r.instance_id ? r.instance_id.slice(0, 8) : "unknown");
-  return `  - agent-${label}${taskPart}   (${ageFrom}, ${filesPart}${lastActivity})${turnSummary}`;
+  return `  - agent-${label}${taskPart}   (${statePart}, ${ageFrom}, ${filesPart}${lastActivity})${turnSummary}`;
+}
+
+function formatState(r: HeartbeatRow): string {
+  const activity = r.activity ?? "unknown";
+  const lifecycle = r.task_state ?? "active";
+  const reason =
+    lifecycle === "blocked" && r.task_state_reason ? `: ${r.task_state_reason.slice(0, 80)}` : "";
+  return `activity=${activity}, lifecycle=${lifecycle}${reason}`;
 }
 
 function fmtFiles(files: string[]): string {

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

@@ -13,6 +13,8 @@ import { join } from "node:path";
 import { resolveBinName, resolveHooksSetupHint } from "../../config.ts";
 import { harneryVersion, loadAdapterWiring } from "../../hooks/adapter/wiring.ts";
 import { readRemoteMachines } from "../../presence/index.ts";
+import { readForkParent } from "../state/names.ts";
+import type { AgentActivity, TaskState } from "../state/session-state.ts";
 
 interface HeartbeatRow {
   instance_id?: string;
@@ -26,6 +28,9 @@ interface HeartbeatRow {
   files_touched?: string[];
   platform?: string;
   task?: string;
+  activity?: AgentActivity;
+  task_state?: TaskState;
+  task_state_reason?: string;
   turn_summary?: string;
 }
 
@@ -54,7 +59,19 @@ export function renderSessionContext(opts: RenderOpts): string {
   const peerTable = [localTable, formatRemoteMachines(coordRoot)].filter(Boolean).join("\n\n");
   if (agentName) {
     const suffix = platformLabel ? ` (${platformLabel})` : "";
-    const selfLine = `You are agent-${agentName}${suffix}.`;
+    // The authority clause guards forked/branched chats. An adapter that forks a
+    // conversation copies the parent's transcript, so the fork's context still
+    // asserts the parent's name, claims, and task. When recorded fork lineage
+    // (.name-history forked_from) names the parent, say so specifically — the
+    // fork is about to read a transcript full of that exact name. Otherwise
+    // fall back to the generic clause, which needs no fork detection.
+    const forkParent = readForkParent(coordRoot, instanceId);
+    const authority = forkParent?.name
+      ? `This conversation was branched from agent-${forkParent.name}'s session: earlier context showing agent-${forkParent.name}'s name, task, or file claims belongs to the pre-fork session, not to you.`
+      : forkParent
+        ? `This conversation was branched from another session (${forkParent.instance_id}); any agent name in earlier context belongs to that session, not to you.`
+        : "Any different agent name in earlier context was inherited from another session; this one is authoritative.";
+    const selfLine = `You are agent-${agentName}${suffix}. ${authority}`;
     messages.push(peerTable ? `${selfLine}\n\n${peerTable}` : selfLine);
   } else if (peerTable) {
     messages.push(peerTable);
@@ -79,7 +96,7 @@ export function renderSessionContext(opts: RenderOpts): string {
     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).";
+      : `Run \`${resolveBinName(coordRoot)} init\` to install the harnery-managed git-hook regions (commit guard + claim pruning).`;
     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);
   }
@@ -122,8 +139,12 @@ function formatRemoteMachines(coordRoot: string): string {
         const files = a.files_touched?.length
           ? `holds: ${a.files_touched.slice(0, 3).join(", ")}${a.files_touched.length > 3 ? `, +${a.files_touched.length - 3} more` : ""}`
           : "nothing held";
+        const reason =
+          a.task_state === "blocked" && a.task_state_reason
+            ? `: ${a.task_state_reason.slice(0, 80)}`
+            : "";
         lines.push(
-          `  - agent-${a.name ?? a.instance_id.slice(0, 8)} @${m.machine}${task} (${files})`,
+          `  - agent-${a.name ?? a.instance_id.slice(0, 8)} @${m.machine}${task} (activity=${a.activity}, lifecycle=${a.task_state}${reason}, ${files})`,
         );
       }
     }
@@ -217,11 +238,15 @@ function renderSubtable(
 
 function formatRow(r: HeartbeatRow & { display_files: string[] }, nowSec: number): string {
   const taskPart = r.task ? ` "${r.task.slice(0, 60)}"` : "";
+  const activity = r.activity ?? "unknown";
+  const lifecycle = r.task_state ?? "active";
+  const reason =
+    lifecycle === "blocked" && r.task_state_reason ? `: ${r.task_state_reason.slice(0, 80)}` : "";
   const ageFrom = fmtAge(nowSec - parseIsoSec(r.started_at));
   const filesPart = fmtFiles(r.display_files);
   const lastActivity = fmtLastActivity(r, nowSec);
   const turnSummary = r.turn_summary ? `\n    last turn: ${r.turn_summary.slice(0, 80)}` : "";
-  return `  - agent-${r.name ?? "unknown"}${taskPart}   (${ageFrom}, ${filesPart}${lastActivity})${turnSummary}`;
+  return `  - agent-${r.name ?? "unknown"}${taskPart}   (activity=${activity}, lifecycle=${lifecycle}${reason}, ${ageFrom}, ${filesPart}${lastActivity})${turnSummary}`;
 }
 
 function fmtFiles(files: string[]): string {

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

@@ -271,8 +271,8 @@ function isFresh(lastHeartbeat: string): boolean {
  *  - diff shows non-empty output (genuinely dirty)
  */
 function isFileCommittedClean(coordRoot: string, relPath: string): boolean {
-  // Tolerate either path form: files_touched can hold absolute-under-coordRoot
-  // entries (legacy file-tracking) or canonical monorepo-relative ones.
+  // Tool payloads can provide either absolute-under-coordRoot or canonical
+  // monorepo-relative paths.
   const rel = relPath.startsWith(`${coordRoot}/`) ? relPath.slice(coordRoot.length + 1) : relPath;
   const abs = join(coordRoot, rel);
   if (!existsSync(abs)) return false;
@@ -305,7 +305,7 @@ function pruneClaimFromPeer(coordRoot: string, instanceId: string, relPath: stri
     const body = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
     const files = (body.files_touched as string[] | undefined) ?? [];
     // Normalize both sides: files_touched can hold absolute-under-coordRoot
-    // entries (legacy projections) as well as canonical relative ones — an
+    // entries as well as canonical relative ones — an
     // exact-string filter silently no-ops on the mixed-form case and the
     // stale claim never heals.
     const norm = (p: string): string =>

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

@@ -1,8 +1,8 @@
 /**
  * Pre-commit E-guard verdict. The caller (typically a bash pre-commit hook)
- * sends a JSON request with the staged paths, resolves its own instance_id
- * via pid-map, and prints the verdict messages + exits with
- * verdict.exit_code.
+ * sends a JSON request with the staged paths and prints the verdict
+ * messages + exits with verdict.exit_code. Committer identity is resolved
+ * HERE via `resolveOwner()` unless the request explicitly carries one.
  *
  * Three outcomes:
  *   1. allow (no conflicts): exit 0.
@@ -24,6 +24,7 @@ import { spawnSync } from "node:child_process";
 import { appendFileSync, existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { coordFreshnessSeconds } from "../../config.ts";
+import { resolveOwner } from "../../hooks/resolve/owner.ts";
 import { instanceHasLivePid } from "../state/pidmap.ts";
 
 interface PeerHeartbeat {
@@ -46,9 +47,16 @@ interface Conflict {
 }
 
 export interface CommitVerdictRequest {
-  instance_id: string;
-  /** Group key. Subagents inherit parent's session_id. */
-  session_id: string;
+  /**
+   * Committer identity. Optional: when absent (or the legacy
+   * `__unattributed__` sentinel), the verdict resolves it via
+   * `resolveOwner()` — env → pid-map walk → validated Codex thread id —
+   * from its own process context. Callers should stop hand-rolling
+   * identity resolution and omit this.
+   */
+  instance_id?: string;
+  /** Group key. Subagents inherit parent's session_id. Same optionality. */
+  session_id?: string;
   /** Canonical monorepo-relative paths. */
   staged_paths: string[];
   /** Paths in `staged_paths` that resolve to submodule gitlinks (mode 160000)
@@ -62,6 +70,8 @@ export interface CommitVerdictResult {
   allow: boolean;
   exit_code: number;
   rule: string;
+  /** The committer identity the verdict actually used (resolved or passed). */
+  instance_id: string;
   /** Conflict details (for the caller to print). */
   conflicts: Conflict[];
   /** Path-specific gates that fired (for `coord_log` lines). */
@@ -73,11 +83,24 @@ export interface CommitVerdictResult {
 }
 
 export function evaluateCommit(coordRoot: string, req: CommitVerdictRequest): CommitVerdictResult {
+  // Resolve the committer here, not in the calling hook. The bash shims used
+  // to carry their own pid-map walk (a pre-extraction fossil of resolveOwner);
+  // a hand-rolled copy can only fall behind as tiers are added, so the rule
+  // resolves identity from its own process context and callers just omit it.
+  const passed = req.instance_id?.trim();
+  const me =
+    passed && passed !== "__unattributed__"
+      ? passed
+      : (resolveOwner({ payload: null, coordRoot })?.instance_id ?? "__unattributed__");
+  const passedSession = req.session_id?.trim();
+  const mySession = passed && passedSession ? passedSession : me;
+
   if (req.staged_paths.length === 0) {
     return {
       allow: true,
       exit_code: 0,
       rule: "commit.pass",
+      instance_id: me,
       conflicts: [],
       log_lines: [],
       message: "",
@@ -91,9 +114,9 @@ export function evaluateCommit(coordRoot: string, req: CommitVerdictRequest): Co
 
   const conflicts: Conflict[] = [];
   for (const peer of peers) {
-    if (peer.instance_id === req.instance_id) continue;
+    if (peer.instance_id === me) continue;
     const peerSession = peer.session_id ?? peer.instance_id;
-    if (req.session_id && peerSession === req.session_id) continue; // same group
+    if (mySession !== "__unattributed__" && peerSession === mySession) continue; // same group
     const ts = peer.last_heartbeat ? Date.parse(peer.last_heartbeat) : 0;
     if (!Number.isFinite(ts) || ts < cutoffMs) continue; // stale
     const files = peer.files_touched ?? [];
@@ -118,6 +141,7 @@ export function evaluateCommit(coordRoot: string, req: CommitVerdictRequest): Co
       allow: true,
       exit_code: 0,
       rule: "commit.pass",
+      instance_id: me,
       conflicts: [],
       log_lines: [],
       message: "",
@@ -129,6 +153,7 @@ export function evaluateCommit(coordRoot: string, req: CommitVerdictRequest): Co
       allow: true,
       exit_code: 0,
       rule: "commit.bypass",
+      instance_id: me,
       conflicts,
       log_lines: conflicts.map(
         (c) => `COMMIT_BYPASSED  path=${c.staged_path} owner=${c.short_name}`,
@@ -149,6 +174,7 @@ export function evaluateCommit(coordRoot: string, req: CommitVerdictRequest): Co
       allow: true,
       exit_code: 0,
       rule: "commit.suppressed",
+      instance_id: me,
       conflicts,
       log_lines: conflicts.map(
         (c) =>
@@ -167,6 +193,7 @@ export function evaluateCommit(coordRoot: string, req: CommitVerdictRequest): Co
     allow: false,
     exit_code: 1,
     rule: "commit.conflict",
+    instance_id: me,
     conflicts,
     log_lines: conflicts.map((c) => `COMMIT_BLOCKED  path=${c.staged_path} owner=${c.short_name}`),
     message: