aiwcli 0.15.7 → 0.17.0

package/bin/run.js

@@ -1,9 +1,5 @@
 #!/usr/bin/env node
 
-// Load environment variable compatibility layer first
-const {loadEnvWithCompatibility} = await import('../dist/lib/env-compat.js')  
-loadEnvWithCompatibility()
-
 import {execute} from '@oclif/core'
 
 // Handle default command: inject 'launch' when no command is specified

package/dist/capabilities/installation/control-plane/clear-command.d.ts

@@ -1,4 +1,5 @@
 import BaseCommand from '../../../cli/base-command.js';
+export declare const PROTECTED_OUTPUT_DIRS: Set<string>;
 /**
  * Clear method runtime folders, output folders, IDE method folders, and update configurations.
  */
@@ -139,6 +140,7 @@ export default class ClearCommand extends BaseCommand {
      * @param cleanup.removedAiwcliContainer - Whether .aiwcli dir was removed
      * @param cleanup.removedClaudeDir - Whether .claude dir was removed
      * @param cleanup.removedCodexDir - Whether .codex dir was removed
+     * @param cleanup.removedDevinDir - Whether .devin dir was removed
      * @param cleanup.removedWindsurfDir - Whether .windsurf dir was removed
      * @param cleanup.removedCoreIdeFiles - Number of core IDE files removed
      * @param cleanup.updatedClaudeSettings - Whether Claude settings were updated

package/dist/capabilities/installation/control-plane/clear-command.js

@@ -22,6 +22,7 @@ const OUTPUT_FOLDER_NAME = '_output';
 const CORE_TEMPLATE_NAME = 'core';
 const SETTINGS_FILES_TO_SKIP = new Set(['hooks.json', 'settings.json']);
 const CORE_RUNTIME_FOLDERS = ['_core'];
+export const PROTECTED_OUTPUT_DIRS = new Set(['contexts', 'cache', '_archive']);
 /**
  * IDE configuration folder names and settings file locations.
  * Method subfolders are discovered dynamically via disk scanning.
@@ -34,6 +35,9 @@ const IDE_FOLDERS = {
     codex: {
         root: '.codex',
     },
+    devin: {
+        root: '.devin',
+    },
     windsurf: {
         root: '.windsurf',
         settingsFile: 'hooks.json',
@@ -441,6 +445,22 @@ export default class ClearCommand extends BaseCommand {
             }
             // Execute deletion and cleanup
             const deleteCounts = await this.executeFolderDeletion(methodRuntimeFolders, outputMethodFolders, ideMethodFolders, coreRuntimeFolders);
+            // Audit log for aiw clear operations (only if _output/ will survive — don't create orphan files)
+            try {
+                const outputDir = join(targetDir, OUTPUT_FOLDER_NAME);
+                if (await pathExists(outputDir) && !await isDirectoryEmpty(outputDir)) {
+                    const hookLogPath = join(outputDir, 'hook-log.jsonl');
+                    const logEntry = JSON.stringify({
+                        ts: new Date().toISOString(),
+                        level: 'warn',
+                        hook: 'aiw_clear',
+                        msg: `aiw clear: deleted ${deleteCounts.deletedMethodRuntime + deleteCounts.deletedOutput + deleteCounts.deletedIde + deleteCounts.deletedCoreRuntime} folder(s)`,
+                        data: { methodRuntime: deleteCounts.deletedMethodRuntime, output: deleteCounts.deletedOutput, ide: deleteCounts.deletedIde, coreRuntime: deleteCounts.deletedCoreRuntime }
+                    });
+                    await fs.appendFile(hookLogPath, logEntry + '\n');
+                }
+            }
+            catch { /* non-critical */ }
             const cleanupResult = await this.performPostDeleteCleanup(targetDir, methodsToRemove, !isTemplateScoped);
             this.reportClearResults(deleteCounts, cleanupResult);
         }
@@ -753,9 +773,10 @@ export default class ClearCommand extends BaseCommand {
             this.log('');
         }
         // Check if IDE folders might be removed after clearing
-        const [willClaudeFolderBeEmpty, willCodexFolderBeEmpty, willWindsurfFolderBeEmpty] = await Promise.all([
+        const [willClaudeFolderBeEmpty, willCodexFolderBeEmpty, willDevinFolderBeEmpty, willWindsurfFolderBeEmpty] = await Promise.all([
             checkIdeRemovalEligibility(targetDir, IDE_FOLDERS.claude, ideMethodFolders),
             checkIdeRemovalEligibility(targetDir, IDE_FOLDERS.codex, ideMethodFolders),
+            checkIdeRemovalEligibility(targetDir, IDE_FOLDERS.devin, ideMethodFolders),
             checkIdeRemovalEligibility(targetDir, IDE_FOLDERS.windsurf, ideMethodFolders),
         ]);
         if (willClaudeFolderBeEmpty) {
@@ -766,6 +787,10 @@ export default class ClearCommand extends BaseCommand {
             this.logInfo(`${IDE_FOLDERS.codex.root}/ folder will be removed (will be empty)`);
             this.log('');
         }
+        if (willDevinFolderBeEmpty) {
+            this.logInfo(`${IDE_FOLDERS.devin.root}/ folder will be removed (will be empty)`);
+            this.log('');
+        }
         if (willWindsurfFolderBeEmpty) {
             this.logInfo(`${IDE_FOLDERS.windsurf.root}/ folder will be removed (will be empty)`);
             this.log('');
@@ -958,7 +983,7 @@ export default class ClearCommand extends BaseCommand {
         try {
             const entries = await fs.readdir(outputDir, { withFileTypes: true });
             for (const entry of entries) {
-                if (entry.isDirectory()) {
+                if (entry.isDirectory() && !PROTECTED_OUTPUT_DIRS.has(entry.name)) {
                     foundFolders.push(join(outputDir, entry.name));
                 }
             }
@@ -1024,6 +1049,7 @@ export default class ClearCommand extends BaseCommand {
         if (removedClaudeDir)
             updatedClaudeSettings = false;
         const removedCodexDir = await this.tryRemoveIdeFolder(targetDir, IDE_FOLDERS.codex);
+        const removedDevinDir = await this.tryRemoveIdeFolder(targetDir, IDE_FOLDERS.devin);
         const removedWindsurfDir = await this.tryRemoveIdeFolder(targetDir, IDE_FOLDERS.windsurf);
         if (removedWindsurfDir)
             updatedWindsurfSettings = false;
@@ -1031,7 +1057,7 @@ export default class ClearCommand extends BaseCommand {
         const gitExcludeUpdated = await this.cleanupGitExclude(targetDir, isFullClear);
         return {
             removedCoreIdeFiles,
-            removedOutputDir, removedAiwcliContainer, removedClaudeDir, removedCodexDir, removedWindsurfDir,
+            removedOutputDir, removedAiwcliContainer, removedClaudeDir, removedCodexDir, removedDevinDir, removedWindsurfDir,
             updatedClaudeSettings, updatedWindsurfSettings, gitExcludeUpdated,
         };
     }
@@ -1109,6 +1135,7 @@ export default class ClearCommand extends BaseCommand {
      * @param cleanup.removedAiwcliContainer - Whether .aiwcli dir was removed
      * @param cleanup.removedClaudeDir - Whether .claude dir was removed
      * @param cleanup.removedCodexDir - Whether .codex dir was removed
+     * @param cleanup.removedDevinDir - Whether .devin dir was removed
      * @param cleanup.removedWindsurfDir - Whether .windsurf dir was removed
      * @param cleanup.removedCoreIdeFiles - Number of core IDE files removed
      * @param cleanup.updatedClaudeSettings - Whether Claude settings were updated
@@ -1135,6 +1162,8 @@ export default class ClearCommand extends BaseCommand {
             parts.push(`${IDE_FOLDERS.claude.root}/ folder`);
         if (cleanup.removedCodexDir)
             parts.push(`${IDE_FOLDERS.codex.root}/ folder`);
+        if (cleanup.removedDevinDir)
+            parts.push(`${IDE_FOLDERS.devin.root}/ folder`);
         if (cleanup.removedWindsurfDir)
             parts.push(`${IDE_FOLDERS.windsurf.root}/ folder`);
         this.logSuccess(`Cleared: ${parts.join(', ')}.`);

package/dist/capabilities/installation/control-plane/init-command.js

@@ -21,7 +21,7 @@ import { EXIT_CODES } from '../../../types/exit-codes.js';
 const KNOWN_IDES = [
     { value: 'claude', name: 'Claude Code', description: 'Anthropic Claude Code CLI' },
     { value: 'codex', name: 'Codex CLI', description: 'OpenAI Codex CLI skills' },
-    { value: 'cognition', name: 'Cognition', description: 'Cognition (Devin) IDE' },
+    { value: 'devin', name: 'Devin', description: 'Devin CLI' },
     { value: 'windsurf', name: 'Windsurf', description: 'Codeium Windsurf IDE' },
 ];
 // detectGitRepository replaced by resolveGitDir from git-exclude-manager
@@ -237,7 +237,7 @@ export default class Init extends BaseCommand {
      */
     async installGlobalResolver() {
         try {
-            const resolverSrc = getCoreResolverSourcePath();
+            const resolverSrc = await getCoreResolverSourcePath();
             const globalBinDir = join(homedir(), '.aiwcli', 'bin');
             const resolverDest = join(globalBinDir, 'resolve-run.ts');
             await fs.mkdir(globalBinDir, { recursive: true });

package/dist/capabilities/launch/contracts.d.ts

@@ -1,4 +1,37 @@
-import type { SplitPaneResult } from '../../platform/launch.js';
+export type ToolMode = 'claude' | 'codex' | 'devin';
+export interface ToolConfig {
+    cliCommand: string;
+    cliArgs: string[];
+    launchFlag: string;
+    toolMode: ToolMode;
+    retryOnQuickExit: boolean;
+    needsLspPatch: boolean;
+    skipVersionCheck: boolean;
+}
+export interface InlineFallbackContext {
+    disableMux: boolean;
+    hasMux: boolean;
+    interactiveTty: boolean;
+    platform: NodeJS.Platform;
+    resolvedReason?: string;
+}
+export interface SplitRequestParams {
+    toolArgs: string[];
+    splitPromptPath: string | undefined;
+    env: Record<string, string>;
+    cwd: string;
+    mode: 'repl';
+    split: 'auto' | 'horizontal' | 'vertical';
+    sentinelPath: string;
+    holdPane: boolean;
+    retryOnQuickExit: boolean;
+}
+export interface SessionRequestParams {
+    sessionName: string;
+    reattach: boolean;
+    toolArgs: string[];
+    promptText: string | undefined;
+}
 export interface LaunchFlags {
     codex: boolean;
     devin: boolean;
@@ -10,7 +43,7 @@ export interface LaunchFlags {
     'prompt-file'?: string | undefined;
     'prompt-path'?: string | undefined;
     'spawned-window': boolean;
-    split?: 'auto' | 'h' | 'v' | undefined;
+    split?: 'auto' | 'horizontal' | 'vertical' | undefined;
     'tmux-session'?: string | undefined;
     wait: boolean;
 }
@@ -40,12 +73,14 @@ export interface LaunchDependencies {
     pid: number;
     tempDir: string;
     writePromptFile(filePath: string, content: string): void;
+    isCalledFromRepl?: () => boolean;
+    clearNestingVars?: () => void;
 }
 export interface JsonLaunchResult {
-    backend: SplitPaneResult['backend'];
+    backend: string;
     exitCode: null | number;
+    handle: null | string;
     launched: boolean;
-    paneId: null | string;
     reason: null | string;
     sentinelPath: null | string;
 }

package/dist/capabilities/launch/control-plane/execute-launch.js

@@ -1,40 +1,46 @@
 import path from 'node:path';
-import { checkVersionCompatibility, configureTmuxSession, detectMultiplexer, ensureLspPatch, findExecutable, findToolPath, getClaudeCodeVersion, launchTerminal, ProcessSpawnError, quoteForSh, readSentinelExitCode, spawnProcess, waitForSentinelFile, } from '../../../platform/launch.js';
+import { checkVersionCompatibility, detectMultiplexer, ensureLspPatch, findExecutable, findToolPath, getClaudeCodeVersion, launchTerminal, ProcessSpawnError, quoteForSh, spawnProcess, } from '../../../platform/launch.js';
 import { EXIT_CODES } from '../../../types/index.js';
-import { buildSpawnedWindowArgs, buildUniqueSessionName, parseExtraEnv, resolvePromptText, sanitizeSessionName, } from '../runtime-core/launch-options.js';
-function buildCodexArgs(platform) {
-    if (platform !== 'win32')
-        return ['--yolo'];
-    return ['-c', 'shell_type="bash"', '--yolo'];
-}
-function buildDevinArgs() {
-    return ['--permission-mode', 'dangerous'];
-}
-function toJsonLaunchResult(result, exitCode) {
-    return {
-        launched: result.launched,
-        backend: result.backend,
-        paneId: result.paneId ?? null,
-        sentinelPath: result.sentinelPath ?? null,
-        exitCode,
-        reason: result.reason ?? null,
-    };
+import { clearProcessNestingVars, isCalledFromRepl } from '../../../lib/env-sanitizer.js';
+import { PromptFileManager } from '../../../lib/prompt-file-manager.js';
+import { SentinelManager } from '../../../lib/sentinel-manager.js';
+import { formatPathWarning } from '../../../lib/spawn-errors.js';
+import { buildSpawnedWindowArgs, parseExtraEnv, resolvePromptText, } from '../runtime-core/launch-options.js';
+import { buildInlineArgs, buildSessionRequest, buildSplitRequest, formatSessionLaunchMessage, formatSplitSuccessMessage, formatVersionCheckMessages, QUICK_EXIT_THRESHOLD_MS, resolveInlineFallbackMessage, resolveSessionFallbackWarning, resolveToolConfig, resolveToolModeDebugMessage, shouldRetry, toJsonLaunchResult, } from '../runtime-core/launch-decisions.js';
+async function runPreflightWarmup(command, host) {
+    try {
+        const result = await spawnProcess(command, ['--version'], { stdio: 'pipe' });
+        host.debug(`${command} preflight: exit=${result}`);
+    }
+    catch {
+        host.debug(`${command} preflight failed (non-fatal)`);
+    }
 }
-async function resolveWaitExitCode(result, wait) {
-    if (!wait || !result.launched || !result.sentinelPath) {
-        return result.exitCode ?? null;
+async function spawnInlineWithRetry(command, args, retryOnQuickExit, host) {
+    if (retryOnQuickExit) {
+        await runPreflightWarmup(command, host);
     }
-    const finished = await waitForSentinelFile(result.sentinelPath, 14_400_000);
-    return finished ? readSentinelExitCode(result.sentinelPath, 1) : -1;
+    const start = Date.now();
+    let exitCode = await spawnProcess(command, args);
+    if (retryOnQuickExit && shouldRetry(Date.now() - start)) {
+        host.debug(`${command} exited in <${QUICK_EXIT_THRESHOLD_MS}ms — retrying (first-run init behavior)`);
+        exitCode = await spawnProcess(command, args);
+    }
+    return exitCode;
 }
 export async function executeLaunch(request, dependencies) {
     const { cwd, flags, interactiveTty, platform, readPromptFile } = request;
     const { host, now, pid, tempDir, writePromptFile } = dependencies;
-    delete process.env['CLAUDECODE'];
-    delete process.env['CLAUDE_CODE_ENTRYPOINT'];
-    const useCodex = flags.codex;
-    const useDevin = flags.devin;
-    if (platform === 'win32' && !useCodex && !useDevin) {
+    // 1. Capture REPL context BEFORE clearing env vars (injectable for testing)
+    const calledFromRepl = (dependencies.isCalledFromRepl ?? isCalledFromRepl)();
+    (dependencies.clearNestingVars ?? clearProcessNestingVars)();
+    // Pure decision: resolve tool config
+    const toolConfig = resolveToolConfig(flags, platform);
+    const { cliCommand, cliArgs, launchFlag, toolMode } = toolConfig;
+    const disableMux = flags['no-tmux'];
+    const wantJson = flags.json;
+    const wantWait = flags.wait;
+    if (toolConfig.needsLspPatch) {
         await ensureLspPatch({
             debugLog: (message) => host.debug(message),
             warn(message) {
@@ -42,12 +48,6 @@ export async function executeLaunch(request, dependencies) {
             },
         });
     }
-    const cliCommand = useDevin ? 'devin' : useCodex ? 'codex' : 'claude';
-    const cliArgs = useDevin ? buildDevinArgs() : useCodex ? buildCodexArgs(platform) : ['--dangerously-skip-permissions'];
-    const launchFlag = useDevin ? '--devin' : useCodex ? '--codex' : '';
-    const disableTmux = flags['no-tmux'];
-    const wantJson = flags.json;
-    const wantWait = flags.wait;
     let extraEnv = {};
     try {
         extraEnv = parseExtraEnv(flags.env);
@@ -59,6 +59,7 @@ export async function executeLaunch(request, dependencies) {
     }
     const promptPath = flags['prompt-path']?.trim() || undefined;
     const promptText = resolvePromptText(flags.prompt, flags['prompt-file'], readPromptFile);
+    // 2. Handle --new (terminal window)
     if (flags.new) {
         host.debug(`Launching new terminal in: ${cwd}`);
         let promptFilePath;
@@ -67,9 +68,9 @@ export async function executeLaunch(request, dependencies) {
             writePromptFile(promptFilePath, promptText);
         }
         const launchArgs = buildSpawnedWindowArgs({
-            useCodex,
-            useDevin,
-            disableTmux,
+            useCodex: flags.codex,
+            useDevin: flags.devin,
+            disableTmux: disableMux,
             ...(promptPath ? { promptPath } : {}),
             ...(promptFilePath ? { promptFilePath } : {}),
             ...(flags.env ? { rawEnvJson: flags.env } : {}),
@@ -88,127 +89,159 @@ export async function executeLaunch(request, dependencies) {
         host.log(`New terminal launched with aiw launch${launchFlag ? ` ${launchFlag}` : ''}`);
         return;
     }
-    if (useCodex) {
-        host.debug('Launching Codex with --yolo flag');
-    }
-    else if (useDevin) {
-        host.debug('Launching Devin with --permission-mode dangerous');
-    }
+    const toolDebugMsg = resolveToolModeDebugMessage(toolMode);
+    if (toolDebugMsg)
+        host.debug(toolDebugMsg);
+    // 3. Detect multiplexer + version check
     const [versionCheck, mux] = await Promise.all([
-        useCodex || useDevin
+        toolConfig.skipVersionCheck
             ? null
             : getClaudeCodeVersion().then((v) => checkVersionCompatibility(v)),
-        disableTmux ? null : detectMultiplexer(platform),
+        disableMux ? null : detectMultiplexer(platform),
     ]);
     if (versionCheck) {
-        host.debug(`Claude Code version: ${versionCheck.version ?? 'unknown'}`);
-        host.debug(`Compatibility status: ${versionCheck.compatible ? 'compatible' : 'incompatible'}`);
-        if (versionCheck.warning) {
-            host.warn(versionCheck.warning);
+        const msgs = formatVersionCheckMessages(versionCheck);
+        for (const line of msgs.debugLines)
+            host.debug(line);
+        if (msgs.warning)
+            host.warn(msgs.warning);
+    }
+    // 4. Resolve strategy — backend decides
+    const resolved = mux?.resolveStrategy({ calledFromRepl, platform, disableMux })
+        ?? { strategy: 'inline', reason: 'No multiplexer available' };
+    if (!mux || resolved.strategy === 'inline' || resolved.strategy === 'unavailable') {
+        // Pure decision: resolve fallback message
+        host.logInfo(resolveInlineFallbackMessage({
+            disableMux,
+            hasMux: Boolean(mux),
+            interactiveTty,
+            platform,
+            resolvedReason: resolved.reason,
+        }));
+        try {
+            // Pure decision: build inline args
+            const inlineArgs = buildInlineArgs(cliArgs, toolMode, promptText, promptPath);
+            const exitCode = await spawnInlineWithRetry(cliCommand, inlineArgs, toolConfig.retryOnQuickExit, host);
+            host.exit(exitCode);
+        }
+        catch (error) {
+            if (error instanceof ProcessSpawnError) {
+                host.error(error.message, { exit: EXIT_CODES.ENVIRONMENT_ERROR });
+            }
+            host.error('Unexpected launch failure.', { exit: EXIT_CODES.GENERAL_ERROR });
         }
+        return;
     }
+    // Lifecycle managers
+    const sentinelMgr = new SentinelManager();
+    const promptMgr = new PromptFileManager({ tempDir, now, pid });
+    // When --json is used without --wait, sentinel ownership transfers to the
+    // JSON caller (e.g. skill scripts).  The CLI must NOT clean up the sentinel
+    // directory because the caller polls for sentinel.txt to detect pane close.
+    let sentinelOwnershipTransferred = false;
     let exitCode = 0;
     try {
-        if (!mux) {
-            if (disableTmux) {
-                host.logInfo('Multiplexer disabled via --no-tmux — launching inline');
-            }
-            else if (!interactiveTty) {
-                host.logInfo('Non-interactive terminal — launching inline');
-            }
-            else if (platform === 'win32') {
-                host.logInfo('No multiplexer found — launching inline. Install psmux for session management: winget install psmux');
-            }
-            else {
-                host.logInfo('No multiplexer found — launching inline. Install tmux for session management.');
-            }
-            exitCode = await spawnProcess(cliCommand, promptText ? [...cliArgs, promptText] : cliArgs);
-        }
-        else if (mux.isInsideSession()) {
+        const strategy = resolved.strategy;
+        if (strategy === 'split') {
+            // 5a. Split pane
             host.logInfo(`Inside ${mux.backend} session — splitting new pane`);
-            if (mux.backend === 'tmux') {
-                configureTmuxSession();
-            }
+            const sentinelPath = sentinelMgr.create(cliCommand);
             let effectivePromptPath = promptPath;
             if (!effectivePromptPath && promptText) {
-                effectivePromptPath = path.join(tempDir, `aiwcli-prompt-${now()}-${pid}.txt`);
-                writePromptFile(effectivePromptPath, promptText);
+                effectivePromptPath = promptMgr.materialize(promptText);
             }
-            const splitResult = await mux.splitPane({
-                toolName: cliCommand,
-                args: cliArgs,
-                env: extraEnv,
+            // Pure decision: build split request (fixes cliArgs mutation bug)
+            const splitParams = buildSplitRequest({
+                cliArgs,
+                toolMode,
+                effectivePromptPath,
+                extraEnv,
                 cwd,
                 split: flags.split ?? 'auto',
-                promptPath: effectivePromptPath,
-                sentinel: wantWait || wantJson,
+                sentinelPath,
+                retryOnQuickExit: toolConfig.retryOnQuickExit,
+            });
+            const splitResult = await mux.split({
+                toolName: cliCommand,
+                args: splitParams.toolArgs,
+                env: splitParams.env,
+                cwd: splitParams.cwd,
+                mode: splitParams.mode,
+                split: splitParams.split,
+                promptPath: splitParams.splitPromptPath,
+                sentinelPath: splitParams.sentinelPath,
+                holdPane: splitParams.holdPane,
+                retryOnQuickExit: splitParams.retryOnQuickExit,
             });
             if (wantJson) {
-                const jsonExitCode = await resolveWaitExitCode(splitResult, wantWait);
+                const jsonExitCode = wantWait && splitResult.launched && splitResult.sentinelPath
+                    ? await sentinelMgr.waitForExit(splitResult.sentinelPath)
+                    : splitResult.exitCode ?? null;
+                // When returning sentinel path to caller without waiting, transfer
+                // ownership so the finally block does not delete the directory.
+                if (!wantWait && splitResult.launched && splitResult.sentinelPath) {
+                    sentinelOwnershipTransferred = true;
+                }
                 host.log(JSON.stringify(toJsonLaunchResult(splitResult, jsonExitCode)));
                 host.exit(jsonExitCode ?? 0);
             }
             if (splitResult.launched) {
-                if (splitResult.paneId) {
-                    host.logInfo(`Launched in ${mux.backend} pane: ${splitResult.paneId}`);
-                }
-                else {
-                    host.logInfo(`Launched in ${mux.backend}`);
-                }
+                host.logInfo(formatSplitSuccessMessage(mux.backend, splitResult.handle));
                 if (wantWait && splitResult.sentinelPath) {
-                    const waitedExitCode = await resolveWaitExitCode(splitResult, true);
+                    const waitedExitCode = await sentinelMgr.waitForExit(splitResult.sentinelPath);
                     host.exit(waitedExitCode ?? 1);
                 }
                 return;
             }
             host.logWarning(`Pane split failed (${splitResult.reason}), launching directly`);
-            exitCode = await spawnProcess(cliCommand, promptText ? [...cliArgs, promptText] : cliArgs);
+            // Pure decision: build inline args for fallback
+            const fallbackArgs = buildInlineArgs(cliArgs, toolMode, promptText, promptPath);
+            exitCode = await spawnInlineWithRetry(cliCommand, fallbackArgs, toolConfig.retryOnQuickExit, host);
         }
         else {
-            const resolvedPath = mux.backend === 'psmux' ? findExecutable(cliCommand) : findToolPath(cliCommand);
+            // 5b. Create session
+            const resolvedPath = findToolPath(cliCommand) ?? findExecutable(cliCommand);
             if (resolvedPath) {
-                const sessionFromFlag = flags['tmux-session']?.trim();
-                const reattach = Boolean(sessionFromFlag && sessionFromFlag.length > 0);
-                const sessionName = reattach
-                    ? sanitizeSessionName(sessionFromFlag)
-                    : buildUniqueSessionName(`aiw-${path.basename(cwd)}`, now(), pid);
-                if (reattach) {
-                    host.logInfo(`Launching in ${mux.backend} session: ${sessionName} (reuse/attach)`);
-                }
-                else {
-                    host.logInfo(`Launching in new ${mux.backend} session: ${sessionName}`);
-                }
+                // Pure decision: build session request
+                const sessionParams = buildSessionRequest({
+                    cliArgs,
+                    toolMode,
+                    promptPath,
+                    promptText,
+                    tmuxSessionFlag: flags['tmux-session'],
+                    cwd,
+                    now: now(),
+                    pid,
+                });
+                host.logInfo(formatSessionLaunchMessage(mux.backend, sessionParams.sessionName, sessionParams.reattach));
                 const result = await mux.createSession({
-                    sessionName,
-                    reattach,
+                    sessionName: sessionParams.sessionName,
+                    reattach: sessionParams.reattach,
                     toolPath: resolvedPath,
-                    toolArgs: cliArgs,
-                    promptText,
+                    toolArgs: sessionParams.toolArgs,
+                    cwd,
+                    promptText: sessionParams.promptText,
                 });
-                if (result.usedMux) {
-                    exitCode = result.exitCode;
+                if (result.launched) {
+                    exitCode = result.exitCode ?? 0;
+                    if (wantJson) {
+                        host.log(JSON.stringify(toJsonLaunchResult(result, exitCode)));
+                        host.exit(exitCode);
+                    }
                 }
                 else {
+                    // Pure decision: resolve fallback warning
                     if (result.reason) {
-                        if (result.reason.includes('not found') || result.reason.includes('unavailable')) {
-                            host.logWarning(`${mux.backend} unavailable — launching inline. ${mux.backend === 'psmux' ? 'Install with: winget install psmux' : ''}`);
-                        }
-                        else if (result.reason.includes('too old')) {
-                            host.logWarning(`${result.reason} — launching inline. ${mux.backend === 'psmux' ? 'Update with: winget upgrade psmux' : ''}`);
-                        }
-                        else if (mux.backend === 'psmux' && result.reason.includes('attach failed')) {
-                            host.logWarning(`${result.reason} — launching inline. Recovery: run "psmux kill-server" and relaunch if this persists.`);
-                        }
-                        else {
-                            host.logWarning(`${result.reason} — launching inline`);
-                        }
+                        host.logWarning(resolveSessionFallbackWarning(mux.backend, result.reason));
                     }
-                    exitCode = await spawnProcess(cliCommand, promptText ? [...cliArgs, promptText] : cliArgs);
+                    const fallbackArgs = buildInlineArgs(cliArgs, toolMode, promptText, promptPath);
+                    exitCode = await spawnInlineWithRetry(cliCommand, fallbackArgs, toolConfig.retryOnQuickExit, host);
                 }
             }
             else {
-                host.logWarning(`${cliCommand} not found on PATH (install from https://claude.ai/download)`);
-                exitCode = await spawnProcess(cliCommand, promptText ? [...cliArgs, promptText] : cliArgs);
+                host.logWarning(formatPathWarning(cliCommand));
+                const fallbackArgs = buildInlineArgs(cliArgs, toolMode, promptText, promptPath);
+                exitCode = await spawnInlineWithRetry(cliCommand, fallbackArgs, toolConfig.retryOnQuickExit, host);
             }
         }
     }
@@ -218,5 +251,11 @@ export async function executeLaunch(request, dependencies) {
         }
         host.error('Unexpected launch failure.', { exit: EXIT_CODES.GENERAL_ERROR });
     }
+    finally {
+        if (!sentinelOwnershipTransferred) {
+            sentinelMgr.cleanupAll();
+        }
+        promptMgr.cleanup();
+    }
     host.exit(exitCode);
 }