harnery 0.40.0 → 0.41.0

package/src/commands/webview.ts

@@ -0,0 +1,159 @@
+import { resolve } from "node:path";
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.ts";
+import { commandPaceGate } from "../lib/pace/index.ts";
+import {
+  parseWebViewTypeStep,
+  parseWebViewViewport,
+  runWebView,
+  type WebViewBackend,
+  WebViewUnavailableError,
+} from "../lib/webview/index.ts";
+
+/**
+ * `harn webview`: a lightweight headless page probe through Bun.WebView.
+ *
+ * Experimental and Bun-only (Bun 1.4+). It always launches a fresh browser with
+ * ephemeral storage unless `--profile` is given, and never attaches to a
+ * running user browser. Use `browse` for headed login, the shared cookie jar,
+ * HAR capture, full-page screenshots, and page QA; use `browse-ai` for
+ * accessibility-tree element references. On Node the command fails with a
+ * clear message, matching how `tunnel` handles its Bun-only worker.
+ */
+
+interface WebviewOpts {
+  userAgent?: string;
+  backend: string;
+  viewport: string;
+  profile?: string;
+  chromePath?: string;
+  browserArg: string[];
+  timeout: string;
+  waitFor?: string;
+  type: string[];
+  click: string[];
+  press: string[];
+  evaluate?: string;
+  settle: string;
+  screenshot?: string;
+  html?: boolean;
+  json?: boolean;
+  pace?: boolean;
+}
+
+export function registerWebviewCommand(program: Command, emit: EmitContext, binName: string): void {
+  program
+    .command("webview <url>")
+    .description(
+      "Lightweight headless page probe through Bun.WebView (experimental, Bun 1.4+). " +
+        `Fresh ephemeral browser per call; use ${binName} browse for login, cookies, HAR, and QA.`,
+    )
+    .option("--backend <engine>", "Browser engine: auto | chrome | webkit", "auto")
+    .option(
+      "--user-agent <ua>",
+      "Chrome user agent: shared store by default; auto refreshes, native disables",
+    )
+    .option("--viewport <WxH>", "Viewport in CSS pixels", "1280x800")
+    .option(
+      "--profile <dir>",
+      "Persist cookies and local storage in this directory (default is ephemeral)",
+    )
+    .option("--chrome-path <path>", "Chrome-family executable; implies the Chrome backend")
+    .option("--browser-arg <flag>", "Extra Chrome launch flag (repeatable)", collect, [])
+    .option("--timeout <ms>", "Navigation and selector timeout in milliseconds", "30000")
+    .option("--wait-for <css>", "Wait for a CSS selector after navigation")
+    .option(
+      "--type <css=>text>",
+      "Focus a selector and insert text (repeatable; runs before clicks)",
+      collect,
+      [],
+    )
+    .option("--click <css>", "Scroll to and click a CSS selector (repeatable)", collect, [])
+    .option(
+      "--press <key>",
+      "Press a key in the currently focused element (repeatable)",
+      collect,
+      [],
+    )
+    .option("--evaluate <expression>", "Evaluate a JavaScript expression after actions")
+    .option("--settle <ms>", "Extra delay after actions before capture", "0")
+    .option(
+      "--screenshot <path>",
+      "Save a viewport PNG (Bun.WebView does not provide full-page capture)",
+    )
+    .option("--html", "Print the final document HTML instead of body text")
+    .option("--json", "Print the full result envelope")
+    .option(
+      "--no-pace",
+      "Skip the human-pace gap (3 to 9 s) between page loads of the same site for this run. " +
+        "HARNERY_PACE=off disables it machine-wide; local and private hosts never wait.",
+    )
+    .action(async (url: string, opts: WebviewOpts) => {
+      try {
+        await runWebview(url, opts, emit);
+      } catch (err: unknown) {
+        const message = err instanceof Error ? err.message : String(err);
+        emit.error({
+          code: err instanceof WebViewUnavailableError ? err.code : "webview_error",
+          message,
+        });
+        process.exit(1);
+      }
+    });
+}
+
+async function runWebview(url: string, opts: WebviewOpts, emit: EmitContext): Promise<void> {
+  if (!isBackend(opts.backend)) {
+    throw new Error(`Invalid backend "${opts.backend}". Expected auto, chrome, or webkit.`);
+  }
+  const backend = opts.backend === "auto" && opts.chromePath ? "chrome" : opts.backend;
+  const result = await runWebView(url, {
+    backend,
+    viewport: parseWebViewViewport(opts.viewport),
+    profileDir: opts.profile ? resolve(opts.profile) : undefined,
+    chromePath: opts.chromePath ? resolve(opts.chromePath) : undefined,
+    browserArgs: opts.browserArg,
+    timeoutMs: parseNonNegativeInteger(opts.timeout, "--timeout", false),
+    waitFor: opts.waitFor,
+    typeSteps: opts.type.map(parseWebViewTypeStep),
+    clicks: opts.click,
+    presses: opts.press,
+    evaluate: opts.evaluate,
+    settleMs: parseNonNegativeInteger(opts.settle, "--settle", true),
+    screenshotPath: opts.screenshot ? resolve(opts.screenshot) : undefined,
+    captureHtml: opts.html === true,
+    pace: commandPaceGate(opts.pace !== false, (message) => emit.log(message, "info")),
+    userAgent: opts.userAgent,
+  });
+
+  if (opts.json) {
+    emit.data(result);
+  } else if (opts.html) {
+    emit.text(result.html?.endsWith("\n") ? result.html : `${result.html ?? ""}\n`);
+  } else if (opts.evaluate !== undefined) {
+    const value =
+      typeof result.evaluation === "string"
+        ? result.evaluation
+        : JSON.stringify(result.evaluation, null, 2);
+    emit.text(`${value ?? "undefined"}\n`);
+  } else {
+    emit.text(result.text.endsWith("\n") ? result.text : `${result.text}\n`);
+  }
+}
+
+function collect(value: string, previous: string[]): string[] {
+  return [...previous, value];
+}
+
+function isBackend(value: string): value is WebViewBackend {
+  return value === "auto" || value === "chrome" || value === "webkit";
+}
+
+function parseNonNegativeInteger(value: string, flag: string, allowZero: boolean): number {
+  if (!/^\d+$/.test(value)) throw new Error(`${flag} expects an integer, got "${value}".`);
+  const parsed = Number.parseInt(value, 10);
+  if ((!allowZero && parsed < 1) || (allowZero && parsed < 0)) {
+    throw new Error(`${flag} must be ${allowZero ? "zero or greater" : "greater than zero"}.`);
+  }
+  return parsed;
+}

package/src/core/adapter.ts

@@ -1,5 +1,106 @@
 /** First-party harness adapters supported by Harnery's canonical V3 ledger. */
-export type Adapter = "claude-code" | "cursor" | "codex";
+export type Adapter = "claude-code" | "cursor" | "codex" | "opencode";
 
 /** Canonical producer classes used by V3 provenance. */
 export type EventSource = "agent-hooks" | "agent-coord" | "user" | "system";
+
+/**
+ * Runtime census of the workflow adapters. Adding a member to `Adapter`
+ * without listing it here is a compile error (see `adaptersComplete`), so a
+ * new adapter can never slip past the shared normalizer.
+ */
+export const ADAPTERS = [
+  "claude-code",
+  "cursor",
+  "codex",
+  "opencode",
+] as const satisfies readonly Adapter[];
+
+type MissingAdapter = Exclude<Adapter, (typeof ADAPTERS)[number]>;
+const adaptersComplete: [MissingAdapter] extends [never] ? true : never = true;
+void adaptersComplete;
+
+/** Every adapter falls back to this identity when a platform value carries no usable evidence. */
+export const DEFAULT_ADAPTER: Adapter = "claude-code";
+
+/** Why a platform value could not be normalized to a known adapter. */
+export type AdapterFallbackReason = "missing" | "unknown";
+
+export interface AdapterFallback {
+  /** The raw value that was normalized. */
+  value: unknown;
+  /** `missing` for null, undefined, or an empty string; `unknown` for anything else. */
+  reason: AdapterFallbackReason;
+  /** The adapter that was substituted. */
+  fallback: string;
+  /** Caller-supplied label naming the code path, for the diagnostic line. */
+  context?: string;
+}
+
+export interface AdapterFallbackOptions {
+  /** Names the caller in the diagnostic line, e.g. `"claim-conflict"`. */
+  context?: string;
+  /**
+   * Receives every fallback. The default writes one stderr line per unknown
+   * value; a missing value is a pre-heartbeat state rather than a
+   * misattribution, so it is passed here but not printed.
+   */
+  onFallback?: (fallback: AdapterFallback) => void;
+}
+
+/**
+ * Generic membership normalizer shared by every adapter census. Returns the
+ * matching id or `null`; it never substitutes a default.
+ */
+export function normalizeAdapterId<T extends string>(
+  value: unknown,
+  census: readonly T[],
+): T | null {
+  if (typeof value !== "string") return null;
+  return (census as readonly string[]).includes(value) ? (value as T) : null;
+}
+
+/**
+ * Normalize with an explicit, reported fallback. Every caller that must end up
+ * with *some* adapter routes through here so the substitution is visible.
+ */
+export function resolveAdapterId<T extends string>(
+  value: unknown,
+  census: readonly T[],
+  fallback: T,
+  options: AdapterFallbackOptions = {},
+): T {
+  const normalized = normalizeAdapterId(value, census);
+  if (normalized !== null) return normalized;
+  const reason: AdapterFallbackReason =
+    value === undefined || value === null || value === "" ? "missing" : "unknown";
+  (options.onFallback ?? reportAdapterFallback)({
+    value,
+    reason,
+    fallback,
+    context: options.context,
+  });
+  return fallback;
+}
+
+/** Default fallback sink: one stderr line for an unrecognized platform value. */
+export function reportAdapterFallback(fallback: AdapterFallback): void {
+  if (fallback.reason !== "unknown") return;
+  const where = fallback.context ? ` (${fallback.context})` : "";
+  process.stderr.write(
+    `harnery: unknown adapter platform ${JSON.stringify(fallback.value)}${where}; treating it as ${fallback.fallback}\n`,
+  );
+}
+
+/** Strict workflow-adapter normalizer: a known id or `null`. */
+export function normalizeAdapter(value: unknown): Adapter | null {
+  return normalizeAdapterId(value, ADAPTERS);
+}
+
+/**
+ * Heartbeat `platform` (or any adapter-shaped string) to a workflow adapter,
+ * substituting `DEFAULT_ADAPTER` and reporting the substitution.
+ */
+export function adapterFromPlatform(value: unknown, options?: AdapterFallbackOptions): Adapter {
+  return resolveAdapterId(value, ADAPTERS, DEFAULT_ADAPTER, options);
+}

package/src/core/adapters/attestation.ts

@@ -22,6 +22,7 @@ import {
 } from "node:fs";
 import { resolve } from "node:path";
 import { monorepoRoot } from "../agents/coord-client.ts";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { stableDigest } from "../workflow/durable-record.ts";
 import type { AdapterId, AdapterProfile, CapabilitySupport } from "./types.ts";
 
@@ -107,12 +108,12 @@ export function writeAttestation(
   opts: AttestationStoreOptions = {},
 ): string {
   const path = attestationPath(record.adapter, opts);
-  mkdirSync(attestationsDir(opts), { recursive: true, mode: 0o700 });
+  mkdirSync(attestationsDir(opts), { recursive: true, mode: stateDirMode() });
   const temporary = `${path}.tmp-${process.pid}`;
   try {
     writeFileSync(temporary, `${JSON.stringify(record, null, 2)}\n`, {
       encoding: "utf8",
-      mode: 0o600,
+      mode: stateFileMode(),
     });
     renameSync(temporary, path);
   } catch (error) {

package/src/core/adapters/profiles.ts

@@ -106,7 +106,7 @@ export const BUILTIN_ADAPTER_PROFILES = {
     authModel: "own-auth",
     modelFamily: "multi",
     effortValues: [],
-    verified: { date: "2026-08-18", version: "2026.08.11-e8db854" },
+    verified: { date: "2026-09-20", version: "2026.09.18-9a7762b" },
     capabilities: capabilities({
       effortSelection: unsupported(
         "Cursor embeds effort in some parameterized model ids; Harnery does not rewrite model ids.",
@@ -114,6 +114,10 @@ export const BUILTIN_ADAPTER_PROFILES = {
       maxTurns: unsupported("cursor-agent exposes no turn-ceiling flag."),
       sessionId: supported("Read from the JSON result envelope."),
       cost: unsupported("The JSON result envelope carries no cost."),
+      // Still unknown on 2026-09-20 against cursor-agent 2026.09.18: the live
+      // `cursor_composer_context_percent` reader serves IDE hook sessions from
+      // the composer `state.vscdb`, and headless `cursor-agent` children (this
+      // workflow adapter) leave no composer row and no usage in the JSON result.
       contextTelemetry: unknown("No stable Cursor context-usage payload has been certified."),
       preCompactionSignal: supported("Cursor preCompact is wired to a durable checkpoint."),
       postCompactionSignal: unsupported(
@@ -121,6 +125,43 @@ export const BUILTIN_ADAPTER_PROFILES = {
       ),
     }),
   },
+  opencode: {
+    id: "opencode",
+    displayName: "OpenCode",
+    binary: "opencode",
+    installHint: "curl -fsSL https://opencode.ai/install | bash",
+    loginHint: "opencode auth login",
+    apiKeyEnv: "OPENCODE_API_KEY",
+    integrationMode: "cli-subprocess",
+    authModel: "own-auth",
+    modelFamily: "multi",
+    // Model reasoning is selected through the `provider/model#variant` id;
+    // OpenCode exposes no separate effort dial for Harnery to map.
+    effortValues: [],
+    verified: { date: "2026-09-20", version: "opencode v2.0.11" },
+    capabilities: capabilities({
+      effortSelection: unsupported(
+        "OpenCode selects reasoning through the model id variant; there is no separate effort flag.",
+      ),
+      maxTurns: unsupported("`opencode run` exposes no turn-ceiling flag."),
+      sessionId: supported("Read from the `sessionID` on every `--format json` NDJSON line."),
+      cost: unsupported(
+        "`opencode run --format json` streams parts without a final cost; cost lives in `session export`.",
+      ),
+      // Tool evidence is delivered on the event axis by the Harnery OpenCode
+      // plugin, not by the final-result workflow spawn, which retains no tool
+      // events (as with Codex and Cursor).
+      contextTelemetry: unknown(
+        "OpenCode stores context in SQLite; no context-window bridge is certified yet.",
+      ),
+      preCompactionSignal: supported(
+        'OpenCode session.hook("compaction") is bridged to a durable checkpoint.',
+      ),
+      postCompactionSignal: unsupported(
+        "No post-compact hook is wired; OpenCode post-compaction recovery is not yet certified.",
+      ),
+    }),
+  },
 } as const satisfies Record<string, AdapterProfile>;
 
 export type BuiltinAdapterId = keyof typeof BUILTIN_ADAPTER_PROFILES;

package/src/core/adapters/registry.ts

@@ -13,6 +13,11 @@ import {
   cursorSpawner,
   normalizeCursorResult,
 } from "../workflow/spawn-cursor.ts";
+import {
+  buildOpenCodeInvocation,
+  normalizeOpenCodeResult,
+  openCodeSpawner,
+} from "../workflow/spawn-opencode.ts";
 import {
   BUILTIN_ADAPTER_IDS,
   BUILTIN_ADAPTER_PROFILES,
@@ -85,6 +90,38 @@ const BUILTIN_ADAPTERS: Record<BuiltinAdapterId, Adapter> = {
       },
     },
   },
+  opencode: {
+    profile: BUILTIN_ADAPTER_PROFILES.opencode,
+    spawn: openCodeSpawner,
+    buildInvocation: buildOpenCodeInvocation,
+    normalizeResult: normalizeOpenCodeResult,
+    fixture: {
+      // `opencode run --format json` streams NDJSON: a step-start line then one
+      // or more text parts, each carrying the same sessionID.
+      raw: {
+        stdout: [
+          JSON.stringify({
+            type: "step_start",
+            sessionID: "opencode-bench-session",
+            part: { type: "step-start" },
+          }),
+          JSON.stringify({
+            type: "text",
+            sessionID: "opencode-bench-session",
+            part: { type: "text", text: "HARNERY_BENCH_OK" },
+          }),
+        ].join("\n"),
+        stderr: "",
+        exitCode: 0,
+        durationMs: 11,
+      },
+      expected: {
+        ok: true,
+        text: "HARNERY_BENCH_OK",
+        sessionId: "opencode-bench-session",
+      },
+    },
+  },
 };
 
 /** Mutable registry for embedders, initialized empty unless adapters are

package/src/core/agents/canonical-emit.ts

@@ -11,7 +11,7 @@
  */
 
 import { spawnSync } from "node:child_process";
-import type { EventAdapterIdV3 } from "../events/v3/adapter-id.ts";
+import { type EventAdapterIdV3, eventAdapterIdV3FromPlatform } from "../events/v3/adapter-id.ts";
 import type { LiveCoordinationObservationV3 } from "../events/v3/live-observation.ts";
 import { coordBinPath } from "./coord-bin.ts";
 import { resolveCoordRoot } from "./coord-client.ts";
@@ -94,10 +94,7 @@ export function emitEventV3(input: EventV3EmitInput): boolean {
  * Normalize the heartbeat's `platform` field to the canonical Adapter type.
  */
 export function normalizeAdapter(platform: string | undefined): EventAdapterIdV3 {
-  if (platform === "cursor") return "cursor";
-  if (platform === "codex") return "codex";
-  if (platform === "openclaw") return "openclaw";
-  return "claude-code";
+  return eventAdapterIdV3FromPlatform(platform, { context: "canonical-emit" });
 }
 
 /** Producer joins use the private native session ID, never its V3 fingerprint. */

package/src/core/agents/cli.ts

@@ -13,6 +13,8 @@ import { appendFile, mkdir } from "node:fs/promises";
 import { hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { coordEnv } from "../../lib/env.ts";
+import { normalizeAdapter, adapterFromPlatform as sharedAdapterFromPlatform } from "../adapter.ts";
+import { resolveBinName } from "../config.ts";
 import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.ts";
 import { acquireNoClobberLease } from "../workflow/workspaces/leases.ts";
 
@@ -166,12 +168,6 @@ async function handleProject(root: string, rest: string[]): Promise<number> {
   return view.authority_safe ? 0 : 1;
 }
 
-function adapterFromPlatform(platform: unknown): "claude-code" | "cursor" | "codex" {
-  if (platform === "cursor") return "cursor";
-  if (platform === "codex") return "codex";
-  return "claude-code";
-}
-
 const coordinationRetryCell = new Int32Array(new SharedArrayBuffer(4));
 const COORDINATION_RETRY_ATTEMPTS = 240;
 const COORDINATION_RETRY_DELAY_MS = 25;
@@ -281,7 +277,7 @@ async function handleStateAction(root: string, action: string, rest: string[]):
                 coordRoot: root,
                 owner,
                 nativeSessionId: before?.session_id ?? owner,
-                adapter: adapterFromPlatform(before?.platform),
+                adapter: sharedAdapterFromPlatform(before?.platform, { context: "agent-coord" }),
                 task,
               });
               break;
@@ -312,9 +308,14 @@ async function handleStateAction(root: string, action: string, rest: string[]):
             hb = writer.setAssignedNameCache(root, owner, name, "session");
           }
         } catch (error) {
-          process.stderr.write(
-            `agent-coord set-task: V3 authority refused (${error instanceof Error ? error.message : String(error)})\n`,
-          );
+          const detail = error instanceof Error ? error.message : String(error);
+          // A missing heartbeat here means the session's generation ended
+          // while its process lived on. Name the reopen command (ADR 0088);
+          // set-task is usually the first thing such a session runs.
+          const hint = detail.includes("heartbeat_missing:")
+            ? `; run \`${resolveBinName(root)} agents lifecycle active\` to open a fresh generation for this continuing session`
+            : "";
+          process.stderr.write(`agent-coord set-task: V3 authority refused (${detail})${hint}\n`);
           return 1;
         }
         if (!hb) {
@@ -347,7 +348,7 @@ async function handleStateAction(root: string, action: string, rest: string[]):
           coordRoot: root,
           owner,
           nativeSessionId: before?.session_id ?? owner,
-          adapter: adapterFromPlatform(before?.platform),
+          adapter: sharedAdapterFromPlatform(before?.platform, { context: "agent-coord" }),
           operation: "released",
           path,
           access: "write",
@@ -408,7 +409,7 @@ async function handleStateAction(root: string, action: string, rest: string[]):
             coordRoot: root,
             owner,
             nativeSessionId: sessionId ?? owner,
-            adapter: adapterFromPlatform(adapter),
+            adapter: sharedAdapterFromPlatform(adapter, { context: "agent-coord" }),
           });
         }
         const { repairLiveCoordinationHeartbeat } = await import(
@@ -418,7 +419,7 @@ async function handleStateAction(root: string, action: string, rest: string[]):
           root,
           owner,
           sessionId ?? owner,
-          adapterFromPlatform(adapter),
+          sharedAdapterFromPlatform(adapter, { context: "agent-coord" }),
           model,
         );
       } catch (error) {
@@ -453,7 +454,7 @@ async function handleStateAction(root: string, action: string, rest: string[]):
           root,
           owner,
           sessionId ?? owner,
-          adapterFromPlatform(adapter),
+          sharedAdapterFromPlatform(adapter, { context: "agent-coord" }),
         );
         if (!heartbeat) {
           throw new Error("authoritative coordination cache could not be materialized");
@@ -471,7 +472,7 @@ async function handleStateAction(root: string, action: string, rest: string[]):
           root,
           owner,
           sessionId ?? owner,
-          adapterFromPlatform(adapter),
+          sharedAdapterFromPlatform(adapter, { context: "agent-coord" }),
         );
         process.stdout.write(
           `${JSON.stringify({
@@ -875,7 +876,7 @@ async function handleEmitEvent(root: string, rest: string[]): Promise<number> {
   const eventType = args.type;
   const instanceId = args.owner;
   const sessionId = args.session;
-  const adapter = args.adapter as "claude-code" | "cursor" | "codex" | undefined;
+  const adapter = normalizeAdapter(args.adapter) ?? undefined;
   const dataJson = args["data-stdin"] === "true" ? await readStdin() : "";
 
   if (!eventType || !instanceId || !sessionId || !adapter || !dataJson) {
@@ -1063,7 +1064,7 @@ async function handleGitHook(fallbackRoot: string, rest: string[]): Promise<numb
               owner,
               subject: hit.instance_id,
               nativeSessionId: hit.session_id ?? owner,
-              adapter: adapterFromPlatform(hit.platform),
+              adapter: sharedAdapterFromPlatform(hit.platform, { context: "agent-coord" }),
               operation: "released",
               path,
               access: "write",

package/src/core/agents/coord-client.ts

@@ -527,6 +527,10 @@ const SESSION_ID_ENV_VARS = [
   "CURSOR_CONVERSATION_ID",
   "CODEX_SESSION_ID",
   "CODEX_THREAD_ID",
+  // OpenCode exports no session id into the tool shell; the Harnery OpenCode
+  // plugin stamps this via shell.hook("create.before") so a coord CLI run as a
+  // Bash tool recovers its identity.
+  "OPENCODE_SESSION_ID",
 ] as const;
 
 /** Read normalized candidates from the first non-empty adapter session-id env var. */
@@ -637,10 +641,12 @@ export function resolveSingleActiveOwner(root: string): string | null {
   return live.size === 1 ? [...live][0]! : null;
 }
 
-function adapterCandidatesFromEnv(): Array<"claude-code" | "codex" | "cursor"> {
+function adapterCandidatesFromEnv(): Array<"claude-code" | "codex" | "cursor" | "opencode"> {
   const value = process.env.HARNERY_AGENT_COORD_PLATFORM?.trim();
-  if (value === "claude-code" || value === "codex" || value === "cursor") return [value];
-  return ["claude-code", "codex", "cursor"];
+  if (value === "claude-code" || value === "codex" || value === "cursor" || value === "opencode") {
+    return [value];
+  }
+  return ["claude-code", "codex", "cursor", "opencode"];
 }
 
 function nativeOwnerForV3Instance(root: string, instanceId: string): string {

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

@@ -17,6 +17,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { adapterFromPlatform as sharedAdapterFromPlatform } from "../../adapter.ts";
 import { recordLiveClaimChangeV3 } from "../live-authority-v3.ts";
 import { readLiveCoordinationRows } from "../state/live-coordination-view.ts";
 
@@ -248,7 +249,7 @@ function acquireClaimThroughLedger(coordRoot: string, req: ClaimRequest): boolea
       coordRoot,
       owner: req.instance_id,
       nativeSessionId: req.session_id ?? owner?.session_id ?? req.instance_id,
-      adapter: adapterFromPlatform(owner?.platform),
+      adapter: sharedAdapterFromPlatform(owner?.platform, { context: "claim-conflict" }),
       operation: "acquired",
       path: req.path,
       access: "write",
@@ -272,7 +273,7 @@ function releaseClaimThroughLedger(
       owner: actor.instance_id,
       subject: subjectInstanceId,
       nativeSessionId: actor.session_id ?? owner?.session_id ?? actor.instance_id,
-      adapter: adapterFromPlatform(owner?.platform),
+      adapter: sharedAdapterFromPlatform(owner?.platform, { context: "claim-conflict" }),
       operation: "released",
       path: relPath,
       access: "write",
@@ -283,12 +284,6 @@ function releaseClaimThroughLedger(
   }
 }
 
-function adapterFromPlatform(platform: unknown): "claude-code" | "cursor" | "codex" {
-  if (platform === "cursor") return "cursor";
-  if (platform === "codex") return "codex";
-  return "claude-code";
-}
-
 function authorityUnavailable(path: string, operation: string): VerdictResult {
   return {
     allow: false,

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

@@ -23,6 +23,7 @@
 import { spawnSync } from "node:child_process";
 import { appendFileSync, existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
+import { adapterFromPlatform as sharedAdapterFromPlatform } from "../../adapter.ts";
 import { coordFreshnessSeconds } from "../../config.ts";
 import { resolveOwner } from "../../hooks/resolve/owner.ts";
 import { recordLiveClaimChangeV3 } from "../live-authority-v3.ts";
@@ -232,7 +233,7 @@ function retainBlockedStagedPaths(
         coordRoot,
         owner: instanceId,
         nativeSessionId: self.session_id ?? sessionId,
-        adapter: adapterFromPlatform(self.platform),
+        adapter: sharedAdapterFromPlatform(self.platform, { context: "commit-conflict" }),
         operation: "acquired",
         path,
         access: "write",
@@ -244,12 +245,6 @@ function retainBlockedStagedPaths(
   }
 }
 
-function adapterFromPlatform(platform: unknown): "claude-code" | "cursor" | "codex" {
-  if (platform === "cursor") return "cursor";
-  if (platform === "codex") return "codex";
-  return "claude-code";
-}
-
 function findOverlap(
   staged: string,
   files: readonly string[],

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

@@ -32,6 +32,8 @@ export interface StopHookRequest {
   turn_window?: { start_ms: number; end_ms: number };
   stop_hook_active?: boolean;
   status_box_present_strict?: boolean;
+  /** Current observation overrides an older failed terminal during remediation. */
+  session_name_observation_unavailable?: boolean;
   bypass?: boolean;
   workflow_child?: boolean;
 }
@@ -188,7 +190,7 @@ export function evaluateStopHookV3Events(
 
   // Claude Code can prove session-name presentation from assistant-only text.
   // Cursor cannot expose that text and Codex returned observe-only above.
-  if (req.adapter !== "cursor") {
+  if (req.adapter !== "cursor" && !req.session_name_observation_unavailable) {
     const naming = turnTerminals
       .map((event) => observedNaming(event.payload.ritual?.session_name))
       .filter((value): value is { required: boolean; present: boolean } => value !== undefined);