harnery 0.31.6 → 0.33.0

package/dist/core/agents/render/prompt-context.js

@@ -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.
@@ -32,7 +33,7 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { coordEnv } from "../../../lib/env.js";
-import { resolveBinName } from "../../config.js";
+import { endOfTurnStatusCommand, resolveBinName } from "../../config.js";
 import { readRemoteMachines } from "../../presence/index.js";
 import { formatPendingCouncils } from "./session-context.js";
 /**
@@ -44,7 +45,7 @@ import { formatPendingCouncils } from "./session-context.js";
  * councils are pending, matching the bash behavior).
  */
 export function renderPromptContext(opts) {
-    const { coordRoot, instanceId, sessionId, agentName, sessionNameNudge, taskNudge, statusFooterNudge, } = opts;
+    const { coordRoot, instanceId, sessionId, agentName, sessionNameNudge, taskNudge, statusFooterNudge, turnRitualNudge, } = opts;
     const sections = [];
     // 1. Peer table with hash dedup.
     const peerTable = computePeerTableIfChanged(coordRoot, instanceId, sessionId);
@@ -75,15 +76,40 @@ export function renderPromptContext(opts) {
         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, selfInstanceId) {
+function renderTurnRitualReminder(coordRoot, selfInstanceId, adapter) {
     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, selfInstanceId) {
+    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.");
 }
 /**
@@ -114,13 +140,19 @@ function computeFocusNudgeIfChanged(coordRoot, selfInstanceId, opts) {
     let needsNudge = false;
     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. ` +
+        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 first `set-task` also satisfies this turn's focus declaration.";
+                "Then continue with the task; that `set-task` also satisfies this turn's focus declaration.";
     }
     else if (opts.taskNudge && !taskValue) {
         needsNudge = true;
@@ -145,8 +177,17 @@ function computeFocusNudgeIfChanged(coordRoot, selfInstanceId, opts) {
         clearHashFile(hashFile);
         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);
@@ -191,6 +232,9 @@ function computePeerTableIfChanged(coordRoot, selfInstanceId, selfSessionIdFallb
         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
@@ -201,6 +245,9 @@ function computePeerTableIfChanged(coordRoot, selfInstanceId, selfSessionIdFallb
             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(),
         })),
     }));
@@ -380,6 +427,7 @@ function renderSubtable(rows, header, nowSec) {
 }
 function formatRow(r, nowSec) {
     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);
@@ -390,7 +438,13 @@ function formatRow(r, nowSec) {
     // 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) {
+    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) {
     if (files.length === 0)

package/dist/core/agents/render/session-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/session-context.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAyC,QAAQ,EAAE,MAAM,SAAS,CAAC;AAqB1E,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;+BAC2B;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAiE7D;AA+ID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBvD;AAwDD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAiDlF;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,iBAAW,CAAC"}
+{"version":3,"file":"session-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/session-context.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAyC,QAAQ,EAAE,MAAM,SAAS,CAAC;AA0B1E,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;+BAC2B;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CA6E7D;AAuJD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBvD;AAwDD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAiDlF;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,iBAAW,CAAC"}

package/dist/core/agents/render/session-context.js

@@ -12,6 +12,7 @@ import { join } from "node:path";
 import { resolveBinName, resolveHooksSetupHint } from "../../config.js";
 import { harneryVersion, loadAdapterWiring } from "../../hooks/adapter/wiring.js";
 import { readRemoteMachines } from "../../presence/index.js";
+import { readForkParent } from "../state/names.js";
 /**
  * Build the combined SessionStart systemMessage. Returns the additionalContext
  * string (or "" if there's nothing to say).
@@ -26,7 +27,19 @@ export function renderSessionContext(opts) {
     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) {
@@ -48,7 +61,7 @@ export function renderSessionContext(opts) {
         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);
     }
@@ -88,7 +101,10 @@ function formatRemoteMachines(coordRoot) {
                 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";
-                lines.push(`  - agent-${a.name ?? a.instance_id.slice(0, 8)} @${m.machine}${task} (${files})`);
+                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} (activity=${a.activity}, lifecycle=${a.task_state}${reason}, ${files})`);
             }
         }
         return `Sessions on other machines (advisory, via presence refs):\n${lines.join("\n")}`;
@@ -166,11 +182,14 @@ function renderSubtable(rows, header, nowSec) {
 }
 function formatRow(r, nowSec) {
     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) {
     if (files.length === 0)

package/dist/core/agents/rules/claim-conflict.js

@@ -232,8 +232,8 @@ function isFresh(lastHeartbeat) {
  *  - diff shows non-empty output (genuinely dirty)
  */
 function isFileCommittedClean(coordRoot, relPath) {
-    // 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))
@@ -269,7 +269,7 @@ function pruneClaimFromPeer(coordRoot, instanceId, relPath) {
         const body = JSON.parse(readFileSync(path, "utf8"));
         const files = body.files_touched ?? [];
         // 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) => p.startsWith(`${coordRoot}/`) ? p.slice(coordRoot.length + 1) : p;

package/dist/core/agents/rules/commit-conflict.d.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.
@@ -30,9 +30,16 @@ interface Conflict {
     short_name: string;
 }
 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)
@@ -45,6 +52,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). */

package/dist/core/agents/rules/commit-conflict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commit-conflict.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/commit-conflict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAgBH,UAAU,QAAQ;IAChB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAC;IACnB,yCAAyC;IACzC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;wEACoE;IACpE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,oBAAoB,GAAG,mBAAmB,CAsGhG"}
+{"version":3,"file":"commit-conflict.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/commit-conflict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAiBH,UAAU,QAAQ;IAChB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,YAAY,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB;wEACoE;IACpE,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,WAAW,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,oBAAoB,GAAG,mBAAmB,CAuHhG"}

package/dist/core/agents/rules/commit-conflict.js

@@ -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.
@@ -23,13 +23,25 @@ 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.js";
+import { resolveOwner } from "../../hooks/resolve/owner.js";
 import { instanceHasLivePid } from "../state/pidmap.js";
 export function evaluateCommit(coordRoot, req) {
+    // 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: "",
@@ -41,10 +53,10 @@ export function evaluateCommit(coordRoot, req) {
     const gitlinkSet = new Set(req.staged_gitlinks ?? []);
     const conflicts = [];
     for (const peer of peers) {
-        if (peer.instance_id === req.instance_id)
+        if (peer.instance_id === me)
             continue;
         const peerSession = peer.session_id ?? peer.instance_id;
-        if (req.session_id && peerSession === req.session_id)
+        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)
@@ -71,6 +83,7 @@ export function evaluateCommit(coordRoot, req) {
             allow: true,
             exit_code: 0,
             rule: "commit.pass",
+            instance_id: me,
             conflicts: [],
             log_lines: [],
             message: "",
@@ -81,6 +94,7 @@ export function evaluateCommit(coordRoot, req) {
             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}`),
             message: "⚠ Multi-Agent coordination: bypass active; staged paths claimed by other agents will be committed anyway:",
@@ -95,6 +109,7 @@ export function evaluateCommit(coordRoot, req) {
             allow: true,
             exit_code: 0,
             rule: "commit.suppressed",
+            instance_id: me,
             conflicts,
             log_lines: conflicts.map((c) => `COMMIT_SUPPRESSED  path=${c.staged_path} owner=${c.short_name} reason=self_attribution`),
             message: "⚠ Multi-Agent coordination: self-attribution detected; staged paths\n" +
@@ -108,6 +123,7 @@ export function evaluateCommit(coordRoot, req) {
         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: "✗ Commit blocked by multi-agent coordination (E guard).\n\n" +

package/dist/core/agents/rules/stop-hook.d.ts

@@ -11,6 +11,9 @@
  *            stop currently firing carries that field via the in-flight event
  *            agent-hook emits before the stop hook runs).
  * Rule 3/3: `state.task_set` event with matching turn boundary exists.
+ * Session-naming rule (at most once per session, CC semantics only): the turn
+ *            whose set-task produced `suggested_session_name` must carry an
+ *            in-window `turn.stop` with `session_name_present: true`.
  *
  * Pure-prose-turn exemption: when zero `tool.pre_use` events fire in
  * the current turn, rules 1/3 and 3/3 do not apply. Rule 2/3 still applies

package/dist/core/agents/rules/stop-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stop-hook.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/stop-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAMH,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAclD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;4EACwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+FAA+F;IAC/F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,yFAAyF;IACzF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;iFAM6E;IAC7E,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA+BD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AAwEnE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,CAqHvF"}
+{"version":3,"file":"stop-hook.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/stop-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAUH,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAclD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;4EACwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+FAA+F;IAC/F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0DAA0D;IAC1D,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,yFAAyF;IACzF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;iFAM6E;IAC7E,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA+BD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AA4DnE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,CA8JvF"}

package/dist/core/agents/rules/stop-hook.js

@@ -11,6 +11,9 @@
  *            stop currently firing carries that field via the in-flight event
  *            agent-hook emits before the stop hook runs).
  * Rule 3/3: `state.task_set` event with matching turn boundary exists.
+ * Session-naming rule (at most once per session, CC semantics only): the turn
+ *            whose set-task produced `suggested_session_name` must carry an
+ *            in-window `turn.stop` with `session_name_present: true`.
  *
  * Pure-prose-turn exemption: when zero `tool.pre_use` events fire in
  * the current turn, rules 1/3 and 3/3 do not apply. Rule 2/3 still applies
@@ -24,7 +27,7 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { resolveBinName } from "../../config.js";
+import { agentsRequireGitFinalization, endOfTurnStatusCommand, resolveBinName, } from "../../config.js";
 function ackSignalFor(adapter) {
     return adapter === "cursor" ? "status_checked" : "status_box_present";
 }
@@ -39,17 +42,6 @@ const RECENT_EVENT_WINDOW_LINES = 5_000;
  * trailing marker could be truncated away on a long reason.
  */
 export const STOP_REMEDIATION_MARKER = "[harnery:stop-remediation";
-/**
- * The pre-marker message shape, still recognized on purpose.
- *
- * A followup already sitting in the stream was written by whichever build was
- * running when it fired. An agent whose session spans an upgrade would otherwise
- * keep alternating until the first new-format followup appeared, which is the
- * exact failure this change removes. Recognizing the older trailing form closes
- * that rollout window at no cost: it only ever appears in a `prompt_text`
- * because Harnery put it there.
- */
-const STOP_REMEDIATION_LEGACY_MARKER = "[agent-hook stop]: rule=";
 /** How far back the remediation walk may travel. Adapters cap their own
  * followup chains (Cursor's `loop_limit`), and each prompt can appear once per
  * observing adapter, so this only guards a pathological stream. */
@@ -58,7 +50,7 @@ function isStopRemediationPrompt(event) {
     const text = event.data.prompt_text;
     if (typeof text !== "string")
         return false;
-    return text.includes(STOP_REMEDIATION_MARKER) || text.includes(STOP_REMEDIATION_LEGACY_MARKER);
+    return text.includes(STOP_REMEDIATION_MARKER);
 }
 /**
  * Start of the window this Stop verdict judges.
@@ -157,7 +149,7 @@ export function evaluateStopHook(coordRoot, req) {
             allow: true,
             exit_code: 0,
             rule: "stop-hook.no_history",
-            reason: "no canonical events for this owner; defer to legacy or skip",
+            reason: "no canonical events for this owner; nothing to evaluate",
         };
     }
     // Turn window: from the most recent user_prompt.submit (this owner) up to
@@ -176,7 +168,11 @@ export function evaluateStopHook(coordRoot, req) {
         return Number.isFinite(t) && t >= startMs && t <= endMs;
     });
     const toolPreUseInTurn = inTurn.some((e) => e.event_type === "tool.pre_use");
-    const statusChecked = inTurn.some((e) => e.event_type === "state.status_checked");
+    const statusEvents = inTurn.filter((e) => e.event_type === "state.status_checked");
+    const statusChecked = statusEvents.length > 0;
+    const requiredStatusChecked = agentsRequireGitFinalization(coordRoot)
+        ? statusEvents.some((e) => e.data.git_finalization_checked === true)
+        : statusChecked;
     const taskSet = inTurn.some((e) => e.event_type === "state.task_set");
     // Rule 2/3: status_box_present on the most recent turn.stop for this owner.
     // The turn.stop event fires from agent-hook stop, which is wired BEFORE
@@ -189,8 +185,12 @@ export function evaluateStopHook(coordRoot, req) {
     // on Claude Code / Codex it's the transcript-scanned `status_box_present`.
     // The matching block helper carries the right "how to fix" message.
     const ackSignal = ackSignalFor(req.adapter);
-    const ackPresent = ackSignal === "status_checked" ? statusChecked : boxPresent;
-    const ackBlock = ackSignal === "status_checked" ? rule13Block : rule23Block;
+    const ackPresent = ackSignal === "status_checked"
+        ? toolPreUseInTurn
+            ? requiredStatusChecked
+            : statusChecked
+        : boxPresent;
+    const ackBlock = ackSignal === "status_checked" ? () => rule13Block(coordRoot) : () => rule23Block(coordRoot);
     // Pure-prose-turn exemption: only the ack signal applies. Parity
     // across adapters: CC requires the box; Cursor requires status_checked.
     if (!toolPreUseInTurn) {
@@ -204,34 +204,70 @@ export function evaluateStopHook(coordRoot, req) {
             reason: "no tool calls this turn; rules 1/3 + 3/3 skipped",
         };
     }
-    if (!statusChecked)
-        return rule13Block();
+    if (!requiredStatusChecked)
+        return rule13Block(coordRoot);
     // On Cursor `ackPresent === statusChecked` (already true here), so this is a
     // no-op and rule 2/3 is not enforced; on CC/Codex it's the box-paste check.
     if (!ackPresent)
         return ackBlock();
     if (!taskSet)
         return rule33Block();
+    // Session-naming rule (at most once per session, evaluated last so
+    // remediation stays monotonic in the established order): the turn whose
+    // set-task produced the suggested session name must show that name in the
+    // reply. Claude Code semantics only — Cursor's Stop payload carries neither
+    // a transcript nor the assistant message, so the fence is undetectable there
+    // (the same reason rule 2/3 collapses into 1/3 on Cursor), and Codex
+    // returned observe-only above. Detection rides `turn.stop`'s
+    // `session_name_present` (assistant-text-only transcript scan), mirroring
+    // how rule 2/3 rides `status_box_present`.
+    if (ackSignal === "status_box_present") {
+        const namingEvent = inTurn.find((e) => ((e.event_type === "state.task_set" && e.data.first_of_session === true) ||
+            (e.event_type === "state.task_state" && e.data.name_reminted === true)) &&
+            typeof e.data.suggested_session_name === "string" &&
+            e.data.suggested_session_name.length > 0);
+        if (namingEvent) {
+            // ANY in-window turn.stop with the flag satisfies the rule, not just the
+            // latest: once seen, `session_name_seen_at` is stamped and later
+            // turn.stops OMIT the field, so a later block on a different rule (whose
+            // repair fires a fresh turn.stop) must not un-satisfy this one.
+            const namePresent = inTurn.some((e) => e.event_type === "turn.stop" && e.data.session_name_present === true);
+            if (!namePresent) {
+                return sessionNameBlock(String(namingEvent.data.suggested_session_name));
+            }
+        }
+    }
     return {
         allow: true,
         exit_code: 0,
         rule: "stop-hook.pass",
     };
 }
-function rule13Block() {
+function rule13Block(coordRoot) {
+    const missingEvidence = agentsRequireGitFinalization(coordRoot)
+        ? "no Git-finalized state.status_checked event found in this turn"
+        : "no state.status_checked event found in this turn";
     return {
         allow: false,
         exit_code: 2,
         rule: "stop-hook.rule_1_3",
-        reason: `End-of-turn rule (1/3): no state.status_checked event found in this turn; run \`${resolveBinName()} agents status\` as your last tool call.`,
+        reason: `End-of-turn rule (1/3): ${missingEvidence}; run \`${endOfTurnStatusCommand(coordRoot)}\` as your last tool call.`,
     };
 }
-function rule23Block() {
+function rule23Block(coordRoot) {
     return {
         allow: false,
         exit_code: 2,
         rule: "stop-hook.rule_2_3",
-        reason: `End-of-turn rule (2/3): turn.stop did not see the agent-status box in your reply text. Paste the \`${resolveBinName()} agents status\` output verbatim as a fenced code block (the \`┌─ agent-\` prefix is the detection signal).`,
+        reason: `End-of-turn rule (2/3): turn.stop did not see the agent-status box in your reply text. Paste the \`${endOfTurnStatusCommand(coordRoot)}\` output verbatim as a fenced code block (the \`┌─ agent-\` prefix is the detection signal).`,
+    };
+}
+function sessionNameBlock(name) {
+    return {
+        allow: false,
+        exit_code: 2,
+        rule: "stop-hook.session_name",
+        reason: `Session-naming rule: this turn's set-task produced the session name, but your reply doesn't show it. Reproduce it by itself in a fenced code block so the operator can one-click-copy it as the session/tab title: ${name}`,
     };
 }
 function rule33Block() {

package/dist/core/agents/session-events.d.ts

@@ -1,21 +1,17 @@
 /**
  * Command/narration event emitter for the coordination layer.
  *
- * `writeSessionEvent` emits command + narration events straight to the
+ * `writeSessionEvent` emits command and narration events straight to the
  * **canonical** `.harnery/events.ndjson` (alongside the hook events), which the
- * `/live` web viewer reads. The exported surface (`writeSessionEvent`,
- * `newCmdId`, `clampField`, `readLastIntent`) is stable so the session-tee
- * middleware callers need no edits.
+ * `/live` web viewer reads.
  */
-/** Event types accepted by `writeSessionEvent`. Only the command stream +
- * narration are emitted canonically; the coord/state types are accepted for
- * call-site compatibility but are no-ops (the agents CLI emits those itself). */
-export type SessionEventType = "command_start" | "output" | "command_end" | "end_of_turn" | "hook_event" | "set_task" | "file_claim" | "file_release" | "peer_change" | "narration";
+/** Event types accepted by `writeSessionEvent`. */
+export type SessionEventType = "command_start" | "output" | "command_end" | "narration";
 /**
  * Resolved path of the ndjson sidecar file. Lives inside `.harnery/` so a
  * containerized reader can pick it up through a single bind mount.
  */
-export declare function sessionEventsPath(): string;
+export declare function canonicalEventsPath(): string;
 /** Random 8-char hex id for grouping output lines under a single command. */
 export declare function newCmdId(): string;
 /**
@@ -28,14 +24,10 @@ export declare function newCmdId(): string;
  */
 export declare function readLastIntent(instanceId?: string): string | null;
 /**
- * Emit a session event. Command + narration events
- * are written to the canonical `.harnery/events.ndjson`; the coord/state types
- * are accepted for call-site compatibility but are no-ops here (the agents CLI
- * emits those itself). Best-effort, never throws into the caller; a command
- * must never break or slow on telemetry. The `agentName` arg is retained for
- * the stable call signature (canonical events key on instance_id, not name).
+ * Emit a command or narration event to `.harnery/events.ndjson`. Best-effort,
+ * never throws into the caller; telemetry must not break or slow a command.
  */
-export declare function writeSessionEvent(type: SessionEventType, _agentName: string, fields?: Record<string, unknown>): void;
+export declare function writeSessionEvent(type: SessionEventType, fields?: Record<string, unknown>): void;
 /** Trim long values to keep individual events small. */
 export declare function clampField(v: string, max?: number): string;
 //# sourceMappingURL=session-events.d.ts.map

package/dist/core/agents/session-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-events.d.ts","sourceRoot":"","sources":["../../../src/core/agents/session-events.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH;;iFAEiF;AACjF,MAAM,MAAM,gBAAgB,GACxB,eAAe,GACf,QAAQ,GACR,aAAa,GACb,aAAa,GACb,YAAY,GACZ,UAAU,GACV,YAAY,GACZ,cAAc,GACd,aAAa,GACb,WAAW,CAAC;AAEhB;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAa1C;AAED,6EAA6E;AAC7E,wBAAgB,QAAQ,IAAI,MAAM,CAEjC;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiBjE;AAsGD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACnC,IAAI,CAEN;AAED,wDAAwD;AACxD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAO,GAAG,MAAM,CAGxD"}
+{"version":3,"file":"session-events.d.ts","sourceRoot":"","sources":["../../../src/core/agents/session-events.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH,mDAAmD;AACnD,MAAM,MAAM,gBAAgB,GAAG,eAAe,GAAG,QAAQ,GAAG,aAAa,GAAG,WAAW,CAAC;AAExF;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAa5C;AAED,6EAA6E;AAC7E,wBAAgB,QAAQ,IAAI,MAAM,CAEjC;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiBjE;AA8FD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACnC,IAAI,CAEN;AAED,wDAAwD;AACxD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAO,GAAG,MAAM,CAGxD"}