@wkronmiller/lisa 0.1.0

package/src/spec/planner.ts

@@ -0,0 +1,299 @@
+import type {
+  LoadedSpecWorkspace,
+  ParsedSpecDocument,
+  PlannedBenchmarkContext,
+  PlannedSpecTarget,
+  PlannedTask,
+  SpecDelta,
+  SpecDiffReport,
+  SpecImplementationPlan,
+} from "./types";
+
+function normalizeHeading(title: string): string {
+  return title.toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+function extractStringArray(frontmatter: Record<string, unknown>, key: string): string[] {
+  const value = frontmatter[key];
+  return Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0)
+    : [];
+}
+
+function extractStringRecord(frontmatter: Record<string, unknown>, key: string): Record<string, string> {
+  const value = frontmatter[key];
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+
+  return Object.fromEntries(
+    Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string" && entry[1].trim().length > 0),
+  );
+}
+
+function extractBulletList(document: ParsedSpecDocument | undefined, title: string): string[] {
+  const section = document?.sections.find((entry) => normalizeHeading(entry.title) === normalizeHeading(title));
+  if (!section || section.content.trim().length === 0) {
+    return [];
+  }
+
+  const bullets = section.content
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith("- "))
+    .map((line) => line.slice(2).trim())
+    .filter((line) => line.length > 0);
+
+  return bullets.length > 0 ? bullets : [section.content.trim()];
+}
+
+function getDeltaDocument(delta: SpecDelta): ParsedSpecDocument | undefined {
+  return delta.nextDocument ?? delta.previousDocument;
+}
+
+function getBaseSpecDocument(
+  specId: string,
+  workspace: LoadedSpecWorkspace,
+  deltas: SpecDelta[],
+): ParsedSpecDocument | undefined {
+  const changedBase = deltas.find((delta) => delta.kind === "base" && delta.specId === specId);
+  if (changedBase) {
+    return getDeltaDocument(changedBase);
+  }
+
+  return workspace.documents.find((document) => document.kind === "base" && document.id === specId);
+}
+
+function buildBenchmarkContext(delta: SpecDelta): PlannedBenchmarkContext | undefined {
+  const document = getDeltaDocument(delta);
+  if (!document) {
+    return undefined;
+  }
+
+  return {
+    id: delta.specId,
+    path: document.path,
+    fileChange: delta.fileChange,
+    environment: typeof document.frontmatter.environment === "string" ? document.frontmatter.environment : undefined,
+    required: typeof document.frontmatter.required === "boolean" ? document.frontmatter.required : undefined,
+    command: typeof document.frontmatter.command === "string" ? document.frontmatter.command : undefined,
+    metrics: extractStringRecord(document.frontmatter, "metrics"),
+  };
+}
+
+function getBenchmarkContexts(
+  specId: string,
+  workspace: LoadedSpecWorkspace,
+  deltas: SpecDelta[],
+): PlannedBenchmarkContext[] {
+  const contexts = new Map<string, PlannedBenchmarkContext>();
+
+  for (const document of workspace.documents) {
+    if (document.kind !== "benchmark" || document.frontmatter.extends !== specId) {
+      continue;
+    }
+
+    contexts.set(document.id ?? document.path, {
+      id: document.id ?? document.path,
+      path: document.path,
+      fileChange: "modified",
+      environment: typeof document.frontmatter.environment === "string" ? document.frontmatter.environment : undefined,
+      required: typeof document.frontmatter.required === "boolean" ? document.frontmatter.required : undefined,
+      command: typeof document.frontmatter.command === "string" ? document.frontmatter.command : undefined,
+      metrics: extractStringRecord(document.frontmatter, "metrics"),
+    });
+  }
+
+  for (const delta of deltas) {
+    if (delta.kind !== "benchmark" || delta.extendsSpecId !== specId) {
+      continue;
+    }
+
+    const context = buildBenchmarkContext(delta);
+    if (context) {
+      contexts.set(context.id, context);
+    }
+  }
+
+  return Array.from(contexts.values()).sort((left, right) => left.id.localeCompare(right.id));
+}
+
+function buildSpecTarget(
+  baseDelta: SpecDelta | undefined,
+  baseDocument: ParsedSpecDocument,
+  workspace: LoadedSpecWorkspace,
+  deltas: SpecDelta[],
+): PlannedSpecTarget {
+  return {
+    specId: baseDocument.id ?? baseDocument.path,
+    path: baseDocument.path,
+    fileChange: baseDelta?.fileChange ?? "modified",
+    codePaths: extractStringArray(baseDocument.frontmatter, "code_paths"),
+    testPaths: extractStringArray(baseDocument.frontmatter, "test_paths"),
+    testCommands: extractStringArray(baseDocument.frontmatter, "test_commands"),
+    invariants: extractBulletList(baseDocument, "Invariants"),
+    acceptanceCriteria: extractBulletList(baseDocument, "Acceptance Criteria"),
+    benchmarkSidecars: getBenchmarkContexts(baseDocument.id ?? baseDocument.path, workspace, deltas),
+  };
+}
+
+function hasChangeType(delta: SpecDelta, changeType: string): boolean {
+  return delta.sectionChanges.some((change) => change.changeType === changeType);
+}
+
+function hasAnyChangeType(delta: SpecDelta, changeTypes: string[]): boolean {
+  return changeTypes.some((changeType) => hasChangeType(delta, changeType));
+}
+
+function buildTasksForDelta(delta: SpecDelta, target?: PlannedSpecTarget): PlannedTask[] {
+  const tasks: PlannedTask[] = [];
+  const baseTargets = target ? [...target.codePaths, ...target.testPaths] : undefined;
+
+  if (delta.kind === "base") {
+    if (delta.fileChange === "added") {
+      tasks.push({
+        id: `${delta.specId}:code`,
+        specId: delta.specId,
+        type: "code",
+        description: `Implement the new behavior or repository artifacts described by ${delta.specId} within the mapped code paths, creating missing mapped files when required and starting with the narrowest affected files.`,
+        targets: target?.codePaths,
+      });
+      tasks.push({
+        id: `${delta.specId}:test`,
+        specId: delta.specId,
+        type: "test",
+        description: `Add or update the smallest mapped tests or artifact assertions needed to cover every acceptance criterion introduced by ${delta.specId}.`,
+        targets: target?.testPaths,
+      });
+    } else if (delta.fileChange === "modified") {
+      if (
+        hasAnyChangeType(delta, [
+          "frontmatter_changed",
+          "summary_changed",
+          "use_case_added_or_removed",
+          "invariant_added_or_removed",
+          "failure_modes_changed",
+          "acceptance_added_or_removed",
+        ])
+      ) {
+        tasks.push({
+          id: `${delta.specId}:code`,
+          specId: delta.specId,
+          type: "code",
+          description: `Update the mapped implementation or repository artifacts directly impacted by the changed requirements in ${delta.specId}.`,
+          targets: target?.codePaths,
+        });
+      }
+
+      if (hasChangeType(delta, "acceptance_added_or_removed")) {
+        tasks.push({
+          id: `${delta.specId}:test`,
+          specId: delta.specId,
+          type: "test",
+          description: `Refresh the smallest mapped tests or artifact assertions so the updated acceptance criteria for ${delta.specId} are enforced.`,
+          targets: target?.testPaths,
+        });
+      }
+
+      if (hasChangeType(delta, "invariant_added_or_removed")) {
+        tasks.push({
+          id: `${delta.specId}:review`,
+          specId: delta.specId,
+          type: "review",
+          description: `Preserve and strengthen regression coverage for the invariants changed in ${delta.specId}, using the closest existing test layer when possible.`,
+          targets: baseTargets,
+        });
+      }
+
+      if (delta.sectionChanges.length > 0 && tasks.length === 0) {
+        tasks.push({
+          id: `${delta.specId}:review`,
+          specId: delta.specId,
+          type: "review",
+          description: `Review the changed spec metadata and ensure the implementation scope for ${delta.specId} still matches the spec.`,
+          targets: baseTargets,
+        });
+      }
+    } else {
+      tasks.push({
+        id: `${delta.specId}:review`,
+        specId: delta.specId,
+        type: "review",
+        description: `Review the deletion of ${delta.specId}; do not remove code automatically without explicit cleanup intent.`,
+        targets: baseTargets,
+      });
+    }
+  }
+
+  if (delta.kind === "benchmark") {
+    const benchmarkTargets = target?.benchmarkSidecars.map((entry) => entry.path) ?? [delta.path];
+    if (delta.fileChange === "deleted") {
+      tasks.push({
+        id: `${delta.specId}:review`,
+        specId: delta.specId,
+        type: "review",
+        description: `Review benchmark sidecar deletion for ${delta.specId} and keep functional code changes conservative.`,
+        targets: benchmarkTargets,
+      });
+    } else if (delta.sectionChanges.length > 0) {
+      tasks.push({
+        id: `${delta.specId}:benchmark`,
+        specId: delta.specId,
+        type: "benchmark",
+        description: `Keep the implementation compatible with benchmark constraints described by ${delta.specId}.`,
+        targets: benchmarkTargets,
+      });
+    }
+  }
+
+  return tasks;
+}
+
+export function planSpecImplementation(
+  workspace: LoadedSpecWorkspace,
+  diff: SpecDiffReport,
+): SpecImplementationPlan {
+  const { deltas } = diff;
+  const impactedSpecs = new Map<string, PlannedSpecTarget>();
+  const tasks = new Map<string, PlannedTask>();
+  const deletedSpecIds: string[] = [];
+
+  for (const delta of deltas) {
+    if (delta.kind === "base" && delta.fileChange === "deleted") {
+      deletedSpecIds.push(delta.specId);
+    }
+
+    const baseDocument = delta.kind === "base"
+      ? getDeltaDocument(delta)
+      : delta.extendsSpecId
+        ? getBaseSpecDocument(delta.extendsSpecId, workspace, deltas)
+        : undefined;
+    const baseDelta = baseDocument?.id ? deltas.find((entry) => entry.kind === "base" && entry.specId === baseDocument.id) : undefined;
+    const target = baseDocument ? buildSpecTarget(baseDelta, baseDocument, workspace, deltas) : undefined;
+
+    if (target && !impactedSpecs.has(target.specId)) {
+      impactedSpecs.set(target.specId, target);
+    }
+
+    for (const task of buildTasksForDelta(delta, target)) {
+      tasks.set(task.id, task);
+    }
+  }
+
+  const sortedImpactedSpecs = Array.from(impactedSpecs.values()).sort((left, right) => left.specId.localeCompare(right.specId));
+  const testCommands = Array.from(
+    new Set(
+      sortedImpactedSpecs
+        .filter((target) => target.fileChange !== "deleted")
+        .flatMap((target) => target.testCommands),
+    ),
+  );
+
+  return {
+    diff,
+    tasks: Array.from(tasks.values()).sort((left, right) => left.id.localeCompare(right.id)),
+    impactedSpecs: sortedImpactedSpecs,
+    testCommands,
+    deletedSpecIds: deletedSpecIds.sort(),
+  };
+}

package/src/spec/prompt-renderer.ts

@@ -0,0 +1,318 @@
+import { relative } from "path";
+
+import { getSpecDiffRelativePath } from "./diff";
+import type {
+  ParsedSpecDocument,
+  PlannedBenchmarkContext,
+  PlannedSpecTarget,
+  SpecCheckEvidence,
+  SpecDelta,
+  SpecImportUncertaintyLevel,
+  SpecImplementationPlan,
+} from "./types";
+
+function indentBlock(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => `    ${line}`)
+    .join("\n");
+}
+
+function relativePath(workspacePath: string, path: string): string {
+  return relative(workspacePath, path).split("\\").join("/") || path;
+}
+
+function formatSectionChange(delta: SpecDelta): string {
+  if (delta.sectionChanges.length === 0) {
+    return "  - no parsed section changes detected\n";
+  }
+
+  return delta.sectionChanges.map((change) => {
+    const parts = [`  - ${change.section} [${change.changeType}]`];
+    if (change.oldText) {
+      parts.push(`    old:\n${indentBlock(change.oldText)}`);
+    }
+    if (change.newText) {
+      parts.push(`    new:\n${indentBlock(change.newText)}`);
+    }
+    return parts.join("\n");
+  }).join("\n");
+}
+
+function formatBenchmark(benchmark: PlannedBenchmarkContext, workspacePath: string): string {
+  const metricEntries = Object.entries(benchmark.metrics)
+    .map(([metric, threshold]) => `${metric} ${threshold}`)
+    .join(", ");
+
+  return [
+    `  - ${benchmark.id} (${benchmark.fileChange}) at ${relativePath(workspacePath, benchmark.path)}`,
+    `    environment: ${benchmark.environment ?? "(unspecified)"}`,
+    `    required: ${benchmark.required === undefined ? "(unspecified)" : benchmark.required ? "true" : "false"}`,
+    `    command: ${benchmark.command ?? "(unspecified)"}`,
+    `    metrics: ${metricEntries || "(none)"}`,
+  ].join("\n");
+}
+
+function formatImpactedSpec(target: PlannedSpecTarget, workspacePath: string): string {
+  const lines = [
+    `- ${target.specId} (${target.fileChange}) at ${relativePath(workspacePath, target.path)}`,
+    `  code_paths: ${target.codePaths.join(" | ") || "(none)"}`,
+    `  test_paths: ${target.testPaths.join(" | ") || "(none)"}`,
+    `  test_commands: ${target.testCommands.join(" | ") || "(none)"}`,
+    `  invariants: ${target.invariants.join(" | ") || "(none)"}`,
+    `  acceptance_criteria: ${target.acceptanceCriteria.join(" | ") || "(none)"}`,
+  ];
+
+  if (target.benchmarkSidecars.length > 0) {
+    lines.push("  benchmark_sidecars:");
+    lines.push(target.benchmarkSidecars.map((benchmark) => formatBenchmark(benchmark, workspacePath)).join("\n"));
+  }
+
+  return lines.join("\n");
+}
+
+export function renderImplementPrompt(plan: SpecImplementationPlan): string {
+  const changedSpecs = plan.diff.deltas
+    .map((delta) => {
+      const lines = [
+        `- ${delta.specId} (${delta.kind}, ${delta.fileChange}) at ${getSpecDiffRelativePath(plan.diff, delta.path)}`,
+      ];
+
+      if (delta.kind !== "base" && delta.extendsSpecId) {
+        lines.push(`  extends: ${delta.extendsSpecId}`);
+      }
+
+      lines.push(formatSectionChange(delta));
+      return lines.join("\n");
+    })
+    .join("\n\n");
+
+  const impactedSpecs = plan.impactedSpecs.length > 0
+    ? plan.impactedSpecs.map((target) => formatImpactedSpec(target, plan.diff.workspacePath)).join("\n\n")
+    : "- No mapped base specs were resolved from the changed deltas.";
+
+  const tasks = plan.tasks.length > 0
+    ? plan.tasks
+      .map((task) => `- [${task.type}] ${task.description}${task.targets && task.targets.length > 0 ? ` Targets: ${task.targets.join(" | ")}` : ""}`)
+      .join("\n")
+    : "- No implementation tasks were derived from the changed specs.";
+
+  return `You are implementing code and test updates for Lisa spec deltas.
+
+Return a brief plain-text note only inside these exact markers:
+LISA_IMPLEMENT_RESULT_START
+Implemented:
+- <short bullet>
+Open Questions:
+- <optional bullet or \"none\">
+LISA_IMPLEMENT_RESULT_END
+
+Rules:
+- If you discover the task cannot be completed safely with the capabilities available in this session, respond with only:
+  LISA_ABORT_START
+  <short reason>
+  LISA_ABORT_END
+- Edit code, tests, and mapped repository artifacts only. Do not modify files under .specs/.
+- Prefer the narrowest change that satisfies the spec.
+- Start with the smallest end-to-end slice across the nearest mapped files before exploring broader repository context.
+- Avoid broad repo scans when the task is clearly scoped to a few CLI, adapter, or test files.
+- Treat mapped code and test paths as candidates, not mandatory edit targets.
+- If the spec concerns checked-in docs, content, config, or repository artifacts, update those artifacts directly before broader code changes.
+- If a mapped path does not exist yet and the spec requires it, create the missing file or directory within that mapped path instead of skipping the work.
+- Stay within the mapped code and test paths unless a small supporting edit is required to satisfy a specific acceptance criterion or invariant.
+- Do not self-certify completion or claim tests passed; Lisa will run deterministic test commands after this stage.
+- Do not return a no-op result when the changed spec is not yet satisfied in the current workspace.
+- When a spec introduces a new CLI command or a mapped path that does not exist yet, create the missing module, wire it from the nearest existing CLI entrypoint, and add the narrowest matching tests in the same pass.
+- If the requested behavior is absent when you inspect the mapped files, a successful implementation must leave concrete repository edits that add that behavior.
+- Acceptance Criteria changes must update or add tests at the narrowest existing seam that proves the requirement.
+- Invariant changes must preserve or strengthen regression coverage, preferably in the closest existing test layer.
+- Prefer durable test assertions over brittle prose-matching when shorter semantic or file-level checks provide enough evidence.
+- If a spec deletion appears below, do not silently remove code. Keep cleanup conservative and explicit.
+- Keep changes scoped to the planned tasks below.
+
+Diff range:
+- base: ${plan.diff.baseRef}
+- head: ${plan.diff.headRef}
+
+Changed specs:
+${changedSpecs || "- none"}
+
+Impacted implementation targets:
+${impactedSpecs}
+
+Planned tasks:
+${tasks}
+
+Deterministic follow-up tests Lisa will run after implementation:
+- ${plan.testCommands.join("\n- ") || "No mapped test commands were declared by the impacted specs."}
+
+  Respond with the marked completion note only.`;
+}
+
+interface RenderCheckPromptInput {
+  workspacePath: string;
+  spec: ParsedSpecDocument;
+  specContent: string;
+  codePaths: string[];
+  testPaths: string[];
+  testCommands: string[];
+  matchedCodeFiles: string[];
+  matchedTestFiles: string[];
+  deterministicEvidence: SpecCheckEvidence[];
+  deterministicIssues: string[];
+  driftWarning?: string;
+}
+
+function formatPromptList(values: string[], emptyLabel: string): string {
+  return values.length > 0 ? `- ${values.join("\n- ")}` : `- ${emptyLabel}`;
+}
+
+export function renderCheckPrompt(input: RenderCheckPromptInput): string {
+  const specPath = relativePath(input.workspacePath, input.spec.path);
+  const deterministicEvidence = input.deterministicEvidence.length > 0
+    ? input.deterministicEvidence.map((entry) => `- [${entry.type}] ${entry.detail}`).join("\n")
+    : "- none";
+  const deterministicIssues = input.deterministicIssues.length > 0
+    ? input.deterministicIssues.map((entry) => `- ${entry}`).join("\n")
+    : "- none";
+
+  return `You are performing a read-only Lisa spec conformance audit.
+
+Return JSON only inside these exact markers:
+LISA_CHECK_JSON_START
+{
+  "status": "PASS | FAIL | UNSURE",
+  "summary": "short summary",
+  "evidence": [
+    { "type": "code-audit", "detail": "specific supporting detail" }
+  ],
+  "issues": ["specific drift, gap, or open question"]
+}
+LISA_CHECK_JSON_END
+
+Rules:
+- If you cannot complete a trustworthy read-only audit because required capabilities or files are unavailable, respond with only:
+  LISA_ABORT_START
+  <short reason>
+  LISA_ABORT_END
+- Read files only. Do not edit code, tests, specs, or reports.
+- Treat the spec as the source of truth.
+- Use the deterministic evidence below first, then inspect the mapped code and tests.
+- Return PASS only when the implementation and tests appear to satisfy the spec.
+- Return FAIL when the spec and implementation clearly drift.
+- Return UNSURE when the evidence is incomplete or inconclusive.
+- Focus on the declared code paths, test paths, invariants, and acceptance criteria.
+
+Spec under audit:
+- id: ${input.spec.id ?? specPath}
+- path: ${specPath}
+- status: ${input.spec.status ?? "(unspecified)"}
+${input.driftWarning ? `- drift warning: ${input.driftWarning}
+` : ""}
+Mapped code paths:
+${formatPromptList(input.codePaths, "none declared")}
+
+Matched code files:
+${formatPromptList(input.matchedCodeFiles, "none matched")}
+
+Mapped test paths:
+${formatPromptList(input.testPaths, "none declared")}
+
+Matched test files:
+${formatPromptList(input.matchedTestFiles, "none matched")}
+
+Mapped test commands:
+${formatPromptList(input.testCommands, "none declared")}
+
+Deterministic evidence:
+${deterministicEvidence}
+
+Deterministic issues:
+${deterministicIssues}
+
+Full spec content:
+${indentBlock(input.specContent)}
+
+Respond with the marked JSON payload only.`;
+}
+
+interface RenderImportPromptInput {
+  workspacePath: string;
+  selectedPaths: string[];
+  existingDocuments: ParsedSpecDocument[];
+  extensionGuidance: string[];
+  directContextOnly?: boolean;
+}
+
+function formatDocumentReference(document: ParsedSpecDocument, workspacePath: string): string {
+  return `- ${document.id ?? relativePath(workspacePath, document.path)} (${document.kind}, ${document.status ?? "unknown"}) at ${relativePath(workspacePath, document.path)}`;
+}
+
+function formatUncertaintyLevels(): string {
+  return (["low", "medium", "high"] as SpecImportUncertaintyLevel[]).join(" | ");
+}
+
+export function renderImportPrompt(input: RenderImportPromptInput): string {
+  const existingDocuments = input.existingDocuments.length > 0
+    ? input.existingDocuments.map((document) => formatDocumentReference(document, input.workspacePath)).join("\n")
+    : "- none";
+  const extensionGuidance = input.extensionGuidance.length > 0
+    ? input.extensionGuidance.map((entry) => `- ${entry}`).join("\n")
+    : "- none";
+  const directContextRules = input.directContextOnly
+    ? "- Do not use tools, subagents, code-review agents, or skills. Work only from the attached files and this prompt.\n"
+      + "- If the attached files are insufficient, abort instead of searching for additional repository context.\n"
+    : "";
+
+  return `You are drafting Lisa specs from an existing codebase.
+
+Return JSON only inside these exact markers:
+LISA_IMPORT_JSON_START
+{
+  "files": [
+    { "path": ".specs/backend/example.md", "content": "full markdown or yaml document" }
+  ],
+  "notes": ["short note grounded in code, tests, or docs"],
+  "uncertainties": [
+    {
+      "path": ".specs/backend/example.md",
+      "specId": "backend.example",
+      "level": "${formatUncertaintyLevels()}",
+      "detail": "what remains uncertain",
+      "question": "optional follow-up question"
+    }
+  ]
+}
+LISA_IMPORT_JSON_END
+
+Rules:
+- If you cannot complete the import safely because required capabilities or repository access are unavailable, respond with only:
+  LISA_ABORT_START
+  <short reason>
+  LISA_ABORT_END
+- Ensure the payload between the markers is valid JSON with properly escaped strings.
+${directContextRules}- Read code, tests, and docs to infer current behavior. Do not edit source files outside \`.specs/\`.
+- Import is scoped to the selected paths below, plus directly relevant tests/docs.
+- Imported base specs and benchmark sidecars must declare \`status: draft\`.
+- Base spec frontmatter must use \`id\` (not \`spec_id\`), \`status\`, \`code_paths\`, and at least one of \`test_paths\` or \`test_commands\`. Optional keys are \`owners\` and \`depends_on\`.
+- Benchmark sidecars must use \`id\`, \`kind: benchmark\`, \`extends\`, \`status\`, \`environment\`, \`command\`, and string-valued \`metrics\`. Optional keys include \`required\`, \`baseline\`, and \`noise_tolerance_pct\`.
+- Environment configs must use \`name\` and may include object-valued \`runtime\` and \`resources\`, plus string-valued \`notes\`.
+- Draft base specs must include Summary, Use Cases, Invariants, Acceptance Criteria, Out of Scope, Open Questions, and Uncertainty sections.
+- Use standard Lisa section headings exactly as written above; do not substitute custom headings like \`Title\` for required sections.
+- Prefer evidence from tests and docs over unsupported guesses.
+- If you find benchmark scripts, perf tests, or explicit latency/throughput targets, draft benchmark sidecars and any needed environment configs.
+- Only emit files under \`.specs/backend/\`, \`.specs/frontend/\`, or \`.specs/environments/\`.
+- Keep file names stable, concrete, and reviewable.
+- Do not invent unsupported frontmatter keys such as \`spec_id\`, \`title\`, or \`sources\`.
+
+Selected import scope:
+- ${input.selectedPaths.join("\n- ")}
+
+Existing spec workspace:
+${existingDocuments}
+
+Extension guidance:
+${extensionGuidance}
+
+Respond with the marked JSON payload only.`;
+}