harnery 0.37.0 → 0.38.0

package/src/core/hooks/cli.ts

@@ -38,13 +38,20 @@ import { evaluateStopHook, STOP_REMEDIATION_MARKER } from "../agents/rules/stop-
 import {
   assistantTextStartsWithSessionNameBlock,
   isSessionNameRemediationCommand,
+  matchSessionNameDisplay,
+  sessionNameDisplayAcceptedNames,
   sessionNameDisplayInstruction,
   sessionNameDisplayPending,
   sessionNameDisplayRecoveryInstruction,
   toolResponseMintedSessionName,
 } from "../agents/session-name-display.ts";
 import type { Heartbeat } from "../agents/state/heartbeat-reader.ts";
-import { readHeartbeat, stampSessionNameSeen } from "../agents/state/heartbeat-writer.ts";
+import {
+  readHeartbeat,
+  setAssignedNameCache,
+  stampSessionNameRequested,
+  stampSessionNameSeen,
+} from "../agents/state/heartbeat-writer.ts";
 import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.ts";
 import { ensureLiveCoordinationHeartbeat } from "../agents/state/live-coordination-writer.ts";
 import { assignName } from "../agents/state/names.ts";
@@ -113,6 +120,7 @@ import {
 import { adapterPidFromEnv, parsePsChainLine, selectAnchorPid } from "./resolve/anchor.ts";
 import { extractIntentComment, resolveIntent } from "./resolve/intent.ts";
 import { resolveOwner } from "./resolve/owner.ts";
+import type { SessionNameDisplayInspection } from "./resolve/transcript.ts";
 import {
   inspectSessionNameDisplayImmediately,
   scanAssistantStatusBoxPresent,
@@ -245,6 +253,31 @@ function assignNameInProcess(
   }
 }
 
+/** Mid-flight sessions can emit tools before SessionStart assigns a pool name.
+ * Stamp the disposable cache so Codec does not render the 8-character id. */
+function ensureSessionDisplayName(
+  coordRoot: string,
+  instanceId: string,
+  sessionId: string,
+  adapter: Adapter,
+): void {
+  if (coordEnv("WORKFLOW_CHILD") === "1") return;
+  const row =
+    readLiveCoordinationRow(coordRoot, instanceId) ?? readHeartbeat(coordRoot, instanceId);
+  if (row?.kind === "subagent" || row?.kind === "transient" || row?.workflow_run_id) return;
+  if (row?.name?.trim()) return;
+  const assigned = assignNameInProcess(coordRoot, instanceId, "session");
+  if (!assigned?.name) return;
+  if (!readHeartbeat(coordRoot, instanceId)) {
+    try {
+      ensureLiveCoordinationHeartbeat(coordRoot, instanceId, sessionId, adapter);
+    } catch {
+      /* cache materialization is best-effort; history still holds the name */
+    }
+  }
+  setAssignedNameCache(coordRoot, instanceId, assigned.name, "session");
+}
+
 /**
  * Direct (in-process) pidmap write, avoiding the spawn overhead of going via
  * the agent-coord CLI for every session.started signal. Pid-map rows
@@ -376,13 +409,11 @@ function buildEventData(
       };
 
     case "turn.started": {
-      // Cursor can deliver beforeSubmitPrompt before sessionStart. Ensure that
-      // high-confidence prompt bootstrap also mints durable display identity;
-      // a later SessionStart remains idempotent.
-      if (
-        ctx.adapter === "cursor" &&
-        !readLiveCoordinationRow(ctx.coordRoot, ctx.instanceId)?.name
-      ) {
+      // Mid-flight onboarding (any adapter) can observe a turn before
+      // SessionStart. Mint durable display identity here so a later
+      // SessionStart remains idempotent and Codec is not stuck on the
+      // 8-character native id.
+      if (!readLiveCoordinationRow(ctx.coordRoot, ctx.instanceId)?.name) {
         assignNameInProcess(ctx.coordRoot, ctx.instanceId, "session");
       }
       const prompt = p?.prompt ?? "";
@@ -703,13 +734,32 @@ async function main(): Promise<number> {
       appendDebug(coordRoot, { ...debugBase, skipped: "no-owner-resolved" });
       return 0;
     }
-    const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, owner.instance_id));
+    const row = readLiveCoordinationRow(coordRoot, owner.instance_id);
+    const name = sessionNameDisplayPending(row);
     const text = typeof payload?.raw.text === "string" ? payload.raw.text : "";
-    if (name && assistantTextStartsWithSessionNameBlock(text, name)) {
-      stampSessionNameSeen(coordRoot, owner.instance_id, name);
-      appendDebug(coordRoot, { ...debugBase, effect: "session-name-display-stamped" });
+    const sighting = matchSessionNameDisplay(row, text);
+    if (sighting) {
+      stampSessionNameSeen(coordRoot, owner.instance_id, sighting.pending);
+      appendDebug(coordRoot, {
+        ...debugBase,
+        effect: "session-name-display-stamped",
+        session_name_pending: sighting.pending,
+        ...(sighting.displayed === sighting.pending
+          ? {}
+          : { session_name_displayed: sighting.displayed, session_name_drift: true }),
+      });
+    } else if (!name) {
+      // Nothing was owed. Distinct from a miss: conflating the two is what made
+      // a latched Cursor session undiagnosable from this log.
+      appendDebug(coordRoot, { ...debugBase, skipped: "no-pending-session-name" });
     } else {
-      appendDebug(coordRoot, { ...debugBase, skipped: "no-session-name-sighting" });
+      appendDebug(coordRoot, {
+        ...debugBase,
+        skipped: "session-name-block-absent",
+        session_name_pending: name,
+        reply_bytes: text.length,
+        reply_leads_with_fence: /^\s*`{3,}/.test(text),
+      });
     }
     if (ledgerRoute.state === "blocked") {
       appendDebug(coordRoot, {
@@ -784,6 +834,16 @@ async function main(): Promise<number> {
 
   const sessionId = payload?.session_id ?? payload?.conversation_id ?? owner.instance_id;
   const priorCoordination = readHeartbeat(coordRoot, owner.instance_id);
+  if (
+    norm.event_type !== "session.ended" &&
+    coordEnv("WORKFLOW_CHILD") !== "1" &&
+    priorCoordination?.kind !== "subagent" &&
+    priorCoordination?.kind !== "transient" &&
+    !priorCoordination?.workflow_run_id &&
+    !priorCoordination?.name?.trim()
+  ) {
+    assignNameInProcess(coordRoot, owner.instance_id, "session");
+  }
 
   const data = buildEventData(norm.event_type, {
     coordRoot,
@@ -879,6 +939,13 @@ async function main(): Promise<number> {
       logError(coordRoot, error, { phase: "epoch-coordination-restore" });
     }
   }
+  if (norm.event_type !== "session.ended") {
+    try {
+      ensureSessionDisplayName(coordRoot, owner.instance_id, sessionId, adapter);
+    } catch (error) {
+      logError(coordRoot, error, { phase: "session-display-name" });
+    }
+  }
   const v3EventId =
     v3Result && "event" in v3Result
       ? v3Result.event.event_id
@@ -1364,6 +1431,11 @@ async function main(): Promise<number> {
     try {
       const name = sessionNameDisplayPending(readLiveCoordinationRow(coordRoot, owner.instance_id));
       if (name && toolResponseMintedSessionName(payload?.tool_response, name)) {
+        // Record the title before asking for it. The suggestion can still
+        // change afterwards (an assigned-name rewrite, a lifecycle re-mint, a
+        // rebuilt cache), and the agent must not be stranded for displaying
+        // exactly what it was handed.
+        stampSessionNameRequested(coordRoot, owner.instance_id, name);
         const { emitContext } = await import("./adapter/output.ts");
         emitContext(adapter, "PostToolUse", sessionNameDisplayInstruction(name));
       }
@@ -1440,25 +1512,7 @@ async function enforcePendingSessionNameDisplay(
   const command = extractBashCommand(payload?.tool_name, payload?.tool_input);
   if (isSessionNameRemediationCommand(command, resolveBinName(coordRoot))) return true;
 
-  const inspection =
-    adapter === "cursor" && payload?.agent_message !== undefined
-      ? {
-          state: assistantTextStartsWithSessionNameBlock(payload.agent_message, name)
-            ? ("present" as const)
-            : ("unavailable" as const),
-        }
-      : inspectSessionNameDisplayImmediately(
-          // Codex hook payloads omit transcript_path on every event, which
-          // left this inspection permanently unavailable and the latch never
-          // stamped. Discover the rollout by session id; the scan only runs
-          // while a name is pending, so the latch closes after one success.
-          payload?.transcript_path ??
-            (adapter === "codex"
-              ? discoverCodexSessionTranscript(payload?.session_id ?? instanceId)
-              : undefined),
-          name,
-          assistantTextStartsWithSessionNameBlock,
-        );
+  const inspection = inspectDisplayEvidence(instanceId, adapter, payload, coordination);
   if (inspection.state === "present") {
     stampSessionNameSeen(coordRoot, instanceId, name);
     return true;
@@ -1473,11 +1527,65 @@ async function enforcePendingSessionNameDisplay(
     return true;
   }
 
+  // Record the refusal. Without this the gate was the one enforcement path
+  // that left no trace, so a session reporting "the gate keeps denying me"
+  // could not be confirmed or refuted from the hook log.
+  appendDebug(coordRoot, {
+    ts: new Date().toISOString(),
+    event_name: "pre-tool-use",
+    adapter,
+    effect: "session-name-display-denied",
+    session_name_pending: name,
+    tool_name: payload?.tool_name,
+  });
   const { emitDeny } = await import("./adapter/output.ts");
   emitDeny(adapter, sessionNameDisplayRecoveryInstruction(name, resolveBinName(coordRoot)));
   return false;
 }
 
+/**
+ * Evidence for the pending display, over every title whose display counts.
+ *
+ * Cursor supplies the current narration directly; Claude Code and Codex are
+ * resolved from their JSONL transcripts. Absent is the only state that denies,
+ * so a title is refused only when a readable surface positively shows some
+ * other opening text for every accepted title.
+ */
+function inspectDisplayEvidence(
+  instanceId: string,
+  adapter: Adapter,
+  payload: ParsedPayload | null,
+  coordination: Heartbeat | null,
+): SessionNameDisplayInspection {
+  if (adapter === "cursor" && payload?.agent_message !== undefined) {
+    return matchSessionNameDisplay(coordination, payload.agent_message)
+      ? { state: "present" }
+      : { state: "unavailable", reason: "transcript_not_ready" };
+  }
+
+  // Codex hook payloads omit transcript_path on every event, which left this
+  // inspection permanently unavailable and the latch never stamped. Discover
+  // the rollout by session id; the scan only runs while a name is pending, so
+  // the latch closes after one success.
+  const transcriptPath =
+    payload?.transcript_path ??
+    (adapter === "codex"
+      ? discoverCodexSessionTranscript(payload?.session_id ?? instanceId)
+      : undefined);
+
+  let verdict: SessionNameDisplayInspection = { state: "absent" };
+  for (const candidate of sessionNameDisplayAcceptedNames(coordination)) {
+    const inspection = inspectSessionNameDisplayImmediately(
+      transcriptPath,
+      candidate,
+      assistantTextStartsWithSessionNameBlock,
+    );
+    if (inspection.state === "present") return inspection;
+    if (inspection.state === "unavailable") verdict = inspection;
+  }
+  return verdict;
+}
+
 function generationBoundHeartbeat(
   heartbeat: Heartbeat | null,
   generationId: `gen_${string}` | undefined,

package/src/core/hooks/resolve/transcript.ts

@@ -167,9 +167,16 @@ export function inspectSessionNameDisplayImmediately(
       awaitingReply = false;
     }
   }
-  return sawMintResult && awaitingReply
-    ? { state: "unavailable", reason: "transcript_not_ready" }
-    : { state: "absent" };
+  // Some adapter transcripts persist assistant messages and tool requests but
+  // omit tool-result rows entirely. A readable file with no mint result cannot
+  // establish the ordered verification boundary, so it is unavailable evidence
+  // rather than proof that the agent displayed the title incorrectly. Only a
+  // transcript that contains the mint followed by a non-matching assistant
+  // reply can safely deny the next tool.
+  if (!sawMintResult || awaitingReply) {
+    return { state: "unavailable", reason: "transcript_not_ready" };
+  }
+  return { state: "absent" };
 }
 
 /**

package/src/core/hooks/session-name-presence.ts

@@ -22,6 +22,7 @@
  * Never throws: coordination telemetry must not take down a hook.
  */
 
+import { sessionNameDisplayAcceptedNames } from "../agents/session-name-display.ts";
 import { stampSessionNameSeen } from "../agents/state/heartbeat-writer.ts";
 import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.ts";
 
@@ -42,7 +43,11 @@ export function sessionNamePresence(
     if (row?.session_name_seen_for === name) {
       return { session_name_present: true, session_name_present_for: name };
     }
-    const present = scanAssistantText(name);
+    // A display of the title Harnery last asked for counts here too, so Stop
+    // and the PreToolUse gate cannot disagree about the same reply.
+    const present = sessionNameDisplayAcceptedNames(row).some((candidate) =>
+      scanAssistantText(candidate),
+    );
     if (present) stampSessionNameSeen(coordRoot, instanceId, name);
     return { session_name_present: present, session_name_present_for: name };
   } catch {

package/src/core/qa-artifacts.ts

@@ -0,0 +1,126 @@
+/**
+ * Managed output workspaces for page-QA commands.
+ *
+ * An implicit qa-run/qa-record output is working evidence, not project source.
+ * Keep it in the bounded artifact store. Callers that pass --out-dir retain
+ * full control of that explicit destination.
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import type { HarneryProgramContext } from "../commander.ts";
+import { monorepoRoot } from "./agents/index.ts";
+import {
+  ARTIFACT_MANIFEST,
+  type ArtifactManifestV2,
+  artifactsRoot,
+  configuredArtifactRetentionDays,
+  createArtifact,
+  parseArtifactManifest,
+} from "./artifacts/index.ts";
+
+export type QaArtifactKind = "qa-run" | "qa-record" | "review-pack";
+
+export function resolveQaRepoRoot(context?: HarneryProgramContext): string {
+  return resolve(context?.repoRoot ?? monorepoRoot() ?? process.cwd());
+}
+
+export function createManagedQaOutParent(
+  repoRoot: string,
+  kind: QaArtifactKind,
+  opts: { retentionMinutes?: number } = {},
+): string {
+  return createArtifact(repoRoot, {
+    slug: kind,
+    purpose:
+      kind === "qa-run"
+        ? "Page QA run evidence"
+        : kind === "review-pack"
+          ? "Page review pack"
+          : "Hand-recorded page QA evidence",
+    retentionDays: configuredArtifactRetentionDays(repoRoot),
+    // A standalone review-pack workspace IS the pack, so the artifact store's
+    // own expiry follows the pack's (90 minutes by default, ruled 2026-09-02).
+    ...(opts.retentionMinutes !== undefined ? { retentionMinutes: opts.retentionMinutes } : {}),
+  }).path;
+}
+
+/**
+ * Find the newest run in a valid managed QA workspace. This keeps no-path
+ * `qa-status` useful even though every implicit invocation gets an isolated
+ * artifact workspace instead of sharing one root-level `.qa-run` directory.
+ */
+export function latestManagedQaRun(repoRoot: string): string | null {
+  const root = artifactsRoot(repoRoot);
+  if (!existsSync(root)) return null;
+
+  let workspaceNames: string[];
+  try {
+    workspaceNames = readdirSync(root).sort();
+  } catch {
+    return null;
+  }
+
+  let latest: { path: string; startedAtMs: number } | null = null;
+  for (const workspaceName of workspaceNames) {
+    const workspace = join(root, workspaceName);
+    const manifest = readQaManifest(join(workspace, ARTIFACT_MANIFEST));
+    if (!manifest) continue;
+
+    let runNames: string[];
+    try {
+      runNames = readdirSync(workspace)
+        .filter((name) => name.startsWith("run-"))
+        .sort();
+    } catch {
+      continue;
+    }
+    for (const runName of runNames) {
+      const runDir = join(workspace, runName);
+      const startedAtMs = readStartedAtMs(runDir);
+      if (startedAtMs === null) continue;
+      if (
+        latest === null ||
+        startedAtMs > latest.startedAtMs ||
+        (startedAtMs === latest.startedAtMs && runDir > latest.path)
+      ) {
+        latest = { path: runDir, startedAtMs };
+      }
+    }
+  }
+  return latest?.path ?? null;
+}
+
+function readQaManifest(path: string): ArtifactManifestV2 | null {
+  try {
+    const parsed = parseArtifactManifest(JSON.parse(readFileSync(path, "utf8")));
+    if (!parsed.ok) return null;
+    if (parsed.manifest.slug !== "qa-run" && parsed.manifest.slug !== "qa-record") return null;
+    return parsed.manifest;
+  } catch {
+    return null;
+  }
+}
+
+function readStartedAtMs(runDir: string): number | null {
+  for (const file of ["run-status.json", "page-qa-result.json"]) {
+    try {
+      const value = JSON.parse(readFileSync(join(runDir, file), "utf8")) as Record<string, unknown>;
+      const run = value.run;
+      const startedAt =
+        typeof value.started_at === "string"
+          ? value.started_at
+          : run &&
+              typeof run === "object" &&
+              typeof (run as Record<string, unknown>).started_at === "string"
+            ? ((run as Record<string, unknown>).started_at as string)
+            : null;
+      if (!startedAt) continue;
+      const parsed = Date.parse(startedAt);
+      if (!Number.isNaN(parsed)) return parsed;
+    } catch {
+      // Try the other authoritative run document.
+    }
+  }
+  return null;
+}

package/src/core/resources/contract.ts

@@ -16,6 +16,7 @@ export interface ResourceProcessSample {
   owner_kind: "agent" | "service" | "unattributed";
   owner_id: string | null;
   owner_root_pid: number | null;
+  owner_source?: "pid-map" | "session-environment" | "service";
 }
 
 export interface ResourceProcessGroup {
@@ -90,6 +91,12 @@ export interface ResourceSamplerState {
   cpu_total_ticks: number;
   cpu_idle_ticks: number;
   process_ticks: Map<string, number>;
+  process_owners: Map<string, ResourceProcessOwnerProof>;
+}
+
+export interface ResourceProcessOwnerProof {
+  session_id: string;
+  instance_id: string;
 }
 
 export interface ResourceSampleResult {

package/src/core/resources/sampler.ts

@@ -3,11 +3,13 @@ import { existsSync, readdirSync, readFileSync, readlinkSync } from "node:fs";
 import { cpus, loadavg, platform, release } from "node:os";
 import { basename, join } from "node:path";
 import { performance } from "node:perf_hooks";
+import { readLiveCoordinationRows } from "../agents/state/live-coordination-view.ts";
 import { parsePidmapRow } from "../agents/state/pidmap.ts";
 import { checkPidToken } from "../agents/state/proc-start.ts";
 import {
   RESOURCE_SNAPSHOT_SCHEMA_VERSION,
   type ResourceProcessGroup,
+  type ResourceProcessOwnerProof,
   type ResourceProcessSample,
   type ResourceSampleResult,
   type ResourceSamplerState,
@@ -44,11 +46,19 @@ interface ResourceSamplerOptions {
   clockTicks?: number;
   pageSize?: number;
   services?: readonly { pid: number; id: string }[];
+  sessionOwners?: readonly SessionOwner[];
   unattributedCpuFloor?: number;
   unattributedRssFloor?: number;
   maxProcesses?: number;
 }
 
+interface SessionOwner {
+  nativeSessionId: string;
+  instanceId: string;
+  platform: string;
+  kind: string;
+}
+
 let cachedClockTicks: number | undefined;
 let cachedPageSize: number | undefined;
 
@@ -86,7 +96,24 @@ export function sampleResources(
   const cpu = parseLinuxCpu(readFileSync(join(procRoot, "stat"), "utf8"));
   const memory = parseMeminfo(readFileSync(join(procRoot, "meminfo"), "utf8"));
   const readings = readLinuxProcesses(procRoot, clockTicks, pageSize, uptimeSeconds);
-  const anchors = readOwnershipAnchors(coordRoot, readings, options.services ?? []);
+  const liveSessionOwners = uniqueLiveCodexSessionOwners(
+    options.sessionOwners ??
+      readLiveCoordinationRows(coordRoot).map((row) => ({
+        nativeSessionId: row.native_session_id ?? "",
+        instanceId: row.instance_id,
+        platform: row.platform ?? "",
+        kind: row.kind ?? "",
+      })),
+  );
+  const ownership = readOwnershipAnchors(
+    coordRoot,
+    procRoot,
+    readings,
+    options.services ?? [],
+    liveSessionOwners,
+    previous?.process_owners,
+  );
+  const anchors = ownership.anchors;
   const byPid = new Map(readings.map((reading) => [reading.pid, reading]));
   const processTicks = new Map<string, number>();
   const intervalMs = previous ? Math.max(0, nowMs - previous.sampled_at_ms) : null;
@@ -116,6 +143,7 @@ export function sampleResources(
       owner_kind: ownership?.kind ?? "unattributed",
       owner_id: ownership?.id ?? null,
       owner_root_pid: ownership?.rootPid ?? null,
+      ...(ownership ? { owner_source: ownership.source } : {}),
     };
   });
   const visible = processes
@@ -182,6 +210,7 @@ export function sampleResources(
       cpu_total_ticks: cpu.total,
       cpu_idle_ticks: cpu.idle,
       process_ticks: processTicks,
+      process_owners: ownership.processOwners,
     },
   };
 }
@@ -288,13 +317,20 @@ function readLinuxProcesses(
 interface OwnershipAnchor {
   kind: "agent" | "service";
   id: string;
+  source: "pid-map" | "session-environment" | "service";
 }
 
 function readOwnershipAnchors(
   coordRoot: string,
+  procRoot: string,
   readings: readonly LinuxProcessReading[],
   services: readonly { pid: number; id: string }[],
-): Map<number, OwnershipAnchor> {
+  liveSessionOwners: ReadonlyMap<string, string>,
+  previousOwners?: ReadonlyMap<string, ResourceProcessOwnerProof>,
+): {
+  anchors: Map<number, OwnershipAnchor>;
+  processOwners: Map<string, ResourceProcessOwnerProof>;
+} {
   const byPid = new Set(readings.map((row) => row.pid));
   const directory = join(coordRoot, ".harnery", "pid-map");
   const anchors = new Map<number, OwnershipAnchor>();
@@ -306,25 +342,121 @@ function readOwnershipAnchors(
       try {
         const row = parsePidmapRow(readFileSync(join(directory, entry), "utf8"));
         if (!row.instanceId || checkPidToken(pid, row.startToken) === "mismatch") continue;
-        anchors.set(pid, { kind: "agent", id: row.instanceId });
+        anchors.set(pid, { kind: "agent", id: row.instanceId, source: "pid-map" });
       } catch {
         // An unreadable or racing row cannot prove ownership.
       }
     }
   }
+
+  const processOwners = readBridgeProcessOwners(
+    procRoot,
+    readings,
+    liveSessionOwners,
+    previousOwners,
+  );
+  const byReadingPid = new Map(readings.map((row) => [row.pid, row]));
+  for (const reading of readings) {
+    const identity = `${reading.pid}:${reading.startTicks}`;
+    const owner = processOwners.get(identity);
+    if (!owner || anchors.has(reading.pid)) continue;
+    const parent = byReadingPid.get(reading.ppid);
+    const parentOwner = parent
+      ? processOwners.get(`${parent.pid}:${parent.startTicks}`)
+      : undefined;
+    if (parentOwner?.instance_id === owner.instance_id) continue;
+    anchors.set(reading.pid, {
+      kind: "agent",
+      id: owner.instance_id,
+      source: "session-environment",
+    });
+  }
+
   for (const service of services) {
     if (byPid.has(service.pid) && service.id.trim()) {
-      anchors.set(service.pid, { kind: "service", id: service.id.trim() });
+      anchors.set(service.pid, { kind: "service", id: service.id.trim(), source: "service" });
     }
   }
-  return anchors;
+  return { anchors, processOwners };
+}
+
+function uniqueLiveCodexSessionOwners(rows: readonly SessionOwner[]): Map<string, string> {
+  const candidates = new Map<string, Set<string>>();
+  for (const row of rows) {
+    const sessionId = row.nativeSessionId.trim();
+    const instanceId = row.instanceId.trim();
+    if (row.platform !== "codex" || row.kind !== "session" || !sessionId || !instanceId) continue;
+    const owners = candidates.get(sessionId) ?? new Set<string>();
+    owners.add(instanceId);
+    candidates.set(sessionId, owners);
+  }
+  const result = new Map<string, string>();
+  for (const [sessionId, owners] of candidates) {
+    if (owners.size === 1) result.set(sessionId, [...owners][0]!);
+  }
+  return result;
+}
+
+function readBridgeProcessOwners(
+  procRoot: string,
+  readings: readonly LinuxProcessReading[],
+  liveSessionOwners: ReadonlyMap<string, string>,
+  previousOwners?: ReadonlyMap<string, ResourceProcessOwnerProof>,
+): Map<string, ResourceProcessOwnerProof> {
+  const result = new Map<string, ResourceProcessOwnerProof>();
+  if (liveSessionOwners.size === 0) return result;
+  for (const reading of readings) {
+    const identity = `${reading.pid}:${reading.startTicks}`;
+    const previous = previousOwners?.get(identity);
+    if (previous && liveSessionOwners.get(previous.session_id) === previous.instance_id) {
+      result.set(identity, previous);
+      continue;
+    }
+    const sessionId = readCodexWslBridgeSessionId(procRoot, reading.pid);
+    if (!sessionId) continue;
+    const instanceId = liveSessionOwners.get(sessionId);
+    if (instanceId) result.set(identity, { session_id: sessionId, instance_id: instanceId });
+  }
+  return result;
+}
+
+function readCodexWslBridgeSessionId(procRoot: string, pid: number): string | undefined {
+  try {
+    const entries = readFileSync(join(procRoot, String(pid), "environ"), "utf8").split("\0");
+    let bridge: string | undefined;
+    let platform: string | undefined;
+    let coordinationSessionId: string | undefined;
+    let codexThreadId: string | undefined;
+    for (const entry of entries) {
+      if (entry.startsWith("HARNERY_AGENT_COORD_BRIDGE=")) {
+        bridge = entry.slice("HARNERY_AGENT_COORD_BRIDGE=".length);
+      } else if (entry.startsWith("HARNERY_AGENT_COORD_PLATFORM=")) {
+        platform = entry.slice("HARNERY_AGENT_COORD_PLATFORM=".length);
+      } else if (entry.startsWith("HARNERY_AGENT_COORD_SESSION_ID=")) {
+        coordinationSessionId = entry.slice("HARNERY_AGENT_COORD_SESSION_ID=".length);
+      } else if (entry.startsWith("CODEX_THREAD_ID=")) {
+        codexThreadId = entry.slice("CODEX_THREAD_ID=".length);
+      }
+    }
+    if (
+      bridge === "codex-wsl" &&
+      platform === "codex" &&
+      coordinationSessionId &&
+      coordinationSessionId === codexThreadId
+    ) {
+      return coordinationSessionId;
+    }
+  } catch {
+    // An unreadable or racing environment cannot prove ownership.
+  }
+  return undefined;
 }
 
 function resolveOwnership(
   pid: number,
   byPid: ReadonlyMap<number, LinuxProcessReading>,
   anchors: ReadonlyMap<number, OwnershipAnchor>,
-): { kind: "agent" | "service"; id: string; rootPid: number } | undefined {
+): (OwnershipAnchor & { rootPid: number }) | undefined {
   const seen = new Set<number>();
   let cursor = pid;
   for (let hops = 0; hops < 64 && cursor > 0 && !seen.has(cursor); hops++) {