@launch11/srgical 0.0.4 → 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/package-info.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readInstalledPackageInfo = readInstalledPackageInfo;
+exports.readLocalChangelog = readLocalChangelog;
+exports.isPlaceholderChangelog = isPlaceholderChangelog;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function readInstalledPackageInfo() {
+    const packageRoot = resolvePackageRoot();
+    const packageJsonPath = node_path_1.default.join(packageRoot, "package.json");
+    const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+    const repositoryUrl = normalizeRepositoryUrl(packageJson.repository);
+    const releasesUrl = repositoryUrl ? `${repositoryUrl}/releases` : undefined;
+    const version = packageJson.version ?? "0.0.0";
+    return {
+        packageRoot,
+        name: packageJson.name ?? "srgical",
+        version,
+        description: packageJson.description ?? "Local-first AI planning and execution orchestration.",
+        homepage: packageJson.homepage,
+        repositoryUrl,
+        issuesUrl: packageJson.bugs?.url,
+        releasesUrl,
+        releaseNotesUrl: releasesUrl ? `${releasesUrl}/tag/v${version}` : undefined,
+        changelogPath: node_path_1.default.join(packageRoot, "CHANGELOG.md")
+    };
+}
+function readLocalChangelog() {
+    const info = readInstalledPackageInfo();
+    try {
+        return (0, node_fs_1.readFileSync)(info.changelogPath, "utf8").trim();
+    }
+    catch {
+        return null;
+    }
+}
+function isPlaceholderChangelog(content) {
+    if (!content) {
+        return true;
+    }
+    const normalized = content.replace(/\r\n/g, "\n").trim();
+    return (normalized ===
+        "# Changelog\n\nRelease history is tracked through git tags, GitHub Releases, GitHub Packages, and npm.\n\nThe repo keeps a base version line in `package.json`, and CI computes the next patch version at release time.");
+}
+function resolvePackageRoot() {
+    return node_path_1.default.resolve(__dirname, "..", "..");
+}
+function normalizeRepositoryUrl(repository) {
+    const raw = typeof repository === "string"
+        ? repository
+        : repository && typeof repository === "object"
+            ? repository.url
+            : undefined;
+    if (!raw) {
+        return undefined;
+    }
+    return raw.replace(/^git\+/, "").replace(/\.git$/, "");
+}

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
     ];