muonroi-cli 1.4.0 → 1.5.0

package/src/product-loop/repo-brief.ts

@@ -1,235 +0,0 @@
-/**
- * src/product-loop/repo-brief.ts
- *
- * Build a compact "what is this repo" brief that the discovery leader and
- * council can cite when recommending changes inside an EXISTING project.
- *
- * The vendor-default preamble (`buildEcosystemPreamble`) belongs to greenfield
- * scaffolding flows only. For existing repos we replace it with this brief —
- * grounded in the actual filesystem — so the leader's rationale can name real
- * files, packages, and scripts instead of inventing generic stack defaults.
- *
- * Output budget: ~1200 chars hard cap. Anything longer competes with the
- * prompt-specificity context + question + constraint + answers-so-far, and
- * the leader has limited maxTokens.
- *
- * The brief is intentionally markdown so the LLM can pattern-match section
- * headers; it is NEVER user-facing.
- */
-
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import type { ExistingProjectSignals } from "./types.js";
-
-const HARD_CAP_CHARS = 1200;
-const README_HEAD_CHARS = 480;
-const MAX_TOP_LEVEL_DIRS = 12;
-const MAX_NESTED_DIRS_PER_TOP = 6;
-const MAX_DEPS_LISTED = 18;
-const MAX_SCRIPTS_LISTED = 8;
-
-const IGNORED_DIRS = new Set([
-  "node_modules",
-  ".git",
-  ".next",
-  "dist",
-  "build",
-  "target",
-  "out",
-  ".turbo",
-  ".cache",
-  "coverage",
-  "venv",
-  ".venv",
-  "__pycache__",
-  ".idea",
-  ".vscode",
-]);
-
-/** Citable tokens extracted from the brief (file/dir names, package names,
- *  script names). Used by `discovery-recommender` to validate that the leader
- *  actually grounded its rationale in something concrete. */
-export interface RepoBrief {
-  markdown: string;
-  citableTokens: string[];
-}
-
-async function safeReaddir(dir: string): Promise<Array<{ name: string; isDir: boolean }>> {
-  try {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    return entries.map((e) => ({ name: e.name, isDir: e.isDirectory() }));
-  } catch {
-    return [];
-  }
-}
-
-async function readTopLevelDirs(cwd: string): Promise<Array<{ name: string; children: string[] }>> {
-  const top = await safeReaddir(cwd);
-  const dirs = top
-    .filter((e) => e.isDir && !IGNORED_DIRS.has(e.name) && !e.name.startsWith("."))
-    .slice(0, MAX_TOP_LEVEL_DIRS)
-    .map((e) => e.name);
-
-  const out: Array<{ name: string; children: string[] }> = [];
-  for (const d of dirs) {
-    const sub = await safeReaddir(path.join(cwd, d));
-    const children = sub
-      .filter((e) => e.isDir && !IGNORED_DIRS.has(e.name) && !e.name.startsWith("."))
-      .slice(0, MAX_NESTED_DIRS_PER_TOP)
-      .map((e) => e.name);
-    out.push({ name: d, children });
-  }
-  return out;
-}
-
-async function readReadmeHead(cwd: string): Promise<string | null> {
-  for (const name of ["README.md", "README.MD", "readme.md", "Readme.md"]) {
-    try {
-      const raw = await fs.readFile(path.join(cwd, name), "utf8");
-      const trimmed = raw.trim();
-      if (trimmed.length === 0) continue;
-      return trimmed.length > README_HEAD_CHARS ? `${trimmed.slice(0, README_HEAD_CHARS)}…` : trimmed;
-    } catch {
-      /* try next */
-    }
-  }
-  return null;
-}
-
-interface PkgJsonSummary {
-  name?: string;
-  description?: string;
-  scripts: string[];
-  deps: string[];
-}
-
-async function readPackageJsonSummary(cwd: string): Promise<PkgJsonSummary | null> {
-  let raw: string;
-  try {
-    raw = await fs.readFile(path.join(cwd, "package.json"), "utf8");
-  } catch {
-    return null;
-  }
-  let parsed: Record<string, unknown>;
-  try {
-    parsed = JSON.parse(raw) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-  const scripts = Object.keys((parsed.scripts as Record<string, string>) ?? {}).slice(0, MAX_SCRIPTS_LISTED);
-  const deps = [
-    ...Object.keys((parsed.dependencies as Record<string, string>) ?? {}),
-    ...Object.keys((parsed.devDependencies as Record<string, string>) ?? {}),
-  ].slice(0, MAX_DEPS_LISTED);
-  return {
-    name: typeof parsed.name === "string" ? parsed.name : undefined,
-    description: typeof parsed.description === "string" ? parsed.description : undefined,
-    scripts,
-    deps,
-  };
-}
-
-function capMarkdown(s: string): string {
-  if (s.length <= HARD_CAP_CHARS) return s;
-  return `${s.slice(0, HARD_CAP_CHARS - 1)}…`;
-}
-
-/**
- * Build a markdown brief of the repo at `cwd`, grounded in `detection` plus
- * a shallow filesystem walk. Returns markdown + the list of citable tokens
- * so the caller can validate that leader rationales reference at least one.
- *
- * Never throws — partial brief is fine when individual probes fail.
- */
-export async function buildRepoBrief(cwd: string, detection: ExistingProjectSignals): Promise<RepoBrief> {
-  const tokens = new Set<string>();
-  const lines: string[] = [];
-
-  lines.push("## Repo brief (existing project — recommendations MUST cite these)");
-  lines.push("");
-
-  // 1) Identity from package.json or manifest list
-  const pkg = await readPackageJsonSummary(cwd);
-  if (pkg?.name) {
-    lines.push(`Package name: \`${pkg.name}\``);
-    tokens.add(pkg.name);
-  }
-  if (pkg?.description) {
-    lines.push(`Description: ${pkg.description}`);
-  }
-
-  // 2) Detected stack signals — already cheap, reuse
-  if (detection.languages.length > 0) {
-    lines.push(`Languages: ${detection.languages.join(", ")}`);
-    for (const l of detection.languages) tokens.add(l);
-  }
-  if (detection.frameworks.length > 0) {
-    lines.push(`Frameworks: ${detection.frameworks.join(", ")}`);
-    for (const f of detection.frameworks) tokens.add(f);
-  }
-  if (detection.manifests.length > 0) {
-    const manifestNames = detection.manifests.map((m) => path.basename(m.file));
-    lines.push(`Manifests: ${manifestNames.join(", ")}`);
-    for (const m of manifestNames) tokens.add(m);
-  }
-  lines.push("");
-
-  // 3) Top-level directory layout depth 2
-  const dirs = await readTopLevelDirs(cwd);
-  if (dirs.length > 0) {
-    lines.push("Top-level layout:");
-    for (const d of dirs) {
-      tokens.add(d.name);
-      if (d.children.length === 0) {
-        lines.push(`- \`${d.name}/\``);
-      } else {
-        for (const c of d.children) tokens.add(`${d.name}/${c}`);
-        lines.push(`- \`${d.name}/\` — ${d.children.map((c) => `\`${c}/\``).join(", ")}`);
-      }
-    }
-    lines.push("");
-  }
-
-  // 4) Scripts + deps when package.json present
-  if (pkg) {
-    if (pkg.scripts.length > 0) {
-      lines.push(`Scripts: ${pkg.scripts.map((s) => `\`${s}\``).join(", ")}`);
-      for (const s of pkg.scripts) tokens.add(s);
-    }
-    if (pkg.deps.length > 0) {
-      lines.push(`Key deps: ${pkg.deps.map((d) => `\`${d}\``).join(", ")}`);
-      for (const d of pkg.deps) tokens.add(d);
-    }
-    if (pkg.scripts.length > 0 || pkg.deps.length > 0) lines.push("");
-  }
-
-  // 5) README head — usually the highest-signal section
-  const readme = await readReadmeHead(cwd);
-  if (readme) {
-    lines.push("README head:");
-    lines.push(readme);
-    lines.push("");
-  }
-
-  lines.push(
-    "Rationales for ANY recommendation MUST cite at least ONE of these tokens (file path, dir, dep, script, or manifest). Generic rationales without a citation are invalid for this project.",
-  );
-
-  const markdown = capMarkdown(lines.join("\n"));
-
-  // Filter tokens to citable-quality (length >= 2, alphanumeric/path chars).
-  const citableTokens = Array.from(tokens).filter((t) => t.length >= 2 && /^[\w./@-]+$/.test(t));
-
-  return { markdown, citableTokens };
-}
-
-/**
- * Test whether `rationale` cites at least one citable token from `brief`.
- * Case-insensitive substring match. Empty/missing brief tokens → returns true
- * (no expectations to check against).
- */
-export function rationaleCitesBrief(rationale: string, brief: RepoBrief | undefined): boolean {
-  if (!brief || brief.citableTokens.length === 0) return true;
-  const lower = rationale.toLowerCase();
-  return brief.citableTokens.some((t) => lower.includes(t.toLowerCase()));
-}

package/src/product-loop/role-memory.ts

@@ -1,72 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import { atomicWriteText } from "../storage/atomic-io.js";
-
-const MAX_MEMORY_BYTES = 2048;
-
-/**
- * Returns the absolute path to a role's memory file.
- */
-export function roleMemoryPath(flowDir: string, runId: string, slot: string): string {
-  return path.join(flowDir, "runs", runId, "memory", `${slot}.md`);
-}
-
-/**
- * Read the full memory for a role slot. Returns "" if missing.
- */
-export async function readRoleMemory(flowDir: string, runId: string, slot: string): Promise<string> {
-  const filePath = roleMemoryPath(flowDir, runId, slot);
-  try {
-    return await fs.readFile(filePath, "utf8");
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") return "";
-    throw err;
-  }
-}
-
-/**
- * Append a sprint block to a role's memory with a 2KB hard cap.
- * Truncates oldest blocks first when exceeding the cap.
- */
-export async function appendRoleMemory(
-  flowDir: string,
-  runId: string,
-  slot: string,
-  sprintN: number,
-  content: string,
-): Promise<void> {
-  const filePath = roleMemoryPath(flowDir, runId, slot);
-  let existing = "";
-  try {
-    existing = await fs.readFile(filePath, "utf8");
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
-  }
-
-  const block = `### Sprint ${sprintN}\n${content.trim()}\n`;
-  let newContent = existing ? `${existing.trim()}\n\n${block}` : block;
-
-  // Truncation logic: oldest-first truncation
-  if (Buffer.byteLength(newContent) > MAX_MEMORY_BYTES) {
-    const matches = [...newContent.matchAll(/^### Sprint \d+/gm)];
-    let found = false;
-    for (const match of matches) {
-      const startIdx = match.index!;
-      const sliced = newContent.slice(startIdx);
-      if (Buffer.byteLength(sliced) <= MAX_MEMORY_BYTES) {
-        newContent = sliced;
-        found = true;
-        break;
-      }
-    }
-
-    // If even the last block is too big, just keep the last block (best effort)
-    if (!found && matches.length > 0) {
-      newContent = newContent.slice(matches[matches.length - 1].index!);
-    }
-  }
-
-  // Ensure directory exists (atomicWriteText does this, but good to be explicit for clarity)
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await atomicWriteText(filePath, newContent);
-}

package/src/product-loop/role-registry.ts

@@ -1,175 +0,0 @@
-import type { EERouteResult } from "../ee/bridge.js";
-import type { ModelInfo, ModelTier } from "../types/index.js";
-import type { RoleSlot } from "./types.js";
-
-export interface ModelAssignment {
-  slot: RoleSlot;
-  provider: string;
-  model: string;
-  tier: ModelTier;
-  source: "ee" | "cold-start";
-}
-
-export type RoleResolutionResult =
-  | { kind: "ok"; roles: Record<RoleSlot, ModelAssignment>; sameProvider: boolean }
-  | { kind: "refuse"; reason: "single_provider_too_few" | "po_customer_collision" | "no_inventory" };
-
-const ROLE_SLOTS: RoleSlot[] = ["PO", "Architect", "Implementer", "Tester", "Reviewer", "Customer"];
-
-const TIER_PREFERENCES: Record<RoleSlot, ModelTier[]> = {
-  PO: ["premium", "balanced"],
-  Architect: ["premium", "balanced"],
-  Reviewer: ["premium", "balanced"],
-  Customer: ["premium", "balanced"],
-  Implementer: ["balanced", "fast", "premium"],
-  Tester: ["balanced", "premium"],
-};
-
-export async function resolveRoles(opts: {
-  inventory: ModelInfo[];
-  eeRouteOverride?: (slot: RoleSlot) => Promise<EERouteResult | null>;
-}): Promise<RoleResolutionResult> {
-  const { inventory, eeRouteOverride } = opts;
-
-  if (inventory.length === 0) {
-    return { kind: "refuse", reason: "no_inventory" };
-  }
-
-  const providers = new Set(inventory.map((m) => m.provider));
-  if (providers.size === 1 && inventory.length <= 5) {
-    return { kind: "refuse", reason: "single_provider_too_few" };
-  }
-
-  // Stable sort inventory: tier (premium > balanced > fast), provider, id
-  const tierRank: Record<ModelTier, number> = { premium: 0, balanced: 1, fast: 2 };
-  const sortedInventory = [...inventory].sort((a, b) => {
-    const rA = tierRank[a.tier || "balanced"];
-    const rB = tierRank[b.tier || "balanced"];
-    if (rA !== rB) return rA - rB;
-    if (a.provider !== b.provider) return (a.provider || "").localeCompare(b.provider || "");
-    return a.id.localeCompare(b.id);
-  });
-
-  const assignments: Partial<Record<RoleSlot, ModelAssignment>> = {};
-  const usedModelIds = new Set<string>();
-
-  // Helper to pick a model
-  function pickModel(slot: RoleSlot, forbiddenProvider?: string): ModelAssignment | null {
-    const preferences = TIER_PREFERENCES[slot];
-    for (const tier of preferences) {
-      const match = sortedInventory.find(
-        (m) =>
-          (m.tier || "balanced") === tier &&
-          !usedModelIds.has(m.id) &&
-          (!forbiddenProvider || m.provider !== forbiddenProvider),
-      );
-      if (match) {
-        return {
-          slot,
-          provider: match.provider || "unknown",
-          model: match.id,
-          tier: (match.tier as ModelTier) || "balanced",
-          source: "cold-start",
-        };
-      }
-    }
-    // Fallback: ignore forbiddenProvider if we couldn't find a match
-    if (forbiddenProvider) {
-      for (const tier of preferences) {
-        const match = sortedInventory.find((m) => (m.tier || "balanced") === tier && !usedModelIds.has(m.id));
-        if (match) {
-          return {
-            slot,
-            provider: match.provider || "unknown",
-            model: match.id,
-            tier: (match.tier as ModelTier) || "balanced",
-            source: "cold-start",
-          };
-        }
-      }
-    }
-    // Final fallback: ignore tier preference
-    const fallback = sortedInventory.find((m) => !usedModelIds.has(m.id));
-    if (fallback) {
-      return {
-        slot,
-        provider: fallback.provider || "unknown",
-        model: fallback.id,
-        tier: (fallback.tier as ModelTier) || "balanced",
-        source: "cold-start",
-      };
-    }
-    return null;
-  }
-
-  // 1. Resolve PO first (most important)
-  const po = pickModel("PO");
-  if (!po) return { kind: "refuse", reason: "no_inventory" }; // Should not happen given initial check
-  assignments.PO = po;
-  usedModelIds.add(po.model);
-
-  // 2. Resolve Customer next, try different provider
-  const customer = pickModel("Customer", po.provider);
-  if (!customer) return { kind: "refuse", reason: "no_inventory" };
-  assignments.Customer = customer;
-  usedModelIds.add(customer.model);
-
-  // Check for PO/Customer collision
-  if (assignments.PO.model === assignments.Customer.model) {
-    return { kind: "refuse", reason: "po_customer_collision" };
-  }
-
-  // 3. Resolve others
-  const others: RoleSlot[] = ["Architect", "Implementer", "Tester", "Reviewer"];
-  for (const slot of others) {
-    const assigned = pickModel(slot);
-    if (!assigned) return { kind: "refuse", reason: "no_inventory" };
-    assignments[slot] = assigned;
-    usedModelIds.add(assigned.model);
-  }
-
-  // 4. Apply EE overrides last
-  //
-  // Phase 21.5 hotfix: query EE for all role slots IN PARALLEL. Sequential
-  // awaits used to multiply the per-call EE timeout by ROLE_SLOTS.length —
-  // when EE is unreachable that meant 6× the route timeout (~6s with the
-  // 1000ms default) before /ideal hot-path could yield its first Sprint
-  // chunk. The override lambda already swallows errors and returns null on
-  // failure, so Promise.all preserves semantics.
-  if (eeRouteOverride) {
-    const overrides = await Promise.all(ROLE_SLOTS.map((slot) => eeRouteOverride(slot).catch(() => null)));
-    for (let i = 0; i < ROLE_SLOTS.length; i++) {
-      const slot = ROLE_SLOTS[i]!;
-      const override = overrides[i];
-      if (override) {
-        // Only apply if it's in inventory AND doesn't cause PO/Customer collision if slot is PO/Customer
-        const inInventory = inventory.find((m) => m.id === override.model);
-        if (inInventory) {
-          const _currentAssignment = assignments[slot]!;
-
-          // If we are overriding PO or Customer, we MUST ensure they remain different
-          if (slot === "PO") {
-            if (override.model === assignments.Customer!.model) continue;
-          }
-          if (slot === "Customer") {
-            if (override.model === assignments.PO!.model) continue;
-          }
-
-          assignments[slot] = {
-            slot,
-            provider: inInventory.provider || "unknown",
-            model: override.model,
-            tier: (override.tier as ModelTier) || (inInventory.tier as ModelTier) || "balanced",
-            source: "ee",
-          };
-        }
-      }
-    }
-  }
-
-  return {
-    kind: "ok",
-    roles: assignments as Record<RoleSlot, ModelAssignment>,
-    sameProvider: assignments.PO!.provider === assignments.Customer!.provider,
-  };
-}

package/src/product-loop/seed-questions.ts

@@ -1,51 +0,0 @@
-import type { GrayAreaQuestion } from "../gsd/gray-areas.js";
-
-/**
- * The 6 hardcoded dimensions for the Product Ideal Loop's Gather stage.
- * These are used as seed questions for the clarifier to ensure high-confidence
- * grounding before research/scoping begins.
- */
-export const SEED_DIMENSIONS: GrayAreaQuestion[] = [
-  {
-    dimension: "persona",
-    id: "persona",
-    question: "Who are the primary users for this product?",
-    options: ["developers using this codebase", "internal team members", "external end-users"],
-    isRequired: true,
-  },
-  {
-    dimension: "core-features",
-    id: "core-features",
-    question: "What are the top 3 must-have features?",
-    options: ["core logic only", "API endpoints", "CLI interface", "web UI"],
-    isRequired: true,
-  },
-  {
-    dimension: "non-functional",
-    id: "non-functional",
-    question: "What are the performance, privacy, offline, or scale targets?",
-    options: ["no specific targets (best effort)", "high performance / low latency", "strict privacy requirements"],
-    isRequired: true,
-  },
-  {
-    dimension: "tech-constraints",
-    id: "tech-constraints",
-    question: "What language, framework, or existing repo constraints apply?",
-    options: ["match existing project stack", "TypeScript / Node.js", "Python / FastApi"],
-    isRequired: true,
-  },
-  {
-    dimension: "success-metric",
-    id: "success-metric",
-    question: "How will 'done' be measured (e.g., metric, threshold)?",
-    options: ["100% test pass with >80% coverage", "user approval of final demo", "specific performance benchmark"],
-    isRequired: true,
-  },
-  {
-    dimension: "cost-tolerance",
-    id: "cost-tolerance",
-    question: "Is there a hard cost cap or a soft target?",
-    options: ["$50 soft target", "$100 hard cap", "no strict limit"],
-    isRequired: true,
-  },
-];

package/src/product-loop/ship-polish.ts

@@ -1,164 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import { slugify } from "../utils/slugify.js";
-import type { ProductSpec } from "./types.js";
-
-/**
- * Ship-time delivery polish. Called once when a /ideal run reaches the
- * shipped stage; idempotent so resume + re-ship don't clobber user content.
- *
- * What it does:
- *  - If no README.md exists in cwd, generate one from the ProductSpec.
- *  - If package.json exists and is missing name/description, fill them
- *    (NEVER overwrite existing fields — user-edited values win).
- *  - Always writes a delivery-notes.md inside the run dir summarizing
- *    what was generated. Caller can surface this to the user.
- *
- * Intentionally does NOT run `git init` or create commits — too invasive
- * for an autonomous loop. User can run git themselves after the ship.
- */
-export interface PolishOptions {
-  cwd: string;
-  runDir: string;
-  productSpec: ProductSpec;
-  runId: string;
-}
-
-export interface PolishResult {
-  readmeWritten: boolean;
-  packageJsonUpdated: boolean;
-  /** Files that already existed and were left alone (paths relative to cwd). */
-  preserved: string[];
-  notes: string[];
-}
-
-export async function polishDelivery(opts: PolishOptions): Promise<PolishResult> {
-  const out: PolishResult = {
-    readmeWritten: false,
-    packageJsonUpdated: false,
-    preserved: [],
-    notes: [],
-  };
-
-  await maybeWriteReadme(opts, out);
-  await maybeFillPackageJson(opts, out);
-  await writeDeliveryNotes(opts, out);
-
-  return out;
-}
-
-async function maybeWriteReadme(opts: PolishOptions, out: PolishResult): Promise<void> {
-  const readmePath = path.join(opts.cwd, "README.md");
-  if (await fileExists(readmePath)) {
-    out.preserved.push("README.md");
-    out.notes.push("README.md already exists — left alone.");
-    return;
-  }
-
-  const spec = opts.productSpec;
-  const lines: string[] = [];
-  const title = spec.idea.split(/[.!?\n]/)[0]?.trim() || "Project";
-  lines.push(`# ${title.slice(0, 80)}`);
-  lines.push("");
-  if (spec.idea && spec.idea !== title) {
-    lines.push(spec.idea);
-    lines.push("");
-  }
-  if (spec.persona) {
-    lines.push("## Audience");
-    lines.push(spec.persona);
-    lines.push("");
-  }
-  if (spec.mvp?.length) {
-    lines.push("## Features");
-    for (const m of spec.mvp) lines.push(`- ${m}`);
-    lines.push("");
-  }
-  if (spec.architecture) {
-    lines.push("## Architecture");
-    lines.push(spec.architecture);
-    lines.push("");
-  }
-  if (spec.ioContract) {
-    lines.push("## Interface");
-    lines.push("```");
-    lines.push(spec.ioContract);
-    lines.push("```");
-    lines.push("");
-  }
-  if (spec.phase2?.length) {
-    lines.push("## Roadmap");
-    for (const p of spec.phase2) lines.push(`- ${p}`);
-    lines.push("");
-  }
-  lines.push("---");
-  lines.push(`_Scaffolded by muonroi-cli /ideal run ${opts.runId}_`);
-
-  await fs.writeFile(readmePath, lines.join("\n"), "utf-8");
-  out.readmeWritten = true;
-  out.notes.push("Wrote README.md from ProductSpec.");
-}
-
-async function maybeFillPackageJson(opts: PolishOptions, out: PolishResult): Promise<void> {
-  const pkgPath = path.join(opts.cwd, "package.json");
-  let raw: string;
-  try {
-    raw = await fs.readFile(pkgPath, "utf-8");
-  } catch {
-    return; // No package.json → not a Node project, skip silently.
-  }
-  let pkg: any;
-  try {
-    pkg = JSON.parse(raw);
-  } catch {
-    out.notes.push("package.json present but unparseable — left alone.");
-    return;
-  }
-
-  let touched = false;
-  const first = opts.productSpec.idea.split(/[.!?\n]/)[0]?.trim();
-  const slugged = first ? slugify(first).slice(0, 60) || undefined : undefined;
-  if (!pkg.name && slugged) {
-    pkg.name = slugged;
-    touched = true;
-  }
-  if (!pkg.description && opts.productSpec.idea) {
-    pkg.description = opts.productSpec.idea.slice(0, 140);
-    touched = true;
-  }
-  if (!pkg.version) {
-    pkg.version = "0.1.0";
-    touched = true;
-  }
-
-  if (touched) {
-    // Preserve trailing newline + 2-space indent — matches npm defaults so
-    // the diff stays clean for users on a managed package.json.
-    await fs.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
-    out.packageJsonUpdated = true;
-    out.notes.push("Filled missing name/description/version in package.json.");
-  } else {
-    out.preserved.push("package.json");
-    out.notes.push("package.json already populated — left alone.");
-  }
-}
-
-async function writeDeliveryNotes(opts: PolishOptions, out: PolishResult): Promise<void> {
-  const notesPath = path.join(opts.runDir, "delivery-notes.md");
-  const lines = ["## Delivery", ""];
-  if (out.readmeWritten) lines.push("- README.md generated from ProductSpec");
-  if (out.packageJsonUpdated) lines.push("- package.json metadata filled");
-  for (const p of out.preserved) lines.push(`- ${p} preserved (already existed)`);
-  if (lines.length === 2) lines.push("- nothing to scaffold (all artifacts already present)");
-  lines.push("");
-  await fs.writeFile(notesPath, lines.join("\n"), "utf-8");
-}
-
-async function fileExists(p: string): Promise<boolean> {
-  try {
-    await fs.stat(p);
-    return true;
-  } catch {
-    return false;
-  }
-}