oh-my-codex 0.7.6 → 0.8.1

package/dist/cli/index.js

@@ -15,6 +15,8 @@ import { hooksCommand } from './hooks.js';
 import { hudCommand } from '../hud/index.js';
 import { teamCommand } from './team.js';
 import { ralphCommand } from './ralph.js';
+import { askCommand } from './ask.js';
+import { MADMAX_FLAG, CODEX_BYPASS_FLAG, HIGH_REASONING_FLAG, XHIGH_REASONING_FLAG, SPARK_FLAG, MADMAX_SPARK_FLAG, CONFIG_FLAG, LONG_CONFIG_FLAG, } from './constants.js';
 import { getBaseStateDir, getStateDir, listModeStateFilesWithScopePreference, } from '../mcp/state-paths.js';
 import { maybeCheckAndPromptUpdate } from './update.js';
 import { maybePromptGithubStar } from './star-prompt.js';
@@ -28,6 +30,7 @@ import { buildHookEvent } from '../hooks/extensibility/events.js';
 import { dispatchHookEvent } from '../hooks/extensibility/dispatcher.js';
 import { collectInheritableTeamWorkerArgs as collectInheritableTeamWorkerArgsShared, resolveTeamWorkerLaunchArgs, resolveTeamLowComplexityDefaultModel, } from '../team/model-contract.js';
 import { parseWorktreeMode, planWorktreeTarget, ensureWorktree, } from '../team/worktree.js';
+import { OMX_NOTIFY_TEMP_CONTRACT_ENV, parseNotifyTempContractFromArgs, serializeNotifyTempContract, } from '../notifications/temp-contract.js';
 const HELP = `
 oh-my-codex (omx) - Multi-agent orchestration for Codex CLI
 
@@ -37,6 +40,7 @@ Usage:
   omx uninstall Remove OMX configuration and clean up installed artifacts
   omx doctor    Check installation health
   omx doctor --team  Check team/swarm runtime health diagnostics
+  omx ask       Ask local provider CLI (claude|gemini) and write artifact output
   omx team      Spawn parallel worker panes in tmux and bootstrap inbox/task state
   omx ralph     Launch Codex with ralph persistence mode active
   omx version   Show version information
@@ -60,6 +64,12 @@ Options:
                 Workers get the configured low-complexity team model; leader model unchanged
   --madmax-spark  spark model for workers + bypass approvals for leader and workers
                 (shorthand for: --spark --madmax)
+  --notify-temp  Enable temporary notification routing for this run/session only
+  --discord      Select Discord provider for temporary notification mode
+  --slack        Select Slack provider for temporary notification mode
+  --telegram     Select Telegram provider for temporary notification mode
+  --custom <name>
+                Select custom/OpenClaw gateway name for temporary notification mode
   -w, --worktree[=<name>]
                 Launch Codex in a git worktree (detached when no name is given)
   --force       Force reinstall (overwrite existing files)
@@ -70,14 +80,6 @@ Options:
   --scope       Setup scope for "omx setup" only:
                 user | project
 `;
-const MADMAX_FLAG = '--madmax';
-const CODEX_BYPASS_FLAG = '--dangerously-bypass-approvals-and-sandbox';
-const HIGH_REASONING_FLAG = '--high';
-const XHIGH_REASONING_FLAG = '--xhigh';
-const SPARK_FLAG = '--spark';
-const MADMAX_SPARK_FLAG = '--madmax-spark';
-const CONFIG_FLAG = '-c';
-const LONG_CONFIG_FLAG = '--config';
 const REASONING_KEY = 'model_reasoning_effort';
 const MODEL_INSTRUCTIONS_FILE_KEY = 'model_instructions_file';
 const TEAM_WORKER_LAUNCH_ARGS_ENV = 'OMX_TEAM_WORKER_LAUNCH_ARGS';
@@ -87,6 +89,11 @@ const OMX_MODEL_INSTRUCTIONS_FILE_ENV = 'OMX_MODEL_INSTRUCTIONS_FILE';
 const REASONING_MODES = ['low', 'medium', 'high', 'xhigh'];
 const REASONING_MODE_SET = new Set(REASONING_MODES);
 const REASONING_USAGE = 'Usage: omx reasoning <low|medium|high|xhigh>';
+const ALLOWED_SHELLS = new Set([
+    '/bin/sh', '/bin/bash', '/bin/zsh', '/bin/dash', '/bin/fish',
+    '/usr/bin/sh', '/usr/bin/bash', '/usr/bin/zsh', '/usr/bin/dash', '/usr/bin/fish',
+    '/usr/local/bin/bash', '/usr/local/bin/zsh', '/usr/local/bin/fish',
+]);
 /**
  * Legacy scope values that may appear in persisted setup-scope.json files.
  * Both 'project-local' (renamed) and old 'project' (minimal, removed) are
@@ -110,7 +117,8 @@ export function readPersistedSetupScope(cwd) {
                 return migrated;
         }
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Ignore malformed persisted scope and use defaults.
     }
     return undefined;
@@ -153,6 +161,9 @@ export function resolveCliInvocation(args) {
     if (firstArg === '--help' || firstArg === '-h') {
         return { command: 'help', launchArgs: [] };
     }
+    if (firstArg === '--version' || firstArg === '-v') {
+        return { command: 'version', launchArgs: [] };
+    }
     if (!firstArg || firstArg.startsWith('--')) {
         return { command: 'launch', launchArgs: firstArg ? args : [] };
     }
@@ -161,6 +172,9 @@ export function resolveCliInvocation(args) {
     }
     return { command: firstArg, launchArgs: [] };
 }
+export function resolveNotifyTempContract(args, env = process.env) {
+    return parseNotifyTempContractFromArgs(args, env);
+}
 export function resolveCodexLaunchPolicy(env = process.env) {
     return env.TMUX ? 'inside-tmux' : 'direct';
 }
@@ -264,18 +278,19 @@ export function buildHudPaneCleanupTargets(existingPaneIds, createdPaneId, leade
 }
 export async function main(args) {
     const knownCommands = new Set([
-        'launch', 'setup', 'uninstall', 'doctor', 'team', 'ralph', 'version', 'tmux-hook', 'hooks', 'hud', 'status', 'cancel', 'help', '--help', '-h',
+        'launch', 'setup', 'uninstall', 'doctor', 'ask', 'team', 'ralph', 'version', 'tmux-hook', 'hooks', 'hud', 'status', 'cancel', 'help', '--help', '-h',
     ]);
     const firstArg = args[0];
     const { command, launchArgs } = resolveCliInvocation(args);
     const flags = new Set(args.filter(a => a.startsWith('--')));
+    const ralphHelpRequested = firstArg === 'ralph' && (args[1] === '--help' || args[1] === '-h');
     const options = {
         force: flags.has('--force'),
         dryRun: flags.has('--dry-run'),
         verbose: flags.has('--verbose'),
         team: flags.has('--team'),
     };
-    if (flags.has('--help') || flags.has('-h')) {
+    if (flags.has('--help') && !ralphHelpRequested && command !== 'team') {
         console.log(HELP);
         return;
     }
@@ -304,6 +319,9 @@ export async function main(args) {
             case 'doctor':
                 await doctor(options);
                 break;
+            case 'ask':
+                await askCommand(args.slice(1));
+                break;
             case 'team':
                 await teamCommand(args.slice(1), options);
                 break;
@@ -363,13 +381,21 @@ async function showStatus() {
         }
         for (const path of states) {
             const content = await readFile(path, 'utf-8');
-            const state = JSON.parse(content);
+            let state;
+            try {
+                state = JSON.parse(content);
+            }
+            catch (err) {
+                process.stderr.write(`[cli/index] operation failed: ${err}\n`);
+                continue;
+            }
             const file = basename(path);
             const mode = file.replace('-state.json', '');
-            console.log(`${mode}: ${state.active ? 'ACTIVE' : 'inactive'} (phase: ${state.current_phase || 'n/a'})`);
+            console.log(`${mode}: ${state.active === true ? 'ACTIVE' : 'inactive'} (phase: ${String(state.current_phase || 'n/a')})`);
         }
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         console.log('No active modes.');
     }
 }
@@ -417,9 +443,10 @@ export async function launchWithHud(args) {
     }
     const launchCwd = process.cwd();
     const parsedWorktree = parseWorktreeMode(args);
+    const notifyTempResult = resolveNotifyTempContract(parsedWorktree.remainingArgs, process.env);
     const codexHomeOverride = resolveCodexHomeForLaunch(launchCwd, process.env);
-    const workerSparkModel = resolveWorkerSparkModel(parsedWorktree.remainingArgs, codexHomeOverride);
-    const normalizedArgs = normalizeCodexLaunchArgs(parsedWorktree.remainingArgs);
+    const workerSparkModel = resolveWorkerSparkModel(notifyTempResult.passthroughArgs, codexHomeOverride);
+    const normalizedArgs = normalizeCodexLaunchArgs(notifyTempResult.passthroughArgs);
     let cwd = launchCwd;
     if (parsedWorktree.mode.enabled) {
         const planned = planWorktreeTarget({
@@ -436,18 +463,20 @@ export async function launchWithHud(args) {
     try {
         await maybeCheckAndPromptUpdate(cwd);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal: update checks must never block launch
     }
     try {
         await maybePromptGithubStar();
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal: star prompt must never block launch
     }
     // ── Phase 1: preLaunch ──────────────────────────────────────────────────
     try {
-        await preLaunch(cwd, sessionId);
+        await preLaunch(cwd, sessionId, notifyTempResult.contract);
     }
     catch (err) {
         // preLaunch errors must NOT prevent Codex from starting
@@ -455,7 +484,10 @@ export async function launchWithHud(args) {
     }
     // ── Phase 2: run ────────────────────────────────────────────────────────
     try {
-        runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride);
+        const notifyTempContractRaw = notifyTempResult.contract.active
+            ? serializeNotifyTempContract(notifyTempResult.contract)
+            : null;
+        runCodex(cwd, normalizedArgs, sessionId, workerSparkModel, codexHomeOverride, notifyTempContractRaw);
     }
     finally {
         // ── Phase 3: postLaunch ─────────────────────────────────────────────
@@ -664,7 +696,8 @@ export function buildTmuxSessionName(cwd, sessionId) {
         if (branch)
             branchToken = sanitizeTmuxToken(branch);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-git directory or git unavailable.
     }
     const sessionToken = sanitizeTmuxToken(sessionId.replace(/^omx-/, ''));
@@ -684,15 +717,17 @@ function detectDetachedSessionWindowIndex(sessionName) {
         const output = execFileSync('tmux', ['display-message', '-p', '-t', sessionName, '#{window_index}'], { encoding: 'utf-8' });
         return parseWindowIndexFromTmuxOutput(output);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         return null;
     }
 }
-export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride) {
+export function buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw) {
     const newSessionArgs = [
         'new-session', '-d', '-s', sessionName, '-c', cwd,
         ...(workerLaunchArgs ? ['-e', `${TEAM_WORKER_LAUNCH_ARGS_ENV}=${workerLaunchArgs}`] : []),
         ...(codexHomeOverride ? ['-e', `CODEX_HOME=${codexHomeOverride}`] : []),
+        ...(notifyTempContractRaw ? ['-e', `${OMX_NOTIFY_TEMP_CONTRACT_ENV}=${notifyTempContractRaw}`] : []),
         codexCmd,
     ];
     const splitCaptureArgs = [
@@ -753,25 +788,42 @@ export function buildDetachedSessionRollbackSteps(sessionName, hookTarget, hookN
     steps.push({ name: 'kill-session', args: ['kill-session', '-t', sessionName] });
     return steps;
 }
+export function buildNotifyTempStartupMessages(contract, hasValidProviders) {
+    const providers = contract.canonicalSelectors.length > 0
+        ? contract.canonicalSelectors.join(',')
+        : 'none';
+    const infoLines = [
+        `notify temp: active | providers=${providers} | persistent-routing=bypassed`,
+    ];
+    const warningLines = [...contract.warnings];
+    if (!hasValidProviders) {
+        warningLines.push('notify temp: no valid providers resolved; notifications skipped');
+    }
+    return { infoLines, warningLines };
+}
 /**
  * preLaunch: Prepare environment before Codex starts.
  * 1. Orphan cleanup (stale session from a crashed launch)
  * 2. Generate runtime overlay + write session-scoped model instructions file
  * 3. Write session.json
  */
-async function preLaunch(cwd, sessionId) {
+async function preLaunch(cwd, sessionId, notifyTempContract) {
     // 1. Orphan cleanup
     const existingSession = await readSessionState(cwd);
     if (existingSession && isSessionStale(existingSession)) {
         try {
             await removeSessionModelInstructionsFile(cwd, existingSession.session_id);
         }
-        catch { /* best effort */ }
+        catch (err) {
+            process.stderr.write(`[cli/index] operation failed: ${err}\n`);
+        }
         const { unlink } = await import('fs/promises');
         try {
             await unlink(join(cwd, '.omx', 'state', 'session.json'));
         }
-        catch { /* best effort */ }
+        catch (err) {
+            process.stderr.write(`[cli/index] operation failed: ${err}\n`);
+        }
     }
     // 2. Generate runtime overlay + write session-scoped model instructions file
     const overlay = await generateOverlay(cwd, sessionId);
@@ -783,18 +835,35 @@ async function preLaunch(cwd, sessionId) {
     try {
         await startNotifyFallbackWatcher(cwd);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
     // 5. Start derived watcher (best effort, opt-in)
     try {
         await startHookDerivedWatcher(cwd);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
-    // 6. Send session-start lifecycle notification (best effort)
+    // 6. Emit temp notification startup summary + warnings, then send session-start lifecycle notification (best effort)
     try {
+        if (notifyTempContract?.active) {
+            process.env[OMX_NOTIFY_TEMP_CONTRACT_ENV] = serializeNotifyTempContract(notifyTempContract);
+            const { getNotificationConfig } = await import('../notifications/config.js');
+            const resolved = getNotificationConfig();
+            const startup = buildNotifyTempStartupMessages(notifyTempContract, Boolean(resolved?.enabled));
+            for (const info of startup.infoLines) {
+                console.log(`[omx] ${info}`);
+            }
+            for (const warning of startup.warningLines) {
+                console.warn(`[omx] ${warning}`);
+            }
+        }
+        else {
+            delete process.env[OMX_NOTIFY_TEMP_CONTRACT_ENV];
+        }
         const { notifyLifecycle } = await import('../notifications/index.js');
         await notifyLifecycle('session-start', {
             sessionId,
@@ -802,7 +871,8 @@ async function preLaunch(cwd, sessionId) {
             projectName: basename(cwd),
         });
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal: notification failures must never block launch
     }
     // 7. Dispatch native hook event (best effort)
@@ -815,7 +885,8 @@ async function preLaunch(cwd, sessionId) {
             },
         });
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
 }
@@ -823,7 +894,7 @@ async function preLaunch(cwd, sessionId) {
  * runCodex: Launch Codex CLI (blocks until exit).
  * All 3 paths (new tmux, existing tmux, no tmux) block via execSync/execFileSync.
  */
-function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride) {
+function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride, notifyTempContractRaw) {
     const launchArgs = injectModelInstructionsBypassArgs(cwd, args, process.env, sessionModelInstructionsPath(cwd, sessionId));
     const omxBin = process.argv[1];
     const hudCmd = buildTmuxPaneCommand('node', [omxBin, 'hud', '--watch']);
@@ -835,6 +906,9 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride) {
     const codexEnv = workerLaunchArgs
         ? { ...codexBaseEnv, [TEAM_WORKER_LAUNCH_ARGS_ENV]: workerLaunchArgs }
         : codexBaseEnv;
+    const codexEnvWithNotify = notifyTempContractRaw
+        ? { ...codexEnv, [OMX_NOTIFY_TEMP_CONTRACT_ENV]: notifyTempContractRaw }
+        : codexEnv;
     if (resolveCodexLaunchPolicy(process.env) === 'inside-tmux') {
         // Already in tmux: launch codex in current pane, HUD in bottom split
         const currentPaneId = process.env.TMUX_PANE;
@@ -846,7 +920,8 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride) {
         try {
             hudPaneId = createHudWatchPane(cwd, hudCmd);
         }
-        catch {
+        catch (err) {
+            process.stderr.write(`[cli/index] operation failed: ${err}\n`);
             // HUD split failed, continue without it
         }
         // Enable mouse scrolling at session start so scroll works before team
@@ -862,12 +937,13 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride) {
                 if (tmuxSession)
                     enableMouseScrolling(tmuxSession);
             }
-            catch {
+            catch (err) {
+                process.stderr.write(`[cli/index] operation failed: ${err}\n`);
                 // Non-fatal: mouse scrolling is a convenience feature
             }
         }
         try {
-            runCodexBlocking(cwd, launchArgs, codexEnv);
+            runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
         }
         finally {
             const cleanupPaneIds = buildHudPaneCleanupTargets(listHudWatchPaneIdsInCurrentWindow(currentPaneId), hudPaneId, currentPaneId);
@@ -886,7 +962,7 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride) {
         let registeredHookName = null;
         let registeredClientAttachedHookName = null;
         try {
-            const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride);
+            const bootstrapSteps = buildDetachedSessionBootstrapSteps(sessionName, cwd, codexCmd, hudCmd, workerLaunchArgs, codexHomeOverride, notifyTempContractRaw);
             for (const step of bootstrapSteps) {
                 const output = execFileSync('tmux', step.args, { stdio: step.name === 'new-session' ? 'ignore' : 'pipe', encoding: 'utf-8' });
                 if (step.name === 'new-session') {
@@ -910,7 +986,8 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride) {
                         try {
                             execFileSync('tmux', finalizeStep.args, { stdio });
                         }
-                        catch {
+                        catch (err) {
+                            process.stderr.write(`[cli/index] operation failed: ${err}\n`);
                             if (finalizeStep.name === 'attach-session')
                                 throw new Error('failed to attach detached tmux session');
                             continue;
@@ -926,20 +1003,22 @@ function runCodex(cwd, args, sessionId, workerDefaultModel, codexHomeOverride) {
                 }
             }
         }
-        catch {
+        catch (err) {
+            process.stderr.write(`[cli/index] operation failed: ${err}\n`);
             if (createdDetachedSession) {
                 const rollbackSteps = buildDetachedSessionRollbackSteps(sessionName, registeredHookTarget, registeredHookName, registeredClientAttachedHookName);
                 for (const rollbackStep of rollbackSteps) {
                     try {
                         execFileSync('tmux', rollbackStep.args, { stdio: 'ignore' });
                     }
-                    catch {
+                    catch (err) {
+                        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
                         // best-effort rollback only
                     }
                 }
             }
             // tmux not available or failed, just run codex directly
-            runCodexBlocking(cwd, launchArgs, codexEnv);
+            runCodexBlocking(cwd, launchArgs, codexEnvWithNotify);
         }
     }
 }
@@ -948,7 +1027,8 @@ function listHudWatchPaneIdsInCurrentWindow(currentPaneId) {
         const output = execFileSync('tmux', ['list-panes', '-F', '#{pane_id}\t#{pane_current_command}\t#{pane_start_command}'], { encoding: 'utf-8' });
         return findHudWatchPaneIds(parseTmuxPaneSnapshot(output), currentPaneId);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         return [];
     }
 }
@@ -962,7 +1042,8 @@ function killTmuxPane(paneId) {
     try {
         execFileSync('tmux', ['kill-pane', '-t', paneId], { stdio: 'ignore' });
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Pane may already be gone; ignore.
     }
 }
@@ -983,7 +1064,8 @@ export function buildTmuxPaneCommand(command, args, shellPath = process.env.SHEL
     else if (shellPath && /\/bash$/i.test(shellPath)) {
         rcSource = 'if [ -f ~/.bashrc ]; then source ~/.bashrc; fi; ';
     }
-    const shellBin = shellPath && shellPath.trim() !== '' ? shellPath : '/bin/sh';
+    const rawShell = shellPath && shellPath.trim() !== '' ? shellPath.trim() : '/bin/sh';
+    const shellBin = ALLOWED_SHELLS.has(rawShell) ? rawShell : '/bin/sh';
     const inner = `${rcSource}exec ${bareCmd}`;
     return `${quoteShellArg(shellBin)} -lc ${quoteShellArg(inner)}`;
 }
@@ -1001,35 +1083,40 @@ async function postLaunch(cwd, sessionId) {
         const sessionState = await readSessionState(cwd);
         sessionStartedAt = sessionState?.started_at;
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
     // 0. Flush fallback watcher once to reduce race with fast codex exit.
     try {
         await flushNotifyFallbackOnce(cwd);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
     // 0. Stop notify fallback watcher first.
     try {
         await stopNotifyFallbackWatcher(cwd);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
     // 0. Flush derived watcher once on shutdown (opt-in, best effort).
     try {
         await flushHookDerivedWatcherOnce(cwd);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
     // 0.1 Stop derived watcher first (opt-in, best effort).
     try {
         await stopHookDerivedWatcher(cwd);
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
     // 1. Remove session-scoped model instructions file
@@ -1083,7 +1170,8 @@ async function postLaunch(cwd, sessionId) {
             reason: 'session_exit',
         });
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal: notification failures must never block session cleanup
     }
     // 5. Dispatch native hook event (best effort)
@@ -1101,7 +1189,8 @@ async function postLaunch(cwd, sessionId) {
             },
         });
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         // Non-fatal
     }
 }
@@ -1299,10 +1388,18 @@ async function cancelModes() {
         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) {
+                process.stderr.write(`[cli/index] operation failed: ${err}\n`);
+                continue;
+            }
             states.set(ref.mode, {
                 path: ref.path,
                 scope: ref.scope,
-                state: JSON.parse(content),
+                state: parsedState,
             });
         }
         const changed = new Set();
@@ -1364,7 +1461,8 @@ async function cancelModes() {
             console.log('No active modes to cancel.');
         }
     }
-    catch {
+    catch (err) {
+        process.stderr.write(`[cli/index] operation failed: ${err}\n`);
         console.log('No active modes to cancel.');
     }
 }