muonroi-cli 1.4.0 → 1.4.1

package/src/product-loop/sprint-self-verify.ts

@@ -1,189 +0,0 @@
-/**
- * src/product-loop/sprint-self-verify.ts
- *
- * Tier 3 — sprint pipeline integration of the self-QA harness.
- *
- * After the verification stage passes (recipe verdict = PASS), if the sprint
- * touched UI / harness watched surfaces, spawn Tier 1 self-verify to catch
- * lifecycle / modal / focus bugs that vitest cannot see. Result is ADDITIVE:
- * a self-verify failure downgrades the sprint verdict to FAIL so the loop
- * iterates again with the failure context in the carryOver feedback.
- *
- * Default OFF — opt-in via MUONROI_SPRINT_SELF_VERIFY=1. Off keeps the sprint
- * loop fast and avoids the ~30s tax on every iteration during /ideal runs.
- *
- * Hook point: `src/product-loop/sprint-runner.ts` ~ line 425 (after
- * `parseVerifyResult` if verdict === "PASS"). See CLAUDE.md §Tier 3 doc.
- */
-
-import { execSync, spawnSync } from "node:child_process";
-import * as path from "node:path";
-
-/** Watched surfaces — must mirror `scripts/self-verify-pre-push.cjs` WATCH_DIRS. */
-const WATCH_DIRS = ["src/ui/", "src/self-qa/", "src/agent-harness/", "packages/agent-harness-"];
-
-export interface SprintSelfVerifyResult {
-  ran: boolean;
-  /** Reason the verifier did not run, when `ran === false`. */
-  skipReason?: "disabled" | "no-watched-changes" | "no-baseref" | "spawn-failed";
-  /** Verdict from self-verify when `ran === true`. */
-  verdict?: "pass" | "fail" | "inconclusive";
-  /** Markdown-formatted detail for inclusion in sprint feedback / verifyResult.error. */
-  detail?: string;
-  /** Wall-clock elapsed in ms. */
-  elapsedMs?: number;
-}
-
-export interface SprintSelfVerifyOpts {
-  /** Project root — used as cwd for git and the self-verify spawn. */
-  repoRoot: string;
-  /**
-   * Git ref to diff HEAD against. Typical caller passes `ctx.baseRef` or
-   * falls back to `origin/master`. When undefined, falls back to `HEAD~1`
-   * so a single-commit sprint still gets coverage.
-   */
-  baseRef?: string;
-  /** Max scenarios for the Tier 1 heuristic run. Defaults to 4. */
-  maxScenarios?: number;
-  /** Timeout for the self-verify child. Defaults to 90s. */
-  timeoutMs?: number;
-  /**
-   * Optional override for the env-var gate. Tests pass `true` to bypass the
-   * default-off behaviour without setting process.env.
-   */
-  forceEnable?: boolean;
-}
-
-/**
- * Default ON for local dev — only OFF when running in CI or when the developer
- * explicitly disables via MUONROI_SPRINT_SELF_VERIFY=0. Rationale: Tier 1 is
- * fast (~30s) and cheap (<$0.01) and catches the most common UI regressions.
- * Off-by-default leaks the gate; on-by-default makes it impossible to forget.
- *
- * CI gets OFF to avoid the ~30s tax on every sprint when nightly /ideal runs
- * generate many iterations.
- */
-function isEnabled(forceEnable?: boolean): boolean {
-  if (forceEnable === true) return true;
-  const v = process.env["MUONROI_SPRINT_SELF_VERIFY"];
-  if (v === "0" || (v && v.toLowerCase() === "false")) return false;
-  if (process.env["CI"] === "true" || process.env["NODE_ENV"] === "ci") return false;
-  // Default: ON. v === "1"/"true" still works; absence of env var also enables.
-  return true;
-}
-
-function detectTouchedWatched(repoRoot: string, baseRef: string): string[] {
-  try {
-    const out = execSync(`git diff --name-only ${baseRef}...HEAD`, {
-      cwd: repoRoot,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-    return out
-      .split(/\r?\n/)
-      .map((l) => l.trim())
-      .filter(Boolean)
-      .filter((f) => WATCH_DIRS.some((d) => f.startsWith(d)));
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Spawn `bun run src/index.ts self-verify --since <baseRef> --max <n> --no-emit --json`
- * and parse the trailing JSON summary line.
- *
- * Returns the parsed verdict plus elapsed ms. Crash / timeout = inconclusive.
- */
-export async function runSprintSelfVerify(opts: SprintSelfVerifyOpts): Promise<SprintSelfVerifyResult> {
-  const t0 = Date.now();
-
-  if (!isEnabled(opts.forceEnable)) {
-    return { ran: false, skipReason: "disabled" };
-  }
-
-  const baseRef = opts.baseRef ?? "HEAD~1";
-  const repoRoot = opts.repoRoot;
-
-  const touched = detectTouchedWatched(repoRoot, baseRef);
-  if (touched.length === 0) {
-    return { ran: false, skipReason: "no-watched-changes" };
-  }
-
-  const max = String(opts.maxScenarios ?? 4);
-  const entry = path.join(repoRoot, "src", "index.ts");
-  const result = spawnSync(
-    "bun",
-    ["run", entry, "self-verify", "--since", baseRef, "--max", max, "--no-emit", "--json"],
-    {
-      cwd: repoRoot,
-      encoding: "utf8",
-      timeout: opts.timeoutMs ?? 90_000,
-      shell: process.platform === "win32",
-    },
-  );
-
-  if (result.error || result.status === null) {
-    return {
-      ran: false,
-      skipReason: "spawn-failed",
-      detail: `self-verify spawn failed: ${result.error?.message ?? "unknown"}`,
-      elapsedMs: Date.now() - t0,
-    };
-  }
-
-  // In --json mode the CLI silences all log() output and prints a single
-  // pretty-printed report JSON. Parse the whole stdout, then read .summary.
-  let report: { summary?: { passed?: number; failed?: number; inconclusive?: number; total?: number } } | null = null;
-  try {
-    const raw = (result.stdout ?? "").trim();
-    if (raw.startsWith("{")) report = JSON.parse(raw);
-  } catch {
-    /* fall through to inconclusive */
-  }
-  const summary = report?.summary ?? null;
-
-  const elapsedMs = Date.now() - t0;
-  if (!summary) {
-    return {
-      ran: true,
-      verdict: "inconclusive",
-      detail: `self-verify produced no parseable JSON summary (exit ${result.status})`,
-      elapsedMs,
-    };
-  }
-
-  const failed = summary.failed ?? 0;
-  const passed = summary.passed ?? 0;
-  const inconc = summary.inconclusive ?? 0;
-  const total = summary.total ?? failed + passed + inconc;
-
-  if (failed > 0) {
-    return {
-      ran: true,
-      verdict: "fail",
-      detail: [
-        `Self-verify Tier 1 reported ${failed}/${total} scenario(s) FAILED on watched UI / harness surfaces.`,
-        `Touched files (${touched.length}):`,
-        ...touched.slice(0, 8).map((f) => `  - ${f}`),
-        touched.length > 8 ? `  (+${touched.length - 8} more)` : "",
-        "",
-        "Action: re-run with --agentic to capture richer goal/actual mismatch, then update the implementation.",
-        "Override (NOT recommended) to ignore this gate: MUONROI_SPRINT_SELF_VERIFY=0.",
-      ]
-        .filter(Boolean)
-        .join("\n"),
-      elapsedMs,
-    };
-  }
-
-  if (passed > 0 && inconc === 0) {
-    return { ran: true, verdict: "pass", elapsedMs };
-  }
-  return {
-    ran: true,
-    verdict: "inconclusive",
-    detail: `Self-verify Tier 1: ${passed}/${total} passed, ${inconc} inconclusive — no hard failures.`,
-    elapsedMs,
-  };
-}

package/src/product-loop/sprint-store.ts

@@ -1,96 +0,0 @@
-/**
- * src/product-loop/sprint-store.ts
- *
- * Atomic read/write helpers for .planning/runs/<runId>/sprint-plan.json.
- * Mirrors backlog-store.ts — same atomicWriteJSON / atomicReadJSON helpers,
- * same patch semantics.
- */
-
-import * as path from "node:path";
-import { atomicReadJSON, atomicWriteJSON } from "../storage/atomic-io.js";
-import type { Sprint, SprintPlan } from "./types.js";
-
-function sprintPlanPath(flowDir: string, runId: string): string {
-  return path.join(flowDir, "runs", runId, "sprint-plan.json");
-}
-
-/**
- * Read sprint-plan.json for a run. Returns null when the file does not exist.
- */
-export async function readSprintPlan(flowDir: string, runId: string): Promise<SprintPlan | null> {
-  return atomicReadJSON<SprintPlan>(sprintPlanPath(flowDir, runId));
-}
-
-/**
- * Write (overwrite) sprint-plan.json atomically.
- */
-export async function writeSprintPlan(flowDir: string, runId: string, plan: SprintPlan): Promise<void> {
-  await atomicWriteJSON(sprintPlanPath(flowDir, runId), plan);
-}
-
-/**
- * Mark a sprint as active. If another sprint was already active, flip it to "done" first.
- * Sets startedAtUtc on the newly-active sprint and updates plan.activeSprintId.
- * Throws when sprint-plan.json is missing or the sprintId is not found.
- */
-export async function setActiveSprint(flowDir: string, runId: string, sprintId: string): Promise<SprintPlan> {
-  const plan = await readSprintPlan(flowDir, runId);
-  if (!plan) {
-    throw new Error(`setActiveSprint: sprint-plan.json not found for runId=${runId}`);
-  }
-
-  const targetIdx = plan.sprints.findIndex((s: Sprint) => s.id === sprintId);
-  if (targetIdx === -1) {
-    throw new Error(`setActiveSprint: sprint id=${sprintId} not found in plan for runId=${runId}`);
-  }
-
-  const now = new Date().toISOString();
-
-  // Flip any currently-active sprint to done first.
-  plan.sprints = plan.sprints.map((s: Sprint) => {
-    if (s.status === "active" && s.id !== sprintId) {
-      return { ...s, status: "done" as const, endedAtUtc: now };
-    }
-    return s;
-  });
-
-  plan.sprints[targetIdx] = {
-    ...plan.sprints[targetIdx],
-    status: "active",
-    startedAtUtc: now,
-  };
-  plan.activeSprintId = sprintId;
-
-  await writeSprintPlan(flowDir, runId, plan);
-  return plan;
-}
-
-/**
- * Mark a sprint as done. Clears activeSprintId if it matched the given sprint.
- * Sets endedAtUtc. Throws when sprint-plan.json is missing or the sprintId is not found.
- */
-export async function markSprintDone(flowDir: string, runId: string, sprintId: string): Promise<SprintPlan> {
-  const plan = await readSprintPlan(flowDir, runId);
-  if (!plan) {
-    throw new Error(`markSprintDone: sprint-plan.json not found for runId=${runId}`);
-  }
-
-  const targetIdx = plan.sprints.findIndex((s: Sprint) => s.id === sprintId);
-  if (targetIdx === -1) {
-    throw new Error(`markSprintDone: sprint id=${sprintId} not found in plan for runId=${runId}`);
-  }
-
-  const now = new Date().toISOString();
-  plan.sprints[targetIdx] = {
-    ...plan.sprints[targetIdx],
-    status: "done",
-    endedAtUtc: now,
-  };
-
-  if (plan.activeSprintId === sprintId) {
-    delete plan.activeSprintId;
-  }
-
-  await writeSprintPlan(flowDir, runId, plan);
-  return plan;
-}

package/src/product-loop/stakeholder-acl.ts

@@ -1,82 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { atomicWriteText } from "../storage/atomic-io.js";
-import { withFileLock } from "../utils/file-lock.js";
-
-const SCHEMA_VERSION = 1;
-
-export interface Stakeholder {
-  discordUserId: string;
-  displayName: string;
-  addedAtUtc: string;
-  addedBy: "owner" | "cli";
-}
-
-export interface StakeholderStore {
-  version: number;
-  items: Record<string, { productSlug: string; stakeholders: Stakeholder[] }>;
-}
-
-function muonroiHome(): string {
-  return process.env.MUONROI_CLI_HOME ?? path.join(os.homedir(), ".muonroi-cli");
-}
-
-function storePath(): string {
-  return path.join(muonroiHome(), "stakeholders.json");
-}
-
-async function readStore(): Promise<StakeholderStore> {
-  const filePath = storePath();
-  let raw: string;
-  try {
-    raw = await fs.readFile(filePath, "utf8");
-  } catch {
-    return { version: SCHEMA_VERSION, items: {} };
-  }
-  let parsed: StakeholderStore;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    await fs.rename(filePath, `${filePath}.corrupt-${ts}`).catch(() => {});
-    return { version: SCHEMA_VERSION, items: {} };
-  }
-  if (parsed.version !== SCHEMA_VERSION) {
-    throw new Error(`stakeholder-acl: unsupported schema version ${parsed.version} (expected ${SCHEMA_VERSION})`);
-  }
-  return parsed;
-}
-
-async function writeStore(store: StakeholderStore): Promise<void> {
-  await fs.mkdir(muonroiHome(), { recursive: true });
-  await atomicWriteText(storePath(), JSON.stringify(store, null, 2));
-}
-
-export async function listStakeholders(slug: string): Promise<Stakeholder[]> {
-  const store = await readStore();
-  return store.items[slug]?.stakeholders ?? [];
-}
-
-export async function addStakeholder(slug: string, s: Stakeholder): Promise<void> {
-  await withFileLock(storePath(), async () => {
-    const store = await readStore();
-    const entry = store.items[slug] ?? { productSlug: slug, stakeholders: [] };
-    if (!entry.stakeholders.some((x) => x.discordUserId === s.discordUserId)) {
-      entry.stakeholders.push(s);
-    }
-    store.items[slug] = entry;
-    await writeStore(store);
-  });
-}
-
-export async function removeStakeholder(slug: string, discordUserId: string): Promise<void> {
-  await withFileLock(storePath(), async () => {
-    const store = await readStore();
-    const entry = store.items[slug];
-    if (!entry) return;
-    entry.stakeholders = entry.stakeholders.filter((x) => x.discordUserId !== discordUserId);
-    store.items[slug] = entry;
-    await writeStore(store);
-  });
-}

package/src/product-loop/typed-artifacts.ts

@@ -1,332 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as path from "node:path";
-import { atomicWriteText } from "../storage/atomic-io.js";
-import type { Criterion, ProductSpec } from "./types.js";
-
-/**
- * P8 - Typed JSON artifacts.
- *
- * The /ideal feature persists markdown sections to roadmap.md, gray-areas.md,
- * and delegations.md so the user can read them. But downstream commands
- * (/execute consuming tasks, /review checking decisions) have to re-parse
- * brittle markdown to extract structured data. P8 adds a parallel set of
- * canonical JSON artifacts that downstream features consume directly.
- *
- * Strategy: dual-write. Markdown stays as the human-readable surface;
- * JSON is the machine-readable canonical store. Both come from the same
- * source data so they cannot drift. Backward compat: callers that read
- * markdown continue to work; new callers prefer JSON.
- *
- * Files in runs/<id>/:
- *   tasks.json     - actionable units derived from MVP + phase2 + sprint plans
- *   decisions.json - architectural / framework / scope decisions surfaced
- *                    during research + scoping
- *   risks.json     - risks with likelihood, impact, mitigation, owner
- *   criteria.json  - structured mirror of gray-areas.md
- */
-
-const ARTIFACTS_VERSION = 1;
-
-interface VersionedFile<T> {
-  version: 1;
-  generatedAt: string;
-  items: T[];
-}
-
-export interface TaskArtifact {
-  id: string;
-  title: string;
-  description?: string;
-  owner: "PO" | "Architect" | "Implementer" | "Tester" | "Reviewer" | "Customer" | "User";
-  dependencies: string[];
-  estimate: { sprint: number; tokens?: number };
-  acceptanceCriteria: string[];
-  status: "pending" | "in_progress" | "done" | "blocked";
-  source: "mvp" | "phase2" | "sprint" | "manual";
-}
-
-export interface DecisionArtifact {
-  id: string;
-  question: string;
-  choice: string;
-  alternatives: string[];
-  rationale: string;
-  reversibility: "easy" | "moderate" | "hard";
-  madeAt: { phase: "research" | "scoping" | "sprint"; sprint?: number };
-}
-
-export interface RiskArtifact {
-  id: string;
-  description: string;
-  likelihood: "low" | "medium" | "high";
-  impact: "low" | "medium" | "high";
-  mitigation: string;
-  owner: string;
-  triggeredInSprint?: number;
-  status: "open" | "mitigated" | "accepted" | "occurred";
-}
-
-export interface CriterionArtifact {
-  id: string;
-  status: "met" | "partial" | "unmet";
-  evidence?: string;
-  sprint?: number;
-}
-
-// ── Path helpers ────────────────────────────────────────────────────────────
-
-function tasksPath(flowDir: string, runId: string): string {
-  return path.join(flowDir, "runs", runId, "tasks.json");
-}
-function decisionsPath(flowDir: string, runId: string): string {
-  return path.join(flowDir, "runs", runId, "decisions.json");
-}
-function risksPath(flowDir: string, runId: string): string {
-  return path.join(flowDir, "runs", runId, "risks.json");
-}
-function criteriaPath(flowDir: string, runId: string): string {
-  return path.join(flowDir, "runs", runId, "criteria.json");
-}
-
-// ── Generic IO ──────────────────────────────────────────────────────────────
-
-async function readVersioned<T>(filePath: string): Promise<VersionedFile<T>> {
-  try {
-    const raw = await fs.readFile(filePath, "utf8");
-    const parsed = JSON.parse(raw) as VersionedFile<T>;
-    if (parsed.version !== ARTIFACTS_VERSION) {
-      return { version: ARTIFACTS_VERSION, generatedAt: new Date().toISOString(), items: [] };
-    }
-    return parsed;
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-      return { version: ARTIFACTS_VERSION, generatedAt: new Date().toISOString(), items: [] };
-    }
-    throw err;
-  }
-}
-
-async function writeVersioned<T>(filePath: string, items: T[]): Promise<void> {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  const payload: VersionedFile<T> = {
-    version: ARTIFACTS_VERSION,
-    generatedAt: new Date().toISOString(),
-    items,
-  };
-  await atomicWriteText(filePath, JSON.stringify(payload, null, 2));
-}
-
-// ── Tasks ───────────────────────────────────────────────────────────────────
-
-/**
- * Derive tasks from a ProductSpec. Each MVP item becomes a task owned by
- * Implementer with sprint=1; each phase2 item becomes a task with the
- * later sprint estimate. Idempotent: re-deriving the same spec produces
- * the same ids.
- */
-export function deriveTasksFromSpec(spec: ProductSpec): TaskArtifact[] {
-  const tasks: TaskArtifact[] = [];
-  spec.mvp.forEach((feature, i) => {
-    tasks.push({
-      id: `t_mvp_${(i + 1).toString().padStart(2, "0")}`,
-      title: feature,
-      owner: "Implementer",
-      dependencies: i === 0 ? [] : [`t_mvp_${i.toString().padStart(2, "0")}`],
-      estimate: { sprint: 1 },
-      acceptanceCriteria: [],
-      status: "pending",
-      source: "mvp",
-    });
-  });
-  spec.phase2.forEach((feature, i) => {
-    tasks.push({
-      id: `t_p2_${(i + 1).toString().padStart(2, "0")}`,
-      title: feature,
-      owner: "Implementer",
-      dependencies: spec.mvp.length > 0 ? [`t_mvp_${spec.mvp.length.toString().padStart(2, "0")}`] : [],
-      estimate: { sprint: 2 },
-      acceptanceCriteria: [],
-      status: "pending",
-      source: "phase2",
-    });
-  });
-  return tasks;
-}
-
-export async function readTasks(flowDir: string, runId: string): Promise<TaskArtifact[]> {
-  const f = await readVersioned<TaskArtifact>(tasksPath(flowDir, runId));
-  return f.items;
-}
-
-export async function writeTasks(flowDir: string, runId: string, tasks: TaskArtifact[]): Promise<void> {
-  await writeVersioned(tasksPath(flowDir, runId), tasks);
-}
-
-/**
- * Update a single task's status. No-op if id is missing.
- */
-export async function updateTaskStatus(
-  flowDir: string,
-  runId: string,
-  id: string,
-  status: TaskArtifact["status"],
-): Promise<void> {
-  const tasks = await readTasks(flowDir, runId);
-  const target = tasks.find((t) => t.id === id);
-  if (!target) return;
-  target.status = status;
-  await writeTasks(flowDir, runId, tasks);
-}
-
-// ── Decisions ───────────────────────────────────────────────────────────────
-
-export async function readDecisions(flowDir: string, runId: string): Promise<DecisionArtifact[]> {
-  const f = await readVersioned<DecisionArtifact>(decisionsPath(flowDir, runId));
-  return f.items;
-}
-
-export async function writeDecisions(flowDir: string, runId: string, items: DecisionArtifact[]): Promise<void> {
-  await writeVersioned(decisionsPath(flowDir, runId), items);
-}
-
-/**
- * Append decisions, deduping by id. Existing decisions are NOT overwritten.
- */
-export async function appendDecisions(
-  flowDir: string,
-  runId: string,
-  newOnes: DecisionArtifact[],
-): Promise<DecisionArtifact[]> {
-  const existing = await readDecisions(flowDir, runId);
-  const byId = new Map(existing.map((d) => [d.id, d]));
-  for (const d of newOnes) if (!byId.has(d.id)) byId.set(d.id, d);
-  const merged = Array.from(byId.values());
-  await writeDecisions(flowDir, runId, merged);
-  return merged;
-}
-
-// ── Risks ───────────────────────────────────────────────────────────────────
-
-export async function readRisks(flowDir: string, runId: string): Promise<RiskArtifact[]> {
-  const f = await readVersioned<RiskArtifact>(risksPath(flowDir, runId));
-  return f.items;
-}
-
-export async function writeRisks(flowDir: string, runId: string, items: RiskArtifact[]): Promise<void> {
-  await writeVersioned(risksPath(flowDir, runId), items);
-}
-
-export async function appendRisks(flowDir: string, runId: string, newOnes: RiskArtifact[]): Promise<RiskArtifact[]> {
-  const existing = await readRisks(flowDir, runId);
-  const byId = new Map(existing.map((r) => [r.id, r]));
-  for (const r of newOnes) if (!byId.has(r.id)) byId.set(r.id, r);
-  const merged = Array.from(byId.values());
-  await writeRisks(flowDir, runId, merged);
-  return merged;
-}
-
-// ── Criteria mirror ─────────────────────────────────────────────────────────
-
-/**
- * Mirror gray-areas.md criteria into criteria.json. Source of truth stays
- * as the markdown file; this is a derived snapshot for downstream consumers.
- */
-export async function syncCriteriaSnapshot(flowDir: string, runId: string, criteria: Criterion[]): Promise<void> {
-  const items: CriterionArtifact[] = criteria.map((c) => ({
-    id: c.id,
-    status: c.status,
-    evidence: c.evidence,
-    sprint: c.sprint,
-  }));
-  await writeVersioned(criteriaPath(flowDir, runId), items);
-}
-
-export async function readCriteriaSnapshot(flowDir: string, runId: string): Promise<CriterionArtifact[]> {
-  const f = await readVersioned<CriterionArtifact>(criteriaPath(flowDir, runId));
-  return f.items;
-}
-
-// ── Extraction from debate ──────────────────────────────────────────────────
-
-/**
- * Heuristic id derivation from claim text.
- */
-function shortIdFrom(prefix: string, text: string): string {
-  const normalized = text.toLowerCase().replace(/\s+/g, " ").trim();
-  let hash = 0;
-  for (let i = 0; i < normalized.length; i++) {
-    hash = ((hash << 5) - hash + normalized.charCodeAt(i)) | 0;
-  }
-  return `${prefix}_${Math.abs(hash).toString(36).padStart(6, "0")}`;
-}
-
-/**
- * Parse an LLM-emitted JSON array of decisions. Tolerant of code fences,
- * preambles, and trailing junk. Returns [] on parse failure.
- */
-export function parseDecisionsJson(raw: string): DecisionArtifact[] {
-  const stripped = raw
-    .trim()
-    .replace(/^```(?:json)?\s*/i, "")
-    .replace(/```\s*$/i, "")
-    .trim();
-  try {
-    const parsed = JSON.parse(stripped);
-    if (!Array.isArray(parsed)) return [];
-    const out: DecisionArtifact[] = [];
-    for (const item of parsed) {
-      if (typeof item !== "object" || item === null) continue;
-      const it = item as Record<string, unknown>;
-      if (typeof it.question !== "string" || typeof it.choice !== "string") continue;
-      const reversibility =
-        it.reversibility === "easy" || it.reversibility === "moderate" || it.reversibility === "hard"
-          ? it.reversibility
-          : "moderate";
-      out.push({
-        id: shortIdFrom("d", it.question),
-        question: it.question,
-        choice: it.choice,
-        alternatives: Array.isArray(it.alternatives) ? (it.alternatives as unknown[]).map(String) : [],
-        rationale: typeof it.rationale === "string" ? it.rationale : "",
-        reversibility,
-        madeAt: { phase: "scoping" },
-      });
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
-
-export function parseRisksJson(raw: string): RiskArtifact[] {
-  const stripped = raw
-    .trim()
-    .replace(/^```(?:json)?\s*/i, "")
-    .replace(/```\s*$/i, "")
-    .trim();
-  try {
-    const parsed = JSON.parse(stripped);
-    if (!Array.isArray(parsed)) return [];
-    const out: RiskArtifact[] = [];
-    for (const item of parsed) {
-      if (typeof item !== "object" || item === null) continue;
-      const it = item as Record<string, unknown>;
-      if (typeof it.description !== "string") continue;
-      const lk =
-        it.likelihood === "low" || it.likelihood === "medium" || it.likelihood === "high" ? it.likelihood : "medium";
-      const ip = it.impact === "low" || it.impact === "medium" || it.impact === "high" ? it.impact : "medium";
-      out.push({
-        id: shortIdFrom("r", it.description),
-        description: it.description,
-        likelihood: lk,
-        impact: ip,
-        mitigation: typeof it.mitigation === "string" ? it.mitigation : "",
-        owner: typeof it.owner === "string" ? it.owner : "unassigned",
-        status: "open",
-      });
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}