harnery 0.34.1 → 0.36.0

package/src/core/agents/rules/stop-hook.ts

@@ -30,6 +30,8 @@ export interface StopHookRequest {
   adapter?: string;
   now_ms?: number;
   turn_window?: { start_ms: number; end_ms: number };
+  stop_hook_active?: boolean;
+  status_box_present_strict?: boolean;
   bypass?: boolean;
   workflow_child?: boolean;
 }
@@ -107,15 +109,24 @@ export function evaluateStopHookV3Events(
       "generation_id" in event.scope &&
       event.scope.generation_id === generationId,
   );
+  const fallbackStartMs = Math.max(0, endMs - 5 * 60 * 1000);
+  const claudeContinuation = req.adapter === "claude-code" && req.stop_hook_active === true;
+  const resolvedStart = resolveTurnStart(ownerEvents, endMs, claudeContinuation);
+  const resolvedStartMs = eventTimeMs(resolvedStart);
   const startMs =
     req.turn_window?.start_ms ??
-    resolveTurnStartMs(ownerEvents, endMs, Math.max(0, endMs - 5 * 60 * 1000));
+    (Number.isFinite(resolvedStartMs) ? resolvedStartMs : fallbackStartMs);
   const inTurn = ownerEvents.filter((event) => {
     const time = eventTimeMs(event);
     return Number.isFinite(time) && time >= startMs && time <= endMs;
   });
 
-  const usedTool = inTurn.some((event) => event.event_type === "tool.requested");
+  const policyEvents =
+    claudeContinuation && resolvedStart
+      ? originalTurnEvents(ownerEvents, resolvedStart, endMs)
+      : inTurn;
+  const usedTool = policyEvents.some((event) => event.event_type === "tool.requested");
+  const cycleAnchor = remediationCycleAnchor(resolvedStart, startMs);
   const statusEvents = inTurn.filter(
     (event) =>
       event.event_type === "coord.status_observed" && event.payload.subject_instance_id === owner,
@@ -138,21 +149,32 @@ export function evaluateStopHookV3Events(
       event.event_type === "turn.completed",
   );
   const latestTerminal = turnTerminals.at(-1);
-  const latestBox = observedBoolean(latestTerminal?.payload.ritual?.status_box_present);
-  if (req.adapter !== "cursor" && latestBox === undefined) {
+  const latestBox = observedBoolean(latestTerminal?.payload.ritual?.status_box_present_strict);
+  const strictBoxObservations = turnTerminals
+    .map((event) => observedBoolean(event.payload.ritual?.status_box_present_strict))
+    .filter((value): value is boolean => value !== undefined);
+  const currentStrictBox = claudeContinuation ? req.status_box_present_strict : undefined;
+  if (req.adapter !== "cursor" && latestBox === undefined && currentStrictBox === undefined) {
     return evidenceUnavailable(
-      "turn.completed has no observed V3 status-box result; Stop remains fail-open",
+      "turn.completed has no observed V3 assistant-text status-box result; Stop remains fail-open",
     );
   }
 
-  const ackPresent = req.adapter === "cursor" ? requiredStatusChecked : latestBox === true;
+  const ackPresent =
+    req.adapter === "cursor"
+      ? requiredStatusChecked
+      : claudeContinuation
+        ? strictBoxObservations.includes(true) || currentStrictBox === true
+        : latestBox === true;
   const ackBlock =
-    req.adapter === "cursor" ? () => rule13Block(coordRoot) : () => rule23Block(coordRoot);
+    req.adapter === "cursor"
+      ? () => rule13Block(coordRoot, req.session_id)
+      : () => rule23Block(coordRoot, req.session_id);
 
   // Pure prose turns keep the human-visible acknowledgement but do not require
   // task or final-status mutations. This preserves the pre-V3 policy exactly.
   if (!usedTool) {
-    if (!ackPresent) return ackBlock();
+    if (!ackPresent) return withCycleAnchor(ackBlock(), cycleAnchor);
     return {
       allow: true,
       exit_code: 0,
@@ -161,9 +183,14 @@ export function evaluateStopHookV3Events(
     };
   }
 
-  if (!requiredStatusChecked) return rule13Block(coordRoot);
-  if (!ackPresent) return ackBlock();
-  if (!taskSet) return rule33Block(coordRoot);
+  // Collect EVERY missing signal before returning. Reporting them one at a
+  // time made each additional missing signal cost a whole continuation, and
+  // every continuation forks a fresh hook process: on a busy multi-agent host
+  // the ritual's own enforcement became part of the hook load it polices.
+  const pending: VerdictResult[] = [];
+  if (!requiredStatusChecked) pending.push(rule13Block(coordRoot, req.session_id));
+  if (!ackPresent) pending.push(ackBlock());
+  if (!taskSet) pending.push(rule33Block(coordRoot, req.session_id));
 
   // Claude Code can prove session-name presentation from assistant-only text.
   // Cursor cannot expose that text and Codex returned observe-only above.
@@ -176,10 +203,13 @@ export function evaluateStopHookV3Events(
       !naming.some(({ present }) => present) &&
       !sessionNameSeenStamped(coordRoot, req.instance_id)
     ) {
-      return sessionNameBlock(coordRoot, req.instance_id);
+      pending.push(sessionNameBlock(coordRoot, req.instance_id));
     }
   }
 
+  const blocked = mergeStopBlocks(pending);
+  if (blocked) return withCycleAnchor(blocked, cycleAnchor);
+
   return { allow: true, exit_code: 0, rule: "stop-hook.pass" };
 }
 
@@ -211,29 +241,65 @@ function unconditionalVerdict(req: StopHookRequest): VerdictResult | undefined {
   return undefined;
 }
 
-function resolveTurnStartMs(
+function resolveTurnStart(
   ownerEvents: readonly EventV3[],
   nowMs: number,
-  fallbackMs: number,
-): number {
+  claudeContinuation: boolean,
+): Extract<EventV3, { event_type: "turn.started" }> | undefined {
   const turns = ownerEvents.filter(
     (event): event is Extract<EventV3, { event_type: "turn.started" }> =>
       event.event_type === "turn.started" && eventTimeMs(event) <= nowMs,
   );
-  if (turns.length === 0) return fallbackMs;
+  if (turns.length === 0) return undefined;
 
   let index = turns.length - 1;
   let hops = 0;
   while (index > 0 && hops < MAX_REMEDIATION_WALK_BACK) {
     const turn = turns[index];
-    if (!turn?.payload.stop_remediation) break;
+    const continuesCycle = claudeContinuation
+      ? turn?.provenance.source_event === "claude-code.recovery" &&
+        turn.provenance.attestation === "derived"
+      : turn?.payload.stop_remediation === true;
+    if (!continuesCycle) break;
     index -= 1;
     hops += 1;
   }
-  return eventTimeMs(turns[index]!);
+  return turns[index];
+}
+
+function originalTurnEvents(
+  ownerEvents: readonly EventV3[],
+  turnStart: Extract<EventV3, { event_type: "turn.started" }> | undefined,
+  endMs: number,
+): EventV3[] {
+  if (!turnStart) return [];
+  const startMs = eventTimeMs(turnStart);
+  const terminal = ownerEvents.find(
+    (event) => event.event_type === "turn.completed" && eventTimeMs(event) >= startMs,
+  );
+  const policyEndMs = terminal ? eventTimeMs(terminal) : endMs;
+  return ownerEvents.filter((event) => {
+    const time = eventTimeMs(event);
+    return time >= startMs && time <= policyEndMs;
+  });
+}
+
+function remediationCycleAnchor(
+  turnStart: Extract<EventV3, { event_type: "turn.started" }> | undefined,
+  startMs: number,
+): string {
+  if (turnStart && "turn_id" in turnStart.scope && turnStart.scope.turn_id) {
+    return turnStart.scope.turn_id;
+  }
+  return new Date(startMs).toISOString();
+}
+
+function withCycleAnchor(verdict: VerdictResult, anchor: string): VerdictResult {
+  return { ...verdict, remediation_cycle_anchor: anchor };
 }
 
-function eventTimeMs(event: EventV3): number {
+function eventTimeMs(event: EventV3 | undefined): number {
+  if (!event) return Number.NaN;
   return Date.parse(event.time.observed_at);
 }
 
@@ -271,7 +337,45 @@ function evidenceUnavailable(reason: string): VerdictResult {
   };
 }
 
-function rule13Block(coordRoot?: string): VerdictResult {
+/**
+ * Remediation commands carry `--session-id` when the session id is known: the
+ * remediating tool call may not descend from a pid-map-registered anchor
+ * (headless children, Cursor shells), and a ppid-walk that resolves to a
+ * DIFFERENT owner records evidence this verdict will never see — the block
+ * then repeats forever while the agent complies every time.
+ */
+function sessionIdSuffix(sessionId?: string): string {
+  return sessionId ? ` --session-id ${sessionId}` : "";
+}
+
+/**
+ * Fold every failing end-of-turn signal into ONE verdict.
+ *
+ * The verdict keeps the first failure's rule id, so the `blocked_rule`
+ * telemetry and the adapter's `rule=` stderr contract are unchanged; the
+ * reason enumerates the rest so a single continuation can repair all of them.
+ * Cursor maps the acknowledgement onto rule 1/3, so identical rules dedupe.
+ */
+function mergeStopBlocks(blocks: VerdictResult[]): VerdictResult | undefined {
+  let primary: VerdictResult | undefined;
+  const seen = new Set<string>();
+  const reasons: string[] = [];
+  for (const block of blocks) {
+    if (seen.has(block.rule)) continue;
+    seen.add(block.rule);
+    if (!primary) primary = block;
+    if (block.reason) reasons.push(block.reason);
+  }
+  if (!primary) return undefined;
+  if (reasons.length < 2) return primary;
+  const numbered = reasons.map((reason, index) => `${index + 1}. ${reason}`).join("\n");
+  return {
+    ...primary,
+    reason: `End-of-turn ritual: ${reasons.length} signals are missing from this turn. Repair ALL of them in this continuation, then stop.\n${numbered}`,
+  };
+}
+
+function rule13Block(coordRoot?: string, sessionId?: string): VerdictResult {
   const missingEvidence = agentsRequireGitFinalization(coordRoot)
     ? "no end_turn_checked coord.status_observed event found in this turn"
     : "no coord.status_observed event found in this turn";
@@ -279,16 +383,16 @@ function rule13Block(coordRoot?: string): VerdictResult {
     allow: false,
     exit_code: 2,
     rule: "stop-hook.rule_1_3",
-    reason: `End-of-turn rule (1/3): ${missingEvidence}; run \`${endOfTurnStatusCommand(coordRoot)}\` as your last tool call.`,
+    reason: `End-of-turn rule (1/3): ${missingEvidence}; run \`${endOfTurnStatusCommand(coordRoot)}${sessionIdSuffix(sessionId)}\` as your last tool call.`,
   };
 }
 
-function rule23Block(coordRoot?: string): VerdictResult {
+function rule23Block(coordRoot?: string, sessionId?: string): VerdictResult {
   return {
     allow: false,
     exit_code: 2,
     rule: "stop-hook.rule_2_3",
-    reason: `End-of-turn rule (2/3): turn.completed did not observe 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).`,
+    reason: `End-of-turn rule (2/3): turn.completed did not observe the agent-status box in your reply text. Paste the \`${endOfTurnStatusCommand(coordRoot)}${sessionIdSuffix(sessionId)}\` output verbatim as a fenced code block (the \`┌─ agent-\` prefix is the detection signal).`,
   };
 }
 
@@ -335,11 +439,11 @@ function sessionNameBlock(coordRoot: string, instanceId: string): VerdictResult
   };
 }
 
-function rule33Block(coordRoot?: string): VerdictResult {
+function rule33Block(coordRoot?: string, sessionId?: string): VerdictResult {
   return {
     allow: false,
     exit_code: 2,
     rule: "stop-hook.rule_3_3",
-    reason: `End-of-turn rule (3/3): no coord.task_changed event found in this turn; run \`${resolveBinName(coordRoot)} agents set-task "<short focus>"\` to declare what you're working on. Pass an empty string if the turn was purely conversational.`,
+    reason: `End-of-turn rule (3/3): no coord.task_changed event found in this turn; run \`${resolveBinName(coordRoot)} agents set-task${sessionIdSuffix(sessionId)} "<short focus>"\` to declare what you're working on. Pass an empty string if the turn was purely conversational.`,
   };
 }

package/src/core/agents/rules/verdict.ts

@@ -10,4 +10,5 @@ export type VerdictResult = {
   exit_code: 0 | 2;
   rule: string;
   reason?: string;
+  remediation_cycle_anchor?: string;
 };

package/src/core/agents/session-events.ts

@@ -102,6 +102,10 @@ function recordCommandObservation(type: SessionEventType, fields: Record<string,
       monotonic_ns: process.hrtime.bigint().toString(),
     });
     if (result.state === "generation_unavailable") {
+      const expectedLifecycleReopenGap =
+        result.reason === "turn_not_started" &&
+        hook.session_start_derivation === "approved_lifecycle_reopen";
+      if (expectedLifecycleReopenGap) return;
       writeProducerDiagnosticV3(coordRoot, "command_emit_unjoinable", {
         type,
         instance_id: instanceId,

package/src/core/agents/session-finalization-state-v3.ts

@@ -1,7 +1,7 @@
 import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { ApprovedSessionEndReasonV3 } from "../events/v3/producers/recorder.ts";
-import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../events/v3/writer.ts";
+import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../events/v3/reader.ts";
 
 export const SESSION_FINALIZATION_REQUEST_FORMAT_V3 =
   "harnery-v3-session-finalization-request" as const;

package/src/core/agents/session-finalizer-v3.ts

@@ -690,7 +690,10 @@ function ensureRequest(
   };
   const observation = buildObservationEvent(coordRoot, record, request, input);
   request.observation_event_id = observation.event_id as `evt_${string}`;
-  writeEventV3(coordRoot, observation);
+  const durability = writeEventV3(coordRoot, observation, {
+    expectedGenesisId: input.route.genesis_id,
+  });
+  if (durability.state === "epoch_replaced") return null;
   writeRequest(coordRoot, request, true);
   return request;
 }

package/src/core/agents/session-name-display.ts

@@ -36,6 +36,14 @@ export function sessionNameDisplayInstruction(name: string): string {
   ].join("\n");
 }
 
+export function sessionNameDisplayRecoveryInstruction(name: string, binName: string): string {
+  return [
+    sessionNameDisplayInstruction(name),
+    "",
+    `If that exact block was already shown but the gate still rejects tools, run \`${binName} agents suggest-name --json\` as the only tool call. That read-only command is exempt and creates a fresh verification boundary.`,
+  ].join("\n");
+}
+
 /**
  * A PostToolUse result should announce the display protocol only when that
  * exact tool call minted or retried the current suggestion. The coordination row keeps
@@ -143,7 +151,7 @@ export function isSessionNameRemediationCommand(
   if (!body || /[\n;&|<>`$]/.test(body)) return false;
   const escapedBin = binName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const pattern = new RegExp(
-    `^(?:codex-wsl\\s+--\\s+)?${escapedBin}\\s+agents\\s+(?:set-task|status)(?:\\s+.*)?$`,
+    `^(?:codex-wsl\\s+--\\s+)?${escapedBin}\\s+agents\\s+(?:set-task|status|suggest-name)(?:\\s+.*)?$`,
   );
   return pattern.test(body);
 }

package/src/core/agents/state/activity-log.ts

@@ -20,6 +20,11 @@ import { readLiveCoordinationRow } from "./live-coordination-view.ts";
 export function resolveShortName(coordRoot: string, instanceId: string | null): string {
   if (!instanceId) return "agent-unknown";
   const row = readLiveCoordinationRow(coordRoot, instanceId);
-  if (row?.name) return `agent-${row.name}`;
-  return `agent-${instanceId.slice(0, 8)}`;
+  return agentDisplayName(instanceId, row?.name);
+}
+
+/** Build a collision-resistant agent label even when identity onboarding has
+ * not produced a usable display name yet. */
+export function agentDisplayName(instanceId: string, name?: string | null): string {
+  return `agent-${name?.trim() || instanceId.slice(0, 8) || "unknown"}`;
 }

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

@@ -0,0 +1,69 @@
+/** Read-only access to the generation-bound heartbeat cache. */
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve, sep } from "node:path";
+import type { AgentActivity, TaskState } from "./session-state.ts";
+
+export interface Heartbeat {
+  schema_version?: number;
+  instance_id: string;
+  name?: string;
+  kind?: string;
+  agent_id?: string;
+  session_id: string;
+  /** Native adapter session ID retained only in a generation-bound local projection. */
+  native_session_id?: string;
+  subagent_call_id?: string;
+  model?: string;
+  platform?: string;
+  started_at?: string;
+  last_heartbeat: string;
+  files_touched: string[];
+  task?: string;
+  task_updated_at?: string | null;
+  activity?: AgentActivity;
+  activity_updated_at?: string;
+  activity_source?: string;
+  task_state?: TaskState;
+  task_state_updated_at?: string;
+  task_state_reason?: string;
+  /** Session name built on the first non-empty set-task (never rebuilt). */
+  suggested_session_name?: string;
+  /** Stamped once the suggested name is seen in assistant reply text. */
+  session_name_seen_at?: string;
+  /** The specific suggested name proven present by the sighting stamp. */
+  session_name_seen_for?: string;
+  last_status_at?: string;
+  current_turn_id?: string;
+  parent_instance_id?: string;
+  workflow_run_id?: string;
+  workflow_agent_id?: string;
+  /** Disposable-cache bindings that prove a row belongs to the current V3 generation. */
+  v3_instance_id?: `inst_${string}`;
+  v3_generation_id?: `gen_${string}`;
+  v3_projection_event_id?: string;
+  v3_task_state?: "set" | "cleared";
+  [extra: string]: unknown;
+}
+
+export function heartbeatPath(coordRoot: string, instanceId: string): string {
+  if (!/^[A-Za-z0-9_-]{1,128}$/.test(instanceId)) {
+    throw new Error("instance_id must be 1-128 ASCII letters, digits, hyphens, or underscores");
+  }
+  const root = resolve(coordRoot, ".harnery", "active");
+  const candidate = resolve(root, `${instanceId}.json`);
+  if (!candidate.startsWith(`${root}${sep}`) || dirname(candidate) !== root) {
+    throw new Error("coordination filename must resolve directly beneath its root");
+  }
+  return candidate;
+}
+
+export function readHeartbeat(coordRoot: string, instanceId: string): Heartbeat | null {
+  const path = heartbeatPath(coordRoot, instanceId);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8")) as Heartbeat;
+  } catch {
+    return null;
+  }
+}

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

@@ -23,65 +23,12 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { assertSafeInstanceId, resolveContainedFile } from "../coord-client.ts";
-import type { AgentActivity, TaskState } from "./session-state.ts";
+import { dirname, join } from "node:path";
+import { canonicalClaimPath } from "../claim-path.ts";
+import { type Heartbeat, heartbeatPath, readHeartbeat } from "./heartbeat-reader.ts";
+import type { TaskState } from "./session-state.ts";
 
-export interface Heartbeat {
-  schema_version?: number;
-  instance_id: string;
-  name?: string;
-  kind?: string;
-  agent_id?: string;
-  session_id: string;
-  /** Native adapter session ID retained only in a generation-bound local projection. */
-  native_session_id?: string;
-  subagent_call_id?: string;
-  model?: string;
-  platform?: string;
-  started_at?: string;
-  last_heartbeat: string;
-  files_touched: string[];
-  task?: string;
-  task_updated_at?: string | null;
-  activity?: AgentActivity;
-  activity_updated_at?: string;
-  activity_source?: string;
-  task_state?: TaskState;
-  task_state_updated_at?: string;
-  task_state_reason?: string;
-  /** Session name built on the first non-empty set-task (never rebuilt). Its
-   * presence is the "this session has been named" signal the prompt-context
-   * nudge and the Stop-hook naming rule key on. */
-  suggested_session_name?: string;
-  /** Stamped by turn.completed once the suggested name is seen in assistant reply
-   * text, ending the per-turn transcript scan. */
-  session_name_seen_at?: string;
-  /** WHICH name that sighting was for. The scan is skipped only while this
-   * matches the current suggested name, so a re-minted name is detectable
-   * again rather than being suppressed by the earlier sighting. */
-  session_name_seen_for?: string;
-  last_status_at?: string;
-  current_turn_id?: string;
-  parent_instance_id?: string;
-  workflow_run_id?: string;
-  workflow_agent_id?: string;
-  /** Disposable-cache bindings that prove a row belongs to the current V3 generation. */
-  v3_instance_id?: `inst_${string}`;
-  v3_generation_id?: `gen_${string}`;
-  v3_projection_event_id?: string;
-  v3_task_state?: "set" | "cleared";
-  [extra: string]: unknown;
-}
-
-function heartbeatPath(coordRoot: string, instanceId: string): string {
-  assertSafeInstanceId(instanceId);
-  const safeInstanceId = basename(instanceId);
-  if (safeInstanceId !== instanceId) {
-    throw new Error("instance_id must be a direct-child coordination basename");
-  }
-  return resolveContainedFile(join(coordRoot, ".harnery", "active"), `${safeInstanceId}.json`);
-}
+export { type Heartbeat, readHeartbeat } from "./heartbeat-reader.ts";
 
 function nowIsoSeconds(): string {
   return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
@@ -94,16 +41,6 @@ function atomicWrite(path: string, content: string): void {
   renameSync(tmp, path);
 }
 
-export function readHeartbeat(coordRoot: string, instanceId: string): Heartbeat | null {
-  const path = heartbeatPath(coordRoot, instanceId);
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as Heartbeat;
-  } catch {
-    return null;
-  }
-}
-
 /** Persist operator-facing lifecycle prose in the generation-bound cache only. */
 export function setLifecycleCache(
   coordRoot: string,
@@ -171,6 +108,33 @@ export function setIdentityCache(
   return heartbeat;
 }
 
+/** Restore the pool-assigned display name on a generation that was
+ * materialized before the adapter's normal SessionStart naming path ran.
+ * The durable assignment lives in `.name-history`; this only repairs the
+ * disposable generation cache and deliberately leaves durable persona state
+ * (`agent_id`) untouched. */
+export function setAssignedNameCache(
+  coordRoot: string,
+  instanceId: string,
+  name: string,
+  kind: "session" | "subagent" | "transient" = "session",
+): Heartbeat | null {
+  return mutate(coordRoot, instanceId, (heartbeat) => {
+    const suggestedSessionName = heartbeat.suggested_session_name?.replace(
+      /^(\[DONE\]\s+)?Agent unknown( - .+)$/,
+      `$1Agent ${name}$2`,
+    );
+    return {
+      ...heartbeat,
+      name,
+      kind: heartbeat.kind ?? kind,
+      ...(suggestedSessionName && suggestedSessionName !== heartbeat.suggested_session_name
+        ? { suggested_session_name: suggestedSessionName }
+        : {}),
+    };
+  });
+}
+
 /**
  * Build the copy-pasteable session name from the coord identity + the agent's
  * description parts. Pure (no coord-state reads) so it's unit-testable; collapses
@@ -221,16 +185,12 @@ export function releaseClaim(
   instanceId: string,
   path: string,
 ): Heartbeat | null {
-  // files_touched can hold either absolute-under-coordRoot or canonical
-  // monorepo-relative entries; normalize both sides so release matches
-  // regardless of the form the caller passes (the old exact-string filter
-  // silently no-op'd on a form mismatch).
-  const norm = (p: string): string =>
-    p.startsWith(`${coordRoot}/`) ? p.slice(coordRoot.length + 1) : p;
-  const target = norm(path);
+  const target = canonicalClaimPath(coordRoot, path);
   return mutate(coordRoot, instanceId, (hb) => ({
     ...hb,
-    files_touched: (hb.files_touched ?? []).filter((p) => norm(p) !== target),
+    files_touched: (hb.files_touched ?? []).filter(
+      (candidate) => canonicalClaimPath(coordRoot, candidate) !== target,
+    ),
   }));
 }
 
@@ -240,12 +200,15 @@ export function acquireClaim(
   instanceId: string,
   path: string,
 ): Heartbeat | null {
-  const norm = (p: string): string =>
-    p.startsWith(`${coordRoot}/`) ? p.slice(coordRoot.length + 1) : p;
-  const target = norm(path);
+  const target = canonicalClaimPath(coordRoot, path);
   return mutate(coordRoot, instanceId, (hb) => ({
     ...hb,
-    files_touched: [...new Set([...(hb.files_touched ?? []).map(norm), target])].sort(),
+    files_touched: [
+      ...new Set([
+        ...(hb.files_touched ?? []).map((candidate) => canonicalClaimPath(coordRoot, candidate)),
+        target,
+      ]),
+    ].sort(),
   }));
 }
 
@@ -282,9 +245,7 @@ export function findGroupClaims(
   if (!groupId || !path) return hits;
   const activeDir = join(coordRoot, ".harnery", "active");
   if (!existsSync(activeDir)) return hits;
-  const norm = (p: string): string =>
-    p.startsWith(`${coordRoot}/`) ? p.slice(coordRoot.length + 1) : p;
-  const target = norm(path);
+  const target = canonicalClaimPath(coordRoot, path);
   for (const f of readdirSync(activeDir)) {
     if (!f.endsWith(".json")) continue;
     const hbPath = join(activeDir, f);
@@ -298,7 +259,9 @@ export function findGroupClaims(
       (body.session_id as string | undefined) ?? (body.instance_id as string | undefined);
     if (peerSession !== groupId) continue;
     const files = (body.files_touched as string[] | undefined) ?? [];
-    if (!files.some((candidate) => norm(candidate) === target)) continue;
+    if (!files.some((candidate) => canonicalClaimPath(coordRoot, candidate) === target)) {
+      continue;
+    }
     hits.push({
       instance_id: (body.instance_id as string | undefined) ?? f.replace(/\.json$/, ""),
       session_id: body.session_id as string | undefined,