muonroi-cli 1.2.2 → 1.3.1

package/src/product-loop/cross-run-memory.ts

@@ -0,0 +1,450 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { performance } from "node:perf_hooks";
+import type { CouncilLLM } from "../council/types.js";
+import { getDefaultEEClient } from "../ee/intercept.js";
+import { readArtifact, writeArtifact } from "../flow/artifact-io.js";
+import { selectEEInjectionsForRun } from "../storage/interaction-log.js";
+import { readManifest } from "./artifact-io.js";
+
+/**
+ * P5 - Cross-run workspace memory.
+ *
+ * Without this layer, each /ideal start runs cold and burns ~$5-10 re-doing
+ * discovery on the same workspace. We load prior runs manifests + role
+ * memories, filter by similarity to the current idea, decay by recency, then
+ * condense via the leader LLM into a 2KB "Prior Decisions Context" string
+ * that gets injected upstream of the clarifier and research debate.
+ *
+ * Storage: filesystem only (runs slash star slash memory slash star.md plus
+ * runs slash star slash manifest.md). No vector store, no DB writes - 20-run
+ * scan is linear and cheap. The condensed digest is persisted to state.md
+ * under "Prior Decisions Context" so the user can audit what was injected.
+ */
+
+const MAX_DIGEST_BYTES = 2048;
+const MAX_RUNS_TO_SCAN = 20;
+const RECENCY_DECAY_DAYS = 30;
+const MIN_KEYWORD_OVERLAP = 0.2;
+
+export type PriorRunSummary = {
+  runId: string;
+  idea: string;
+  verdictPass: boolean;
+  failedCondition?: string;
+  createdAt: Date;
+  doneAt?: Date;
+  memories: Map<string, string>;
+  similarity: number;
+  recency: number;
+  weight: number;
+};
+
+const STOPWORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "of",
+  "to",
+  "in",
+  "on",
+  "at",
+  "for",
+  "with",
+  "is",
+  "are",
+  "be",
+  "been",
+  "was",
+  "were",
+  "as",
+  "by",
+  "this",
+  "that",
+  "it",
+  "i",
+  "my",
+  "we",
+  "our",
+  "you",
+  "your",
+  "they",
+  "them",
+  "their",
+]);
+
+function tokenize(text: string): Set<string> {
+  const tokens = text
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, " ")
+    .split(/\s+/)
+    .filter((t) => t.length >= 3 && !STOPWORDS.has(t));
+  return new Set(tokens);
+}
+
+function jaccard(a: Set<string>, b: Set<string>): number {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const t of a) if (b.has(t)) inter++;
+  const union = a.size + b.size - inter;
+  return union === 0 ? 0 : inter / union;
+}
+
+function recencyFactor(createdAt: Date, now: Date = new Date()): number {
+  const days = (now.getTime() - createdAt.getTime()) / (1000 * 60 * 60 * 24);
+  if (days <= 0) return 1.0;
+  if (days >= RECENCY_DECAY_DAYS) return 0.3;
+  return 1.0 - (0.7 * days) / RECENCY_DECAY_DAYS;
+}
+
+async function listMemoryFiles(memoryDir: string): Promise<Map<string, string>> {
+  const result = new Map<string, string>();
+  let entries: string[];
+  try {
+    entries = await fs.readdir(memoryDir);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return result;
+    throw err;
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const slot = entry.replace(/\.md$/, "");
+    try {
+      const text = await fs.readFile(path.join(memoryDir, entry), "utf8");
+      if (text.trim().length > 0) result.set(slot, text);
+    } catch {
+      /* skip unreadable */
+    }
+  }
+  return result;
+}
+
+/**
+ * Discover prior runs under flowDir/runs, excluding the current run.
+ * Returns runs that pass the similarity gate, ranked by weight, capped at
+ * MAX_RUNS_TO_SCAN.
+ */
+export async function discoverPriorRuns(
+  flowDir: string,
+  currentRunId: string,
+  currentIdea: string,
+): Promise<PriorRunSummary[]> {
+  const runsRoot = path.join(flowDir, "runs");
+  let runIds: string[];
+  try {
+    runIds = await fs.readdir(runsRoot);
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
+    throw err;
+  }
+
+  const currentTokens = tokenize(currentIdea);
+  if (currentTokens.size === 0) return [];
+
+  const candidates: PriorRunSummary[] = [];
+  for (const runId of runIds) {
+    if (runId === currentRunId) continue;
+    const manifest = await readManifest(flowDir, runId).catch(() => null);
+    if (!manifest || !manifest.idea) continue;
+
+    const sim = jaccard(currentTokens, tokenize(manifest.idea));
+    if (sim < MIN_KEYWORD_OVERLAP) continue;
+
+    const rec = recencyFactor(manifest.createdAt);
+    const memoryDir = path.join(runsRoot, runId, "memory");
+    const memories = await listMemoryFiles(memoryDir);
+
+    candidates.push({
+      runId,
+      idea: manifest.idea,
+      verdictPass: manifest.verdict?.pass ?? false,
+      failedCondition: manifest.verdict?.failedCondition,
+      createdAt: manifest.createdAt,
+      doneAt: manifest.doneAt,
+      memories,
+      similarity: sim,
+      recency: rec,
+      weight: sim * rec,
+    });
+  }
+
+  candidates.sort((a, b) => b.weight - a.weight);
+  return candidates.slice(0, MAX_RUNS_TO_SCAN);
+}
+
+/**
+ * Build raw material for the LLM to condense. Caps total input at 8KB.
+ */
+function buildCondensationInput(runs: PriorRunSummary[]): string {
+  const MAX_INPUT_BYTES = 8192;
+  const blocks: string[] = [];
+  let bytes = 0;
+  for (const r of runs) {
+    let status: string;
+    if (r.verdictPass) {
+      status = "SHIPPED";
+    } else if (r.failedCondition) {
+      status = "HALTED (" + r.failedCondition + ")";
+    } else {
+      status = "INCOMPLETE";
+    }
+
+    const memSnippets: string[] = [];
+    for (const [slot, text] of r.memories) {
+      const head = text.trim().slice(0, 400);
+      memSnippets.push("  [" + slot + "] " + head);
+    }
+
+    const lines: string[] = [];
+    lines.push("## Run " + r.runId + " - " + status);
+    lines.push("Idea: " + r.idea);
+    const created = r.createdAt.toISOString().slice(0, 10);
+    const simStr = r.similarity.toFixed(2);
+    const recStr = r.recency.toFixed(2);
+    lines.push("Created: " + created + " | similarity=" + simStr + " | recency=" + recStr);
+    if (memSnippets.length > 0) {
+      lines.push("Roles:");
+      lines.push(memSnippets.join("\n"));
+    }
+    const block = lines.join("\n") + "\n";
+
+    const blockBytes = Buffer.byteLength(block);
+    if (bytes + blockBytes > MAX_INPUT_BYTES) break;
+    blocks.push(block);
+    bytes += blockBytes;
+  }
+  return blocks.join("\n");
+}
+
+/**
+ * Condense prior-run material into a 2KB Prior Decisions Context string.
+ */
+export async function condensePriorRuns(
+  runs: PriorRunSummary[],
+  leaderModelId: string,
+  llm: CouncilLLM,
+): Promise<string> {
+  if (runs.length === 0) return "";
+
+  const system =
+    "You are summarizing prior /ideal runs for an engineering team about to start a similar product. " +
+    "Output a tight, bulleted brief (max 1500 characters) covering ONLY reusable knowledge: " +
+    "architectural decisions made, approaches that were abandoned and why, recurring risks, " +
+    "and model/tooling preferences that worked. " +
+    "Skip per-sprint trivia, status updates, and anything specific to the prior idea that does " +
+    "not generalize. If a run shipped successfully, lead with what worked; if it halted, lead with " +
+    "why and what to avoid. Plain markdown, no preamble.";
+
+  const ideaLine = runs.length > 0 ? "Current idea: (see runs below for context)" : "Current idea:";
+  const prompt = ideaLine + "\n\n" + buildCondensationInput(runs);
+
+  try {
+    const raw = await llm.generate(leaderModelId, system, prompt, 1024);
+    const trimmed = (raw ?? "").trim();
+    if (!trimmed) return "";
+    if (Buffer.byteLength(trimmed) <= MAX_DIGEST_BYTES) return trimmed;
+    return trimmed.slice(0, MAX_DIGEST_BYTES).trim() + "...";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Top-level helper. Discover prior runs, persist EE injection audit to state.md.
+ * Returns digest="" (digest synthesis removed in P1.5 — PIL Layer 3 + EE T0
+ * handle semantic injection per-call, so the leader LLM condensation step is
+ * no longer needed) and the discovered runs list.
+ */
+export async function buildPriorContext(opts: {
+  flowDir: string;
+  runId: string;
+  idea: string;
+  /**
+   * @deprecated P1.5 — digest synthesis via the leader LLM was removed.
+   * The parameter is kept so callers in loop-driver.ts don't need a signature
+   * change yet. Will be pruned in P2 cleanup.
+   */
+  leaderModelId: string;
+  /**
+   * @deprecated P1.5 — same as leaderModelId above. Kept for call-site
+   * compatibility; no longer used inside buildPriorContext.
+   */
+  llm: CouncilLLM;
+  optOut?: boolean;
+}): Promise<{ digest: string; runs: PriorRunSummary[] }> {
+  if (opts.optOut) return { digest: "", runs: [] };
+
+  const runs = await discoverPriorRuns(opts.flowDir, opts.runId, opts.idea);
+
+  // Digest synthesis is no longer needed: PIL Layer 3 + EE T0 handle semantic
+  // injection per-call. The caller still uses runs.length for the discovery card.
+  const digest = "";
+
+  const runDir = path.join(opts.flowDir, "runs", opts.runId);
+  try {
+    const stateMap = (await readArtifact(runDir, "state.md")) ?? { preamble: "", sections: new Map() };
+
+    // Query both PIL Layer 3 injection events (event_subtype IS NULL or "injected"/noise/error)
+    // and extract events (event_subtype = "extract") for this run.
+    const allRows = selectEEInjectionsForRun(opts.runId, 40);
+    const pilRows = allRows.filter((r) => r.event_subtype !== "extract");
+    const extractRows = allRows.filter((r) => r.event_subtype === "extract");
+
+    if (allRows.length === 0) {
+      stateMap.sections.set(
+        "EE Injections (Layer 3)",
+        "_(no EE injections recorded yet — PIL Layer 3 fires on the next LLM call)_",
+      );
+    } else {
+      const lines: string[] = [];
+      lines.push(`**Prior runs scanned:** ${runs.length} (similarity-filtered)`);
+      lines.push("");
+
+      // PIL injection hits
+      lines.push(`**PIL Layer 3 hits this run:** ${pilRows.length}`);
+      for (const row of pilRows) {
+        let detail = "";
+        if (row.metadata_json) {
+          try {
+            const meta = JSON.parse(row.metadata_json) as Record<string, unknown>;
+            const pc = meta.principleCount ?? "";
+            const bc = meta.behavioralCount ?? "";
+            if (pc !== "" || bc !== "") {
+              detail = ` | principles=${pc} behavioral=${bc}`;
+            }
+          } catch {
+            /* ignore malformed json */
+          }
+        }
+        const subtype = row.event_subtype ? ` (${row.event_subtype})` : "";
+        lines.push(`- ${row.created_at}: injected at score floor 0.55${subtype}${detail}`);
+      }
+      lines.push("");
+
+      // Extract outcomes
+      lines.push(`**Extracts this run:** ${extractRows.length}`);
+      for (const row of extractRows) {
+        let detail = "";
+        if (row.metadata_json) {
+          try {
+            const meta = JSON.parse(row.metadata_json) as Record<string, unknown>;
+            const ok = meta.ok ?? "?";
+            const stored = meta.stored ?? "?";
+            const mistakes = meta.mistakes ?? "?";
+            const ms = row.duration_ms ?? "?";
+            detail = `ok=${ok} stored=${stored} mistakes=${mistakes} durationMs=${ms}`;
+          } catch {
+            detail = "metadata_parse_error";
+          }
+        }
+        lines.push(`- ${row.created_at}: ${detail}`);
+      }
+      lines.push("");
+
+      lines.push(
+        `*Audit raw events: \`sqlite3 ~/.muonroi-cli/muonroi.db "SELECT * FROM interaction_logs WHERE session_id='${opts.runId}' AND event_type='ee_injection' ORDER BY created_at DESC"\`*`,
+      );
+
+      stateMap.sections.set("EE Injections (Layer 3)", lines.join("\n"));
+    }
+    await writeArtifact(runDir, "state.md", stateMap);
+  } catch {
+    /* non-critical — state.md write must never throw */
+  }
+
+  return { digest, runs };
+}
+
+// ─── P1: EE transcript extraction ────────────────────────────────────────────
+
+const TRANSCRIPT_FILES = ["manifest.md", "roadmap.md", "delegations.md", "gray-areas.md"] as const;
+const MAX_TRANSCRIPT_BYTES = 32768;
+
+/**
+ * Compose a single transcript string from the run artifact files
+ * (manifest.md, roadmap.md, delegations.md, gray-areas.md), in that exact
+ * order, each prefixed with a section header. Missing files are skipped
+ * silently. If total length exceeds 32KB, the result is truncated and a
+ * "[...truncated]" marker appended.
+ */
+export async function composeRunTranscript(flowDir: string, runId: string): Promise<string> {
+  const runDir = path.join(flowDir, "runs", runId);
+  const parts: string[] = [];
+
+  for (const file of TRANSCRIPT_FILES) {
+    const filePath = path.join(runDir, file);
+    let content: string;
+    try {
+      content = await fs.readFile(filePath, "utf8");
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") continue;
+      throw err;
+    }
+    parts.push(`\n\n# ${file}\n\n${content}`);
+  }
+
+  const result = parts.join("");
+  if (Buffer.byteLength(result) > MAX_TRANSCRIPT_BYTES) {
+    // Truncate to exactly MAX_TRANSCRIPT_BYTES characters and append marker.
+    return result.slice(0, MAX_TRANSCRIPT_BYTES) + "\n\n[...truncated]";
+  }
+  return result;
+}
+
+/**
+ * Extract a run's artifact transcript to the Experience Engine.
+ *
+ * Non-fatal: any network/client error returns { ok: false } without throwing.
+ * Callers are responsible for telemetry/logging.
+ */
+export async function extractRunToEE(
+  flowDir: string,
+  runId: string,
+  projectPath: string,
+): Promise<{ ok: boolean; mistakes?: number; stored?: number; durationMs: number }> {
+  const transcript = await composeRunTranscript(flowDir, runId);
+
+  if (transcript.length === 0) {
+    return { ok: false, durationMs: 0 };
+  }
+
+  const t0 = performance.now();
+  try {
+    const response = await getDefaultEEClient().extract({
+      transcript,
+      projectPath,
+      meta: { source: "cli-exit", scope: `ideal:${runId}` },
+    });
+    const durationMs = performance.now() - t0;
+
+    if (response === null) {
+      return { ok: false, durationMs };
+    }
+    return {
+      ok: response.ok,
+      mistakes: response.mistakes,
+      stored: response.stored,
+      durationMs,
+    };
+  } catch {
+    const durationMs = performance.now() - t0;
+    return { ok: false, durationMs };
+  }
+}
+
+// ─── P5: Prior-run prompt context ─────────────────────────────────────────────
+
+/**
+ * Format the digest for injection into clarifier/debate conversationContext.
+ */
+export function formatPriorContextForPrompt(digest: string): string {
+  const trimmed = digest.trim();
+  if (!trimmed) return "";
+  const header = "\n## Prior Decisions Context (from earlier /ideal runs on this workspace)\n";
+  const intro =
+    "These are reusable lessons - treat as defaults you may override with explicit reason, not as hard requirements.\n\n";
+  return header + intro + trimmed + "\n";
+}

package/src/product-loop/design-output.ts

@@ -0,0 +1,24 @@
+import type { DesignSpec, UINode } from "@muonroi/agent-harness-core/protocol";
+import { PROTOCOL_VERSION } from "@muonroi/agent-harness-core/protocol";
+
+type Input = Omit<DesignSpec, "mode" | "version">;
+
+function collectIds(node: UINode, set: Set<string>): void {
+  set.add(node.id);
+  for (const c of node.children ?? []) collectIds(c, set);
+}
+
+export function emitDesignSpec(input: Input): DesignSpec {
+  for (const scene of input.scenes) {
+    const ids = new Set<string>();
+    collectIds(scene.layout, ids);
+    for (const state of scene.states ?? []) {
+      for (const p of state.patches) {
+        if (!ids.has(p.id)) {
+          throw new Error(`patch references unknown id "${p.id}" in scene "${scene.id}"`);
+        }
+      }
+    }
+  }
+  return { mode: "design", version: PROTOCOL_VERSION, ...input };
+}

package/src/product-loop/discover.ts

@@ -0,0 +1,159 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+
+/**
+ * High-confidence project discovery for /ideal — runs before gather so the
+ * loop does not ask the user about things the codebase already answers (stack,
+ * test command). Soft dimensions like persona/core-features/cost-tolerance are
+ * deliberately NOT auto-filled (low signal-to-noise from README scraping).
+ */
+export interface DiscoveryResult {
+  hasProject: boolean;
+  /** Maps SEED_DIMENSIONS.id → confident answer. Only populated when evidence is unambiguous. */
+  prefilled: Map<string, string>;
+  /** Audit trail: which file proved each dimension. */
+  evidence: Array<{ dim: string; source: string; value: string }>;
+  /** Human-readable summary line per discovery (for the streamed chunk). */
+  notes: string[];
+}
+
+interface ManifestProbe {
+  filename: string;
+  language: string;
+  testHint?: string;
+}
+
+const MANIFESTS: ManifestProbe[] = [
+  { filename: "package.json", language: "TypeScript/JavaScript (Node.js)" },
+  { filename: "pyproject.toml", language: "Python", testHint: "pytest" },
+  { filename: "requirements.txt", language: "Python", testHint: "pytest" },
+  { filename: "Cargo.toml", language: "Rust", testHint: "cargo test" },
+  { filename: "go.mod", language: "Go", testHint: "go test ./..." },
+  { filename: "pom.xml", language: "Java (Maven)", testHint: "mvn test" },
+  { filename: "build.gradle", language: "Java/Kotlin (Gradle)", testHint: "gradle test" },
+  { filename: "Gemfile", language: "Ruby", testHint: "bundle exec rspec" },
+  { filename: "composer.json", language: "PHP", testHint: "composer test" },
+];
+
+export async function discoverProject(cwd: string | undefined): Promise<DiscoveryResult> {
+  const result: DiscoveryResult = {
+    hasProject: false,
+    prefilled: new Map(),
+    evidence: [],
+    notes: [],
+  };
+  if (!cwd) return result;
+
+  for (const probe of MANIFESTS) {
+    const found = await readIfExists(path.join(cwd, probe.filename));
+    if (!found) continue;
+    result.hasProject = true;
+
+    if (probe.filename === "package.json") {
+      await fillFromPackageJson(found, probe, result);
+    } else {
+      // Non-package.json manifests: language is enough for tech-constraints; test hint
+      // is best-effort (does not parse contents for fine-grained framework detection).
+      addPrefill(
+        result,
+        "tech-constraints",
+        probe.language,
+        probe.filename,
+        `Detected ${probe.language} from ${probe.filename}`,
+      );
+      if (probe.testHint) {
+        addPrefill(
+          result,
+          "success-metric",
+          `automated tests pass (${probe.testHint})`,
+          probe.filename,
+          `Test runner inferred: ${probe.testHint}`,
+        );
+      }
+    }
+    break;
+  }
+
+  return result;
+}
+
+async function fillFromPackageJson(content: string, probe: ManifestProbe, out: DiscoveryResult): Promise<void> {
+  let pkg: any = null;
+  try {
+    pkg = JSON.parse(content);
+  } catch {
+    addPrefill(
+      out,
+      "tech-constraints",
+      probe.language,
+      probe.filename,
+      `Detected ${probe.language} from package.json (unparseable, using default stack)`,
+    );
+    return;
+  }
+
+  const frameworks = detectNodeFrameworks(pkg);
+  const stack = frameworks.length > 0 ? `${probe.language} + ${frameworks.join(", ")}` : probe.language;
+  addPrefill(out, "tech-constraints", stack, probe.filename, `Stack: ${stack}`);
+
+  const testCmd: string | undefined = pkg?.scripts?.test;
+  if (testCmd && !/echo .*no test/i.test(testCmd)) {
+    addPrefill(
+      out,
+      "success-metric",
+      `automated tests pass via \`npm test\` (${testCmd.slice(0, 80)})`,
+      probe.filename,
+      `Test command: ${testCmd.slice(0, 80)}`,
+    );
+  }
+}
+
+function detectNodeFrameworks(pkg: any): string[] {
+  const out: string[] = [];
+  const deps: Record<string, string> = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
+  if (deps["react"] || deps["next"]) out.push("React/Next.js");
+  if (deps["vue"] || deps["nuxt"]) out.push("Vue/Nuxt");
+  if (deps["@angular/core"]) out.push("Angular");
+  if (deps["express"] || deps["fastify"] || deps["koa"]) out.push("Node.js HTTP");
+  if (deps["nestjs"] || deps["@nestjs/core"]) out.push("NestJS");
+  if (deps["vitest"]) out.push("Vitest");
+  else if (deps["jest"]) out.push("Jest");
+  return out;
+}
+
+function addPrefill(out: DiscoveryResult, dim: string, value: string, source: string, note: string): void {
+  if (out.prefilled.has(dim)) return;
+  out.prefilled.set(dim, value);
+  out.evidence.push({ dim, source, value });
+  out.notes.push(note);
+}
+
+async function readIfExists(p: string): Promise<string | null> {
+  try {
+    return await fs.readFile(p, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format DiscoveryResult into a single content chunk for the UI. Returns null
+ * when nothing was detected (caller can skip the chunk).
+ */
+export function formatDiscoverySummary(d: DiscoveryResult): string | null {
+  if (!d.hasProject) {
+    return "No existing project manifest detected — proceeding as greenfield.";
+  }
+  if (d.prefilled.size === 0) {
+    return "Existing project detected, but no high-confidence dimensions could be auto-filled.";
+  }
+  const lines = ["**Discovered from your project:**"];
+  for (const ev of d.evidence) {
+    lines.push(`- \`${ev.dim}\` ← ${ev.value} _(from ${ev.source})_`);
+  }
+  lines.push("");
+  lines.push(
+    `Skipping ${d.prefilled.size} clarification question${d.prefilled.size === 1 ? "" : "s"}; you'll only be asked the rest.`,
+  );
+  return lines.join("\n");
+}

package/src/product-loop/discovery-context-format.ts

@@ -0,0 +1,32 @@
+// src/product-loop/discovery-context-format.ts
+import type { ProjectContext } from "./types.js";
+
+export function formatProjectContextForPrompt(ctx: ProjectContext): string {
+  const lines: string[] = [];
+  lines.push(`Idea: ${ctx.idea}`);
+  lines.push(`Product type: ${ctx.context.productType}`);
+  lines.push(`Platform: ${ctx.context.targetPlatform.join(", ")}`);
+  lines.push(
+    `Audience: ${ctx.context.audience.persona} (scale ${ctx.context.audience.scale}, ${ctx.context.audience.geography})`,
+  );
+  lines.push(`Backend arch: ${ctx.context.backendArchitecture}`);
+  lines.push(
+    `Backend stack: ${ctx.context.backendStack.language} / ${ctx.context.backendStack.framework}${ctx.context.backendStack.runtime ? " on " + ctx.context.backendStack.runtime : ""}`,
+  );
+  lines.push(`Database: ${ctx.context.dbStrategy.mode} ${ctx.context.dbStrategy.engine}`);
+  if (ctx.context.frontendApproach) {
+    const harness = ctx.context.frontendApproach.agentHarness
+      ? ` (harness: @muonroi/agent-harness-${ctx.context.frontendApproach.agentHarness})`
+      : "";
+    lines.push(
+      `Frontend: ${ctx.context.frontendApproach.library} + ${ctx.context.frontendApproach.framework}${harness}`,
+    );
+  }
+  if (ctx.context.deployment) {
+    lines.push(
+      `Deployment: ${ctx.context.deployment.target}${ctx.context.deployment.provider ? " on " + ctx.context.deployment.provider : ""}`,
+    );
+  }
+  lines.push(`Constraints: fePolicy=${ctx.recommendations.constraints.fePolicy}`);
+  return lines.join("\n");
+}