@launch11/srgical 0.0.4 → 0.0.6

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, "\\$&");

package/dist/core/planning-state.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPlanningState = loadPlanningState;
+exports.savePlanningState = savePlanningState;
+exports.markPlanningPackAuthored = markPlanningPackAuthored;
+exports.ensurePlanningPackState = ensurePlanningPackState;
+exports.inferLegacyPackMode = inferLegacyPackMode;
+const workspace_1 = require("./workspace");
+async function loadPlanningState(workspaceRoot, options = {}) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot, options);
+    if (!(await (0, workspace_1.fileExists)(paths.planningState))) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(await (0, workspace_1.readText)(paths.planningState));
+        if (parsed.version !== 1 ||
+            typeof parsed.planId !== "string" ||
+            typeof parsed.createdAt !== "string" ||
+            typeof parsed.updatedAt !== "string" ||
+            (parsed.packMode !== "scaffolded" && parsed.packMode !== "authored")) {
+            return null;
+        }
+        return {
+            version: 1,
+            planId: parsed.planId,
+            createdAt: parsed.createdAt,
+            updatedAt: parsed.updatedAt,
+            packMode: parsed.packMode
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function savePlanningState(workspaceRoot, packMode, options = {}) {
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot, options);
+    const existing = await loadPlanningState(workspaceRoot, options);
+    const now = new Date().toISOString();
+    const state = {
+        version: 1,
+        planId: paths.planId,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        packMode
+    };
+    await (0, workspace_1.writeText)(paths.planningState, JSON.stringify(state, null, 2));
+    return state;
+}
+async function markPlanningPackAuthored(workspaceRoot, options = {}) {
+    return savePlanningState(workspaceRoot, "authored", options);
+}
+async function ensurePlanningPackState(workspaceRoot, packMode, options = {}) {
+    const existing = await loadPlanningState(workspaceRoot, options);
+    if (existing) {
+        return existing;
+    }
+    return savePlanningState(workspaceRoot, packMode, options);
+}
+function inferLegacyPackMode(position) {
+    return position.lastCompleted === "BOOT-001" && position.nextRecommended === "PLAN-001" ? "scaffolded" : "authored";
+}

package/dist/core/prompts.js

@@ -38,8 +38,8 @@ ${renderTranscript(messages)}
 
 Respond as the planning partner.`;
 }
-async function buildPackWriterPrompt(messages, workspaceRoot) {
-    const repoTruth = await buildRepoTruthSnapshot(workspaceRoot);
+async function buildPackWriterPrompt(messages, workspaceRoot, options = {}) {
+    const repoTruth = await buildRepoTruthSnapshot(workspaceRoot, options);
     return `You are writing a planning pack for the current repository.
 
 Read the conversation transcript below and update or create the following files under .srgical/:
@@ -74,8 +74,8 @@ Conversation transcript:
 ${renderTranscript(messages)}
 `;
 }
-async function buildRepoTruthSnapshot(workspaceRoot) {
-    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot);
+async function buildRepoTruthSnapshot(workspaceRoot, options = {}) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot, options);
     const [packageSummary, topLevelEntries, sourceFiles, docFiles, readmeSnippet, foundationSnippet, adrSnippet, planSnippet, contextSnippet, trackerSnippet, nextPromptSnippet] = await Promise.all([
         summarizePackageManifest(workspaceRoot),
         listDirectoryEntries(workspaceRoot),

package/dist/core/studio-session.js

@@ -13,11 +13,11 @@ exports.DEFAULT_STUDIO_MESSAGES = [
         content: "Describe what you are building, what is already true in the repo, or the next decision you need to make. I will help turn it into a disciplined `.srgical/` execution pack, and `/write` will update the repo files when you are ready."
     }
 ];
-async function loadStudioSession(workspaceRoot) {
-    return (await loadStudioSessionState(workspaceRoot)).messages;
+async function loadStudioSession(workspaceRoot, options = {}) {
+    return (await loadStudioSessionState(workspaceRoot, options)).messages;
 }
-async function loadStudioSessionState(workspaceRoot) {
-    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot);
+async function loadStudioSessionState(workspaceRoot, options = {}) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot, options);
     const exists = await (0, workspace_1.fileExists)(paths.studioSession);
     if (!exists) {
         return createDefaultSessionState();
@@ -35,25 +35,25 @@ async function loadStudioSessionState(workspaceRoot) {
         return createDefaultSessionState();
     }
 }
-async function saveStudioSession(workspaceRoot, messages) {
-    const currentState = await loadStudioSessionState(workspaceRoot);
+async function saveStudioSession(workspaceRoot, messages, options = {}) {
+    const currentState = await loadStudioSessionState(workspaceRoot, options);
     await writeStudioSession(workspaceRoot, {
         messages,
         activeAgentId: currentState.activeAgentId
-    });
+    }, options);
 }
-async function loadStoredActiveAgentId(workspaceRoot) {
-    return (await loadStudioSessionState(workspaceRoot)).activeAgentId;
+async function loadStoredActiveAgentId(workspaceRoot, options = {}) {
+    return (await loadStudioSessionState(workspaceRoot, options)).activeAgentId;
 }
-async function saveStoredActiveAgentId(workspaceRoot, activeAgentId) {
-    const currentState = await loadStudioSessionState(workspaceRoot);
+async function saveStoredActiveAgentId(workspaceRoot, activeAgentId, options = {}) {
+    const currentState = await loadStudioSessionState(workspaceRoot, options);
     await writeStudioSession(workspaceRoot, {
         messages: currentState.messages,
         activeAgentId
-    });
+    }, options);
 }
-async function writeStudioSession(workspaceRoot, state) {
-    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot);
+async function writeStudioSession(workspaceRoot, state, options = {}) {
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot, options);
     const payload = {
         version: 2,
         updatedAt: new Date().toISOString(),

package/dist/core/templates.js

@@ -56,7 +56,8 @@ Define and ship a local-first CLI that helps a user:
 - the UI feels like a sharp creative control room
 `;
 }
-function buildContextTemplate() {
+function buildContextTemplate(paths) {
+    const planDir = `\`${paths.relativeDir}/\``;
     return `# Agent Context Kickoff
 
 Updated: ${new Date().toISOString()}
@@ -64,7 +65,7 @@ Updated By: srgical
 
 ## Mission
 
-Continue the current project from the planning pack in \`.srgical/\`. Read the stable plan, the tracker, and the next
+Continue the current project from the planning pack in ${planDir}. Read the stable plan, the tracker, and the next
 agent prompt before making changes.
 
 ## Working Agreements
@@ -86,6 +87,7 @@ agent prompt before making changes.
 ### ${new Date().toISOString().slice(0, 10)} - BOOT-001 - srgical
 
 - Created the initial \`.srgical/\` planning pack.
+- Active planning directory: \`${paths.relativeDir}\`.
 - Validation: confirmed the four planning-pack files were written.
 - Blockers: none.
 - Next recommended work: \`PLAN-001\`.
@@ -138,7 +140,8 @@ Updated By: srgical
 | EXEC-001 | pending | PLAN-001 | Execute the next eligible implementation slice from the tracker. | The selected slice is complete, validated, and logged. | Pending tracker detail. |
 `;
 }
-function buildNextPromptTemplate() {
+function buildNextPromptTemplate(paths) {
+    const planDir = paths.relativeDir;
     return `# Next Agent Prompt
 
 You are continuing the current project from the existing repo state. Do not restart product design or casually rewrite
@@ -146,9 +149,9 @@ the whole codebase.
 
 ## Read Order
 
-1. Read \`.srgical/02-agent-context-kickoff.md\`.
-2. Read \`.srgical/01-product-plan.md\`.
-3. Read \`.srgical/03-detailed-implementation-plan.md\`.
+1. Read \`${planDir}/02-agent-context-kickoff.md\`.
+2. Read \`${planDir}/01-product-plan.md\`.
+3. Read \`${planDir}/03-detailed-implementation-plan.md\`.
 4. Execute only the next eligible step block.
 
 ## What To Determine Before Editing
@@ -167,10 +170,10 @@ the whole codebase.
 
 ## Required Updates After Execution
 
-1. Update \`.srgical/03-detailed-implementation-plan.md\`.
+1. Update \`${planDir}/03-detailed-implementation-plan.md\`.
 2. Mark finished steps \`done\` only if validation passed.
 3. Update the \`Current Position\` section.
-4. Append a dated handoff entry to \`.srgical/02-agent-context-kickoff.md\`.
+4. Append a dated handoff entry to \`${planDir}/02-agent-context-kickoff.md\`.
 
 ## Stop Conditions
 
@@ -182,8 +185,8 @@ the whole codebase.
 function getInitialTemplates(paths) {
     return {
         [paths.plan]: buildPlanTemplate(paths.root),
-        [paths.context]: buildContextTemplate(),
+        [paths.context]: buildContextTemplate(paths),
         [paths.tracker]: buildTrackerTemplate(),
-        [paths.nextPrompt]: buildNextPromptTemplate()
+        [paths.nextPrompt]: buildNextPromptTemplate(paths)
     };
 }

package/dist/core/workspace.js

@@ -3,40 +3,78 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLAN_DIR = void 0;
+exports.ACTIVE_PLAN_FILE = exports.NAMED_PLANS_DIR = exports.DEFAULT_PLAN_ID = exports.PLAN_DIR = void 0;
 exports.resolveWorkspace = resolveWorkspace;
+exports.normalizePlanId = normalizePlanId;
+exports.getPlanningRoot = getPlanningRoot;
 exports.getPlanningPackPaths = getPlanningPackPaths;
 exports.ensurePlanningDir = ensurePlanningDir;
+exports.ensurePlanningRoot = ensurePlanningRoot;
 exports.fileExists = fileExists;
 exports.planningPackExists = planningPackExists;
+exports.listPlanningDirectories = listPlanningDirectories;
+exports.readActivePlanId = readActivePlanId;
+exports.saveActivePlanId = saveActivePlanId;
+exports.resolvePlanId = resolvePlanId;
 exports.readText = readText;
 exports.writeText = writeText;
 exports.isGitRepo = isGitRepo;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 exports.PLAN_DIR = ".srgical";
+exports.DEFAULT_PLAN_ID = "default";
+exports.NAMED_PLANS_DIR = "plans";
+exports.ACTIVE_PLAN_FILE = "active-plan.txt";
 function resolveWorkspace(input) {
     return node_path_1.default.resolve(input ?? process.cwd());
 }
-function getPlanningPackPaths(root) {
-    const dir = node_path_1.default.join(root, exports.PLAN_DIR);
+function normalizePlanId(value) {
+    const normalized = (value ?? exports.DEFAULT_PLAN_ID)
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return normalized.length > 0 ? normalized : exports.DEFAULT_PLAN_ID;
+}
+function getPlanningRoot(root) {
+    return node_path_1.default.join(root, exports.PLAN_DIR);
+}
+function getPlanningPackPaths(root, options = {}) {
+    const planningRoot = getPlanningRoot(root);
+    const planId = normalizePlanId(options.planId);
+    const isDefaultPlan = planId === exports.DEFAULT_PLAN_ID;
+    const dir = isDefaultPlan ? planningRoot : node_path_1.default.join(planningRoot, exports.NAMED_PLANS_DIR, planId);
+    const relativeDir = node_path_1.default.relative(root, dir).replace(/\\/g, "/") || exports.PLAN_DIR;
     return {
         root,
+        planningRoot,
+        planId,
+        isDefaultPlan,
         dir,
+        relativeDir,
         plan: node_path_1.default.join(dir, "01-product-plan.md"),
         context: node_path_1.default.join(dir, "02-agent-context-kickoff.md"),
         tracker: node_path_1.default.join(dir, "03-detailed-implementation-plan.md"),
         nextPrompt: node_path_1.default.join(dir, "04-next-agent-prompt.md"),
         studioSession: node_path_1.default.join(dir, "studio-session.json"),
         executionState: node_path_1.default.join(dir, "execution-state.json"),
-        executionLog: node_path_1.default.join(dir, "execution-log.md")
+        executionLog: node_path_1.default.join(dir, "execution-log.md"),
+        planningState: node_path_1.default.join(dir, "planning-state.json"),
+        autoRunState: node_path_1.default.join(dir, "auto-run-state.json"),
+        activePlanFile: node_path_1.default.join(planningRoot, exports.ACTIVE_PLAN_FILE)
     };
 }
-async function ensurePlanningDir(root) {
-    const paths = getPlanningPackPaths(root);
+async function ensurePlanningDir(root, options = {}) {
+    const paths = getPlanningPackPaths(root, options);
+    await (0, promises_1.mkdir)(paths.planningRoot, { recursive: true });
     await (0, promises_1.mkdir)(paths.dir, { recursive: true });
     return paths;
 }
+async function ensurePlanningRoot(root) {
+    const planningRoot = getPlanningRoot(root);
+    await (0, promises_1.mkdir)(planningRoot, { recursive: true });
+    return planningRoot;
+}
 async function fileExists(filePath) {
     try {
         await (0, promises_1.access)(filePath);
@@ -46,8 +84,8 @@ async function fileExists(filePath) {
         return false;
     }
 }
-async function planningPackExists(root) {
-    const paths = getPlanningPackPaths(root);
+async function planningPackExists(root, options = {}) {
+    const paths = getPlanningPackPaths(root, options);
     const checks = await Promise.all([
         fileExists(paths.plan),
         fileExists(paths.context),
@@ -56,6 +94,72 @@ async function planningPackExists(root) {
     ]);
     return checks.every(Boolean);
 }
+async function listPlanningDirectories(root) {
+    const planningRoot = getPlanningRoot(root);
+    const namedPlansRoot = node_path_1.default.join(planningRoot, exports.NAMED_PLANS_DIR);
+    const planIds = new Set();
+    if (await hasDefaultPlanPresence(root)) {
+        planIds.add(exports.DEFAULT_PLAN_ID);
+    }
+    try {
+        const entries = await (0, promises_1.readdir)(namedPlansRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            planIds.add(normalizePlanId(entry.name));
+        }
+    }
+    catch {
+        // ignore missing named-plan directory
+    }
+    const activePlanId = await readActivePlanId(root);
+    if (activePlanId) {
+        planIds.add(activePlanId);
+    }
+    return Array.from(planIds)
+        .sort((left, right) => {
+        if (left === exports.DEFAULT_PLAN_ID) {
+            return -1;
+        }
+        if (right === exports.DEFAULT_PLAN_ID) {
+            return 1;
+        }
+        return left.localeCompare(right);
+    })
+        .map((planId) => {
+        const paths = getPlanningPackPaths(root, { planId });
+        return {
+            planId,
+            dir: paths.dir,
+            relativeDir: paths.relativeDir,
+            isDefaultPlan: paths.isDefaultPlan
+        };
+    });
+}
+async function readActivePlanId(root) {
+    const markerPath = getPlanningPackPaths(root).activePlanFile;
+    if (!(await fileExists(markerPath))) {
+        return null;
+    }
+    try {
+        return normalizePlanId(await readText(markerPath));
+    }
+    catch {
+        return null;
+    }
+}
+async function saveActivePlanId(root, planId) {
+    const normalizedPlanId = normalizePlanId(planId);
+    const planningRoot = await ensurePlanningRoot(root);
+    await writeText(node_path_1.default.join(planningRoot, exports.ACTIVE_PLAN_FILE), normalizedPlanId);
+}
+async function resolvePlanId(root, requestedPlanId) {
+    if (requestedPlanId && requestedPlanId.trim().length > 0) {
+        return normalizePlanId(requestedPlanId);
+    }
+    return (await readActivePlanId(root)) ?? exports.DEFAULT_PLAN_ID;
+}
 async function readText(filePath) {
     return (0, promises_1.readFile)(filePath, "utf8");
 }
@@ -65,3 +169,18 @@ async function writeText(filePath, content) {
 async function isGitRepo(root) {
     return fileExists(node_path_1.default.join(root, ".git"));
 }
+async function hasDefaultPlanPresence(root) {
+    const paths = getPlanningPackPaths(root, { planId: exports.DEFAULT_PLAN_ID });
+    const checks = await Promise.all([
+        fileExists(paths.plan),
+        fileExists(paths.context),
+        fileExists(paths.tracker),
+        fileExists(paths.nextPrompt),
+        fileExists(paths.studioSession),
+        fileExists(paths.executionState),
+        fileExists(paths.executionLog),
+        fileExists(paths.planningState),
+        fileExists(paths.autoRunState)
+    ]);
+    return checks.some(Boolean);
+}

package/dist/index.js

@@ -1,43 +1,67 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
 const commander_1 = require("commander");
+const about_1 = require("./commands/about");
+const changelog_1 = require("./commands/changelog");
 const doctor_1 = require("./commands/doctor");
 const init_1 = require("./commands/init");
 const run_next_1 = require("./commands/run-next");
 const studio_1 = require("./commands/studio");
+const version_1 = require("./commands/version");
+const package_info_1 = require("./core/package-info");
 const program = new commander_1.Command();
-const packageVersion = readPackageVersion();
+const packageInfo = (0, package_info_1.readInstalledPackageInfo)();
+if (isStandaloneVersionRequest(process.argv.slice(2))) {
+    (0, version_1.runVersionCommand)();
+    process.exit(0);
+}
 program
     .name("srgical")
     .description("Local-first AI planning and execution orchestration.")
-    .version(packageVersion);
+    .version(packageInfo.version, "-V, --version", "Show installed version and release info.");
+program
+    .command("version")
+    .description("Show installed version and release info.")
+    .action(() => {
+    (0, version_1.runVersionCommand)();
+});
+program
+    .command("about")
+    .description("Show package, release, and supported-agent information.")
+    .action(() => {
+    (0, about_1.runAboutCommand)();
+});
+program
+    .command("changelog")
+    .description("Show where to find upgrade notes for the installed version.")
+    .action(() => {
+    (0, changelog_1.runChangelogCommand)();
+});
 program
     .command("doctor")
     .description("Inspect the workspace and local agent availability.")
     .argument("[workspace]", "Workspace path")
-    .action(async (workspace) => {
-    await (0, doctor_1.runDoctorCommand)(workspace);
+    .option("--plan <id>", "Planning pack id to inspect")
+    .action(async (workspace, options) => {
+    await (0, doctor_1.runDoctorCommand)(workspace, { planId: options.plan });
 });
 program
     .command("init")
     .description("Create a local .srgical planning pack scaffold.")
     .argument("[workspace]", "Workspace path")
     .option("-f, --force", "Overwrite an existing planning pack")
+    .option("--plan <id>", "Named planning pack id to create or overwrite")
     .action(async (workspace, options) => {
-    await (0, init_1.runInitCommand)(workspace, Boolean(options.force));
+    await (0, init_1.runInitCommand)(workspace, Boolean(options.force), options.plan);
 });
 program
     .command("studio")
     .description("Open the planning studio.")
     .argument("[workspace]", "Workspace path")
-    .action(async (workspace) => {
-    await (0, studio_1.runStudioCommand)(workspace);
+    .option("--plan <id>", "Planning pack id to open")
+    .action(async (workspace, options) => {
+    await (0, studio_1.runStudioCommand)(workspace, { planId: options.plan });
 });
 program
     .command("run-next")
@@ -45,16 +69,23 @@ program
     .argument("[workspace]", "Workspace path")
     .option("--dry-run", "Preview the current execution prompt without invoking the active agent")
     .option("--agent <id>", "Temporarily override the active agent for this run only")
+    .option("--plan <id>", "Planning pack id to execute")
+    .option("--auto", "Continue executing eligible execution steps until a stop condition is reached")
+    .option("--max-steps <n>", "Maximum number of auto iterations to attempt", Number)
     .action(async (workspace, options) => {
-    await (0, run_next_1.runRunNextCommand)(workspace, { dryRun: Boolean(options.dryRun), agent: options.agent });
+    await (0, run_next_1.runRunNextCommand)(workspace, {
+        dryRun: Boolean(options.dryRun),
+        agent: options.agent,
+        planId: options.plan,
+        auto: Boolean(options.auto),
+        maxSteps: options.maxSteps
+    });
 });
 program.parseAsync(process.argv).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     process.stderr.write(`${message}\n`);
     process.exitCode = 1;
 });
-function readPackageVersion() {
-    const packageJsonPath = node_path_1.default.resolve(__dirname, "..", "package.json");
-    const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
-    return packageJson.version ?? "0.0.0";
+function isStandaloneVersionRequest(args) {
+    return args.length === 1 && (args[0] === "--version" || args[0] === "-V");
 }