harnery 0.36.0 → 0.38.0

package/dist/core/agents/reconcile-coordination-v3.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The canonical supervisor reconcile pass.
+ *
+ * Two things have to happen together, in this order:
+ *
+ *   1. `staleSweep` prunes the disposable coordination cache under
+ *      `.harnery/active` (plus orphaned pid-map and `.last-peer-hash` files)
+ *      and leaves a durable lifecycle observation for every deletion.
+ *   2. `reconcileSessionFinalizationV3` turns those observations, along with
+ *      archive/idle/run/host signals, into session finalization requests.
+ *
+ * Running the sweep first is what makes a single pass self-contained: the
+ * `lifecycle.sweep_observed` rows it writes are visible to the finalizer in
+ * the same pass, so a stale session is both reaped and finalized without
+ * waiting for a later invocation.
+ *
+ * ADR 0077 already specified that `agents reconcile` and session start
+ * discover stale-sweep in the same pass. Both entry points had drifted to
+ * calling only the finalizer, so the sweep never ran outside its own
+ * subcommand. This module is the single composition both now share; adding a
+ * caller means calling this, not re-composing the two halves.
+ */
+import { type ReconcileSessionFinalizationOptionsV3, type ReconcileSessionFinalizationResultV3 } from "./session-finalizer-v3.js";
+export interface ReconcileCoordinationResultV3 extends ReconcileSessionFinalizationResultV3 {
+    /** Heartbeat cache files deleted from `.harnery/active` by the sweep. */
+    swept_heartbeats: number;
+    /** Orphaned `.harnery/pid-map` entries deleted by the sweep. */
+    swept_pidmaps: number;
+    /** Dead-owner `.last-peer-hash.*` files deleted by the sweep. */
+    swept_peer_hashes: number;
+}
+/**
+ * Sweep the disposable coordination cache, then reconcile session
+ * finalization, and report both sets of counts.
+ *
+ * The sweep owns its own safety contract (configured coordination freshness
+ * for valid rows, an additional stale-mtime gate for malformed or missing
+ * timestamps, and a durable audit record before any deletion, failing closed
+ * when neither can be written). Nothing here loosens it, and a sweep failure
+ * never blocks finalization: the cache is a projection that heals on the
+ * owning agent's next tool call, while the V3 ledger is authoritative.
+ */
+export declare function reconcileCoordinationV3(coordRoot: string, options?: ReconcileSessionFinalizationOptionsV3): ReconcileCoordinationResultV3;
+//# sourceMappingURL=reconcile-coordination-v3.d.ts.map

package/dist/core/agents/reconcile-coordination-v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile-coordination-v3.d.ts","sourceRoot":"","sources":["../../../src/core/agents/reconcile-coordination-v3.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EACL,KAAK,qCAAqC,EAC1C,KAAK,oCAAoC,EAE1C,MAAM,2BAA2B,CAAC;AAGnC,MAAM,WAAW,6BAA8B,SAAQ,oCAAoC;IACzF,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,aAAa,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,qCAA0C,GAClD,6BAA6B,CAuB/B"}

package/dist/core/agents/reconcile-coordination-v3.js

@@ -0,0 +1,58 @@
+/**
+ * The canonical supervisor reconcile pass.
+ *
+ * Two things have to happen together, in this order:
+ *
+ *   1. `staleSweep` prunes the disposable coordination cache under
+ *      `.harnery/active` (plus orphaned pid-map and `.last-peer-hash` files)
+ *      and leaves a durable lifecycle observation for every deletion.
+ *   2. `reconcileSessionFinalizationV3` turns those observations, along with
+ *      archive/idle/run/host signals, into session finalization requests.
+ *
+ * Running the sweep first is what makes a single pass self-contained: the
+ * `lifecycle.sweep_observed` rows it writes are visible to the finalizer in
+ * the same pass, so a stale session is both reaped and finalized without
+ * waiting for a later invocation.
+ *
+ * ADR 0077 already specified that `agents reconcile` and session start
+ * discover stale-sweep in the same pass. Both entry points had drifted to
+ * calling only the finalizer, so the sweep never ran outside its own
+ * subcommand. This module is the single composition both now share; adding a
+ * caller means calling this, not re-composing the two halves.
+ */
+import { reconcileSessionFinalizationV3, } from "./session-finalizer-v3.js";
+import { staleSweep } from "./state/stale-sweep.js";
+/**
+ * Sweep the disposable coordination cache, then reconcile session
+ * finalization, and report both sets of counts.
+ *
+ * The sweep owns its own safety contract (configured coordination freshness
+ * for valid rows, an additional stale-mtime gate for malformed or missing
+ * timestamps, and a durable audit record before any deletion, failing closed
+ * when neither can be written). Nothing here loosens it, and a sweep failure
+ * never blocks finalization: the cache is a projection that heals on the
+ * owning agent's next tool call, while the V3 ledger is authoritative.
+ */
+export function reconcileCoordinationV3(coordRoot, options = {}) {
+    let sweptHeartbeats = 0;
+    let sweptPidmaps = 0;
+    let sweptPeerHashes = 0;
+    const sweepDiagnostics = [];
+    try {
+        const sweep = staleSweep(coordRoot);
+        sweptHeartbeats = sweep.heartbeatsRemoved.length;
+        sweptPidmaps = sweep.pidmapsRemoved;
+        sweptPeerHashes = sweep.peerHashesRemoved;
+    }
+    catch (error) {
+        sweepDiagnostics.push(`stale_sweep_failed:${error instanceof Error ? error.message : String(error)}`);
+    }
+    const result = reconcileSessionFinalizationV3(coordRoot, options);
+    return {
+        ...result,
+        diagnostics: [...sweepDiagnostics, ...result.diagnostics],
+        swept_heartbeats: sweptHeartbeats,
+        swept_pidmaps: sweptPidmaps,
+        swept_peer_hashes: sweptPeerHashes,
+    };
+}

package/dist/core/agents/render/prompt-context.d.ts

@@ -49,6 +49,11 @@ 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 this prompt is being rendered for. Gates the mailbox drain:
+     * an adapter that cannot receive UserPromptSubmit context must not consume
+     * messages here, or they are removed from the queue and never shown. When
+     * omitted, delivery is attempted (the default route can receive). */
+    adapter?: string;
     /** 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

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

@@ -1 +1 @@
-{"version":3,"file":"prompt-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/prompt-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AA4CH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;8EAC0E;IAC1E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;kFAC8E;IAC9E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;kFAC8E;IAC9E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;uEACmE;IACnE,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;wBAIoB;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CA8DnE"}
+{"version":3,"file":"prompt-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/prompt-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AA+CH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;8EAC0E;IAC1E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;kFAC8E;IAC9E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;kFAC8E;IAC9E,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;uEACmE;IACnE,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;yEAGqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;wBAIoB;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAqFnE"}

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

@@ -37,10 +37,12 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, w
 import { join } from "node:path";
 import { coordEnv } from "../../../lib/env.js";
 import { endOfTurnStatusCommand, hostPromptReminder, resolveBinName } from "../../config.js";
+import { canReceiveContext } from "../../hooks/adapter/output.js";
 import { readRemoteMachines } from "../../presence/index.js";
+import { drainMailbox, formatMailboxDelivery } from "../mailbox.js";
 import { sessionNameDisplayBlock, sessionNameDisplayPending } from "../session-name-display.js";
 import { readLiveCoordinationRow, readLiveCoordinationRows, } from "../state/live-coordination-view.js";
-import { formatPendingCouncils } from "./session-context.js";
+import { formatPendingCouncils, recordDeliveredMessages } from "./session-context.js";
 /**
  * Build the combined UserPromptSubmit additionalContext string. Returns "" when
  * nothing has changed since the last call (so the caller can skip the JSON emit).
@@ -50,19 +52,39 @@ import { formatPendingCouncils } from "./session-context.js";
  * councils are pending, matching the bash behavior).
  */
 export function renderPromptContext(opts) {
-    const { coordRoot, instanceId, sessionId, agentName, sessionNameNudge, taskNudge, hostPromptReminder: promptReminderEnabled, statusFooterNudge, turnRitualNudge, } = opts;
+    const { coordRoot, instanceId, sessionId, agentName, sessionNameNudge, taskNudge, hostPromptReminder: promptReminderEnabled, statusFooterNudge, turnRitualNudge, adapter, } = opts;
     const sections = [];
-    // 1. Peer table with hash dedup.
+    // The hook route does not pass --name, so resolve it from the heartbeat.
+    // Every name-addressed section below (messages, councils) is silently
+    // skipped without it.
+    const resolvedName = agentName ?? readLiveCoordinationRow(coordRoot, instanceId)?.name;
+    // 1. Peer messages. Drained first and never deduped: a message is delivered
+    // exactly once, and it is the one section here that carries new information
+    // from another agent rather than a reminder.
+    //
+    // Draining is gated on the adapter being able to receive this event's
+    // context. Cursor cannot, so draining there would empty the queue into output
+    // that is discarded; those sessions get their messages at SessionStart, which
+    // Cursor does deliver.
+    const canDeliverHere = !adapter || canReceiveContext(adapter, "UserPromptSubmit");
+    if (resolvedName && canDeliverHere) {
+        const delivered = drainMailbox(coordRoot, resolvedName);
+        if (delivered.length > 0) {
+            recordDeliveredMessages(instanceId, delivered);
+            sections.push(formatMailboxDelivery(coordRoot, delivered));
+        }
+    }
+    // 2. Peer table with hash dedup.
     const peerTable = computePeerTableIfChanged(coordRoot, instanceId, sessionId);
     if (peerTable)
         sections.push(peerTable);
-    // 2. Council pending with hash dedup.
-    if (agentName) {
-        const councilMsg = computeCouncilPendingIfChanged(coordRoot, instanceId, agentName);
+    // 3. Council pending with hash dedup.
+    if (resolvedName) {
+        const councilMsg = computeCouncilPendingIfChanged(coordRoot, instanceId, resolvedName);
         if (councilMsg)
             sections.push(councilMsg);
     }
-    // 3. First-session naming for every adapter, plus unset/stale-task reminders
+    // 4. First-session naming for every adapter, plus unset/stale-task reminders
     // for Cursor/Codex. One state machine avoids a second generic "task unset"
     // reminder immediately after the first-session reminder has been deduped.
     if (sessionNameNudge || taskNudge) {
@@ -73,7 +95,7 @@ export function renderPromptContext(opts) {
         if (nudgeMsg)
             sections.push(nudgeMsg);
     }
-    // 4. A supported adapter gets the host reminder on every prompt. The text is
+    // 5. A supported adapter gets the host reminder on every prompt. The text is
     // intentionally not hash-deduped or persisted into runtime state: freshness
     // is the feature, and the project config remains its only durable copy.
     if (promptReminderEnabled) {
@@ -81,7 +103,7 @@ export function renderPromptContext(opts) {
         if (reminder)
             sections.push(reminder);
     }
-    // 5. Codex gets this on every prompt. It is intentionally not hash-deduped:
+    // 6. Codex gets this on every prompt. It is intentionally not hash-deduped:
     // the reminder must be fresh in the model's context when it writes the reply.
     // Missing it is harmless because Codex Stop enforcement remains observe-only.
     if (statusFooterNudge) {
@@ -89,7 +111,7 @@ export function renderPromptContext(opts) {
         if (statusMsg)
             sections.push(statusMsg);
     }
-    // 6. Adapters whose Stop hook ENFORCES the turn ritual get a fresh reminder
+    // 7. 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
@@ -113,9 +135,8 @@ function renderTurnRitualReminder(coordRoot, selfInstanceId, adapter) {
         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"
+    // Claude Code and Cursor can both enforce completed assistant reply text.
+    const paste = adapter === "claude-code" || adapter === "cursor"
         ? " 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}. ` +

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

@@ -7,6 +7,7 @@
  * string.
  */
 import { statSync } from "node:fs";
+import { type MailboxMessageV1 } from "../mailbox.js";
 export interface RenderOpts {
     coordRoot: string;
     instanceId: string;
@@ -21,6 +22,13 @@ export interface RenderOpts {
  * string (or "" if there's nothing to say).
  */
 export declare function renderSessionContext(opts: RenderOpts): string;
+/**
+ * Write delivered peer messages into the recipient's own journal, so they
+ * survive context compaction the way any other coordination breadcrumb does.
+ * A message the sender already journaled (the recipient was live when it was
+ * sent) is skipped to avoid a duplicate entry.
+ */
+export declare function recordDeliveredMessages(instanceId: string, messages: readonly MailboxMessageV1[]): void;
 /**
  * Returns a list of commit-guard wiring issues (empty when wired). Portable
  * across host projects: it asserts the FUNCTIONAL property ("does this repo's

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;AAwB1E,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;AAkID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBvD;AA0DD;;;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;AAM1E,OAAO,EAAuC,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAoB3F,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,CAwF7D;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,IAAI,CAUN;AAkID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBvD;AA0DD;;;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

@@ -11,7 +11,9 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { resolveBinName, resolveHooksSetupHint } from "../../config.js";
 import { harneryVersion, loadAdapterWiring } from "../../hooks/adapter/wiring.js";
+import { appendEntry } from "../../journal/index.js";
 import { readRemoteMachines } from "../../presence/index.js";
+import { drainMailbox, formatMailboxDelivery } from "../mailbox.js";
 import { readLiveCoordinationRows } from "../state/live-coordination-view.js";
 import { readForkParent } from "../state/names.js";
 /**
@@ -50,13 +52,23 @@ export function renderSessionContext(opts) {
     if (isLinkedWorktree(coordRoot)) {
         messages.push(`Running inside worktree ${process.cwd()}. The coord layer is scoped to this worktree only; use \`${resolveBinName(coordRoot)} worktree diff\` to check for conflicts against sibling worktrees.`);
     }
-    // 3. Council invites
+    // 3. Peer messages queued for this name while no session held it. Draining
+    // here is what makes `agents ping` safe to use on a dormant agent: the sender
+    // never has to know whether the recipient is running.
+    if (agentName) {
+        const delivered = drainMailbox(coordRoot, agentName);
+        if (delivered.length > 0) {
+            recordDeliveredMessages(instanceId, delivered);
+            messages.push(formatMailboxDelivery(coordRoot, delivered));
+        }
+    }
+    // 4. Council invites
     if (agentName) {
         const councilMsg = formatPendingCouncils(coordRoot, agentName);
         if (councilMsg)
             messages.push(councilMsg);
     }
-    // 4. Commit-guard wiring check
+    // 5. Commit-guard wiring check
     const wiringIssues = checkWiring(coordRoot);
     if (wiringIssues.length > 0) {
         const hint = resolveHooksSetupHint(coordRoot);
@@ -66,7 +78,7 @@ export function renderSessionContext(opts) {
         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);
     }
-    // 5. Adapter-hook drift: a harnery upgrade changed the hook set, but this
+    // 6. Adapter-hook drift: a harnery upgrade changed the hook set, but this
     // project's settings file hasn't been re-wired. Only fires for a adapter the
     // project already opted into (≥1 hook wired), so it never nags a project that
     // simply has a settings file. Remedy is always `<bin> init` (idempotent).
@@ -89,6 +101,25 @@ export function renderSessionContext(opts) {
     }
     return messages.join("\n\n");
 }
+/**
+ * Write delivered peer messages into the recipient's own journal, so they
+ * survive context compaction the way any other coordination breadcrumb does.
+ * A message the sender already journaled (the recipient was live when it was
+ * sent) is skipped to avoid a duplicate entry.
+ */
+export function recordDeliveredMessages(instanceId, messages) {
+    for (const m of messages) {
+        if (m.journaled)
+            continue;
+        try {
+            appendEntry(instanceId, "handoff", `from agent-${m.from_name}: ${m.body}`);
+        }
+        catch {
+            // A journal write failure must never cost the delivery itself; the
+            // message is already in the rendered context the model reads.
+        }
+    }
+}
 /** One-line-per-agent view of sessions on other machines (presence refs). */
 function formatRemoteMachines(coordRoot) {
     try {

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;AAkBH,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"}
+{"version":3,"file":"commit-conflict.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/commit-conflict.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAoBH,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,CAgIhG"}

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

@@ -24,6 +24,7 @@ import { appendFileSync, existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 import { coordFreshnessSeconds } from "../../config.js";
 import { resolveOwner } from "../../hooks/resolve/owner.js";
+import { recordLiveClaimChangeV3 } from "../live-authority-v3.js";
 import { readLiveCoordinationRows } from "../state/live-coordination-view.js";
 import { instanceHasLivePid } from "../state/pidmap.js";
 export function evaluateCommit(coordRoot, req) {
@@ -120,6 +121,14 @@ export function evaluateCommit(coordRoot, req) {
             suppressed_self_attribution: true,
         };
     }
+    // A blocked commit proves this session has work in every staged path, even
+    // when the edit hook never acquired a claim (for example, a shell edit made
+    // just before another session claimed the same file). Keep those paths on
+    // the blocked session's durable claim set. The original holder's later
+    // commit will then see the overlap instead of silently sweeping this
+    // session's working-tree hunks. A successful later commit releases clean
+    // paths through the existing post-commit hook.
+    retainBlockedStagedPaths(coordRoot, me, mySession, req.staged_paths, peers);
     return {
         allow: false,
         exit_code: 1,
@@ -132,6 +141,37 @@ export function evaluateCommit(coordRoot, req) {
             "  active agents:",
     };
 }
+function retainBlockedStagedPaths(coordRoot, instanceId, sessionId, stagedPaths, peers) {
+    if (instanceId === "__unattributed__")
+        return;
+    const self = peers.find((peer) => peer.instance_id === instanceId);
+    if (!self)
+        return;
+    for (const path of stagedPaths) {
+        try {
+            recordLiveClaimChangeV3({
+                coordRoot,
+                owner: instanceId,
+                nativeSessionId: self.session_id ?? sessionId,
+                adapter: adapterFromPlatform(self.platform),
+                operation: "acquired",
+                path,
+                access: "write",
+            });
+        }
+        catch {
+            // The commit is already blocked. Coordination remains fail-open for
+            // authority-write failures so a damaged cache cannot brick Git.
+        }
+    }
+}
+function adapterFromPlatform(platform) {
+    if (platform === "cursor")
+        return "cursor";
+    if (platform === "codex")
+        return "codex";
+    return "claude-code";
+}
 function findOverlap(staged, files, coordRoot, stagedIsGitlink) {
     for (const claimed of files) {
         if (claimed === staged)
@@ -188,13 +228,22 @@ function isGitlinkInIndex(coordRoot, path) {
     return result.stdout.trim().startsWith("160000 ");
 }
 function isHolderSelfAttributed(coordRoot, holderId, stagedSet, peers) {
+    const holder = peers.find((p) => p.instance_id === holderId);
+    // Windows-hosted Codex sessions cross a process boundary into WSL, so they
+    // deliberately have no usable PID anchor. Their canonical V3 session row is
+    // the foreign-identity evidence instead. Treating that row as a transient
+    // self identity would suppress the symmetric claim retained after a blocked
+    // commit and reopen the working-tree sweep this guard is meant to stop.
+    if (holder?.platform === "codex" && holder.session_id) {
+        debugGate(coordRoot, { holder: holderId, gate: "B", reason: "canonical_codex_session" });
+        return false;
+    }
     // Gate B (cheaper): live foreign pid-map entry blocks self-attribution.
     if (holderHasLiveForeignPid(coordRoot, holderId)) {
         debugGate(coordRoot, { holder: holderId, gate: "B", reason: "live_pid_anchor" });
         return false;
     }
     // Gate A: every held path is either in the staged set or already clean in HEAD.
-    const holder = peers.find((p) => p.instance_id === holderId);
     if (!holder) {
         debugGate(coordRoot, { holder: holderId, gate: "A", reason: "holder_not_found" });
         return false;

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;;;;;;;;GAQG;AAOH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAM3D,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AAInE,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,CA6BvF;AAED,oFAAoF;AACpF,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,eAAe,EACpB,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,aAAa,CAuIf"}
+{"version":3,"file":"stop-hook.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/rules/stop-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAM3D,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,eAAO,MAAM,uBAAuB,8BAA8B,CAAC;AAInE,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,aAAa,CA6BvF;AAED,oFAAoF;AACpF,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,eAAe,EACpB,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,aAAa,CAiIf"}

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

@@ -91,17 +91,13 @@ export function evaluateStopHookV3Events(coordRoot, req, events) {
         .map((event) => observedBoolean(event.payload.ritual?.status_box_present_strict))
         .filter((value) => value !== undefined);
     const currentStrictBox = claudeContinuation ? req.status_box_present_strict : undefined;
-    if (req.adapter !== "cursor" && latestBox === undefined && currentStrictBox === undefined) {
+    if (latestBox === undefined && currentStrictBox === undefined) {
         return evidenceUnavailable("turn.completed has no observed V3 assistant-text status-box result; Stop remains fail-open");
     }
-    const ackPresent = req.adapter === "cursor"
-        ? requiredStatusChecked
-        : claudeContinuation
-            ? strictBoxObservations.includes(true) || currentStrictBox === true
-            : latestBox === true;
-    const ackBlock = req.adapter === "cursor"
-        ? () => rule13Block(coordRoot, req.session_id)
-        : () => rule23Block(coordRoot, req.session_id);
+    const ackPresent = claudeContinuation
+        ? strictBoxObservations.includes(true) || currentStrictBox === true
+        : latestBox === true;
+    const ackBlock = () => 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) {
@@ -260,7 +256,7 @@ function sessionIdSuffix(sessionId) {
  * 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.
+ * Duplicate rules are folded so one continuation repairs every missing signal.
  */
 function mergeStopBlocks(blocks) {
     let primary;

package/dist/core/agents/session-finalizer-v3.js

@@ -450,7 +450,10 @@ function observeCascades(coordRoot, route, records, events, lastByGeneration, no
             }
         }
         if (event.event_type === "lifecycle.sweep_observed" &&
-            event.payload.observation === "stale_sweep") {
+            // stale-sweep.ts emits the observation as `stale_heartbeat`; the
+            // finalization request it produces is the one named `stale_sweep`.
+            // Matching the request name here made this branch unreachable.
+            event.payload.observation === "stale_heartbeat") {
             const record = records.find(({ state }) => !state.terminal && state.instance_id === event.payload.subject_instance_id);
             const last = record ? lastByGeneration.get(record.state.generation_id) : undefined;
             if (!record?.state.last_event_id || !last)

package/dist/core/agents/session-name-display.d.ts

@@ -7,9 +7,29 @@
 export interface SessionNameDisplayState {
     suggested_session_name?: string;
     session_name_seen_for?: string;
+    session_name_display_requested_for?: string;
 }
 export declare const SESSION_NAME_DISPLAY_NOTE = "Next, before any prose or another tool call, send suggested_session_name verbatim by itself in a fenced code block.";
 export declare function sessionNameDisplayPending(row: SessionNameDisplayState | null | undefined): string | null;
+/**
+ * Every title whose exact display satisfies the current latch.
+ *
+ * The pending title always counts. The title the agent was last instructed to
+ * display also counts, because the harness — not the agent — is what changed
+ * the target after asking. Accepting it costs nothing the operator can see: a
+ * clean one-line block did open that reply. Refusing it left Cursor sessions
+ * permanently latched, since no Cursor surface can re-open a missed window.
+ */
+export declare function sessionNameDisplayAcceptedNames(row: SessionNameDisplayState | null | undefined): string[];
+/**
+ * Match assistant text against any accepted title and report which one closed
+ * the latch, so a drifted display can be stamped against the pending title and
+ * logged as drift rather than silently discarded.
+ */
+export declare function matchSessionNameDisplay(row: SessionNameDisplayState | null | undefined, text: string | undefined, startsWithBlock?: (text: string, expectedName: string) => boolean): {
+    pending: string;
+    displayed: string;
+} | null;
 export declare function sessionNameDisplayBlock(name: string): string;
 export declare function sessionNameDisplayInstruction(name: string): string;
 export declare function sessionNameDisplayRecoveryInstruction(name: string, binName: string): string;
@@ -26,11 +46,6 @@ export declare function sessionNameDisplayRecoveryInstruction(name: string, binN
  * activating the display ritual.
  */
 export declare function toolResponseMintedSessionName(response: unknown, name: string): boolean;
-/**
- * Accept the exact unlabelled block Harnery requests. `text` and `plaintext`
- * are tolerated for older prompts, but the code block may contain only the
- * suggested name and must be the first non-whitespace user-facing content.
- */
 export declare function assistantTextStartsWithSessionNameBlock(text: string, name: string): boolean;
 /**
  * The display latch must not block the two coordination commands that can

package/dist/core/agents/session-name-display.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-name-display.d.ts","sourceRoot":"","sources":["../../../src/core/agents/session-name-display.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,uBAAuB;IACtC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,eAAO,MAAM,yBAAyB,wHACiF,CAAC;AAExH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,uBAAuB,GAAG,IAAI,GAAG,SAAS,GAC9C,MAAM,GAAG,IAAI,CAIf;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASlE;AAED,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM3F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGtF;AAgDD;;;;GAIG;AACH,wBAAgB,uCAAuC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAK3F;AAUD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,EAAE,MAAM,GACd,OAAO,CAmBT"}
+{"version":3,"file":"session-name-display.d.ts","sourceRoot":"","sources":["../../../src/core/agents/session-name-display.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,uBAAuB;IACtC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,kCAAkC,CAAC,EAAE,MAAM,CAAC;CAC7C;AAED,eAAO,MAAM,yBAAyB,wHACiF,CAAC;AAExH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,uBAAuB,GAAG,IAAI,GAAG,SAAS,GAC9C,MAAM,GAAG,IAAI,CAIf;AAED;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAC7C,GAAG,EAAE,uBAAuB,GAAG,IAAI,GAAG,SAAS,GAC9C,MAAM,EAAE,CAKV;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,uBAAuB,GAAG,IAAI,GAAG,SAAS,EAC/C,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,eAAe,GAAE,CACf,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,KACjB,OAAiD,GACrD;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAO/C;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CASlE;AAED,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAM3F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAGtF;AAqFD,wBAAgB,uCAAuC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAI3F;AAUD;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,EAAE,MAAM,GACd,OAAO,CAmBT"}

package/dist/core/agents/session-name-display.js

@@ -11,6 +11,37 @@ export function sessionNameDisplayPending(row) {
         return null;
     return name;
 }
+/**
+ * Every title whose exact display satisfies the current latch.
+ *
+ * The pending title always counts. The title the agent was last instructed to
+ * display also counts, because the harness — not the agent — is what changed
+ * the target after asking. Accepting it costs nothing the operator can see: a
+ * clean one-line block did open that reply. Refusing it left Cursor sessions
+ * permanently latched, since no Cursor surface can re-open a missed window.
+ */
+export function sessionNameDisplayAcceptedNames(row) {
+    const pending = sessionNameDisplayPending(row);
+    if (!pending)
+        return [];
+    const requested = row?.session_name_display_requested_for;
+    return requested && requested !== pending ? [pending, requested] : [pending];
+}
+/**
+ * Match assistant text against any accepted title and report which one closed
+ * the latch, so a drifted display can be stamped against the pending title and
+ * logged as drift rather than silently discarded.
+ */
+export function matchSessionNameDisplay(row, text, startsWithBlock = assistantTextStartsWithSessionNameBlock) {
+    if (!text)
+        return null;
+    const accepted = sessionNameDisplayAcceptedNames(row);
+    const pending = accepted[0];
+    if (!pending)
+        return null;
+    const displayed = accepted.find((candidate) => startsWithBlock(text, candidate));
+    return displayed ? { pending, displayed } : null;
+}
 export function sessionNameDisplayBlock(name) {
     return `\`\`\`\n${name}\n\`\`\``;
 }
@@ -62,10 +93,16 @@ function responseContainsSessionNameMint(value, name, seen, depth) {
                 }
             }
             catch {
-                // Wrapper prose and partial JSON are not authoritative mint evidence.
+                // Fall through to the textual check below.
             }
         }
-        return false;
+        // The mint command's stdout often reaches the transcript mangled: cut
+        // short by `cut`/`head -c`, or with a tail-truncated first line. Whole-JSON
+        // parsing then fails even though the name and the mint flag are both
+        // legible, and a session that did mint can never latch. Accept the text
+        // when the exact quoted name sits under its key AND a mint flag is true;
+        // ordinary status output carries the name without any flag.
+        return textCarriesSessionNameMint(value, name);
     }
     if (typeof value !== "object")
         return false;
@@ -82,17 +119,40 @@ function responseContainsSessionNameMint(value, name, seen, depth) {
     }
     return Object.values(row).some((item) => responseContainsSessionNameMint(item, name, seen, depth + 1));
 }
+const MINT_FLAG_PATTERN = /"(?:first_of_session|name_reminted|session_name_retry)"\s*:\s*true\b/;
+function textCarriesSessionNameMint(text, name) {
+    const quotedName = JSON.stringify(name);
+    const keyIndex = text.indexOf('"suggested_session_name"');
+    if (keyIndex < 0)
+        return false;
+    const afterKey = text.slice(keyIndex + '"suggested_session_name"'.length);
+    const valueMatch = /^\s*:\s*("(?:[^"\\]|\\.)*")/.exec(afterKey);
+    if (!valueMatch || valueMatch[1] !== quotedName)
+        return false;
+    return MINT_FLAG_PATTERN.test(text);
+}
 /**
- * Accept the exact unlabelled block Harnery requests. `text` and `plaintext`
- * are tolerated for older prompts, but the code block may contain only the
- * suggested name and must be the first non-whitespace user-facing content.
+ * A leading fenced block whose only line is the suggested name.
+ *
+ * What the contract protects is what the operator sees: the reply opens with a
+ * code block containing exactly the title, so it renders as one clean
+ * copy-pasteable line. The fence's info string changes none of that, so any
+ * single-word language tag passes. Restricting it to `text`/`plaintext` meant a
+ * model that wrote ```txt or ```markdown produced a display the operator could
+ * read perfectly while the latch refused to close — and since nothing else can
+ * close a Cursor latch, that mismatch stranded the whole session.
+ *
+ * Still exact in every load-bearing way: the block is the first user-facing
+ * content, holds one line, and that line equals the name. The backreference
+ * requires the closing fence to match the opening run, so a longer fence cannot
+ * be closed by a shorter one.
  */
+const LEADING_SESSION_NAME_BLOCK = /^(`{3,})[ \t]*[A-Za-z0-9_.+#-]*[ \t]*\n([^\n]*)\n\1[ \t]*(?:\n|$)/;
 export function assistantTextStartsWithSessionNameBlock(text, name) {
     if (!text || !name)
         return false;
     const normalized = text.replace(/\r\n?/g, "\n").trimStart();
-    const match = /^```(?:text|plaintext)?[ \t]*\n([^\n]*)\n```(?:[ \t]*(?:\n|$))/.exec(normalized);
-    return match?.[1] === name;
+    return LEADING_SESSION_NAME_BLOCK.exec(normalized)?.[2] === name;
 }
 /**
  * A trailing stream redirect to `/dev/null` or another descriptor. Agents append