@yagni-app/code 0.2.1 → 0.3.1

package/dist/extension/cmux/dispatcher.js

@@ -0,0 +1,266 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+function resolveExecutable(name) {
+    const pathEnv = process.env.PATH || "";
+    for (const dir of pathEnv.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, name);
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            if (fs.statSync(candidate).isFile())
+                return candidate;
+        }
+        catch { }
+    }
+    return name;
+}
+function looksLikePiExecutable(value) {
+    const base = path.basename(value).toLowerCase();
+    return base === "pi" || base === "pi-coding-agent";
+}
+function looksLikePiScript(value) {
+    const normalized = value.replaceAll("\\", "/").toLowerCase();
+    const base = path.basename(normalized);
+    return (normalized.includes("/@earendil-works/pi-coding-agent/") ||
+        normalized.includes("/@mariozechner/pi-coding-agent/") ||
+        normalized.includes("/packages/coding-agent/") ||
+        ((base === "cli.js" || base === "cli.ts") &&
+            (normalized.includes("pi-coding-agent") || normalized.includes("coding-agent"))));
+}
+export function normalizedLaunchArgv() {
+    const raw = Array.isArray(process.argv) ? process.argv.map((value) => String(value)) : [];
+    if (raw.length === 0)
+        return [resolveExecutable("pi")];
+    if (looksLikePiExecutable(raw[0]))
+        return raw;
+    if (raw.length > 1 && looksLikePiScript(raw[1])) {
+        return [resolveExecutable("pi"), ...raw.slice(2)];
+    }
+    return [resolveExecutable("pi"), ...raw.slice(1)];
+}
+function base64NulSeparated(values) {
+    const bytes = [];
+    for (const value of values) {
+        bytes.push(Buffer.from(String(value), "utf8"));
+        bytes.push(Buffer.from([0]));
+    }
+    return Buffer.concat(bytes).toString("base64");
+}
+function secretLikeEnvKey(key) {
+    return /(TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY|CREDENTIAL|AUTHORIZATION|COOKIE)/i.test(key);
+}
+function safePiEnvKey(key) {
+    return (key === "PI_CODING_AGENT_DIR" ||
+        key === "PI_CONFIG_DIR" ||
+        key === "PI_CODING_AGENT_SESSION_DIR" ||
+        (key.startsWith("PI_CODING_AGENT_") && !secretLikeEnvKey(key)));
+}
+function safeNodeEnvKey(key) {
+    return (key === "NODE_ENV" ||
+        key === "NODE_OPTIONS" ||
+        key === "NODE_PATH" ||
+        key === "NODE_NO_WARNINGS" ||
+        key === "NODE_EXTRA_CA_CERTS");
+}
+function safeCmuxEnvKey(key) {
+    if (key.startsWith("CMUX_TEST_PI_"))
+        return !secretLikeEnvKey(key);
+    if (key.startsWith("CMUX_AGENT_LAUNCH_"))
+        return !secretLikeEnvKey(key);
+    if (key === "CMUX_AGENT_HOOK_STATE_DIR")
+        return true;
+    if (key === "CMUX_PI_CMUX_BIN" || key === "CMUX_PI_HOOKS_DISABLED")
+        return true;
+    if (key === "CMUX_SURFACE_ID" || key === "CMUX_WORKSPACE_ID" || key === "CMUX_WINDOW_ID")
+        return true;
+    if (key === "CMUX_PANE_ID" || key === "CMUX_TAB_ID" || key === "CMUX_PANEL_ID")
+        return true;
+    if (key === "CMUX_SOCKET" || key === "CMUX_SOCKET_PATH")
+        return true;
+    if (key === "CMUX_BUNDLE_ID" || key === "CMUX_BUNDLED_CLI_PATH")
+        return true;
+    if (key === "CMUX_CLI_SENTRY_DISABLED" || key === "CMUX_DEBUG_LOG")
+        return true;
+    return false;
+}
+export function shouldPreserveEnvKey(key) {
+    if (safeCmuxEnvKey(key))
+        return true;
+    if (safePiEnvKey(key))
+        return true;
+    if (safeNodeEnvKey(key))
+        return true;
+    if (key === "PATH" || key === "HOME" || key === "PWD" || key === "SHELL")
+        return true;
+    if (key === "USER" || key === "LOGNAME" || key === "TMPDIR" || key === "TZ")
+        return true;
+    if (key === "LANG" || key.startsWith("LC_"))
+        return true;
+    if (key === "TERM" || key === "TERM_PROGRAM" || key === "TERM_PROGRAM_VERSION" || key === "COLORTERM")
+        return true;
+    if (key === "SSH_AUTH_SOCK")
+        return true;
+    if (key.startsWith("PI_") || key.startsWith("NODE_"))
+        return !secretLikeEnvKey(key);
+    return false;
+}
+export function hookEnvironment(cwd, includeSocketPassword = false) {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (value === undefined)
+            continue;
+        if (shouldPreserveEnvKey(key))
+            env[key] = value;
+    }
+    if (includeSocketPassword) {
+        const socketPassword = process.env.CMUX_SOCKET_PASSWORD;
+        if (socketPassword)
+            env.CMUX_SOCKET_PASSWORD = socketPassword;
+    }
+    if (!env.CMUX_AGENT_LAUNCH_ARGV_B64) {
+        const argv = normalizedLaunchArgv();
+        env.CMUX_AGENT_LAUNCH_KIND = "pi";
+        env.CMUX_AGENT_LAUNCH_EXECUTABLE = argv[0] || resolveExecutable("pi");
+        env.CMUX_AGENT_LAUNCH_ARGV_B64 = base64NulSeparated(argv);
+        env.CMUX_AGENT_LAUNCH_CWD = cwd || process.cwd();
+    }
+    return env;
+}
+function cmuxExecutable() {
+    return process.env.CMUX_PI_CMUX_BIN || "cmux";
+}
+export class CmuxDispatcher {
+    static surfaceUnavailableExitCode = 69;
+    controlQueues = new Map();
+    unavailableSessions = new Set();
+    canDispatch(sessionId) {
+        return !sessionId || !this.unavailableSessions.has(sessionId);
+    }
+    releaseSession(sessionId) {
+        this.unavailableSessions.delete(sessionId);
+    }
+    run(args, cwd, input, context) {
+        const sessionId = context.sessionId;
+        const previous = this.controlQueues.get(sessionId) || Promise.resolve();
+        const scheduled = previous.then(() => this.execute(args, cwd, input, context));
+        let tail;
+        tail = scheduled
+            .then(() => undefined, () => undefined)
+            .finally(() => {
+            if (this.controlQueues.get(sessionId) === tail)
+                this.controlQueues.delete(sessionId);
+        });
+        this.controlQueues.set(sessionId, tail);
+        return scheduled;
+    }
+    async execute(args, cwd, input, context) {
+        const sessionId = context.sessionId;
+        if (!this.canDispatch(sessionId)) {
+            return this.surfaceUnavailableResult();
+        }
+        const result = await this.spawnCmux(args, cwd, input);
+        if (this.isSurfaceResolutionFailure(result)) {
+            if (sessionId)
+                this.unavailableSessions.add(sessionId);
+            return { ...result, surfaceUnavailable: true };
+        }
+        return result;
+    }
+    spawnCmux(args, cwd, input) {
+        return new Promise((resolve) => {
+            let settled = false;
+            let stdout = "";
+            let stderr = "";
+            let inputError;
+            let timeout = null;
+            let terminateGrace = null;
+            let forceSettleTimeout = null;
+            let terminationError;
+            const appendOutput = (current, chunk) => {
+                const limit = 1024 * 1024;
+                if (current.length >= limit)
+                    return current;
+                return current + String(chunk).slice(0, limit - current.length);
+            };
+            const settle = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                if (terminateGrace)
+                    clearTimeout(terminateGrace);
+                if (forceSettleTimeout)
+                    clearTimeout(forceSettleTimeout);
+                resolve(result);
+            };
+            const terminatedResult = () => ({
+                ok: false,
+                status: null,
+                stdout,
+                stderr,
+                error: terminationError,
+            });
+            try {
+                const child = spawn(cmuxExecutable(), args, {
+                    env: hookEnvironment(cwd, true),
+                    stdio: ["pipe", "pipe", "pipe"],
+                });
+                child.stdout.setEncoding("utf8");
+                child.stderr.setEncoding("utf8");
+                child.stdout.on("data", (chunk) => { stdout = appendOutput(stdout, chunk); });
+                child.stderr.on("data", (chunk) => { stderr = appendOutput(stderr, chunk); });
+                child.stdin.on("error", (error) => { inputError = error; });
+                const beginTermination = (error) => {
+                    if (terminationError)
+                        return;
+                    terminationError = error;
+                    child.stdin.destroy();
+                    try {
+                        child.kill("SIGTERM");
+                    }
+                    catch { }
+                    terminateGrace = setTimeout(() => {
+                        try {
+                            child.kill("SIGKILL");
+                        }
+                        catch { }
+                        forceSettleTimeout = setTimeout(() => {
+                            child.stdout.destroy();
+                            child.stderr.destroy();
+                            child.unref();
+                            settle(terminatedResult());
+                        }, 250);
+                    }, 250);
+                };
+                child.on("error", (error) => {
+                    settle(terminationError ? terminatedResult() : { ok: false, status: null, stdout, stderr, error });
+                });
+                child.on("close", (code) => {
+                    if (terminationError) {
+                        settle(terminatedResult());
+                        return;
+                    }
+                    const status = typeof code === "number" ? code : null;
+                    settle({ ok: status === 0 && inputError === undefined, status, stdout, stderr, error: inputError });
+                });
+                timeout = setTimeout(() => {
+                    beginTermination(new Error("cmux command timed out after 5000ms"));
+                }, 5000);
+                child.stdin.end(input);
+            }
+            catch (error) {
+                settle({ ok: false, status: null, stdout, stderr, error });
+            }
+        });
+    }
+    isSurfaceResolutionFailure(result) {
+        return !result.ok && result.status === CmuxDispatcher.surfaceUnavailableExitCode;
+    }
+    surfaceUnavailableResult() {
+        return { ok: false, status: null, stdout: "", stderr: "", surfaceUnavailable: true };
+    }
+}
+//# sourceMappingURL=dispatcher.js.map

package/dist/extension/cmux/hooks.d.ts

@@ -0,0 +1,12 @@
+import type { CmuxDispatcher, CommandResult } from "./dispatcher.js";
+import type { PiExtensionContextSnapshot } from "./state.js";
+type HookExtra = Record<string, unknown>;
+export declare function eventName(subcommand: string): string;
+export declare function surfaceTargetArgs(dispatcher: CmuxDispatcher, sessionId: string): string[] | null;
+export declare function rememberSurfaceTarget(dispatcher: CmuxDispatcher, sessionId: string, result: CommandResult): void;
+export declare function releaseSessionRuntime(dispatcher: CmuxDispatcher, sessionStates: Map<string, unknown>, sessionId: string): void;
+export declare function sendHook(dispatcher: CmuxDispatcher, subcommand: string, context: PiExtensionContextSnapshot, extra?: HookExtra): Promise<boolean>;
+export declare function ensureResumeBinding(dispatcher: CmuxDispatcher, context: PiExtensionContextSnapshot, sessionId: string): Promise<void>;
+export declare function clearResumeBinding(dispatcher: CmuxDispatcher, context: PiExtensionContextSnapshot, sessionId: string): Promise<void>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/extension/cmux/hooks.js

@@ -0,0 +1,192 @@
+import { normalizedLaunchArgv } from "./dispatcher.js";
+import { firstString, warn } from "./state.js";
+export function eventName(subcommand) {
+    switch (subcommand) {
+        case "session-start": return "SessionStart";
+        case "prompt-submit": return "UserPromptSubmit";
+        case "stop": return "Stop";
+        case "notification": return "Notification";
+        default: return subcommand;
+    }
+}
+const resolvedSurfaceTargets = new WeakMap();
+function surfaceTargetsFor(dispatcher) {
+    let targets = resolvedSurfaceTargets.get(dispatcher);
+    if (!targets) {
+        targets = new Map();
+        resolvedSurfaceTargets.set(dispatcher, targets);
+    }
+    return targets;
+}
+export function surfaceTargetArgs(dispatcher, sessionId) {
+    const resolved = surfaceTargetsFor(dispatcher).get(sessionId);
+    if (resolved)
+        return [...resolved];
+    const surfaceId = firstString(process.env.CMUX_SURFACE_ID);
+    if (!surfaceId)
+        return null;
+    const args = [];
+    const workspaceId = firstString(process.env.CMUX_WORKSPACE_ID);
+    if (workspaceId)
+        args.push("--workspace", workspaceId);
+    args.push("--surface", surfaceId);
+    return args;
+}
+export function rememberSurfaceTarget(dispatcher, sessionId, result) {
+    const payload = parseJSONOutput(result);
+    const workspaceId = firstString(payload?.workspace_id);
+    const surfaceId = firstString(payload?.surface_id);
+    if (!workspaceId || !surfaceId)
+        return;
+    surfaceTargetsFor(dispatcher).set(sessionId, ["--workspace", workspaceId, "--surface", surfaceId]);
+}
+export function releaseSessionRuntime(dispatcher, sessionStates, sessionId) {
+    dispatcher.releaseSession(sessionId);
+    sessionStates.delete(sessionId);
+    surfaceTargetsFor(dispatcher).delete(sessionId);
+}
+function parseJSONOutput(result) {
+    if (!result.ok)
+        return null;
+    try {
+        const parsed = JSON.parse(result.stdout);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function sendHook(dispatcher, subcommand, context, extra = {}) {
+    if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
+        return true;
+    const sessionId = context.sessionId;
+    if (!sessionId)
+        return true;
+    const target = surfaceTargetArgs(dispatcher, sessionId);
+    if (!target)
+        return !firstString(process.env.CMUX_PANEL_ID);
+    const cwd = context.cwd;
+    const payload = {
+        session_id: sessionId,
+        cwd,
+        hook_event_name: eventName(subcommand),
+        event: eventName(subcommand),
+        ...extra,
+    };
+    const result = await dispatcher.run(["hooks", "pi", subcommand, ...target], cwd, JSON.stringify(payload), context);
+    if (result.ok)
+        rememberSurfaceTarget(dispatcher, sessionId, result);
+    if (!result.ok && !result.surfaceUnavailable) {
+        warn(context, "cmux hook command failed", {
+            subcommand,
+            status: result.status,
+            stderr_available: result.stderr.trim().length > 0,
+            error_available: result.error !== undefined,
+        });
+    }
+    return result.ok;
+}
+// --- Resume bindings ---
+const piOptionsWithValue = new Set([
+    "--model", "-m", "--thinking", "--provider", "--extension", "-e",
+    "--skill", "--mcp-config", "--permission-mode", "--session-dir",
+    "--config", "--profile", "--system-prompt", "--append-system-prompt",
+    "--cwd", "--dir", "--trust", "--sandbox",
+]);
+const piOptionsWithoutValue = new Set([
+    "--no-color", "--dangerously-skip-permissions", "--yolo",
+]);
+const piSelectorsToDrop = new Set([
+    "--session", "-s", "--resume", "--fork", "--api-key", "--prompt", "--print",
+]);
+function sanitizedResumeArgv(sessionId) {
+    const raw = normalizedLaunchArgv();
+    const executable = raw[0] || "pi";
+    const out = [executable, "--session", sessionId];
+    for (let index = 1; index < raw.length; index += 1) {
+        const arg = raw[index];
+        if (!arg)
+            continue;
+        if (piSelectorsToDrop.has(arg)) {
+            if (index + 1 < raw.length && !raw[index + 1].startsWith("-"))
+                index += 1;
+            continue;
+        }
+        if (arg.startsWith("--session=") || arg.startsWith("--resume=") ||
+            arg.startsWith("--fork=") || arg.startsWith("--api-key=") ||
+            arg.startsWith("--prompt=")) {
+            continue;
+        }
+        if (piOptionsWithValue.has(arg)) {
+            out.push(arg);
+            if (index + 1 < raw.length) {
+                out.push(raw[index + 1]);
+                index += 1;
+            }
+            continue;
+        }
+        if ([...piOptionsWithValue].some((option) => arg.startsWith(`${option}=`)) || piOptionsWithoutValue.has(arg)) {
+            out.push(arg);
+        }
+    }
+    return out;
+}
+function resumeBindingMatches(payload, sessionId) {
+    const binding = payload?.resume_binding;
+    if (!binding || typeof binding !== "object")
+        return false;
+    const typed = binding;
+    return firstString(typed.kind) === "pi" &&
+        firstString(typed.checkpoint_id, typed.checkpointId) === sessionId;
+}
+export async function ensureResumeBinding(dispatcher, context, sessionId) {
+    if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
+        return;
+    const target = surfaceTargetArgs(dispatcher, sessionId);
+    if (!target)
+        return;
+    const cwd = context.cwd;
+    const resumeArgv = sanitizedResumeArgv(sessionId);
+    const set = await dispatcher.run([
+        "--json", "surface", "resume", "set", ...target,
+        "--name", "Pi", "--kind", "pi", "--checkpoint-id", sessionId,
+        "--source", "agent-hook", "--cwd", cwd, "--", ...resumeArgv,
+    ], cwd, undefined, context);
+    if (!set.ok && !set.surfaceUnavailable) {
+        warn(context, "failed to set Pi resume binding", {
+            status: set.status,
+            stderr_available: set.stderr.trim().length > 0,
+        });
+        return;
+    }
+    if (set.surfaceUnavailable)
+        return;
+    const verification = await dispatcher.run(["--json", "surface", "resume", "get", ...target], cwd, undefined, context);
+    if (verification.surfaceUnavailable)
+        return;
+    const verified = parseJSONOutput(verification);
+    if (!resumeBindingMatches(verified, sessionId)) {
+        warn(context, "Pi resume binding did not verify after write", { session_id: sessionId });
+    }
+}
+export async function clearResumeBinding(dispatcher, context, sessionId) {
+    if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
+        return;
+    const target = surfaceTargetArgs(dispatcher, sessionId);
+    if (!target)
+        return;
+    const cwd = context.cwd;
+    const result = await dispatcher.run([
+        "--json", "surface", "resume", "clear", ...target,
+        "--checkpoint-id", sessionId, "--source", "agent-hook",
+    ], cwd, undefined, context);
+    if (result.surfaceUnavailable)
+        return;
+    if (!result.ok) {
+        warn(context, "failed to clear Pi resume binding", {
+            status: result.status,
+            stderr_available: result.stderr.trim().length > 0,
+        });
+    }
+}
+//# sourceMappingURL=hooks.js.map

package/dist/extension/cmux/index.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export declare function registerCmuxBridge(pi: ExtensionAPI): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/extension/cmux/index.js

@@ -0,0 +1,155 @@
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { CmuxDispatcher } from "./dispatcher.js";
+import { stateFor, snapshotContext, beginTurn, currentTurnId, finishTurn, settleTurn, lastAssistantMessage, firstString, objectValue, warn, } from "./state.js";
+import { sendHook, ensureResumeBinding, clearResumeBinding, releaseSessionRuntime, } from "./hooks.js";
+import { renameWorkspaceFromPrompt } from "./naming.js";
+/** Remove a stale cmux-installed extension so hooks don't double-fire. */
+function removeStaleManagedExtension() {
+    const agentDir = process.env.PI_CODING_AGENT_DIR || process.env.YAGNI_CODING_AGENT_DIR;
+    if (!agentDir)
+        return;
+    const managed = join(agentDir, "extensions", "cmux-session.ts");
+    try {
+        if (!existsSync(managed))
+            return;
+        const head = readFileSync(managed, "utf8").slice(0, 200);
+        if (head.includes("cmux-pi-session-extension-marker")) {
+            unlinkSync(managed);
+            try {
+                unlinkSync(join(agentDir, "extensions", ".cmux-session.lock"));
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+export function registerCmuxBridge(pi) {
+    if (!process.env.CMUX_SURFACE_ID)
+        return;
+    if (process.env.CMUX_PI_HOOKS_DISABLED === "1")
+        return;
+    const dispatcher = new CmuxDispatcher();
+    const sessionStates = new Map();
+    const lifecycleTails = new Map();
+    const enqueueLifecycleTask = (sessionId, context, operation) => {
+        const previous = lifecycleTails.get(sessionId) || Promise.resolve();
+        let tracked;
+        tracked = previous
+            .then(operation)
+            .then(() => undefined)
+            .catch((error) => {
+            const msg = error instanceof Error ? error.message : undefined;
+            warn(context, "cmux lifecycle task failed", { error_message: msg?.slice(0, 512) }, true);
+        })
+            .finally(() => {
+            if (lifecycleTails.get(sessionId) === tracked)
+                lifecycleTails.delete(sessionId);
+        });
+        lifecycleTails.set(sessionId, tracked);
+        return tracked;
+    };
+    pi.on("session_start", (_event, ctx) => {
+        removeStaleManagedExtension();
+        const context = snapshotContext(ctx);
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const state = stateFor(sessionStates, sessionId);
+        state.pendingCompletion = undefined;
+        state.stopped = false;
+        enqueueLifecycleTask(sessionId, context, async () => {
+            const ok = await sendHook(dispatcher, "session-start", context);
+            if (ok)
+                await ensureResumeBinding(dispatcher, context, sessionId);
+        });
+    });
+    pi.on("before_agent_start", (event, ctx) => {
+        const context = snapshotContext(ctx);
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const turnId = beginTurn(sessionStates, sessionId, event);
+        const st = stateFor(sessionStates, sessionId);
+        if (typeof event.prompt === "string" && event.prompt.trim()) {
+            st.lastPrompt = event.prompt.trim();
+        }
+        enqueueLifecycleTask(sessionId, context, () => sendHook(dispatcher, "prompt-submit", context, { prompt: event.prompt, turn_id: turnId }));
+    });
+    pi.on("agent_end", (event, ctx) => {
+        const context = snapshotContext(ctx);
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const state = stateFor(sessionStates, sessionId);
+        const message = lastAssistantMessage(event);
+        state.pendingCompletion = {
+            lastAssistantMessage: message || state.pendingCompletion?.lastAssistantMessage,
+            notificationType: firstString(objectValue(event, ["stopReason", "reason", "terminationReason"])) || "completed",
+            turnId: currentTurnId(sessionStates, sessionId, event),
+        };
+        // Pi >= 0.80.5 always emits agent_settled, so we wait for it there.
+    });
+    pi.on("agent_settled", (_event, ctx) => {
+        const context = snapshotContext(ctx);
+        try {
+            if (!ctx.isIdle())
+                return;
+        }
+        catch {
+            return;
+        }
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const completion = settleTurn(sessionStates, sessionId);
+        if (completion) {
+            enqueueLifecycleTask(sessionId, context, () => publishCompletion(dispatcher, sessionStates, context, sessionId, completion));
+        }
+    });
+    pi.on("session_shutdown", async (event, ctx) => {
+        const context = snapshotContext(ctx);
+        const sessionId = context.sessionId;
+        if (!sessionId)
+            return;
+        const state = stateFor(sessionStates, sessionId);
+        let stopPayload;
+        if (!state.stopped) {
+            const turnId = finishTurn(sessionStates, sessionId, event);
+            stopPayload = {
+                turn_id: turnId,
+                terminationReason: firstString(objectValue(event, ["reason"])) || "session_shutdown",
+            };
+        }
+        await enqueueLifecycleTask(sessionId, context, async () => {
+            if (stopPayload)
+                await sendHook(dispatcher, "stop", context, stopPayload);
+            try {
+                await clearResumeBinding(dispatcher, context, sessionId);
+            }
+            finally {
+                releaseSessionRuntime(dispatcher, sessionStates, sessionId);
+            }
+        });
+    });
+}
+async function publishCompletion(dispatcher, sessionStates, context, sessionId, completion) {
+    const stopPayload = {
+        last_assistant_message: completion.lastAssistantMessage,
+        turn_id: completion.turnId,
+    };
+    const notificationRouted = await sendHook(dispatcher, "notification", context, {
+        message: completion.lastAssistantMessage || "Task completed",
+        turn_id: completion.turnId,
+        notification: { type: completion.notificationType },
+    });
+    if (notificationRouted)
+        stopPayload.cmux_notification_routed = true;
+    await sendHook(dispatcher, "stop", context, stopPayload);
+    const state = stateFor(sessionStates, sessionId);
+    if (!state.hasNamed) {
+        renameWorkspaceFromPrompt(dispatcher, sessionStates, context, sessionId);
+        state.hasNamed = true;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/extension/cmux/naming.d.ts

@@ -0,0 +1,5 @@
+import type { CmuxDispatcher } from "./dispatcher.js";
+import { type PiExtensionContextSnapshot, type SessionState } from "./state.js";
+export declare function titleFromPrompt(prompt: string): string | undefined;
+export declare function renameWorkspaceFromPrompt(dispatcher: CmuxDispatcher, sessionStates: Map<string, SessionState>, context: PiExtensionContextSnapshot, sessionId: string): void;
+//# sourceMappingURL=naming.d.ts.map

package/dist/extension/cmux/naming.js

@@ -0,0 +1,23 @@
+import { firstString } from "./state.js";
+export function titleFromPrompt(prompt) {
+    const words = prompt.trim().split(/\s+/).filter(Boolean);
+    if (words.length === 0)
+        return undefined;
+    return words.slice(0, 8).join(" ").slice(0, 60) || undefined;
+}
+export function renameWorkspaceFromPrompt(dispatcher, sessionStates, context, sessionId) {
+    const prompt = sessionStates.get(sessionId)?.lastPrompt;
+    if (!prompt)
+        return;
+    const title = titleFromPrompt(prompt);
+    if (!title)
+        return;
+    // Use the workspace-scoped rename form: cmux workspace rename <ws> --title <title>
+    // (NOT rename-workspace --workspace ... --surface ... which misinterprets --surface
+    // as part of the title).
+    const workspaceId = firstString(process.env.CMUX_WORKSPACE_ID);
+    if (!workspaceId)
+        return;
+    void dispatcher.run(["workspace", "rename", workspaceId, "--title", title], context.cwd, undefined, context);
+}
+//# sourceMappingURL=naming.js.map