@kjerneverk/riotplan-ai 1.0.0-dev.0

package/dist/index.js

@@ -0,0 +1,1963 @@
+import { ToolRegistry, ConversationManager, AgentLoop } from "@kjerneverk/agentic";
+import { createRequest } from "@kjerneverk/execution";
+import { join } from "node:path";
+import { readdir, stat, readFile } from "node:fs/promises";
+import { createSqliteProvider } from "@kjerneverk/riotplan-format";
+const DEFAULT_TOKEN_BUDGET = {
+  maxTokens: 4e4,
+  // Conservative default for most models
+  evidenceFullThreshold: 2048,
+  // 2KB
+  evidenceSummaryThreshold: 20480,
+  // 20KB
+  historyFullCount: 15,
+  historyAbbreviatedCount: 5
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function truncateToLines(text, lineCount) {
+  const lines = text.split("\n");
+  if (lines.length <= lineCount) {
+    return text;
+  }
+  return lines.slice(0, lineCount).join("\n") + "\n\n... [truncated, see full file]";
+}
+function calculateTiering(constraints, selectedApproach, evidence, historyEventCount, budget = DEFAULT_TOKEN_BUDGET) {
+  const decision = {
+    totalEstimatedTokens: 0,
+    budgetExceeded: false,
+    evidenceTiered: {
+      full: [],
+      summarized: [],
+      listOnly: []
+    },
+    historyAbbreviated: false,
+    warnings: []
+  };
+  let baseTokens = 0;
+  for (const constraint of constraints) {
+    baseTokens += estimateTokens(constraint);
+  }
+  if (selectedApproach) {
+    baseTokens += estimateTokens(selectedApproach.name);
+    baseTokens += estimateTokens(selectedApproach.description);
+    baseTokens += estimateTokens(selectedApproach.reasoning);
+  }
+  baseTokens += 2e3;
+  decision.totalEstimatedTokens = baseTokens;
+  let evidenceTokens = 0;
+  for (const ev of evidence) {
+    const fullTokens = estimateTokens(ev.content);
+    if (ev.size < budget.evidenceFullThreshold) {
+      decision.evidenceTiered.full.push(ev.name);
+      evidenceTokens += fullTokens;
+    } else if (ev.size < budget.evidenceSummaryThreshold) {
+      const summarized = truncateToLines(ev.content, 50);
+      decision.evidenceTiered.summarized.push(ev.name);
+      evidenceTokens += estimateTokens(summarized);
+    } else {
+      const listOnly = truncateToLines(ev.content, 5);
+      decision.evidenceTiered.listOnly.push(ev.name);
+      evidenceTokens += estimateTokens(listOnly);
+      decision.warnings.push(`Evidence file "${ev.name}" is very large (${Math.round(ev.size / 1024)}KB), showing first 5 lines only`);
+    }
+  }
+  decision.totalEstimatedTokens += evidenceTokens;
+  const avgEventTokens = 50;
+  const historyTokens = historyEventCount * avgEventTokens;
+  decision.totalEstimatedTokens += historyTokens;
+  if (decision.totalEstimatedTokens > budget.maxTokens) {
+    decision.budgetExceeded = true;
+    if (historyEventCount > budget.historyAbbreviatedCount) {
+      decision.historyAbbreviated = true;
+      const savedTokens = (historyEventCount - budget.historyAbbreviatedCount) * avgEventTokens;
+      decision.totalEstimatedTokens -= savedTokens;
+      decision.warnings.push(`History abbreviated to ${budget.historyAbbreviatedCount} most recent events (was ${historyEventCount})`);
+    }
+  }
+  if (decision.evidenceTiered.summarized.length > 0) {
+    decision.warnings.push(`${decision.evidenceTiered.summarized.length} evidence file(s) summarized to manage token budget`);
+  }
+  return decision;
+}
+function applyEvidenceTiering(evidence, decision) {
+  return evidence.map((ev) => {
+    if (decision.evidenceTiered.summarized.includes(ev.name)) {
+      return {
+        ...ev,
+        content: truncateToLines(ev.content, 50),
+        tiered: "summarized"
+      };
+    } else if (decision.evidenceTiered.listOnly.includes(ev.name)) {
+      return {
+        ...ev,
+        content: truncateToLines(ev.content, 5),
+        tiered: "listOnly"
+      };
+    }
+    return ev;
+  });
+}
+const PLAN_GENERATION_RESPONSE_SCHEMA = {
+  type: "object",
+  properties: {
+    analysis: {
+      type: "object",
+      properties: {
+        constraintAnalysis: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              constraint: { type: "string" },
+              understanding: { type: "string" },
+              plannedApproach: { type: "string" }
+            },
+            required: ["constraint", "understanding", "plannedApproach"]
+          }
+        },
+        evidenceAnalysis: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              evidenceFile: { type: "string" },
+              keyFindings: { type: "string" },
+              impactOnPlan: { type: "string" }
+            },
+            required: ["evidenceFile", "keyFindings", "impactOnPlan"]
+          }
+        },
+        approachAnalysis: {
+          type: "object",
+          properties: {
+            selectedApproach: { type: "string" },
+            commitments: { type: "string" },
+            implementationStrategy: { type: "string" }
+          }
+        },
+        risks: {
+          type: "array",
+          items: { type: "string" }
+        }
+      },
+      required: ["constraintAnalysis"]
+    },
+    summary: { type: "string" },
+    approach: { type: "string" },
+    successCriteria: { type: "string" },
+    steps: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          number: { type: "number" },
+          title: { type: "string" },
+          objective: { type: "string" },
+          background: { type: "string" },
+          tasks: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                description: { type: "string" }
+              },
+              required: ["id", "description"]
+            }
+          },
+          acceptanceCriteria: {
+            type: "array",
+            items: { type: "string" }
+          },
+          testing: { type: "string" },
+          filesChanged: {
+            type: "array",
+            items: { type: "string" }
+          },
+          notes: { type: "string" },
+          provenance: {
+            type: "object",
+            properties: {
+              constraintsAddressed: {
+                type: "array",
+                items: { type: "string" }
+              },
+              evidenceUsed: {
+                type: "array",
+                items: { type: "string" }
+              },
+              rationale: { type: "string" }
+            }
+          }
+        },
+        required: ["number", "title", "objective", "background", "tasks", "acceptanceCriteria", "testing", "filesChanged", "notes"]
+      }
+    }
+  },
+  required: ["analysis", "summary", "approach", "successCriteria", "steps"]
+};
+function getPlanGenerationSystemPrompt() {
+  return SYSTEM_PROMPT;
+}
+async function generatePlan(context, provider, options = {}) {
+  let tieringDecision;
+  let tieredContext = context;
+  if (context.constraints || context.evidence || context.historyContext) {
+    const budget = {
+      ...DEFAULT_TOKEN_BUDGET,
+      ...context.tokenBudget
+    };
+    tieringDecision = calculateTiering(
+      context.constraints || [],
+      context.selectedApproach || null,
+      context.evidence || [],
+      context.historyContext?.recentEvents.length || 0,
+      budget
+    );
+    if (context.evidence && context.evidence.length > 0) {
+      const tieredEvidence = applyEvidenceTiering(context.evidence, tieringDecision);
+      tieredContext = {
+        ...context,
+        evidence: tieredEvidence
+      };
+    }
+    if (tieringDecision.historyAbbreviated && context.historyContext) {
+      const abbreviatedCount = budget.historyAbbreviatedCount || 5;
+      tieredContext = {
+        ...tieredContext,
+        historyContext: {
+          ...context.historyContext,
+          recentEvents: context.historyContext.recentEvents.slice(0, abbreviatedCount)
+        }
+      };
+    }
+  }
+  const prompt = buildPlanPrompt(tieredContext);
+  const request = {
+    model: options.model || "claude-sonnet-4-5",
+    messages: [
+      {
+        role: "system",
+        content: SYSTEM_PROMPT
+      },
+      {
+        role: "user",
+        content: prompt
+      }
+    ],
+    responseFormat: {
+      type: "json_schema",
+      json_schema: {
+        name: "plan_generation",
+        description: "Generate a detailed execution plan",
+        schema: PLAN_GENERATION_RESPONSE_SCHEMA
+      }
+    },
+    addMessage: function(message) {
+      this.messages.push(message);
+    }
+  };
+  let responseContent = "";
+  const { onProgress } = options;
+  onProgress?.({ type: "started", message: "Generating plan..." });
+  if (provider.executeStream) {
+    let lastProgressUpdate = Date.now();
+    for await (const chunk of provider.executeStream(request, options)) {
+      if (chunk.type === "text" && chunk.text) {
+        responseContent += chunk.text;
+        const now = Date.now();
+        if (now - lastProgressUpdate > 500) {
+          onProgress?.({
+            type: "streaming",
+            charsReceived: responseContent.length,
+            message: `Generating... (${responseContent.length} chars)`
+          });
+          lastProgressUpdate = now;
+        }
+      }
+    }
+  } else {
+    const response = await provider.execute(request, options);
+    responseContent = response.content;
+  }
+  onProgress?.({ type: "parsing", message: "Parsing generated plan..." });
+  const plan = parsePlanResponse(responseContent, context.stepCount || 5);
+  onProgress?.({ type: "complete", message: "Plan generation complete" });
+  return {
+    plan,
+    tiering: tieringDecision
+  };
+}
+const SYSTEM_PROMPT = `You are an expert project planner generating an execution plan that MUST be grounded in the provided artifacts.
+
+## Dual Audience
+
+Your plan serves two audiences: (1) a human reviewer who will read the plan and judge your design choices BEFORE implementation, and (2) an LLM that will execute each step. Both need you to SHOW your thinking with code samples, not just describe it in prose.
+
+## Core Principles
+
+1. **Constraints are non-negotiable**: Every constraint from IDEA.md MUST be addressed by at least one step. Do not ignore or work around constraints.
+
+2. **Evidence informs design**: Evidence files contain research, analysis, code snippets, and findings gathered during idea exploration. Use this evidence to inform step design - reference specific findings, not general knowledge.
+
+3. **Selected approach is the strategy**: If a selected approach is provided from SHAPING.md, your plan MUST implement that approach, not an alternative. The approach was chosen deliberately with tradeoffs considered.
+
+4. **History shows evolution**: The history context shows how thinking evolved during exploration. Respect decisions that were made and questions that were answered.
+
+5. **Be concrete, not generic**: Reference specific files, functions, code patterns from the evidence. Don't generate generic steps that could apply to any project.
+
+6. **Use portable file paths**: In \`filesChanged\`, always use repository/project-root-relative paths (e.g., \`src/module/file.ts\`), never absolute machine-specific paths.
+
+7. **Show, don't tell**: Every task that introduces an interface, schema, config, or significant function MUST include a code sketch in its description — key method signatures, table schemas, type definitions. Not the full implementation, just enough for a human to evaluate the design and say "yes" or "change X."
+
+## Output Requirements
+
+- Generate steps that are directly traceable to the artifacts
+- Each step should cite which constraints it addresses
+- Reference evidence when it informs a step's design
+- Be specific about files, functions, and code changes
+- Include sample code in task descriptions (markdown code blocks with language tags)
+
+CRITICAL: You must output ONLY valid JSON. Do not include any text before or after the JSON object. Ensure all strings are properly escaped. Code blocks in task descriptions should use escaped backticks.`;
+function buildPlanPrompt(context) {
+  const hasStructuredArtifacts = context.constraints && context.constraints.length > 0 || context.evidence && context.evidence.length > 0 || context.selectedApproach || context.historyContext && context.historyContext.recentEvents.length > 0;
+  if (hasStructuredArtifacts) {
+    return buildArtifactAwarePrompt(context);
+  } else {
+    return buildLegacyPrompt(context);
+  }
+}
+function buildArtifactAwarePrompt(context) {
+  const sections = [];
+  sections.push(`== PLAN NAME ==
+${context.planName}`);
+  let coreConcept = context.description;
+  const contextMarker = coreConcept.indexOf("\n\n--- IDEA CONTEXT ---");
+  if (contextMarker !== -1) {
+    coreConcept = coreConcept.substring(0, contextMarker).trim();
+  }
+  sections.push(`== CORE CONCEPT ==
+${coreConcept}`);
+  if (context.constraints && context.constraints.length > 0) {
+    const constraintsList = context.constraints.map((c, i) => `${i + 1}. ${c}`).join("\n");
+    sections.push(`== CONSTRAINTS (MUST HONOR ALL) ==
+The following constraints are NON-NEGOTIABLE. Every constraint must be addressed by at least one step in the plan.
+
+${constraintsList}`);
+  }
+  if (context.catalystContent?.constraints) {
+    sections.push(`== CATALYST CONSTRAINTS ==
+The following constraints come from applied catalysts and must also be honored:
+
+${context.catalystContent.constraints}`);
+  }
+  if (context.selectedApproach) {
+    sections.push(`== SELECTED APPROACH ==
+This approach was selected during shaping. Your plan MUST implement this approach, not an alternative.
+
+**Name**: ${context.selectedApproach.name}
+
+**Description**: ${context.selectedApproach.description}
+
+**Reasoning**: ${context.selectedApproach.reasoning}`);
+  }
+  if (context.evidence && context.evidence.length > 0) {
+    const evidenceContent = context.evidence.map((e) => {
+      const content = e.content.trim();
+      const tiered = e.tiered;
+      let header = `### ${e.name}`;
+      if (tiered === "summarized") {
+        header += " (summarized for token budget)";
+      } else if (tiered === "listOnly") {
+        header += " (preview only - full content available)";
+      }
+      return `${header}
+${content}`;
+    }).join("\n\n");
+    sections.push(`== EVIDENCE ==
+The following evidence was gathered during idea exploration. Use these findings to inform step design.
+
+${evidenceContent}`);
+  }
+  if (context.historyContext && context.historyContext.recentEvents.length > 0) {
+    const historyList = context.historyContext.recentEvents.map((e) => `- [${e.type}] ${e.summary}`).join("\n");
+    sections.push(`== HISTORY CONTEXT ==
+Recent events from idea exploration (${context.historyContext.totalEvents} total events):
+
+${historyList}`);
+  }
+  if (context.questions && context.questions.length > 0) {
+    const questionsList = context.questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
+    sections.push(`== OPEN QUESTIONS ==
+These questions were raised during exploration. Consider them when designing steps.
+
+${questionsList}`);
+  }
+  if (context.catalystContent?.domainKnowledge) {
+    sections.push(`== CATALYST DOMAIN KNOWLEDGE ==
+The following domain knowledge comes from applied catalysts and provides context about the domain, organization, or technology:
+
+${context.catalystContent.domainKnowledge}`);
+  }
+  if (context.catalystContent?.outputTemplates) {
+    sections.push(`== CATALYST OUTPUT TEMPLATES ==
+The following output templates define expected deliverables that the plan should produce:
+
+${context.catalystContent.outputTemplates}`);
+  }
+  if (context.catalystContent?.processGuidance) {
+    sections.push(`== CATALYST PROCESS GUIDANCE ==
+The following process guidance from applied catalysts should inform how the plan is structured:
+
+${context.catalystContent.processGuidance}`);
+  }
+  if (context.catalystContent?.questions) {
+    sections.push(`== CATALYST QUESTIONS ==
+The following questions from applied catalysts should be considered during planning:
+
+${context.catalystContent.questions}`);
+  }
+  if (context.catalystContent?.validationRules) {
+    sections.push(`== CATALYST VALIDATION RULES ==
+The following validation rules from applied catalysts define post-creation checks:
+
+${context.catalystContent.validationRules}`);
+  }
+  if (context.catalystContent?.appliedCatalysts && context.catalystContent.appliedCatalysts.length > 0) {
+    const catalystList = context.catalystContent.appliedCatalysts.map((id, i) => `${i + 1}. ${id}`).join("\n");
+    sections.push(`== APPLIED CATALYSTS ==
+This plan was generated with the following catalysts applied (in order):
+
+${catalystList}
+
+The catalyst content above has influenced the constraints, domain knowledge, output expectations, and process guidance for this plan.`);
+  }
+  sections.push(`== GENERATION INSTRUCTIONS ==
+
+**CRITICAL: You must complete the 'analysis' section FIRST before generating steps.**
+
+The analysis section demonstrates your understanding of the artifacts and serves as your reasoning gate. Fill it out completely:
+
+1. **constraintAnalysis**: For EACH constraint listed above, provide:
+   - constraint: The exact constraint text
+   - understanding: What this constraint means and why it exists
+   - plannedApproach: How you will address this constraint in the plan
+
+2. **evidenceAnalysis** (if evidence provided): For each evidence file that informs the plan:
+   - evidenceFile: The evidence file name
+   - keyFindings: The most important findings from this evidence
+   - impactOnPlan: How these findings will shape the implementation steps
+
+3. **approachAnalysis** (if selected approach provided):
+   - selectedApproach: The approach name
+   - commitments: What this approach commits us to doing
+   - implementationStrategy: How the steps will implement this approach
+
+4. **risks**: Any risks or challenges you foresee in implementing this plan
+
+**After completing the analysis, generate ${context.stepCount || 5} implementation steps following these requirements:**
+
+1. **Address every constraint**: Each constraint from your analysis MUST be addressed by at least one step
+2. **Implement the selected approach**: Follow the implementation strategy from your analysis
+3. **Reference evidence**: Use the key findings from your evidence analysis to inform step design
+4. **Be concrete**: Reference specific files, functions, and code patterns from the evidence
+5. **Include provenance**: For each step, fill the provenance field with:
+   - constraintsAddressed: List which constraints this step addresses
+   - evidenceUsed: List which evidence files informed this step
+   - rationale: Explain why this step exists and how it connects to the idea
+
+For each step, provide:
+- A clear title
+- Objective (what this step accomplishes)
+- Background (context and prerequisites, referencing evidence where relevant)
+- Specific tasks with **sample code** — every task that introduces an interface, schema, config, or significant function MUST include a code sketch in the description using markdown code blocks. Don't write the full implementation, just enough for a human to judge the design: key method signatures, table schemas, type definitions, config formats. This is a plan that a human will review before execution.
+- Acceptance criteria (measurable verification)
+- Testing approach
+- Files that will be changed
+- Notes (including which constraints are addressed)
+
+IMPORTANT: Output ONLY the JSON object, with no markdown formatting, no code blocks, no additional text.
+
+JSON structure:
+{
+  "analysis": {
+    "constraintAnalysis": [
+      {
+        "constraint": "exact constraint text",
+        "understanding": "what this constraint means",
+        "plannedApproach": "how the plan will address this"
+      }
+    ],
+    "evidenceAnalysis": [
+      {
+        "evidenceFile": "evidence file name",
+        "keyFindings": "important findings from this evidence",
+        "impactOnPlan": "how these findings shape the plan"
+      }
+    ],
+    "approachAnalysis": {
+      "selectedApproach": "approach name",
+      "commitments": "what this approach commits to",
+      "implementationStrategy": "how steps will implement this"
+    },
+    "risks": ["risk 1", "risk 2"]
+  },
+  "summary": "executive summary explaining what this plan accomplishes and how it addresses the constraints",
+  "approach": "how the plan implements the selected approach (or your chosen approach if none selected)",
+  "successCriteria": "how we'll know all constraints are satisfied and the project is complete",
+  "steps": [
+    {
+      "number": 1,
+      "title": "Step Title",
+      "objective": "what this step accomplishes",
+      "background": "context, prerequisites, and relevant evidence",
+      "tasks": [
+        {"id": "01.1", "description": "specific task"},
+        {"id": "01.2", "description": "another task"}
+      ],
+      "acceptanceCriteria": ["criterion 1", "criterion 2"],
+      "testing": "how to verify this step",
+      "filesChanged": ["file1.ts", "file2.ts"],
+      "notes": "additional notes",
+      "provenance": {
+        "constraintsAddressed": ["constraint 1", "constraint 2"],
+        "evidenceUsed": ["evidence file 1", "evidence file 2"],
+        "rationale": "why this step exists and how it connects to the idea"
+      }
+    }
+  ]
+}`);
+  return sections.join("\n\n");
+}
+function buildLegacyPrompt(context) {
+  let prompt = `Create a detailed execution plan for the following project:
+
+**Project Name**: ${context.planName}
+
+**Description**:
+${context.description}
+`;
+  if (context.elaborations && context.elaborations.length > 0) {
+    prompt += `
+**Additional Context**:
+`;
+    context.elaborations.forEach((elab, i) => {
+      prompt += `
+${i + 1}. ${elab}
+`;
+    });
+  }
+  prompt += `
+**Requirements**:
+- Generate ${context.stepCount || 5} steps
+- Each step should be focused and achievable
+- Provide specific tasks, not generic placeholders
+- Include concrete acceptance criteria
+- Consider what files or components will be affected
+
+Please provide:
+1. Executive Summary (2-3 paragraphs explaining what this plan accomplishes)
+2. Approach (how you'll tackle this work, key decisions)
+3. Success Criteria (how we'll know the project is complete)
+4. Detailed steps with:
+   - Step title
+   - Objective (what this step accomplishes)
+   - Background (context needed)
+   - Tasks (specific actions to take)
+   - Acceptance criteria (how to verify completion)
+   - Testing approach
+   - Files that will be changed
+   - Any notes or considerations
+
+IMPORTANT: Output ONLY the JSON object below, with no markdown formatting, no code blocks, no additional text. Ensure all strings use proper JSON escaping for quotes and newlines.
+
+JSON structure:
+{
+  "summary": "executive summary text",
+  "approach": "approach description",
+  "successCriteria": "success criteria description",
+  "steps": [
+    {
+      "number": 1,
+      "title": "Step Title",
+      "objective": "what this step accomplishes",
+      "background": "context and prerequisites",
+      "tasks": [
+        {"id": "01.1", "description": "specific task"},
+        {"id": "01.2", "description": "another task"}
+      ],
+      "acceptanceCriteria": ["criterion 1", "criterion 2"],
+      "testing": "how to verify this step",
+      "filesChanged": ["file1.ts", "file2.ts"],
+      "notes": "additional notes"
+    }
+  ]
+}`;
+  return prompt;
+}
+function stripMarkdownFences(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("```")) return trimmed;
+  const firstNewline = trimmed.indexOf("\n");
+  if (firstNewline === -1) return trimmed;
+  const closingFence = trimmed.lastIndexOf("```");
+  if (closingFence <= firstNewline) return trimmed;
+  return trimmed.slice(firstNewline + 1, closingFence).trim();
+}
+function extractFirstJsonObject(content) {
+  let inString = false;
+  let escape = false;
+  let depth = 0;
+  let start = -1;
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escape = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") {
+      if (depth === 0) start = i;
+      depth += 1;
+      continue;
+    }
+    if (ch === "}") {
+      if (depth === 0) continue;
+      depth -= 1;
+      if (depth === 0 && start !== -1) {
+        return content.slice(start, i + 1);
+      }
+    }
+  }
+  return null;
+}
+function parsePlanResponse(content, _stepCount) {
+  try {
+    const cleanedContent = stripMarkdownFences(content);
+    const jsonCandidate = extractFirstJsonObject(cleanedContent) || cleanedContent;
+    const parsed = JSON.parse(jsonCandidate);
+    if (!parsed.summary || !parsed.approach || !parsed.successCriteria || !parsed.steps) {
+      throw new Error("Invalid plan structure: missing required fields");
+    }
+    if (parsed.analysis && !parsed.analysis.constraintAnalysis) {
+      throw new Error("Invalid analysis structure: missing constraintAnalysis");
+    }
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(
+      `Failed to parse plan response: ${message}. Expected a valid JSON object (markdown fences are allowed).`
+    );
+  }
+}
+function formatSummary(plan, planName) {
+  const title = planName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  return `# ${title} - Summary
+
+## Executive Summary
+
+${plan.summary}
+
+## Approach
+
+${plan.approach}
+
+## Success Criteria
+
+${plan.successCriteria}
+`;
+}
+function formatStep(step) {
+  const num = String(step.number).padStart(2, "0");
+  let content = `# Step ${num}: ${step.title}
+
+## Objective
+
+${step.objective}
+
+## Background
+
+${step.background}
+
+## Tasks
+
+`;
+  step.tasks.forEach((task) => {
+    content += `### ${task.id} ${task.description}
+
+`;
+  });
+  content += `## Acceptance Criteria
+
+`;
+  step.acceptanceCriteria.forEach((criterion) => {
+    content += `- [ ] ${criterion}
+`;
+  });
+  content += `
+## Testing
+
+${step.testing}
+
+## Files Changed
+
+`;
+  step.filesChanged.forEach((file) => {
+    content += `- ${file}
+`;
+  });
+  if (step.notes) {
+    content += `
+## Notes
+
+${step.notes}
+`;
+  }
+  return content;
+}
+function createWritePlanTool() {
+  let resolvePlan;
+  let rejectPlan;
+  const planPromise = new Promise((resolve, reject) => {
+    resolvePlan = resolve;
+    rejectPlan = reject;
+  });
+  const tool = {
+    name: "write_plan",
+    description: `Submit the completed execution plan. Call this ONCE when you have finished exploring the codebase and are ready to submit your plan.
+
+The plan_json parameter must be a valid JSON string with this structure:
+{
+  "analysis": {
+    "constraintAnalysis": [{ "constraint": "...", "understanding": "...", "plannedApproach": "..." }],
+    "evidenceAnalysis": [{ "evidenceFile": "...", "keyFindings": "...", "impactOnPlan": "..." }],
+    "approachAnalysis": { "selectedApproach": "...", "commitments": "...", "implementationStrategy": "..." },
+    "risks": ["..."]
+  },
+  "summary": "Executive summary of what this plan accomplishes",
+  "approach": "How the plan implements the selected approach",
+  "successCriteria": "How we'll know the project is complete",
+  "steps": [{
+    "number": 1,
+    "title": "Step Title",
+    "objective": "What this step accomplishes",
+    "background": "Context, prerequisites, and relevant evidence",
+    "tasks": [{ "id": "01.1", "description": "Specific task with file paths and code references" }],
+    "acceptanceCriteria": ["Measurable criterion 1"],
+    "testing": "How to verify this step",
+    "filesChanged": ["src/actual/file.ts"],
+    "notes": "Additional notes",
+    "provenance": {
+      "constraintsAddressed": ["constraint text"],
+      "evidenceUsed": ["evidence file"],
+      "rationale": "Why this step exists"
+    }
+  }]
+}
+
+IMPORTANT: Every step MUST include real file paths in filesChanged, reference actual interfaces/classes by name, and describe concrete code changes based on your codebase exploration.`,
+    parameters: {
+      type: "object",
+      properties: {
+        plan_json: {
+          type: "string",
+          description: "The complete plan as a JSON string matching the GeneratedPlan schema described above."
+        }
+      },
+      required: ["plan_json"]
+    },
+    category: "planning",
+    cost: "cheap",
+    execute: async (params) => {
+      try {
+        const parsed = JSON.parse(params.plan_json);
+        if (!parsed.summary || !parsed.approach || !parsed.successCriteria || !parsed.steps) {
+          const missing = [];
+          if (!parsed.summary) missing.push("summary");
+          if (!parsed.approach) missing.push("approach");
+          if (!parsed.successCriteria) missing.push("successCriteria");
+          if (!parsed.steps) missing.push("steps");
+          return `Error: Missing required fields: ${missing.join(", ")}. Please include all required fields and call write_plan again.`;
+        }
+        if (!Array.isArray(parsed.steps) || parsed.steps.length === 0) {
+          return "Error: steps must be a non-empty array. Please generate at least one step and call write_plan again.";
+        }
+        for (const step of parsed.steps) {
+          if (!step.number || !step.title || !step.objective) {
+            return `Error: Step ${step.number || "?"} is missing required fields (number, title, objective). Please fix and call write_plan again.`;
+          }
+          if (!step.tasks || !Array.isArray(step.tasks) || step.tasks.length === 0) {
+            return `Error: Step ${step.number} has no tasks. Each step must have at least one concrete task. Please fix and call write_plan again.`;
+          }
+          if (!step.filesChanged || !Array.isArray(step.filesChanged) || step.filesChanged.length === 0) {
+            return `Error: Step ${step.number} has no filesChanged. Each step must list specific files that will be modified. Use your codebase exploration to identify real file paths. Please fix and call write_plan again.`;
+          }
+        }
+        resolvePlan(parsed);
+        return `Plan accepted with ${parsed.steps.length} steps. Plan generation complete.`;
+      } catch (parseError) {
+        if (parseError instanceof SyntaxError) {
+          return `Error: Invalid JSON in plan_json. ${parseError.message}. Please fix the JSON and call write_plan again.`;
+        }
+        return `Error: ${parseError instanceof Error ? parseError.message : "Unknown error"}. Please fix and call write_plan again.`;
+      }
+    }
+  };
+  tool._rejectPlan = rejectPlan;
+  return { tool, planPromise };
+}
+const DEFAULT_MAX_ITERATIONS = 30;
+const AGENT_SYSTEM_PROMPT = `You are an expert project planner generating a detailed execution plan. You have access to codebase tools that let you explore the actual project.
+
+## Dual Audience
+
+Your plan serves TWO audiences:
+
+1. **A human reviewer** who wants to see your design thinking, judge your approach, and give feedback BEFORE implementation begins. They need sample code, interface sketches, and schema examples — enough to form an opinion and say "yes, that's the right approach" or "no, change X."
+
+2. **An LLM executor** who will implement each step. They need precise file paths, interface names, and concrete task descriptions.
+
+Both audiences need you to SHOW, not just TELL. Don't say "create a storage interface" — show a draft of the interface with key method signatures. Don't say "design a schema" — show the schema. You don't have to write every line, but include enough sample code that a reader can evaluate your design choices.
+
+## Your Workflow
+
+1. **EXPLORE the codebase** — Use your tools to understand the project:
+   - **START with \`query_index\`** — it returns the full project structure, all packages, and exported symbols in a single call (the index is pre-built and cached, so this is instant). Use queries like "packages", "find file generator", or "export AgentLoop".
+   - Then use \`read_file\` to examine specific interfaces, types, and implementations
+   - Use \`grep\` to find usage patterns and references
+   - Use \`file_outline\` to understand a file's structure without reading every line
+   - Use \`list_files\` only if you need directory contents not covered by the index
+
+2. **ANALYZE the artifacts** — Study the plan artifacts in the user message:
+   - Constraints are NON-NEGOTIABLE — every one must be addressed
+   - Evidence contains research and findings — use them to inform design
+   - The selected approach defines the strategy — implement it, not an alternative
+   - History shows how thinking evolved — respect past decisions
+
+3. **DESIGN concrete steps with code examples** — Each step must:
+   - Reference REAL file paths you verified with tools
+   - Name ACTUAL interfaces, classes, and functions from the codebase
+   - Include **sample code** in task descriptions: interface drafts, schema sketches, function signatures, config examples — enough for a human to review the design
+   - Include provenance linking back to constraints and evidence
+
+4. **SUBMIT the plan** — Call \`write_plan\` with the complete JSON
+
+## What "Show, Don't Tell" Means in Practice
+
+**BAD task description:**
+"Create a StorageProvider interface with methods for reading and writing plan data"
+
+**GOOD task description:**
+"Create a StorageProvider interface in src/storage/types.ts:
+
+\\\`\\\`\\\`typescript
+export interface StorageProvider {
+  readPlan(id: string): Promise<Plan>;
+  writePlan(id: string, plan: Plan): Promise<void>;
+  listPlans(): Promise<PlanMetadata[]>;
+  readStep(planId: string, stepNumber: number): Promise<PlanStep>;
+  writeStep(planId: string, step: PlanStep): Promise<void>;
+}
+\\\`\\\`\\\`
+
+This interface mirrors the existing file-based operations in plan/loader.ts but abstracts the storage backend. The key design choice is passing PlanStep objects rather than raw markdown — the provider handles serialization."
+
+The good version lets a human reviewer evaluate the interface design, method signatures, and data flow before any code is written.
+
+## Critical Rules
+
+- EXPLORE FIRST. Do NOT generate the plan without reading relevant code.
+- Every file path in filesChanged MUST be a real file you verified exists.
+- Every interface or type name MUST be verified in the codebase.
+- Include CODE SAMPLES in task descriptions: interface sketches, schema drafts, function signatures, example configs. Use markdown code blocks.
+- Be concrete: "Add a \`generatePlanWithAgent()\` function to \`src/ai/generator.ts\`" not "Add a new function to the generator"
+- If write_plan returns an error, fix the issue and call it again.
+- You MUST call write_plan exactly once with the complete plan when done.`;
+function createAgentProvider(provider, model) {
+  return {
+    name: provider.name,
+    execute: async (request) => {
+      const execRequest = createRequest(model);
+      for (const msg of request.messages) {
+        execRequest.addMessage(msg);
+      }
+      if (request.tools && request.tools.length > 0) {
+        execRequest.tools = request.tools;
+      }
+      const response = await provider.execute(execRequest);
+      return {
+        content: response.content,
+        model: response.model,
+        usage: response.usage ? {
+          inputTokens: response.usage.inputTokens,
+          outputTokens: response.usage.outputTokens
+        } : void 0,
+        toolCalls: response.toolCalls
+      };
+    },
+    executeStream: async function* (request) {
+      const execRequest = createRequest(model);
+      for (const msg of request.messages) {
+        execRequest.addMessage(msg);
+      }
+      if (request.tools && request.tools.length > 0) {
+        execRequest.tools = request.tools;
+      }
+      if (provider.executeStream) {
+        for await (const chunk of provider.executeStream(execRequest)) {
+          if (chunk.type === "text") {
+            yield { type: "text", text: chunk.text };
+          } else if (chunk.type === "tool_call_start") {
+            yield {
+              type: "tool_call_start",
+              toolCall: {
+                id: chunk.toolCall?.id,
+                index: chunk.toolCall?.index,
+                name: chunk.toolCall?.name
+              }
+            };
+          } else if (chunk.type === "tool_call_delta") {
+            yield {
+              type: "tool_call_delta",
+              toolCall: {
+                id: chunk.toolCall?.id,
+                index: chunk.toolCall?.index,
+                argumentsDelta: chunk.toolCall?.argumentsDelta
+              }
+            };
+          } else if (chunk.type === "tool_call_end") {
+            yield {
+              type: "tool_call_end",
+              toolCall: {
+                id: chunk.toolCall?.id,
+                index: chunk.toolCall?.index
+              }
+            };
+          } else if (chunk.type === "usage") {
+            yield {
+              type: "usage",
+              usage: chunk.usage ? {
+                inputTokens: chunk.usage.inputTokens,
+                outputTokens: chunk.usage.outputTokens
+              } : void 0
+            };
+          } else if (chunk.type === "done") {
+            yield { type: "done" };
+          }
+        }
+      } else {
+        const response = await provider.execute(execRequest);
+        yield { type: "text", text: response.content };
+        yield { type: "done" };
+      }
+    }
+  };
+}
+function buildAgentUserPrompt(context) {
+  const sections = [];
+  sections.push(`== PLAN NAME ==
+${context.planName}`);
+  let coreConcept = context.description;
+  const contextMarker = coreConcept.indexOf("\n\n--- IDEA CONTEXT ---");
+  if (contextMarker !== -1) {
+    coreConcept = coreConcept.substring(0, contextMarker).trim();
+  }
+  sections.push(`== CORE CONCEPT ==
+${coreConcept}`);
+  if (context.constraints && context.constraints.length > 0) {
+    const constraintsList = context.constraints.map((c, i) => `${i + 1}. ${c}`).join("\n");
+    sections.push(`== CONSTRAINTS (MUST HONOR ALL) ==
+The following constraints are NON-NEGOTIABLE. Every constraint must be addressed by at least one step.
+
+${constraintsList}`);
+  }
+  if (context.catalystContent?.constraints) {
+    sections.push(`== CATALYST CONSTRAINTS ==
+${context.catalystContent.constraints}`);
+  }
+  if (context.selectedApproach) {
+    sections.push(`== SELECTED APPROACH ==
+This approach was selected during shaping. Your plan MUST implement this approach.
+
+**Name**: ${context.selectedApproach.name}
+**Description**: ${context.selectedApproach.description}
+**Reasoning**: ${context.selectedApproach.reasoning}`);
+  }
+  if (context.evidence && context.evidence.length > 0) {
+    const evidenceContent = context.evidence.map((e) => `### ${e.name}
+${e.content.trim()}`).join("\n\n");
+    sections.push(`== EVIDENCE ==
+Evidence gathered during exploration. Use these findings to inform step design.
+
+${evidenceContent}`);
+  }
+  if (context.historyContext && context.historyContext.recentEvents.length > 0) {
+    const historyList = context.historyContext.recentEvents.map((e) => `- [${e.type}] ${e.summary}`).join("\n");
+    sections.push(`== HISTORY CONTEXT ==
+Recent events (${context.historyContext.totalEvents} total):
+
+${historyList}`);
+  }
+  if (context.questions && context.questions.length > 0) {
+    const questionsList = context.questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
+    sections.push(`== OPEN QUESTIONS ==
+Consider these when designing steps.
+
+${questionsList}`);
+  }
+  if (context.catalystContent?.domainKnowledge) {
+    sections.push(`== CATALYST DOMAIN KNOWLEDGE ==
+${context.catalystContent.domainKnowledge}`);
+  }
+  if (context.catalystContent?.processGuidance) {
+    sections.push(`== CATALYST PROCESS GUIDANCE ==
+${context.catalystContent.processGuidance}`);
+  }
+  if (context.catalystContent?.outputTemplates) {
+    sections.push(`== CATALYST OUTPUT TEMPLATES ==
+${context.catalystContent.outputTemplates}`);
+  }
+  if (context.codebaseContext) {
+    sections.push(`== CODEBASE CONTEXT ==
+${context.codebaseContext}`);
+  }
+  const stepCount = context.stepCount || 5;
+  sections.push(`== YOUR TASK ==
+
+Generate a ${stepCount}-step execution plan for this project.
+
+**Step 1: Explore the codebase.** Start by calling \`query_index\` with query "packages" to see the full project structure (this is instant — the index is pre-built). Then use \`query_index\` to find specific files and exports, \`read_file\` to examine key interfaces, and \`grep\` to find usage patterns.
+
+**Step 2: Call write_plan.** Once you understand the codebase well enough, call \`write_plan\` with the complete plan JSON. Include:
+- analysis (constraintAnalysis, evidenceAnalysis, approachAnalysis, risks)
+- summary, approach, successCriteria
+- ${stepCount} steps, each with concrete tasks referencing real files
+
+**IMPORTANT — Task descriptions must include sample code.** A human will review this plan before execution. Every task that introduces an interface, schema, config, or significant function should include a code sketch in its description using markdown code blocks. Don't write the full implementation — just enough for a person to judge the design: key method signatures, table schemas, type definitions, config formats. This is the plan's most important quality signal.
+
+Every step's \`filesChanged\` must list actual files from the codebase. Every task must reference real interfaces and functions. No placeholders.`);
+  return sections.join("\n\n");
+}
+async function generatePlanWithAgent(context, provider, codebaseTools, options = {}, projectRoot) {
+  const { onProgress } = options;
+  let tieringDecision;
+  let tieredContext = context;
+  if (context.constraints || context.evidence || context.historyContext) {
+    const budget = {
+      ...DEFAULT_TOKEN_BUDGET,
+      ...context.tokenBudget
+    };
+    tieringDecision = calculateTiering(
+      context.constraints || [],
+      context.selectedApproach || null,
+      context.evidence || [],
+      context.historyContext?.recentEvents.length || 0,
+      budget
+    );
+    if (context.evidence && context.evidence.length > 0) {
+      const tieredEvidence = applyEvidenceTiering(context.evidence, tieringDecision);
+      tieredContext = { ...context, evidence: tieredEvidence };
+    }
+    if (tieringDecision.historyAbbreviated && context.historyContext) {
+      const abbreviatedCount = budget.historyAbbreviatedCount || 5;
+      tieredContext = {
+        ...tieredContext,
+        historyContext: {
+          ...context.historyContext,
+          recentEvents: context.historyContext.recentEvents.slice(0, abbreviatedCount)
+        }
+      };
+    }
+  }
+  onProgress?.({ type: "started", message: "Starting agent-powered plan generation..." });
+  const { tool: writePlanTool, planPromise } = createWritePlanTool();
+  const workingDir = projectRoot || process.cwd();
+  const toolRegistry = ToolRegistry.create({
+    workingDirectory: workingDir
+  });
+  for (const tool of codebaseTools) {
+    toolRegistry.register(tool);
+  }
+  toolRegistry.register(writePlanTool);
+  const conversation = ConversationManager.create();
+  conversation.addSystemMessage(AGENT_SYSTEM_PROMPT);
+  const model = options.model || "claude-sonnet-4-20250514";
+  const agentProvider = createAgentProvider(provider, model);
+  const agentLoop = AgentLoop.create({
+    provider: agentProvider,
+    toolRegistry,
+    conversation,
+    model,
+    maxIterations: DEFAULT_MAX_ITERATIONS
+  });
+  const userPrompt = buildAgentUserPrompt(tieredContext);
+  onProgress?.({ type: "streaming", message: "Agent exploring codebase...", charsReceived: 0 });
+  let textContent = "";
+  let toolCallCount = 0;
+  let lastProgressUpdate = Date.now();
+  const agentDone = (async () => {
+    for await (const chunk of agentLoop.runStream(userPrompt)) {
+      if (chunk.type === "text" && chunk.text) {
+        textContent += chunk.text;
+      }
+      if (chunk.type === "tool_start" && chunk.tool) {
+        toolCallCount++;
+        const now = Date.now();
+        if (now - lastProgressUpdate > 300) {
+          const toolName = chunk.tool.name;
+          let detail = "";
+          if (toolName === "read_file" && chunk.tool.arguments?.path) {
+            detail = `: ${chunk.tool.arguments.path}`;
+          } else if (toolName === "grep" && chunk.tool.arguments?.pattern) {
+            detail = `: "${chunk.tool.arguments.pattern}"`;
+          } else if (toolName === "list_files" && chunk.tool.arguments?.path) {
+            detail = `: ${chunk.tool.arguments.path}`;
+          } else if (toolName === "write_plan") {
+            detail = " (submitting plan)";
+          }
+          onProgress?.({
+            type: "streaming",
+            message: `Agent: ${toolName}${detail} (${toolCallCount} tool calls)`,
+            charsReceived: textContent.length
+          });
+          lastProgressUpdate = now;
+        }
+      }
+      if (chunk.type === "tool_result" && chunk.tool) {
+        const now = Date.now();
+        if (now - lastProgressUpdate > 300) {
+          onProgress?.({
+            type: "streaming",
+            message: `Agent: ${chunk.tool.name} complete (${toolCallCount} tool calls)`,
+            charsReceived: textContent.length
+          });
+          lastProgressUpdate = now;
+        }
+      }
+    }
+  })();
+  let plan;
+  try {
+    const result = await Promise.race([
+      planPromise.then((p) => ({ type: "plan", plan: p })),
+      agentDone.then(() => ({ type: "done", plan: null }))
+    ]);
+    if (result.type === "plan") {
+      plan = result.plan;
+    } else {
+      try {
+        plan = await Promise.race([
+          planPromise,
+          new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 1e3))
+        ]);
+      } catch {
+        throw new Error(
+          `Agent completed ${toolCallCount} tool calls over ${DEFAULT_MAX_ITERATIONS} iterations but did not call write_plan to submit the plan. The agent may have run out of iterations. Try increasing maxIterations or simplifying the plan scope.`
+        );
+      }
+    }
+  } catch (error) {
+    writePlanTool._rejectPlan?.(error instanceof Error ? error : new Error(String(error)));
+    throw error;
+  }
+  onProgress?.({ type: "parsing", message: `Plan received with ${plan.steps.length} steps from ${toolCallCount} tool calls` });
+  onProgress?.({ type: "complete", message: "Agent-powered plan generation complete" });
+  return {
+    plan,
+    tiering: tieringDecision
+  };
+}
+async function loadProvider(config) {
+  const { name, apiKey, session, mcpServer } = config;
+  if (session && session.providerMode === "sampling") {
+    return await loadSamplingProvider(session, mcpServer);
+  }
+  if (name) {
+    return await loadDirectProvider(name, apiKey);
+  }
+  const defaultProvider = getDefaultProvider();
+  if (defaultProvider) {
+    return await loadDirectProvider(defaultProvider, apiKey);
+  }
+  const clientName = session?.clientInfo?.name ?? "your client";
+  const errorMessage = [
+    "❌ No AI provider available for RiotPlan.",
+    "",
+    `Your client (${clientName}) does not support MCP sampling, and no API keys are configured.`,
+    "",
+    "To use RiotPlan's AI generation features, either:",
+    "",
+    "1. Use a client that supports MCP sampling:",
+    "   - GitHub Copilot (supports sampling)",
+    "   - FastMCP (Python framework for testing)",
+    "",
+    "2. Set up an API key:",
+    "   - ANTHROPIC_API_KEY for Claude models (recommended)",
+    "   - OPENAI_API_KEY for GPT models",
+    "   - GOOGLE_API_KEY for Gemini models",
+    "",
+    "3. Create plan steps manually:",
+    "   - Use riotplan_step with action=add to add steps without AI",
+    "",
+    "For more information: https://github.com/kjerneverk/riotplan#ai-providers"
+  ].join("\n");
+  throw new Error(errorMessage);
+}
+async function loadSamplingProvider(session, mcpServer) {
+  try {
+    const { createSamplingProvider } = await import("@kjerneverk/execution-sampling");
+    const provider = createSamplingProvider({
+      sessionId: session.sessionId,
+      clientName: session.clientInfo?.name,
+      supportsTools: false,
+      // RiotPlan doesn't use tools in generation
+      debug: false
+    });
+    if (mcpServer) {
+      provider.setSamplingClient(mcpServer);
+    }
+    return provider;
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("Cannot find package") || error.message.includes("Cannot find module") || error.message.includes("Could not resolve"))) {
+      throw new Error(
+        "Sampling provider (@kjerneverk/execution-sampling) is not installed.\nThis is a development error - the package should be installed as a dependency."
+      );
+    }
+    throw error;
+  }
+}
+async function loadDirectProvider(name, apiKey) {
+  try {
+    switch (name.toLowerCase()) {
+      case "anthropic":
+      case "claude":
+        return await loadAnthropicProvider(apiKey);
+      case "openai":
+      case "gpt":
+        return await loadOpenAIProvider(apiKey);
+      case "gemini":
+      case "google":
+        return await loadGeminiProvider(apiKey);
+      default:
+        throw new Error(`Unknown provider: ${name}`);
+    }
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("Cannot find package") || error.message.includes("Cannot find module") || error.message.includes("Could not resolve"))) {
+      const errorMessage = [
+        `❌ Provider '${name}' is not installed.`,
+        "",
+        "To use this provider, install it:",
+        `  npm install @kjerneverk/execution-${name}`,
+        "",
+        "Then set the appropriate API key:",
+        `  export ${name.toUpperCase()}_API_KEY="your-key-here"`,
+        "",
+        "Alternative options:",
+        "  1. Use a different provider (anthropic, openai, gemini)",
+        "  2. Use RiotPlan via MCP with a sampling-enabled client",
+        "  3. Create plan steps manually with riotplan_step(action=add)"
+      ].join("\n");
+      throw new Error(errorMessage);
+    }
+    throw error;
+  }
+}
+async function loadAnthropicProvider(_apiKey) {
+  const { createAnthropicProvider } = await import("@kjerneverk/execution-anthropic");
+  return createAnthropicProvider();
+}
+async function loadOpenAIProvider(_apiKey) {
+  const { createOpenAIProvider } = await import("@kjerneverk/execution-openai");
+  return createOpenAIProvider();
+}
+async function loadGeminiProvider(_apiKey) {
+  const { createGeminiProvider } = await import("@kjerneverk/execution-gemini");
+  return createGeminiProvider();
+}
+async function detectAvailableProviders() {
+  const providers = [];
+  const candidates = [
+    { name: "anthropic", pkg: "@kjerneverk/execution-anthropic" },
+    { name: "openai", pkg: "@kjerneverk/execution-openai" },
+    { name: "gemini", pkg: "@kjerneverk/execution-gemini" }
+  ];
+  for (const candidate of candidates) {
+    try {
+      await import(candidate.pkg);
+      providers.push(candidate.name);
+    } catch {
+    }
+  }
+  return providers;
+}
+function getDefaultProvider() {
+  if (process.env.ANTHROPIC_API_KEY) return "anthropic";
+  if (process.env.OPENAI_API_KEY) return "openai";
+  if (process.env.GOOGLE_API_KEY) return "gemini";
+  return null;
+}
+function getProviderApiKey(provider) {
+  switch (provider.toLowerCase()) {
+    case "anthropic":
+    case "claude":
+      return process.env.ANTHROPIC_API_KEY;
+    case "openai":
+    case "gpt":
+      return process.env.OPENAI_API_KEY;
+    case "gemini":
+    case "google":
+      return process.env.GOOGLE_API_KEY;
+    default:
+      return void 0;
+  }
+}
+class ConstraintCoverageCheck {
+  name = "constraint-coverage";
+  validate(plan, context) {
+    const warnings = [];
+    const coverage = {};
+    const constraints = context.constraints || [];
+    if (constraints.length === 0) {
+      return {
+        passed: true,
+        warnings: [],
+        details: { coverage, message: "No constraints to validate" }
+      };
+    }
+    for (const step of plan.steps) {
+      if (step.provenance?.constraintsAddressed) {
+        for (const constraint of step.provenance.constraintsAddressed) {
+          if (!coverage[constraint]) {
+            coverage[constraint] = [];
+          }
+          coverage[constraint].push(`Step ${step.number}`);
+        }
+      }
+    }
+    for (const constraint of constraints) {
+      const addressed = Object.keys(coverage).some(
+        (key) => constraint.includes(key) || key.includes(constraint.substring(0, 50))
+      );
+      if (!addressed) {
+        warnings.push(`Constraint not addressed: "${constraint.substring(0, 80)}${constraint.length > 80 ? "..." : ""}"`);
+      }
+    }
+    return {
+      passed: warnings.length === 0,
+      warnings,
+      details: {
+        coverage,
+        totalConstraints: constraints.length,
+        coveredConstraints: constraints.length - warnings.length
+      }
+    };
+  }
+}
+class EvidenceReferenceCheck {
+  name = "evidence-reference";
+  validate(plan, context) {
+    const warnings = [];
+    const references = {};
+    const evidence = context.evidence || [];
+    if (evidence.length === 0) {
+      return {
+        passed: true,
+        warnings: [],
+        details: { references, message: "No evidence to validate" }
+      };
+    }
+    const analysisFiles = /* @__PURE__ */ new Set();
+    if (plan.analysis?.evidenceAnalysis) {
+      for (const ea of plan.analysis.evidenceAnalysis) {
+        analysisFiles.add(ea.evidenceFile);
+      }
+    }
+    for (const step of plan.steps) {
+      if (step.provenance?.evidenceUsed) {
+        for (const evidenceFile of step.provenance.evidenceUsed) {
+          if (!references[evidenceFile]) {
+            references[evidenceFile] = [];
+          }
+          references[evidenceFile].push(`Step ${step.number}`);
+        }
+      }
+    }
+    for (const ev of evidence) {
+      const inAnalysis = analysisFiles.has(ev.name);
+      const inSteps = references[ev.name] && references[ev.name].length > 0;
+      if (!inAnalysis && !inSteps) {
+        warnings.push(`Evidence file not referenced: "${ev.name}"`);
+      }
+    }
+    return {
+      passed: warnings.length === 0,
+      warnings,
+      details: {
+        references,
+        analysisFiles: Array.from(analysisFiles),
+        totalEvidence: evidence.length,
+        referencedEvidence: evidence.length - warnings.length
+      }
+    };
+  }
+}
+class SelectedApproachCheck {
+  name = "selected-approach";
+  validate(plan, context) {
+    const warnings = [];
+    if (!context.selectedApproach) {
+      return {
+        passed: true,
+        warnings: [],
+        details: { message: "No selected approach to validate" }
+      };
+    }
+    const approachName = context.selectedApproach.name;
+    if (!plan.analysis?.approachAnalysis) {
+      warnings.push(`Selected approach "${approachName}" not analyzed in the analysis section`);
+    } else {
+      const analysisText = JSON.stringify(plan.analysis.approachAnalysis).toLowerCase();
+      if (!analysisText.includes(approachName.toLowerCase())) {
+        warnings.push(`Selected approach "${approachName}" not mentioned in approach analysis`);
+      }
+    }
+    const planText = (plan.summary + " " + plan.approach).toLowerCase();
+    if (!planText.includes(approachName.toLowerCase())) {
+      warnings.push(`Selected approach "${approachName}" not mentioned in plan summary or approach`);
+    }
+    return {
+      passed: warnings.length === 0,
+      warnings,
+      details: {
+        approachName,
+        hasApproachAnalysis: !!plan.analysis?.approachAnalysis
+      }
+    };
+  }
+}
+class ValidationPipeline {
+  checks = [];
+  constructor() {
+    this.addCheck(new ConstraintCoverageCheck());
+    this.addCheck(new EvidenceReferenceCheck());
+    this.addCheck(new SelectedApproachCheck());
+  }
+  /**
+   * Add a custom validation check
+   */
+  addCheck(check) {
+    this.checks.push(check);
+  }
+  /**
+   * Run all validation checks
+   */
+  validate(plan, context) {
+    const results = [];
+    const allWarnings = [];
+    for (const check of this.checks) {
+      const result = check.validate(plan, context);
+      results.push({ name: check.name, result });
+      allWarnings.push(...result.warnings);
+    }
+    return {
+      overallPassed: allWarnings.length === 0,
+      checks: results,
+      allWarnings
+    };
+  }
+}
+function validatePlan(plan, context) {
+  const pipeline = new ValidationPipeline();
+  return pipeline.validate(plan, context);
+}
+function generateProvenanceMarkdown(data) {
+  const { plan, context, validation, tiering, generatedAt } = data;
+  const sections = [];
+  sections.push(`# Plan Provenance
+
+This document traces how the generated plan connects to the idea artifacts.`);
+  sections.push(`## How This Plan Was Generated
+
+- **Generated**: ${generatedAt.toISOString()}
+- **Constraints**: ${context.constraints?.length || 0}
+- **Evidence files**: ${context.evidence?.length || 0}
+- **Selected approach**: ${context.selectedApproach?.name || "None"}
+- **History events**: ${context.historyContext?.totalEvents || 0}`);
+  sections.push(`## Artifact Analysis`);
+  if (plan.analysis?.constraintAnalysis && plan.analysis.constraintAnalysis.length > 0) {
+    sections.push(`### Constraints
+
+The model analyzed ${plan.analysis.constraintAnalysis.length} constraint(s):
+
+| # | Constraint | Addressed By | Model's Understanding |
+|---|-----------|-------------|----------------------|`);
+    for (let i = 0; i < plan.analysis.constraintAnalysis.length; i++) {
+      const ca = plan.analysis.constraintAnalysis[i];
+      const addressedBy = [];
+      for (const step of plan.steps) {
+        if (step.provenance?.constraintsAddressed) {
+          for (const constraintRef of step.provenance.constraintsAddressed) {
+            if (ca.constraint.includes(constraintRef) || constraintRef.includes(ca.constraint.substring(0, 30))) {
+              addressedBy.push(`Step ${step.number}`);
+              break;
+            }
+          }
+        }
+      }
+      const constraintText = ca.constraint.length > 60 ? ca.constraint.substring(0, 60) + "..." : ca.constraint;
+      const understanding = ca.understanding.length > 80 ? ca.understanding.substring(0, 80) + "..." : ca.understanding;
+      const steps = addressedBy.length > 0 ? addressedBy.join(", ") : "*(none)*";
+      sections.push(`| ${i + 1} | ${constraintText} | ${steps} | ${understanding} |`);
+    }
+  } else if (context.constraints && context.constraints.length > 0) {
+    sections.push(`### Constraints
+
+${context.constraints.length} constraint(s) were provided but not analyzed in the response.`);
+  }
+  if (plan.analysis?.evidenceAnalysis && plan.analysis.evidenceAnalysis.length > 0) {
+    sections.push(`
+### Evidence Used
+
+The model analyzed ${plan.analysis.evidenceAnalysis.length} evidence file(s):
+
+| File | Key Findings | Referenced In |
+|------|-------------|--------------|`);
+    for (const ea of plan.analysis.evidenceAnalysis) {
+      const referencedIn = [];
+      for (const step of plan.steps) {
+        if (step.provenance?.evidenceUsed?.includes(ea.evidenceFile)) {
+          referencedIn.push(`Step ${step.number}`);
+        }
+      }
+      const findings = ea.keyFindings.length > 100 ? ea.keyFindings.substring(0, 100) + "..." : ea.keyFindings;
+      const refs = referencedIn.length > 0 ? referencedIn.join(", ") : "*(none)*";
+      sections.push(`| ${ea.evidenceFile} | ${findings} | ${refs} |`);
+    }
+  } else if (context.evidence && context.evidence.length > 0) {
+    sections.push(`
+### Evidence Used
+
+${context.evidence.length} evidence file(s) were provided but not analyzed in the response.`);
+  }
+  if (plan.analysis?.approachAnalysis) {
+    const aa = plan.analysis.approachAnalysis;
+    sections.push(`
+### Selected Approach
+
+- **Approach**: ${aa.selectedApproach}
+- **Commitments**: ${aa.commitments}
+- **Implementation Strategy**: ${aa.implementationStrategy}`);
+  } else if (context.selectedApproach) {
+    sections.push(`
+### Selected Approach
+
+A selected approach ("${context.selectedApproach.name}") was provided but not analyzed in the response.`);
+  }
+  if (plan.analysis?.risks && plan.analysis.risks.length > 0) {
+    sections.push(`
+### Risks Identified
+
+${plan.analysis.risks.map((r, i) => `${i + 1}. ${r}`).join("\n")}`);
+  }
+  if (validation.allWarnings.length > 0) {
+    sections.push(`## Coverage Warnings
+
+The following gaps were detected during validation:
+
+${validation.allWarnings.map((w) => `- ${w}`).join("\n")}`);
+  } else {
+    sections.push(`## Coverage Validation
+
+✅ All constraints addressed, all evidence referenced, selected approach implemented.`);
+  }
+  if (tiering) {
+    sections.push(`## Token Budget
+
+- **Estimated tokens**: ${tiering.totalEstimatedTokens}
+- **Budget exceeded**: ${tiering.budgetExceeded ? "Yes" : "No"}`);
+    if (tiering.evidenceTiered.full.length > 0) {
+      sections.push(`- **Evidence (full)**: ${tiering.evidenceTiered.full.join(", ")}`);
+    }
+    if (tiering.evidenceTiered.summarized.length > 0) {
+      sections.push(`- **Evidence (summarized)**: ${tiering.evidenceTiered.summarized.join(", ")}`);
+    }
+    if (tiering.evidenceTiered.listOnly.length > 0) {
+      sections.push(`- **Evidence (preview only)**: ${tiering.evidenceTiered.listOnly.join(", ")}`);
+    }
+    if (tiering.historyAbbreviated) {
+      sections.push(`- **History**: abbreviated to most recent events`);
+    }
+    if (tiering.warnings.length > 0) {
+      sections.push(`
+### Tiering Warnings
+
+${tiering.warnings.map((w) => `- ${w}`).join("\n")}`);
+    }
+  }
+  sections.push(`## Step Provenance
+
+How each step connects to the idea artifacts:
+`);
+  for (const step of plan.steps) {
+    sections.push(`### Step ${step.number}: ${step.title}`);
+    if (step.provenance) {
+      if (step.provenance.rationale) {
+        sections.push(`
+**Rationale**: ${step.provenance.rationale}`);
+      }
+      if (step.provenance.constraintsAddressed && step.provenance.constraintsAddressed.length > 0) {
+        sections.push(`
+**Addresses constraints**: ${step.provenance.constraintsAddressed.join(", ")}`);
+      }
+      if (step.provenance.evidenceUsed && step.provenance.evidenceUsed.length > 0) {
+        sections.push(`
+**Uses evidence**: ${step.provenance.evidenceUsed.join(", ")}`);
+      }
+    } else {
+      sections.push(`
+*(No provenance data)*`);
+    }
+    sections.push("");
+  }
+  return sections.join("\n\n");
+}
+async function readFileSafe(path) {
+  try {
+    return await readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function getMostRecentFileByType(files, fileType) {
+  const matches = files.filter((file) => file.type === fileType).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+  return matches[0]?.content ?? null;
+}
+function normalizeArtifactKey(value) {
+  return (value || "").trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function isArtifactMatch(file, aliases, filenameCandidates) {
+  const normalizedType = normalizeArtifactKey(file.type);
+  const normalizedFilename = normalizeArtifactKey(file.filename);
+  const normalizedAliases = aliases.map(normalizeArtifactKey);
+  const normalizedCandidates = filenameCandidates.map(normalizeArtifactKey);
+  return normalizedAliases.includes(normalizedType) || normalizedCandidates.includes(normalizedFilename);
+}
+function getMostRecentArtifactContent(files, aliases, filenameCandidates) {
+  const matches = files.filter((file) => isArtifactMatch(file, aliases, filenameCandidates)).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+  return matches[0]?.content ?? null;
+}
+function extractConstraints(ideaContent) {
+  const constraints = [];
+  const constraintsMatch = ideaContent.match(/## Constraints\n\n([\s\S]*?)(?=\n## |$)/);
+  if (constraintsMatch) {
+    const lines = constraintsMatch[1].split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("- ") && !trimmed.includes("_Add constraints")) {
+        constraints.push(trimmed.substring(2));
+      }
+    }
+  }
+  return constraints;
+}
+function extractQuestions(ideaContent) {
+  const questions = [];
+  const questionsMatch = ideaContent.match(/## Questions\n\n([\s\S]*?)(?=\n## |$)/);
+  if (questionsMatch) {
+    const lines = questionsMatch[1].split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("- ") && !trimmed.includes("_Add questions")) {
+        questions.push(trimmed.substring(2));
+      }
+    }
+  }
+  return questions;
+}
+function extractSelectedApproach(shapingContent) {
+  const nameMatch = shapingContent.match(/\*\*Selected Approach\*\*: (.+)/);
+  if (!nameMatch) return null;
+  const approachName = nameMatch[1].trim();
+  const approachPattern = new RegExp(`### Approach: ${approachName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s+\\*\\*Description\\*\\*: ([\\s\\S]*?)(?:\\*\\*Tradeoffs\\*\\*:|### Approach:|## |$)`);
+  const approachMatch = shapingContent.match(approachPattern);
+  const reasoningMatch = shapingContent.match(/\*\*Reasoning\*\*: ([^\n]+)/);
+  return {
+    name: approachName,
+    description: approachMatch ? approachMatch[1].trim() : "",
+    reasoning: reasoningMatch ? reasoningMatch[1].trim() : ""
+  };
+}
+async function readEvidenceFiles(planPath, includeContent = true) {
+  const evidenceDir = join(planPath, "evidence");
+  const dotEvidenceDir = join(planPath, ".evidence");
+  let files = [];
+  let actualDir = evidenceDir;
+  try {
+    files = await readdir(evidenceDir);
+  } catch {
+    try {
+      files = await readdir(dotEvidenceDir);
+      actualDir = dotEvidenceDir;
+    } catch {
+      return [];
+    }
+  }
+  const evidenceFiles = [];
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const filePath = join(actualDir, file);
+    try {
+      const stats = await stat(filePath);
+      let content = "";
+      if (includeContent) {
+        const fileContent = await readFile(filePath, "utf-8");
+        content = fileContent;
+      }
+      evidenceFiles.push({
+        name: file,
+        content,
+        size: stats.size
+      });
+    } catch {
+    }
+  }
+  return evidenceFiles;
+}
+async function readRecentHistory(planPath, limit = 15) {
+  const timelinePath = join(planPath, ".history", "timeline.jsonl");
+  try {
+    const content = await readFile(timelinePath, "utf-8");
+    const lines = content.trim().split("\n").filter((line) => line.trim());
+    const totalEvents = lines.length;
+    const recentLines = lines.slice(-limit);
+    const recentEvents = [];
+    for (const line of recentLines) {
+      try {
+        const event = JSON.parse(line);
+        recentEvents.push({
+          type: event.type || "unknown",
+          timestamp: event.timestamp || "",
+          summary: summarizeEvent(event)
+        });
+      } catch {
+      }
+    }
+    return { recentEvents, totalEvents };
+  } catch {
+    return { recentEvents: [], totalEvents: 0 };
+  }
+}
+function summarizeEvent(event) {
+  const type = event.type || "unknown";
+  const data = event.data || {};
+  switch (type) {
+    case "note_added":
+      return `Note: ${truncate(data.note, 60)}`;
+    case "constraint_added":
+      return `Constraint: ${truncate(data.constraint, 60)}`;
+    case "question_added":
+      return `Question: ${truncate(data.question, 60)}`;
+    case "evidence_added":
+      return `Evidence: ${truncate(data.description, 60)}`;
+    case "narrative_chunk":
+      return `Narrative: ${truncate(data.content, 60)}`;
+    case "approach_added":
+      return `Approach: ${data.name || "unnamed"}`;
+    case "approach_selected":
+      return `Selected: ${data.approach || "unknown"}`;
+    case "shaping_started":
+      return "Shaping started";
+    case "checkpoint_created":
+      return `Checkpoint: ${data.name || "unnamed"}`;
+    case "step_reflected":
+      return `Step ${data.step || "?"} reflection: ${truncate(data.reflection, 60)}`;
+    default:
+      return type;
+  }
+}
+function truncate(str, maxLength) {
+  if (!str) return "";
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength - 3) + "...";
+}
+function loadCatalystContent(mergedCatalyst) {
+  if (!mergedCatalyst) {
+    return void 0;
+  }
+  const renderFacet = (facetContent) => {
+    if (!facetContent || facetContent.length === 0) {
+      return "";
+    }
+    const bySource = /* @__PURE__ */ new Map();
+    for (const item of facetContent) {
+      const existing = bySource.get(item.sourceId) || [];
+      existing.push(item.content);
+      bySource.set(item.sourceId, existing);
+    }
+    const parts = [];
+    for (const [sourceId, contents] of bySource) {
+      parts.push(`### From ${sourceId}
+
+${contents.join("\n\n")}`);
+    }
+    return parts.join("\n\n");
+  };
+  return {
+    constraints: renderFacet(mergedCatalyst.facets.constraints),
+    domainKnowledge: renderFacet(mergedCatalyst.facets.domainKnowledge),
+    outputTemplates: renderFacet(mergedCatalyst.facets.outputTemplates),
+    processGuidance: renderFacet(mergedCatalyst.facets.processGuidance),
+    questions: renderFacet(mergedCatalyst.facets.questions),
+    validationRules: renderFacet(mergedCatalyst.facets.validationRules),
+    appliedCatalysts: mergedCatalyst.catalystIds
+  };
+}
+async function loadArtifacts(planPath) {
+  if (planPath.endsWith(".plan")) {
+    const provider = createSqliteProvider(planPath);
+    try {
+      const [filesResult, metadataResult, evidenceResult, allEventsResult] = await Promise.all([
+        provider.getFiles(),
+        provider.getMetadata(),
+        provider.getEvidence(),
+        provider.getTimelineEvents()
+      ]);
+      if (!filesResult.success) {
+        throw new Error(filesResult.error || "Failed to load plan files from SQLite");
+      }
+      if (!metadataResult.success || !metadataResult.data) {
+        throw new Error(metadataResult.error || "Failed to load plan metadata from SQLite");
+      }
+      if (!evidenceResult.success) {
+        throw new Error(evidenceResult.error || "Failed to load evidence from SQLite");
+      }
+      if (!allEventsResult.success) {
+        throw new Error(allEventsResult.error || "Failed to load timeline events from SQLite");
+      }
+      const files = filesResult.data || [];
+      const ideaContent2 = getMostRecentArtifactContent(files, ["idea"], ["IDEA.md", "idea"]) || getMostRecentFileByType(files, "idea");
+      const shapingContent2 = getMostRecentArtifactContent(files, ["shaping"], ["SHAPING.md", "shaping"]) || getMostRecentFileByType(files, "shaping");
+      const lifecycleFile = getMostRecentArtifactContent(files, ["lifecycle"], ["LIFECYCLE.md", "lifecycle"]) || getMostRecentFileByType(files, "lifecycle");
+      const lifecycleContent2 = lifecycleFile || `# Lifecycle
+
+## Current Stage
+
+**Stage**: \`${metadataResult.data.stage}\`
+**Since**: ${metadataResult.data.updatedAt}
+`;
+      const evidence2 = (evidenceResult.data || []).map((entry) => {
+        const body = entry.content || entry.summary || entry.description;
+        return {
+          name: entry.filePath || `${entry.id}.md`,
+          content: body,
+          size: Buffer.byteLength(body, "utf-8")
+        };
+      });
+      const events = (allEventsResult.data || []).slice().sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+      const recentEvents = events.slice(-15).map((event) => ({
+        type: event.type || "unknown",
+        timestamp: event.timestamp || "",
+        summary: summarizeEvent(event)
+      }));
+      const constraints2 = ideaContent2 ? extractConstraints(ideaContent2) : [];
+      const questions2 = ideaContent2 ? extractQuestions(ideaContent2) : [];
+      const selectedApproach2 = shapingContent2 ? extractSelectedApproach(shapingContent2) : null;
+      return {
+        ideaContent: ideaContent2,
+        shapingContent: shapingContent2,
+        lifecycleContent: lifecycleContent2,
+        artifactDiagnostics: {
+          planId: planPath,
+          hasIdeaArtifact: Boolean(ideaContent2),
+          detectedArtifacts: files.map((file) => ({
+            type: file.type,
+            filename: file.filename
+          }))
+        },
+        constraints: constraints2,
+        questions: questions2,
+        selectedApproach: selectedApproach2,
+        evidence: evidence2,
+        historyContext: {
+          recentEvents,
+          totalEvents: events.length
+        }
+      };
+    } finally {
+      await provider.close();
+    }
+  }
+  const [ideaContent, shapingContent, lifecycleContent, evidence, history] = await Promise.all([
+    readFileSafe(join(planPath, "IDEA.md")),
+    readFileSafe(join(planPath, "SHAPING.md")),
+    readFileSafe(join(planPath, "LIFECYCLE.md")),
+    readEvidenceFiles(planPath, true),
+    readRecentHistory(planPath)
+  ]);
+  const constraints = ideaContent ? extractConstraints(ideaContent) : [];
+  const questions = ideaContent ? extractQuestions(ideaContent) : [];
+  const selectedApproach = shapingContent ? extractSelectedApproach(shapingContent) : null;
+  return {
+    ideaContent,
+    shapingContent,
+    lifecycleContent,
+    artifactDiagnostics: {
+      planId: planPath,
+      hasIdeaArtifact: Boolean(ideaContent),
+      detectedArtifacts: [
+        ...ideaContent ? [{ type: "idea", filename: "IDEA.md" }] : [],
+        ...shapingContent ? [{ type: "shaping", filename: "SHAPING.md" }] : [],
+        ...lifecycleContent ? [{ type: "lifecycle", filename: "LIFECYCLE.md" }] : []
+      ]
+    },
+    constraints,
+    questions,
+    selectedApproach,
+    evidence,
+    historyContext: history
+  };
+}
+export {
+  ConstraintCoverageCheck,
+  DEFAULT_TOKEN_BUDGET,
+  EvidenceReferenceCheck,
+  PLAN_GENERATION_RESPONSE_SCHEMA,
+  SelectedApproachCheck,
+  ValidationPipeline,
+  applyEvidenceTiering,
+  buildPlanPrompt,
+  calculateTiering,
+  createWritePlanTool,
+  detectAvailableProviders,
+  estimateTokens,
+  extractConstraints,
+  extractQuestions,
+  extractSelectedApproach,
+  formatStep,
+  formatSummary,
+  generatePlan,
+  generatePlanWithAgent,
+  generateProvenanceMarkdown,
+  getDefaultProvider,
+  getPlanGenerationSystemPrompt,
+  getProviderApiKey,
+  loadArtifacts,
+  loadCatalystContent,
+  loadProvider,
+  parsePlanResponse,
+  readEvidenceFiles,
+  readRecentHistory,
+  truncateToLines,
+  validatePlan as validateGeneratedPlan
+};
+//# sourceMappingURL=index.js.map