Sanitize Save Workspace Layout agent commands through the shared sanitizer; fail loudly on un-replayable commands; fix save dialog layout

Packages/macOS/CMUXAgentLaunch/Sources/CMUXAgentLaunch/AgentForkArgv.swift

@@ -78,10 +78,18 @@ public struct AgentForkArgv: Sendable, Equatable {
             return ["claude", "--resume", sessionId, "--fork-session"] + preserved
         case "codex":
             let parts = commandParts(executablePath: executablePath, arguments: arguments, fallbackExecutable: "codex")
-            guard let preserved = AgentLaunchSanitizer.preservedArguments(kind: "codex-fork-replay", args: parts.tail) else {
+            guard let preserved = preservedCodexForkArguments(
+                args: parts.tail,
+                preservePromptTags: true,
+                stripCmuxHooks: parts.executable == "codex"
+            ) else {
                 return nil
             }
-            return [parts.executable, "fork", sessionId] + preserved
+            let replayExecutable = codexReplayExecutable(
+                capturedExecutable: parts.executable,
+                launchTail: parts.tail
+            )
+            return [replayExecutable, "fork", sessionId] + preserved
         case "opencode":
             let parts = commandParts(executablePath: executablePath, arguments: arguments, fallbackExecutable: "opencode")
             guard let preserved = AgentLaunchSanitizer.preservedArguments(kind: "opencode", args: parts.tail) else {

Packages/macOS/CMUXAgentLaunch/Sources/CMUXAgentLaunch/AgentLaunchSanitizer.swift

@@ -32,10 +32,21 @@ public enum AgentLaunchSanitizer {
         var scansOptionsPastPositionals: Bool = false
         var skipClaudeHookSettings: Bool = false
     }
+    /// Returns launch arguments with non-restorable agent resume/session artifacts removed.
+    ///
+    /// - Parameters:
+    ///   - arguments: Captured argv, including the executable as element zero.
+    ///   - launcher: The cmux launcher token associated with the argv, if any.
+    ///   - fallbackKind: Agent kind to use when `launcher` does not select a wrapper.
+    ///   - stripCmuxHookArguments: Remove cmux-owned hook injection even when the captured
+    ///     executable is an absolute path. This keeps save-layout replay commands below
+    ///     pty canonical-line limits without treating hook argv as executable identity proof.
+    /// - Returns: Sanitized argv, or nil when the launch form is not restorable.
     public static func sanitizedLaunchArguments(
         _ arguments: [String],
         launcher: String,
-        fallbackKind: String
+        fallbackKind: String,
+        stripCmuxHookArguments: Bool = false
     ) -> [String]? {
         guard let executable = arguments.first, !executable.isEmpty else { return nil }
         var tail = Array(arguments.dropFirst())
@@ -66,9 +77,19 @@ public enum AgentLaunchSanitizer {
         }
 
         switch fallbackKind {
-        case "codex":
-            guard let preserved = preservedCodexLaunchArguments(args: tail) else { return nil }
+        case "claude":
+            guard let preserved = ClaudeLaunchArgumentsPreserver().preservedArguments(
+                args: tail,
+                stripCmuxHookSettings: stripCmuxHookArguments || executable == "claude"
+            ) else { return nil }
             return [executable] + preserved
+        case "codex":
+            guard let preserved = preservedCodexLaunchArguments(
+                args: tail,
+                stripCmuxHooks: stripCmuxHookArguments || executable == "codex"
+            ) else { return nil }
+            let replayExecutable = codexReplayExecutable(capturedExecutable: executable, launchTail: tail)
+            return [replayExecutable] + preserved
         case "rovodev":
             guard let preserved = preservedArguments(kind: fallbackKind, args: tail) else { return nil }
             return [executable, "rovodev", "run"] + preserved
@@ -79,67 +100,13 @@ public enum AgentLaunchSanitizer {
     }
 
     public static func preservedArguments(kind: String, args: [String]) -> [String]? {
-        func preserveCodexFork(_ preservePromptTags: Bool) -> [String]? {
-            func dropForkPositionals(_ args: [String], forkCommand: CodexForkCommand) -> [String] {
-                var result: [String] = []
-                var index = 0
-                var skippedSession = false
-
-                while index < args.count {
-                    let arg = args[index]
-                    if arg == "--" { break }
-                    if index == forkCommand.forkIndex { index += 1; continue }
-                    if index == forkCommand.sessionIndex { skippedSession = true; index += 1; continue }
-                    if !arg.hasPrefix("-") || arg == "-" {
-                        if skippedSession && preservePromptTags { result.append(arg) }
-                        index += 1
-                        continue
-                    }
-
-                    let width = optionWidth(args, index: index, policy: codexPolicy)
-                    let end = min(args.count, index + width)
-                    if codexPolicy.variadicOptions.contains(arg),
-                       forkCommand.forkIndex > index,
-                       forkCommand.forkIndex < end {
-                        if forkCommand.forkIndex > index + 1 {
-                            result.append(contentsOf: args[index..<forkCommand.forkIndex])
-                        }
-                        index = forkCommand.forkIndex
-                        continue
-                    }
-                    if codexPolicy.variadicOptions.contains(arg),
-                       forkCommand.sessionIndex > index,
-                       forkCommand.sessionIndex < end {
-                        if forkCommand.sessionIndex > index + 1 {
-                            result.append(contentsOf: args[index..<forkCommand.sessionIndex])
-                        }
-                        index = forkCommand.sessionIndex
-                        continue
-                    }
-                    result.append(contentsOf: args[index..<end])
-                    index += width
-                }
-
-                return result
-            }
-
-            var tail = args; var preservePositionals = false
-            if let forkCommand = codexForkCommand(in: tail) {
-                tail = dropForkPositionals(tail, forkCommand: forkCommand); preservePositionals = preservePromptTags
-            }
-            var policy = codexPolicy; policy.preservePositionals = preservePositionals
-            if preservePositionals {
-                policy.nonRestorableCommands = []
-            }
-            return preserveOptions(tail, policy: policy)
-        }
         switch kind {
         case "claude":
-            return preserveOptions(args, policy: claudePolicy)
+            return ClaudeLaunchArgumentsPreserver().preservedArguments(args: args)
         case "codex":
-            return preserveOptions(args, policy: codexPolicy)
-        case "codex-fork-replay": return preserveCodexFork(true)
-        case "codex-fork-restore": return preserveCodexFork(false)
+            return preservedCodexLaunchArguments(args: args)
+        case "codex-fork-replay": return preservedCodexForkArguments(args: args, preservePromptTags: true)
+        case "codex-fork-restore": return preservedCodexForkArguments(args: args, preservePromptTags: false)
         case "grok":
             return preserveOptions(args, policy: grokPolicy)
         case "pi", "omp":
@@ -297,85 +264,6 @@ public enum AgentLaunchSanitizer {
         return result
     }
 
-    private static func preservedCodexLaunchArguments(args: [String]) -> [String]? {
-        if let forkCommand = codexForkCommand(in: args) {
-            return CodexForkLaunchCapture(args: args, forkIndex: forkCommand.forkIndex, sessionIndex: forkCommand.sessionIndex, preserveOptions: preserveOptions)
-                .arguments()
-        }
-        return preservedArguments(kind: "codex", args: args)
-    }
-
-    private struct CodexForkCommand {
-        let forkIndex: Int
-        let sessionIndex: Int
-    }
-
-    private static func codexForkCommand(in args: [String]) -> CodexForkCommand? {
-        var index = 0
-        while index < args.count {
-            let arg = args[index]
-            if arg == "--" {
-                return nil
-            }
-            if !isOptionToken(arg) || arg == "-" {
-                guard arg == "fork",
-                      let sessionIndex = codexForkCommandSessionIndex(args, forkIndex: index) else {
-                    return nil
-                }
-                return CodexForkCommand(forkIndex: index, sessionIndex: sessionIndex)
-            }
-            let width = optionWidth(args, index: index, policy: codexPolicy)
-            if codexPolicy.variadicOptions.contains(arg) {
-                let end = min(args.count, index + width)
-                if index + 2 < end {
-                    for candidateIndex in (index + 2)..<end where args[candidateIndex] == "fork" {
-                        if let sessionIndex = codexForkCommandSessionIndex(args, forkIndex: candidateIndex) {
-                            return CodexForkCommand(forkIndex: candidateIndex, sessionIndex: sessionIndex)
-                        }
-                    }
-                }
-            }
-            index += width
-        }
-        return nil
-    }
-
-    private static func codexForkCommandSessionIndex(_ args: [String], forkIndex: Int) -> Int? {
-        var index = forkIndex + 1
-        while index < args.count {
-            let argument = args[index]
-            if argument == "--" {
-                return nil
-            }
-            if !argument.hasPrefix("-") || argument == "-" {
-                return looksLikeCodexSessionIdentifier(argument) ? index : nil
-            }
-            let width = optionWidth(args, index: index, policy: codexPolicy)
-            if codexPolicy.variadicOptions.contains(argument) {
-                let end = min(args.count, index + width)
-                if index + 2 < end {
-                    for candidateIndex in (index + 2)..<end {
-                        if looksLikeCodexSessionIdentifier(args[candidateIndex]) {
-                            return candidateIndex
-                        }
-                    }
-                }
-            }
-            index += width
-        }
-        return nil
-    }
-
-    private static func looksLikeCodexSessionIdentifier(_ value: String) -> Bool {
-        let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard trimmed.count >= 20 else { return false }
-        if trimmed.hasPrefix("019") {
-            return true
-        }
-        let allowed = CharacterSet(charactersIn: "0123456789abcdefABCDEF-")
-        return trimmed.unicodeScalars.allSatisfy { allowed.contains($0) } && trimmed.contains("-")
-    }
-
     private static func normalizedWorkingDirectory(_ value: String?) -> String? {
         guard let trimmed = value?.trimmingCharacters(in: .whitespacesAndNewlines),
               !trimmed.isEmpty else {