harnery 0.40.0 → 0.42.0

package/src/core/config.ts

@@ -80,6 +80,8 @@ interface HarneryConfig {
   /** Optional host prompt-context extension. Project config only. */
   hooks?: {
     promptContext?: unknown;
+    /** Project-only opt-in; read via `codexWindowsBridgeConfig()`. */
+    codexWindowsBridge?: unknown;
   };
   /**
    * Agent-ritual policy owned by the host project. Git finalization is opt-in:
@@ -107,7 +109,7 @@ interface HarneryConfig {
    * `workflow run` in this repo to subscription billing (API-key vars are
    * scrubbed from child envs) without anyone having to remember the flag.
    */
-  workflow?: { subscriptionOnly?: boolean };
+  workflow?: { subscriptionOnly?: boolean; workerFullAccess?: unknown };
   /**
    * Cross-machine presence (ADR 0016). `{ enabled: false }` opts a repo out of
    * the git-refs transport (publishing `refs/harnery/presence/<machine>` to
@@ -152,15 +154,36 @@ interface HarneryConfig {
     archive_keep_min?: number;
     archive_auto_clean?: boolean;
   };
+  /**
+   * Who can use this project's `.harnery/` state. `private` (the default) keeps every state
+   * directory 0700 and every state file 0600, owned by whoever wrote it. `group` makes them 0770 and
+   * 0660 so several Unix users who share the project directory's group can coordinate in one
+   * project. It never grants access to other users. The project directory must be setgid to that
+   * group so new state inherits it. Read via `storageSharing()`.
+   */
+  storage?: {
+    sharing?: "private" | "group";
+  };
   /**
    * Managed working-artifact defaults. `default_retention_days` is the
    * create-time TTL when the caller does not pass `artifacts create --days`.
    */
+  /** Local server registry (`servers` command, `harnery/core/servers`). */
+  servers?: {
+    /** Inclusive port range per server type, e.g. `"preview": [3100, 3199]`. */
+    port_ranges?: Record<string, unknown>;
+    idle_hours?: number;
+    owner_stale_hours?: number;
+  };
   artifacts?: {
     default_retention_days?: number;
     auto_clean?: boolean;
     max_bytes?: number;
     max_unit_bytes?: number;
+    idle_grace_hours?: number;
+    hold_days?: number;
+    max_held_bytes?: number;
+    min_free_bytes?: number;
   };
   /**
    * Page review packs. `auto_clean` lets `qa-run` and `review-pack create`
@@ -484,6 +507,42 @@ export function resolveHooksSetupHint(coordRoot?: string | null): string | null
  * values fail closed to no reminder so a malformed optional setting cannot
  * break the prompt hook.
  */
+/** A plain Windows command name, so it is safe to splice into a PowerShell hook command. */
+const CODEX_WINDOWS_BRIDGE_ENTRY_POINT = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+
+export interface CodexWindowsBridgeConfig {
+  /** Command name Windows-native Codex hooks hand off to, or null when not opted in. */
+  entryPoint: string | null;
+  /** Why the configured value was ignored, when it was. */
+  error: string | null;
+}
+
+/**
+ * Per-project opt-in that routes Windows-native Codex hooks through a resident
+ * WSL bridge (ADR 0197). Read from the project config only: the value is
+ * written into the committed `.codex/hooks.json`, so a user-level setting
+ * would make `init` output differ between machines. An invalid value is
+ * ignored and reported rather than spliced into a shell command.
+ */
+export function codexWindowsBridgeConfig(projectRoot: string): CodexWindowsBridgeConfig {
+  const raw = readProjectConfig(projectRoot).hooks?.codexWindowsBridge;
+  if (raw === undefined) return { entryPoint: null, error: null };
+  const entryPoint = isPlainObject(raw) ? raw.entryPoint : undefined;
+  if (typeof entryPoint !== "string") {
+    return {
+      entryPoint: null,
+      error: "hooks.codexWindowsBridge.entryPoint must be a command name",
+    };
+  }
+  if (!CODEX_WINDOWS_BRIDGE_ENTRY_POINT.test(entryPoint)) {
+    return {
+      entryPoint: null,
+      error: `hooks.codexWindowsBridge.entryPoint ${JSON.stringify(entryPoint)} is not a plain command name`,
+    };
+  }
+  return { entryPoint, error: null };
+}
+
 export function hostPromptReminder(coordRoot?: string | null): string | null {
   const root = coordRoot ?? findCoordRoot();
   if (!root) return null;
@@ -591,6 +650,40 @@ export function workflowSubscriptionOnly(coordRoot?: string | null): boolean {
   return readConfig(root).workflow?.subscriptionOnly === true;
 }
 
+/**
+ * The host's raw worker full-access policy (ADR 0192), validated by
+ * `parseWorkerFullAccessPolicy` in the workflow layer, which knows each
+ * adapter's effort scale.
+ *
+ * `.harnery/config.jsonc`:
+ * `{ "workflow": { "workerFullAccess": { "enabled": true, "floors": { ... } } } }`
+ *
+ * This is a trust boundary, so it comes only from the project config, like
+ * `agents.finalizationRoots`: a user-global file cannot remove the sandbox from
+ * one project's workers. `HARNERY_WORKFLOW_WORKER_FULL_ACCESS=0` turns it off
+ * for one process. There is deliberately no `=1`: an environment variable can
+ * withdraw the grant but never supply it.
+ */
+export function workflowWorkerFullAccessConfig(coordRoot?: string | null): unknown {
+  if (coordEnv("WORKFLOW_WORKER_FULL_ACCESS") === "0") return { enabled: false };
+  const root = coordRoot ?? findCoordRoot();
+  if (!root) return undefined;
+  return readProjectConfig(root).workflow?.workerFullAccess;
+}
+
+/**
+ * How this project's `.harnery/` state is shared: `private` or `group`. `HARNERY_STORAGE_SHARING`
+ * overrides per process; an unrecognized value falls back to `private`, the safer reading.
+ */
+export function storageSharing(coordRoot?: string | null): "private" | "group" {
+  const env = coordEnv("STORAGE_SHARING");
+  if (env === "group" || env === "private") return env;
+  const root = coordRoot ?? findCoordRoot();
+  if (!root) return "private";
+  // Project file only: a user-global "group" would loosen every project that user touches.
+  return readProjectConfig(root).storage?.sharing === "group" ? "group" : "private";
+}
+
 /**
  * Whether cross-machine presence (ADR 0016) is enabled for this repo.
  * Default ON — the transport itself additionally gates on an origin remote
@@ -742,6 +835,46 @@ export function resolveWebPort(explicitPort?: string, coordRoot?: string | null)
   return DEFAULT_WEB_PORT;
 }
 
+/** The configured inclusive port range for one server type, or null. */
+export function serverPortRange(type: string, coordRoot?: string | null): [number, number] | null {
+  const root = coordRoot ?? findCoordRoot();
+  const value = root ? readConfig(root).servers?.port_ranges?.[type] : undefined;
+  if (!Array.isArray(value) || value.length !== 2) return null;
+  const [low, high] = value as unknown[];
+  const valid = (n: unknown): n is number =>
+    Number.isInteger(n) && (n as number) > 0 && (n as number) < 65536;
+  return valid(low) && valid(high) && low <= high ? [low, high] : null;
+}
+
+/** Every configured server port range, keyed by type (invalid entries dropped). */
+export function serverPortRanges(coordRoot?: string | null): Record<string, [number, number]> {
+  const root = coordRoot ?? findCoordRoot();
+  const ranges = root ? readConfig(root).servers?.port_ranges : undefined;
+  const out: Record<string, [number, number]> = {};
+  for (const type of Object.keys(ranges ?? {})) {
+    const range = serverPortRange(type, root);
+    if (range) out[type] = range;
+  }
+  return out;
+}
+
+/** Configured `servers gc` windows; undefined fields use the built-in defaults. */
+export function serverGcConfig(coordRoot?: string | null): {
+  idle_hours?: number;
+  owner_stale_hours?: number;
+} {
+  const root = coordRoot ?? findCoordRoot();
+  const configured = root ? readConfig(root).servers : undefined;
+  const positive = (n: unknown): n is number =>
+    typeof n === "number" && Number.isFinite(n) && n > 0;
+  return {
+    ...(positive(configured?.idle_hours) ? { idle_hours: configured.idle_hours } : {}),
+    ...(positive(configured?.owner_stale_hours)
+      ? { owner_stale_hours: configured.owner_stale_hours }
+      : {}),
+  };
+}
+
 /** Policy for converging independent termination signals on one finalizer. */
 export function sessionFinalizationConfig(coordRoot?: string | null): SessionFinalizationConfig {
   const root = coordRoot ?? findCoordRoot();
@@ -820,12 +953,81 @@ export function artifactMaxUnitBytes(coordRoot?: string | null): number {
   );
 }
 
+/**
+ * How long an unexpired workspace must sit idle before a size rule (the
+ * per-bundle ceiling or the repository budget) may delete it. Idle means no
+ * change inside the workspace and no heartbeat from its owner. An agent waiting
+ * on a human reply looks idle, so a short window deletes work someone is still
+ * reviewing. Precedence: `HARNERY_ARTIFACT_IDLE_GRACE_HOURS` ->
+ * `artifacts.idle_grace_hours` -> 24. Expiry never waits for this grace.
+ */
+export function artifactIdleGraceHours(coordRoot?: string | null): number {
+  const root = coordRoot ?? findCoordRoot();
+  return integerSetting(
+    coordEnv("ARTIFACT_IDLE_GRACE_HOURS"),
+    root ? readConfig(root).artifacts?.idle_grace_hours : undefined,
+    1,
+    24 * 365,
+    24,
+  );
+}
+
+/**
+ * Default lifetime of an artifact hold. A hold that is not renewed lapses after
+ * this many days and the workspace returns to ordinary retention. Precedence:
+ * `HARNERY_ARTIFACT_HOLD_DAYS` -> `artifacts.hold_days` -> 14.
+ */
+export function artifactHoldDays(coordRoot?: string | null): number {
+  const root = coordRoot ?? findCoordRoot();
+  return integerSetting(
+    coordEnv("ARTIFACT_HOLD_DAYS"),
+    root ? readConfig(root).artifacts?.hold_days : undefined,
+    1,
+    365,
+    14,
+  );
+}
+
+/**
+ * Advisory budget for held artifact bytes. Exceeding it produces warnings
+ * only: holds record owner intent, so cleanup never deletes held work.
+ * Precedence: `HARNERY_ARTIFACT_MAX_HELD_BYTES` -> `artifacts.max_held_bytes`
+ * -> 20 GiB.
+ */
+export function artifactMaxHeldBytes(coordRoot?: string | null): number {
+  const root = coordRoot ?? findCoordRoot();
+  return integerSetting(
+    coordEnv("ARTIFACT_MAX_HELD_BYTES"),
+    root ? readConfig(root).artifacts?.max_held_bytes : undefined,
+    64 * 1024 * 1024,
+    1024 * 1024 * 1024 * 1024,
+    DEFAULT_ARTIFACT_MAX_BYTES,
+  );
+}
+
+/**
+ * Free-disk floor for the artifact store. Below it, artifact commands warn and
+ * `artifacts create --big` refuses unless `--allow-low-disk` is passed.
+ * Precedence: `HARNERY_ARTIFACT_MIN_FREE_BYTES` -> `artifacts.min_free_bytes`
+ * -> 20 GiB. Zero disables the floor.
+ */
+export function artifactMinFreeBytes(coordRoot?: string | null): number {
+  const root = coordRoot ?? findCoordRoot();
+  return integerSetting(
+    coordEnv("ARTIFACT_MIN_FREE_BYTES"),
+    root ? readConfig(root).artifacts?.min_free_bytes : undefined,
+    0,
+    1024 * 1024 * 1024 * 1024 * 1024,
+    20 * 1024 * 1024 * 1024,
+  );
+}
+
 /**
  * Whether opportunistic cleanup of expired artifact workspaces runs.
  * Precedence: `HARNERY_ARTIFACT_AUTO_CLEAN` (0/false disables) ->
- * `artifacts.auto_clean` -> enabled. The sweep only ever deletes
- * `managed-expired` entries via the same guarded classifier as
- * `artifacts clean --yes`.
+ * `artifacts.auto_clean` -> enabled. The sweep deletes the same
+ * `managed-expired`, `managed-oversize`, and `managed-over-budget` entries as
+ * `artifacts clean --yes`, through the same guarded classifier.
  */
 export function artifactAutoCleanEnabled(coordRoot?: string | null): boolean {
   const env = coordEnv("ARTIFACT_AUTO_CLEAN");

package/src/core/context/index.ts

@@ -11,6 +11,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "
 import { dirname, join } from "node:path";
 import type { Adapter } from "../adapter.ts";
 import { readLiveCoordinationRow } from "../agents/state/live-coordination-view.ts";
+import { stateFileMode } from "../storage/modes.ts";
 
 export const CONTEXT_SCHEMA_VERSION = 1 as const;
 export const MAX_CAPSULE_BYTES = 32 * 1024;
@@ -499,7 +500,7 @@ function writeBoundedJson(path: string, value: unknown, maxBytes: number): void
   }
   mkdirSync(dirname(path), { recursive: true });
   const temp = `${path}.tmp.${process.pid}.${randomUUID()}`;
-  writeFileSync(temp, text, { encoding: "utf8", mode: 0o600 });
+  writeFileSync(temp, text, { encoding: "utf8", mode: stateFileMode() });
   renameSync(temp, path);
 }
 

package/src/core/conversations/archive.ts

@@ -5,6 +5,7 @@ import {
   type DurableHistoryFaultBoundary,
   readDurableHistorySync,
 } from "../storage/durable-history.ts";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import type {
   HarneryConversationAccessMode,
   HarneryConversationArchiveAuthorityMode,
@@ -69,10 +70,10 @@ export async function captureProviderConversation(
     provider.capabilities.provider_id,
     options.conversation_id,
   );
-  mkdirSync(objectDir, { recursive: true, mode: 0o700 });
+  mkdirSync(objectDir, { recursive: true, mode: stateDirMode() });
   const lease = join(objectDir, ".capture.lease");
   try {
-    mkdirSync(lease, { mode: 0o700 });
+    mkdirSync(lease, { mode: stateDirMode() });
   } catch {
     throw new Error(`conversation capture lease busy: ${options.conversation_id}`);
   }
@@ -223,7 +224,7 @@ function manifestFor(
 function publishManifest(objectDir: string, manifest: HarneryConversationArchiveManifest): void {
   const path = join(objectDir, "manifest.json");
   const temp = `${path}.tmp-${process.pid}`;
-  writeFileSync(temp, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+  writeFileSync(temp, `${JSON.stringify(manifest, null, 2)}\n`, { mode: stateFileMode() });
   renameSync(temp, path);
 }
 

package/src/core/diagnostics/bundle.ts

@@ -15,6 +15,7 @@ import type {
 } from "../artifacts/index.ts";
 import {
   ARTIFACT_MANIFEST,
+  artifactHoldState,
   artifactsRoot,
   configuredArtifactRetentionDays,
   createArtifact,
@@ -25,6 +26,7 @@ import {
 } from "../artifacts/index.ts";
 import { currentHarneryRuntimeBuild } from "../events/v3/runtime-build.ts";
 import { writePrivateJsonAtomic } from "../storage/atomic-json.ts";
+import { stateDirMode } from "../storage/modes.ts";
 import {
   SUPERVISOR_DIAGNOSTIC_LIMITS,
   SUPERVISOR_EXPLANATION_SCHEMA_VERSION,
@@ -171,8 +173,8 @@ export function captureDiagnosticBundle(
     now,
   });
   const inputsPath = join(created.path, "inputs");
-  mkdirSync(inputsPath, { recursive: true, mode: 0o700 });
-  tryChmod(inputsPath, 0o700);
+  mkdirSync(inputsPath, { recursive: true, mode: stateDirMode() });
+  tryChmod(inputsPath, stateDirMode());
 
   const payloads: Record<(typeof PAYLOAD_FILES)[number], unknown> = {
     "inputs/observations.json": observations,
@@ -411,7 +413,7 @@ function candidateArtifactId(artifactPath: string): string | undefined {
 function candidateClassification(
   manifest: ArtifactManifestV2,
 ): ArtifactInventoryEntry["classification"] {
-  if (manifest.holds.length > 0) return "managed-held";
+  if (artifactHoldState(manifest).active.length > 0) return "managed-held";
   if (!manifest.released_at) return "managed-active";
   return Date.parse(manifest.retention.expires_at) <= Date.now()
     ? "managed-expired"

package/src/core/events/legacy-storage/canary.ts

@@ -4,6 +4,7 @@ import { chmod, lstat, mkdir, open, rename, rm } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { createGzip } from "node:zlib";
+import { stateDirMode, stateFileMode } from "../../storage/modes.ts";
 import { canonicalJsonV3 } from "../v3/canonical.ts";
 import { verifyLegacyV1HardFence } from "./fence.ts";
 import { type LegacyV1SegmentManifest, validateLegacyV1SegmentManifest } from "./manifest.ts";
@@ -46,8 +47,8 @@ export async function writeLegacyV1Canary(input: {
     .digest("hex")
     .slice(0, 32)}` as const;
   const outputDirectory = resolve(input.output_directory);
-  await mkdir(outputDirectory, { recursive: true, mode: 0o700 });
-  await chmod(outputDirectory, 0o700);
+  await mkdir(outputDirectory, { recursive: true, mode: stateDirMode() });
+  await chmod(outputDirectory, stateDirMode());
   const payloadPath = join(outputDirectory, `${segmentId}.ndjson.gz`);
   const manifestPath = join(outputDirectory, `${segmentId}.manifest.json`);
   const partialPayload = `${payloadPath}.partial`;
@@ -57,7 +58,7 @@ export async function writeLegacyV1Canary(input: {
     await pipeline(
       createReadStream(source),
       createGzip({ level: 9 }),
-      createWriteStream(partialPayload, { flags: "wx", mode: 0o600 }),
+      createWriteStream(partialPayload, { flags: "wx", mode: stateFileMode() }),
     );
     await rename(partialPayload, payloadPath);
     const payloadStat = await lstat(payloadPath);
@@ -85,7 +86,7 @@ export async function writeLegacyV1Canary(input: {
     const handle = await open(
       partialManifest,
       constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL,
-      0o600,
+      stateFileMode(),
     );
     try {
       await handle.writeFile(`${canonicalJsonV3(manifest)}\n`, "utf8");

package/src/core/events/legacy-storage/compression.ts

@@ -5,6 +5,7 @@ import { chmod, lstat, rename, rm } from "node:fs/promises";
 import { basename } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { createGzip } from "node:zlib";
+import { stateFileMode } from "../../storage/modes.ts";
 import { verifyLegacyV1HardFence } from "./fence.ts";
 import { inventoryLegacyV1Segments } from "./inventory.ts";
 import { streamLegacyV1Rows } from "./reader.ts";
@@ -84,7 +85,7 @@ export async function compressSealedLegacyV1Segments(
       await pipeline(
         createReadStream(row.path),
         createGzip({ level: 9 }),
-        createWriteStream(temporary, { flags: "wx", mode: 0o600 }),
+        createWriteStream(temporary, { flags: "wx", mode: stateFileMode() }),
       );
       await proveRowParity(row.path, temporary);
       const unchanged = (await inventoryLegacyV1Segments(coordRoot)).find(

package/src/core/events/v3/adapter-id.ts

@@ -1,4 +1,10 @@
-import type { Adapter } from "../../adapter.ts";
+import {
+  type Adapter,
+  type AdapterFallbackOptions,
+  DEFAULT_ADAPTER,
+  normalizeAdapterId,
+  resolveAdapterId,
+} from "../../adapter.ts";
 
 /** Harness identities that may produce or describe Event Ledger V3 evidence. */
 export type EventAdapterIdV3 = Adapter | "openclaw";
@@ -8,5 +14,27 @@ export const EVENT_ADAPTER_IDS_V3 = [
   "claude-code",
   "codex",
   "cursor",
+  "opencode",
   "openclaw",
 ] as const satisfies readonly EventAdapterIdV3[];
+
+type MissingEventAdapterId = Exclude<EventAdapterIdV3, (typeof EVENT_ADAPTER_IDS_V3)[number]>;
+const eventAdapterIdsComplete: [MissingEventAdapterId] extends [never] ? true : never = true;
+void eventAdapterIdsComplete;
+
+/** Strict event-adapter normalizer: a known id or `null`. */
+export function normalizeEventAdapterIdV3(value: unknown): EventAdapterIdV3 | null {
+  return normalizeAdapterId(value, EVENT_ADAPTER_IDS_V3);
+}
+
+/**
+ * Heartbeat `platform` to an event adapter id, substituting `DEFAULT_ADAPTER`
+ * and reporting the substitution. Use this wherever a row must be attributed
+ * to some adapter; use `normalizeEventAdapterIdV3` when `null` is acceptable.
+ */
+export function eventAdapterIdV3FromPlatform(
+  value: unknown,
+  options?: AdapterFallbackOptions,
+): EventAdapterIdV3 {
+  return resolveAdapterId(value, EVENT_ADAPTER_IDS_V3, DEFAULT_ADAPTER, options);
+}

package/src/core/events/v3/authority-outbox.ts

@@ -11,6 +11,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
+import { stateFileMode } from "../../storage/modes.ts";
 import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import { canonicalJsonV3, sha256V3 } from "./canonical.ts";
 import type { EventV3 } from "./contract.ts";
@@ -540,7 +541,7 @@ function publishExclusive(path: string, serialized: string): void {
   const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
   let fd: number | undefined;
   try {
-    fd = openSync(temporary, "wx", 0o600);
+    fd = openSync(temporary, "wx", stateFileMode());
     writeFileSync(fd, serialized, "utf8");
     fsyncSync(fd);
     closeSync(fd);

package/src/core/events/v3/bootstrap.ts

@@ -16,6 +16,7 @@ import {
 import { hostname } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { stateDirMode, stateFileMode } from "../../storage/modes.ts";
 import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import { acquireNoClobberLease } from "../../workflow/workspaces/leases.ts";
 import { canonicalJsonV3, sha256V3 } from "./canonical.ts";
@@ -524,7 +525,7 @@ function archiveCurrentEpoch(root: string, createdAt: string): string | undefine
   const current = join(root, ".harnery", "ledgers", "v3");
   if (!existsSync(current)) return undefined;
   const archives = join(root, ".harnery", "ledgers", "v3-archives");
-  mkdirSync(archives, { recursive: true, mode: 0o700 });
+  mkdirSync(archives, { recursive: true, mode: stateDirMode() });
   const stamp = createdAt.replace(/[^0-9]/g, "");
   let target = join(archives, `epoch-${stamp}`);
   let suffix = 0;
@@ -535,20 +536,20 @@ function archiveCurrentEpoch(root: string, createdAt: string): string | undefine
 }
 
 function publishControlFile(path: string, value: unknown): void {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
   const temp = `${path}.tmp.${process.pid}`;
   // A prior failed publish by this same pid would otherwise make every retry
   // fail on the exclusive create, which is exactly how one transient error
   // turns into a permanently stranded epoch.
   if (existsSync(temp)) unlinkSync(temp);
-  const fd = openSync(temp, "wx", 0o600);
+  const fd = openSync(temp, "wx", stateFileMode());
   try {
     writeFileSync(fd, `${canonicalJsonV3(value)}\n`, "utf8");
     fsyncSync(fd);
   } finally {
     closeSync(fd);
   }
-  chmodSync(temp, 0o600);
+  chmodSync(temp, stateFileMode());
   renameSync(temp, path);
   fsyncParentDirectory(path);
 }

package/src/core/events/v3/capabilities.ts

@@ -115,6 +115,19 @@ const BASE_SIGNAL_SUPPORT: Record<
     post_compaction: "unsupported",
     context_usage: "conditional",
   },
+  opencode: {
+    ...SHARED_SIGNAL_SUPPORT,
+    // OpenCode sessions are persistent server objects; the plugin observes a
+    // turn boundary (session.idle) rather than a clean session close, so end is
+    // conditional. Turns group by messageID without a first-class turn id.
+    session_end: "conditional",
+    turn_id: "conditional",
+    permission: "native",
+    // Compaction is intercepted (session.hook("compaction")); post-compaction
+    // recovery and SQLite-backed context usage are not yet certified.
+    post_compaction: "unsupported",
+    context_usage: "unsupported",
+  },
   openclaw: {
     session_start: "conditional",
     session_end: "native",
@@ -169,6 +182,10 @@ export const ADAPTER_CAPABILITY_PROFILES_V3: Record<EventAdapterIdV3, AdapterCap
       model_usage: "unsupported",
       inference_timing: "unsupported",
     }),
+    opencode: profile("opencode", {
+      model_usage: "conditional",
+      inference_timing: "unsupported",
+    }),
     openclaw: profile(
       "openclaw",
       {

package/src/core/events/v3/contract.ts

@@ -123,8 +123,15 @@ export const TurnCompletedV3Schema = eventV3("turn.completed", {
   }),
 });
 
+export const ToolLineChangesV3Schema = StrictObject({
+  added: Type.Integer({ minimum: 0 }),
+  removed: Type.Integer({ minimum: 0 }),
+});
+
 export const ToolCompletedV3Schema = eventV3("tool.completed", {
-  payload: terminalPayloadV3("tool.completed"),
+  payload: terminalPayloadV3("tool.completed", {
+    line_changes: Type.Optional(ObservationV3Schema(ToolLineChangesV3Schema)),
+  }),
 });
 
 export const CommandCompletedV3Schema = eventV3("command.completed", {
@@ -260,6 +267,7 @@ type ToolCompletedEventV3 = ReplaceEventV3<
   Omit<EventOfTypeV3Base<"tool.completed">["payload"], "duration_ms"> & {
     duration_ms: SpanSummaryValueV3["duration_ms"];
     span: SpanSummaryValueV3;
+    line_changes?: Static<ReturnType<typeof ObservationV3Schema<typeof ToolLineChangesV3Schema>>>;
   }
 >;
 type CommandCompletedEventV3 = ReplaceEventV3<

package/src/core/events/v3/control-witness.ts

@@ -10,6 +10,7 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
+import { stateFileMode } from "../../storage/modes.ts";
 import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import { canonicalJsonV3, type FingerprintV3, fingerprintV3, sha256V3 } from "./canonical.ts";
 import type { ActivationManifestV3, CandidateGenesisManifestV3 } from "./control.ts";
@@ -332,12 +333,12 @@ function publishCanonicalFileV3(path: string, value: unknown): boolean {
   const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
   let fd: number | undefined;
   try {
-    fd = openSync(temporary, "wx", 0o600);
+    fd = openSync(temporary, "wx", stateFileMode());
     writeFileSync(fd, `${canonicalJsonV3(value)}\n`, "utf8");
     fsyncSync(fd);
     closeSync(fd);
     fd = undefined;
-    chmodSync(temporary, 0o600);
+    chmodSync(temporary, stateFileMode());
     renameSync(temporary, path);
     fsyncParentDirectory(path);
     return true;

package/src/core/events/v3/coordination-transaction-recovery.ts

@@ -13,6 +13,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
+import { stateDirMode, stateFileMode } from "../../storage/modes.ts";
 import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import {
   type AuthorityTransactionV3,
@@ -306,8 +307,8 @@ function recoveryPaths(coordRoot: string, transactionId: string) {
 
 function ensureRecoveryLayout(paths: ReturnType<typeof recoveryPaths>): void {
   for (const path of [paths.root, paths.quarantineRoot]) {
-    mkdirSync(path, { recursive: true, mode: 0o700 });
-    chmodSync(path, 0o700);
+    mkdirSync(path, { recursive: true, mode: stateDirMode() });
+    chmodSync(path, stateDirMode());
   }
 }
 
@@ -325,7 +326,7 @@ function publishSerializedExclusive(path: string, serialized: string): void {
   const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
   let fd: number | undefined;
   try {
-    fd = openSync(temporary, "wx", 0o600);
+    fd = openSync(temporary, "wx", stateFileMode());
     writeFileSync(fd, serialized, "utf8");
     fsyncSync(fd);
     closeSync(fd);

package/src/core/events/v3/fingerprint-keys.ts

@@ -14,6 +14,7 @@ import {
 } from "node:fs";
 import { hostname } from "node:os";
 import { join, resolve } from "node:path";
+import { stateDirMode, stateFileMode, stateModeTooOpen } from "../../storage/modes.ts";
 import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import { acquireNoClobberLease } from "../../workflow/workspaces/leases.ts";
 import type { FingerprintContextV3 } from "./canonical.ts";
@@ -78,8 +79,8 @@ export function readFingerprintKeyStoreV3(coordRoot: string): FingerprintKeyStor
 
 function readKeyStoreValue(path: string): unknown {
   const mode = statSync(path).mode & 0o777;
-  if ((mode & 0o077) !== 0) {
-    throw new Error("fingerprint key store permissions are not owner-only");
+  if (stateModeTooOpen(mode)) {
+    throw new Error("fingerprint key store is open to other users");
   }
   let parsed: unknown;
   try {
@@ -135,8 +136,8 @@ export function fingerprintContextV3(
 
 function withKeyStoreLock<T>(coordRoot: string, operation: () => T): T {
   const privateDir = join(resolve(coordRoot), ".harnery/private");
-  mkdirSync(privateDir, { recursive: true, mode: 0o700 });
-  chmodSync(privateDir, 0o700);
+  mkdirSync(privateDir, { recursive: true, mode: stateDirMode() });
+  chmodSync(privateDir, stateDirMode());
   const leasePath = join(privateDir, "fingerprint-key-lease");
   const authority = createHash("sha256").update(resolve(coordRoot)).digest("hex");
   let lease: ReturnType<typeof acquireNoClobberLease> | undefined;
@@ -178,12 +179,12 @@ function publishKeyStore(path: string, store: FingerprintKeyStoreV3, replacing:
   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(store)}\n`, "utf8");
     fsyncSync(fd);
     closeSync(fd);
     fd = undefined;
-    chmodSync(temporary, 0o600);
+    chmodSync(temporary, stateFileMode());
     if (!replacing && existsSync(path)) throw new Error("fingerprint key store already exists");
     renameSync(temporary, path);
     fsyncParentDirectory(path);

package/src/core/events/v3/generated.ts

@@ -1,6 +1,6 @@
 /** Generated by scripts/generate-event-v3-contract.ts. Do not edit. */
 export const EVENT_V3_SCHEMA_DIGEST =
-  "sha256:bdcee8d7839add0c786740ba9d5cfd0b6573f0ad4974bf53272737468734aa36" as const;
+  "sha256:07137e2cdf5eaed58d55a34e4036c87aa1f375d45c88274d07ad1cc69a6fe6f7" as const;
 export const EVENT_V3_GENERATED_CORE_TYPES = [
   "ledger.genesis",
   "ledger.activated",