harnery 0.40.0 → 0.42.0

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/adapters/types.ts

@@ -67,6 +67,16 @@ export interface AdapterProfile {
   /** How this adapter projects host filesystem policy into the vendor's own
    * sandbox (ADR 0039). Absent means it cannot project any of it. */
   sandboxProjection?: AdapterSandboxProjection;
+  /** Vendor-native arguments that launch a worker with no vendor sandbox
+   * (ADR 0192). Absent means the adapter has no distinguishable full-access
+   * mode, so a worker on it never qualifies for one. */
+  fullAccess?: AdapterFullAccessRendering;
+}
+
+/** How an adapter renders an unsandboxed launch (ADR 0192). The spawner emits
+ * exactly these arguments, so the declaration and the argv cannot drift. */
+export interface AdapterFullAccessRendering {
+  argv: readonly string[];
 }
 
 /** Fully planned child invocation. `resultFile` is used by adapters such as

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,22 @@ 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 usually means the session's generation ended
+          // while its process lived on, so name the reopen command (ADR 0088).
+          // A still-live generation whose authority the ledger withholds looks
+          // the same here; name its diagnostics instead, since reopen cannot apply.
+          const { describeLiveAuthorityBlockV3, liveAuthorityBlockHintV3, liveAuthorityBlockV3 } =
+            await import("./state/live-coordination-view.ts");
+          const block = detail.includes("heartbeat_missing:")
+            ? liveAuthorityBlockV3(root, owner)
+            : null;
+          const hint = block
+            ? `; ${describeLiveAuthorityBlockV3(block)}; ${liveAuthorityBlockHintV3(resolveBinName(root))}`
+            : 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 +356,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 +417,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 +427,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 +462,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 +480,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 +884,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 +1072,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/render/session-context.ts

@@ -126,6 +126,7 @@ export function renderSessionContext(opts: RenderOpts): string {
       if (d.missing.length > 0)
         bits.push(`missing: ${d.missing.map((m) => m.subcommand).join(", ")}`);
       if (d.orphans.length > 0) bits.push(`orphaned: ${d.orphans.join(", ")}`);
+      if (d.stale.length > 0) bits.push(`outdated: ${d.stale.map((m) => m.subcommand).join(", ")}`);
       return `  - ${d.settingsFile} — ${bits.join("; ")}`;
     });
     messages.push(

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);

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

@@ -4,7 +4,7 @@
  * `writeSessionEvent` records command spans in the canonical V3 ledger.
  */
 
-import { randomBytes } from "node:crypto";
+import { createHash, type Hash, randomBytes } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 // Kept dependency-light: vendored verbatim into a downstream consumer, so no coordEnv import.
@@ -64,18 +64,52 @@ export function readLastIntent(instanceId?: string): string | null {
   }
 }
 
-const outputSequence = new Map<string, number>();
+type OutputStream = "stdout" | "stderr" | "combined";
+
+interface OutputSummary {
+  stream: OutputStream;
+  bytes: number;
+  lines: number;
+  chunks: number;
+  hash: Hash;
+}
+
+interface PendingCommand {
+  coordRoot: string;
+  fields: Record<string, unknown>;
+  streams: Map<OutputStream, OutputSummary>;
+}
+
+const pendingCommands = new Map<string, PendingCommand>();
+let exitFlushInstalled = false;
+
+function commandKey(fields: Record<string, unknown>): string | undefined {
+  return typeof fields.instance_id === "string" && typeof fields.cmd_id === "string"
+    ? JSON.stringify([fields.instance_id, fields.cmd_id])
+    : undefined;
+}
+
+function flushCommandOutput(command: PendingCommand): void {
+  for (const summary of command.streams.values()) {
+    recordCommandObservation("command.output_observed", command.fields, command.coordRoot, summary);
+  }
+  command.streams.clear();
+}
 
 /** Emit a command/narration event to the canonical stream. Swallows every
  * error and skips when identity can't be resolved: telemetry must never break
  * or slow down a command. */
-function recordCommandObservation(type: SessionEventType, fields: Record<string, unknown>): void {
+function recordCommandObservation(
+  type: SessionEventType,
+  fields: Record<string, unknown>,
+  coordRoot: string,
+  summary?: OutputSummary,
+): boolean {
   const instanceId = typeof fields.instance_id === "string" ? fields.instance_id : undefined;
-  if (!instanceId) return;
+  if (!instanceId) return false;
   try {
-    const coordRoot = coordinationRootPath();
     const route = resolveLiveEventLedgerRouteV3(coordRoot);
-    if (route.state === "blocked") return;
+    if (route.state === "blocked") return false;
     const liveInstanceId = liveInstanceIdV3(instanceId);
     const hook = readHookProducerStateByInstanceV3(coordRoot, liveInstanceId);
     if (!hook) {
@@ -84,10 +118,10 @@ function recordCommandObservation(type: SessionEventType, fields: Record<string,
         instance_id: instanceId,
         reason: "hook_generation_not_found",
       });
-      return;
+      return false;
     }
-    const command = commandSignalAndObservation(type, fields);
-    if (!command) return;
+    const command = commandSignalAndObservation(type, fields, summary);
+    if (!command) return false;
     const result = recordCommandSignalV3({
       coordRoot,
       mode: route.mode,
@@ -105,7 +139,7 @@ function recordCommandObservation(type: SessionEventType, fields: Record<string,
       const expectedLifecycleReopenGap =
         result.reason === "turn_not_started" &&
         hook.session_start_derivation === "approved_lifecycle_reopen";
-      if (expectedLifecycleReopenGap) return;
+      if (expectedLifecycleReopenGap) return false;
       writeProducerDiagnosticV3(coordRoot, "command_emit_unjoinable", {
         type,
         instance_id: instanceId,
@@ -120,10 +154,10 @@ function recordCommandObservation(type: SessionEventType, fields: Record<string,
         result_state: result.state,
       });
     }
+    return result.state === "recorded" || result.state === "already_recorded";
   } catch (error) {
     // Telemetry must never break the command, but the loss is preserved.
     try {
-      const coordRoot = coordinationRootPath();
       writeProducerDiagnosticV3(coordRoot, "command_emit_failed", {
         type,
         instance_id: instanceId,
@@ -132,17 +166,26 @@ function recordCommandObservation(type: SessionEventType, fields: Record<string,
     } catch {
       /* diagnostics are best-effort */
     }
+    return false;
   }
 }
 
+/** Count the non-empty lines in one output chunk; a single event may carry many. */
+export function countOutputLines(text: string): number {
+  if (!text) return 0;
+  let count = 0;
+  for (const line of text.split("\n")) if (line.length > 0) count += 1;
+  return count;
+}
+
 function commandSignalAndObservation(
   type: SessionEventType,
   fields: Record<string, unknown>,
+  summary?: OutputSummary,
 ): { signal: CommandSignalV3; observation: CommandObservationV3 } | undefined {
   const commandId = typeof fields.cmd_id === "string" ? fields.cmd_id : undefined;
   if (!commandId) return undefined;
   if (type === "command.started") {
-    outputSequence.set(commandId, 0);
     const command = typeof fields.cmd === "string" ? fields.cmd : "";
     const executable = command.trim().split(/\s+/, 1)[0] || "unknown";
     return {
@@ -161,24 +204,25 @@ function commandSignalAndObservation(
     };
   }
   if (type === "command.output_observed") {
-    const sequence = (outputSequence.get(commandId) ?? 0) + 1;
-    outputSequence.set(commandId, sequence);
-    const line = typeof fields.line === "string" ? fields.line : "";
-    const stream =
-      fields.stream === "stdout" || fields.stream === "stderr" ? fields.stream : "combined";
+    if (!summary) return undefined;
     return {
       signal: "command.output_observed",
       observation: {
         native_command_id: commandId,
-        native_observation_id: `${commandId}:output:${sequence}`,
-        stream,
-        output: line,
-        output_bytes: Buffer.byteLength(line, "utf8"),
-        output_lines: line ? 1 : 0,
+        native_observation_id: `${commandId}:output-summary:${summary.stream}`,
+        stream: summary.stream,
+        // The normalizer HMACs this bounded descriptor with the generation key.
+        // Neither raw output nor its unkeyed digest is written to the ledger.
+        output: {
+          format: "harnery-output-chunks-v1",
+          chunks: summary.chunks,
+          sha256: summary.hash.digest("hex"),
+        },
+        output_bytes: summary.bytes,
+        output_lines: summary.lines,
       },
     };
   }
-  outputSequence.delete(commandId);
   const exitCode =
     typeof fields.exit === "number" && Number.isSafeInteger(fields.exit) ? fields.exit : undefined;
   return {
@@ -197,14 +241,64 @@ function commandSignalAndObservation(
 }
 
 /**
- * Record a command event in V3. Best-effort, never throws into the caller;
- * telemetry must not break or slow a command.
+ * Start/completion use the durable V3 recorder. Output only updates bounded
+ * per-stream counters and hashes; summaries flush before completion or at
+ * process exit. A forced kill can lose unflushed summaries (ADR 0188).
+ * Best-effort: telemetry never throws into the caller.
  */
 export function writeSessionEvent(
   type: SessionEventType,
   fields: Record<string, unknown> = {},
 ): void {
-  recordCommandObservation(type, fields);
+  try {
+    const key = commandKey(fields);
+    if (!key) return;
+    if (type === "command.output_observed") {
+      const command = pendingCommands.get(key);
+      if (!command) return;
+      const stream =
+        fields.stream === "stdout" || fields.stream === "stderr" ? fields.stream : "combined";
+      let summary = command.streams.get(stream);
+      if (!summary) {
+        summary = { stream, bytes: 0, lines: 0, chunks: 0, hash: createHash("sha256") };
+        command.streams.set(stream, summary);
+      }
+      const line = typeof fields.line === "string" ? fields.line : "";
+      const normalized = line.normalize("NFC");
+      // Length framing preserves chunk boundaries, including empty chunks.
+      summary.hash.update(`${Buffer.byteLength(normalized, "utf8")}:`).update(normalized);
+      summary.bytes += Buffer.byteLength(line, "utf8");
+      summary.lines += countOutputLines(line);
+      summary.chunks += 1;
+      return;
+    }
+    const command = pendingCommands.get(key);
+    const coordRoot = command?.coordRoot ?? coordinationRootPath();
+    if (type === "command.completed") {
+      pendingCommands.delete(key);
+      if (command) flushCommandOutput(command);
+      recordCommandObservation(type, fields, coordRoot);
+    } else if (recordCommandObservation(type, fields, coordRoot) && !command) {
+      pendingCommands.set(key, {
+        coordRoot,
+        fields: {
+          instance_id: fields.instance_id,
+          cmd_id: fields.cmd_id,
+          bridge: fields.bridge,
+        },
+        streams: new Map(),
+      });
+      if (!exitFlushInstalled) {
+        exitFlushInstalled = true;
+        process.once("exit", () => {
+          for (const pending of pendingCommands.values()) flushCommandOutput(pending);
+          pendingCommands.clear();
+        });
+      }
+    }
+  } catch {
+    // Root resolution and in-memory bookkeeping must not break the command.
+  }
 }
 
 /** Trim long values to keep individual events small. */

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

@@ -2,6 +2,7 @@ import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { ApprovedSessionEndReasonV3 } from "../events/v3/producers/recorder.ts";
 import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../events/v3/reader.ts";
+import { stateModeTooOpen } from "../storage/modes.ts";
 
 export const SESSION_FINALIZATION_REQUEST_FORMAT_V3 =
   "harnery-v3-session-finalization-request" as const;
@@ -72,7 +73,7 @@ export function listSessionFinalizationRequestsV3(
 
 export function readSessionFinalizationRequestV3(filePath: string): SessionFinalizationRequestV3 {
   const metadata = lstatSync(filePath);
-  if (!metadata.isFile() || metadata.isSymbolicLink() || (metadata.mode & 0o077) !== 0) {
+  if (!metadata.isFile() || metadata.isSymbolicLink() || stateModeTooOpen(metadata.mode)) {
     throw new Error("V3 session finalization request is unsafe");
   }
   const request = JSON.parse(readFileSync(filePath, "utf8")) as SessionFinalizationRequestV3;

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

@@ -32,6 +32,7 @@ import {
 import { readLedgerV3 } from "../events/v3/reader.ts";
 import { assertEventV3 } from "../events/v3/validate.ts";
 import { EVENT_V3_LEDGER_RELATIVE_ROOT, writeEventV3 } from "../events/v3/writer.ts";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { fsyncParentDirectory } from "../workflow/durable-record.ts";
 import { acquireNoClobberLease } from "../workflow/workspaces/leases.ts";
 import { readCodexArchiveObservationsV3 } from "./codex-archive-v3.ts";
@@ -901,20 +902,20 @@ function writeRequest(
   create = false,
 ): void {
   const directory = sessionFinalizationRequestDirectoryV3(coordRoot);
-  mkdirSync(directory, { recursive: true, mode: 0o700 });
-  chmodSync(directory, 0o700);
+  mkdirSync(directory, { recursive: true, mode: stateDirMode() });
+  chmodSync(directory, stateDirMode());
   const path = sessionFinalizationRequestPathV3(coordRoot, request.request_id);
   if (create && existsSync(path)) throw new Error("V3 finalization request already exists");
   const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
   let fd: number | undefined;
   try {
-    fd = openSync(temporary, "wx", 0o600);
+    fd = openSync(temporary, "wx", stateFileMode());
     writeFileSync(fd, `${JSON.stringify(request)}\n`, "utf8");
     fsyncSync(fd);
     closeSync(fd);
     fd = undefined;
     renameSync(temporary, path);
-    chmodSync(path, 0o600);
+    chmodSync(path, stateFileMode());
     fsyncParentDirectory(path);
   } finally {
     if (fd !== undefined) closeSync(fd);