@launch11/srgical 0.0.5 → 0.0.7

package/README.md

@@ -30,20 +30,20 @@ This repo currently ships the foundation for:
 - `srgical --version`
   Prints the installed version with release-note links instead of only echoing the semver.
 - `srgical doctor`
-  Reports whether the current workspace has a planning pack, which supported agent is active, and which supported
-  agents are available locally.
+  Reports the active plan, plan readiness, execution state, auto-run state, and which supported agents are available
+  locally.
 - `srgical about`
   Shows package details, release links, and the currently supported agent adapters.
 - `srgical changelog`
   Points straight at the installed version's release notes and the local packaged changelog.
 - `srgical init`
-  Creates a local `.srgical/` planning pack from built-in templates.
+  Creates a local `.srgical/` planning pack from built-in templates, with `--plan <id>` for named plans.
 - `srgical studio`
-  Opens a full-screen planning studio where you can plan against the repo, inspect supported tools with `/agents`,
-  switch the session agent with `/agent <id>`, and explicitly trigger pack writes or execution.
+  Opens a full-screen planning studio where you can switch between named plans, inspect readiness with `/readiness`,
+  inspect supported tools with `/agents`, and explicitly trigger pack writes, single-step execution, or `/auto`.
 - `srgical run-next`
-  Replays the generated next-agent prompt through the active agent, with `--dry-run` for safe preview and
-  `--agent <id>` for a one-run override that does not change the stored workspace choice.
+  Replays the generated next-agent prompt through the active agent, with `--plan <id>` for plan targeting,
+  `--dry-run` for safe preview, `--agent <id>` for a one-run override, and `--auto` for bounded multi-step execution.
 
 ## Supported Agents
 
@@ -148,8 +148,11 @@ node dist/index.js --version
 node dist/index.js about
 node dist/index.js doctor
 node dist/index.js changelog
+node dist/index.js init --plan release-readiness
+node dist/index.js studio --plan release-readiness
 node dist/index.js run-next --dry-run
 node dist/index.js run-next
+node dist/index.js run-next --auto --max-steps 10
 ```
 
 To override the active workspace agent for one execution only:
@@ -160,6 +163,15 @@ node dist/index.js run-next --agent claude
 node dist/index.js run-next --agent augment
 ```
 
+Inside the studio, the footer is intentionally minimal:
+
+- `PgUp/PgDn` scrolls the transcript
+- `/agents` chooses the current tool
+- `/help` shows the full command set
+
+The composer is now multiline with a minimum two-line visible input area. `Enter` sends, while `Shift+Enter`,
+`Alt+Enter`, or `Ctrl+J` inserts a newline when the terminal exposes those keys distinctly.
+
 ## Current Claude Caveat
 
 Claude support is real, but it is not treated as interchangeable with Codex. The current non-interactive Claude path

package/dist/commands/doctor.js

@@ -8,30 +8,43 @@ const node_process_1 = __importDefault(require("node:process"));
 const agent_1 = require("../core/agent");
 const planning_pack_state_1 = require("../core/planning-pack-state");
 const workspace_1 = require("../core/workspace");
-async function runDoctorCommand(workspaceArg) {
+async function runDoctorCommand(workspaceArg, options = {}) {
     const workspace = (0, workspace_1.resolveWorkspace)(workspaceArg);
-    const [resolvedAgent, packState, gitRepo] = await Promise.all([
-        (0, agent_1.resolvePrimaryAgent)(workspace),
-        (0, planning_pack_state_1.readPlanningPackState)(workspace),
-        (0, workspace_1.isGitRepo)(workspace)
+    const selectedPlanId = await (0, workspace_1.resolvePlanId)(workspace, options.planId);
+    const [resolvedAgent, gitRepo, planRefs, selectedPlanState] = await Promise.all([
+        (0, agent_1.resolvePrimaryAgent)(workspace, { planId: selectedPlanId }),
+        (0, workspace_1.isGitRepo)(workspace),
+        (0, workspace_1.listPlanningDirectories)(workspace),
+        (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId: selectedPlanId })
     ]);
     const { status: activeAgent, statuses } = resolvedAgent;
     const lines = [
         `Workspace: ${workspace}`,
         `Git repo: ${gitRepo ? "yes" : "no"}`,
-        `Planning pack: ${packState.packPresent ? "present" : "missing"}`,
+        `Active plan: ${selectedPlanId}`,
         `Active agent: ${activeAgent.label} (${activeAgent.id}) - ${formatAgentAvailability(activeAgent)}`,
         "",
         ...renderSupportedAgentLines(statuses, activeAgent.id),
+        "",
+        "Plans:"
     ];
-    if (packState.packPresent) {
-        lines.push("", ...renderNextStepLines(packState.nextStepSummary, packState.currentPosition.nextRecommended));
+    if (planRefs.length === 0) {
+        lines.push(`- ${workspace_1.DEFAULT_PLAN_ID}: no planning packs detected yet`);
+    }
+    else {
+        const planStates = await Promise.all(planRefs.map((ref) => (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId: ref.planId })));
+        for (const state of planStates) {
+            lines.push(renderPlanSummaryLine(state, state.planId === selectedPlanId));
+        }
     }
-    lines.push("", packState.packPresent
-        ? packState.nextStepSummary || packState.currentPosition.nextRecommended
-            ? "Next move: run `srgical studio` to refine the plan or `srgical run-next` to execute the next step."
-            : "Next move: run `srgical studio` to queue more work or update the tracker with a new recommended step."
-        : "Next move: run `srgical init` for a local scaffold or `srgical studio` to plan with the primary agent first.");
+    lines.push("", `Selected plan details (${selectedPlanId}):`, ...renderPlanDetailLines(selectedPlanState));
+    lines.push("", selectedPlanState.packPresent
+        ? selectedPlanState.mode === "Ready to Write" || selectedPlanState.mode === "Gathering Context"
+            ? "Next move: run `srgical studio` to refine the plan, check `/readiness`, and use `/write` when it is ready."
+            : selectedPlanState.mode === "Ready to Execute" || selectedPlanState.mode === "Execution Active" || selectedPlanState.mode === "Auto Running"
+                ? "Next move: run `srgical run-next --plan <id>` for one step or `srgical run-next --plan <id> --auto` to continue automatically."
+                : "Next move: run `srgical studio` to queue or refine the next execution-ready step."
+        : "Next move: run `srgical init --plan <id>` for a scaffold or `srgical studio --plan <id>` to start planning.");
     node_process_1.default.stdout.write(`${lines.join("\n")}\n`);
 }
 function renderSupportedAgentLines(statuses, activeAgentId) {
@@ -41,11 +54,45 @@ function renderSupportedAgentLines(statuses, activeAgentId) {
     }
     return lines;
 }
+function renderPlanSummaryLine(state, selected) {
+    return [
+        `- ${state.planId}${selected ? " [active]" : ""}:`,
+        `path ${state.packDir}`,
+        `mode ${state.mode}`,
+        `docs ${state.docsPresent}/4`,
+        `readiness ${state.readiness.score}/${state.readiness.total}`,
+        `execution ${state.executionActivated ? "started" : "not-started"}`,
+        `auto ${state.autoRun?.status ?? "idle"}`
+    ].join(" | ");
+}
 function formatAgentAvailability(status) {
     return status.available
         ? `available (${status.version ?? "version unknown"})`
         : `missing (${status.error ?? "unknown error"})`;
 }
+function renderPlanDetailLines(state) {
+    const lines = [
+        `Plan dir: ${state.packDir}`,
+        `Pack present: ${state.packPresent ? "yes" : "no"}`,
+        `Pack mode: ${state.packMode}`,
+        `Mode: ${state.mode}${state.hasFailureOverlay ? " [last run failed]" : ""}`,
+        `Docs present: ${state.docsPresent}/4`,
+        `Readiness: ${state.readiness.score}/${state.readiness.total}${state.readiness.readyToWrite ? " (ready to write)" : ""}`,
+        `Execution activated: ${state.executionActivated ? "yes" : "no"}`,
+        `Auto mode: ${state.autoRun?.status ?? "idle"}`
+    ];
+    if (state.readiness.missingLabels.length > 0) {
+        lines.push(`Missing readiness signals: ${state.readiness.missingLabels.join(", ")}`);
+    }
+    lines.push(...renderNextStepLines(state.nextStepSummary, state.currentPosition.nextRecommended));
+    if (state.lastExecution) {
+        lines.push(`Last run: ${state.lastExecution.status} via ${state.lastExecution.source} at ${state.lastExecution.updatedAt}`);
+    }
+    if (state.autoRun) {
+        lines.push(`Auto run detail: attempted ${state.autoRun.stepsAttempted}${state.autoRun.maxSteps ? `/${state.autoRun.maxSteps}` : ""}, stop reason ${state.autoRun.stopReason ?? "none"}`);
+    }
+    return lines;
+}
 function renderNextStepLines(nextStepSummary, nextRecommended) {
     if (!nextStepSummary) {
         return [

package/dist/commands/init.js

@@ -5,22 +5,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runInitCommand = runInitCommand;
 const node_process_1 = __importDefault(require("node:process"));
+const planning_state_1 = require("../core/planning-state");
 const templates_1 = require("../core/templates");
 const workspace_1 = require("../core/workspace");
-async function runInitCommand(workspaceArg, force = false) {
+async function runInitCommand(workspaceArg, force = false, planId) {
     const workspace = (0, workspace_1.resolveWorkspace)(workspaceArg);
-    const exists = await (0, workspace_1.planningPackExists)(workspace);
+    const exists = await (0, workspace_1.planningPackExists)(workspace, { planId });
     if (exists && !force) {
-        throw new Error("A .srgical planning pack already exists. Re-run with --force to overwrite it.");
+        throw new Error("A planning pack already exists for the selected plan. Re-run with --force to overwrite it.");
     }
-    const paths = await (0, workspace_1.ensurePlanningDir)(workspace);
+    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: paths.planId });
+    await (0, workspace_1.saveActivePlanId)(workspace, paths.planId);
     node_process_1.default.stdout.write([
-        `Created planning pack in ${paths.dir}`,
+        `Created planning pack for plan \`${paths.planId}\` in ${paths.dir}`,
         `- ${paths.plan}`,
         `- ${paths.context}`,
         `- ${paths.tracker}`,
-        `- ${paths.nextPrompt}`
+        `- ${paths.nextPrompt}`,
+        `Next: run \`srgical doctor --plan ${paths.planId}\` or open \`srgical studio --plan ${paths.planId}\`.`
     ].join("\n") + "\n");
 }

package/dist/commands/run-next.js

@@ -5,23 +5,53 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runRunNextCommand = runRunNextCommand;
 const node_process_1 = __importDefault(require("node:process"));
+const auto_run_1 = require("../core/auto-run");
 const agent_1 = require("../core/agent");
 const execution_state_1 = require("../core/execution-state");
 const execution_controls_1 = require("../core/execution-controls");
 const planning_pack_state_1 = require("../core/planning-pack-state");
 const workspace_1 = require("../core/workspace");
+const workspace_2 = require("../core/workspace");
 async function runRunNextCommand(workspaceArg, options = {}) {
-    const workspace = (0, workspace_1.resolveWorkspace)(workspaceArg);
-    const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspace);
+    const workspace = (0, workspace_2.resolveWorkspace)(workspaceArg);
+    const planId = await (0, workspace_1.resolvePlanId)(workspace, options.planId);
+    const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspace, { planId });
     if (!packState.packPresent) {
         throw new Error("No .srgical planning pack found. Run `srgical init` or `srgical studio` first.");
     }
+    if (options.auto && options.dryRun) {
+        throw new Error("`--auto` cannot be combined with `--dry-run`.");
+    }
     if (!options.dryRun && !(0, execution_controls_1.hasQueuedNextStep)(packState.currentPosition.nextRecommended)) {
         throw new Error((0, execution_controls_1.formatNoQueuedNextStepMessage)("run-next"));
     }
-    await (0, agent_1.resolveExecutionAgent)(workspace, options.agent);
-    const paths = (0, workspace_1.getPlanningPackPaths)(workspace);
-    const prompt = await (0, workspace_1.readText)(paths.nextPrompt);
+    await (0, agent_1.resolveExecutionAgent)(workspace, options.agent, { planId });
+    await (0, workspace_1.saveActivePlanId)(workspace, planId);
+    if (options.auto) {
+        const stopHandler = () => {
+            void (0, auto_run_1.requestAutoRunStop)(workspace, { planId });
+            node_process_1.default.stdout.write("Stop requested. Auto mode will finish the current iteration before stopping.\n");
+        };
+        node_process_1.default.once("SIGINT", stopHandler);
+        try {
+            const result = await (0, auto_run_1.executeAutoRun)(workspace, {
+                source: "run-next",
+                planId,
+                agentId: options.agent,
+                maxSteps: options.maxSteps,
+                onMessage: (line) => {
+                    node_process_1.default.stdout.write(`${line}\n`);
+                }
+            });
+            node_process_1.default.stdout.write(`${result.summary}\n`);
+            return;
+        }
+        finally {
+            node_process_1.default.removeListener("SIGINT", stopHandler);
+        }
+    }
+    const paths = (0, workspace_2.getPlanningPackPaths)(workspace, { planId });
+    const prompt = await (0, workspace_2.readText)(paths.nextPrompt);
     const previewLines = options.dryRun
         ? (0, execution_controls_1.renderDryRunPreview)(prompt, packState.nextStepSummary, packState.currentPosition.nextRecommended)
         : (0, execution_controls_1.renderExecutionStepLines)(packState.nextStepSummary, packState.currentPosition.nextRecommended);
@@ -35,18 +65,21 @@ async function runRunNextCommand(workspaceArg, options = {}) {
     node_process_1.default.stdout.write(`Running the current next-agent prompt through ${(0, agent_1.getPrimaryAgentAdapter)().label}...\n`);
     try {
         const result = await (0, agent_1.runNextPrompt)(workspace, prompt, {
-            agentId: options.agent
+            agentId: options.agent,
+            planId
         });
-        await (0, execution_state_1.saveExecutionState)(workspace, "success", "run-next", result);
+        await (0, execution_state_1.saveExecutionState)(workspace, "success", "run-next", result, { planId });
         await (0, execution_state_1.appendExecutionLog)(workspace, "success", "run-next", result, {
+            planId,
             stepLabel: (0, execution_controls_1.formatStepLabel)(packState.nextStepSummary, packState.currentPosition.nextRecommended)
         });
         node_process_1.default.stdout.write(`${result}\n`);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        await (0, execution_state_1.saveExecutionState)(workspace, "failure", "run-next", message);
+        await (0, execution_state_1.saveExecutionState)(workspace, "failure", "run-next", message, { planId });
         await (0, execution_state_1.appendExecutionLog)(workspace, "failure", "run-next", message, {
+            planId,
             stepLabel: (0, execution_controls_1.formatStepLabel)(packState.nextStepSummary, packState.currentPosition.nextRecommended)
         });
         throw new Error((0, execution_controls_1.formatExecutionFailureMessage)(message, packState.nextStepSummary, packState.currentPosition.nextRecommended, "run-next"));

package/dist/commands/studio.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runStudioCommand = runStudioCommand;
 const studio_1 = require("../ui/studio");
-async function runStudioCommand(workspaceArg) {
-    await (0, studio_1.launchStudio)({ workspace: workspaceArg });
+async function runStudioCommand(workspaceArg, options = {}) {
+    await (0, studio_1.launchStudio)({ workspace: workspaceArg, planId: options.planId });
 }

package/dist/core/agent.js

@@ -84,9 +84,9 @@ async function detectSupportedAgents(workspaceRoot) {
     syncPrimaryAgent((await resolvePrimaryAgentStatus(statuses, workspaceRoot)).id);
     return statuses;
 }
-async function resolvePrimaryAgent(workspaceRoot) {
+async function resolvePrimaryAgent(workspaceRoot, options = {}) {
     const statuses = await collectAgentStatuses();
-    const status = await resolvePrimaryAgentStatus(statuses, workspaceRoot);
+    const status = await resolvePrimaryAgentStatus(statuses, workspaceRoot, options);
     const adapter = getAgentAdapterById(status.id) ?? getSupportedAgentAdapters()[0];
     syncPrimaryAgent(adapter.id);
     return {
@@ -95,13 +95,13 @@ async function resolvePrimaryAgent(workspaceRoot) {
         statuses
     };
 }
-async function detectPrimaryAgent(workspaceRoot) {
-    return (await resolvePrimaryAgent(workspaceRoot)).status;
+async function detectPrimaryAgent(workspaceRoot, options = {}) {
+    return (await resolvePrimaryAgent(workspaceRoot, options)).status;
 }
-async function resolveExecutionAgent(workspaceRoot, overrideId) {
+async function resolveExecutionAgent(workspaceRoot, overrideId, options = {}) {
     const normalizedOverrideId = overrideId?.trim().toLowerCase();
     if (!normalizedOverrideId) {
-        return resolvePrimaryAgent(workspaceRoot);
+        return resolvePrimaryAgent(workspaceRoot, options);
     }
     const statuses = await collectAgentStatuses();
     const status = statuses.find((candidate) => candidate.id === normalizedOverrideId);
@@ -119,19 +119,19 @@ async function resolveExecutionAgent(workspaceRoot, overrideId) {
         statuses
     };
 }
-async function requestPlannerReply(workspaceRoot, messages) {
-    const { adapter } = await resolvePrimaryAgent(workspaceRoot);
-    return adapter.requestPlannerReply(workspaceRoot, messages);
+async function requestPlannerReply(workspaceRoot, messages, options = {}) {
+    const { adapter } = await resolvePrimaryAgent(workspaceRoot, options);
+    return adapter.requestPlannerReply(workspaceRoot, messages, options);
 }
-async function writePlanningPack(workspaceRoot, messages) {
-    const { adapter } = await resolvePrimaryAgent(workspaceRoot);
-    return adapter.writePlanningPack(workspaceRoot, messages);
+async function writePlanningPack(workspaceRoot, messages, options = {}) {
+    const { adapter } = await resolvePrimaryAgent(workspaceRoot, options);
+    return adapter.writePlanningPack(workspaceRoot, messages, options);
 }
 async function runNextPrompt(workspaceRoot, prompt, options = {}) {
-    const { adapter } = await resolveExecutionAgent(workspaceRoot, options.agentId);
-    return adapter.runNextPrompt(workspaceRoot, prompt);
+    const { adapter } = await resolveExecutionAgent(workspaceRoot, options.agentId, { planId: options.planId });
+    return adapter.runNextPrompt(workspaceRoot, prompt, { planId: options.planId });
 }
-async function selectPrimaryAgent(workspaceRoot, id) {
+async function selectPrimaryAgent(workspaceRoot, id, options = {}) {
     const normalizedId = id.trim().toLowerCase();
     const statuses = await collectAgentStatuses();
     const status = statuses.find((candidate) => candidate.id === normalizedId);
@@ -141,7 +141,7 @@ async function selectPrimaryAgent(workspaceRoot, id) {
     if (!status.available) {
         throw new Error(`Cannot activate ${status.label}: ${status.error ?? `${status.command} is not available`}.`);
     }
-    await (0, studio_session_1.saveStoredActiveAgentId)(workspaceRoot, status.id);
+    await (0, studio_session_1.saveStoredActiveAgentId)(workspaceRoot, status.id, options);
     const adapter = getAgentAdapterById(status.id) ?? getSupportedAgentAdapters()[0];
     syncPrimaryAgent(adapter.id);
     return {
@@ -161,15 +161,15 @@ function setAgentAdaptersForTesting(adapters) {
 async function collectAgentStatuses() {
     return Promise.all(getSupportedAgentAdapters().map((adapter) => adapter.detectStatus()));
 }
-async function resolvePrimaryAgentStatus(statuses, workspaceRoot) {
-    const storedId = workspaceRoot ? await (0, studio_session_1.loadStoredActiveAgentId)(workspaceRoot) : null;
+async function resolvePrimaryAgentStatus(statuses, workspaceRoot, options = {}) {
+    const storedId = workspaceRoot ? await (0, studio_session_1.loadStoredActiveAgentId)(workspaceRoot, options) : null;
     if (storedId) {
         const storedStatus = statuses.find((status) => status.id === storedId);
         if (storedStatus) {
             return storedStatus;
         }
         if (workspaceRoot) {
-            await (0, studio_session_1.saveStoredActiveAgentId)(workspaceRoot, null);
+            await (0, studio_session_1.saveStoredActiveAgentId)(workspaceRoot, null, options);
         }
     }
     return statuses.find((status) => status.available) ?? statuses[0];

package/dist/core/augment.js

@@ -46,7 +46,7 @@ async function detectAugment() {
         };
     }
 }
-async function requestPlannerReply(workspaceRoot, messages) {
+async function requestPlannerReply(workspaceRoot, messages, _options = {}) {
     const result = await runAugmentExec({
         cwd: workspaceRoot,
         prompt: (0, prompts_1.buildPlannerPrompt)(messages, workspaceRoot),
@@ -55,16 +55,16 @@ async function requestPlannerReply(workspaceRoot, messages) {
     });
     return result.lastMessage.trim();
 }
-async function writePlanningPack(workspaceRoot, messages) {
-    const planningEpoch = await (0, planning_epochs_1.preparePlanningPackForWrite)(workspaceRoot);
+async function writePlanningPack(workspaceRoot, messages, options = {}) {
+    const planningEpoch = await (0, planning_epochs_1.preparePlanningPackForWrite)(workspaceRoot, options);
     const augmentStatus = await detectAugment();
     if (!augmentStatus.available) {
-        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, augmentStatus.error ?? "Augment CLI is unavailable", "Augment CLI"));
+        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, augmentStatus.error ?? "Augment CLI is unavailable", "Augment CLI", options));
     }
     try {
         const result = await runAugmentExec({
             cwd: workspaceRoot,
-            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot),
+            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot, options),
             maxTurns: 24
         });
         return appendPlanningEpochSummary(planningEpoch, result.lastMessage.trim());
@@ -72,7 +72,7 @@ async function writePlanningPack(workspaceRoot, messages) {
     catch (error) {
         if (isAugmentUnavailableError(error)) {
             const message = error instanceof Error ? error.message : "Augment CLI is unavailable";
-            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Augment CLI"));
+            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Augment CLI", options));
         }
         const message = error instanceof Error ? error.message : String(error);
         const epochSummary = (0, planning_epochs_1.formatPlanningEpochSummary)(planningEpoch);
@@ -82,7 +82,7 @@ async function writePlanningPack(workspaceRoot, messages) {
         throw error;
     }
 }
-async function runNextPrompt(workspaceRoot, prompt) {
+async function runNextPrompt(workspaceRoot, prompt, _options = {}) {
     const result = await runAugmentExec({
         cwd: workspaceRoot,
         prompt,

package/dist/core/auto-run-state.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAutoRunState = loadAutoRunState;
+exports.saveAutoRunState = saveAutoRunState;
+exports.updateAutoRunState = updateAutoRunState;
+exports.createIdleAutoRunState = createIdleAutoRunState;
+const workspace_1 = require("./workspace");
+async function loadAutoRunState(workspaceRoot, options = {}) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot, options);
+    if (!(await (0, workspace_1.fileExists)(paths.autoRunState))) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(await (0, workspace_1.readText)(paths.autoRunState));
+        if (parsed.version !== 1 ||
+            typeof parsed.planId !== "string" ||
+            !isAutoRunStatus(parsed.status) ||
+            (parsed.startedAt !== null && typeof parsed.startedAt !== "string") ||
+            typeof parsed.updatedAt !== "string" ||
+            (parsed.endedAt !== null && typeof parsed.endedAt !== "string") ||
+            (parsed.source !== null && parsed.source !== "studio" && parsed.source !== "run-next") ||
+            (parsed.maxSteps !== null && typeof parsed.maxSteps !== "number") ||
+            typeof parsed.stepsAttempted !== "number" ||
+            (parsed.lastStartedStepId !== null && typeof parsed.lastStartedStepId !== "string") ||
+            (parsed.lastObservedNextStepId !== null && typeof parsed.lastObservedNextStepId !== "string") ||
+            (parsed.stopReason !== null && typeof parsed.stopReason !== "string")) {
+            return null;
+        }
+        return {
+            version: 1,
+            planId: parsed.planId,
+            status: parsed.status,
+            startedAt: parsed.startedAt,
+            updatedAt: parsed.updatedAt,
+            endedAt: parsed.endedAt,
+            source: parsed.source,
+            maxSteps: parsed.maxSteps,
+            stepsAttempted: parsed.stepsAttempted,
+            lastStartedStepId: parsed.lastStartedStepId,
+            lastObservedNextStepId: parsed.lastObservedNextStepId,
+            stopReason: parsed.stopReason
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function saveAutoRunState(workspaceRoot, state, options = {}) {
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot, options);
+    await (0, workspace_1.writeText)(paths.autoRunState, JSON.stringify(state, null, 2));
+    return state;
+}
+async function updateAutoRunState(workspaceRoot, updates, options = {}) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot, options);
+    const existing = (await loadAutoRunState(workspaceRoot, options)) ?? createIdleAutoRunState(paths.planId);
+    const nextState = {
+        ...existing,
+        ...updates,
+        version: 1,
+        planId: paths.planId,
+        updatedAt: new Date().toISOString()
+    };
+    await saveAutoRunState(workspaceRoot, nextState, options);
+    return nextState;
+}
+function createIdleAutoRunState(planId) {
+    return {
+        version: 1,
+        planId,
+        status: "idle",
+        startedAt: null,
+        updatedAt: new Date().toISOString(),
+        endedAt: null,
+        source: null,
+        maxSteps: null,
+        stepsAttempted: 0,
+        lastStartedStepId: null,
+        lastObservedNextStepId: null,
+        stopReason: null
+    };
+}
+function isAutoRunStatus(value) {
+    return (value === "idle" ||
+        value === "running" ||
+        value === "stop_requested" ||
+        value === "stopped" ||
+        value === "completed" ||
+        value === "failed");
+}