@glrs-dev/cli 2.4.0 → 2.6.0

package/dist/node_modules/@glrs-dev/autopilot/dist/chunk-6JZQLIRP.js

@@ -0,0 +1,781 @@
+import {
+  resolveModel
+} from "./chunk-S34HOCZ4.js";
+import {
+  childLogger
+} from "./chunk-2ZQ6SBV3.js";
+import {
+  detectSpecPhases,
+  hasSpec,
+  parseSpecItems
+} from "./chunk-GXXCEGDD.js";
+
+// src/plan-enrichment.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+
+// src/enrich-strategy.ts
+import * as fs from "fs";
+import * as path from "path";
+function loadStrategy(repoRoot, name) {
+  const projectPath = path.join(repoRoot, ".glrs", "plan-enrich-strategies", `${name}.md`);
+  if (fs.existsSync(projectPath)) {
+    return fs.readFileSync(projectPath, "utf-8");
+  }
+  const builtinPath = path.join(__dirname, "strategies", `${name}.md`);
+  if (fs.existsSync(builtinPath)) {
+    return fs.readFileSync(builtinPath, "utf-8");
+  }
+  throw new Error(`Unknown enrichment strategy "${name}". Searched:
+  ${projectPath}
+  ${builtinPath}`);
+}
+function extractFieldNames(strategy) {
+  const regex = /^\s*(?:-|\d+\.)\s+\*\*(\w+)\*\*:/gm;
+  const matches = [];
+  let match;
+  while ((match = regex.exec(strategy)) !== null) {
+    matches.push(match[1]);
+  }
+  return matches.length > 0 ? matches : ["mirror", "context", "conventions"];
+}
+
+// src/plan-enrichment.ts
+var ENRICHMENT_RATIO_THRESHOLD = 1;
+function isFreeformFile(resolvedPath) {
+  try {
+    if (fs2.statSync(resolvedPath).isDirectory()) return false;
+  } catch {
+    return false;
+  }
+  let content;
+  try {
+    content = fs2.readFileSync(resolvedPath, "utf-8");
+  } catch {
+    return false;
+  }
+  const checkboxItems = (content.match(/^- \[[ xX]\]/gm) ?? []).length;
+  const headingItems = (content.match(/^###\s+\d+\.\d+\s/gm) ?? []).length;
+  return Math.max(checkboxItems, headingItems) === 0;
+}
+function buildDecompositionPrompt(cwd, planDir, sourceFile, content) {
+  return `You are decomposing a freeform document into a structured multi-file plan for automated execution.
+
+Read the freeform content below and explore the codebase at ${cwd} to understand the project structure. Then write a structured plan as multiple files in the directory: ${planDir}
+
+## Required output files
+
+### 1. main.md
+Write \`${planDir}/main.md\` with this structure:
+
+\`\`\`markdown
+# <Title derived from the document>
+
+## Goal
+<1-3 sentence summary of what this work accomplishes>
+
+## Constraints
+<Technical constraints, conventions to follow, or boundaries on the work>
+
+## Phases
+- [ ] wave_0.md - <phase description>
+- [ ] wave_1.md - <phase description>
+(add more phases as needed)
+\`\`\`
+
+### 2. Phase files (wave_0.md, wave_1.md, etc.)
+For each phase, write \`${planDir}/wave_N.md\` with numbered items:
+
+\`\`\`markdown
+# Wave N: <Phase title>
+
+### N.1 <Item title>
+- intent: <What this item accomplishes>
+- files:
+    - <path/to/file.ts>
+      Change: <What changes in this file>
+- tests:
+    - <path/to/test.ts>
+- verify: <command to verify this item, e.g., "bun test path/to/test.ts">
+
+### N.2 <Item title>
+...
+\`\`\`
+
+## Guidelines for decomposition
+
+1. **Explore the codebase first.** Use file listing and reading tools to find:
+   - The project's test framework and test patterns
+   - Existing file naming conventions
+   - Related modules that items will modify or reference
+   - The package manager (bun/npm/pnpm/yarn) for verify commands
+
+2. **Group items into phases by dependency.** Items in wave_0 should have no dependencies on later waves. Items within a wave should be independent or naturally sequential.
+
+3. **Each item must be concrete and actionable.** Every item needs:
+   - A clear \`intent:\` describing the change
+   - Specific \`files:\` with real paths from the codebase
+   - At least one test file in \`tests:\`
+   - A runnable \`verify:\` command
+
+4. **Keep items small.** Each item should be completable in a single focused session (1-3 files modified). Split large changes across multiple items.
+
+5. **The heading format matters.** Use \`### N.M\` (e.g., \`### 0.1\`, \`### 0.2\`, \`### 1.1\`) \u2014 this is the format the enrichment pipeline recognizes.
+
+## Source document
+
+File: ${sourceFile}
+
+\`\`\`markdown
+${content}
+\`\`\`
+
+Write all the plan files using the write/edit tool, then respond with "DECOMPOSITION_COMPLETE" when done.`;
+}
+async function decomposeFreeformPlan(cwd, resolvedPath, log, emitter, adapter, stallMs, config) {
+  const parsed = path2.parse(resolvedPath);
+  const planDir = path2.join(parsed.dir, parsed.name);
+  const mainMdPath = path2.join(planDir, "main.md");
+  if (fs2.existsSync(mainMdPath)) {
+    log?.info({ planDir }, "Decomposed plan directory already exists \u2014 skipping");
+    emitter?.emitEvent({
+      type: "enrich:file:skip",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      file: path2.relative(cwd, resolvedPath),
+      reason: "decomposed directory already exists"
+    });
+    return planDir;
+  }
+  let content;
+  try {
+    content = fs2.readFileSync(resolvedPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log?.warn({ err: msg }, "Failed to read freeform file");
+    return null;
+  }
+  fs2.mkdirSync(planDir, { recursive: true });
+  emitter?.emitEvent({
+    type: "enrich:file:start",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    file: path2.relative(cwd, resolvedPath)
+  });
+  const handle = await adapter.start({ cwd });
+  let sessionId;
+  try {
+    const adapterName = adapter.name;
+    const cfgObj = config;
+    const models = cfgObj?.models;
+    const enrichmentSpecifier = models?.enrichment;
+    const resolvedModel = enrichmentSpecifier ? resolveModel(enrichmentSpecifier, adapterName ?? "opencode") : void 0;
+    sessionId = await adapter.createSession(handle, {
+      agentName: "prime",
+      model: resolvedModel
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log?.warn({ err: msg }, "createSession failed for decomposition");
+    await adapter.shutdown(handle);
+    return null;
+  }
+  const prompt = buildDecompositionPrompt(cwd, planDir, resolvedPath, content);
+  try {
+    const result = await adapter.sendAndWait(handle, {
+      sessionId,
+      message: prompt,
+      stallMs,
+      onToolCall: (toolName) => {
+        log?.debug({ toolName }, "Decomposition tool call");
+      },
+      onTextDelta: () => {
+      },
+      onCostUpdate: (cost, tokens) => {
+        emitter?.emitEvent({
+          type: "cost:update",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          cumulativeCostUsd: cost,
+          isEstimated: false,
+          iteration: 0,
+          tokensIn: tokens.input,
+          tokensOut: tokens.output
+        });
+      }
+    });
+    if (result.kind === "error" || result.kind === "stall") {
+      const errMsg = result.kind === "error" ? "message" in result ? result.message : "session error" : "session stalled";
+      log?.error({ err: errMsg }, "Decomposition session failed");
+      emitter?.emitEvent({
+        type: "enrich:file:error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        file: path2.relative(cwd, resolvedPath),
+        error: `decomposition failed: ${errMsg}`
+      });
+      return null;
+    }
+    const response = await adapter.getLastResponse(handle, sessionId);
+    if (!fs2.existsSync(mainMdPath)) {
+      log?.warn("Decomposition completed but main.md was not written");
+      emitter?.emitEvent({
+        type: "enrich:file:error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        file: path2.relative(cwd, resolvedPath),
+        error: "decomposition completed but main.md was not written"
+      });
+      return null;
+    }
+    if (!response.includes("DECOMPOSITION_COMPLETE")) {
+      log?.warn("Decomposition session did not emit completion sentinel");
+    }
+    log?.info({ planDir }, "Freeform file decomposed into structured plan");
+    emitter?.emitEvent({
+      type: "enrich:file:done",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      file: path2.relative(cwd, resolvedPath),
+      toolCalls: 0
+    });
+    return planDir;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log?.error({ err: msg }, "Decomposition failed");
+    return null;
+  } finally {
+    await adapter.shutdown(handle);
+  }
+}
+function computeEnrichmentRatio(planFiles, fieldNames = ["mirror", "context", "conventions", "proof", "proof_type"]) {
+  let total = 0;
+  let enriched = 0;
+  for (const f of planFiles) {
+    let content;
+    try {
+      content = fs2.readFileSync(f, "utf-8");
+    } catch {
+      continue;
+    }
+    const checkboxItems = (content.match(/^- \[[ xX]\]/gm) ?? []).length;
+    const headingItems = (content.match(/^###\s+\d+\.\d+\s/gm) ?? []).length;
+    total += headingItems > 0 ? headingItems : checkboxItems;
+    const fieldCounts = fieldNames.map((field) => {
+      const regex = new RegExp(`^\\s*-?\\s*${field}:`, "gm");
+      return (content.match(regex) ?? []).length;
+    });
+    enriched += Math.min(...fieldCounts);
+  }
+  return total > 0 ? enriched / total : 0;
+}
+function computeSpecEnrichmentRatio(planDir, fieldNames = ["mirror", "context", "conventions", "proof", "proof_type"]) {
+  if (!hasSpec(planDir)) return 0;
+  const phaseFiles = detectSpecPhases(planDir);
+  let total = 0;
+  let enriched = 0;
+  for (const phaseFile of phaseFiles) {
+    const phasePath = path2.join(planDir, "spec", phaseFile);
+    let content;
+    try {
+      content = fs2.readFileSync(phasePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const raw = yamlParse(content);
+    const items = Array.isArray(raw?.items) ? raw.items : [];
+    total += items.length;
+    for (const item of items) {
+      const hasAllFields = fieldNames.every((field) => item[field]);
+      if (hasAllFields) {
+        enriched++;
+      }
+    }
+  }
+  return total > 0 ? enriched / total : 0;
+}
+function buildSpecGenerationPrompt(cwd, planDir, phaseFile, content, strategyName) {
+  const isMain = phaseFile === "main.md";
+  const specFileName = isMain ? "main.yaml" : phaseFile.replace(/\.md$/, ".yaml");
+  const specPath = `spec/${specFileName}`;
+  const schemaExample = isMain ? `\`\`\`yaml
+# spec/main.yaml
+title: "Plan title from H1"
+goal: "Goal text"
+constraints: "Constraints text"
+phases:
+  - file: wave_0.yaml
+    completed: false
+\`\`\`` : `\`\`\`yaml
+# spec/${specFileName}
+items:
+  - id: "0.1"
+    intent: "What this item does"
+    checked: false
+    files:
+      - path: src/foo.ts
+        isNew: false
+        change: "What changes"
+    tests:
+      - "test/foo.test.ts"
+    verify: "bun test test/foo.test.ts"
+    mirror: "src/similar-file.ts"
+    context: |
+      // relevant code from the file being modified
+    conventions: "ESM imports, named exports, bun:test"
+    proof: "The acceptance proof should verify that the new function accepts valid inputs and rejects invalid ones"
+    proof_type: "test"
+\`\`\``;
+  const mainInstructions = `You are generating a YAML spec file from a markdown plan.
+
+Read the markdown plan content below and write \`${specPath}\` (relative to the plan directory: ${planDir}) using the write/edit tool.
+
+The output file should follow this schema:
+
+${schemaExample}
+
+Extract from the markdown:
+- \`title\`: the H1 heading text
+- \`goal\`: the Goal section text
+- \`constraints\`: the Constraints section text (if present)
+- \`phases\`: one entry per phase file referenced (e.g., wave_0.md \u2192 wave_0.yaml), all with \`completed: false\`
+
+Here is the plan file to convert:
+
+### ${phaseFile}
+\`\`\`markdown
+${content}
+\`\`\`
+
+Write the file \`${planDir}/${specPath}\` using the write/edit tool, then respond with "SPEC_COMPLETE" when done.`;
+  if (isMain) {
+    return mainInstructions;
+  }
+  const phaseTemplate = loadStrategy(cwd, strategyName ?? "default");
+  const phaseInstructions = phaseTemplate.replaceAll("{{specPath}}", specPath).replaceAll("{{planDir}}", planDir).replaceAll("{{specFileName}}", specFileName).replaceAll("{{phaseFile}}", phaseFile).replaceAll("{{content}}", content);
+  return phaseInstructions;
+}
+async function runEnrichmentPass(cwd, resolvedPath, planFiles, isDir, fieldNames, log, emitter, adapter, handle, stallMs, strategyName, config) {
+  let stallOccurred = false;
+  for (const f of planFiles) {
+    const rel = path2.relative(cwd, f);
+    const phaseFile = path2.basename(f);
+    const specFileName = phaseFile === "main.md" ? "main.yaml" : phaseFile.replace(/\.md$/, ".yaml");
+    const specPath = isDir ? path2.join(resolvedPath, "spec", specFileName) : null;
+    if (specPath && fs2.existsSync(specPath)) {
+      if (phaseFile === "main.md") {
+        log?.info({ file: rel }, "Spec already exists \u2014 skipping");
+        emitter?.emitEvent({
+          type: "enrich:file:skip",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          reason: "spec already exists"
+        });
+        continue;
+      }
+      const phaseItems = parseSpecItems(specPath);
+      if (phaseItems.some((it) => it.checked)) {
+        log?.info({ file: rel }, "Phase has checked items \u2014 skipping re-enrichment");
+        emitter?.emitEvent({
+          type: "enrich:file:skip",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          reason: "phase has checked items (in-progress)"
+        });
+        continue;
+      }
+      const phaseTotal = phaseItems.length;
+      const phaseEnriched = phaseItems.filter(
+        (it) => {
+          const item = it;
+          return fieldNames.every((field) => item[field]);
+        }
+      ).length;
+      const phaseRatio = phaseTotal > 0 ? phaseEnriched / phaseTotal : 0;
+      if (phaseRatio >= ENRICHMENT_RATIO_THRESHOLD) {
+        log?.info({ file: rel, ratio: phaseRatio }, "Phase spec already enriched \u2014 skipping");
+        emitter?.emitEvent({
+          type: "enrich:file:skip",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          reason: `already enriched (${Math.round(phaseRatio * 100)}%)`
+        });
+        continue;
+      }
+    }
+    let content;
+    try {
+      content = fs2.readFileSync(f, "utf-8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log?.warn({ file: rel, err: msg }, "File read failed \u2014 skipping");
+      emitter?.emitEvent({
+        type: "enrich:file:error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        file: rel,
+        error: `read failed: ${msg}`
+      });
+      continue;
+    }
+    if (phaseFile !== "main.md") {
+      const checkboxItems = (content.match(/^- \[[ xX]\]/gm) ?? []).length;
+      const headingItems = (content.match(/^###\s+\d+\.\d+\s/gm) ?? []).length;
+      const itemCount = Math.max(checkboxItems, headingItems);
+      if (itemCount === 0) {
+        log?.info({ file: rel }, "No enrichable items \u2014 skipping");
+        emitter?.emitEvent({
+          type: "enrich:file:skip",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          reason: "no enrichable items"
+        });
+        continue;
+      }
+    }
+    emitter?.emitEvent({
+      type: "enrich:file:start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      file: rel
+    });
+    let sessionId;
+    try {
+      const adapterName = adapter?.name;
+      const cfgObj = config;
+      const models = cfgObj?.models;
+      const enrichmentSpecifier = models?.enrichment;
+      const resolvedModel = enrichmentSpecifier ? resolveModel(enrichmentSpecifier, adapterName ?? "opencode") : void 0;
+      sessionId = await adapter.createSession(handle, {
+        agentName: "prime",
+        model: resolvedModel
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log?.warn({ file: rel, err: msg }, "createSession failed \u2014 skipping");
+      emitter?.emitEvent({
+        type: "enrich:file:error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        file: rel,
+        error: `createSession failed: ${msg}`
+      });
+      continue;
+    }
+    const prompt = buildSpecGenerationPrompt(cwd, resolvedPath, phaseFile, content, strategyName);
+    let toolCalls = 0;
+    let fileCost = 0;
+    try {
+      log?.info({ file: rel }, "Starting spec generation session");
+      const sessionResult = await adapter.sendAndWait(handle, {
+        sessionId,
+        message: prompt,
+        stallMs,
+        onToolCall: (toolName, firstArg) => {
+          toolCalls++;
+          log?.debug({ file: rel, toolName, firstArg, toolCalls }, "Spec generation tool call");
+          emitter?.emitEvent({
+            type: "tool:call",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            toolName,
+            ...firstArg ? { firstArg } : {},
+            iteration: 0
+          });
+        },
+        onTextDelta: () => {
+        },
+        onCostUpdate: (cost, tokens) => {
+          fileCost = cost;
+          emitter?.emitEvent({
+            type: "cost:update",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            cumulativeCostUsd: cost,
+            isEstimated: false,
+            iteration: 0,
+            tokensIn: tokens.input,
+            tokensOut: tokens.output
+          });
+        }
+      });
+      if (sessionResult.kind === "error") {
+        const rawMsg = "message" in sessionResult ? sessionResult.message : "unknown error";
+        const errMsg = adapter.enhanceError ? await adapter.enhanceError(rawMsg) : rawMsg;
+        log?.error({ file: rel, err: errMsg }, "Session errored");
+        emitter?.emitEvent({
+          type: "enrich:file:error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          error: errMsg
+        });
+        continue;
+      }
+      if (sessionResult.kind === "stall") {
+        log?.error({ file: rel }, "Session stalled");
+        stallOccurred = true;
+        emitter?.emitEvent({
+          type: "enrich:file:error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          error: "session stalled"
+        });
+        continue;
+      }
+      const response = await adapter.getLastResponse(handle, sessionId);
+      log?.debug({ file: rel, toolCalls, responseLength: response.length }, "Session response received");
+      if (adapter.getSessionStats) {
+        try {
+          const stats = await adapter.getSessionStats(handle, sessionId);
+          if (stats.tokensIn > 0 || stats.tokensOut > 0) {
+            emitter?.emitEvent({
+              type: "cost:update",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              cumulativeCostUsd: stats.cost,
+              isEstimated: false,
+              iteration: 0,
+              tokensIn: stats.tokensIn,
+              tokensOut: stats.tokensOut
+            });
+          }
+        } catch {
+        }
+      }
+      if (!response.includes("SPEC_COMPLETE")) {
+        log?.warn({ file: rel, toolCalls }, "Spec generation session did not complete cleanly");
+        emitter?.emitEvent({
+          type: "enrich:file:error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          error: "spec generation session did not complete cleanly"
+        });
+      } else if (specPath && !fs2.existsSync(specPath)) {
+        log?.warn({ file: rel, toolCalls }, "Spec generation session did not complete cleanly");
+        emitter?.emitEvent({
+          type: "enrich:file:error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          error: `SPEC_COMPLETE received but spec/${specFileName} was not written`
+        });
+      } else {
+        log?.info({ file: rel, toolCalls }, "Spec generated successfully");
+        emitter?.emitEvent({
+          type: "enrich:file:done",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          file: rel,
+          toolCalls,
+          ...specPath ? { specFile: `spec/${specFileName}` } : {}
+        });
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log?.error({ file: rel, err: msg, toolCalls }, "Spec generation failed \u2014 continuing");
+      emitter?.emitEvent({
+        type: "enrich:file:error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        file: rel,
+        error: `spec generation failed: ${msg}`
+      });
+    }
+  }
+  return stallOccurred;
+}
+async function enrichPlanForFastModel(cwd, planPath, logger, emitter, adapter, enrichmentConfig, config) {
+  const log = logger ? childLogger(logger.root, "autopilot.enrichment") : void 0;
+  const resolvedPath = path2.resolve(cwd, planPath);
+  const isDir = fs2.existsSync(resolvedPath) && fs2.statSync(resolvedPath).isDirectory();
+  if (!isDir && isFreeformFile(resolvedPath)) {
+    if (!adapter) {
+      throw new Error("enrichPlanForFastModel: adapter is required for freeform decomposition");
+    }
+    log?.info({ file: resolvedPath }, "Freeform file detected \u2014 decomposing into structured plan");
+    const stallMs2 = enrichmentConfig?.stall_timeout ?? 5 * 60 * 1e3;
+    const decomposedDir = await decomposeFreeformPlan(
+      cwd,
+      resolvedPath,
+      log,
+      emitter,
+      adapter,
+      stallMs2,
+      config
+    );
+    if (decomposedDir) {
+      log?.info({ planDir: decomposedDir }, "Decomposition complete \u2014 enriching structured plan");
+      return enrichPlanForFastModel(
+        cwd,
+        decomposedDir,
+        logger,
+        emitter,
+        adapter,
+        enrichmentConfig,
+        config
+      );
+    }
+    log?.warn("Freeform decomposition failed \u2014 falling through to single-file enrichment");
+  }
+  let planFiles;
+  if (isDir) {
+    const entries = fs2.readdirSync(resolvedPath);
+    planFiles = entries.filter((f) => f.endsWith(".md") && f !== "scope.md" && f !== "scope-seed.md").sort((a, b) => {
+      if (a === "main.md") return -1;
+      if (b === "main.md") return 1;
+      const numA = parseInt(a.replace(/[^0-9]/g, ""), 10) || 0;
+      const numB = parseInt(b.replace(/[^0-9]/g, ""), 10) || 0;
+      return numA - numB;
+    }).map((f) => path2.join(resolvedPath, f));
+  } else {
+    planFiles = [resolvedPath];
+  }
+  emitter?.emitEvent({
+    type: "enrich:start",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    planPath: resolvedPath,
+    fileCount: planFiles.length
+  });
+  let fieldNames = ["mirror", "context", "conventions", "proof", "proof_type"];
+  try {
+    const strategy = loadStrategy(cwd, "default");
+    fieldNames = extractFieldNames(strategy);
+  } catch (err) {
+    log?.warn({ err }, "Failed to load strategy \u2014 using defaults");
+  }
+  const isYamlSpec = isDir && hasSpec(resolvedPath);
+  const wholePlanRatio = isYamlSpec ? computeSpecEnrichmentRatio(resolvedPath, fieldNames) : computeEnrichmentRatio(planFiles, fieldNames);
+  if (wholePlanRatio >= ENRICHMENT_RATIO_THRESHOLD) {
+    log?.info({ ratio: wholePlanRatio }, "Plan already enriched \u2014 skipping");
+    emitter?.emitEvent({
+      type: "enrich:done",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      filesProcessed: 0
+    });
+    return resolvedPath;
+  }
+  if (isDir) {
+    fs2.mkdirSync(path2.join(resolvedPath, "spec"), { recursive: true });
+  }
+  const existingMainYaml = path2.join(resolvedPath, "spec", "main.yaml");
+  let savedCompletionStates = null;
+  try {
+    if (fs2.existsSync(existingMainYaml)) {
+      const content = fs2.readFileSync(existingMainYaml, "utf-8");
+      const raw = yamlParse(content);
+      if (raw && Array.isArray(raw.phases)) {
+        savedCompletionStates = /* @__PURE__ */ new Map();
+        for (const phase of raw.phases) {
+          if (phase.file && phase.completed === true) {
+            savedCompletionStates.set(phase.file, true);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  const enableRetry = enrichmentConfig?.retry !== false;
+  const maxRetries = enrichmentConfig?.max_retries ?? 3;
+  const stallMs = enrichmentConfig?.stall_timeout ?? 5 * 60 * 1e3;
+  const strategyName = enrichmentConfig?.strategy;
+  if (!adapter) {
+    throw new Error("enrichPlanForFastModel: adapter is required");
+  }
+  log?.info({ planPath: resolvedPath, fileCount: planFiles.length, enableRetry, maxRetries }, "Starting enrichment");
+  let enrichmentCumulativeCost = 0;
+  if (!enableRetry) {
+    log?.info("Enrichment retry disabled \u2014 single attempt only");
+    const handle = await adapter.start({ cwd });
+    log?.info({ agentId: handle.id }, "Agent ready for enrichment");
+    try {
+      const stallOccurred = await runEnrichmentPass(
+        cwd,
+        resolvedPath,
+        planFiles,
+        isDir,
+        fieldNames,
+        log,
+        emitter,
+        adapter,
+        handle,
+        stallMs,
+        strategyName,
+        config
+      );
+      if (stallOccurred) {
+        log?.warn("Enrichment stalled but retry is disabled");
+      }
+    } finally {
+      await adapter.shutdown(handle);
+    }
+  } else {
+    let passSucceeded = false;
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        log?.info({ attempt, maxRetries }, "Starting enrichment attempt");
+        const handle = await adapter.start({ cwd });
+        log?.info({ agentId: handle.id, attempt }, "Agent ready for enrichment");
+        try {
+          const stallOccurred = await runEnrichmentPass(
+            cwd,
+            resolvedPath,
+            planFiles,
+            isDir,
+            fieldNames,
+            log,
+            emitter,
+            adapter,
+            handle,
+            stallMs,
+            strategyName,
+            config
+          );
+          if (!stallOccurred) {
+            log?.info({ attempt }, "Enrichment pass completed without stalling");
+            passSucceeded = true;
+            break;
+          }
+          log?.warn({ attempt }, "Enrichment pass stalled, will retry");
+        } finally {
+          await adapter.shutdown(handle);
+        }
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        const msg = lastError.message;
+        log?.warn({ attempt, err: msg }, "Enrichment attempt failed");
+        if (attempt === maxRetries) {
+          throw new Error(`Enrichment exhausted ${maxRetries} retries: ${msg}`);
+        }
+      }
+    }
+    if (!passSucceeded) {
+      const msg = lastError?.message ?? "unknown error";
+      throw new Error(`Enrichment exhausted ${maxRetries} retries: ${msg}`);
+    }
+  }
+  if (savedCompletionStates && savedCompletionStates.size > 0) {
+    try {
+      const mainYamlPath = path2.join(resolvedPath, "spec", "main.yaml");
+      if (fs2.existsSync(mainYamlPath)) {
+        let content = fs2.readFileSync(mainYamlPath, "utf-8");
+        const raw = yamlParse(content);
+        if (raw && Array.isArray(raw.phases)) {
+          let modified = false;
+          for (const phase of raw.phases) {
+            if (phase.file && savedCompletionStates.has(phase.file) && phase.completed !== true) {
+              phase.completed = true;
+              modified = true;
+            }
+          }
+          if (modified) {
+            fs2.writeFileSync(mainYamlPath, yamlStringify(raw), "utf-8");
+            log?.info({ restored: savedCompletionStates.size }, "Restored phase completion states after enrichment");
+          }
+        }
+      }
+    } catch (err) {
+      log?.warn({ err }, "Failed to restore phase completion states \u2014 phases may need manual re-marking");
+    }
+  }
+  emitter?.emitEvent({
+    type: "enrich:done",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    filesProcessed: planFiles.length
+  });
+  return resolvedPath;
+}
+
+export {
+  ENRICHMENT_RATIO_THRESHOLD,
+  isFreeformFile,
+  computeEnrichmentRatio,
+  computeSpecEnrichmentRatio,
+  enrichPlanForFastModel
+};