@launch11/srgical 0.0.5 → 0.0.6

package/dist/ui/studio.js

@@ -11,17 +11,22 @@ exports.renderWorkspaceSelectionMessage = renderWorkspaceSelectionMessage;
 exports.resolveStudioWorkspaceInput = resolveStudioWorkspaceInput;
 const node_path_1 = __importDefault(require("node:path"));
 const blessed_1 = __importDefault(require("blessed"));
+const auto_run_1 = require("../core/auto-run");
 const agent_1 = require("../core/agent");
 const execution_controls_1 = require("../core/execution-controls");
 const execution_state_1 = require("../core/execution-state");
 const planning_pack_state_1 = require("../core/planning-pack-state");
+const planning_state_1 = require("../core/planning-state");
 const studio_session_1 = require("../core/studio-session");
+const templates_1 = require("../core/templates");
 const workspace_1 = require("../core/workspace");
-const READY_FOOTER = " Enter send message   PgUp/PgDn scroll   /workspace switch repo   /agents tools   /write save plan   /preview safe preview   /run execute next step   /quit exit ";
+const READY_FOOTER = " PgUp/PgDn scroll   /agents choose tool   /help commands ";
 const ACTIVITY_FRAMES = ["[    ]", "[=   ]", "[==  ]", "[=== ]", "[ ===]", "[  ==]", "[   =]"];
 async function launchStudio(options = {}) {
     let workspace = (0, workspace_1.resolveWorkspace)(options.workspace);
-    let messages = await (0, studio_session_1.loadStudioSession)(workspace);
+    let planId = await (0, workspace_1.resolvePlanId)(workspace, options.planId);
+    await (0, workspace_1.saveActivePlanId)(workspace, planId);
+    let messages = await (0, studio_session_1.loadStudioSession)(workspace, { planId });
     const screen = blessed_1.default.screen({
         smartCSR: true,
         fullUnicode: true,
@@ -43,7 +48,7 @@ async function launchStudio(options = {}) {
         top: 3,
         left: 0,
         width: "72%",
-        height: "100%-7",
+        height: "100%-8",
         tags: true,
         scrollable: true,
         alwaysScroll: true,
@@ -74,7 +79,7 @@ async function launchStudio(options = {}) {
         top: 3,
         left: "72%",
         width: "28%",
-        height: "100%-7",
+        height: "100%-8",
         tags: true,
         padding: {
             top: 1,
@@ -94,12 +99,14 @@ async function launchStudio(options = {}) {
             }
         }
     });
-    const input = blessed_1.default.textbox({
+    const input = blessed_1.default.textarea({
         bottom: 1,
         left: 0,
         width: "100%",
-        height: 3,
+        height: 4,
         inputOnFocus: true,
+        keys: true,
+        mouse: true,
         border: {
             type: "line"
         },
@@ -112,6 +119,7 @@ async function launchStudio(options = {}) {
             }
         }
     });
+    configureComposer(input);
     const footer = blessed_1.default.box({
         bottom: 0,
         left: 0,
@@ -139,12 +147,14 @@ async function launchStudio(options = {}) {
     let planningPackSummary = "not checked";
     let trackerSummary = "loading...";
     let executionSummary = "never run";
+    let autoSummary = "idle";
     function setSidebar(status) {
-        const planningPaths = (0, workspace_1.getPlanningPackPaths)(workspace);
+        const planningPaths = (0, workspace_1.getPlanningPackPaths)(workspace, { planId });
         sidebar.setContent([
             "{bold}Workspace{/bold}",
             `root: ${workspace}`,
-            `plan dir: ${planningPaths.dir}`,
+            `plan: ${planId}`,
+            `plan dir: ${planningPaths.relativeDir}`,
             "",
             "{bold}Agent{/bold}",
             agentSummary,
@@ -158,15 +168,8 @@ async function launchStudio(options = {}) {
             "{bold}Last Run{/bold}",
             executionSummary,
             "",
-            "{bold}Commands{/bold}",
-            "/workspace [path]  inspect or switch planning view",
-            "/agents  list supported tools and the current session choice",
-            "/agent <id>  switch the active agent for this workspace",
-            "/write  put the current plan on disk",
-            "/preview  inspect the next execution without invoking the active agent",
-            "/run    execute .srgical/04-next-agent-prompt.md",
-            "/help   show the workflow and key controls",
-            "/quit   close the studio",
+            "{bold}Auto{/bold}",
+            autoSummary,
             "",
             "{bold}State{/bold}",
             status ?? getActivityState()
@@ -239,18 +242,28 @@ async function launchStudio(options = {}) {
     }
     async function appendMessage(message) {
         messages.push(message);
-        await (0, studio_session_1.saveStudioSession)(workspace, messages);
+        await (0, studio_session_1.saveStudioSession)(workspace, messages, { planId });
+    }
+    async function appendSystemMessage(content) {
+        await appendMessage({
+            role: "system",
+            content
+        });
+        renderTranscript();
+        setSidebar();
+        setFooter();
+        screen.render();
     }
     async function refreshEnvironment() {
         const [storedAgentId, packState] = await Promise.all([
-            (0, studio_session_1.loadStoredActiveAgentId)(workspace),
-            (0, planning_pack_state_1.readPlanningPackState)(workspace)
+            (0, studio_session_1.loadStoredActiveAgentId)(workspace, { planId }),
+            (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId })
         ]);
-        let agentState = await (0, agent_1.resolvePrimaryAgent)(workspace);
+        let agentState = await (0, agent_1.resolvePrimaryAgent)(workspace, { planId });
         if (!storedAgentId) {
             const availableAgents = agentState.statuses.filter((status) => status.available);
             if (availableAgents.length === 1) {
-                agentState = await (0, agent_1.selectPrimaryAgent)(workspace, availableAgents[0].id);
+                agentState = await (0, agent_1.selectPrimaryAgent)(workspace, availableAgents[0].id, { planId });
             }
         }
         latestPackState = packState;
@@ -259,112 +272,126 @@ async function launchStudio(options = {}) {
         planningPackSummary = formatPlanningPackSummary(workspace, packState);
         trackerSummary = formatTrackerSummary(packState.currentPosition);
         executionSummary = formatExecutionSummary(packState.lastExecution);
+        autoSummary = formatAutoSummary(packState);
         setSidebar();
         setFooter();
         renderTranscript();
         screen.render();
     }
+    async function switchPlan(nextPlanId) {
+        planId = (0, workspace_1.normalizePlanId)(nextPlanId);
+        await (0, workspace_1.saveActivePlanId)(workspace, planId);
+        messages = await (0, studio_session_1.loadStudioSession)(workspace, { planId });
+        await refreshEnvironment();
+    }
     async function handleSlashCommand(command) {
         if (command === "/quit") {
             screen.destroy();
             return;
         }
         if (command === "/workspace") {
-            const packState = latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace));
-            await appendMessage({
-                role: "system",
-                content: renderWorkspaceSelectionMessage(workspace, packState)
-            });
-            renderTranscript();
-            setSidebar();
-            setFooter();
-            screen.render();
+            const packState = latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId }));
+            await appendSystemMessage(renderWorkspaceSelectionMessage(workspace, packState));
             return;
         }
         if (command.startsWith("/workspace")) {
             const requestedWorkspace = command.slice("/workspace".length).trim();
             if (!requestedWorkspace) {
-                const packState = latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace));
-                await appendMessage({
-                    role: "system",
-                    content: renderWorkspaceSelectionMessage(workspace, packState)
-                });
-                renderTranscript();
-                setSidebar();
-                setFooter();
-                screen.render();
+                const packState = latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId }));
+                await appendSystemMessage(renderWorkspaceSelectionMessage(workspace, packState));
                 return;
             }
             const nextWorkspace = resolveStudioWorkspaceInput(workspace, requestedWorkspace);
-            setSidebar("switching planning view...");
-            setFooter(" Switching planning view... ");
+            setSidebar("switching workspace...");
+            setFooter(" Switching workspace... ");
             screen.render();
             workspace = nextWorkspace;
-            messages = await (0, studio_session_1.loadStudioSession)(workspace);
+            planId = await (0, workspace_1.resolvePlanId)(workspace);
+            await (0, workspace_1.saveActivePlanId)(workspace, planId);
+            messages = await (0, studio_session_1.loadStudioSession)(workspace, { planId });
             await refreshEnvironment();
-            await appendMessage({
-                role: "system",
-                content: [
-                    `Now looking at ${workspace}.`,
-                    "",
-                    renderWorkspaceSelectionMessage(workspace, latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace)))
-                ].join("\n")
-            });
-            renderTranscript();
-            setSidebar();
-            setFooter();
+            await appendSystemMessage([
+                `Now looking at ${workspace}.`,
+                "",
+                renderWorkspaceSelectionMessage(workspace, latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId })))
+            ].join("\n"));
+            return;
+        }
+        if (command === "/plans") {
+            await appendSystemMessage(await renderPlansMessage(workspace, planId));
+            return;
+        }
+        if (command === "/plan") {
+            await appendSystemMessage(renderPlanUsageMessage(planId, (0, workspace_1.getPlanningPackPaths)(workspace, { planId })));
+            return;
+        }
+        if (command.startsWith("/plan new ")) {
+            const requestedPlanId = command.slice("/plan new ".length).trim();
+            if (!requestedPlanId) {
+                await appendSystemMessage("Usage: `/plan new <id>`");
+                return;
+            }
+            setSidebar("creating named plan...");
+            setFooter(" Creating named plan... ");
             screen.render();
+            const createdPaths = await createPlanScaffold(workspace, requestedPlanId);
+            await switchPlan(createdPaths.planId);
+            await appendSystemMessage([
+                `Created and selected plan \`${createdPaths.planId}\`.`,
+                `Planning directory: ${createdPaths.relativeDir}`,
+                "Use `/readiness` while gathering context, then `/write` when the plan is ready."
+            ].join("\n"));
+            return;
+        }
+        if (command.startsWith("/plan ")) {
+            const requestedPlanId = command.slice("/plan ".length).trim();
+            if (!requestedPlanId) {
+                await appendSystemMessage(renderPlanUsageMessage(planId, (0, workspace_1.getPlanningPackPaths)(workspace, { planId })));
+                return;
+            }
+            await switchPlan(requestedPlanId);
+            await appendSystemMessage(`Active plan set to \`${planId}\`.\nPlanning directory: ${(0, workspace_1.getPlanningPackPaths)(workspace, { planId }).relativeDir}`);
+            return;
+        }
+        if (command === "/status") {
+            const packState = latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId }));
+            await appendSystemMessage(renderStatusMessage(workspace, packState));
+            return;
+        }
+        if (command === "/readiness") {
+            const packState = latestPackState ?? (await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId }));
+            await appendSystemMessage(renderReadinessMessage(packState));
+            return;
+        }
+        if (command === "/stop") {
+            const state = await (0, auto_run_1.requestAutoRunStop)(workspace, { planId });
+            await refreshEnvironment();
+            await appendSystemMessage(state.status === "stop_requested"
+                ? "Stop requested. Auto mode will finish the current iteration before stopping."
+                : "No active auto run was in progress.");
             return;
         }
         if (command === "/agents") {
-            const agentState = await (0, agent_1.resolvePrimaryAgent)(workspace);
-            await appendMessage({
-                role: "system",
-                content: renderAgentSelectionMessage(agentState.status, agentState.statuses)
-            });
-            renderTranscript();
-            setSidebar();
-            setFooter();
-            screen.render();
+            const agentState = await (0, agent_1.resolvePrimaryAgent)(workspace, { planId });
+            await appendSystemMessage(renderAgentSelectionMessage(agentState.status, agentState.statuses));
             return;
         }
         if (command.startsWith("/agent")) {
             const requestedId = command.slice("/agent".length).trim().toLowerCase();
             if (!requestedId) {
-                const agentState = await (0, agent_1.resolvePrimaryAgent)(workspace);
-                await appendMessage({
-                    role: "system",
-                    content: [
-                        buildAgentUsageMessage(),
-                        "",
-                        renderAgentSelectionMessage(agentState.status, agentState.statuses)
-                    ].join("\n")
-                });
-                renderTranscript();
-                setSidebar();
-                setFooter();
-                screen.render();
+                const agentState = await (0, agent_1.resolvePrimaryAgent)(workspace, { planId });
+                await appendSystemMessage([buildAgentUsageMessage(), "", renderAgentSelectionMessage(agentState.status, agentState.statuses)].join("\n"));
                 return;
             }
             setSidebar("updating active agent...");
             setFooter(" Updating active agent selection... ");
             screen.render();
             try {
-                const agentState = await (0, agent_1.selectPrimaryAgent)(workspace, requestedId);
-                await appendMessage({
-                    role: "system",
-                    content: [
-                        `Active agent set to ${agentState.status.label} for this workspace session.`,
-                        "",
-                        renderAgentSelectionMessage(agentState.status, agentState.statuses)
-                    ].join("\n")
-                });
+                const agentState = await (0, agent_1.selectPrimaryAgent)(workspace, requestedId, { planId });
+                await appendSystemMessage([`Active agent set to ${agentState.status.label} for plan \`${planId}\`.`, "", renderAgentSelectionMessage(agentState.status, agentState.statuses)].join("\n"));
             }
             catch (error) {
-                await appendMessage({
-                    role: "system",
-                    content: `Agent selection failed: ${error instanceof Error ? error.message : String(error)}`
-                });
+                await appendSystemMessage(`Agent selection failed: ${error instanceof Error ? error.message : String(error)}`);
             }
             finally {
                 await refreshEnvironment();
@@ -372,68 +399,43 @@ async function launchStudio(options = {}) {
             return;
         }
         if (command === "/help") {
-            await appendMessage({
-                role: "system",
-                content: [
-                    "Workflow:",
-                    "1. Talk normally to sharpen the plan against the real repo.",
-                    "2. Run `/workspace <path>` when you want to change which repo and planning directory you are looking at.",
-                    "3. Run `/agents` to inspect available tools and `/agent <id>` when you want to switch the workspace session.",
-                    "4. Run `/write` when the shape is ready to put the plan on disk inside `.srgical/`.",
-                    "5. Run `/preview` to inspect the next execution safely before writes happen.",
-                    "6. Run `/run` when you want the active agent to execute the next eligible tracker block.",
-                    "",
-                    "Controls:",
-                    "- `Enter` sends the current message.",
-                    "- `PageUp` and `PageDown` scroll the transcript.",
-                    "- `/quit` closes the studio."
-                ].join("\n")
-            });
-            renderTranscript();
-            setSidebar();
-            setFooter();
-            screen.render();
+            await appendSystemMessage([
+                "Workflow:",
+                "1. Talk normally to sharpen the plan against the real repo.",
+                "2. Use `/plans`, `/plan`, and `/plan new <id>` to manage named planning packs in this workspace.",
+                "3. Use `/readiness` to see what context is still missing before you write the pack.",
+                "4. Run `/write` when the plan is ready to put on disk.",
+                "5. Run `/preview` for a safe execution preview, `/run` for one execution step, or `/auto [max]` for continuous execution.",
+                "6. Run `/stop` to stop auto mode after the current iteration.",
+                "",
+                "Controls:",
+                "- `Enter` sends the current message or command.",
+                "- `Shift+Enter`, `Alt+Enter`, or `Ctrl+J` inserts a new line when the terminal exposes those keys distinctly.",
+                "- `PageUp` and `PageDown` scroll the transcript.",
+                "- `/quit` closes the studio."
+            ].join("\n"));
             return;
         }
         if (command === "/preview") {
-            const paths = (0, workspace_1.getPlanningPackPaths)(workspace);
-            const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspace);
+            const paths = (0, workspace_1.getPlanningPackPaths)(workspace, { planId });
+            const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId });
             if (!packState.packPresent) {
-                await appendMessage({
-                    role: "system",
-                    content: "Execution preview unavailable: no .srgical planning pack was found yet."
-                });
-                renderTranscript();
-                setSidebar();
-                setFooter();
-                screen.render();
+                await appendSystemMessage("Execution preview unavailable: no planning pack was found for the selected plan yet.");
                 return;
             }
             const prompt = await (0, workspace_1.readText)(paths.nextPrompt);
-            await appendMessage({
-                role: "system",
-                content: (0, execution_controls_1.renderDryRunPreview)(prompt, packState.nextStepSummary, packState.currentPosition.nextRecommended).join("\n")
-            });
-            renderTranscript();
-            setSidebar();
-            setFooter();
-            screen.render();
+            await appendSystemMessage((0, execution_controls_1.renderDryRunPreview)(prompt, packState.nextStepSummary, packState.currentPosition.nextRecommended).join("\n"));
             return;
         }
         if (command === "/write") {
             startBusy("pack");
             try {
-                const result = await (0, agent_1.writePlanningPack)(workspace, messages);
-                await appendMessage({
-                    role: "system",
-                    content: `Planning pack updated. Summary:\n${result}`
-                });
+                const result = await (0, agent_1.writePlanningPack)(workspace, messages, { planId });
+                await (0, planning_state_1.markPlanningPackAuthored)(workspace, { planId });
+                await appendSystemMessage(`Planning pack updated for \`${planId}\`. Summary:\n${result}`);
             }
             catch (error) {
-                await appendMessage({
-                    role: "system",
-                    content: `Pack generation failed: ${error instanceof Error ? error.message : String(error)}`
-                });
+                await appendSystemMessage(`Pack generation failed: ${error instanceof Error ? error.message : String(error)}`);
             }
             finally {
                 stopBusy();
@@ -442,37 +444,32 @@ async function launchStudio(options = {}) {
             return;
         }
         if (command === "/run") {
-            const paths = (0, workspace_1.getPlanningPackPaths)(workspace);
-            const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspace);
+            const paths = (0, workspace_1.getPlanningPackPaths)(workspace, { planId });
+            const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId });
             if (!(0, execution_controls_1.hasQueuedNextStep)(packState.currentPosition.nextRecommended)) {
-                await appendMessage({
-                    role: "system",
-                    content: (0, execution_controls_1.formatNoQueuedNextStepMessage)("studio")
-                });
-                renderTranscript();
-                setSidebar();
-                setFooter();
-                screen.render();
+                await appendSystemMessage((0, execution_controls_1.formatNoQueuedNextStepMessage)("studio"));
                 return;
             }
             startBusy("run");
             try {
                 const prompt = await (0, workspace_1.readText)(paths.nextPrompt);
-                const result = await (0, agent_1.runNextPrompt)(workspace, prompt);
-                await (0, execution_state_1.saveExecutionState)(workspace, "success", "studio", result);
-                await appendMessage({
-                    role: "system",
-                    content: `Execution run finished. ${(0, agent_1.getPrimaryAgentAdapter)().label} summary:\n${result}`
+                const result = await (0, agent_1.runNextPrompt)(workspace, prompt, { planId });
+                await (0, execution_state_1.saveExecutionState)(workspace, "success", "studio", result, { planId });
+                await (0, execution_state_1.appendExecutionLog)(workspace, "success", "studio", result, {
+                    planId,
+                    stepLabel: packState.nextStepSummary?.id ?? packState.currentPosition.nextRecommended
                 });
+                await appendSystemMessage(`Execution run finished. ${(0, agent_1.getPrimaryAgentAdapter)().label} summary:\n${result}`);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                await (0, execution_state_1.saveExecutionState)(workspace, "failure", "studio", message);
-                const refreshedPackState = await (0, planning_pack_state_1.readPlanningPackState)(workspace);
-                await appendMessage({
-                    role: "system",
-                    content: (0, execution_controls_1.formatExecutionFailureMessage)(message, refreshedPackState.nextStepSummary, refreshedPackState.currentPosition.nextRecommended, "studio")
+                await (0, execution_state_1.saveExecutionState)(workspace, "failure", "studio", message, { planId });
+                await (0, execution_state_1.appendExecutionLog)(workspace, "failure", "studio", message, {
+                    planId,
+                    stepLabel: packState.nextStepSummary?.id ?? packState.currentPosition.nextRecommended
                 });
+                const refreshedPackState = await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId });
+                await appendSystemMessage((0, execution_controls_1.formatExecutionFailureMessage)(message, refreshedPackState.nextStepSummary, refreshedPackState.currentPosition.nextRecommended, "studio"));
             }
             finally {
                 stopBusy();
@@ -480,19 +477,36 @@ async function launchStudio(options = {}) {
             }
             return;
         }
-        await appendMessage({
-            role: "system",
-            content: `Unknown command: ${command}`
-        });
-        renderTranscript();
-        setSidebar();
-        setFooter();
-        screen.render();
+        if (command.startsWith("/auto")) {
+            const requestedMax = command.slice("/auto".length).trim();
+            const maxSteps = requestedMax ? Number(requestedMax) : undefined;
+            startBusy("auto");
+            try {
+                const result = await (0, auto_run_1.executeAutoRun)(workspace, {
+                    source: "studio",
+                    planId,
+                    maxSteps,
+                    onMessage: async (line) => {
+                        await appendSystemMessage(line);
+                    }
+                });
+                await appendSystemMessage(`Auto mode finished: ${result.summary}`);
+            }
+            catch (error) {
+                await appendSystemMessage(`Auto mode failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                stopBusy();
+                await refreshEnvironment();
+            }
+            return;
+        }
+        await appendSystemMessage(`Unknown command: ${command}`);
     }
     input.on("submit", async (value) => {
         const text = value.trim();
         input.clearValue();
-        if (!text || busy) {
+        if (!text || (busy && text !== "/stop")) {
             screen.render();
             return;
         }
@@ -511,7 +525,7 @@ async function launchStudio(options = {}) {
         setFooter();
         screen.render();
         try {
-            const reply = await (0, agent_1.requestPlannerReply)(workspace, messages);
+            const reply = await (0, agent_1.requestPlannerReply)(workspace, messages, { planId });
             await appendMessage({
                 role: "assistant",
                 content: reply
@@ -533,6 +547,10 @@ async function launchStudio(options = {}) {
         }
     });
     screen.key(["C-c"], () => {
+        if (busyMode === "auto") {
+            void (0, auto_run_1.requestAutoRunStop)(workspace, { planId });
+            return;
+        }
         stopBusy();
         screen.destroy();
     });
@@ -555,14 +573,7 @@ async function launchStudio(options = {}) {
         if (!latestPackState || !isDefaultStudioSession(messages)) {
             return;
         }
-        await appendMessage({
-            role: "system",
-            content: renderWorkspaceSelectionMessage(workspace, latestPackState)
-        });
-        renderTranscript();
-        setSidebar();
-        setFooter();
-        screen.render();
+        await appendSystemMessage(renderWorkspaceSelectionMessage(workspace, latestPackState));
     }
 }
 function describeBusyMode(mode) {
@@ -573,6 +584,8 @@ function describeBusyMode(mode) {
             return `writing planning pack via ${(0, agent_1.getPrimaryAgentAdapter)().label}`;
         case "run":
             return `executing next-agent prompt via ${(0, agent_1.getPrimaryAgentAdapter)().label}`;
+        case "auto":
+            return `running auto mode via ${(0, agent_1.getPrimaryAgentAdapter)().label}`;
     }
 }
 function formatElapsed(durationMs) {
@@ -604,6 +617,22 @@ function formatExecutionSummary(execution) {
     const label = execution.status === "success" ? "success" : "failure";
     return `${label} via ${execution.source}\n${execution.updatedAt}\n${execution.summary}`;
 }
+function formatAutoSummary(packState) {
+    if (!packState?.autoRun) {
+        return "idle";
+    }
+    const lines = [packState.autoRun.status];
+    if (packState.autoRun.maxSteps) {
+        lines.push(`steps: ${packState.autoRun.stepsAttempted}/${packState.autoRun.maxSteps}`);
+    }
+    else {
+        lines.push(`steps: ${packState.autoRun.stepsAttempted}`);
+    }
+    if (packState.autoRun.stopReason) {
+        lines.push(packState.autoRun.stopReason);
+    }
+    return lines.join("\n");
+}
 function formatAgentSummary(activeAgent, statuses) {
     return [`active: ${activeAgent.label}`, ...statuses.map((status) => formatAgentStatusLine(status, status.id === activeAgent.id))]
         .join("\n");
@@ -614,32 +643,48 @@ function buildStudioHeaderContent(workspace, packState) {
     return ` {bold}SRGICAL STUDIO{/bold}   ${workspaceName}   ${packLabel}`;
 }
 function formatPlanningPackSummary(workspace, packState) {
+    const planId = packState.planId ?? "default";
+    const readinessScore = packState.readiness?.score ?? 0;
+    const readinessTotal = packState.readiness?.total ?? 4;
+    const docsPresent = packState.docsPresent ?? (packState.packPresent ? 4 : 0);
     const lines = [
         `state: ${describePlanningPackState(packState)}`,
-        `dir: ${(0, workspace_1.getPlanningPackPaths)(workspace).dir}`
+        `plan: ${planId}`,
+        `dir: ${(0, workspace_1.getPlanningPackPaths)(workspace, { planId }).relativeDir}`,
+        `docs: ${docsPresent}/4`,
+        `readiness: ${readinessScore}/${readinessTotal}`
     ];
-    if (!packState.packPresent) {
-        lines.push("next: /write will put the plan on disk");
+    const mode = deriveDisplayMode(packState);
+    const readyToWrite = packState.readiness?.readyToWrite ?? false;
+    if (mode === "Gathering Context" || mode === "Ready to Write") {
+        lines.push(readyToWrite ? "next: /write will create or refresh the planning doc set" : "next: keep gathering context or run /readiness");
     }
-    else if (packState.trackerReadable) {
-        lines.push(packState.currentPosition.nextRecommended ? "next: /preview or /run when ready" : "next: plan is written; queue more work when ready");
+    else if (mode === "Ready to Execute" || mode === "Execution Active" || mode === "Auto Running") {
+        lines.push("next: /preview, /run, or /auto when ready");
+    }
+    else if (!packState.packPresent) {
+        lines.push("next: /plan new <id> or /write to create the planning doc set");
     }
     else {
-        lines.push("next: rewrite or repair the pack before running");
+        lines.push("next: add or queue the next execution-ready step");
     }
     return lines.join("\n");
 }
 function renderWorkspaceSelectionMessage(workspace, packState) {
+    const planId = packState.planId ?? "default";
     return [
         "Planning view:",
         `- workspace: ${workspace}`,
-        `- planning dir: ${(0, workspace_1.getPlanningPackPaths)(workspace).dir}`,
+        `- active plan: ${planId}`,
+        `- planning dir: ${(0, workspace_1.getPlanningPackPaths)(workspace, { planId }).relativeDir}`,
         `- plan status: ${describePlanningPackState(packState)}`,
+        `- readiness: ${packState.readiness.score}/${packState.readiness.total}`,
         "",
         "Use `/workspace <path>` to switch repos.",
-        !packState.packPresent
+        "Use `/plans` to inspect plan directories and `/plan <id>` to switch plans.",
+        !packState.packPresent || packState.mode === "Gathering Context" || packState.mode === "Ready to Write"
             ? "Use `/write` when you want to put the current plan on disk."
-            : "Use `/write` when you want to refresh the plan on disk from this transcript."
+            : "Use `/write` when you want to refresh the selected plan from this transcript."
     ].join("\n");
 }
 function renderAgentSelectionMessage(activeAgent, statuses) {
@@ -698,20 +743,111 @@ function isDefaultStudioSession(messages) {
             message.content === studio_session_1.DEFAULT_STUDIO_MESSAGES[index]?.content));
 }
 function describePlanningPackState(packState) {
+    return `${deriveDisplayMode(packState).toLowerCase()}${packState.hasFailureOverlay ? " (last run failed)" : ""}`;
+}
+function formatPlanningPackPill(packState) {
+    const planId = packState.planId ?? "default";
+    const mode = deriveDisplayMode(packState);
+    if (mode === "Auto Running") {
+        return `{#4de2c5-fg}PLAN ${planId.toUpperCase()} | AUTO RUNNING{/}`;
+    }
     if (!packState.packPresent) {
-        return "not written yet";
+        return `{#ffb14a-fg}PLAN ${planId.toUpperCase()} | NO PACK{/}`;
     }
-    if (!packState.trackerReadable) {
-        return "written but needs attention";
+    if (packState.hasFailureOverlay) {
+        return `{#ff7a59-fg}PLAN ${planId.toUpperCase()} | ${mode.toUpperCase()} | FAILED{/}`;
     }
-    return "written to disk";
+    if (mode === "Ready to Execute" || mode === "Execution Active") {
+        return `{#4de2c5-fg}PLAN ${planId.toUpperCase()} | ${mode.toUpperCase()}{/}`;
+    }
+    return `{#ffb14a-fg}PLAN ${planId.toUpperCase()} | ${mode.toUpperCase()}{/}`;
 }
-function formatPlanningPackPill(packState) {
+function deriveDisplayMode(packState) {
+    if (packState.mode) {
+        return packState.mode;
+    }
     if (!packState.packPresent) {
-        return "{#ffb14a-fg}PLAN NOT WRITTEN{/}";
+        return "No Pack";
+    }
+    if (packState.currentPosition?.nextRecommended) {
+        return "Execution Active";
+    }
+    return packState.trackerReadable ? "Plan Written - Needs Step" : "Gathering Context";
+}
+function configureComposer(input) {
+    const internals = input;
+    const originalListener = internals._listener;
+    if (!originalListener) {
+        return;
     }
-    if (!packState.trackerReadable) {
-        return "{#ff7a59-fg}PACK NEEDS ATTENTION{/}";
+    internals._listener = function patchedListener(ch, key) {
+        if (key.name === "enter" && !key.shift && !key.meta && !key.ctrl) {
+            if (typeof internals._done === "function") {
+                internals._done(null, internals.value ?? "");
+            }
+            return;
+        }
+        if ((key.name === "enter" && (key.shift || key.meta)) || (key.ctrl && key.name === "j")) {
+            originalListener.call(this, "\n", { ...key, name: "enter" });
+            return;
+        }
+        originalListener.call(this, ch, key);
+    };
+}
+function renderStatusMessage(workspace, packState) {
+    return [
+        `Plan: ${packState.planId}`,
+        `Planning dir: ${(0, workspace_1.getPlanningPackPaths)(workspace, { planId: packState.planId }).relativeDir}`,
+        `Mode: ${packState.mode}${packState.hasFailureOverlay ? " [last run failed]" : ""}`,
+        `Docs: ${packState.docsPresent}/4`,
+        `Readiness: ${packState.readiness.score}/${packState.readiness.total}${packState.readiness.readyToWrite ? " (ready to write)" : ""}`,
+        `Execution activated: ${packState.executionActivated ? "yes" : "no"}`,
+        `Auto mode: ${packState.autoRun?.status ?? "idle"}`,
+        `Next step: ${packState.nextStepSummary?.id ?? packState.currentPosition.nextRecommended ?? "none queued"}`
+    ].join("\n");
+}
+function renderReadinessMessage(packState) {
+    return [
+        `Readiness for plan \`${packState.planId}\`: ${packState.readiness.score}/${packState.readiness.total}${packState.readiness.readyToWrite ? " (ready to write)" : ""}`,
+        "",
+        ...packState.readiness.checks.map((check) => `- ${check.passed ? "[x]" : "[ ]"} ${check.label}`),
+        "",
+        packState.readiness.missingLabels.length > 0
+            ? `Missing: ${packState.readiness.missingLabels.join(", ")}`
+            : "Missing: none",
+        packState.readiness.readyToWrite
+            ? "Next: run `/write` to create or refresh the planning doc set."
+            : "Next: keep gathering repo truth, constraints, and the first execution slice."
+    ].join("\n");
+}
+function renderPlanUsageMessage(currentPlanId, paths) {
+    return [
+        `Current plan: ${currentPlanId}`,
+        `Planning dir: ${paths.relativeDir}`,
+        "",
+        "Commands:",
+        "- `/plans` lists available plans",
+        "- `/plan <id>` switches the active plan",
+        "- `/plan new <id>` creates a named plan scaffold"
+    ].join("\n");
+}
+async function renderPlansMessage(workspace, currentPlanId) {
+    const refs = await (0, workspace_1.listPlanningDirectories)(workspace);
+    if (refs.length === 0) {
+        return "No planning packs exist yet.\nUse `/plan new <id>` or `/write` to create one.";
     }
-    return "{#4de2c5-fg}PLAN WRITTEN{/}";
+    const states = await Promise.all(refs.map((ref) => (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId: ref.planId })));
+    return [
+        "Plans:",
+        ...states.map((state) => `- ${state.planId}${state.planId === currentPlanId ? " [active]" : ""}: ${state.packDir} | ${state.mode} | docs ${state.docsPresent}/4 | readiness ${state.readiness.score}/${state.readiness.total} | auto ${state.autoRun?.status ?? "idle"}`)
+    ].join("\n");
+}
+async function createPlanScaffold(workspace, requestedPlanId) {
+    const planId = (0, workspace_1.normalizePlanId)(requestedPlanId);
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspace, { planId });
+    const templates = (0, templates_1.getInitialTemplates)(paths);
+    await Promise.all(Object.entries(templates).map(([filePath, content]) => (0, workspace_1.writeText)(filePath, content)));
+    await (0, planning_state_1.savePlanningState)(workspace, "scaffolded", { planId });
+    await (0, workspace_1.saveActivePlanId)(workspace, planId);
+    return paths;
 }