@launch11/srgical 0.0.1

package/dist/core/execution-state.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadExecutionState = loadExecutionState;
+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);
+    const exists = await (0, workspace_1.fileExists)(paths.executionState);
+    if (!exists) {
+        return null;
+    }
+    try {
+        const raw = await (0, workspace_1.readText)(paths.executionState);
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1 ||
+            (parsed.status !== "success" && parsed.status !== "failure") ||
+            (parsed.source !== "studio" && parsed.source !== "run-next") ||
+            typeof parsed.updatedAt !== "string" ||
+            typeof parsed.summary !== "string") {
+            return null;
+        }
+        return {
+            version: 1,
+            updatedAt: parsed.updatedAt,
+            status: parsed.status,
+            source: parsed.source,
+            summary: parsed.summary
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function saveExecutionState(workspaceRoot, status, source, summary) {
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot);
+    const payload = {
+        version: 1,
+        updatedAt: new Date().toISOString(),
+        status,
+        source,
+        summary: normalizeSummary(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 entry = buildExecutionLogEntry(status, source, summary, options);
+    const exists = await (0, workspace_1.fileExists)(paths.executionLog);
+    if (!exists) {
+        await (0, workspace_1.writeText)(paths.executionLog, buildExecutionLogHeader());
+    }
+    await (0, promises_1.appendFile)(paths.executionLog, entry, "utf8");
+}
+function normalizeSummary(summary) {
+    const compact = summary.replace(/\s+/g, " ").trim();
+    if (compact.length <= 180) {
+        return compact;
+    }
+    return `${compact.slice(0, 177)}...`;
+}
+function buildExecutionLogHeader() {
+    return [
+        "# Execution Log",
+        "",
+        "Durable execution history for `.srgical/` runs. Each entry records when a run happened, its final status, and a",
+        "concise summary for review and debugging.",
+        ""
+    ].join("\n");
+}
+function buildExecutionLogEntry(status, source, summary, options) {
+    const timestamp = new Date().toISOString();
+    const lines = [`## ${timestamp} - ${source} - ${status}`, ""];
+    if (options.stepLabel) {
+        lines.push(`- Step: ${options.stepLabel}`);
+    }
+    lines.push(`- Summary: ${normalizeLogSummary(summary)}`, "");
+    return `${lines.join("\n")}\n`;
+}
+function normalizeLogSummary(summary) {
+    const compact = summary.replace(/\s+/g, " ").trim();
+    if (compact.length <= 400) {
+        return compact;
+    }
+    return `${compact.slice(0, 397)}...`;
+}

package/dist/core/local-pack.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writePlanningPackFallback = writePlanningPackFallback;
+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);
+    const templates = (0, templates_1.getInitialTemplates)(paths);
+    const createdFiles = [];
+    const preservedFiles = [];
+    for (const [filePath, content] of Object.entries(templates)) {
+        const exists = await (0, workspace_1.fileExists)(filePath);
+        if (exists) {
+            preservedFiles.push(toPackLabel(paths, filePath));
+            continue;
+        }
+        await (0, workspace_1.writeText)(filePath, content);
+        createdFiles.push(toPackLabel(paths, filePath));
+    }
+    const currentPosition = await readCurrentPosition(paths.tracker);
+    const context = await (0, workspace_1.readText)(paths.context);
+    const updatedContext = appendFallbackEntry(context, buildFallbackEntry(messages, reason, createdFiles, preservedFiles, currentPosition, agentLabel));
+    await (0, workspace_1.writeText)(paths.context, updatedContext);
+    const summary = [
+        `Local fallback pack refresh completed because ${agentLabel} was unavailable.`,
+        `Reason: ${reason}`,
+        createdFiles.length > 0 ? `Created: ${createdFiles.join(", ")}` : "Created: none",
+        preservedFiles.length > 0 ? `Preserved: ${preservedFiles.join(", ")}` : "Preserved: none",
+        currentPosition.nextRecommended
+            ? `Tracker remains on next recommended step: ${currentPosition.nextRecommended}`
+            : "Tracker next step is not yet available."
+    ];
+    return summary.join("\n");
+}
+function buildFallbackEntry(messages, reason, createdFiles, preservedFiles, currentPosition, agentLabel) {
+    const now = new Date();
+    const transcriptSummary = summarizeRecentUserMessages(messages);
+    const nextRecommended = currentPosition.nextRecommended ?? "PLAN-001";
+    return [
+        `### ${now.toISOString().slice(0, 10)} - PACK-LOCAL - srgical`,
+        "",
+        `- Triggered an explicit local planning-pack refresh because ${agentLabel} was unavailable.`,
+        `- Reason: ${reason}.`,
+        createdFiles.length > 0
+            ? `- Created missing planning-pack files: ${createdFiles.join(", ")}.`
+            : "- Created missing planning-pack files: none.",
+        preservedFiles.length > 0
+            ? `- Preserved existing planning-pack files: ${preservedFiles.join(", ")}.`
+            : "- Preserved existing planning-pack files: none.",
+        transcriptSummary
+            ? `- Recent user direction: ${transcriptSummary}.`
+            : "- Recent user direction: no user transcript was available for summarization.",
+        `- Validation: local fallback pack refresh completed without invoking ${agentLabel}.`,
+        `- Blockers: live planner and live pack-authoring behavior remain unavailable until ${agentLabel} is restored.`,
+        `- Next recommended work: \`${nextRecommended}\`.`
+    ].join("\n");
+}
+async function readCurrentPosition(trackerPath) {
+    const exists = await (0, workspace_1.fileExists)(trackerPath);
+    if (!exists) {
+        return {
+            lastCompleted: null,
+            nextRecommended: null
+        };
+    }
+    try {
+        const tracker = await (0, workspace_1.readText)(trackerPath);
+        return {
+            lastCompleted: readCurrentPositionValue(tracker, "Last Completed"),
+            nextRecommended: readCurrentPositionValue(tracker, "Next Recommended")
+        };
+    }
+    catch {
+        return {
+            lastCompleted: null,
+            nextRecommended: null
+        };
+    }
+}
+function readCurrentPositionValue(tracker, label) {
+    const match = tracker.match(new RegExp(`- ${escapeRegExp(label)}: \`([^\`]+)\``));
+    return match?.[1] ?? null;
+}
+function summarizeRecentUserMessages(messages) {
+    const recent = messages
+        .filter((message) => message.role === "user")
+        .slice(-2)
+        .map((message) => sanitizeInlineText(message.content))
+        .filter(Boolean);
+    if (recent.length === 0) {
+        return "";
+    }
+    return recent.join(" | ");
+}
+function sanitizeInlineText(value) {
+    const collapsed = value.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= 180) {
+        return collapsed;
+    }
+    return `${collapsed.slice(0, 177).trimEnd()}...`;
+}
+function appendFallbackEntry(context, entry) {
+    if (context.includes("## Handoff Log")) {
+        return `${context.trimEnd()}\n\n${entry}\n`;
+    }
+    return `${context.trimEnd()}\n\n## Handoff Log\n\n${entry}\n`;
+}
+function toPackLabel(paths, filePath) {
+    if (filePath === paths.plan) {
+        return ".srgical/01-product-plan.md";
+    }
+    if (filePath === paths.context) {
+        return ".srgical/02-agent-context-kickoff.md";
+    }
+    if (filePath === paths.tracker) {
+        return ".srgical/03-detailed-implementation-plan.md";
+    }
+    if (filePath === paths.nextPrompt) {
+        return ".srgical/04-next-agent-prompt.md";
+    }
+    return filePath;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/core/planning-epochs.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePlanningPackForWrite = preparePlanningPackForWrite;
+exports.formatPlanningEpochSummary = formatPlanningEpochSummary;
+exports.isArchivedPlanningDirName = isArchivedPlanningDirName;
+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 templates_1 = require("./templates");
+const workspace_1 = require("./workspace");
+const ARCHIVED_PACK_FILE_NAMES = [
+    "01-product-plan.md",
+    "02-agent-context-kickoff.md",
+    "03-detailed-implementation-plan.md",
+    "04-next-agent-prompt.md",
+    "studio-session.json",
+    "execution-state.json",
+    "execution-log.md"
+];
+async function preparePlanningPackForWrite(workspaceRoot) {
+    const packState = await (0, planning_pack_state_1.readPlanningPackState)(workspaceRoot);
+    if (!packState.packPresent || packState.currentPosition.nextRecommended) {
+        return {
+            archived: false,
+            archiveDir: null,
+            archivedFiles: []
+        };
+    }
+    const paths = await (0, workspace_1.ensurePlanningDir)(workspaceRoot);
+    const archiveDirName = await nextPlanningEpochName(paths.dir);
+    const archiveDir = node_path_1.default.join(paths.dir, archiveDirName);
+    await (0, promises_1.mkdir)(archiveDir, { recursive: false });
+    const archivedFiles = await archiveActivePlanningFiles(paths, archiveDir);
+    await resetActivePlanningPack(paths);
+    return {
+        archived: archivedFiles.length > 0,
+        archiveDir: archivedFiles.length > 0 ? toRelativePackPath(workspaceRoot, archiveDir) : null,
+        archivedFiles
+    };
+}
+function formatPlanningEpochSummary(preparation) {
+    if (!preparation.archived || !preparation.archiveDir) {
+        return null;
+    }
+    return [
+        `Started a new planning epoch by archiving the previous active pack to ${preparation.archiveDir}.`,
+        preparation.archivedFiles.length > 0
+            ? `Archived files: ${preparation.archivedFiles.join(", ")}`
+            : "Archived files: none"
+    ].join("\n");
+}
+async function archiveActivePlanningFiles(paths, archiveDir) {
+    const archivedFiles = [];
+    for (const sourcePath of listArchivablePaths(paths)) {
+        if (!(await (0, workspace_1.fileExists)(sourcePath))) {
+            continue;
+        }
+        const content = await (0, workspace_1.readText)(sourcePath);
+        const fileName = node_path_1.default.basename(sourcePath);
+        await (0, workspace_1.writeText)(node_path_1.default.join(archiveDir, fileName), content);
+        archivedFiles.push(fileName);
+    }
+    return archivedFiles;
+}
+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 Promise.all([
+        (0, promises_1.rm)(paths.executionState, { force: true }),
+        (0, promises_1.rm)(paths.executionLog, { force: true })
+    ]);
+}
+function listArchivablePaths(paths) {
+    return [
+        paths.plan,
+        paths.context,
+        paths.tracker,
+        paths.nextPrompt,
+        paths.studioSession,
+        paths.executionState,
+        paths.executionLog
+    ];
+}
+async function nextPlanningEpochName(planningDir) {
+    let highest = 0;
+    try {
+        const entries = await (0, promises_1.readdir)(planningDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const match = /^planning-(\d+)$/.exec(entry.name);
+            if (!match) {
+                continue;
+            }
+            highest = Math.max(highest, Number(match[1]));
+        }
+    }
+    catch {
+        return "planning-1";
+    }
+    return `planning-${highest + 1}`;
+}
+function toRelativePackPath(workspaceRoot, value) {
+    return node_path_1.default.relative(workspaceRoot, value).replace(/\\/g, "/");
+}
+function isArchivedPlanningDirName(value) {
+    return /^planning-\d+$/.test(value);
+}
+function listArchivedPackFileNames() {
+    return [...ARCHIVED_PACK_FILE_NAMES];
+}

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPlanningPackState = readPlanningPackState;
+const execution_state_1 = require("./execution-state");
+const workspace_1 = require("./workspace");
+const workspace_2 = require("./workspace");
+async function readPlanningPackState(workspaceRoot) {
+    const packPresent = await (0, workspace_1.planningPackExists)(workspaceRoot);
+    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);
+            Object.assign(currentPosition, parseCurrentPosition(tracker));
+            nextStepSummary = parseNextStepSummary(tracker, currentPosition.nextRecommended);
+            trackerReadable = currentPosition.lastCompleted !== null || currentPosition.nextRecommended !== null;
+        }
+        catch {
+            trackerReadable = false;
+        }
+    }
+    const lastExecution = await (0, execution_state_1.loadExecutionState)(workspaceRoot);
+    return {
+        packPresent,
+        trackerReadable,
+        currentPosition,
+        nextStepSummary,
+        lastExecution
+    };
+}
+function parseCurrentPosition(tracker) {
+    return {
+        lastCompleted: readCurrentPositionValue(tracker, "Last Completed"),
+        nextRecommended: 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;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseNextStepSummary(tracker, stepId) {
+    if (!stepId) {
+        return null;
+    }
+    const rows = parseTrackerRows(tracker);
+    return rows.find((row) => row.id === stepId) ?? null;
+}
+function parseTrackerRows(tracker) {
+    const lines = tracker.split(/\r?\n/);
+    const rows = [];
+    let currentPhase = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index].trim();
+        if (line.startsWith("## ")) {
+            currentPhase = line.slice(3).trim();
+            continue;
+        }
+        if (!isTableRow(line) || index + 1 >= lines.length || !isTableSeparator(lines[index + 1].trim())) {
+            continue;
+        }
+        const headers = splitTableCells(line);
+        index += 2;
+        while (index < lines.length && isTableRow(lines[index].trim())) {
+            const cells = splitTableCells(lines[index].trim());
+            const row = buildTrackerRow(headers, cells, currentPhase);
+            if (row) {
+                rows.push(row);
+            }
+            index += 1;
+        }
+        index -= 1;
+    }
+    return rows;
+}
+function buildTrackerRow(headers, cells, phase) {
+    const values = new Map();
+    headers.forEach((header, index) => {
+        values.set(normalizeHeader(header), cells[index] ?? "");
+    });
+    const id = values.get("id") ?? "";
+    if (!id) {
+        return null;
+    }
+    return {
+        id,
+        status: values.get("status") ?? "",
+        dependsOn: values.get("depends_on") ?? "",
+        scope: values.get("scope") ?? "",
+        acceptance: values.get("acceptance") ?? "",
+        notes: values.get("notes") ?? "",
+        phase
+    };
+}
+function isTableRow(line) {
+    return line.startsWith("|") && line.endsWith("|");
+}
+function isTableSeparator(line) {
+    return /^\|(?:\s*:?-+:?\s*\|)+$/.test(line);
+}
+function splitTableCells(line) {
+    const trimmed = line.slice(1, -1);
+    return trimmed.split("|").map((cell) => cell.trim());
+}
+function normalizeHeader(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+function emptyCurrentPosition() {
+    return {
+        lastCompleted: null,
+        nextRecommended: null,
+        updatedAt: null
+    };
+}

package/dist/core/prompts.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlannerPrompt = buildPlannerPrompt;
+exports.buildPackWriterPrompt = buildPackWriterPrompt;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const workspace_1 = require("./workspace");
+const REPO_FILE_LIST_LIMIT = 24;
+const FILE_SNIPPET_LIMIT = 2200;
+function renderTranscript(messages) {
+    return messages
+        .map((message, index) => {
+        const label = message.role === "user" ? "User" : message.role === "assistant" ? "Planner" : "System";
+        return `${index + 1}. ${label}: ${message.content}`;
+    })
+        .join("\n\n");
+}
+function buildPlannerPrompt(messages, workspaceRoot) {
+    return `You are the planning partner inside srgical, a local-first CLI that helps users turn long AI-driven delivery
+projects into a disciplined execution pack.
+
+Your job in this mode is conversation only. Do not write files. Do not output markdown boilerplate. Help the user
+clarify the project and get it ready for pack generation.
+
+Rules:
+- Be concise, sharp, and practical.
+- Ask at most one clarifying question at a time.
+- Prefer decisions over brainstorming sprawl.
+- Optimize for shipping a concrete first version.
+- The current workspace is: ${workspaceRoot}
+
+Conversation so far:
+
+${renderTranscript(messages)}
+
+Respond as the planning partner.`;
+}
+async function buildPackWriterPrompt(messages, workspaceRoot) {
+    const repoTruth = await buildRepoTruthSnapshot(workspaceRoot);
+    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/:
+
+- 01-product-plan.md
+- 02-agent-context-kickoff.md
+- 03-detailed-implementation-plan.md
+- 04-next-agent-prompt.md
+
+Operating rules:
+- Start from the repo truth snapshot below, not from generic assumptions.
+- Treat any existing .srgical files as current project state to refine in place, not blank templates to overwrite casually.
+- Preserve valid locked decisions, completed steps, and step IDs unless the repo truth or conversation clearly requires a change.
+- Prefer repo truth for what already exists in the codebase and the conversation for what the user now wants next.
+- Make the pack specific to the actual commands, docs, stack, and current capabilities in this workspace.
+- Do not invent frameworks, release channels, adapters, tests, or subsystems that are not supported by the repo truth or transcript.
+- Keep the workflow local-first, explicit, incremental, and validation-aware.
+
+Quality bar:
+- 01-product-plan.md should capture the real product direction, locked decisions, and current repo findings.
+- 02-agent-context-kickoff.md should capture current repo truth, working agreements, current position, and a concise handoff log.
+- 03-detailed-implementation-plan.md should keep a readable status legend, current position, phase-based next steps, and concrete notes.
+- 04-next-agent-prompt.md should enforce incremental execution, validation, tracker updates, and stop conditions.
+- The tracker should stay execution-ready: use concrete step IDs, realistic acceptance criteria, and concise validation notes instead of filler.
+
+Repo truth snapshot:
+
+${repoTruth}
+
+Conversation transcript:
+
+${renderTranscript(messages)}
+`;
+}
+async function buildRepoTruthSnapshot(workspaceRoot) {
+    const paths = (0, workspace_1.getPlanningPackPaths)(workspaceRoot);
+    const [packageSummary, topLevelEntries, sourceFiles, docFiles, readmeSnippet, foundationSnippet, adrSnippet, planSnippet, contextSnippet, trackerSnippet, nextPromptSnippet] = await Promise.all([
+        summarizePackageManifest(workspaceRoot),
+        listDirectoryEntries(workspaceRoot),
+        listRelativeFiles(node_path_1.default.join(workspaceRoot, "src"), workspaceRoot, REPO_FILE_LIST_LIMIT),
+        listRelativeFiles(node_path_1.default.join(workspaceRoot, "docs"), workspaceRoot, REPO_FILE_LIST_LIMIT),
+        readSnippet(workspaceRoot, "README.md", FILE_SNIPPET_LIMIT),
+        readSnippet(workspaceRoot, "docs/product-foundation.md", FILE_SNIPPET_LIMIT),
+        readSnippet(workspaceRoot, "docs/adr/0001-tech-stack.md", FILE_SNIPPET_LIMIT),
+        readOptionalAbsoluteSnippet(paths.plan, workspaceRoot, FILE_SNIPPET_LIMIT),
+        readOptionalAbsoluteSnippet(paths.context, workspaceRoot, FILE_SNIPPET_LIMIT),
+        readOptionalAbsoluteSnippet(paths.tracker, workspaceRoot, FILE_SNIPPET_LIMIT),
+        readOptionalAbsoluteSnippet(paths.nextPrompt, workspaceRoot, FILE_SNIPPET_LIMIT)
+    ]);
+    return [
+        `Workspace root: ${workspaceRoot}`,
+        "",
+        "Top-level repo entries:",
+        renderList(topLevelEntries),
+        "",
+        "Source file inventory:",
+        renderList(sourceFiles),
+        "",
+        "Docs file inventory:",
+        renderList(docFiles),
+        "",
+        "Package manifest:",
+        packageSummary,
+        "",
+        "Key docs:",
+        renderNamedSnippet("README.md", readmeSnippet),
+        "",
+        renderNamedSnippet("docs/product-foundation.md", foundationSnippet),
+        "",
+        renderNamedSnippet("docs/adr/0001-tech-stack.md", adrSnippet),
+        "",
+        "Existing planning-pack files:",
+        renderNamedSnippet(".srgical/01-product-plan.md", planSnippet),
+        "",
+        renderNamedSnippet(".srgical/02-agent-context-kickoff.md", contextSnippet),
+        "",
+        renderNamedSnippet(".srgical/03-detailed-implementation-plan.md", trackerSnippet),
+        "",
+        renderNamedSnippet(".srgical/04-next-agent-prompt.md", nextPromptSnippet)
+    ].join("\n");
+}
+async function summarizePackageManifest(workspaceRoot) {
+    const packageJsonPath = node_path_1.default.join(workspaceRoot, "package.json");
+    const exists = await (0, workspace_1.fileExists)(packageJsonPath);
+    if (!exists) {
+        return "- package.json not present";
+    }
+    try {
+        const raw = await (0, workspace_1.readText)(packageJsonPath);
+        const parsed = JSON.parse(raw);
+        const scripts = Object.entries(parsed.scripts ?? {}).map(([name, command]) => `${name}: ${command}`);
+        const dependencies = Object.entries(parsed.dependencies ?? {}).map(([name, version]) => `${name}: ${version}`);
+        const devDependencies = Object.entries(parsed.devDependencies ?? {}).map(([name, version]) => `${name}: ${version}`);
+        return [
+            `- name: ${parsed.name ?? "unknown"}`,
+            `- version: ${parsed.version ?? "unknown"}`,
+            `- description: ${parsed.description ?? "none"}`,
+            "- scripts:",
+            renderList(scripts),
+            "- dependencies:",
+            renderList(dependencies),
+            "- devDependencies:",
+            renderList(devDependencies)
+        ].join("\n");
+    }
+    catch {
+        const fallback = await (0, workspace_1.readText)(packageJsonPath);
+        return limitText(fallback.trim(), FILE_SNIPPET_LIMIT);
+    }
+}
+async function listDirectoryEntries(directoryPath) {
+    try {
+        const entries = await (0, promises_1.readdir)(directoryPath, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.name !== ".git" && entry.name !== "node_modules")
+            .map((entry) => (entry.isDirectory() ? `${entry.name}/` : entry.name))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return ["- unavailable"];
+    }
+}
+async function listRelativeFiles(directoryPath, workspaceRoot, maxCount) {
+    const collected = [];
+    const exists = await (0, workspace_1.fileExists)(directoryPath);
+    if (!exists) {
+        return ["- unavailable"];
+    }
+    await walkFiles(directoryPath, workspaceRoot, collected, maxCount);
+    if (collected.length === 0) {
+        return ["- none"];
+    }
+    return collected;
+}
+async function walkFiles(directoryPath, workspaceRoot, collected, maxCount) {
+    if (collected.length >= maxCount || hasTruncationMarker(collected)) {
+        return;
+    }
+    const entries = await (0, promises_1.readdir)(directoryPath, { withFileTypes: true });
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (collected.length >= maxCount) {
+            collected.push(`... truncated after ${maxCount} files`);
+            return;
+        }
+        const fullPath = node_path_1.default.join(directoryPath, entry.name);
+        if (entry.isDirectory()) {
+            await walkFiles(fullPath, workspaceRoot, collected, maxCount);
+            continue;
+        }
+        collected.push(node_path_1.default.relative(workspaceRoot, fullPath).replace(/\\/g, "/"));
+    }
+}
+async function readSnippet(workspaceRoot, relativePath, maxChars) {
+    return readOptionalAbsoluteSnippet(node_path_1.default.join(workspaceRoot, relativePath), workspaceRoot, maxChars);
+}
+async function readOptionalAbsoluteSnippet(filePath, workspaceRoot, maxChars) {
+    const exists = await (0, workspace_1.fileExists)(filePath);
+    if (!exists) {
+        return "- missing";
+    }
+    try {
+        const content = await (0, workspace_1.readText)(filePath);
+        const relativePath = node_path_1.default.relative(workspaceRoot, filePath).replace(/\\/g, "/");
+        return [`Path: ${relativePath}`, limitText(content.trim(), maxChars)].join("\n");
+    }
+    catch {
+        return "- unreadable";
+    }
+}
+function renderNamedSnippet(name, content) {
+    return [`${name}:`, content].join("\n");
+}
+function renderList(items) {
+    if (items.length === 0) {
+        return "- none";
+    }
+    return items.map((item) => (item.startsWith("- ") ? item : `- ${item}`)).join("\n");
+}
+function limitText(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    // Keep snippets short enough to ground the planner without overwhelming the prompt.
+    return `${value.slice(0, maxChars).trimEnd()}\n... [truncated after ${maxChars} chars]`;
+}
+function hasTruncationMarker(items) {
+    return items.some((item) => item.startsWith("... truncated after "));
+}