harnery 0.40.0 → 0.42.0

package/src/core/events/v3/support-storage/maintenance.ts

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { constants, createReadStream } from "node:fs";
 import { chmod, lstat, mkdir, open, readdir, readFile, realpath } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
+import { stateDirMode, stateFileMode } from "../../../storage/modes.ts";
 import { canonicalJsonV3 } from "../canonical.ts";
 import type { EventV3SupportInventoryEntry } from "./inventory.ts";
 import { digestEventV3LogicalAuthority } from "./logical-authority.ts";
@@ -136,7 +137,7 @@ export async function planEventV3SupportTransaction(
   };
   const directory = transactionDirectory(input.transaction_root, transactionId);
   try {
-    await mkdir(directory, { recursive: false, mode: 0o700 });
+    await mkdir(directory, { recursive: false, mode: stateDirMode() });
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
     const existing = await readEventV3SupportTransaction(input.transaction_root, transactionId);
@@ -145,7 +146,7 @@ export async function planEventV3SupportTransaction(
     }
     return existing;
   }
-  await chmod(directory, 0o700);
+  await chmod(directory, stateDirMode());
   await publishState(directory, transaction);
   return transaction;
 }
@@ -427,7 +428,11 @@ async function publishState(
   transaction: EventV3SupportMaintenanceTransaction,
 ): Promise<void> {
   const path = join(directory, `state-${String(transaction.sequence).padStart(6, "0")}.json`);
-  const handle = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+  const handle = await open(
+    path,
+    constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL,
+    stateFileMode(),
+  );
   try {
     await handle.writeFile(`${canonicalJsonV3(transaction)}\n`, "utf8");
     await handle.sync();

package/src/core/events/v3/support-storage/pack-reader.ts

@@ -4,6 +4,7 @@ import { lstat, mkdir, open, realpath, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { createGunzip, createInflateRaw } from "node:zlib";
+import { stateDirMode, stateFileMode } from "../../../storage/modes.ts";
 import {
   type EventV3LogicalAuthorityEntry,
   type EventV3SupportPackManifest,
@@ -226,7 +227,7 @@ export async function unpackEventV3SupportPack(
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
   }
-  await mkdir(target, { recursive: false, mode: 0o700 });
+  await mkdir(target, { recursive: false, mode: stateDirMode() });
   let files = 0;
   let bytes = 0;
   try {
@@ -234,8 +235,8 @@ export async function unpackEventV3SupportPack(
       const path = resolve(target, ...record.path.split("/"));
       if (relative(target, path).startsWith(".."))
         throw new Error("event_v3_support_unpack_path_escape");
-      await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-      await writeFile(path, record.content, { flag: "wx", mode: 0o600 });
+      await mkdir(dirname(path), { recursive: true, mode: stateDirMode() });
+      await writeFile(path, record.content, { flag: "wx", mode: stateFileMode() });
       files += 1;
       bytes += record.bytes;
     }

package/src/core/events/v3/support-storage/pack-writer.ts

@@ -5,6 +5,7 @@ import { chmod, lstat, mkdir, open, realpath, rename, rm } from "node:fs/promise
 import { basename, isAbsolute, join, relative, 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 "../canonical.ts";
 import {
   EVENT_V3_SUPPORT_FAMILIES,
@@ -95,8 +96,8 @@ export async function writeEventV3SupportPack(
     .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 payloadName = `${packId}.ndjson.gz`;
   const payloadPath = join(outputDirectory, payloadName);
   const manifestPath = join(outputDirectory, `${packId}.manifest.json`);
@@ -106,7 +107,7 @@ export async function writeEventV3SupportPack(
 
   try {
     await streamPayload(inspected, payloadPartial, authorityReal);
-    await chmod(payloadPartial, 0o600);
+    await chmod(payloadPartial, stateFileMode());
     await rename(payloadPartial, payloadPath);
     const payload = await inspectRegularFile(payloadPath);
     const manifest = validateEventV3SupportPackManifest({
@@ -143,7 +144,7 @@ export async function writeEventV3SupportPack(
     const handle = await open(
       manifestPartial,
       constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL,
-      0o600,
+      stateFileMode(),
     );
     try {
       await handle.writeFile(`${canonicalJsonV3(manifest)}\n`, "utf8");
@@ -168,7 +169,7 @@ async function streamPayload(
   authorityReal: string,
 ): Promise<void> {
   const gzip = createGzip({ level: 9 });
-  const output = createWriteStream(destination, { flags: "wx", mode: 0o600 });
+  const output = createWriteStream(destination, { flags: "wx", mode: stateFileMode() });
   const completed = pipeline(gzip, output);
   try {
     for (const entry of entries) {

package/src/core/events/v3/tool-line-changes.ts

@@ -0,0 +1,139 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import type { ParsedPayload } from "../../hooks/adapter/parse.ts";
+import { stateFileMode } from "../../storage/modes.ts";
+
+export interface LineChanges {
+  added: number;
+  removed: number;
+}
+
+// Unknown tools remain unmeasured: a shell, script, or connector can write files.
+const READ_TOOLS = new Set(["Read", "Glob", "Grep", "LS", "view_image"]);
+const MAX_BYTES = 2 * 1024 * 1024;
+
+function object(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value === "string") {
+    try {
+      return object(JSON.parse(value));
+    } catch {
+      return undefined;
+    }
+  }
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function lineCount(text: string): number {
+  return text === "" ? 0 : text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+}
+
+function readText(path: string): string {
+  if (statSync(path).size > MAX_BYTES) throw new Error("unmeasured file");
+  const bytes = readFileSync(path);
+  if (bytes.length > MAX_BYTES || bytes.includes(0)) throw new Error("unmeasured file");
+  return bytes.toString("utf8");
+}
+
+/** Use Git's line semantics without retaining file contents in producer state. */
+function compare(before: string, after: string): LineChanges | undefined {
+  if (Buffer.byteLength(after) > MAX_BYTES || after.includes("\0")) return;
+  if (before === after) return { added: 0, removed: 0 };
+  const directory = mkdtempSync(join(tmpdir(), "harnery-lines-"));
+  try {
+    const oldPath = join(directory, "before");
+    const newPath = join(directory, "after");
+    writeFileSync(oldPath, before, { mode: stateFileMode() });
+    writeFileSync(newPath, after, { mode: stateFileMode() });
+    const result = spawnSync(
+      "git",
+      ["diff", "--no-index", "--no-ext-diff", "--no-textconv", "--numstat", "--", oldPath, newPath],
+      {
+        encoding: "utf8",
+        timeout: 2000,
+        maxBuffer: 4096,
+      },
+    );
+    if (result.status !== 0 && result.status !== 1) return;
+    const match = /^(\d+)\t(\d+)\t/.exec(result.stdout);
+    return match ? { added: Number(match[1]), removed: Number(match[2]) } : undefined;
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+/** Proposed edit counts, captured before execution; publish only on success. */
+export function prepareToolLineChanges(
+  payload: ParsedPayload,
+  cwd: string,
+): LineChanges | undefined {
+  try {
+    const name = payload.tool_name ?? "";
+    if (READ_TOOLS.has(name)) return { added: 0, removed: 0 };
+    const input = object(payload.tool_input);
+    if (name === "apply_patch") {
+      const patch =
+        typeof payload.tool_input === "string" && payload.tool_input.startsWith("*** Begin Patch")
+          ? payload.tool_input
+          : (input?.patch ?? input?.input ?? input?.command);
+      if (
+        typeof patch !== "string" ||
+        !patch.startsWith("*** Begin Patch\n") ||
+        !patch.includes("*** End Patch")
+      )
+        return;
+      let added = 0;
+      let removed = 0;
+      let inFile = false;
+      for (const line of patch.split("\n")) {
+        if (line.startsWith("*** Delete File: ")) {
+          removed += lineCount(readText(resolve(cwd, line.slice(17))));
+          inFile = false;
+        } else if (/^\*\*\* (?:Add|Update) File: /.test(line)) {
+          inFile = true;
+        } else if (line === "*** End Patch") {
+          inFile = false;
+        } else if (inFile && line.startsWith("+")) added++;
+        else if (inFile && line.startsWith("-")) removed++;
+      }
+      return { added, removed };
+    }
+    if (!["Write", "Edit", "StrReplace", "MultiEdit"].includes(name) || !input) return;
+    const path = input.file_path ?? input.path;
+    if (typeof path !== "string") return;
+    let before: string;
+    try {
+      before = readText(resolve(cwd, path));
+    } catch (error) {
+      if (name !== "Write" || (error as NodeJS.ErrnoException).code !== "ENOENT") return;
+      before = "";
+    }
+    if (name === "Write")
+      return typeof input.content === "string" ? compare(before, input.content) : undefined;
+    let after = before;
+    const edits = name === "MultiEdit" ? input.edits : [input];
+    if (!Array.isArray(edits)) return;
+    for (const entry of edits) {
+      const edit = object(entry);
+      if (
+        !edit ||
+        typeof edit.old_string !== "string" ||
+        typeof edit.new_string !== "string" ||
+        !edit.old_string
+      )
+        return;
+      const occurrences = after.split(edit.old_string).length - 1;
+      if (occurrences === 0 || (occurrences > 1 && edit.replace_all !== true)) return;
+      after =
+        edit.replace_all === true
+          ? after.split(edit.old_string).join(edit.new_string)
+          : after.replace(edit.old_string, () => edit.new_string as string);
+    }
+    return compare(before, after);
+  } catch {
+    return undefined;
+  }
+}

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

@@ -19,6 +19,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 { canonicalJsonV3, sha256V3 } from "./canonical.ts";
@@ -212,7 +213,7 @@ export function drainReadyEventsUnderLeaseV3(
     checkpoint?.genesis_id ? checkpoint : undefined,
   );
   if (readyRows.length === 0) return 0;
-  const activeFd = openSync(paths.active, "a", 0o600);
+  const activeFd = openSync(paths.active, "a", stateFileMode());
   let committed = 0;
   try {
     for (const { readyName, readyPath, row } of readyRows) {
@@ -397,13 +398,13 @@ export function ensureEventV3Layout(coordRoot: string) {
     paths.segments,
     paths.authorityOutbox,
   ]) {
-    mkdirSync(path, { recursive: true, mode: 0o700 });
-    chmodSync(path, 0o700);
+    mkdirSync(path, { recursive: true, mode: stateDirMode() });
+    chmodSync(path, stateDirMode());
   }
   if (!existsSync(paths.active)) {
     let fd: number | undefined;
     try {
-      fd = openSync(paths.active, "wx", 0o600);
+      fd = openSync(paths.active, "wx", stateFileMode());
       fsyncSync(fd);
       fsyncParentDirectory(paths.active);
     } catch (error) {
@@ -413,8 +414,8 @@ export function ensureEventV3Layout(coordRoot: string) {
     }
   }
   const active = lstatSync(paths.active);
-  if (!active.isFile() || active.isSymbolicLink() || (active.mode & 0o077) !== 0) {
-    throw new Error("active V3 ledger must be an owner-only regular file");
+  if (!active.isFile() || active.isSymbolicLink() || stateModeTooOpen(active.mode)) {
+    throw new Error("active V3 ledger must be a regular file closed to other users");
   }
   return paths;
 }
@@ -429,7 +430,7 @@ function writeReadyRecord(
   const temporary = join(spool, `.tmp-${process.pid}-${randomUUID()}`);
   let fd: number | undefined;
   try {
-    fd = openSync(temporary, "wx", 0o600);
+    fd = openSync(temporary, "wx", stateFileMode());
     writeFileSync(fd, row, "utf8");
     fsyncSync(fd);
     onStep?.("ready_temp_flushed", eventId);

package/src/core/governor/planning.ts

@@ -11,6 +11,7 @@ import {
 } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { appendSegmentedJsonlFile } from "../storage/durable-history.ts";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { createWorkItem, readWorkItem } from "../work/index.ts";
 import {
   digestResult,
@@ -709,8 +710,8 @@ function createPlanRequest(
   };
   const script = plannerScript(coordRoot, record, planId, trigger);
   const dir = planDir(coordRoot, record.intent.id, planId);
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-  chmodSync(dir, 0o700);
+  mkdirSync(dir, { recursive: true, mode: stateDirMode() });
+  chmodSync(dir, stateDirMode());
   writeExclusiveJson(join(dir, "request.json"), request, "governor plan request");
   writeExclusive(join(dir, "planner.mjs"), script, "governor planner script");
   return request;
@@ -1610,10 +1611,10 @@ function writeExclusive(path: string, body: string, label: string): void {
   if (Buffer.byteLength(body) > MAX_RECORD_BYTES) {
     throw new Error(`${label} exceeds ${MAX_RECORD_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) {
@@ -1621,7 +1622,7 @@ function writeExclusive(path: string, body: string, label: string): void {
       const existing = readFileSync(path, "utf8");
       if (existing !== body) throw new Error(`${label} already exists with different content`);
     }
-    chmodSync(path, 0o600);
+    chmodSync(path, stateFileMode());
   } finally {
     try {
       unlinkSync(temporary);

package/src/core/governor/service.ts

@@ -18,6 +18,7 @@ import { dirname, join, resolve } from "node:path";
 import { coordEnv } from "../../lib/env.ts";
 import { type NormalizedPolicy, normalizePolicy, type PolicyIsolation } from "../policy/index.ts";
 import { closeProcessLoggers, legacyLogFields, processLogger } from "../storage/logger.ts";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { RotatingTextSink } from "../storage/process-log.ts";
 import type { RunWorkItemInput } from "../work/index.ts";
 import { type GovernorRunReport, type GovernorStopReason, runGovernor } from "./runner.ts";
@@ -196,8 +197,8 @@ export function configureGovernorService(
     created_at: new Date().toISOString(),
   };
   const dir = serviceDir(coordRoot);
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-  chmodSync(dir, 0o700);
+  mkdirSync(dir, { recursive: true, mode: stateDirMode() });
+  chmodSync(dir, stateDirMode());
   writePrivateJsonAtomic(serviceConfigPath(coordRoot), config);
   return readGovernorServiceConfig(coordRoot);
 }
@@ -261,10 +262,10 @@ export async function spawnGovernorService(coordRootRaw: string): Promise<Govern
   if (current.running) {
     throw new Error(`governor service is already running under pid ${current.record?.pid}`);
   }
-  mkdirSync(serviceDir(coordRoot), { recursive: true, mode: 0o700 });
+  mkdirSync(serviceDir(coordRoot), { recursive: true, mode: stateDirMode() });
   const sharedLogs = coordEnv("SHARED_LOGS") !== "0";
-  const logFd = sharedLogs ? undefined : openSync(serviceLogPath(coordRoot), "a", 0o600);
-  if (logFd !== undefined) chmodSync(serviceLogPath(coordRoot), 0o600);
+  const logFd = sharedLogs ? undefined : openSync(serviceLogPath(coordRoot), "a", stateFileMode());
+  if (logFd !== undefined) chmodSync(serviceLogPath(coordRoot), stateFileMode());
   const harnBin = new URL("../../../bin/harn", import.meta.url).pathname;
   if (!existsSync(harnBin)) {
     if (logFd !== undefined) closeSync(logFd);
@@ -712,7 +713,7 @@ function normalizeIsolation(value: unknown): PolicyIsolation | undefined {
 
 function acquireServiceLease(coordRoot: string): () => void {
   const path = serviceLeasePath(coordRoot);
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
   const owner: ServiceLease = {
     pid: process.pid,
     host: hostname(),
@@ -721,7 +722,7 @@ function acquireServiceLease(coordRoot: string): () => void {
   };
   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 {
@@ -867,12 +868,12 @@ function writePrivateJsonAtomic(path: string, value: unknown): void {
   if (Buffer.byteLength(body) > MAX_FILE_BYTES) {
     throw new Error(`governor service file exceeds ${MAX_FILE_BYTES} bytes`);
   }
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  chmodSync(dirname(path), 0o700);
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
+  chmodSync(dirname(path), stateDirMode());
   const temporary = `${path}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
-  writeFileSync(temporary, body, { encoding: "utf8", flag: "wx", mode: 0o600 });
+  writeFileSync(temporary, body, { encoding: "utf8", flag: "wx", mode: stateFileMode() });
   renameSync(temporary, path);
-  chmodSync(path, 0o600);
+  chmodSync(path, stateFileMode());
 }
 
 function serviceDir(coordRoot: string): string {

package/src/core/governor/state.ts

@@ -13,6 +13,7 @@ import {
 } from "node:fs";
 import { hostname } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { stateDirMode, stateFileMode } from "../storage/modes.ts";
 import { assertWorkId, readWorkItem, type WorkRecord } from "../work/read.ts";
 import { workflowScriptDigest } from "../workflow/run-state.ts";
 import { normalizeWorkflowSpecialists } from "../workflow/specialists.ts";
@@ -233,8 +234,8 @@ export function createGovernor(input: CreateGovernorInput): GovernorRecord {
     created_at: new Date().toISOString(),
   };
   const path = governorIntentPath(coordRoot, id);
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  chmodSync(dirname(path), 0o700);
+  mkdirSync(dirname(path), { recursive: true, mode: stateDirMode() });
+  chmodSync(dirname(path), stateDirMode());
   writePrivateJson(path, intent);
   return readGovernor(coordRoot, id);
 }
@@ -309,13 +310,13 @@ export function acquireGovernorLease(coordRoot: string, goalId: string): () => v
   };
   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;
@@ -1250,8 +1251,8 @@ function writePrivateJson(path: string, value: unknown): void {
   if (Buffer.byteLength(body) > MAX_INTENT_BYTES) {
     throw new Error(`governor intent exceeds ${MAX_INTENT_BYTES} 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 bounded(value: unknown, field: string, max: number): string {

package/src/core/guard/evaluator.ts

@@ -185,6 +185,7 @@ function attestedContextSource(
     "claude-code": ["hook", "native_event", "result"],
     codex: ["native_event", "result", "transcript"],
     cursor: ["native_event"],
+    opencode: ["native_event", "result"],
   };
   return !!source && (allowed[adapter] ?? []).includes(source);
 }

package/src/core/guard/storage.ts

@@ -12,6 +12,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
+import { stateFileMode } from "../storage/modes.ts";
 import type { RunQualitySnapshot } from "./types.ts";
 
 export interface GuardCursor {
@@ -143,7 +144,7 @@ export function writeAtomicJson(
   try {
     writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, {
       encoding: "utf8",
-      mode: 0o600,
+      mode: stateFileMode(),
     });
     if (beforeRename && !beforeRename()) throw new Error("run_quality_lock_stolen");
     renameSync(temporary, path);
@@ -155,7 +156,7 @@ export function writeAtomicJson(
 function createExclusive(path: string, value: EvaluationLock): boolean {
   let fd: number | undefined;
   try {
-    fd = openSync(path, "wx", 0o600);
+    fd = openSync(path, "wx", stateFileMode());
     writeFileSync(fd, `${JSON.stringify(value)}\n`, "utf8");
     return true;
   } catch (error) {

package/src/core/hooks/adapter/behaviors/claude-code.ts

@@ -0,0 +1,33 @@
+import type { AdapterBehavior } from "./types.ts";
+
+/** Claude Code: the reference adapter; host-default labels, full effect set. */
+export const claudeCodeBehavior: AdapterBehavior = {
+  id: "claude-code",
+  sessionStartPlatformLabel: undefined,
+  soundEffects: true,
+  journalMaintenance: true,
+  sessionTelemetrySync: true,
+  promptPresenceDetection: true,
+  promptContextNudges: {
+    taskNudge: false,
+    hostPromptReminder: false,
+    statusFooterNudge: false,
+    turnRitualNudge: "claude-code",
+  },
+  completedResponseEvent: undefined,
+  sessionIdentityOnStartOnly: false,
+  nativeTurnIdOptional: false,
+  tracksExecutionMode: false,
+  shellOperationDedup: false,
+  promptMayPrecedeSessionStart: false,
+  promptContinuesOpenTurn: false,
+  turnRecovery: true,
+  nativeTelemetryOnly: false,
+  runtimeContextTranscriptOptional: false,
+  runtimeContextRetry: false,
+  effortAttestation: "payload",
+  transcriptTuningRefresh: true,
+  modelProvider: "anthropic",
+  runtimeContextAvailable: () => true,
+  bridgeFor: () => undefined,
+};

package/src/core/hooks/adapter/behaviors/codex.ts

@@ -0,0 +1,96 @@
+import { resolveBinName } from "../../../config.ts";
+import {
+  codexWslFileLinkTelemetry,
+  inspectCodexWslBridge,
+  isWslUncPath,
+  renderCodexWslFileLinkContext,
+} from "../../codex-wsl-bridge.ts";
+import { unsafeCrossShellReason } from "../../unsafe-cross-shell.ts";
+import type { ParsedPayload } from "../parse.ts";
+import { discoverCodexSessionTranscript } from "../runtime-telemetry.ts";
+import type { AdapterBehavior } from "./types.ts";
+
+/**
+ * Privacy-safe environment and recovery provenance for Codex mid-flight
+ * onboarding. WSLENV values are never recorded, only normalized variable
+ * names, and the native session identifier itself remains fingerprinted.
+ */
+export function codexMidFlightDiagnosticContext(
+  payload: ParsedPayload,
+  env: NodeJS.ProcessEnv = process.env,
+): Record<string, string | boolean> {
+  const wslenv = env.WSLENV?.trim() ?? "";
+  const wslenvNames = [
+    ...new Set(
+      wslenv
+        .split(":")
+        .map((entry) => entry.split("/", 1)[0]?.trim() ?? "")
+        .filter((name) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name)),
+    ),
+  ]
+    .sort()
+    .join(":")
+    .slice(0, 512);
+  const identityRecoverySource = payload.session_id
+    ? "native_session_id"
+    : payload.conversation_id
+      ? "native_conversation_id"
+      : payload.agent_id
+        ? "native_agent_id"
+        : "unavailable";
+  return {
+    thread_id_present: Boolean(env.CODEX_THREAD_ID?.trim()),
+    wslenv_present: wslenv.length > 0,
+    wslenv_names: wslenvNames,
+    identity_recovery_source: identityRecoverySource,
+  };
+}
+
+/**
+ * Codex: hook payloads omit `transcript_path`, so the rollout is discovered by
+ * session id; effort is probed from the rollout; a Windows-native Codex over a
+ * WSL UNC workspace is the one bridged deployment Harnery knows about.
+ */
+export const codexBehavior: AdapterBehavior = {
+  id: "codex",
+  sessionStartPlatformLabel: "Codex",
+  soundEffects: false,
+  journalMaintenance: false,
+  sessionTelemetrySync: false,
+  promptPresenceDetection: false,
+  promptContextNudges: {
+    taskNudge: true,
+    hostPromptReminder: true,
+    statusFooterNudge: true,
+    turnRitualNudge: undefined,
+  },
+  completedResponseEvent: undefined,
+  sessionIdentityOnStartOnly: false,
+  nativeTurnIdOptional: false,
+  tracksExecutionMode: false,
+  shellOperationDedup: false,
+  promptMayPrecedeSessionStart: false,
+  promptContinuesOpenTurn: false,
+  turnRecovery: true,
+  nativeTelemetryOnly: false,
+  runtimeContextTranscriptOptional: false,
+  runtimeContextRetry: true,
+  effortAttestation: "rollout-probe",
+  transcriptTuningRefresh: false,
+  modelProvider: "openai",
+  runtimeContextAvailable: () => true,
+  bridgeFor: (cwd) => (isWslUncPath(cwd) ? "codex-wsl" : undefined),
+  discoverTranscript: (nativeSessionId, candidate, options) =>
+    discoverCodexSessionTranscript(nativeSessionId, candidate, options),
+  midFlightDiagnosticContext: (payload) => codexMidFlightDiagnosticContext(payload),
+  fileLinkTelemetry: (coordRoot, cwd, lastAssistantMessage) =>
+    codexWslFileLinkTelemetry(coordRoot, cwd, lastAssistantMessage),
+  fileLinkContext: (coordRoot, cwd) => renderCodexWslFileLinkContext(coordRoot, cwd),
+  bridgeWarning: (coordRoot, cwd) => {
+    if (!isWslUncPath(cwd)) return undefined;
+    const bridge = inspectCodexWslBridge(process.env, { expected: true });
+    if (!bridge || bridge.ok) return undefined;
+    return `Harnery hybrid warning: ${bridge.detail}. Run \`${resolveBinName(coordRoot)} doctor\` for the repair hint.`;
+  },
+  unsafeCrossShellReason: (input) => unsafeCrossShellReason({ adapter: "codex", ...input }),
+};

package/src/core/hooks/adapter/behaviors/cursor.ts

@@ -0,0 +1,37 @@
+import type { AdapterBehavior } from "./types.ts";
+
+/**
+ * Cursor: no exit-code enforcement, a separate afterAgentResponse hook carries
+ * the completed reply, and cloud mode has no readable runtime context.
+ */
+export const cursorBehavior: AdapterBehavior = {
+  id: "cursor",
+  sessionStartPlatformLabel: "Cursor",
+  soundEffects: false,
+  journalMaintenance: false,
+  sessionTelemetrySync: false,
+  promptPresenceDetection: false,
+  promptContextNudges: {
+    taskNudge: true,
+    hostPromptReminder: true,
+    statusFooterNudge: false,
+    turnRitualNudge: undefined,
+  },
+  completedResponseEvent: "after-agent-response",
+  sessionIdentityOnStartOnly: true,
+  nativeTurnIdOptional: true,
+  tracksExecutionMode: true,
+  shellOperationDedup: true,
+  promptMayPrecedeSessionStart: true,
+  promptContinuesOpenTurn: true,
+  turnRecovery: true,
+  nativeTelemetryOnly: false,
+  runtimeContextTranscriptOptional: true,
+  runtimeContextRetry: false,
+  effortAttestation: "payload",
+  transcriptTuningRefresh: false,
+  modelProvider: "cursor",
+  runtimeContextAvailable: (mode) => mode !== "cloud",
+  bridgeFor: () => undefined,
+  inlineAssistantText: (payload) => payload?.agent_message,
+};