oh-my-codex 0.20.3 → 0.21.0

package/dist/cli/__tests__/session-scoped-runtime.test.js

@@ -1,33 +1,109 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdir, mkdtemp, rm, writeFile, readFile } from 'fs/promises';
-import { existsSync } from 'fs';
+import { chmod, mkdir, mkdtemp, readFile, readdir, rm, symlink, writeFile } from 'fs/promises';
+import { existsSync, realpathSync } from 'fs';
 import { dirname, join } from 'path';
-import { tmpdir } from 'os';
+import { tmpdir as osTmpdir } from 'os';
 import { spawnSync } from 'child_process';
 import { fileURLToPath } from 'url';
+import { readModeState } from '../../modes/base.js';
+import { readSkillActiveState } from '../../state/skill-active.js';
+import { recordSkillActivation } from '../../hooks/keyword-detector.js';
+import { cancelModesForTest } from '../index.js';
+const tmpdir = () => realpathSync(osTmpdir());
+async function createFakeCodexBin(root, output) {
+    const binDir = join(root, 'bin');
+    await mkdir(binDir, { recursive: true });
+    await writeFile(join(binDir, 'codex'), `#!/bin/sh\nprintf '%s\\n' '${output}'\n`);
+    await chmod(join(binDir, 'codex'), 0o755);
+    return binDir;
+}
 const testDir = dirname(fileURLToPath(import.meta.url));
 const repoRoot = join(testDir, '..', '..', '..');
 const omxBin = join(repoRoot, 'dist', 'cli', 'omx.js');
+function cleanOmxEnv(overrides = {}) {
+    const env = { ...process.env };
+    for (const name of [
+        'OMX_ROOT',
+        'OMX_STATE_ROOT',
+        'OMX_TEAM_STATE_ROOT',
+        'OMX_SESSION_ID',
+        'CODEX_SESSION_ID',
+        'SESSION_ID',
+        'OMX_RUNS_DIR',
+    ]) {
+        delete env[name];
+    }
+    return {
+        ...env,
+        ...(overrides.FAKE_TMUX_SESSION_NAME ? {
+            FAKE_TMUX_PANE_PID: '4242',
+            FAKE_TMUX_INTERNAL_SESSION_ID: '$1',
+            FAKE_TMUX_SESSION_CREATED: '100',
+        } : {}),
+        ...overrides,
+    };
+}
 function runOmx(cwd, ...args) {
     return spawnSync(process.execPath, [omxBin, ...args], {
         cwd,
         encoding: 'utf-8',
+        env: cleanOmxEnv(),
     });
 }
 function runOmxWithEnv(cwd, env, ...args) {
     return spawnSync(process.execPath, [omxBin, ...args], {
         cwd,
         encoding: 'utf-8',
-        env: { ...process.env, ...env },
+        env: cleanOmxEnv(env),
     });
 }
+async function createFakeTmuxBin(root) {
+    const binDir = join(root, 'bin');
+    const tmuxPath = join(binDir, 'tmux');
+    await mkdir(binDir, { recursive: true });
+    await writeFile(tmuxPath, `#!/bin/sh
+case "$1" in
+  list-panes)
+    count=0
+    if [ -n "$FAKE_TMUX_COUNTER_FILE" ] && [ -f "$FAKE_TMUX_COUNTER_FILE" ]; then count=$(cat "$FAKE_TMUX_COUNTER_FILE"); fi
+    count=$((count + 1))
+    if [ -n "$FAKE_TMUX_COUNTER_FILE" ]; then printf '%s' "$count" > "$FAKE_TMUX_COUNTER_FILE"; fi
+    created="$FAKE_TMUX_SESSION_CREATED"
+    if [ "$FAKE_TMUX_REPLACE_AFTER_FIRST" = "1" ] && [ "$count" -gt 1 ]; then created=$((created + 1)); fi
+    printf '%%42\\t0\\t%s\\t%s\\t%s\\t%s\\t%s\\n' "$FAKE_TMUX_PANE_PID" "$FAKE_TMUX_SESSION_NAME" "$FAKE_TMUX_INTERNAL_SESSION_ID" "$created" "$FAKE_OMX_SESSION_ID"
+    ;;
+  *) exit 1 ;;
+esac
+`);
+    await chmod(tmuxPath, 0o755);
+    return binDir;
+}
+async function writeActiveRunRecord(options) {
+    const activeDir = join(options.runsRoot, 'active-detached');
+    await mkdir(activeDir, { recursive: true });
+    await writeFile(join(activeDir, `${options.contextKey}.json`), JSON.stringify({
+        version: 1,
+        context_key: options.contextKey,
+        created_at: '2026-07-19T00:00:00.000Z',
+        source_cwd: options.sourceCwd,
+        ...(options.worktreeCwd ? { worktree_cwd: options.worktreeCwd } : {}),
+        argv: ['--madmax'],
+        run_dir: options.runDir,
+        tmux_session_name: options.tmuxSessionName,
+        session_id: options.sessionId,
+        tmux_pane_id: '%42',
+        tmux_internal_session_id: '$1',
+        tmux_session_created: '100',
+        tmux_pane_pid: 4242,
+    }, null, 2));
+}
 describe('CLI session-scoped state parity', () => {
     it('status and cancel include session-scoped states', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-cli-session-scope-'));
         try {
             await mkdir(join(wd, '.omx', 'state'), { recursive: true });
-            await writeFile(join(wd, '.omx', 'state', 'session.json'), JSON.stringify({ session_id: 'sess1' }));
+            await writeFile(join(wd, '.omx', 'state', 'session.json'), JSON.stringify({ session_id: 'sess1', cwd: wd, state_root: join(wd, '.omx', 'state') }));
             const scopedDir = join(wd, '.omx', 'state', 'sessions', 'sess1');
             await mkdir(scopedDir, { recursive: true });
             await writeFile(join(scopedDir, 'team-state.json'), JSON.stringify({
@@ -60,15 +136,14 @@ describe('CLI session-scoped state parity', () => {
             const ralphPath = join(sessionDir, 'ralph-state.json');
             const nativeStopPath = join(sessionDir, 'native-stop-state.json');
             await mkdir(sessionDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
             await writeFile(ralphPath, JSON.stringify({ active: true, current_phase: 'executing' }));
             await writeFile(nativeStopPath, JSON.stringify({
                 sessions: { [sessionId]: { last_signature: 'ralph-stop|pending' } },
             }));
             const cancelResult = runOmxWithEnv(wd, { OMX_SESSION_ID: 'unmatched-session' }, 'cancel', '--force');
-            assert.equal(cancelResult.status, 0, cancelResult.stderr || cancelResult.stdout);
-            assert.match(cancelResult.stderr, /OMX_SESSION_ID is not bound to session\.json/);
-            assert.match(cancelResult.stdout, /No active modes to cancel\./);
+            assert.notEqual(cancelResult.status, 0);
+            assert.match(cancelResult.stderr, /OMX_SESSION_ID does not match the live session recorded in session\.json/);
             assert.deepEqual(JSON.parse(await readFile(ralphPath, 'utf-8')), { active: true, current_phase: 'executing' });
             assert.deepEqual(JSON.parse(await readFile(nativeStopPath, 'utf-8')), { sessions: { [sessionId]: { last_signature: 'ralph-stop|pending' } } });
         }
@@ -76,6 +151,660 @@ describe('CLI session-scoped state parity', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('ignores ambient Codex session aliases that do not own writable cancellation', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-codex-session-mismatch-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const ownerSession = 'owner-session';
+            const foreignSession = 'foreign-codex-session';
+            const ownerPath = join(stateDir, 'sessions', ownerSession, 'ralplan-state.json');
+            const foreignPath = join(stateDir, 'sessions', foreignSession, 'team-state.json');
+            const ownerState = JSON.stringify({ active: true, mode: 'ralplan', current_phase: 'executing' }, null, 2);
+            const foreignState = JSON.stringify({ active: true, mode: 'team', current_phase: 'team-exec' }, null, 2);
+            await mkdir(dirname(ownerPath), { recursive: true });
+            await mkdir(dirname(foreignPath), { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: ownerSession, cwd: wd, state_root: stateDir }));
+            await writeFile(ownerPath, ownerState);
+            await writeFile(foreignPath, foreignState);
+            for (const environmentName of ['CODEX_SESSION_ID', 'SESSION_ID']) {
+                await writeFile(ownerPath, ownerState);
+                const cancelResult = runOmxWithEnv(wd, { [environmentName]: foreignSession }, 'cancel');
+                assert.equal(cancelResult.status, 0, cancelResult.stderr || cancelResult.stdout);
+                assert.match(cancelResult.stdout, /Cancelled: ralplan/);
+                assert.doesNotMatch(cancelResult.stdout, /Cancelled: team/);
+                assert.equal(JSON.parse(await readFile(ownerPath, 'utf-8')).active, false);
+                assert.equal(await readFile(foreignPath, 'utf-8'), foreignState);
+            }
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('keeps root cancellation authoritative despite ambient session aliases', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-root-ambient-session-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const foreignSession = 'foreign-ambient-session';
+            const rootPath = join(stateDir, 'team-state.json');
+            const foreignPath = join(stateDir, 'sessions', foreignSession, 'ralplan-state.json');
+            const rootState = JSON.stringify({ active: true, mode: 'team', current_phase: 'team-exec' }, null, 2);
+            const foreignState = JSON.stringify({ active: true, mode: 'ralplan', current_phase: 'executing' }, null, 2);
+            await mkdir(dirname(foreignPath), { recursive: true });
+            await writeFile(rootPath, rootState);
+            await writeFile(foreignPath, foreignState);
+            for (const environmentName of ['CODEX_SESSION_ID', 'SESSION_ID']) {
+                await writeFile(rootPath, rootState);
+                const cancelResult = runOmxWithEnv(wd, { [environmentName]: foreignSession }, 'cancel');
+                assert.equal(cancelResult.status, 0, cancelResult.stderr || cancelResult.stdout);
+                assert.match(cancelResult.stdout, /Cancelled: team/);
+                assert.doesNotMatch(cancelResult.stdout, /Cancelled: ralplan/);
+                assert.equal(JSON.parse(await readFile(rootPath, 'utf-8')).active, false);
+                assert.equal(await readFile(foreignPath, 'utf-8'), foreignState);
+            }
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('rejects unsupported cancellation flags before mutation', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-flags-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const statePath = join(stateDir, 'team-state.json');
+            const state = JSON.stringify({ active: true, mode: 'team', current_phase: 'team-exec' }, null, 2);
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(statePath, state);
+            for (const args of [['--all'], ['--unknown'], ['--force', '--all']]) {
+                const result = runOmx(wd, 'cancel', ...args);
+                assert.notEqual(result.status, 0);
+                assert.equal(await readFile(statePath, 'utf-8'), state);
+            }
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('rejects symlinked ordinary-scope state targets', async () => {
+        if (process.platform === 'win32')
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-root-symlink-'));
+        const outside = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-root-symlink-outside-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const outsidePath = join(outside, 'team-state.json');
+            const state = JSON.stringify({ active: true, mode: 'team', current_phase: 'team-exec' }, null, 2);
+            await mkdir(stateDir, { recursive: true });
+            await writeFile(outsidePath, state);
+            await symlink(outsidePath, join(stateDir, 'team-state.json'));
+            const result = runOmx(wd, 'cancel');
+            assert.notEqual(result.status, 0);
+            assert.match(result.stderr, /non-regular state target/);
+            assert.equal(await readFile(outsidePath, 'utf-8'), state);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(outside, { recursive: true, force: true });
+        }
+    });
+    it('rejects symlinked session authority directories', async () => {
+        if (process.platform === 'win32')
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-session-root-symlink-'));
+        const outside = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-session-root-outside-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'session-root-link';
+            const outsidePath = join(outside, 'ralplan-state.json');
+            const state = JSON.stringify({ active: true, mode: 'ralplan', session_id: sessionId, current_phase: 'executing' }, null, 2);
+            await mkdir(join(stateDir, 'sessions'), { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(outsidePath, state);
+            await symlink(outside, join(stateDir, 'sessions', sessionId), 'dir');
+            const result = runOmx(wd, 'cancel');
+            assert.notEqual(result.status, 0);
+            assert.match(result.stderr, /symlinked authority component|unusable/);
+            assert.equal(await readFile(outsidePath, 'utf-8'), state);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(outside, { recursive: true, force: true });
+        }
+    });
+    it('denies contradictory selected session state transaction-wide', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-contradictory-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'sess-contradictory';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const contradictoryPath = join(sessionDir, 'ralplan-state.json');
+            const validPath = join(sessionDir, 'autopilot-state.json');
+            const contradictory = JSON.stringify({ active: true, mode: 'team', session_id: 'foreign', current_phase: 'team-exec' }, null, 2);
+            const valid = JSON.stringify({ active: true, mode: 'autopilot', session_id: sessionId, current_phase: 'executing' }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(contradictoryPath, contradictory);
+            await writeFile(validPath, valid);
+            const result = runOmx(wd, 'cancel');
+            assert.notEqual(result.status, 0);
+            assert.match(result.stderr, /contradictory mode state/);
+            assert.equal(await readFile(contradictoryPath, 'utf-8'), contradictory);
+            assert.equal(await readFile(validPath, 'utf-8'), valid);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('fails closed when owned session state is malformed', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-malformed-owner-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'malformed-owner';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const malformedPath = join(sessionDir, 'ralplan-state.json');
+            const teamPath = join(stateDir, 'team-state.json');
+            const malformedState = '{"active":true';
+            const rootTeamState = JSON.stringify({ active: true, mode: 'team', current_phase: 'team-exec' }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(malformedPath, malformedState);
+            await writeFile(teamPath, rootTeamState);
+            const cancelResult = runOmx(wd, 'cancel');
+            assert.notEqual(cancelResult.status, 0);
+            assert.match(cancelResult.stderr, /Refusing partial cancellation/);
+            assert.doesNotMatch(cancelResult.stdout, /Cancelled: team/);
+            assert.equal(await readFile(malformedPath, 'utf-8'), malformedState);
+            assert.equal(await readFile(teamPath, 'utf-8'), rootTeamState);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('denies wrong-typed and nested ownership contradictions transaction-wide', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-owner-evidence-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'owner-evidence-session';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const skillPath = join(sessionDir, 'skill-active-state.json');
+            const modePath = join(sessionDir, 'autopilot-state.json');
+            const skillState = JSON.stringify({ active: true, skill: 'autopilot', owner_codex_session_id: 42, active_skills: [{ skill: 'autopilot', active: true, owner_codex_session_id: 'foreign-owner' }] }, null, 2);
+            const modeState = JSON.stringify({ active: true, mode: 'autopilot', session_id: sessionId }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(skillPath, skillState);
+            await writeFile(modePath, modeState);
+            const result = runOmx(wd, 'cancel');
+            assert.notEqual(result.status, 0);
+            assert.match(result.stderr, /contradictory owner_codex_session_id/);
+            assert.equal(await readFile(skillPath, 'utf-8'), skillState);
+            assert.equal(await readFile(modePath, 'utf-8'), modeState);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('keeps root Team compatibility state read-only when current-session Ralplan owns cancellation', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-cross-mode-scope-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'sess-ralplan-owner';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const ralplanPath = join(sessionDir, 'ralplan-state.json');
+            const teamPath = join(stateDir, 'team-state.json');
+            const skillActivePath = join(stateDir, 'skill-active-state.json');
+            const nativeStopPath = join(stateDir, 'native-stop-state.json');
+            const ralplanState = JSON.stringify({
+                active: true,
+                mode: 'ralplan',
+                current_phase: 'executing',
+            }, null, 2);
+            const rootTeamState = JSON.stringify({
+                active: true,
+                mode: 'team',
+                current_phase: 'team-exec',
+            }, null, 2);
+            const rootSkillActiveState = JSON.stringify({
+                version: 1,
+                active: true,
+                skill: 'team',
+                phase: 'team-exec',
+                active_skills: [{ skill: 'team', phase: 'team-exec', active: true }],
+            }, null, 2);
+            const rootNativeStopState = JSON.stringify({
+                sessions: { [sessionId]: { last_signature: 'team-stop|pending' } },
+            }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(ralplanPath, ralplanState);
+            await writeFile(teamPath, rootTeamState);
+            await writeFile(skillActivePath, rootSkillActiveState);
+            await writeFile(nativeStopPath, rootNativeStopState);
+            const cancelResult = runOmx(wd, 'cancel');
+            assert.equal(cancelResult.status, 0, cancelResult.stderr || cancelResult.stdout);
+            assert.match(cancelResult.stdout, /Cancelled: ralplan/);
+            assert.doesNotMatch(cancelResult.stdout, /Cancelled: team/);
+            assert.equal(JSON.parse(await readFile(ralplanPath, 'utf-8')).active, false);
+            assert.equal(await readFile(teamPath, 'utf-8'), rootTeamState);
+            assert.equal(await readFile(skillActivePath, 'utf-8'), rootSkillActiveState);
+            assert.equal(await readFile(nativeStopPath, 'utf-8'), rootNativeStopState);
+            await writeFile(ralplanPath, ralplanState);
+            const forceResult = runOmx(wd, 'cancel', '--force');
+            assert.equal(forceResult.status, 0, forceResult.stderr || forceResult.stdout);
+            assert.match(forceResult.stdout, /Cancelled: ralplan/);
+            assert.doesNotMatch(forceResult.stdout, /Cancelled: team/);
+            assert.equal(JSON.parse(await readFile(ralplanPath, 'utf-8')).active, false);
+            assert.equal(await readFile(teamPath, 'utf-8'), rootTeamState);
+            assert.equal(await readFile(skillActivePath, 'utf-8'), rootSkillActiveState);
+            assert.equal(await readFile(nativeStopPath, 'utf-8'), rootNativeStopState);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('replaces only a stale top-level skill owner under complete current native authority', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-stale-skill-owner-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'current-session';
+            const nativeSessionId = 'current-native-owner';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const pointer = JSON.stringify({
+                session_id: sessionId,
+                native_session_id: nativeSessionId,
+                cwd: wd,
+                state_root: stateDir,
+                platform: process.platform,
+            }, null, 2);
+            const skillPath = join(sessionDir, 'skill-active-state.json');
+            const ralplanPath = join(sessionDir, 'ralplan-state.json');
+            const rootSkillPath = join(stateDir, 'skill-active-state.json');
+            const rootSkill = JSON.stringify({ active: true, skill: 'team' }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), pointer);
+            await mkdir(join(stateDir, 'sessions', nativeSessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', nativeSessionId, 'session-owner.json'), JSON.stringify({
+                session_id: nativeSessionId,
+                native_session_id: nativeSessionId,
+                cwd: wd,
+                platform: process.platform,
+            }, null, 2));
+            await writeFile(skillPath, JSON.stringify({
+                active: true,
+                skill: 'ralplan',
+                owner_codex_session_id: 'stale-native-owner',
+                active_skills: [{ skill: 'ralplan', active: true, owner_codex_session_id: nativeSessionId }],
+            }, null, 2));
+            await writeFile(ralplanPath, JSON.stringify({ active: true, mode: 'ralplan' }, null, 2));
+            await writeFile(rootSkillPath, rootSkill);
+            const descendantCwd = join(wd, 'packages', 'app');
+            await mkdir(descendantCwd, { recursive: true });
+            const result = runOmxWithEnv(descendantCwd, { OMX_ROOT: wd }, 'cancel');
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const skill = JSON.parse(await readFile(skillPath, 'utf-8'));
+            assert.equal(skill.owner_codex_session_id, nativeSessionId);
+            assert.equal(skill.active_skills[0].owner_codex_session_id, nativeSessionId);
+            assert.equal(skill.active, false);
+            assert.equal(await readFile(rootSkillPath, 'utf-8'), rootSkill);
+            const repeat = runOmx(wd, 'cancel');
+            assert.equal(repeat.status, 0, repeat.stderr || repeat.stdout);
+            assert.equal(JSON.parse(await readFile(skillPath, 'utf-8')).owner_codex_session_id, nativeSessionId);
+            const malformedNestedSkill = JSON.stringify({
+                active: true,
+                skill: 'ralplan',
+                owner_codex_session_id: nativeSessionId,
+                active_skills: [{ skill: 'ralplan', active: 'true', owner_codex_session_id: nativeSessionId }],
+            }, null, 2);
+            await writeFile(skillPath, malformedNestedSkill);
+            const malformedNestedResult = runOmx(wd, 'cancel');
+            assert.notEqual(malformedNestedResult.status, 0);
+            assert.match(malformedNestedResult.stderr, /malformed active/);
+            assert.equal(await readFile(skillPath, 'utf-8'), malformedNestedSkill);
+            const fieldSwappedSkill = JSON.stringify({
+                active: true,
+                skill: 'ralplan',
+                session_id: nativeSessionId,
+                owner_codex_session_id: nativeSessionId,
+                active_skills: [{ skill: 'ralplan', active: true, session_id: nativeSessionId, owner_codex_session_id: nativeSessionId }],
+            }, null, 2);
+            await writeFile(skillPath, fieldSwappedSkill);
+            const fieldSwappedResult = runOmx(wd, 'cancel');
+            assert.notEqual(fieldSwappedResult.status, 0);
+            assert.match(fieldSwappedResult.stderr, /contradictory session_id/);
+            assert.equal(await readFile(skillPath, 'utf-8'), fieldSwappedSkill);
+            const inactiveStaleSkill = JSON.stringify({
+                active: false,
+                skill: 'ralplan',
+                owner_codex_session_id: 'stale-native-owner',
+                active_skills: [{ skill: 'ralplan', active: false, owner_codex_session_id: nativeSessionId }],
+            }, null, 2);
+            await writeFile(skillPath, inactiveStaleSkill);
+            const noActiveResult = runOmx(wd, 'cancel');
+            assert.equal(noActiveResult.status, 0, noActiveResult.stderr || noActiveResult.stdout);
+            assert.match(noActiveResult.stdout, /No active modes to cancel/);
+            assert.equal(await readFile(skillPath, 'utf-8'), inactiveStaleSkill);
+            const displacedDir = join(stateDir, 'sessions', 'stale-native-owner');
+            await mkdir(displacedDir, { recursive: true });
+            await writeFile(join(displacedDir, 'session-owner.json'), JSON.stringify({
+                session_id: 'stale-native-owner',
+                native_session_id: 'stale-native-owner',
+                cwd: wd,
+                platform: process.platform,
+            }, null, 2));
+            const liveDisplacedSkill = JSON.stringify({
+                active: true,
+                skill: 'ralplan',
+                owner_codex_session_id: 'stale-native-owner',
+                active_skills: [{ skill: 'ralplan', active: true, owner_codex_session_id: nativeSessionId }],
+            }, null, 2);
+            const activeRalplan = JSON.stringify({ active: true, mode: 'ralplan' }, null, 2);
+            await writeFile(skillPath, liveDisplacedSkill);
+            await writeFile(ralplanPath, activeRalplan);
+            const liveDisplaced = runOmx(wd, 'cancel');
+            assert.notEqual(liveDisplaced.status, 0);
+            assert.match(liveDisplaced.stderr, /non-stale displaced owner evidence/);
+            assert.equal(await readFile(skillPath, 'utf-8'), liveDisplacedSkill);
+            assert.equal(await readFile(ralplanPath, 'utf-8'), activeRalplan);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('preserves active Team skill entries while cancelling Ralph', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-ralph-team-peer-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'canonical-session';
+            const nativeSessionId = 'native-session';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const skillPath = join(sessionDir, 'skill-active-state.json');
+            const ralphPath = join(sessionDir, 'ralph-state.json');
+            const teamPath = join(sessionDir, 'team-state.json');
+            const teamState = JSON.stringify({ active: true, mode: 'team', current_phase: 'team-exec' }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({
+                session_id: sessionId,
+                native_session_id: nativeSessionId,
+                cwd: wd,
+                state_root: stateDir,
+            }, null, 2));
+            await mkdir(join(stateDir, 'sessions', nativeSessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', nativeSessionId, 'session-owner.json'), JSON.stringify({
+                session_id: nativeSessionId,
+                native_session_id: nativeSessionId,
+                cwd: wd,
+            }, null, 2));
+            await writeFile(skillPath, JSON.stringify({
+                active: true,
+                skill: 'ralph',
+                phase: 'executing',
+                session_id: sessionId,
+                owner_codex_session_id: nativeSessionId,
+                active_skills: [
+                    { skill: 'ralph', phase: 'executing', session_id: sessionId, owner_codex_session_id: nativeSessionId },
+                    { skill: 'team', phase: 'team-exec', session_id: sessionId, owner_codex_session_id: nativeSessionId },
+                ],
+            }, null, 2));
+            await writeFile(ralphPath, JSON.stringify({ active: true, mode: 'ralph' }, null, 2));
+            await writeFile(teamPath, teamState);
+            const result = runOmx(wd, 'cancel');
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const skill = JSON.parse(await readFile(skillPath, 'utf-8'));
+            assert.equal(skill.active, true);
+            assert.equal(skill.skill, 'team');
+            assert.equal(skill.phase, 'team-exec');
+            assert.equal(skill.current_phase, 'team-exec');
+            assert.deepEqual(skill.active_skills.map((entry) => [entry.skill, entry.active]), [
+                ['ralph', false],
+                ['team', undefined],
+            ]);
+            assert.equal(JSON.parse(await readFile(ralphPath, 'utf-8')).active, false);
+            assert.equal(await readFile(teamPath, 'utf-8'), teamState);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('preserves a legacy top-level Team marker while cancelling Ralph', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-legacy-team-ralph-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'legacy-team-ralph-session';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            const skillPath = join(sessionDir, 'skill-active-state.json');
+            const teamPath = join(sessionDir, 'team-state.json');
+            const ralphPath = join(sessionDir, 'ralph-state.json');
+            const legacyTeamSkill = JSON.stringify({ active: true, skill: 'team', phase: 'team-exec', session_id: sessionId, active_skills: [{ skill: 'code-review', active: false }] }, null, 2);
+            const activeTeam = JSON.stringify({ active: true, mode: 'team', session_id: sessionId }, null, 2);
+            await writeFile(skillPath, legacyTeamSkill);
+            await writeFile(teamPath, activeTeam);
+            await writeFile(ralphPath, JSON.stringify({ active: true, mode: 'ralph', session_id: sessionId }, null, 2));
+            const result = runOmx(wd, 'cancel');
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.equal(await readFile(skillPath, 'utf-8'), legacyTeamSkill);
+            assert.equal(await readFile(teamPath, 'utf-8'), activeTeam);
+            assert.equal(JSON.parse(await readFile(ralphPath, 'utf-8')).active, false);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('cancels valid skill-active-only workflow names without a duplicate allowlist', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-skill-only-name-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'skill-only-name-session';
+            const nativeSessionId = 'skill-only-name-native';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, native_session_id: nativeSessionId, cwd: wd, state_root: stateDir }));
+            const nativeOwnerDir = join(stateDir, 'sessions', nativeSessionId);
+            await mkdir(nativeOwnerDir, { recursive: true });
+            await writeFile(join(nativeOwnerDir, 'session-owner.json'), JSON.stringify({
+                session_id: nativeSessionId,
+                native_session_id: nativeSessionId,
+                cwd: wd,
+                platform: process.platform,
+            }));
+            const skillPath = join(sessionDir, 'skill-active-state.json');
+            await writeFile(skillPath, JSON.stringify({
+                active: true,
+                skill: 'code-review',
+                session_id: sessionId,
+                active_skills: [{ skill: 'code-review', active: true, session_id: sessionId, owner_codex_session_id: nativeSessionId }],
+            }, null, 2));
+            const result = runOmx(wd, 'cancel');
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            const skill = JSON.parse(await readFile(skillPath, 'utf-8'));
+            assert.equal(skill.active, false);
+            assert.equal(skill.active_skills[0].active, false);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('preserves mode-only cancellation without creating a skill marker', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-mode-only-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'mode-only-session';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const skillPath = join(sessionDir, 'skill-active-state.json');
+            const modePath = join(sessionDir, 'ralplan-state.json');
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(modePath, JSON.stringify({ active: true, mode: 'ralplan', session_id: sessionId }, null, 2));
+            const result = runOmx(wd, 'cancel');
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.match(result.stdout, /Cancelled: ralplan/);
+            assert.equal(existsSync(skillPath), false);
+            assert.equal(JSON.parse(await readFile(modePath, 'utf-8')).active, false);
+            const repeat = runOmx(wd, 'cancel');
+            assert.equal(repeat.status, 0, repeat.stderr || repeat.stdout);
+            assert.equal(existsSync(skillPath), false);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('reports rollback restoration failures without false cancellation success', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-rollback-failure-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'rollback-session';
+            const nativeSessionId = 'rollback-native';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const modePath = join(sessionDir, 'ralplan-state.json');
+            const skillPath = join(sessionDir, 'skill-active-state.json');
+            const modeState = JSON.stringify({ active: true, mode: 'ralplan', session_id: sessionId }, null, 2);
+            const skillState = JSON.stringify({
+                active: true,
+                skill: 'ralplan',
+                session_id: sessionId,
+                owner_codex_session_id: nativeSessionId,
+                active_skills: [{ skill: 'ralplan', active: true, session_id: sessionId, owner_codex_session_id: nativeSessionId }],
+            }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, native_session_id: nativeSessionId, cwd: wd, state_root: stateDir }));
+            await mkdir(join(stateDir, 'sessions', nativeSessionId), { recursive: true });
+            await writeFile(join(stateDir, 'sessions', nativeSessionId, 'session-owner.json'), JSON.stringify({
+                session_id: nativeSessionId,
+                native_session_id: nativeSessionId,
+                cwd: wd,
+            }));
+            await writeFile(modePath, modeState);
+            await writeFile(skillPath, skillState);
+            const errors = [];
+            const logs = [];
+            const previousError = console.error;
+            const previousLog = console.log;
+            const previousExitCode = process.exitCode;
+            const previousStderrWrite = process.stderr.write;
+            console.error = (...args) => { errors.push(args.map(String).join(' ')); };
+            console.log = (...args) => { logs.push(args.map(String).join(' ')); };
+            process.stderr.write = ((chunk) => {
+                errors.push(String(chunk));
+                return true;
+            });
+            try {
+                await cancelModesForTest(wd, [], {
+                    writeFailureMode: 'skill-active',
+                    rollbackFailureMode: 'ralplan',
+                });
+                assert.equal(process.exitCode, 1);
+            }
+            finally {
+                console.error = previousError;
+                console.log = previousLog;
+                process.stderr.write = previousStderrWrite;
+                process.exitCode = previousExitCode;
+            }
+            assert.match(errors.join('\n'), /cancellation_rollback_failed:1:ralplan/);
+            assert.doesNotMatch(logs.join('\n'), /Cancelled:/);
+            assert.equal(await readFile(skillPath, 'utf-8'), skillState);
+            assert.equal(JSON.parse(await readFile(modePath, 'utf-8')).active, false);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('fails Ralplan preflight without mutating unproven session state', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-ralplan-preflight-scope-'));
+        const codexBin = await createFakeCodexBin(wd, 'codex-cli 0.147.0');
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'sess-unproven-owner';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const ralplanPath = join(sessionDir, 'ralplan-state.json');
+            const ralplanState = JSON.stringify({
+                active: true,
+                mode: 'ralplan',
+                current_phase: 'starting',
+            }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(ralplanPath, ralplanState);
+            const preflightResult = runOmxWithEnv(wd, { PATH: `${codexBin}:${process.env.PATH}` }, 'ralplan', 'preflight', '--json');
+            assert.equal(preflightResult.status, 1, preflightResult.stderr || preflightResult.stdout);
+            assert.deepEqual(JSON.parse(preflightResult.stdout), {
+                ok: false,
+                reason: 'unsupported_documented_leader_proof',
+                diagnostics: {
+                    probe_status: 'ok',
+                    detected_version: '0.147.0',
+                    documented_root_identity: { status: 'unknown' },
+                },
+            });
+            assert.equal(await readFile(ralplanPath, 'utf-8'), ralplanState);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('keeps exact-owner routing-only Ralplan active after preflight denial', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-ralplan-preflight-owner-'));
+        const codexBin = await createFakeCodexBin(wd, 'codex-cli 0.147.0');
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'sess-proven-owner';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const ralplanPath = join(sessionDir, 'ralplan-state.json');
+            const sessionSkillPath = join(sessionDir, 'skill-active-state.json');
+            const rootTeamPath = join(stateDir, 'team-state.json');
+            const rootSkillPath = join(stateDir, 'skill-active-state.json');
+            const rootStopPath = join(stateDir, 'native-stop-state.json');
+            const rootTeam = JSON.stringify({ active: true, mode: 'team', current_phase: 'team-exec' }, null, 2);
+            const rootSkill = JSON.stringify({ active: true, skill: 'team', phase: 'team-exec' }, null, 2);
+            const rootStop = JSON.stringify({ sessions: { foreign: { pending: true } } }, null, 2);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            const activated = await recordSkillActivation({
+                stateDir,
+                sourceCwd: wd,
+                text: '$ralplan continue issue #3212',
+                sessionId,
+                threadId: 'thread-preflight-owner',
+                turnId: 'turn-preflight-owner',
+                nowIso: '2026-07-19T00:00:00.000Z',
+            });
+            assert.ok(activated);
+            const ralplanState = await readFile(ralplanPath, 'utf-8');
+            const sessionSkillState = await readFile(sessionSkillPath, 'utf-8');
+            await writeFile(rootTeamPath, rootTeam);
+            await writeFile(rootSkillPath, rootSkill);
+            await writeFile(rootStopPath, rootStop);
+            const sessionEntries = await readdir(sessionDir);
+            const preflightResult = runOmxWithEnv(wd, { OMX_SESSION_ID: sessionId, PATH: `${codexBin}:${process.env.PATH}` }, 'ralplan', 'preflight', '--json');
+            assert.equal(preflightResult.status, 1, preflightResult.stderr || preflightResult.stdout);
+            assert.deepEqual(JSON.parse(preflightResult.stdout), {
+                ok: false,
+                reason: 'unsupported_documented_leader_proof',
+                diagnostics: {
+                    probe_status: 'ok',
+                    detected_version: '0.147.0',
+                    documented_root_identity: { status: 'unknown' },
+                },
+            });
+            assert.equal(await readFile(ralplanPath, 'utf-8'), ralplanState);
+            assert.equal(await readFile(sessionSkillPath, 'utf-8'), sessionSkillState);
+            const [state, skillState] = await Promise.all([
+                readModeState('ralplan', wd),
+                readSkillActiveState(sessionSkillPath),
+            ]);
+            assert.equal(state?.active, true);
+            assert.equal(skillState?.active, true);
+            const postPreflightEntries = await readdir(sessionDir);
+            assert.deepEqual(postPreflightEntries, sessionEntries);
+            assert.equal(postPreflightEntries.some((name) => name.startsWith('.ralplan-neutralization-')), false);
+            assert.equal(await readFile(rootTeamPath, 'utf-8'), rootTeam);
+            assert.equal(await readFile(rootSkillPath, 'utf-8'), rootSkill);
+            assert.equal(await readFile(rootStopPath, 'utf-8'), rootStop);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('status does not report a root fallback mode as active after current-session clear', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-cli-session-clear-fallback-'));
         try {
@@ -83,7 +812,7 @@ describe('CLI session-scoped state parity', () => {
             const sessionId = 'sess-clear';
             const sessionDir = join(stateDir, 'sessions', sessionId);
             await mkdir(sessionDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
             await writeFile(join(stateDir, 'deep-interview-state.json'), JSON.stringify({
                 active: true,
                 mode: 'deep-interview',
@@ -106,17 +835,367 @@ describe('CLI session-scoped state parity', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('does not cancel a foreign hook-visible run-dir from session-owned scope', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-cancel-foreign-owner-'));
+        const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-cancel-foreign-runs-'));
+        try {
+            const ownerSessionId = 'sess-canonical-owner';
+            const foreignSessionId = 'sess-foreign-run';
+            const stateDir = join(wd, '.omx', 'state');
+            const runDir = join(runsRoot, 'run-foreign-session');
+            const runStateDir = join(runDir, '.omx', 'state');
+            const foreignSessionDir = join(runStateDir, 'sessions', foreignSessionId);
+            const foreignStatePath = join(foreignSessionDir, 'autopilot-state.json');
+            const foreignState = JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'deep-interview',
+            }, null, 2);
+            await mkdir(join(stateDir, 'sessions', ownerSessionId), { recursive: true });
+            await mkdir(foreignSessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: ownerSessionId }));
+            await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: foreignSessionId }));
+            await writeFile(foreignStatePath, foreignState);
+            await writeFile(join(runsRoot, 'registry.jsonl'), `${JSON.stringify({
+                source_cwd: wd,
+                run_dir: runDir,
+            })}\n`);
+            const cancelResult = runOmxWithEnv(wd, { OMX_RUNS_DIR: runsRoot }, 'cancel');
+            assert.notEqual(cancelResult.status, 0);
+            assert.match(cancelResult.stderr, /session\.json is present but unusable/);
+            assert.doesNotMatch(cancelResult.stdout, /Cancelled: autopilot/);
+            assert.equal(await readFile(foreignStatePath, 'utf-8'), foreignState);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(runsRoot, { recursive: true, force: true });
+        }
+    });
+    it('keeps stale registry-only run state read-only during root cancellation', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-stale-registry-'));
+        const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-stale-runs-'));
+        try {
+            const sessionId = 'sess-stale-registry';
+            const runDir = join(runsRoot, 'run-stale-registry');
+            const runStateDir = join(runDir, '.omx', 'state');
+            const statePath = join(runStateDir, 'sessions', sessionId, 'autopilot-state.json');
+            const state = JSON.stringify({ active: true, mode: 'autopilot', current_phase: 'deep-interview' }, null, 2);
+            await mkdir(dirname(statePath), { recursive: true });
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: sessionId }));
+            await writeFile(statePath, state);
+            await writeFile(join(runsRoot, 'registry.jsonl'), `${JSON.stringify({ source_cwd: wd, run_dir: runDir })}\n`);
+            const cancelResult = runOmxWithEnv(wd, { OMX_RUNS_DIR: runsRoot }, 'cancel');
+            assert.equal(cancelResult.status, 0, cancelResult.stderr || cancelResult.stdout);
+            assert.match(cancelResult.stdout, /No active modes to cancel\./);
+            assert.equal(await readFile(statePath, 'utf-8'), state);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(runsRoot, { recursive: true, force: true });
+        }
+    });
+    it('rejects a live run record whose run directory escapes through a symlink', async () => {
+        if (process.platform === 'win32')
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-symlink-owner-'));
+        const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-symlink-runs-'));
+        const outsideRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-symlink-outside-'));
+        try {
+            const sessionId = 'sess-symlink-escape';
+            const tmuxSessionName = 'omx-symlink-run';
+            const linkRunDir = join(runsRoot, 'linked-run');
+            const outsideStateDir = join(outsideRoot, '.omx', 'state');
+            const statePath = join(outsideStateDir, 'sessions', sessionId, 'autopilot-state.json');
+            const state = JSON.stringify({ active: true, mode: 'autopilot', current_phase: 'deep-interview' }, null, 2);
+            const fakeBin = await createFakeTmuxBin(wd);
+            await mkdir(dirname(statePath), { recursive: true });
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(outsideStateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: outsideStateDir }));
+            await writeFile(statePath, state);
+            await symlink(outsideRoot, linkRunDir, 'dir');
+            await writeActiveRunRecord({
+                runsRoot,
+                contextKey: 'symlink-run-context',
+                sourceCwd: wd,
+                runDir: linkRunDir,
+                sessionId,
+                tmuxSessionName,
+            });
+            const cancelResult = runOmxWithEnv(wd, {
+                OMX_RUNS_DIR: runsRoot,
+                PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+                FAKE_OMX_SESSION_ID: sessionId,
+                FAKE_TMUX_SESSION_NAME: tmuxSessionName,
+            }, 'cancel');
+            assert.notEqual(cancelResult.status, 0);
+            assert.match(cancelResult.stderr, /detached run authority is invalid/);
+            assert.equal(await readFile(statePath, 'utf-8'), state);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(runsRoot, { recursive: true, force: true });
+            await rm(outsideRoot, { recursive: true, force: true });
+        }
+    });
+    it('rejects nested session-directory and state-file symlink escapes', async () => {
+        if (process.platform === 'win32')
+            return;
+        for (const kind of ['session-dir', 'state-file']) {
+            const wd = await mkdtemp(join(tmpdir(), `omx-cli-nested-${kind}-owner-`));
+            const runsRoot = await mkdtemp(join(tmpdir(), `omx-cli-nested-${kind}-runs-`));
+            const outsideRoot = await mkdtemp(join(tmpdir(), `omx-cli-nested-${kind}-outside-`));
+            try {
+                const sessionId = `sess-nested-${kind}`;
+                const tmuxSessionName = `omx-nested-${kind}`;
+                const runDir = join(runsRoot, `run-nested-${kind}`);
+                const stateDir = join(runDir, '.omx', 'state');
+                const sessionDir = join(stateDir, 'sessions', sessionId);
+                const outsideStatePath = join(outsideRoot, 'autopilot-state.json');
+                const state = JSON.stringify({ active: true, mode: 'autopilot', current_phase: 'executing' }, null, 2);
+                const fakeBin = await createFakeTmuxBin(wd);
+                await mkdir(join(stateDir, 'sessions'), { recursive: true });
+                await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+                await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+                await writeFile(outsideStatePath, state);
+                if (kind === 'session-dir') {
+                    await symlink(outsideRoot, sessionDir, 'dir');
+                }
+                else {
+                    await mkdir(sessionDir, { recursive: true });
+                    await symlink(outsideStatePath, join(sessionDir, 'autopilot-state.json'));
+                }
+                await writeActiveRunRecord({ runsRoot, contextKey: `nested-${kind}`, sourceCwd: wd, runDir, sessionId, tmuxSessionName });
+                const cancelResult = runOmxWithEnv(wd, {
+                    OMX_RUNS_DIR: runsRoot,
+                    PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+                    FAKE_OMX_SESSION_ID: sessionId,
+                    FAKE_TMUX_SESSION_NAME: tmuxSessionName,
+                }, 'cancel');
+                assert.notEqual(cancelResult.status, 0);
+                assert.match(cancelResult.stderr, /detached run (?:state )?authority is invalid/);
+                assert.equal(await readFile(outsideStatePath, 'utf-8'), state);
+            }
+            finally {
+                await rm(wd, { recursive: true, force: true });
+                await rm(runsRoot, { recursive: true, force: true });
+                await rm(outsideRoot, { recursive: true, force: true });
+            }
+        }
+    });
+    it('revalidates frozen tmux incarnation immediately before mutation', async () => {
+        if (process.platform === 'win32')
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-run-toctou-owner-'));
+        const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-toctou-runs-'));
+        try {
+            const sessionId = 'sess-run-toctou';
+            const tmuxSessionName = 'omx-run-toctou';
+            const runDir = join(runsRoot, 'run-toctou');
+            const stateDir = join(runDir, '.omx', 'state');
+            const statePath = join(stateDir, 'sessions', sessionId, 'autopilot-state.json');
+            const state = JSON.stringify({ active: true, mode: 'autopilot', current_phase: 'executing' }, null, 2);
+            const counterPath = join(wd, 'tmux-count');
+            const fakeBin = await createFakeTmuxBin(wd);
+            await mkdir(dirname(statePath), { recursive: true });
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(statePath, state);
+            await writeActiveRunRecord({ runsRoot, contextKey: 'toctou-run', sourceCwd: wd, runDir, sessionId, tmuxSessionName });
+            const cancelResult = runOmxWithEnv(wd, {
+                OMX_RUNS_DIR: runsRoot,
+                PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+                FAKE_OMX_SESSION_ID: sessionId,
+                FAKE_TMUX_SESSION_NAME: tmuxSessionName,
+                FAKE_TMUX_COUNTER_FILE: counterPath,
+                FAKE_TMUX_REPLACE_AFTER_FIRST: '1',
+            }, 'cancel');
+            assert.notEqual(cancelResult.status, 0);
+            assert.match(cancelResult.stderr, /detached run authority changed/);
+            assert.equal(await readFile(statePath, 'utf-8'), state);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(runsRoot, { recursive: true, force: true });
+        }
+    });
+    it('denies the entire run transaction when one candidate state is malformed', async () => {
+        if (process.platform === 'win32')
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-run-malformed-owner-'));
+        const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-malformed-runs-'));
+        try {
+            const sessionId = 'sess-run-malformed';
+            const tmuxSessionName = 'omx-run-malformed';
+            const runDir = join(runsRoot, 'run-malformed');
+            const stateDir = join(runDir, '.omx', 'state');
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const validPath = join(sessionDir, 'ralplan-state.json');
+            const malformedPath = join(sessionDir, 'autopilot-state.json');
+            const validState = JSON.stringify({ active: true, mode: 'ralplan', current_phase: 'executing' }, null, 2);
+            const malformedState = '{"active":true';
+            const fakeBin = await createFakeTmuxBin(wd);
+            await mkdir(sessionDir, { recursive: true });
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(validPath, validState);
+            await writeFile(malformedPath, malformedState);
+            await writeActiveRunRecord({ runsRoot, contextKey: 'malformed-run', sourceCwd: wd, runDir, sessionId, tmuxSessionName });
+            const cancelResult = runOmxWithEnv(wd, {
+                OMX_RUNS_DIR: runsRoot,
+                PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+                FAKE_OMX_SESSION_ID: sessionId,
+                FAKE_TMUX_SESSION_NAME: tmuxSessionName,
+            }, 'cancel');
+            assert.notEqual(cancelResult.status, 0);
+            assert.match(cancelResult.stderr, /Refusing partial cancellation/);
+            assert.equal(await readFile(validPath, 'utf-8'), validState);
+            assert.equal(await readFile(malformedPath, 'utf-8'), malformedState);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(runsRoot, { recursive: true, force: true });
+        }
+    });
+    it('uses the authorized run session for force native-stop cleanup', async () => {
+        if (process.platform === 'win32')
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-run-force-owner-'));
+        const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-force-runs-'));
+        try {
+            const sessionId = 'sess-run-force';
+            const tmuxSessionName = 'omx-run-force';
+            const runDir = join(runsRoot, 'run-force');
+            const stateDir = join(runDir, '.omx', 'state');
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            const modePath = join(sessionDir, 'autopilot-state.json');
+            const stopPath = join(sessionDir, 'native-stop-state.json');
+            const fakeBin = await createFakeTmuxBin(wd);
+            await mkdir(sessionDir, { recursive: true });
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(modePath, JSON.stringify({ active: true, mode: 'autopilot', current_phase: 'executing' }));
+            await writeFile(stopPath, JSON.stringify({ sessions: { [sessionId]: { pending: true }, foreign: { pending: true } } }, null, 2));
+            await writeActiveRunRecord({ runsRoot, contextKey: 'force-run', sourceCwd: wd, runDir, sessionId, tmuxSessionName });
+            const cancelResult = runOmxWithEnv(wd, {
+                OMX_RUNS_DIR: runsRoot,
+                PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+                FAKE_OMX_SESSION_ID: sessionId,
+                FAKE_TMUX_SESSION_NAME: tmuxSessionName,
+            }, 'cancel', '--force');
+            assert.equal(cancelResult.status, 0, cancelResult.stderr || cancelResult.stdout);
+            assert.match(cancelResult.stdout, /Cancelled: autopilot/);
+            const stopState = JSON.parse(await readFile(stopPath, 'utf-8'));
+            assert.deepEqual(stopState.sessions, { foreign: { pending: true } });
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(runsRoot, { recursive: true, force: true });
+        }
+    });
+    it('issue #3550: bound detached-launch pointer lets ambient OMX_SESSION_ID cancel exact-session ralph state while a foreign session cannot', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cancel-3550-detached-root-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const omxLaunchId = 'omx-3550-launch';
+            const codexRootId = 'codex-root-3550';
+            const canonicalDir = join(stateDir, 'sessions', omxLaunchId);
+            const ralphPath = join(canonicalDir, 'ralph-state.json');
+            const ralphState = JSON.stringify({ active: true, current_phase: 'executing' }, null, 2);
+            await mkdir(canonicalDir, { recursive: true });
+            // Post-SessionStart state on current dev: the detached launch pointer has
+            // rebound to the native Codex root UUID while keeping the OMX owner alias.
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({
+                session_id: omxLaunchId,
+                native_session_id: codexRootId,
+                owner_omx_session_id: omxLaunchId,
+                cwd: wd,
+                state_root: stateDir,
+            }));
+            await writeFile(ralphPath, ralphState);
+            const foreignCancel = runOmxWithEnv(wd, { OMX_SESSION_ID: 'omx-foreign-session-3550' }, 'cancel', '--force');
+            assert.notEqual(foreignCancel.status, 0);
+            assert.match(foreignCancel.stderr, /OMX_SESSION_ID does not match the live session recorded in session\.json/);
+            assert.equal(await readFile(ralphPath, 'utf-8'), ralphState);
+            const boundCancel = runOmxWithEnv(wd, { OMX_SESSION_ID: omxLaunchId }, 'cancel', '--force');
+            assert.equal(boundCancel.status, 0, boundCancel.stderr || boundCancel.stdout);
+            assert.match(boundCancel.stdout, /Cancelled: ralph/);
+            const updated = JSON.parse(await readFile(ralphPath, 'utf-8'));
+            assert.equal(updated.active, false);
+            assert.equal(updated.current_phase, 'cancelled');
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it('fails closed when multiple live run records match the same root', async () => {
+        if (process.platform === 'win32')
+            return;
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-duplicate-owner-'));
+        const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-duplicate-runs-'));
+        try {
+            const sessionId = 'sess-duplicate-live';
+            const tmuxSessionName = 'omx-duplicate-run';
+            const fakeBin = await createFakeTmuxBin(wd);
+            const states = [];
+            await mkdir(join(wd, '.omx', 'state'), { recursive: true });
+            for (const [index, mode] of ['autopilot', 'ralplan'].entries()) {
+                const runDir = join(runsRoot, `run-duplicate-${index}`);
+                const runStateDir = join(runDir, '.omx', 'state');
+                const statePath = join(runStateDir, 'sessions', sessionId, `${mode}-state.json`);
+                const content = JSON.stringify({ active: true, mode, current_phase: 'executing' }, null, 2);
+                await mkdir(dirname(statePath), { recursive: true });
+                await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: runStateDir }));
+                await writeFile(statePath, content);
+                await writeActiveRunRecord({
+                    runsRoot,
+                    contextKey: `duplicate-run-context-${index}`,
+                    sourceCwd: wd,
+                    runDir,
+                    sessionId,
+                    tmuxSessionName,
+                });
+                states.push({ path: statePath, content });
+            }
+            const cancelResult = runOmxWithEnv(wd, {
+                OMX_RUNS_DIR: runsRoot,
+                PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+                FAKE_OMX_SESSION_ID: sessionId,
+                FAKE_TMUX_SESSION_NAME: tmuxSessionName,
+            }, 'cancel');
+            assert.notEqual(cancelResult.status, 0);
+            assert.match(cancelResult.stderr, /No active modes|multiple|authority/i);
+            for (const state of states) {
+                assert.equal(await readFile(state.path, 'utf-8'), state.content);
+            }
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+            await rm(runsRoot, { recursive: true, force: true });
+        }
+    });
     it('cancels hook-visible run-dir session state when worktree state list-active is empty', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-cancel-worktree-'));
         const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-cancel-runs-'));
         try {
+            if (process.platform === 'win32')
+                return;
             const sessionId = 'sess-run-dir-cancel';
+            const tmuxSessionName = 'omx-live-run';
             const runDir = join(runsRoot, 'run-20260610121751-b6c4');
             const runStateDir = join(runDir, '.omx', 'state');
             const runSessionDir = join(runStateDir, 'sessions', sessionId);
+            const fakeBin = await createFakeTmuxBin(wd);
+            const rootAutopilotPath = join(runStateDir, 'autopilot-state.json');
+            const rootAutopilotState = JSON.stringify({
+                active: true,
+                mode: 'autopilot',
+                current_phase: 'stale-root-copy',
+            }, null, 2);
             await mkdir(runSessionDir, { recursive: true });
             await mkdir(join(wd, '.omx', 'state'), { recursive: true });
-            await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
+            await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: runStateDir }, null, 2));
+            await writeFile(rootAutopilotPath, rootAutopilotState);
             await writeFile(join(runSessionDir, 'autopilot-state.json'), JSON.stringify({
                 active: true,
                 mode: 'autopilot',
@@ -130,18 +1209,23 @@ describe('CLI session-scoped state parity', () => {
                 session_id: sessionId,
                 active_skills: [{ skill: 'autopilot', phase: 'deep-interview', active: true, session_id: sessionId }],
             }, null, 2));
-            await writeFile(join(runsRoot, 'registry.jsonl'), `${JSON.stringify({
-                launcher: 'omx --madmax',
-                created_at: '2026-06-10T12:17:51.000Z',
-                cwd: runDir,
-                source_cwd: wd,
-                argv: ['codex'],
-                run_dir: runDir,
-            })}\n`);
+            await writeActiveRunRecord({
+                runsRoot,
+                contextKey: 'live-run-context',
+                sourceCwd: wd,
+                runDir,
+                sessionId,
+                tmuxSessionName,
+            });
             const listResult = runOmx(wd, 'state', 'list-active', '--json');
             assert.equal(listResult.status, 0, listResult.stderr || listResult.stdout);
             assert.deepEqual(JSON.parse(listResult.stdout), { active_modes: [] });
-            const cancelResult = runOmxWithEnv(wd, { OMX_RUNS_DIR: runsRoot }, 'cancel');
+            const cancelResult = runOmxWithEnv(wd, {
+                OMX_RUNS_DIR: runsRoot,
+                PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+                FAKE_OMX_SESSION_ID: sessionId,
+                FAKE_TMUX_SESSION_NAME: tmuxSessionName,
+            }, 'cancel');
             assert.equal(cancelResult.status, 0, cancelResult.stderr || cancelResult.stdout);
             assert.match(cancelResult.stdout, /Cancelled: autopilot/);
             assert.doesNotMatch(cancelResult.stdout, /No active modes to cancel/);
@@ -149,6 +1233,7 @@ describe('CLI session-scoped state parity', () => {
             assert.equal(autopilot.active, false);
             assert.equal(autopilot.current_phase, 'cancelled');
             assert.ok(typeof autopilot.completed_at === 'string' && autopilot.completed_at.length > 0);
+            assert.equal(await readFile(rootAutopilotPath, 'utf-8'), rootAutopilotState);
             const skillActive = JSON.parse(await readFile(join(runSessionDir, 'skill-active-state.json'), 'utf-8'));
             assert.equal(skillActive.active, false);
             assert.equal(skillActive.current_phase, 'cancelled');
@@ -173,7 +1258,7 @@ describe('CLI session-scoped state parity', () => {
             const runSessionDir = join(runStateDir, 'sessions', sessionId);
             await mkdir(runSessionDir, { recursive: true });
             await mkdir(join(wd, '.omx', 'state'), { recursive: true });
-            await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
+            await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: runStateDir }, null, 2));
             await writeFile(join(runSessionDir, 'autopilot-state.json'), JSON.stringify({
                 active: true,
                 mode: 'autopilot',
@@ -205,35 +1290,39 @@ describe('CLI session-scoped state parity', () => {
         const worktree = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-worktree-alias-wt-'));
         const runsRoot = await mkdtemp(join(tmpdir(), 'omx-cli-run-dir-worktree-alias-runs-'));
         try {
+            if (process.platform === 'win32')
+                return;
             const sessionId = 'sess-run-dir-worktree-alias';
             const runDir = join(runsRoot, 'run-20260610121751-a11a');
             const runStateDir = join(runDir, '.omx', 'state');
             const runSessionDir = join(runStateDir, 'sessions', sessionId);
+            const fakeBin = await createFakeTmuxBin(worktree);
             await mkdir(runSessionDir, { recursive: true });
             await mkdir(join(worktree, '.omx', 'state'), { recursive: true });
-            await mkdir(join(runsRoot, 'active-detached'), { recursive: true });
-            await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
+            await writeFile(join(runStateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: runStateDir }, null, 2));
             await writeFile(join(runSessionDir, 'autopilot-state.json'), JSON.stringify({
                 active: true,
                 mode: 'autopilot',
                 current_phase: 'deep-interview',
             }, null, 2));
-            await writeFile(join(runsRoot, 'active-detached', 'ctx-worktree-alias.json'), `${JSON.stringify({
-                version: 1,
-                context_key: 'ctx-worktree-alias',
-                created_at: '2026-06-10T12:17:51.000Z',
-                source_cwd: wd,
-                worktree_cwd: worktree,
-                argv: ['--madmax', '--worktree', '--tmux'],
-                run_dir: runDir,
-                tmux_session_name: 'omx-detached',
-                session_id: sessionId,
-                tmux_pane_id: '%42',
-            })}\n`);
+            await writeActiveRunRecord({
+                runsRoot,
+                contextKey: 'ctx-worktree-alias',
+                sourceCwd: wd,
+                worktreeCwd: worktree,
+                runDir,
+                sessionId,
+                tmuxSessionName: 'omx-detached',
+            });
             const statusResult = runOmxWithEnv(worktree, { OMX_RUNS_DIR: runsRoot }, 'status');
             assert.equal(statusResult.status, 0, statusResult.stderr || statusResult.stdout);
             assert.match(statusResult.stdout, /autopilot: ACTIVE \(phase: deep-interview\)/);
-            const cancelResult = runOmxWithEnv(worktree, { OMX_RUNS_DIR: runsRoot }, 'cancel');
+            const cancelResult = runOmxWithEnv(worktree, {
+                OMX_RUNS_DIR: runsRoot,
+                PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+                FAKE_OMX_SESSION_ID: sessionId,
+                FAKE_TMUX_SESSION_NAME: 'omx-detached',
+            }, 'cancel');
             assert.equal(cancelResult.status, 0, cancelResult.stderr || cancelResult.stdout);
             assert.match(cancelResult.stdout, /Cancelled: autopilot/);
             const autopilot = JSON.parse(await readFile(join(runSessionDir, 'autopilot-state.json'), 'utf-8'));
@@ -251,7 +1340,7 @@ describe('CLI session-scoped state parity', () => {
         try {
             const stateDir = join(wd, '.omx', 'state');
             await mkdir(stateDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: 'sess-stale-autopilot' }, null, 2));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: 'sess-stale-autopilot', cwd: wd, state_root: stateDir }, null, 2));
             const currentAutopilotPath = join(stateDir, 'current-autopilot.json');
             const currentAutopilot = {
                 active: true,
@@ -281,7 +1370,7 @@ describe('CLI session-scoped state parity', () => {
             const sessionId = 'sess-stale-autopilot-inactive';
             const sessionDir = join(stateDir, 'sessions', sessionId);
             await mkdir(sessionDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }, null, 2));
             const currentAutopilotPath = join(stateDir, 'current-autopilot.json');
             const currentAutopilot = {
                 active: true,
@@ -313,7 +1402,7 @@ describe('CLI session-scoped state parity', () => {
             const sessionId = 'sess-active-autopilot';
             const sessionDir = join(stateDir, 'sessions', sessionId);
             await mkdir(sessionDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }, null, 2));
             await writeFile(join(stateDir, 'current-autopilot.json'), JSON.stringify({
                 active: true,
                 current_phase: 'complete',
@@ -389,7 +1478,7 @@ describe('CLI session-scoped state parity', () => {
             const ultragoalDir = join(wd, '.omx', 'ultragoal');
             await mkdir(sessionDir, { recursive: true });
             await mkdir(ultragoalDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
             await writeFile(join(sessionDir, 'ultragoal-state.json'), JSON.stringify({
                 active: true,
                 mode: 'ultragoal',
@@ -425,7 +1514,7 @@ describe('CLI session-scoped state parity', () => {
             const sessionId = 'sess-link';
             const sessionDir = join(stateDir, 'sessions', sessionId);
             await mkdir(sessionDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
             await writeFile(join(sessionDir, 'ralph-state.json'), JSON.stringify({
                 active: true,
                 iteration: 2,
@@ -454,6 +1543,27 @@ describe('CLI session-scoped state parity', () => {
             await rm(wd, { recursive: true, force: true });
         }
     });
+    it('cancels linked ecomode before Ralph', async () => {
+        const wd = await mkdtemp(join(tmpdir(), 'omx-cli-ralph-ecomode-link-'));
+        try {
+            const stateDir = join(wd, '.omx', 'state');
+            const sessionId = 'sess-ecomode-link';
+            const sessionDir = join(stateDir, 'sessions', sessionId);
+            await mkdir(sessionDir, { recursive: true });
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }));
+            await writeFile(join(sessionDir, 'ralph-state.json'), JSON.stringify({ active: true, mode: 'ralph', session_id: sessionId, current_phase: 'executing', linked_ecomode: true }));
+            await writeFile(join(sessionDir, 'ecomode-state.json'), JSON.stringify({ active: true, mode: 'ecomode', session_id: sessionId, current_phase: 'executing' }));
+            const result = runOmx(wd, 'cancel');
+            assert.equal(result.status, 0, result.stderr || result.stdout);
+            assert.match(result.stdout, /Cancelled: ecomode/);
+            assert.match(result.stdout, /Cancelled: ralph/);
+            assert.equal(JSON.parse(await readFile(join(sessionDir, 'ecomode-state.json'), 'utf-8')).active, false);
+            assert.equal(JSON.parse(await readFile(join(sessionDir, 'ralph-state.json'), 'utf-8')).active, false);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
     it('does not mutate unrelated sessions when cancelling current session mode', async () => {
         const wd = await mkdtemp(join(tmpdir(), 'omx-cli-cross-session-'));
         try {
@@ -462,7 +1572,7 @@ describe('CLI session-scoped state parity', () => {
             const sessionB = join(stateDir, 'sessions', 'sessB');
             await mkdir(sessionA, { recursive: true });
             await mkdir(sessionB, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: 'sessA' }));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: 'sessA', cwd: wd, state_root: stateDir }));
             await writeFile(join(sessionA, 'ralph-state.json'), JSON.stringify({
                 active: true,
                 current_phase: 'executing',
@@ -494,7 +1604,7 @@ describe('CLI session-scoped state parity', () => {
             const sessionId = 'sess-stale-autopilot-mirror';
             const sessionDir = join(stateDir, 'sessions', sessionId);
             await mkdir(sessionDir, { recursive: true });
-            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId }, null, 2));
+            await writeFile(join(stateDir, 'session.json'), JSON.stringify({ session_id: sessionId, cwd: wd, state_root: stateDir }, null, 2));
             await writeFile(join(stateDir, 'autopilot-state.json'), JSON.stringify({
                 active: false,
                 mode: 'autopilot',