[pi] Name workspaces after the first prompt

CLI/CMUXCLI+AutoNaming.swift

@@ -355,7 +355,9 @@ struct AutoNamingEngine: Sendable {
         totalMessageCount: Int? = nil
     ) -> Int {
         let count = max(messages.count, totalMessageCount ?? 0)
-        return count * config.minLineGrowth
+        // Empty caches stay ineligible; one initial prompt reaches the naming floor.
+        guard count > 0 else { return 0 }
+        return max(config.minTranscriptLines, count * config.minLineGrowth)
     }
 
     // MARK: - Prompt and response

CLI/CMUXCLI+AutoNamingGenericHooks.swift

@@ -45,6 +45,30 @@ extension CMUXCLI {
         return engine.extractHookMessages(fromPayloadObjects: [object])
     }
 
+    /// Starts a detached naming pass; the worker checks live settings and title ownership.
+    func spawnDetachedAgentAutoNameIfSupported(
+        def: AgentHookDef,
+        sessionId: String,
+        workspaceId: String,
+        surfaceId: String,
+        transcriptPath: String?,
+        cwd: String?,
+        env: [String: String],
+        telemetry: CLISocketSentryTelemetry
+    ) {
+        guard autoNamingSource(for: def) != nil, !sessionId.isEmpty else { return }
+        spawnDetachedAgentAutoName(
+            def: def,
+            sessionId: sessionId,
+            workspaceId: workspaceId,
+            surfaceId: surfaceId,
+            transcriptPath: transcriptPath,
+            cwd: cwd,
+            env: env,
+            telemetry: telemetry
+        )
+    }
+
     /// Detached naming pass for non-Codex generic agents.
     func runGenericAgentAutoNameHook(
         def: AgentHookDef,

CLI/CMUXCLI+AutoNamingHooks.swift

@@ -1,4 +1,3 @@
-import Darwin
 import Foundation
 
 extension CMUXCLI {
@@ -119,51 +118,56 @@ extension CMUXCLI {
         telemetry: CLISocketSentryTelemetry
     ) {
         let selfPath: String = {
-            if let first = ProcessInfo.processInfo.arguments.first,
-               first.hasPrefix("/"),
-               FileManager.default.isExecutableFile(atPath: first) {
-                return first
+            if let first = ProcessInfo.processInfo.arguments.first {
+                let resolved = URL(
+                    fileURLWithPath: first,
+                    relativeTo: URL(fileURLWithPath: FileManager.default.currentDirectoryPath, isDirectory: true)
+                ).standardizedFileURL.path
+                if isExecutableRegularFile(atPath: resolved) {
+                    return resolved
+                }
             }
             if let bundled = normalizedHookValue(env["CMUX_BUNDLED_CLI_PATH"]),
-               FileManager.default.isExecutableFile(atPath: bundled) {
+               isExecutableRegularFile(atPath: bundled) {
                 return bundled
             }
             return "cmux"
         }()
-        let process = Process()
-        process.executableURL = URL(fileURLWithPath: "/bin/sh")
-        process.arguments = [
-            "-c",
-            "\"$0\" hooks \"$1\" auto-name --session \"$2\" --workspace \"$3\" --surface \"$4\" --transcript \"$5\" --cwd \"$6\" </dev/null >/dev/null 2>&1 &",
-            selfPath,
-            def.name,
-            sessionId,
-            workspaceId,
-            surfaceId,
-            transcriptPath ?? "",
-            cwd ?? ""
+        let hookArguments = [
+            "hooks", def.name, "auto-name",
+            "--session", sessionId,
+            "--workspace", workspaceId,
+            "--surface", surfaceId,
+            "--transcript", transcriptPath ?? "",
+            "--cwd", cwd ?? ""
         ]
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: selfPath.hasPrefix("/") ? selfPath : "/usr/bin/env")
+        process.arguments = selfPath.hasPrefix("/") ? hookArguments : [selfPath] + hookArguments
         var spawnEnv = env
         spawnEnv["CMUX_CLAUDE_HOOK_STATE_PATH"] = agentHookStatePath(sessionStoreSuffix: def.sessionStoreSuffix, env: env)
         process.environment = spawnEnv
         process.standardInput = FileHandle.nullDevice
         process.standardOutput = FileHandle.nullDevice
         process.standardError = FileHandle.nullDevice
         do {
+            // Launch the bounded worker directly; the short-lived hook process must not own its lifetime.
             try process.run()
         } catch {
             telemetry.breadcrumb("\(def.name)-hook.auto-name.spawn-failed")
-            return
-        }
-        if ((try? waitForProcessExit(process, timeout: 2)) ?? false) == false {
-            process.terminate()
-            if ((try? waitForProcessExit(process, timeout: 1)) ?? false) == false {
-                kill(process.processIdentifier, SIGKILL)
-                _ = try? waitForProcessExit(process, timeout: 1)
-            }
         }
     }
 
+    private func isExecutableRegularFile(atPath path: String) -> Bool {
+        // Resolve symlinks before rejecting non-regular filesystem entries.
+        let resolvedURL = URL(fileURLWithPath: path).resolvingSymlinksInPath()
+        guard let values = try? resolvedURL.resourceValues(forKeys: [.isRegularFileKey]),
+              values.isRegularFile == true else {
+            return false
+        }
+        return FileManager.default.isExecutableFile(atPath: path)
+    }
+
     /// Detached Codex naming pass.
     func runCodexAutoNameHook(
         commandArgs: [String],

CLI/cmux.swift

@@ -31872,6 +31872,20 @@ export default CMUXSessionRestore;
                 )
             }
 
+            // Message-backed agents can name the workspace from the first prompt while work continues.
+            if usesHookMessageCacheForAutoNaming(def), !suppressVisibleMutations {
+                spawnDetachedAgentAutoNameIfSupported(
+                    def: def,
+                    sessionId: sessionId,
+                    workspaceId: workspaceId,
+                    surfaceId: surfaceId,
+                    transcriptPath: normalizedHookValue(input.transcriptPath ?? mapped?.transcriptPath),
+                    cwd: hookCwd ?? mapped?.cwd,
+                    env: env,
+                    telemetry: telemetry
+                )
+            }
+
         case .stop:
             if def.name == "codex", !sessionId.isEmpty {
                 let stopTurnId = input.turnId?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
@@ -32208,19 +32222,9 @@ export default CMUXSessionRestore;
                 }
             }
 
-            // Opt-in auto-naming for generic-agent sessions: a detached pass so the
-            // summarization subprocess never blocks this short sync hook.
-            // Gate the fork on the live setting (one cheap socket probe) so a
-            // disabled feature spawns nothing extra on turn end; the detached
-            // process re-probes to honor a toggle that lands mid-pass.
-            if autoNamingSource(for: def) != nil, !suppressVisibleMutations, !sessionId.isEmpty,
-               let autoNameProbe = try? client.sendV2(
-                   method: "workspace.set_auto_title",
-                   params: ["probe": true, "workspace_id": workspaceId]
-               ),
-               autoNameProbe["enabled"] as? Bool == true,
-               autoNameProbe["workspace_user_owned"] as? Bool != true {
-                spawnDetachedAgentAutoName(
+            // Turn-end naming refreshes file-backed agents and incorporates the completed response.
+            if !suppressVisibleMutations {
+                spawnDetachedAgentAutoNameIfSupported(
                     def: def,
                     sessionId: sessionId,
                     workspaceId: workspaceId,

cmuxTests/AutoNamingHookPayloadAdapterTests.swift

@@ -41,14 +41,13 @@ import Testing
         ])
     }
 
-    @Test func hookMessageLineEquivalentsReachSharedThrottleFloor() {
-        let messages = [
-            AutoNamingTranscriptMessage(role: "user", text: "Name this workspace"),
-            AutoNamingTranscriptMessage(role: "assistant", text: "I can summarize it.")
-        ]
+    @Test func initialPromptReachesSharedThrottleFloor() {
+        // The first submitted prompt must be sufficient to start workspace naming.
+        let messages = [AutoNamingTranscriptMessage(role: "user", text: "Name this workspace")]
 
         let lineCount = engine.hookMessageLineEquivalentCount(messages)
         #expect(lineCount == engine.config.minTranscriptLines)
+        #expect(engine.hookMessageLineEquivalentCount([]) == 0)
 
         let decision = engine.throttleDecision(
             snapshot: AutoNamingSessionSnapshot(),

cmuxTests/CLINotifyProcessIntegrationRegressionTests.swift

@@ -81,6 +81,92 @@ final class CLINotifyProcessIntegrationRegressionTests: XCTestCase {
         )
     }
 
+    func testPiPromptSubmitStartsWorkspaceAutoNaming() throws {
+        let context = try makeClaudeHookContext(name: "pi-first-prompt-auto-name")
+        defer { context.cleanup() }
+
+        // Gate the Pi summarizer so the test controls when detached naming can finish.
+        let piURL = context.root.appendingPathComponent("pi", isDirectory: false)
+        let piStartedURL = context.root.appendingPathComponent("pi-started", isDirectory: false)
+        let piReleaseURL = context.root.appendingPathComponent("pi-release", isDirectory: false)
+        guard Darwin.mkfifo(piReleaseURL.path, 0o600) == 0 else {
+            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+        }
+        let piReleaseFD = Darwin.open(piReleaseURL.path, O_RDWR | O_CLOEXEC)
+        guard piReleaseFD >= 0 else {
+            throw POSIXError(POSIXErrorCode(rawValue: errno) ?? .EIO)
+        }
+        var piWasReleased = false
+        let releasePiSummarizer = {
+            guard !piWasReleased else { return }
+            piWasReleased = true
+            // A newline releases the mock's blocking read exactly once.
+            _ = "\n".withCString { Darwin.write(piReleaseFD, $0, 1) }
+        }
+        defer {
+            releasePiSummarizer()
+            Darwin.close(piReleaseFD)
+        }
+        // The isolated paths avoid relying on credentials-safe summarizer environment variables.
+        try """
+        #!/bin/sh
+        : > "\(piStartedURL.path)"
+        IFS= read -r _ < "\(piReleaseURL.path)"
+        printf 'Java Workspace\\n'
+        """.write(
+            to: piURL,
+            atomically: true,
+            encoding: .utf8
+        )
+        try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: piURL.path)
+        startAgentHookMockServerAccepting(
+            context: context,
+            workspaceAutoTitleResult: [
+                "enabled": true,
+                "workspace_user_owned": false,
+                "workspace_applied": true,
+            ]
+        )
+
+        let result = runAgentHook(
+            context: context,
+            agent: "pi",
+            subcommand: "prompt-submit",
+            standardInput: #"{"session_id":"pi-first-prompt","turn_id":"turn-1","cwd":"\#(context.root.path)","hook_event_name":"UserPromptSubmit","prompt":"Fix the Java build"}"#,
+            extraEnvironment: [
+                "PATH": "\(context.root.path):/usr/bin:/bin:/usr/sbin:/sbin",
+            ]
+        )
+
+        XCTAssertFalse(result.timedOut, "The prompt hook must return before Pi completes: \(result.stderr)")
+        XCTAssertEqual(result.status, 0, result.stderr)
+        XCTAssertTrue(
+            waitForConditionBlocking(timeout: 5) { FileManager.default.fileExists(atPath: piStartedURL.path) },
+            "The Pi summarizer must reach the controlled release point."
+        )
+        XCTAssertFalse(
+            context.state.snapshot().compactMap(self.jsonObject).contains { payload in
+                guard payload["method"] as? String == "workspace.set_auto_title",
+                      let params = payload["params"] as? [String: Any] else {
+                    return false
+                }
+                return params["title"] != nil
+            },
+            "Auto-naming must remain blocked until the test releases Pi."
+        )
+
+        releasePiSummarizer()
+        XCTAssertTrue(waitForConditionBlocking(timeout: 5) {
+            context.state.snapshot().compactMap(self.jsonObject).contains { payload in
+                guard payload["method"] as? String == "workspace.set_auto_title",
+                      let params = payload["params"] as? [String: Any] else {
+                    return false
+                }
+                return params["title"] as? String == "Java Workspace"
+            }
+        }, "The first submitted Pi prompt must start and apply workspace auto-naming.")
+    }
+
     func testClaudePreToolUseFeedContextReadsOnlyRecentTranscriptTail() throws {
         let context = try makeClaudeHookContext(name: "claude-pretool-tail")
         defer { context.cleanup() }
@@ -9158,10 +9244,17 @@ final class CLINotifyProcessIntegrationRegressionTests: XCTestCase {
     /// Serves this context's agent-hook mock socket for the rest of the test. One
     /// accept loop answers every connection, including the CLI's extra `system.top`
     /// lookup connection, and the registry reaps the loop at teardown.
-    private func startAgentHookMockServerAccepting(context: ClaudeHookContext) {
+    private func startAgentHookMockServerAccepting(
+        context: ClaudeHookContext,
+        workspaceAutoTitleResult: [String: Any]? = nil
+    ) {
         let state = context.state
         let mockResponse: @Sendable (String) -> String = { line in
-            self.agentHookMockResponse(line: line, context: context)
+            self.agentHookMockResponse(
+                line: line,
+                context: context,
+                workspaceAutoTitleResult: workspaceAutoTitleResult
+            )
         }
         CLIMockAcceptLoopRegistry.shared.start(listenerFD: context.listenerFD, onConnection: { clientFD in
             defer { Darwin.close(clientFD) }
@@ -9172,7 +9265,11 @@ final class CLINotifyProcessIntegrationRegressionTests: XCTestCase {
         }, onListenerClosed: {})
     }
 
-    private func agentHookMockResponse(line: String, context: ClaudeHookContext) -> String {
+    private func agentHookMockResponse(
+        line: String,
+        context: ClaudeHookContext,
+        workspaceAutoTitleResult: [String: Any]? = nil
+    ) -> String {
         guard let payload = jsonObject(line) else {
             return "OK"
         }
@@ -9188,6 +9285,15 @@ final class CLINotifyProcessIntegrationRegressionTests: XCTestCase {
             return v2Response(id: id, ok: true, result: ["resume_binding": [:]])
         case "surface.resume.clear":
             return v2Response(id: id, ok: true, result: ["cleared": true])
+        case "workspace.set_auto_title":
+            guard let workspaceAutoTitleResult else {
+                return v2Response(
+                    id: id,
+                    ok: false,
+                    error: ["code": "unrecognized_method", "message": "unexpected method: \(method)"]
+                )
+            }
+            return v2Response(id: id, ok: true, result: workspaceAutoTitleResult)
         default:
             return v2Response(id: id, ok: false, error: ["code": "unrecognized_method", "message": "unexpected method: \(method)"])
         }