oh-my-codex 0.18.11 → 0.18.13

package/dist/cli/index.js

@@ -3,8 +3,8 @@
  * Multi-agent orchestration for OpenAI Codex CLI
  */
 import { execFileSync, spawn } from "child_process";
-import { basename, delimiter, dirname, join, posix, win32 } from "path";
-import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { basename, dirname, join, posix, resolve, win32 } from "path";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "fs";
 import { copyFile, cp, lstat, mkdir, readFile, readdir, rm, symlink, writeFile } from "fs/promises";
 import { constants as osConstants, homedir } from "os";
 import { createHash } from "crypto";
@@ -41,6 +41,7 @@ import { MADMAX_FLAG, CODEX_BYPASS_FLAG, HIGH_REASONING_FLAG, XHIGH_REASONING_FL
 import { getBaseStateDir, getStateDir, listModeStateFilesWithScopePreference, } from "../mcp/state-paths.js";
 import { evaluateRalphCompletionAuditEvidence, isRalphCompletePhase } from "../ralph/completion-audit.js";
 import { readPersistedSetupPreferences, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
+import { discoverProjectRuntimeCodexHomes } from "./project-runtime-codex-homes.js";
 import { escapeTomlString, readTopLevelTomlString, upsertTopLevelTomlString } from "../utils/toml.js";
 export { readPersistedSetupPreferences, readPersistedSetupScope, resolveCodexConfigPathForLaunch, resolveCodexHomeForLaunch, resolveProjectLocalCodexHomeForLaunch, } from "./codex-home.js";
 import { SKILL_ACTIVE_STATE_MODE, extractSessionIdFromInitializedStatePath, getSkillActiveStatePathsForStateDir, listActiveSkills, readSkillActiveState, syncCanonicalSkillStateForMode, } from "../state/skill-active.js";
@@ -107,10 +108,10 @@ Usage:
   omx auth      Manage Codex OAuth auth slots (add|list|use)
   omx question  OMX-owned blocking question UI entrypoint for agent-invoked user questions
   omx adapt     Scaffold OMX-owned adapter foundations for persistent external targets
-  omx resume    Resume a previous interactive Codex session
+  omx resume    Resume Codex sessions (supports --project and --codex-home <path>)
   omx explore   DEPRECATED compatibility command; use normal repo inspection or omx sparkshell
   omx api       Run native omx-api localhost gateway commands (serve|status|stop|generate)
-  omx session   Search prior local session transcripts and history artifacts
+  omx session   Search prior local session transcripts (--codex-home <path> escape hatch)
   omx agents-init [path]
                 Bootstrap lightweight AGENTS.md files for a repo/subtree
   omx agents    Manage Codex native agent TOML files
@@ -563,14 +564,124 @@ const PROJECT_LAUNCH_PERSISTED_RUNTIME_ENTRY_NAMES = new Set([
     // log the contents.
     "auth.json",
 ]);
+const PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES = new Set([
+    "sessions",
+    "history.jsonl",
+    "session_index.jsonl",
+]);
 // Mirroring these files into the runtime CODEX_HOME would cause Codex to load
 // them as user-scope config alongside the canonical project-scope copies under
 // <cwd>/.codex, duplicating every native hook and asking the user to re-trust
 // hooks on every launch. See GH issue #2470.
 const PROJECT_LAUNCH_RUNTIME_SKIPPED_ENTRY_NAMES = new Set(["hooks.json"]);
+function shouldMirrorProjectLaunchRuntimeEntry(entryName, includeHistoryArtifacts) {
+    if (PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES.has(entryName))
+        return true;
+    if (isCodexSqliteArtifact(entryName))
+        return includeHistoryArtifacts;
+    return true;
+}
 function shouldPersistProjectLaunchRuntimeEntry(entryName) {
     return PROJECT_LAUNCH_PERSISTED_RUNTIME_ENTRY_NAMES.has(entryName);
 }
+function uniqueJsonlLines(contents) {
+    const seen = new Set();
+    const lines = [];
+    for (const line of contents.split(/\r?\n/)) {
+        if (line === "" || seen.has(line))
+            continue;
+        seen.add(line);
+        lines.push(line);
+    }
+    return lines;
+}
+async function persistProjectLaunchRuntimeJsonlArtifact(source, destination) {
+    const existing = existsSync(destination) ? await readFile(destination, "utf-8").catch(() => "") : "";
+    const sourceContents = await readFile(source, "utf-8");
+    const separator = existing === "" || existing.endsWith("\n") || sourceContents === "" ? "" : "\n";
+    const lines = uniqueJsonlLines(`${existing}${separator}${sourceContents}`);
+    await writeFile(destination, lines.length > 0 ? `${lines.join("\n")}\n` : "", "utf-8");
+}
+async function persistProjectLaunchRuntimeHistoryArtifacts(runtimeCodexHome, projectCodexHome) {
+    if (!runtimeCodexHome || !projectCodexHome)
+        return;
+    if (!existsSync(runtimeCodexHome))
+        return;
+    await mkdir(projectCodexHome, { recursive: true });
+    for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+        const source = join(runtimeCodexHome, entryName);
+        if (!existsSync(source))
+            continue;
+        const sourceStat = await lstat(source);
+        if (sourceStat.isSymbolicLink())
+            continue;
+        const destination = join(projectCodexHome, entryName);
+        if (sourceStat.isDirectory()) {
+            await cp(source, destination, { recursive: true, force: true, verbatimSymlinks: true });
+            continue;
+        }
+        if (entryName === "history.jsonl" || entryName === "session_index.jsonl") {
+            await persistProjectLaunchRuntimeJsonlArtifact(source, destination);
+            continue;
+        }
+        if (sourceStat.isFile()) {
+            await copyFile(source, destination);
+        }
+    }
+}
+async function ensureProjectLaunchRuntimeHistoryLinks(runtimeCodexHome, projectCodexHome) {
+    await mkdir(projectCodexHome, { recursive: true });
+    for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+        const runtimeEntry = join(runtimeCodexHome, entryName);
+        if (existsSync(runtimeEntry))
+            continue;
+        const projectEntry = join(projectCodexHome, entryName);
+        if (entryName === "sessions") {
+            await mkdir(projectEntry, { recursive: true });
+        }
+        else if (!existsSync(projectEntry)) {
+            await writeFile(projectEntry, "");
+        }
+        await linkOrCopyCodexHomeEntry(projectEntry, runtimeEntry);
+    }
+}
+async function materializeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, sourceCodexHome) {
+    for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+        const source = join(sourceCodexHome, entryName);
+        if (!existsSync(source))
+            continue;
+        const destination = join(runtimeCodexHome, entryName);
+        await rm(destination, { recursive: true, force: true });
+        const sourceStat = await lstat(source);
+        if (sourceStat.isDirectory()) {
+            await cp(source, destination, { recursive: true, force: true, dereference: true });
+            continue;
+        }
+        await copyFile(source, destination);
+    }
+}
+async function mergeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, sourceCodexHome) {
+    for (const entryName of PROJECT_LAUNCH_DURABLE_HISTORY_ENTRY_NAMES) {
+        const source = join(sourceCodexHome, entryName);
+        if (!existsSync(source))
+            continue;
+        const destination = join(runtimeCodexHome, entryName);
+        const sourceStat = await lstat(source);
+        if (sourceStat.isDirectory()) {
+            await mkdir(destination, { recursive: true });
+            await cp(source, destination, { recursive: true, force: true, dereference: true });
+            continue;
+        }
+        if (existsSync(destination)) {
+            const existing = await readFile(destination, "utf-8").catch(() => "");
+            const addition = await readFile(source, "utf-8");
+            const separator = existing === "" || existing.endsWith("\n") || addition === "" ? "" : "\n";
+            await writeFile(destination, `${existing}${separator}${addition}`, "utf-8");
+            continue;
+        }
+        await copyFile(source, destination);
+    }
+}
 export async function persistProjectLaunchRuntimeAuthState(runtimeCodexHome, projectCodexHome) {
     if (!runtimeCodexHome || !projectCodexHome)
         return;
@@ -587,10 +698,12 @@ export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, pr
     const runtimeCodexHome = runtimeCodexHomePath(cwd, sessionId);
     await rm(runtimeCodexHome, { recursive: true, force: true });
     await mkdir(runtimeCodexHome, { recursive: true });
-    if (!existsSync(projectCodexHome))
+    if (!existsSync(projectCodexHome)) {
+        await ensureProjectLaunchRuntimeHistoryLinks(runtimeCodexHome, projectCodexHome);
         return runtimeCodexHome;
+    }
     for (const entry of await readdir(projectCodexHome, { withFileTypes: true })) {
-        if (isCodexSqliteArtifact(entry.name) && !options.includeHistoryArtifacts)
+        if (!shouldMirrorProjectLaunchRuntimeEntry(entry.name, options.includeHistoryArtifacts === true))
             continue;
         if (PROJECT_LAUNCH_RUNTIME_SKIPPED_ENTRY_NAMES.has(entry.name))
             continue;
@@ -608,6 +721,13 @@ export async function prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, pr
         }
         await linkOrCopyCodexHomeEntry(source, destination);
     }
+    await ensureProjectLaunchRuntimeHistoryLinks(runtimeCodexHome, projectCodexHome);
+    if (options.includeHistoryArtifacts === true && (options.extraHistoryCodexHomes?.length ?? 0) > 0) {
+        await materializeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, projectCodexHome);
+        for (const extraCodexHome of options.extraHistoryCodexHomes ?? []) {
+            await mergeProjectLaunchRuntimeHistoryEntries(runtimeCodexHome, extraCodexHome);
+        }
+    }
     return runtimeCodexHome;
 }
 function resolveProjectSqliteHomeForLaunch(projectCodexHome, env) {
@@ -619,7 +739,7 @@ function resolveProjectSqliteHomeForLaunch(projectCodexHome, env) {
 export async function prepareCodexHomeForLaunch(cwd, sessionId, env = process.env, options = {}) {
     const projectLocalCodexHomeForCleanup = resolveProjectLocalCodexHomeForLaunch(cwd, env);
     if (projectLocalCodexHomeForCleanup) {
-        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectLocalCodexHomeForCleanup, { includeHistoryArtifacts: options.includeHistoryArtifacts });
+        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectLocalCodexHomeForCleanup, { includeHistoryArtifacts: options.includeHistoryArtifacts, extraHistoryCodexHomes: options.extraHistoryCodexHomes });
         return {
             codexHomeOverride: runtimeCodexHome,
             sqliteHomeOverride: resolveProjectSqliteHomeForLaunch(projectLocalCodexHomeForCleanup, env),
@@ -632,6 +752,81 @@ export async function prepareCodexHomeForLaunch(cwd, sessionId, env = process.en
         projectLocalCodexHomeForCleanup,
     };
 }
+export function parseResumeCodexHomeSelection(args) {
+    const nextArgs = [];
+    let explicitCodexHome;
+    let projectOnly = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--codex-home") {
+            const value = args[index + 1];
+            if (!value || value.startsWith("-")) {
+                throw new Error("Missing value after --codex-home.");
+            }
+            explicitCodexHome = value;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--codex-home=")) {
+            explicitCodexHome = arg.slice("--codex-home=".length);
+            if (explicitCodexHome.trim() === "") {
+                throw new Error("Missing value after --codex-home.");
+            }
+            continue;
+        }
+        if (arg === "--project") {
+            projectOnly = true;
+            continue;
+        }
+        nextArgs.push(arg);
+    }
+    return {
+        args: nextArgs,
+        explicitCodexHome,
+        projectOnly,
+    };
+}
+async function prepareResumeCodexHomeForLaunch(cwd, sessionId, args, env = process.env) {
+    const selection = parseResumeCodexHomeSelection(args);
+    if (selection.explicitCodexHome) {
+        return {
+            args: selection.args,
+            prepared: {
+                codexHomeOverride: resolve(selection.explicitCodexHome),
+            },
+        };
+    }
+    const projectHomes = await discoverProjectRuntimeCodexHomes(cwd);
+    if (selection.projectOnly) {
+        if (projectHomes.length === 0) {
+            const emptyRuntimeCodexHome = runtimeCodexHomePath(cwd, sessionId);
+            await rm(emptyRuntimeCodexHome, { recursive: true, force: true });
+            await mkdir(join(emptyRuntimeCodexHome, "sessions"), { recursive: true });
+            return {
+                args: selection.args,
+                prepared: {
+                    codexHomeOverride: emptyRuntimeCodexHome,
+                    runtimeCodexHomeForCleanup: emptyRuntimeCodexHome,
+                },
+            };
+        }
+        const runtimeCodexHome = await prepareRuntimeCodexHomeForProjectLaunch(cwd, sessionId, projectHomes[0].path, {
+            includeHistoryArtifacts: true,
+            extraHistoryCodexHomes: projectHomes.slice(1).map((home) => home.path),
+        });
+        return {
+            args: selection.args,
+            prepared: {
+                codexHomeOverride: runtimeCodexHome,
+            },
+        };
+    }
+    const prepared = await prepareCodexHomeForLaunch(cwd, sessionId, env, {
+        includeHistoryArtifacts: true,
+        extraHistoryCodexHomes: projectHomes.map((home) => home.path),
+    });
+    return { args: selection.args, prepared };
+}
 export async function persistProjectLaunchRuntimeProjectTrustState(runtimeCodexHome, projectCodexHome) {
     if (!runtimeCodexHome || !projectCodexHome)
         return;
@@ -654,6 +849,7 @@ export async function cleanupRuntimeCodexHome(runtimeCodexHomeForCleanup, projec
     if (!runtimeCodexHomeForCleanup)
         return;
     await persistProjectLaunchRuntimeAuthState(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence);
+    await persistProjectLaunchRuntimeHistoryArtifacts(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence);
     await persistProjectLaunchRuntimeProjectTrustState(runtimeCodexHomeForCleanup, projectCodexHomeForPersistence);
     await rm(runtimeCodexHomeForCleanup, { recursive: true, force: true });
 }
@@ -774,7 +970,10 @@ function tmuxPaneBelongsToSession(paneId, sessionName) {
     }
 }
 function buildDetachedHistoryPruneHookCommand(leaderPaneId) {
-    return `if-shell -F '#{==:#{session_attached},0}' 'clear-history -t ${leaderPaneId}'`;
+    // The leader pane can be gone by the time the hook fires (e.g. crashed
+    // leader with a lingering session); suppress errors so tmux does not queue
+    // "(null):0: can't find pane" for the next attaching client.
+    return `if-shell -F '#{==:#{session_attached},0}' 'run-shell -b "tmux clear-history -t ${leaderPaneId} >/dev/null 2>&1 || true"'`;
 }
 function buildDetachedHistoryPruneHookSlot(sessionName, leaderPaneId) {
     const key = `${sessionName}:${leaderPaneId}:omx-history-prune`;
@@ -992,8 +1191,11 @@ function runCodexBlocking(cwd, launchArgs, codexEnv) {
         }
     }
 }
-export function omxRuntimeCommandShimPath(cwd) {
-    return join(omxRoot(cwd), "runtime", "bin", "omx");
+export function omxRuntimeCommandShimFileName(platform = process.platform) {
+    return platform === "win32" ? "omx.cmd" : "omx";
+}
+export function omxRuntimeCommandShimPath(cwd, platform = process.platform) {
+    return join(omxRoot(cwd), "runtime", "bin", omxRuntimeCommandShimFileName(platform));
 }
 function ensureRuntimeShimDirectory(path) {
     if (existsSync(path)) {
@@ -1008,15 +1210,22 @@ function ensureRuntimeShimDirectory(path) {
     }
     mkdirSync(path, { mode: 0o700 });
 }
-function buildOmxRuntimeCommandShim(nodePath, omxBin) {
+function buildOmxRuntimeCommandShim(nodePath, omxBin, platform = process.platform) {
+    if (platform === "win32") {
+        return [
+            "@echo off",
+            `"${nodePath}" "${omxBin}" %*`,
+            "",
+        ].join("\r\n");
+    }
     return [
         "#!/bin/sh",
         `exec ${quoteShellArg(nodePath)} ${quoteShellArg(omxBin)} "$@"`,
         "",
     ].join("\n");
 }
-export function ensureOmxRuntimeCommandShim(cwd, omxBin, nodePath = process.execPath) {
-    const shimPath = omxRuntimeCommandShimPath(cwd);
+export function ensureOmxRuntimeCommandShim(cwd, omxBin, nodePath = process.execPath, platform = process.platform) {
+    const shimPath = omxRuntimeCommandShimPath(cwd, platform);
     const shimDir = dirname(shimPath);
     const rootDir = omxRoot(cwd);
     const runtimeDir = dirname(shimDir);
@@ -1032,24 +1241,53 @@ export function ensureOmxRuntimeCommandShim(cwd, omxBin, nodePath = process.exec
             rmSync(shimPath, { force: true });
         }
     }
-    writeFileSync(shimPath, buildOmxRuntimeCommandShim(nodePath, omxBin), {
+    writeFileSync(shimPath, buildOmxRuntimeCommandShim(nodePath, omxBin, platform), {
         encoding: "utf-8",
         mode: 0o700,
     });
-    chmodSync(shimPath, 0o700);
+    if (platform !== "win32") {
+        chmodSync(shimPath, 0o700);
+    }
     return shimDir;
 }
-export function prependOmxRuntimeCommandShimToEnv(cwd, env, omxBin, nodePath = process.execPath) {
-    const shimDir = ensureOmxRuntimeCommandShim(cwd, omxBin, nodePath);
-    const currentPath = typeof env.PATH === "string" ? env.PATH : "";
-    return {
-        ...env,
-        PATH: currentPath ? `${shimDir}${delimiter}${currentPath}` : shimDir,
-        OMX_ENTRY_PATH: omxBin,
-        OMX_STARTUP_CWD: typeof env.OMX_STARTUP_CWD === "string" && env.OMX_STARTUP_CWD.trim()
-            ? env.OMX_STARTUP_CWD
-            : cwd,
-    };
+export function prependOmxRuntimeCommandShimToEnv(cwd, env, omxBin, nodePath = process.execPath, platform = process.platform) {
+    const shimDir = ensureOmxRuntimeCommandShim(cwd, omxBin, nodePath, platform);
+    const pathDelimiter = platform === "win32" ? win32.delimiter : posix.delimiter;
+    const result = { ...env };
+    if (platform === "win32") {
+        // Windows env var names are case-insensitive; the inherited key is usually
+        // `Path`, not `PATH`. Find every case variant, preserve the existing value,
+        // prepend the shim directory, and collapse to a single key so the child does
+        // not see an empty `PATH` shadowing the real `Path` (which drops System32,
+        // WindowsPowerShell, etc.).
+        const pathVariants = Object.keys(result).filter((key) => key.toLowerCase() === "path");
+        let pathKey = "Path";
+        let currentPath = "";
+        for (const variant of pathVariants) {
+            const value = result[variant];
+            if (typeof value === "string" && value.length > 0) {
+                pathKey = variant;
+                currentPath = value;
+                break;
+            }
+        }
+        for (const variant of pathVariants) {
+            delete result[variant];
+        }
+        result[pathKey] = currentPath
+            ? `${shimDir}${pathDelimiter}${currentPath}`
+            : shimDir;
+    }
+    else {
+        const currentPath = typeof result.PATH === "string" ? result.PATH : "";
+        result.PATH = currentPath ? `${shimDir}${pathDelimiter}${currentPath}` : shimDir;
+    }
+    result.OMX_ENTRY_PATH = omxBin;
+    result.OMX_STARTUP_CWD =
+        typeof result.OMX_STARTUP_CWD === "string" && result.OMX_STARTUP_CWD.trim()
+            ? result.OMX_STARTUP_CWD
+            : cwd;
+    return result;
 }
 export function buildHudPaneCleanupTargets(existingPaneIds, createdPaneId, leaderPaneId) {
     const targets = new Set(existingPaneIds.filter((id) => id.startsWith("%")));
@@ -1656,7 +1894,31 @@ async function showStatus() {
     const { readFile } = await import("fs/promises");
     const cwd = process.cwd();
     try {
-        const refs = await listModeStateFilesWithScopePreference(cwd);
+        let refs = await listModeStateFilesWithScopePreference(cwd);
+        // Reconcile with hook-visible run-dir state when the worktree-scoped state
+        // list reports no active workflow mode (parity with `omx cancel`). This
+        // surfaces detached/madmax sessions whose state lives under the run dir.
+        const hasActiveWorkflowMode = async (candidate) => {
+            for (const ref of candidate) {
+                const mode = basename(ref.path).replace("-state.json", "");
+                if (mode === SKILL_ACTIVE_STATE_MODE)
+                    continue;
+                try {
+                    const parsed = JSON.parse(await readFile(ref.path, "utf-8"));
+                    if (parsed.active === true)
+                        return true;
+                }
+                catch {
+                    continue;
+                }
+            }
+            return false;
+        };
+        if (!(await hasActiveWorkflowMode(refs))) {
+            const runDirRefs = await listHookVisibleRunDirStateRefs(cwd);
+            if (await hasActiveWorkflowMode(runDirRefs))
+                refs = runDirRefs;
+        }
         const states = refs.map((ref) => ref.path);
         const ultragoalState = await readUltragoalState(cwd).catch(() => null);
         if (states.length === 0) {
@@ -1825,7 +2087,7 @@ export async function launchWithHud(args) {
     const { launchPolicy, effectiveExplicitLaunchPolicy } = resolveTmuxAwareLaunchPolicy(explicitLaunchPolicy, isNativeWindows());
     const enableNotifyFallbackAuthority = launchPolicy === "direct";
     const workerSparkModel = resolveWorkerSparkModel(notifyTempResult.passthroughArgs, persistentCodexHomeForLaunch);
-    const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
+    let normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
     let cwd = launchCwd;
     let worktreeDirty = false;
     let ensuredLaunchWorktree;
@@ -1883,7 +2145,13 @@ export async function launchWithHud(args) {
     catch {
         // Non-fatal: repair failure must not block launch
     }
-    const preparedCodexHome = await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env, {
+    const resumePrepared = normalizedArgs[0] === "resume"
+        ? await prepareResumeCodexHomeForLaunch(launchCwd, sessionId, normalizedArgs, process.env)
+        : null;
+    if (resumePrepared) {
+        normalizedArgs = resumePrepared.args;
+    }
+    const preparedCodexHome = resumePrepared?.prepared ?? await prepareCodexHomeForLaunch(launchCwd, sessionId, process.env, {
         includeHistoryArtifacts: normalizedArgs[0] === "resume",
     });
     const codexHomeOverride = preparedCodexHome.codexHomeOverride;
@@ -4321,28 +4589,144 @@ async function flushHookDerivedWatcherOnce(cwd) {
         },
     });
 }
+// Canonicalize a path for comparing a registry `source_cwd` against the current
+// working directory. `process.cwd()` resolves symlinks (e.g. macOS `/var` ->
+// `/private/var`), so registry values must be canonicalized the same way or the
+// run-dir fallback never matches. Falls back to `resolve` when the path is
+// missing (realpathSync requires an existing target).
+function canonicalizePathForRunDirMatch(p) {
+    try {
+        return realpathSync(resolve(p));
+    }
+    catch {
+        return resolve(p);
+    }
+}
+async function listHookVisibleRunDirStateRefs(cwd) {
+    const runsRoot = resolveMadmaxRunsRoot(process.env);
+    const registryPath = join(runsRoot, "registry.jsonl");
+    const runDirs = new Set();
+    const canonicalCwd = canonicalizePathForRunDirMatch(cwd);
+    const canonicalRunsRoot = resolve(runsRoot);
+    const addRecord = (raw) => {
+        if (!raw || typeof raw !== "object")
+            return;
+        const record = raw;
+        const sourceCwd = typeof record.source_cwd === "string" ? record.source_cwd.trim() : "";
+        const runDir = typeof record.run_dir === "string"
+            ? record.run_dir.trim()
+            : typeof record.cwd === "string"
+                ? record.cwd.trim()
+                : "";
+        if (!sourceCwd || !runDir)
+            return;
+        try {
+            if (canonicalizePathForRunDirMatch(sourceCwd) !== canonicalCwd)
+                return;
+            const resolvedRunDir = resolve(runDir);
+            if (resolvedRunDir !== canonicalRunsRoot
+                && !resolvedRunDir.startsWith(`${canonicalRunsRoot}/`)) {
+                return;
+            }
+            runDirs.add(resolvedRunDir);
+        }
+        catch {
+            return;
+        }
+    };
+    try {
+        const rawRegistry = await readFile(registryPath, "utf-8");
+        for (const line of rawRegistry.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                addRecord(JSON.parse(trimmed));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { }
+    try {
+        const activeDir = join(runsRoot, MADMAX_DETACHED_ACTIVE_DIR);
+        const files = await readdir(activeDir).catch(() => []);
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            try {
+                addRecord(JSON.parse(await readFile(join(activeDir, file), "utf-8")));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { }
+    const refs = [];
+    const seenPaths = new Set();
+    for (const runDir of runDirs) {
+        const stateDir = join(runDir, ".omx", "state");
+        let sessionId;
+        try {
+            const session = JSON.parse(await readFile(join(stateDir, "session.json"), "utf-8"));
+            if (typeof session.session_id === "string" && session.session_id.trim()) {
+                sessionId = session.session_id.trim();
+            }
+        }
+        catch { }
+        const candidateDirs = sessionId ? [join(stateDir, "sessions", sessionId), stateDir] : [stateDir];
+        for (const dir of candidateDirs) {
+            const files = await readdir(dir).catch(() => []);
+            for (const file of files) {
+                if (!file.endsWith("-state.json") || file === "session.json")
+                    continue;
+                const path = join(dir, file);
+                if (seenPaths.has(path))
+                    continue;
+                seenPaths.add(path);
+                refs.push({
+                    mode: file.slice(0, -"-state.json".length),
+                    path,
+                    scope: dir === stateDir ? "root" : "session",
+                });
+            }
+        }
+    }
+    return refs.sort((a, b) => a.mode.localeCompare(b.mode));
+}
 async function cancelModes() {
     const { writeFile, readFile } = await import("fs/promises");
     const cwd = process.cwd();
     const nowIso = new Date().toISOString();
     try {
-        const refs = await listModeStateFilesWithScopePreference(cwd);
-        const states = new Map();
-        for (const ref of refs) {
-            const content = await readFile(ref.path, "utf-8");
-            let parsedState;
-            try {
-                parsedState = JSON.parse(content);
-            }
-            catch (err) {
-                logCliOperationFailure(err);
-                continue;
+        const loadStates = async (refs) => {
+            const loaded = new Map();
+            for (const ref of refs) {
+                const content = await readFile(ref.path, "utf-8");
+                let parsedState;
+                try {
+                    parsedState = JSON.parse(content);
+                }
+                catch (err) {
+                    logCliOperationFailure(err);
+                    continue;
+                }
+                loaded.set(ref.mode, {
+                    path: ref.path,
+                    scope: ref.scope,
+                    state: parsedState,
+                });
             }
-            states.set(ref.mode, {
-                path: ref.path,
-                scope: ref.scope,
-                state: parsedState,
-            });
+            return loaded;
+        };
+        let states = await loadStates(await listModeStateFilesWithScopePreference(cwd));
+        const hasActiveWorkflowMode = (entries) => [...entries.entries()].some(([mode, entry]) => mode !== SKILL_ACTIVE_STATE_MODE && entry.state.active === true);
+        if (!hasActiveWorkflowMode(states)) {
+            const runDirStates = await loadStates(await listHookVisibleRunDirStateRefs(cwd));
+            if (hasActiveWorkflowMode(runDirStates))
+                states = runDirStates;
         }
         const changed = new Set();
         const reported = new Set();
@@ -4361,8 +4745,17 @@ async function cancelModes() {
             entry.state.current_phase = phase;
             entry.state.completed_at = nowIso;
             entry.state.last_turn_at = nowIso;
+            if (mode === SKILL_ACTIVE_STATE_MODE) {
+                entry.state.phase = phase;
+                const activeSkills = Array.isArray(entry.state.active_skills)
+                    ? entry.state.active_skills
+                    : [];
+                entry.state.active_skills = activeSkills.map((skill) => (skill && typeof skill === "object"
+                    ? { ...skill, active: false, phase }
+                    : skill));
+            }
             changed.add(mode);
-            if (reportIfWasActive && wasActive)
+            if (reportIfWasActive && wasActive && mode !== SKILL_ACTIVE_STATE_MODE)
                 reported.add(mode);
         };
         const ralphLinksUltrawork = (state) => state.linked_ultrawork === true || state.linked_mode === "ultrawork";