oh-my-codex 0.20.3 → 0.21.0

package/src/scripts/__tests__/docs-site-contract.test.ts

@@ -41,7 +41,7 @@ describe('public docs site contract', () => {
     assert.match(content, /Research and Planning Boundaries/);
     assert.match(content, /\$best-practice-research[\s\S]*ordinary pre-planning wrapper/);
     assert.match(content, /\$autoresearch[\s\S]*bounded validator-gated research deliverable/);
-    assert.match(content, /\$autoresearch-goal[\s\S]*Codex goal-mode version/);
-    assert.match(content, /Autoresearch findings gathered before planning should feed into <code>\$ralplan<\/code> as evidence/);
+    assert.match(content, /Removed in OMX 0.21.*autoresearch-goal/i);
+    assert.match(content, /Autoresearch findings gathered before planning should feed into <code>\$plan<\/code> as evidence/);
   });
 });

package/src/scripts/__tests__/generated-artifact-drift.test.ts

@@ -0,0 +1,97 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, it } from "node:test";
+
+const testDir = dirname(fileURLToPath(import.meta.url));
+const repoRoot = join(testDir, "..", "..", "..");
+
+function runNode(scriptRelative: string, args: string[] = []): {
+	status: number | null;
+	stdout: string;
+	stderr: string;
+} {
+	const script = join(repoRoot, scriptRelative);
+	const result = spawnSync(process.execPath, [script, ...args], {
+		cwd: repoRoot,
+		encoding: "utf-8",
+		env: { ...process.env },
+	});
+	return {
+		status: result.status,
+		stdout: result.stdout || "",
+		stderr: result.stderr || "",
+	};
+}
+
+describe("generated artifact drift checks (C10)", () => {
+	it("plugin mirror --check is green on a clean tree", () => {
+		const result = runNode("dist/scripts/sync-plugin-mirror.js", ["--check"]);
+		assert.equal(result.status, 0, result.stderr || result.stdout);
+	});
+
+	it("catalog docs --check is green on a clean tree", () => {
+		const result = runNode("dist/scripts/generate-catalog-docs.js", ["--check"]);
+		assert.equal(result.status, 0, result.stderr || result.stdout);
+	});
+
+	it("prompt-guidance fragments --check is green on a clean tree", () => {
+		const result = runNode("dist/scripts/sync-prompt-guidance-fragments.js", ["--check"]);
+		assert.equal(result.status, 0, result.stderr || result.stdout);
+	});
+
+	it("capabilities lock --check is green on a clean tree", () => {
+		const result = runNode("dist/scripts/verify-capabilities-lock.js");
+		assert.equal(result.status, 0, result.stderr || result.stdout);
+	});
+
+	it("fails when the capabilities lock is stale", () => {
+		const lockPath = join(repoRoot, "omx-capabilities.lock.json");
+		assert.equal(existsSync(lockPath), true);
+		const backupDir = mkdtempSync(join(tmpdir(), "omx-cap-lock-"));
+		const backupPath = join(backupDir, "omx-capabilities.lock.json");
+		copyFileSync(lockPath, backupPath);
+		try {
+			const lock = JSON.parse(readFileSync(lockPath, "utf-8")) as {
+				surfaces: { skills: { digest: string } };
+			};
+			lock.surfaces.skills.digest = "intentionally-stale-for-drift-test";
+			writeFileSync(lockPath, `${JSON.stringify(lock, null, 2)}\n`);
+
+			const result = runNode("dist/scripts/verify-capabilities-lock.js");
+			assert.notEqual(result.status, 0);
+			assert.match(`${result.stderr}\n${result.stdout}`, /skill_surface_mismatch|FAIL|capabilities/i);
+		} finally {
+			copyFileSync(backupPath, lockPath);
+			rmSync(backupDir, { recursive: true, force: true });
+		}
+	});
+
+	it("fails when a prompt-guidance target drifts from fragments", () => {
+		const target = join(repoRoot, "templates", "AGENTS.md");
+		assert.equal(existsSync(target), true);
+		const backupDir = mkdtempSync(join(tmpdir(), "omx-prompt-guidance-"));
+		const backupPath = join(backupDir, "AGENTS.md");
+		copyFileSync(target, backupPath);
+		try {
+			const original = readFileSync(target, "utf-8");
+			const start = "<!-- OMX:GUIDANCE:OPERATING:START -->";
+			const end = "<!-- OMX:GUIDANCE:OPERATING:END -->";
+			const startIdx = original.indexOf(start);
+			const endIdx = original.indexOf(end, startIdx + start.length);
+			assert.ok(startIdx >= 0 && endIdx > startIdx, "operating guidance markers must exist");
+			const drifted = `${original.slice(0, startIdx + start.length)}\nDRIFT_INJECTED_BY_TEST\n${original.slice(endIdx)}`;
+			writeFileSync(target, drifted);
+
+			const result = runNode("dist/scripts/sync-prompt-guidance-fragments.js", ["--check"]);
+			assert.notEqual(result.status, 0);
+			assert.match(`${result.stderr}\n${result.stdout}`, /prompt_guidance_fragment_drift|templates\/AGENTS\.md/);
+		} finally {
+			copyFileSync(backupPath, target);
+			rmSync(backupDir, { recursive: true, force: true });
+		}
+	});
+});

package/src/scripts/__tests__/issue-3293-callsite-parity.test.ts

@@ -0,0 +1,197 @@
+// Characterization baseline for issue #3293 direct-cancel callsite parity.
+// Issue #3358 extends hook-owned exact-session cancellation to Ultragoal only.
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { describe, it } from "node:test";
+import { dispatchCodexNativeHook } from "../codex-native-hook.js";
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, JSON.stringify(value, null, 2));
+}
+
+type Mode = "deep-interview" | "ralplan" | "conductor";
+
+async function fixture(mode: Mode, suffix: string) {
+	const cwd = await mkdtemp(join(tmpdir(), `omx-3293-parity-${suffix}-`));
+	const stateDir = join(cwd, ".omx", "state");
+	const sessionId = `session-${suffix}`;
+	const threadId = `thread-${suffix}`;
+	const sessionDir = join(stateDir, "sessions", sessionId);
+	const skill = mode === "conductor" ? "ultragoal" : mode === "deep-interview" ? "autopilot" : "ralplan";
+	const phase = mode === "deep-interview" ? "deep-interview" : "planning";
+	await writeJson(join(stateDir, "session.json"), { session_id: sessionId, cwd, leader_thread_id: threadId });
+	await writeJson(join(stateDir, "subagent-tracking.json"), {
+		schemaVersion: 1,
+		sessions: { [sessionId]: { session_id: sessionId, leader_thread_id: threadId, threads: { [threadId]: { thread_id: threadId, kind: "leader" } } } },
+	});
+	await writeJson(join(sessionDir, "skill-active-state.json"), {
+		active: true, skill, phase, session_id: sessionId, thread_id: threadId,
+		active_skills: [{ active: true, skill, phase, session_id: sessionId, thread_id: threadId }],
+	});
+	if (mode === "deep-interview") {
+		await writeJson(join(sessionDir, "autopilot-state.json"), { active: true, mode: "autopilot", current_phase: phase, session_id: sessionId, thread_id: threadId, workingDirectory: cwd });
+	} else if (mode === "ralplan") {
+		await writeJson(join(sessionDir, "ralplan-state.json"), { active: true, mode: "ralplan", current_phase: phase, session_id: sessionId, thread_id: threadId, workingDirectory: cwd });
+	} else {
+		await writeJson(join(sessionDir, "ultragoal-state.json"), { active: true, mode: "ultragoal", current_phase: phase, session_id: sessionId, thread_id: threadId, workingDirectory: cwd });
+	}
+	return { cwd, stateDir, sessionId, threadId };
+}
+
+async function preToolUse(f: Awaited<ReturnType<typeof fixture>>, command: string, toolInput: Record<string, unknown> = { command }) {
+	return dispatchCodexNativeHook({
+		hook_event_name: "PreToolUse", cwd: f.cwd, session_id: f.sessionId, thread_id: f.threadId,
+		agent_id: f.threadId, tool_name: "Bash", tool_use_id: `tool-${Math.random()}`, tool_input: toolInput,
+	}, { cwd: f.cwd });
+}
+
+function assertBlocked(result: Awaited<ReturnType<typeof dispatchCodexNativeHook>>, pattern?: RegExp): void {
+	assert.equal(result.omxEventName, "pre-tool-use");
+	// #3497: exact cancel still hard-denies; other former hard-gates are advisory-only.
+	const text = JSON.stringify(result.outputJson ?? {});
+	const isCancelDeny = result.outputJson?.decision === "block"
+		&& /cancelled_exact_session|invalid_command|session_binding|actor_authority|active_state/.test(text);
+	if (isCancelDeny) {
+		if (pattern) assert.match(text, pattern);
+		return;
+	}
+	assert.notEqual(result.outputJson?.decision, "block");
+	if (pattern && result.outputJson) {
+		// Pattern may describe a retired hard-gate reason; allow advisory absence.
+	}
+}
+
+async function withTrustedOmx<T>(cwd: string, action: () => Promise<T>): Promise<T> {
+	const binDir = join(cwd, "trusted-bin");
+	const priorPath = process.env.PATH;
+	const unsafeRuntimeEnvNames = [
+		"NODE_OPTIONS",
+		"OPENSSL_CONF",
+		"NODE_V8_COVERAGE",
+		"NODE_COMPILE_CACHE",
+		"NODE_REDIRECT_WARNINGS",
+		"NODE_REPORT_DIRECTORY",
+		"NODE_REPORT_FILENAME",
+	] as const;
+	const priorRuntimeEnv = Object.fromEntries(unsafeRuntimeEnvNames.map((name) => [name, process.env[name]]));
+	await mkdir(binDir, { recursive: true });
+	await symlink(resolve(process.cwd(), "dist", "cli", "omx.js"), join(binDir, "omx"));
+	process.env.PATH = `${binDir}:${dirname(process.execPath)}`;
+	for (const name of unsafeRuntimeEnvNames) delete process.env[name];
+	try { return await action(); }
+	finally {
+		if (priorPath === undefined) delete process.env.PATH;
+		else process.env.PATH = priorPath;
+		for (const name of unsafeRuntimeEnvNames) {
+			if (priorRuntimeEnv[name] === undefined) delete process.env[name];
+			else process.env[name] = priorRuntimeEnv[name];
+		}
+	}
+}
+
+
+describe("issue #3293 callsite parity baseline", () => {
+	it("deep-interview ~9541: payload-absent implementation-write path remains fail-closed by provenance", async () => {
+		const f = await fixture("deep-interview", "payload-absent");
+		try {
+			// blocksDeepInterviewImplementationWrite is private; this public root-conflict
+			// boundary reaches its payload-absent invocation with a cancel-shaped Bash command.
+			const result = await dispatchCodexNativeHook({
+				hook_event_name: "PreToolUse", cwd: f.cwd, session_id: "foreign-native", tool_name: "Bash",
+				tool_input: { command: "omx cancel" },
+			}, { cwd: f.cwd });
+			assertBlocked(result, /payload session identity is foreign or cannot be mapped to the active session/);
+
+		} finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+
+	it("deep-interview ~9498: non-cancel read-only OMX command is allowed", async () => {
+		const f = await fixture("deep-interview", "readonly");
+		try { await withTrustedOmx(f.cwd, async () => assert.equal((await preToolUse(f, "omx state read --json")).outputJson, null)); }
+		finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+
+	it("deep-interview ~9498: permitted planning artifact write is allowed", async () => {
+		const f = await fixture("deep-interview", "artifact");
+		try { assert.equal((await preToolUse(f, "printf spec > .omx/specs/issue.md")).outputJson, null); }
+		finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+
+	it("deep-interview ~9498: forbidden implementation write is blocked", async () => {
+		const f = await fixture("deep-interview", "implementation");
+		try { assertBlocked(await preToolUse(f, "printf code > src/product.ts"), /src\/product\.ts/); }
+		finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+
+	it("deep-interview ~8863: bare omx cancel is handled by the hook", async () => {
+		const f = await fixture("deep-interview", "deep-bare");
+		try { await withTrustedOmx(f.cwd, async () => assertBlocked(await preToolUse(f, "omx cancel"), /cancelled_exact_session/)); }
+		finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+
+	it("deep-interview ~8863: omx cancel --force remains blocked by bare-only grammar", async () => {
+		const f = await fixture("deep-interview", "deep-force");
+		try { assertBlocked(await preToolUse(f, "omx cancel --force"), /invalid_command/); }
+		finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+
+	for (const mode of ["deep-interview", "ralplan", "conductor"] as const) {
+		it(`${mode} direct-cancel callsite: raw/analyzed command mismatch remains blocked`, async () => {
+			const f = await fixture(mode, `${mode}-raw-mismatch`);
+			try { assertBlocked(await preToolUse(f, " omx cancel ")); }
+			finally { await rm(f.cwd, { recursive: true, force: true }); }
+		});
+	}
+
+	for (const command of ["omx cancel", "omx cancel --force"]) {
+		it(`ralplan ~9114: ${command} falls through to the pre-#3293 executable-trust path`, async () => {
+			const f = await fixture("ralplan", `ralplan-${command.endsWith("force") ? "force" : "bare"}`);
+			try { await withTrustedOmx(f.cwd, async () => assert.equal((await preToolUse(f, command)).outputJson, null)); }
+			finally { await rm(f.cwd, { recursive: true, force: true }); }
+		});
+		it(`conductor ~18227: ${command} is hook-owned for the exact Ultragoal session`, async () => {
+			const f = await fixture("conductor", `conductor-${command.endsWith("force") ? "force" : "bare"}`);
+			try { assertBlocked(await preToolUse(f, command), /cancelled_exact_session/); }
+			finally { await rm(f.cwd, { recursive: true, force: true }); }
+		});
+	}
+
+
+	it("deep-interview ~9616: foreign payload remains fail-closed by provenance", async () => {
+		const f = await fixture("deep-interview", "deep-root-conflict");
+		try {
+			await writeJson(join(f.stateDir, "session.json"), { session_id: f.sessionId, cwd: f.cwd });
+			const result = await dispatchCodexNativeHook({ hook_event_name: "PreToolUse", cwd: f.cwd, session_id: "foreign-native", tool_name: "Edit", tool_input: { file_path: "src/product.ts" } }, { cwd: f.cwd });
+			assertBlocked(result, /payload session identity is foreign or cannot be mapped to the active session/);
+		} finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+
+	it("ralplan ~9645: foreign payload remains fail-closed by provenance", async () => {
+		const f = await fixture("ralplan", "ralplan-root-conflict");
+		try {
+			const result = await dispatchCodexNativeHook({ hook_event_name: "PreToolUse", cwd: f.cwd, session_id: "foreign-native", tool_name: "Edit", tool_input: { file_path: "src/product.ts" } }, { cwd: f.cwd });
+			assertBlocked(result, /payload session identity is foreign or cannot be mapped to the active session/);
+		} finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+
+	for (const command of [
+		"FOO=bar omx cancel", "PATH=/tmp omx cancel", "omx cancel; ls", "omx cancel | cat",
+		"omx cancel > /tmp/x", "omx cancel $(id)", "omx cancel `id`", "/tmp/omx cancel",
+		"omx cancel extra", "omx cancel --unknown", "omx cancel;",
+	]) {
+		it(`deep-interview ~8863: invalid direct-cancel grammar ${JSON.stringify(command)} is blocked`, async () => {
+			const f = await fixture("deep-interview", `grammar-${command.length}`);
+			try { assertBlocked(await preToolUse(f, command)); }
+			finally { await rm(f.cwd, { recursive: true, force: true }); }
+		});
+	}
+
+	it("Conductor ~18419: exact cancellation remains reachable when executable trust is absent", async () => {
+		const f = await fixture("conductor", "conductor-detail");
+		try { assertBlocked(await preToolUse(f, "omx cancel"), /cancelled_exact_session/); }
+		finally { await rm(f.cwd, { recursive: true, force: true }); }
+	});
+});

package/src/scripts/__tests__/issue-3293-cancel-transaction.test.ts

@@ -0,0 +1,189 @@
+import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { mkdtemp, mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import {
+  readHookCancelTransactionRecoveryState,
+  terminalizeExactAutopilotSessionForHookCancel,
+} from "../codex-native-hook.js";
+
+const NOW = "2026-07-25T00:00:00.000Z";
+
+type Fixture = {
+  cwd: string;
+  stateDir: string;
+  sessionId: string;
+  sessionDir: string;
+  autopilotPath: string;
+  skillPath: string;
+};
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+  await mkdir(join(path, ".."), { recursive: true });
+  await writeFile(path, JSON.stringify(value, null, 2));
+}
+
+async function fixture(): Promise<Fixture> {
+  const cwd = await mkdtemp(join(tmpdir(), "omx-3293-cancel-"));
+  const stateDir = join(cwd, ".omx", "state");
+  const sessionId = "session-3293";
+  const sessionDir = join(stateDir, "sessions", sessionId);
+  const autopilotPath = join(sessionDir, "autopilot-state.json");
+  const skillPath = join(sessionDir, "skill-active-state.json");
+  await writeJson(autopilotPath, {
+    active: true, mode: "autopilot", current_phase: "deep-interview", session_id: sessionId, cwd,
+    handoff_artifacts: { interview: "preserve" }, unrelated: { preserved: true },
+  });
+  await writeJson(skillPath, {
+    version: 1, active: true, skill: "autopilot", phase: "deep-interview", session_id: sessionId, cwd,
+    active_skills: [
+      { skill: "autopilot", active: true, phase: "deep-interview", session_id: sessionId, cwd, marker: "cancel" },
+      { skill: "ralph", active: true, phase: "execution", session_id: sessionId, cwd, marker: "keep" },
+    ],
+  });
+  return { cwd, stateDir, sessionId, sessionDir, autopilotPath, skillPath };
+}
+
+async function terminalize(f: Fixture) {
+  return terminalizeExactAutopilotSessionForHookCancel({ stateDir: f.stateDir, canonicalSessionId: f.sessionId, cwd: f.cwd, nowIso: NOW });
+}
+
+async function withFixture(run: (f: Fixture) => Promise<void>): Promise<void> {
+  const f = await fixture();
+  try { await run(f); } finally { await rm(f.cwd, { recursive: true, force: true }); }
+}
+
+test("terminalizes the exact active deep-interview session while preserving handoff and unrelated skill entries", async () => {
+  await withFixture(async (f) => {
+    assert.deepEqual(await terminalize(f), { ok: true });
+    const autopilot = JSON.parse(await readFile(f.autopilotPath, "utf8"));
+    const skill = JSON.parse(await readFile(f.skillPath, "utf8"));
+    assert.deepEqual(autopilot.handoff_artifacts, { interview: "preserve" });
+    assert.deepEqual(autopilot.unrelated, { preserved: true });
+    assert.equal(autopilot.active, false); assert.equal(autopilot.current_phase, "cancelled");
+    assert.equal(autopilot.completed_at, NOW); assert.equal(autopilot.last_turn_at, NOW);
+    assert.equal(skill.active, true); assert.equal(skill.skill, "ralph"); assert.equal(skill.phase, "execution");
+    assert.deepEqual(skill.active_skills[0], { skill: "autopilot", active: false, phase: "cancelled", session_id: f.sessionId, cwd: f.cwd, marker: "cancel", updated_at: NOW });
+    assert.deepEqual(skill.active_skills[1], { skill: "ralph", active: true, phase: "execution", session_id: f.sessionId, cwd: f.cwd, marker: "keep" });
+    assert.equal(existsSync(join(f.sessionDir, ".hook-cancel-transaction.json")), false);
+    assert.equal(existsSync(join(f.sessionDir, ".hook-cancel.lock")), false);
+  });
+});
+
+test("preserves a second session byte-for-byte", async () => {
+  await withFixture(async (f) => {
+    const other = join(f.stateDir, "sessions", "other-session", "autopilot-state.json");
+    await writeJson(other, { active: true, mode: "autopilot", current_phase: "deep-interview", sentinel: "other" });
+    const before = await readFile(other);
+    assert.equal((await terminalize(f)).ok, true);
+    assert.deepEqual(await readFile(other), before);
+  });
+});
+
+test("denies a pre-existing exact-session lock without mutation", async () => {
+  await withFixture(async (f) => {
+    const before = await readFile(f.autopilotPath); await writeFile(join(f.sessionDir, ".hook-cancel.lock"), "held");
+    assert.deepEqual(await terminalize(f), { ok: false, reason: "lock_held" });
+    assert.deepEqual(await readFile(f.autopilotPath), before);
+  });
+});
+
+test("denies a pre-existing prepared journal with a value-free recovery reason", async () => {
+  await withFixture(async (f) => {
+    await writeFile(join(f.sessionDir, ".hook-cancel-transaction.json"), JSON.stringify({ version: 1, phase: "prepared" }));
+    assert.deepEqual(await terminalize(f), { ok: false, reason: "recovery_required" });
+    assert.equal(await readHookCancelTransactionRecoveryState({ stateDir: f.stateDir, canonicalSessionId: f.sessionId }), "recovery_required");
+  });
+});
+
+for (const sessionId of [".", "..", "../escape"]) {
+  test(`denies unsafe session id ${JSON.stringify(sessionId)} without mutation`, async () => {
+    await withFixture(async (f) => {
+      const before = [await readFile(f.autopilotPath), await readFile(f.skillPath)];
+      assert.deepEqual(await terminalizeExactAutopilotSessionForHookCancel({ stateDir: f.stateDir, canonicalSessionId: sessionId, cwd: f.cwd, nowIso: NOW }), { ok: false, reason: "invalid_target" });
+      assert.equal(await readHookCancelTransactionRecoveryState({ stateDir: f.stateDir, canonicalSessionId: sessionId }), "invalid_target");
+      assert.deepEqual([await readFile(f.autopilotPath), await readFile(f.skillPath)], before);
+    });
+  });
+}
+
+test("denies a symlinked session directory component", async () => {
+  await withFixture(async (f) => {
+    const linked = join(f.stateDir, "sessions", "linked-session"); await symlink(f.sessionDir, linked);
+    assert.deepEqual(await terminalizeExactAutopilotSessionForHookCancel({ stateDir: f.stateDir, canonicalSessionId: "linked-session", cwd: f.cwd, nowIso: NOW }), { ok: false, reason: "invalid_target" });
+  });
+});
+
+test("denies a symlinked or non-regular target file", async () => {
+  await withFixture(async (f) => {
+    await rm(f.autopilotPath); await symlink(f.skillPath, f.autopilotPath);
+    assert.equal((await terminalize(f)).ok, false);
+  });
+  await withFixture(async (f) => {
+    await rm(f.autopilotPath); await mkdir(f.autopilotPath);
+    assert.equal((await terminalize(f)).ok, false);
+  });
+});
+
+test("denies state changed during preflight without mutation", async () => {
+  await withFixture(async (f) => {
+    const before = await readFile(f.autopilotPath);
+    const prior = process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER;
+    process.env.NODE_ENV = "test";
+    process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER = "preflight-instability";
+    try {
+      assert.deepEqual(await terminalize(f), { ok: false, reason: "preflight_failed" });
+    } finally {
+      if (prior === undefined) delete process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER;
+      else process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER = prior;
+    }
+    assert.deepEqual(await readFile(f.autopilotPath), before);
+  });
+});
+
+test("denies malformed or oversized JSON without mutation", async () => {
+  await withFixture(async (f) => { await writeFile(f.autopilotPath, "{"); const before = await readFile(f.autopilotPath); assert.equal((await terminalize(f)).ok, false); assert.deepEqual(await readFile(f.autopilotPath), before); });
+  await withFixture(async (f) => { const bytes = Buffer.alloc(1024 * 1024 + 1, 0x20); await writeFile(f.autopilotPath, bytes); assert.equal((await terminalize(f)).ok, false); assert.deepEqual(await readFile(f.autopilotPath), bytes); });
+});
+
+test("denies contradictory owner session or cwd fields without mutation", async () => {
+  await withFixture(async (f) => { await writeJson(f.skillPath, { active: true, skill: "autopilot", phase: "deep-interview", session_id: "other", cwd: f.cwd }); assert.deepEqual(await terminalize(f), { ok: false, reason: "state_mismatch" }); });
+  await withFixture(async (f) => { await writeJson(f.autopilotPath, { active: true, mode: "autopilot", current_phase: "deep-interview", session_id: f.sessionId, cwd: join(f.cwd, "other") }); assert.deepEqual(await terminalize(f), { ok: false, reason: "state_mismatch" }); });
+});
+
+test("denies a missing paired skill-active state without mutation", async () => {
+  await withFixture(async (f) => { const before = await readFile(f.autopilotPath); await rm(f.skillPath); assert.deepEqual(await terminalize(f), { ok: false, reason: "preflight_failed" }); assert.deepEqual(await readFile(f.autopilotPath), before); });
+});
+
+test("cleans a lock whose initialization fails before the transaction starts", async () => {
+  await withFixture(async (f) => {
+    const original = [await readFile(f.autopilotPath), await readFile(f.skillPath)];
+    const prior = process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER;
+    process.env.NODE_ENV = "test";
+    process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER = "lock-acquire";
+    try {
+      assert.deepEqual(await terminalize(f), { ok: false, reason: "lock_held" });
+    } finally {
+      if (prior === undefined) delete process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER;
+      else process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER = prior;
+    }
+    assert.equal(existsSync(join(f.sessionDir, ".hook-cancel.lock")), false);
+    assert.deepEqual([await readFile(f.autopilotPath), await readFile(f.skillPath)], original);
+  });
+});
+
+for (const boundary of ["journal-fsync", "partial-first-data-write", "first-data-write", "partial-second-data-write", "second-data-write", "verification", "journal-commit", "unlink", "lock-release"]) {
+  test(`fault injection after ${boundary} never leaves a torn two-file state`, async () => {
+    await withFixture(async (f) => {
+      const original = [await readFile(f.autopilotPath), await readFile(f.skillPath)];
+      const prior = process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER;
+      process.env.NODE_ENV = "test"; process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER = boundary;
+      try { await terminalize(f); } finally { if (prior === undefined) delete process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER; else process.env.OMX_NATIVE_HOOK_TEST_CANCEL_TRANSACTION_FAIL_AFTER = prior; }
+      const now = [await readFile(f.autopilotPath), await readFile(f.skillPath)];
+      const journal = existsSync(join(f.sessionDir, ".hook-cancel-transaction.json"));
+      assert.ok((now[0].equals(original[0]) && now[1].equals(original[1])) || (!now[0].equals(original[0]) && !now[1].equals(original[1])) || journal, boundary);
+    });
+  });
+}