@launch11/srgical 0.0.5 → 0.0.6

package/dist/core/auto-run.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeAutoRun = executeAutoRun;
+exports.requestAutoRunStop = requestAutoRunStop;
+const execution_state_1 = require("./execution-state");
+const execution_controls_1 = require("./execution-controls");
+const planning_pack_state_1 = require("./planning-pack-state");
+const auto_run_state_1 = require("./auto-run-state");
+const workspace_1 = require("./workspace");
+const agent_1 = require("./agent");
+const DEFAULT_AUTO_MAX_STEPS = 10;
+async function executeAutoRun(workspaceRoot, options) {
+    const planOptions = { planId: options.planId };
+    const initialState = await (0, planning_pack_state_1.readPlanningPackState)(workspaceRoot, planOptions);
+    assertAutoRunnable(initialState);
+    const maxSteps = sanitizeMaxSteps(options.maxSteps);
+    let autoRunState = await (0, auto_run_state_1.updateAutoRunState)(workspaceRoot, {
+        status: "running",
+        startedAt: new Date().toISOString(),
+        endedAt: null,
+        source: options.source,
+        maxSteps,
+        stepsAttempted: 0,
+        lastStartedStepId: initialState.currentPosition.nextRecommended,
+        lastObservedNextStepId: initialState.currentPosition.nextRecommended,
+        stopReason: null
+    }, planOptions);
+    await emit(options, `Auto mode started for plan \`${initialState.planId}\` with max ${maxSteps} step${maxSteps === 1 ? "" : "s"}.`);
+    for (let iteration = 0; iteration < maxSteps; iteration += 1) {
+        const requestedStopState = await (0, auto_run_state_1.loadAutoRunState)(workspaceRoot, planOptions);
+        if (requestedStopState?.status === "stop_requested") {
+            autoRunState = await finalizeAutoRun(workspaceRoot, "stopped", "Stop requested by user.", options, {
+                stepsAttempted: iteration
+            });
+            return {
+                finalState: autoRunState,
+                summary: autoRunState.stopReason ?? "Auto run stopped."
+            };
+        }
+        const beforeState = await (0, planning_pack_state_1.readPlanningPackState)(workspaceRoot, planOptions);
+        const naturalStop = describeNaturalStop(beforeState, iteration, maxSteps);
+        if (naturalStop) {
+            autoRunState = await finalizeAutoRun(workspaceRoot, naturalStop.status, naturalStop.reason, options, {
+                stepsAttempted: iteration,
+                lastObservedNextStepId: beforeState.currentPosition.nextRecommended
+            });
+            return {
+                finalState: autoRunState,
+                summary: naturalStop.reason
+            };
+        }
+        const stepLabel = (0, execution_controls_1.formatStepLabel)(beforeState.nextStepSummary, beforeState.currentPosition.nextRecommended) ?? "unknown step";
+        await emit(options, `Auto iteration ${iteration + 1}/${maxSteps}: ${stepLabel}`);
+        autoRunState = await (0, auto_run_state_1.updateAutoRunState)(workspaceRoot, {
+            status: "running",
+            source: options.source,
+            maxSteps,
+            stepsAttempted: iteration + 1,
+            lastStartedStepId: beforeState.currentPosition.nextRecommended,
+            lastObservedNextStepId: beforeState.currentPosition.nextRecommended,
+            stopReason: null
+        }, planOptions);
+        const iterationResult = await executeIteration(workspaceRoot, beforeState, options);
+        if (!iterationResult.success) {
+            autoRunState = await finalizeAutoRun(workspaceRoot, "failed", iterationResult.summary, options, {
+                stepsAttempted: iteration + 1,
+                lastStartedStepId: beforeState.currentPosition.nextRecommended,
+                lastObservedNextStepId: iterationResult.afterState.currentPosition.nextRecommended
+            });
+            return {
+                finalState: autoRunState,
+                summary: iterationResult.summary
+            };
+        }
+        await emit(options, iterationResult.summary);
+    }
+    autoRunState = await finalizeAutoRun(workspaceRoot, "stopped", `Reached the auto-run step cap (${maxSteps}).`, options, { stepsAttempted: maxSteps });
+    return {
+        finalState: autoRunState,
+        summary: autoRunState.stopReason ?? `Reached the auto-run step cap (${maxSteps}).`
+    };
+}
+async function requestAutoRunStop(workspaceRoot, options = {}) {
+    const current = await (0, auto_run_state_1.loadAutoRunState)(workspaceRoot, options);
+    const status = current?.status === "running" ? "stop_requested" : "stopped";
+    return (0, auto_run_state_1.updateAutoRunState)(workspaceRoot, {
+        status,
+        stopReason: status === "stop_requested" ? "Stop requested by user." : "No active auto run was in progress."
+    }, options);
+}
+function sanitizeMaxSteps(value) {
+    if (!value || !Number.isFinite(value) || value < 1) {
+        return DEFAULT_AUTO_MAX_STEPS;
+    }
+    return Math.floor(value);
+}
+function assertAutoRunnable(state) {
+    if (!state.packPresent) {
+        throw new Error("Auto mode requires an existing planning pack.");
+    }
+    if (state.packMode !== "authored") {
+        throw new Error("Auto mode only runs authored plans. Finish planning and `/write` the pack first.");
+    }
+    if (!(0, planning_pack_state_1.isExecutionReadyState)(state)) {
+        throw new Error("Auto mode requires a queued execution step in the selected plan.");
+    }
+}
+function describeNaturalStop(state, iteration, maxSteps) {
+    if (!state.currentPosition.nextRecommended) {
+        return {
+            status: "completed",
+            reason: "Auto mode completed because no next recommended step remains."
+        };
+    }
+    if (!state.nextStepSummary) {
+        return {
+            status: "failed",
+            reason: `Auto mode stopped because the tracker could not summarize \`${state.currentPosition.nextRecommended}\`.`
+        };
+    }
+    if (state.nextStepSummary.status.toLowerCase() === "blocked") {
+        return {
+            status: "failed",
+            reason: `Auto mode stopped because ${state.nextStepSummary.id} is blocked.`
+        };
+    }
+    if (!(0, planning_pack_state_1.isExecutionReadyState)(state)) {
+        return {
+            status: "stopped",
+            reason: `Auto mode stopped because ${state.nextStepSummary.id} is outside execution scope.`
+        };
+    }
+    if (iteration >= maxSteps) {
+        return {
+            status: "stopped",
+            reason: `Reached the auto-run step cap (${maxSteps}).`
+        };
+    }
+    return null;
+}
+async function executeIteration(workspaceRoot, beforeState, options) {
+    const planOptions = { planId: options.planId };
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot, planOptions);
+    const prompt = await (0, workspace_1.readText)(paths.nextPrompt);
+    const targetStepId = beforeState.currentPosition.nextRecommended;
+    const stepLabel = (0, execution_controls_1.formatStepLabel)(beforeState.nextStepSummary, beforeState.currentPosition.nextRecommended);
+    let firstAttempt;
+    try {
+        const result = await (0, agent_1.runNextPrompt)(workspaceRoot, prompt, {
+            agentId: options.agentId,
+            planId: beforeState.planId
+        });
+        firstAttempt = { ok: true, message: result };
+    }
+    catch (error) {
+        firstAttempt = { ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+    const firstAfterState = await (0, planning_pack_state_1.readPlanningPackState)(workspaceRoot, planOptions);
+    const firstReconciled = hasTrackerAdvanced(beforeState, firstAfterState, targetStepId);
+    if (firstReconciled) {
+        const summary = firstAttempt.ok
+            ? firstAttempt.message
+            : `Reconciled success after an execution error because the tracker advanced for ${targetStepId ?? "the active step"}.`;
+        await (0, execution_state_1.saveExecutionState)(workspaceRoot, "success", options.source, summary, planOptions);
+        await (0, execution_state_1.appendExecutionLog)(workspaceRoot, "success", options.source, summary, {
+            planId: beforeState.planId,
+            stepLabel
+        });
+        return {
+            success: true,
+            summary: `Completed ${stepLabel ?? targetStepId ?? "the current step"} and advanced the tracker.`,
+            afterState: firstAfterState
+        };
+    }
+    await emit(options, `No tracker advancement detected for ${stepLabel ?? targetStepId ?? "the current step"}; retrying once.`);
+    try {
+        const retryResult = await (0, agent_1.runNextPrompt)(workspaceRoot, prompt, {
+            agentId: options.agentId,
+            planId: beforeState.planId
+        });
+        const retryAfterState = await (0, planning_pack_state_1.readPlanningPackState)(workspaceRoot, planOptions);
+        if (hasTrackerAdvanced(beforeState, retryAfterState, targetStepId)) {
+            await (0, execution_state_1.saveExecutionState)(workspaceRoot, "success", options.source, retryResult, planOptions);
+            await (0, execution_state_1.appendExecutionLog)(workspaceRoot, "success", options.source, retryResult, {
+                planId: beforeState.planId,
+                stepLabel
+            });
+            return {
+                success: true,
+                summary: `Completed ${stepLabel ?? targetStepId ?? "the current step"} after one reconciliation retry.`,
+                afterState: retryAfterState
+            };
+        }
+        const failureSummary = `Auto mode failed because ${targetStepId ?? "the current step"} did not advance after one retry.`;
+        await (0, execution_state_1.saveExecutionState)(workspaceRoot, "failure", options.source, failureSummary, planOptions);
+        await (0, execution_state_1.appendExecutionLog)(workspaceRoot, "failure", options.source, failureSummary, {
+            planId: beforeState.planId,
+            stepLabel
+        });
+        return {
+            success: false,
+            summary: failureSummary,
+            afterState: retryAfterState
+        };
+    }
+    catch (error) {
+        const retryAfterState = await (0, planning_pack_state_1.readPlanningPackState)(workspaceRoot, planOptions);
+        if (hasTrackerAdvanced(beforeState, retryAfterState, targetStepId)) {
+            const summary = `Reconciled success after a retry failure because the tracker advanced for ${targetStepId ?? "the active step"}.`;
+            await (0, execution_state_1.saveExecutionState)(workspaceRoot, "success", options.source, summary, planOptions);
+            await (0, execution_state_1.appendExecutionLog)(workspaceRoot, "success", options.source, summary, {
+                planId: beforeState.planId,
+                stepLabel
+            });
+            return {
+                success: true,
+                summary: `Completed ${stepLabel ?? targetStepId ?? "the current step"} after reconciliation.`,
+                afterState: retryAfterState
+            };
+        }
+        const failureSummary = `Auto mode failed because ${targetStepId ?? "the current step"} did not advance after one retry. Reason: ${error instanceof Error ? error.message : String(error)}`;
+        await (0, execution_state_1.saveExecutionState)(workspaceRoot, "failure", options.source, failureSummary, planOptions);
+        await (0, execution_state_1.appendExecutionLog)(workspaceRoot, "failure", options.source, failureSummary, {
+            planId: beforeState.planId,
+            stepLabel
+        });
+        return {
+            success: false,
+            summary: failureSummary,
+            afterState: retryAfterState
+        };
+    }
+}
+function hasTrackerAdvanced(beforeState, afterState, targetStepId) {
+    if (!targetStepId) {
+        return false;
+    }
+    if (afterState.currentPosition.nextRecommended && afterState.currentPosition.nextRecommended !== targetStepId) {
+        return true;
+    }
+    if (afterState.currentPosition.lastCompleted === targetStepId) {
+        return true;
+    }
+    if (afterState.nextStepSummary && afterState.nextStepSummary.id === targetStepId) {
+        const status = afterState.nextStepSummary.status.toLowerCase();
+        if (status === "done" || status === "skipped") {
+            return true;
+        }
+    }
+    return false;
+}
+async function finalizeAutoRun(workspaceRoot, status, reason, options, updates = {}) {
+    const nextState = await (0, auto_run_state_1.updateAutoRunState)(workspaceRoot, {
+        ...updates,
+        status,
+        endedAt: new Date().toISOString(),
+        stopReason: reason
+    }, { planId: options.planId });
+    await (0, execution_state_1.appendExecutionLog)(workspaceRoot, status === "failed" ? "failure" : "success", options.source, reason, {
+        planId: nextState.planId,
+        stepLabel: "auto-run summary"
+    });
+    await emit(options, reason);
+    return nextState;
+}
+async function emit(options, line) {
+    if (options.onMessage) {
+        await options.onMessage(line);
+    }
+}

package/dist/core/claude.js

@@ -40,7 +40,7 @@ async function detectClaude() {
         };
     }
 }
-async function requestPlannerReply(workspaceRoot, messages) {
+async function requestPlannerReply(workspaceRoot, messages, _options = {}) {
     const result = await runClaudeExec({
         cwd: workspaceRoot,
         prompt: (0, prompts_1.buildPlannerPrompt)(messages, workspaceRoot),
@@ -49,16 +49,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 claudeStatus = await detectClaude();
     if (!claudeStatus.available) {
-        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, claudeStatus.error ?? "Claude Code CLI is unavailable", "Claude Code"));
+        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, claudeStatus.error ?? "Claude Code CLI is unavailable", "Claude Code", options));
     }
     try {
         const result = await runClaudeExec({
             cwd: workspaceRoot,
-            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot),
+            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot, options),
             permissionMode: "acceptEdits",
             allowedTools: CLAUDE_WRITE_ALLOW_TOOLS,
             maxTurns: 24
@@ -68,7 +68,7 @@ async function writePlanningPack(workspaceRoot, messages) {
     catch (error) {
         if (isClaudeUnavailableError(error)) {
             const message = error instanceof Error ? error.message : "Claude Code CLI is unavailable";
-            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Claude Code"));
+            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Claude Code", options));
         }
         const message = error instanceof Error ? error.message : String(error);
         const epochSummary = (0, planning_epochs_1.formatPlanningEpochSummary)(planningEpoch);
@@ -78,7 +78,7 @@ async function writePlanningPack(workspaceRoot, messages) {
         throw error;
     }
 }
-async function runNextPrompt(workspaceRoot, prompt) {
+async function runNextPrompt(workspaceRoot, prompt, _options = {}) {
     const result = await runClaudeExec({
         cwd: workspaceRoot,
         prompt,

package/dist/core/codex.js

@@ -37,7 +37,7 @@ async function detectCodex() {
         };
     }
 }
-async function requestPlannerReply(workspaceRoot, messages) {
+async function requestPlannerReply(workspaceRoot, messages, _options = {}) {
     const result = await runCodexExec({
         cwd: workspaceRoot,
         prompt: (0, prompts_1.buildPlannerPrompt)(messages, workspaceRoot),
@@ -47,16 +47,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 codexStatus = await detectCodex();
     if (!codexStatus.available) {
-        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, codexStatus.error ?? "Codex is unavailable", "Codex"));
+        return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, codexStatus.error ?? "Codex is unavailable", "Codex", options));
     }
     try {
         const result = await runCodexExec({
             cwd: workspaceRoot,
-            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot),
+            prompt: await (0, prompts_1.buildPackWriterPrompt)(messages, workspaceRoot, options),
             allowWrite: true,
             skipGitRepoCheck: true,
             ephemeral: false
@@ -66,7 +66,7 @@ async function writePlanningPack(workspaceRoot, messages) {
     catch (error) {
         if (isCodexUnavailableError(error)) {
             const message = error instanceof Error ? error.message : "Codex is unavailable";
-            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Codex"));
+            return appendPlanningEpochSummary(planningEpoch, await (0, local_pack_1.writePlanningPackFallback)(workspaceRoot, messages, message, "Codex", options));
         }
         const message = error instanceof Error ? error.message : String(error);
         const epochSummary = (0, planning_epochs_1.formatPlanningEpochSummary)(planningEpoch);
@@ -76,7 +76,7 @@ async function writePlanningPack(workspaceRoot, messages) {
         throw error;
     }
 }
-async function runNextPrompt(workspaceRoot, prompt) {
+async function runNextPrompt(workspaceRoot, prompt, _options = {}) {
     const result = await runCodexExec({
         cwd: workspaceRoot,
         prompt,

package/dist/core/execution-state.js

@@ -5,8 +5,8 @@ exports.saveExecutionState = saveExecutionState;
 exports.appendExecutionLog = appendExecutionLog;
 const promises_1 = require("node:fs/promises");
 const workspace_1 = require("./workspace");
-async function loadExecutionState(workspaceRoot) {
-    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot);
+async function loadExecutionState(workspaceRoot, options = {}) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot, options);
     const exists = await (0, workspace_1.fileExists)(paths.executionState);
     if (!exists) {
         return null;
@@ -33,8 +33,8 @@ async function loadExecutionState(workspaceRoot) {
         return null;
     }
 }
-async function saveExecutionState(workspaceRoot, status, source, summary) {
-    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot);
+async function saveExecutionState(workspaceRoot, status, source, summary, options = {}) {
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot, options);
     const payload = {
         version: 1,
         updatedAt: new Date().toISOString(),
@@ -45,7 +45,7 @@ async function saveExecutionState(workspaceRoot, status, source, summary) {
     await (0, workspace_1.writeText)(paths.executionState, JSON.stringify(payload, null, 2));
 }
 async function appendExecutionLog(workspaceRoot, status, source, summary, options = {}) {
-    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot);
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot, options);
     const entry = buildExecutionLogEntry(status, source, summary, options);
     const exists = await (0, workspace_1.fileExists)(paths.executionLog);
     if (!exists) {

package/dist/core/local-pack.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writePlanningPackFallback = writePlanningPackFallback;
+const planning_state_1 = require("./planning-state");
 const templates_1 = require("./templates");
 const workspace_1 = require("./workspace");
-async function writePlanningPackFallback(workspaceRoot, messages, reason, agentLabel = "Codex") {
-    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot);
+async function writePlanningPackFallback(workspaceRoot, messages, reason, agentLabel = "Codex", options = {}) {
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot, options);
     const templates = (0, templates_1.getInitialTemplates)(paths);
     const createdFiles = [];
     const preservedFiles = [];
@@ -30,6 +31,7 @@ async function writePlanningPackFallback(workspaceRoot, messages, reason, agentL
             ? `Tracker remains on next recommended step: ${currentPosition.nextRecommended}`
             : "Tracker next step is not yet available."
     ];
+    await (0, planning_state_1.ensurePlanningPackState)(workspaceRoot, "scaffolded", options);
     return summary.join("\n");
 }
 function buildFallbackEntry(messages, reason, createdFiles, preservedFiles, currentPosition, agentLabel) {
@@ -106,17 +108,18 @@ function appendFallbackEntry(context, entry) {
     return `${context.trimEnd()}\n\n## Handoff Log\n\n${entry}\n`;
 }
 function toPackLabel(paths, filePath) {
+    const prefix = `${paths.relativeDir}/`;
     if (filePath === paths.plan) {
-        return ".srgical/01-product-plan.md";
+        return `${prefix}01-product-plan.md`;
     }
     if (filePath === paths.context) {
-        return ".srgical/02-agent-context-kickoff.md";
+        return `${prefix}02-agent-context-kickoff.md`;
     }
     if (filePath === paths.tracker) {
-        return ".srgical/03-detailed-implementation-plan.md";
+        return `${prefix}03-detailed-implementation-plan.md`;
     }
     if (filePath === paths.nextPrompt) {
-        return ".srgical/04-next-agent-prompt.md";
+        return `${prefix}04-next-agent-prompt.md`;
     }
     return filePath;
 }

package/dist/core/planning-epochs.js

@@ -10,6 +10,7 @@ exports.listArchivedPackFileNames = listArchivedPackFileNames;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const planning_pack_state_1 = require("./planning-pack-state");
+const planning_state_1 = require("./planning-state");
 const templates_1 = require("./templates");
 const workspace_1 = require("./workspace");
 const ARCHIVED_PACK_FILE_NAMES = [
@@ -18,11 +19,13 @@ const ARCHIVED_PACK_FILE_NAMES = [
     "03-detailed-implementation-plan.md",
     "04-next-agent-prompt.md",
     "studio-session.json",
+    "planning-state.json",
+    "auto-run-state.json",
     "execution-state.json",
     "execution-log.md"
 ];
-async function preparePlanningPackForWrite(workspaceRoot) {
-    const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspaceRoot);
+async function preparePlanningPackForWrite(workspaceRoot, options = {}) {
+    const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspaceRoot, options);
     if (!packState.packPresent || packState.currentPosition.nextRecommended) {
         return {
             archived: false,
@@ -30,7 +33,7 @@ async function preparePlanningPackForWrite(workspaceRoot) {
             archivedFiles: []
         };
     }
-    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot);
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot, options);
     const archiveDirName = await nextPlanningEpochName(paths.dir);
     const archiveDir = node_path_1.default.join(paths.dir, archiveDirName);
     await (0, promises_1.mkdir)(archiveDir, { recursive: false });
@@ -69,7 +72,9 @@ async function archiveActivePlanningFiles(paths, archiveDir) {
 async function resetActivePlanningPack(paths) {
     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)(paths.root, "scaffolded", { planId: paths.planId });
     await Promise.all([
+        (0, promises_1.rm)(paths.autoRunState, { force: true }),
         (0, promises_1.rm)(paths.executionState, { force: true }),
         (0, promises_1.rm)(paths.executionLog, { force: true })
     ]);
@@ -81,6 +86,8 @@ function listArchivablePaths(paths) {
         paths.tracker,
         paths.nextPrompt,
         paths.studioSession,
+        paths.planningState,
+        paths.autoRunState,
         paths.executionState,
         paths.executionLog
     ];

package/dist/core/planning-pack-state.js

@@ -1,17 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readPlanningPackState = readPlanningPackState;
+exports.isExecutionStepSummary = isExecutionStepSummary;
+exports.isExecutionReadyState = isExecutionReadyState;
+const auto_run_state_1 = require("./auto-run-state");
 const execution_state_1 = require("./execution-state");
+const planning_state_1 = require("./planning-state");
+const studio_session_1 = require("./studio-session");
 const workspace_1 = require("./workspace");
-const workspace_2 = require("./workspace");
-async function readPlanningPackState(workspaceRoot) {
-    const packPresent = await (0, workspace_1.planningPackExists)(workspaceRoot);
+async function readPlanningPackState(workspaceRoot, options = {}) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot, options);
+    const packPresent = await (0, workspace_1.planningPackExists)(workspaceRoot, options);
     const currentPosition = emptyCurrentPosition();
     let nextStepSummary = null;
     let trackerReadable = false;
     if (packPresent) {
         try {
-            const tracker = await (0, workspace_1.readText)((0, workspace_2.getPlanningPackPaths)(workspaceRoot).tracker);
+            const tracker = await (0, workspace_1.readText)(paths.tracker);
             Object.assign(currentPosition, parseCurrentPosition(tracker));
             nextStepSummary = parseNextStepSummary(tracker, currentPosition.nextRecommended);
             trackerReadable = currentPosition.lastCompleted !== null || currentPosition.nextRecommended !== null;
@@ -20,25 +25,132 @@ async function readPlanningPackState(workspaceRoot) {
             trackerReadable = false;
         }
     }
-    const lastExecution = await (0, execution_state_1.loadExecutionState)(workspaceRoot);
+    const [lastExecution, planningState, autoRun, docsPresent, studioSession] = await Promise.all([
+        (0, execution_state_1.loadExecutionState)(workspaceRoot, options),
+        (0, planning_state_1.loadPlanningState)(workspaceRoot, options),
+        (0, auto_run_state_1.loadAutoRunState)(workspaceRoot, options),
+        countPresentDocs(paths),
+        (0, studio_session_1.loadStudioSessionState)(workspaceRoot, options)
+    ]);
+    const readiness = buildReadiness(studioSession.messages, nextStepSummary);
+    const packMode = planningState?.packMode ?? (0, planning_state_1.inferLegacyPackMode)(currentPosition);
+    const executionActivated = Boolean(lastExecution ||
+        (autoRun && autoRun.status !== "idle") ||
+        (isExecutionStepSummary(nextStepSummary) && currentPosition.lastCompleted !== "PLAN-001"));
+    const mode = derivePlanningMode({
+        packPresent,
+        packMode,
+        readiness,
+        nextStepSummary,
+        autoRun,
+        executionActivated
+    });
     return {
+        planId: paths.planId,
+        packDir: paths.relativeDir,
         packPresent,
         trackerReadable,
+        docsPresent,
         currentPosition,
         nextStepSummary,
-        lastExecution
+        lastExecution,
+        planningState,
+        packMode,
+        readiness,
+        autoRun,
+        executionActivated,
+        mode,
+        hasFailureOverlay: lastExecution?.status === "failure"
     };
 }
+function isExecutionStepSummary(step) {
+    if (!step) {
+        return false;
+    }
+    const phase = step.phase?.toLowerCase() ?? "";
+    return phase.includes("delivery") || phase.includes("execution") || /^exec[-\d]/i.test(step.id);
+}
+function isExecutionReadyState(state) {
+    return state.packPresent && state.packMode === "authored" && isExecutionStepSummary(state.nextStepSummary);
+}
+function derivePlanningMode(input) {
+    if (!input.packPresent) {
+        return "No Pack";
+    }
+    if (input.autoRun?.status === "running" || input.autoRun?.status === "stop_requested") {
+        return "Auto Running";
+    }
+    if (input.packMode === "scaffolded") {
+        return input.readiness.readyToWrite ? "Ready to Write" : "Gathering Context";
+    }
+    if (!isExecutionStepSummary(input.nextStepSummary)) {
+        return "Plan Written - Needs Step";
+    }
+    return input.executionActivated ? "Execution Active" : "Ready to Execute";
+}
+function buildReadiness(messages, nextStepSummary) {
+    const meaningfulMessages = messages.filter((message) => message.content.trim().length > 0);
+    const userMessages = meaningfulMessages.filter((message) => message.role === "user");
+    const assistantMessages = meaningfulMessages.filter((message) => message.role === "assistant" &&
+        !studio_session_1.DEFAULT_STUDIO_MESSAGES.some((defaultMessage) => defaultMessage.content === message.content));
+    const transcript = meaningfulMessages.map((message) => message.content.toLowerCase()).join("\n");
+    const checks = [
+        {
+            id: "goal",
+            label: "Goal captured",
+            passed: userMessages.length > 0
+        },
+        {
+            id: "repo",
+            label: "Repo context captured",
+            passed: /repo|current|existing|already|codebase|today|currently|workspace/.test(transcript)
+        },
+        {
+            id: "constraints",
+            label: "Constraints or decisions captured",
+            passed: /constraint|must|should|can't|cannot|need|require|locked|decision|prefer|non-negotiable/.test(transcript)
+        },
+        {
+            id: "execution",
+            label: "First executable slice captured",
+            passed: isExecutionStepSummary(nextStepSummary) || /step|slice|execute|execution|implement|delivery|tracker/.test(transcript)
+        }
+    ];
+    const score = checks.filter((check) => check.passed).length;
+    const readyToWrite = score >= 3 && userMessages.length > 0 && assistantMessages.length > 0;
+    return {
+        checks,
+        score,
+        total: checks.length,
+        readyToWrite,
+        missingLabels: checks.filter((check) => !check.passed).map((check) => check.label)
+    };
+}
+async function countPresentDocs(paths) {
+    const checks = await Promise.all([
+        (0, workspace_1.fileExists)(paths.plan),
+        (0, workspace_1.fileExists)(paths.context),
+        (0, workspace_1.fileExists)(paths.tracker),
+        (0, workspace_1.fileExists)(paths.nextPrompt)
+    ]);
+    return checks.filter(Boolean).length;
+}
 function parseCurrentPosition(tracker) {
     return {
         lastCompleted: readCurrentPositionValue(tracker, "Last Completed"),
-        nextRecommended: readCurrentPositionValue(tracker, "Next Recommended"),
+        nextRecommended: normalizeStepReference(readCurrentPositionValue(tracker, "Next Recommended")),
         updatedAt: readCurrentPositionValue(tracker, "Updated At")
     };
 }
 function readCurrentPositionValue(tracker, label) {
-    const match = tracker.match(new RegExp(`- ${escapeRegExp(label)}: \`([^\`]+)\``));
-    return match?.[1] ?? null;
+    const match = tracker.match(new RegExp(`- ${escapeRegExp(label)}: (?:\\\`([^\\\`]+)\\\`|([^\\n]+))`));
+    return match?.[1]?.trim() ?? match?.[2]?.trim() ?? null;
+}
+function normalizeStepReference(value) {
+    if (!value) {
+        return null;
+    }
+    return value.toLowerCase() === "none queued" ? null : value;
 }
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");