harnery 0.40.0 → 0.41.0

package/src/core/storage/modes.ts

@@ -0,0 +1,53 @@
+/**
+ * The permission modes for everything Harnery writes as project state under `.harnery/`.
+ *
+ * `private` (the default) is owner-only: 0700 directories and 0600 files, exactly as before this
+ * module existed. `group` is for a project several Unix users share through one group, such as a
+ * workspace that several people's agents work in at once: 2770 (setgid) and 0660, with nothing ever granted
+ * to other users. Every state write takes its mode from here, and every integrity check that
+ * rejects a loosely permissioned file asks `stateModeTooOpen`, so the two cannot disagree.
+ *
+ * Personal state outside the project (browser cookies, sessions, pacing ledgers in the user's home)
+ * is not project state and stays owner-only regardless.
+ */
+import { storageSharing } from "../config.ts";
+
+let resolved: "private" | "group" | undefined;
+
+/** The sharing mode for this process, resolved once. Tests reset it with `resetStorageSharing`. */
+export function stateSharing(): "private" | "group" {
+  if (resolved === undefined) {
+    resolved = storageSharing();
+    // A umask that strips group bits would quietly turn every group file back into an owner-only
+    // one, and the next user's write would fail. Keep the process's other-bits mask as it was.
+    if (resolved === "group" && typeof process.umask === "function")
+      process.umask(process.umask() & ~0o070);
+  }
+  return resolved;
+}
+
+export function resetStorageSharing(): void {
+  resolved = undefined;
+}
+
+/**
+ * Mode for a directory of project state. Group mode includes setgid: Harnery chmods directories
+ * after creating them, and a plain 0770 would clear the bit, so files made inside would take the
+ * writer's own group instead of the project's, and other users could not read them.
+ */
+export function stateDirMode(): number {
+  return stateSharing() === "group" ? 0o2770 : 0o700;
+}
+
+/** Mode for a file of project state. */
+export function stateFileMode(): number {
+  return stateSharing() === "group" ? 0o660 : 0o600;
+}
+
+/**
+ * True when a state file or directory is readable or writable by someone it should not be: anyone
+ * but the owner in private mode, anyone outside the owner and group in group mode.
+ */
+export function stateModeTooOpen(mode: number): boolean {
+  return (mode & (stateSharing() === "group" ? 0o007 : 0o077)) !== 0;
+}

package/src/core/storage/process-log.ts

@@ -12,6 +12,7 @@ import {
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createStorageCatalog } from "./catalog.ts";
+import { stateDirMode, stateFileMode } from "./modes.ts";
 import { familyLogDirectory } from "./segments.ts";
 
 export interface RotatingTextSinkOptions {
@@ -79,7 +80,7 @@ export class RotatingTextSink {
   append(text: string): void {
     if (this.#closed) throw new Error("text sink is closed");
     const bytes = Buffer.from(text, "utf8");
-    mkdirSync(dirname(this.#options.path), { recursive: true, mode: 0o700 });
+    mkdirSync(dirname(this.#options.path), { recursive: true, mode: stateDirMode() });
     let offset = 0;
     while (offset < bytes.byteLength) {
       let current = existsSync(this.#options.path) ? statSync(this.#options.path).size : 0;
@@ -88,7 +89,7 @@ export class RotatingTextSink {
         current = 0;
       }
       const length = Math.min(bytes.byteLength - offset, this.#options.max_bytes - current);
-      const fd = openSync(this.#options.path, "a", 0o600);
+      const fd = openSync(this.#options.path, "a", stateFileMode());
       try {
         writeSync(fd, bytes.subarray(offset, offset + length));
         if (this.#options.durable) fdatasyncSync(fd);

package/src/core/storage/receipts.ts

@@ -18,6 +18,7 @@ import {
   HarneryMaintenanceError,
   type HarneryMaintenanceReceipt,
 } from "./maintenance.ts";
+import { stateDirMode, stateFileMode } from "./modes.ts";
 
 export const HARNERY_RECEIPT_SEGMENT_MANIFEST_SCHEMA =
   "harnery.storage-maintenance-receipt-segment/v1" as const;
@@ -85,7 +86,7 @@ export function consolidateMutationReceipts(
     );
   }
   const segments = join(root, "segments");
-  mkdirSync(segments, { recursive: true, mode: 0o700 });
+  mkdirSync(segments, { recursive: true, mode: stateDirMode() });
   const payloadPath = join(segments, `${segmentId}.jsonl`);
   const manifestPath = join(segments, `${segmentId}.manifest.json`);
   writeExclusiveDurable(payloadPath, payload);
@@ -144,9 +145,9 @@ function readReceipt(path: string): {
 }
 
 function writeExclusiveDurable(path: string, bytes: string): void {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
   const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
-  const fd = openSync(temporary, "wx", 0o600);
+  const fd = openSync(temporary, "wx", stateFileMode());
   try {
     writeFileSync(fd, bytes, "utf8");
     fsyncSync(fd);

package/src/core/storage/segments.ts

@@ -23,6 +23,7 @@ import type { HarneryRegisteredStorageFamily } from "./contract.ts";
 import { parseLogRecord } from "./jsonl.ts";
 import type { HarneryLogMetricsDelta } from "./metrics.ts";
 import { mergeMetricsSidecar } from "./metrics.ts";
+import { stateDirMode, stateFileMode } from "./modes.ts";
 
 export interface HarneryLogSegmentV1 {
   sequence: number;
@@ -165,7 +166,7 @@ export class FileSegmentSink {
       const fd = openSync(
         active,
         fsConstants.O_RDWR | fsConstants.O_APPEND | fsConstants.O_CREAT | noFollowFlag(),
-        0o600,
+        stateFileMode(),
       );
       let bytes = 0;
       try {
@@ -337,7 +338,7 @@ export async function withFamilyLease<T>(
   let owner: LeaseOwner | undefined;
   while (true) {
     try {
-      mkdirSync(lease, { mode: 0o700 });
+      mkdirSync(lease, { mode: stateDirMode() });
       const leaseIdentity = captureDirectoryIdentity(lease);
       owner = {
         owner_id: randomUUID(),
@@ -397,7 +398,7 @@ function sealActive(active: string, options: ResolvedSegmentOptions, now: Date):
   const sequence = manifest.next_sequence;
   const name = `${now.toISOString().slice(0, 10).replaceAll("-", "")}-${String(sequence).padStart(8, "0")}.jsonl.gz`;
   const target = join(directory, "segments", name);
-  mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
+  mkdirSync(dirname(target), { recursive: true, mode: stateDirMode() });
   const temporary = `${target}.tmp-${process.pid}-${randomUUID()}`;
   const compressed = gzipSync(content);
   writeNewFile(temporary, compressed);
@@ -425,7 +426,7 @@ function sealActive(active: string, options: ResolvedSegmentOptions, now: Date):
     ],
   };
   const sealedManifest = join(directory, "manifests", `${String(sequence).padStart(8, "0")}.json`);
-  mkdirSync(dirname(sealedManifest), { recursive: true, mode: 0o700 });
+  mkdirSync(dirname(sealedManifest), { recursive: true, mode: stateDirMode() });
   writeNewFile(sealedManifest, Buffer.from(`${JSON.stringify(next)}\n`));
   atomicJson(join(directory, "manifest.json"), next);
   truncateRegularFile(active);
@@ -539,7 +540,7 @@ interface DirectoryIdentity {
 }
 
 function ensurePrivateDirectory(path: string): DirectoryIdentity {
-  mkdirSync(path, { recursive: true, mode: 0o700 });
+  mkdirSync(path, { recursive: true, mode: stateDirMode() });
   return captureDirectoryIdentity(path);
 }
 
@@ -632,7 +633,7 @@ function writeNewFile(path: string, content: Buffer): void {
   const fd = openSync(
     path,
     fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL | noFollowFlag(),
-    0o600,
+    stateFileMode(),
   );
   try {
     assertOpenFileIdentity(path, fd, parent);

package/src/core/supervisor/hook-health.ts

@@ -1,3 +1,4 @@
+import { type EventAdapterIdV3, normalizeEventAdapterIdV3 } from "../events/v3/adapter-id.ts";
 import {
   HOOK_HEALTH_EVENT,
   HOOK_HEALTH_RECEIPT_VERSION,
@@ -18,7 +19,7 @@ export interface CompletedHookHealth {
   id: string;
   observed_at: string;
   hook_name: string;
-  adapter: "claude-code" | "codex" | "cursor" | "unknown";
+  adapter: EventAdapterIdV3 | "unknown";
   outcome: HookHealthOutcome;
   duration_ms: number;
   rss_start_bytes: number;
@@ -267,9 +268,8 @@ function token(value: unknown): string | undefined {
 }
 
 function adapterValue(value: unknown): CompletedHookHealth["adapter"] | undefined {
-  return value === "claude-code" || value === "codex" || value === "cursor" || value === "unknown"
-    ? value
-    : undefined;
+  if (value === "unknown") return value;
+  return normalizeEventAdapterIdV3(value) ?? undefined;
 }
 
 function outcomeValue(value: unknown): HookHealthOutcome | undefined {

package/src/core/supervisor/service.ts

@@ -28,6 +28,7 @@ import { readResourceServiceStatus } from "../resources/service-status.ts";
 import { resourcePaths } from "../resources/storage.ts";
 import { writePrivateJsonAtomic } from "../storage/atomic-json.ts";
 import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.ts";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { collectSupervisorActivitySnapshot } from "./activity.ts";
 import {
   SUPERVISOR_PRESSURE_SCHEMA_VERSION,
@@ -103,7 +104,7 @@ export async function spawnSupervisor(
   const intervalMs = normalizeInterval(options.intervalMs);
   const idleExitMs = normalizeIdleExit(options.idleExitMs);
   const paths = supervisorPaths(coordRoot);
-  mkdirSync(paths.root, { recursive: true, mode: 0o700 });
+  mkdirSync(paths.root, { recursive: true, mode: stateDirMode() });
   rmSync(paths.stop, { force: true });
   const cliPath = fileURLToPath(
     new URL(import.meta.url.endsWith(".ts") ? "../../cli.ts" : "../../cli.js", import.meta.url),
@@ -170,7 +171,7 @@ export function requestSupervisorStop(coordRootRaw: string): SupervisorStatus {
   const coordRoot = resolve(coordRootRaw);
   const paths = supervisorPaths(coordRoot);
   const status = readSupervisorStatus(coordRoot);
-  mkdirSync(paths.root, { recursive: true, mode: 0o700 });
+  mkdirSync(paths.root, { recursive: true, mode: stateDirMode() });
   writePrivateJsonAtomic(paths.stop, {
     requested_at: new Date().toISOString(),
     requested_by_pid: process.pid,
@@ -352,8 +353,8 @@ export async function runSupervisor(
           });
         }
         pressureHysteresis = assessment.hysteresis;
-        mkdirSync(paths.timelines, { recursive: true, mode: 0o700 });
-        mkdirSync(paths.explanations, { recursive: true, mode: 0o700 });
+        mkdirSync(paths.timelines, { recursive: true, mode: stateDirMode() });
+        mkdirSync(paths.explanations, { recursive: true, mode: stateDirMode() });
         const projectionUpdates = [
           ...findings.active.filter((finding) => !priorActiveFindingIds.has(finding.id)),
           ...findings.transitions.filter(
@@ -495,7 +496,7 @@ function observeLedgerControlState(
 
 function acquireLease(coordRoot: string, now: Date): SupervisorLease {
   const paths = supervisorPaths(coordRoot);
-  mkdirSync(paths.root, { recursive: true, mode: 0o700 });
+  mkdirSync(paths.root, { recursive: true, mode: stateDirMode() });
   for (let attempt = 0; attempt < 2; attempt++) {
     const startToken = processStartToken(process.pid);
     const lease: SupervisorLease = {
@@ -506,7 +507,7 @@ function acquireLease(coordRoot: string, now: Date): SupervisorLease {
       created_at: now.toISOString(),
     };
     try {
-      const fd = openSync(paths.lease, "wx", 0o600);
+      const fd = openSync(paths.lease, "wx", stateFileMode());
       try {
         writeFileSync(fd, `${JSON.stringify(lease)}\n`, "utf8");
       } finally {

package/src/core/work/state.ts

@@ -17,6 +17,7 @@ import {
   appendSegmentedJsonlFile,
   readSegmentedJsonlFileSync,
 } from "../storage/durable-history.ts";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { readWorkflowApproval } from "../workflow/approvals.ts";
 import { stableDigest } from "../workflow/durable-record.ts";
 import { readWorkflowProof } from "../workflow/proof.ts";
@@ -260,9 +261,9 @@ export function createWorkItem(input: CreateWorkItemInput): WorkRecord {
     created_at: new Date().toISOString(),
   };
   const dir = workDir(coordRoot, id);
-  mkdirSync(dirname(dir), { recursive: true, mode: 0o700 });
-  mkdirSync(dir, { mode: 0o700 });
-  chmodSync(dir, 0o700);
+  mkdirSync(dirname(dir), { recursive: true, mode: stateDirMode() });
+  mkdirSync(dir, { mode: stateDirMode() });
+  chmodSync(dir, stateDirMode());
   writePrivateJson(join(dir, "intent.json"), intent, MAX_INTENT_BYTES);
   const release = acquireWorkLease(coordRoot, id);
   try {
@@ -1250,13 +1251,13 @@ function acquireWorkFileLease(
   };
   const acquire = (): boolean => {
     try {
-      const fd = openSync(path, "wx", 0o600);
+      const fd = openSync(path, "wx", stateFileMode());
       try {
         writeFileSync(fd, `${JSON.stringify(owner)}\n`, "utf8");
       } finally {
         closeSync(fd);
       }
-      chmodSync(path, 0o600);
+      chmodSync(path, stateFileMode());
       return true;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
@@ -1337,8 +1338,8 @@ function writePrivateJson(path: string, value: unknown, maxBytes: number): void
   const body = `${JSON.stringify(value, null, 2)}\n`;
   if (Buffer.byteLength(body) > maxBytes)
     throw new Error(`private record exceeds ${maxBytes} bytes`);
-  writeFileSync(path, body, { encoding: "utf8", flag: "wx", mode: 0o600 });
-  chmodSync(path, 0o600);
+  writeFileSync(path, body, { encoding: "utf8", flag: "wx", mode: stateFileMode() });
+  chmodSync(path, stateFileMode());
 }
 
 function readBoundedLines(

package/src/core/workflow/adapters.ts

@@ -7,6 +7,8 @@
  * but they do drift — keep this module the single place they live.
  */
 
+import type { Adapter } from "../adapter.ts";
+import { probeBinaryVersion } from "../adapters/bench.ts";
 import { BUILTIN_ADAPTER_PROFILES } from "../adapters/profiles.ts";
 import type { AdapterName } from "./types.ts";
 
@@ -24,6 +26,19 @@ export const ADAPTER_LOGIN_HINTS: Record<string, string> = Object.fromEntries(
   Object.values(BUILTIN_ADAPTER_PROFILES).map((profile) => [profile.id, profile.loginHint]),
 );
 
+/**
+ * Adapter ids whose CLI answers a version probe on this machine's PATH, in
+ * `BUILTIN_ADAPTER_PROFILES` order. The probe is injectable so callers can keep
+ * tests deterministic instead of keying on the host's toolchain.
+ */
+export function detectInstalledAdapters(
+  probe: (binary: string) => unknown = probeBinaryVersion,
+): Adapter[] {
+  return (Object.keys(ADAPTER_BINARIES) as Adapter[]).filter(
+    (id) => probe(ADAPTER_BINARIES[id]) !== null,
+  );
+}
+
 /** One-line "it's missing, here's the fix" string for spawn adapters. */
 export function notFoundError(adapter: AdapterName): string {
   const binary = ADAPTER_BINARIES[adapter] ?? adapter;

package/src/core/workflow/approvals.ts

@@ -12,6 +12,7 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 import type { PolicyEvaluation, PolicyRequestSummary, PolicyVerdict } from "../policy/index.ts";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { appendWorkflowTranscriptEvent } from "./transcript.ts";
 
 export const WORKFLOW_APPROVAL_SCHEMA_VERSION = 1 as const;
@@ -108,8 +109,8 @@ export function createWorkflowApproval(input: CreateWorkflowApprovalInput): {
     request_sha256: requestSha256,
   };
   const dir = approvalDir(input.coordRoot, id);
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-  chmodSync(dir, 0o700);
+  mkdirSync(dir, { recursive: true, mode: stateDirMode() });
+  chmodSync(dir, stateDirMode());
   const created = writeExclusiveJson(join(dir, "request.json"), record);
   const approval = readWorkflowApproval(input.coordRoot, id);
   if (
@@ -249,17 +250,17 @@ function writeExclusiveJson(path: string, value: unknown): boolean {
   if (Buffer.byteLength(body) > RECORD_LIMIT_BYTES) {
     throw new Error(`approval record exceeds ${RECORD_LIMIT_BYTES} bytes`);
   }
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
   const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
   try {
-    writeFileSync(temporary, body, { encoding: "utf8", flag: "wx", mode: 0o600 });
+    writeFileSync(temporary, body, { encoding: "utf8", flag: "wx", mode: stateFileMode() });
     try {
       linkSync(temporary, path);
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === "EEXIST") return false;
       throw error;
     }
-    chmodSync(path, 0o600);
+    chmodSync(path, stateFileMode());
     return true;
   } finally {
     if (existsSync(temporary)) unlinkSync(temporary);

package/src/core/workflow/billing.ts

@@ -85,10 +85,7 @@ export function probeBilling(adapter: AdapterName, io: ProbeIo = {}): BillingPro
       break;
     }
     case "cursor":
-      // cursor-agent's stored-login location is not yet verified against a
-      // live install (adapter itself is pending verification); never claim
-      // presence or absence we can't prove.
-      login = "unknown";
+      login = probeCursorLogin(env, home);
       break;
     default:
       // External adapters own their authentication. The generic engine must
@@ -126,6 +123,39 @@ function probeClaudeLogin(home: string): LoginState {
   return existsSync(dir) ? "unknown" : "absent";
 }
 
+/**
+ * cursor-agent: the stored login is `auth.json` holding `accessToken` and
+ * `refreshToken`. The path follows the CLI's own resolution, read from the
+ * installed 2026.09.18 build: `$CURSOR_CONFIG_DIR` when set, else
+ * `%APPDATA%\\cursor` on Windows, `~/.cursor` on macOS, and
+ * `$XDG_CONFIG_HOME/cursor` (default `~/.config/cursor`) elsewhere.
+ * `cursor-agent status --format json` reports the same two tokens as
+ * `hasAccessToken` / `hasRefreshToken`.
+ */
+function probeCursorLogin(env: NodeJS.ProcessEnv, home: string): LoginState {
+  const authPath = join(cursorConfigDir(env, home), "auth.json");
+  if (!existsSync(authPath)) return "absent";
+  try {
+    const parsed = JSON.parse(readFileSync(authPath, "utf8")) as {
+      accessToken?: string;
+      refreshToken?: string;
+    };
+    return parsed.accessToken?.trim() || parsed.refreshToken?.trim() ? "present" : "absent";
+  } catch {
+    return "unknown";
+  }
+}
+
+function cursorConfigDir(env: NodeJS.ProcessEnv, home: string): string {
+  const override = env.CURSOR_CONFIG_DIR?.trim();
+  if (override) return override;
+  const platform = env.HARNERY_BILLING_PLATFORM?.trim() || process.platform;
+  if (platform === "win32")
+    return join(env.APPDATA?.trim() || join(home, "AppData", "Roaming"), "cursor");
+  if (platform === "darwin") return join(home, ".cursor");
+  return join(env.XDG_CONFIG_HOME?.trim() || join(home, ".config"), "cursor");
+}
+
 /** codex: auth lives at $CODEX_HOME/auth.json (default ~/.codex). A `tokens`
  * object means a ChatGPT (subscription) login; an OPENAI_API_KEY field means
  * a stored API key (`codex login --api-key`). */

package/src/core/workflow/durable-record.ts

@@ -13,6 +13,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname } from "node:path";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 
 const JSON_LIMIT = 512 * 1024;
 
@@ -33,18 +34,18 @@ export function writeImmutableJson(path: string, value: unknown): boolean {
   if (Buffer.byteLength(body) > JSON_LIMIT) {
     throw new Error(`immutable record exceeds ${JSON_LIMIT} bytes`);
   }
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
   const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
   let fd: number | undefined;
   try {
-    fd = openSync(temporary, "wx", 0o600);
+    fd = openSync(temporary, "wx", stateFileMode());
     writeFileSync(fd, body, "utf8");
     fsyncSync(fd);
     closeSync(fd);
     fd = undefined;
     try {
       linkSync(temporary, path);
-      chmodSync(path, 0o600);
+      chmodSync(path, stateFileMode());
       fsyncParentDirectory(path);
       return true;
     } catch (error) {

package/src/core/workflow/live-session-v3.ts

@@ -1,4 +1,4 @@
-import type { Adapter } from "../adapter.ts";
+import { type Adapter, adapterFromPlatform } from "../adapter.ts";
 import { recordLiveTaskChangeV3 } from "../agents/live-authority-v3.ts";
 import { endSessionExplicitV3 } from "../agents/session-finalizer-v3.ts";
 import {
@@ -115,8 +115,7 @@ function requireV3Route(coordRoot: string) {
 }
 
 function workflowAdapter(adapter: string | undefined): Adapter {
-  if (adapter === "codex" || adapter === "cursor" || adapter === "claude-code") return adapter;
-  return "claude-code";
+  return adapterFromPlatform(adapter, { context: "workflow-child" });
 }
 
 export { stableScopeId } from "./scope-id.ts";

package/src/core/workflow/run-state.ts

@@ -20,6 +20,7 @@ import {
   type PolicyNetworkAccess,
   policyDigest,
 } from "../policy/index.ts";
+import { stateFileMode } from "../storage/modes.ts";
 import { assertWorkflowRunId, readWorkflowApproval } from "./approvals.ts";
 import { isCanonicalWorkflowAttemptContext } from "./attempt-context.ts";
 import { readJsonRecord, writeImmutableJson } from "./durable-record.ts";
@@ -205,13 +206,13 @@ export function acquireWorkflowResumeLease(coordRoot: string, runId: string): ()
 
   const acquire = (): boolean => {
     try {
-      const fd = openSync(path, "wx", 0o600);
+      const fd = openSync(path, "wx", stateFileMode());
       try {
         writeFileSync(fd, `${JSON.stringify(owner)}\n`, "utf8");
       } finally {
         closeSync(fd);
       }
-      chmodSync(path, 0o600);
+      chmodSync(path, stateFileMode());
       return true;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;

package/src/core/workflow/spawn-opencode.ts

@@ -0,0 +1,150 @@
+/**
+ * opencode spawn adapter: runs one subagent as a headless `opencode run`
+ * subprocess with `--format json`.
+ *
+ * Contract notes (verified 2026-09-20 against opencode v2.0.11: a
+ * `--format json` run streams NDJSON parts and a `PONG` probe round-trips):
+ * - `opencode run --format json --model <provider/model#variant> "<prompt>"`
+ *   prints one JSON object per line (NDJSON). Each line carries `sessionID`;
+ *   the assistant answer is the concatenation of `type:"text"` parts.
+ * - `--title` names the session; the final text is assembled from the stream
+ *   rather than a single result envelope (there is no `type:"result"` line).
+ * - `run` connects to the shared background service by default; a workflow
+ *   child inherits whatever service is discovered, matching interactive runs.
+ * - No per-run cost surface in the stream (cost lives in `session export`) →
+ *   left undefined. No max-turns equivalent → `maxTurns` accepted and ignored.
+ * - OpenCode selects reasoning through the model id variant, so there is no
+ *   effort flag; `effortValues` is empty and a supplied effort is rejected.
+ */
+
+import { exec } from "../../lib/exec.ts";
+import { builtinAdapterProfile, validateAdapterEffort } from "../adapters/profiles.ts";
+import type { AdapterInvocation, AdapterRawResult } from "../adapters/types.ts";
+import { notFoundError } from "./adapters.ts";
+import { buildChildEnv } from "./child-env.ts";
+import { resolveSandboxProjection } from "./sandbox-projection.ts";
+import { isUpstreamFailureText, vendorFailureText } from "./spawn-failure.ts";
+import type { Spawner, SpawnRequest, SpawnResult } from "./types.ts";
+
+interface OpenCodeStreamPart {
+  type?: string;
+  sessionID?: string;
+  part?: { type?: string; text?: string };
+}
+
+/**
+ * Parse the NDJSON `opencode run --format json` stream into the final answer
+ * text and the session id. Exported for unit tests (no live binary needed).
+ *
+ * Tolerant by contract: non-JSON lines (a stray log line) are skipped, and the
+ * text is the ordered concatenation of every `text` part so a multi-part answer
+ * is preserved.
+ */
+export function parseOpenCodeStream(stdout: string): {
+  text: string;
+  sessionId?: string;
+} {
+  let sessionId: string | undefined;
+  const chunks: string[] = [];
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let parsed: OpenCodeStreamPart;
+    try {
+      parsed = JSON.parse(trimmed) as OpenCodeStreamPart;
+    } catch {
+      continue;
+    }
+    if (!sessionId && typeof parsed.sessionID === "string" && parsed.sessionID.length > 0) {
+      sessionId = parsed.sessionID;
+    }
+    if (parsed.type === "text" && typeof parsed.part?.text === "string") {
+      chunks.push(parsed.part.text);
+    }
+  }
+  return { text: chunks.join("").trim(), sessionId };
+}
+
+export function buildOpenCodeInvocation(req: SpawnRequest): AdapterInvocation {
+  validateAdapterEffort("opencode", req.effort);
+  if (req.filesystemPolicy) {
+    // Declared unrepresentable: refuse rather than drop it silently (ADR 0039).
+    resolveSandboxProjection(
+      "opencode",
+      builtinAdapterProfile("opencode")?.sandboxProjection,
+      req.filesystemPolicy,
+    );
+  }
+  // `--auto` auto-approves permissions that are not explicitly denied, which a
+  // headless workflow child needs because it has no interactive approval
+  // channel; it does not map host policy into child tools (unsupported).
+  const argv = ["opencode", "run", "--format", "json", "--auto"];
+  if (req.model) argv.push("--model", req.model);
+  argv.push(req.prompt);
+  return { argv };
+}
+
+export function normalizeOpenCodeResult(raw: AdapterRawResult): SpawnResult {
+  if (raw.timedOut) {
+    return {
+      ok: false,
+      text: "",
+      durationMs: raw.durationMs,
+      error: `opencode timed out after ${raw.durationMs}ms and was killed`,
+    };
+  }
+  // Structural environment signal: the binary was never there (spawned directly,
+  // so a missing binary surfaces as ENOENT). Uncharged and not retried.
+  if (raw.spawnErrno === "ENOENT") {
+    return {
+      ok: false,
+      text: "",
+      durationMs: raw.durationMs,
+      error: notFoundError("opencode"),
+      class: "environment",
+    };
+  }
+  if (raw.exitCode === 127) {
+    // A bare 127 with no errno is a shell/vendor 127, indistinguishable from a
+    // legitimate one — charged as work rather than classed environment.
+    return { ok: false, text: "", durationMs: raw.durationMs, error: notFoundError("opencode") };
+  }
+  if (raw.exitCode !== 0) {
+    const failureText = vendorFailureText(raw);
+    return {
+      ok: false,
+      text: "",
+      durationMs: raw.durationMs,
+      error: `opencode exited ${raw.exitCode}: ${failureText}`,
+      ...(isUpstreamFailureText(failureText) ? { class: "upstream" as const } : {}),
+    };
+  }
+
+  const parsed = parseOpenCodeStream(raw.stdout);
+  return {
+    ok: true,
+    text: parsed.text,
+    sessionId: parsed.sessionId,
+    durationMs: raw.durationMs,
+  };
+}
+
+export const openCodeSpawner: Spawner = async (req: SpawnRequest): Promise<SpawnResult> => {
+  const t0 = Date.now();
+  let invocation: AdapterInvocation;
+  try {
+    invocation = buildOpenCodeInvocation(req);
+  } catch (error) {
+    return { ok: false, text: "", durationMs: 0, error: (error as Error).message };
+  }
+
+  const r = await exec(invocation.argv, {
+    cwd: req.cwd,
+    env: buildChildEnv(req.runId, {
+      subscriptionOnly: req.subscriptionOnly,
+      agentId: req.agentId,
+    }),
+    timeout: req.timeoutMs,
+  });
+  return normalizeOpenCodeResult({ ...r, durationMs: Date.now() - t0 });
+};

package/src/core/workflow/transcript.ts

@@ -1,5 +1,6 @@
 import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { fsyncParentDirectory, stableDigest } from "./durable-record.ts";
 
 // Limit for the JSON record body. The trailing newline delimiter is outside the
@@ -47,9 +48,9 @@ export function appendWorkflowTranscriptEvent(
     data,
   );
   const line = `${JSON.stringify(record)}\n`;
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
   const existed = existsSync(path);
-  const fd = openSync(path, "a", 0o600);
+  const fd = openSync(path, "a", stateFileMode());
   try {
     writeFileSync(fd, line, "utf8");
     fsyncSync(fd);