muonroi-cli 1.8.4 → 1.8.5

package/dist/src/flow/run-artifacts.js

@@ -0,0 +1,208 @@
+/**
+ * First-class run artifacts for the Product Ideal Loop.
+ *
+ * Sprint-2 MVP (Part A core, run-centric — hierarchy deferred per REV-3 Kill B):
+ * promotes the debate research summary and the prior-run context out of buried
+ * `delegations.md` sections into dedicated `research.md` / `context.md` files,
+ * gives the Resume Digest structured, parseable content (the empty digest was
+ * the root cause of "resume blindness"), and persists per-sprint outcome JSON so
+ * `/ideal review` and cross-run memory can render real history.
+ *
+ * All artifacts live under `.muonroi-flow/runs/<runId>/`. Writes are atomic.
+ * Reads are tolerant: a missing file returns null, never throws.
+ */
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import { atomicWriteJSON, atomicWriteText } from "../storage/atomic-io.js";
+const DIGEST_FIELD = {
+    stage: "Stage",
+    lastCompleted: "Last completed",
+    nextAction: "Next action",
+    sprintN: "Sprint",
+    score: "Score",
+    verify: "Verify",
+    updatedAt: "Updated",
+};
+/**
+ * Render a ResumeDigest as markdown for the `## Resume Digest` section body.
+ * Deterministic field order so diffs stay minimal.
+ */
+export function renderResumeDigest(d) {
+    const lines = [];
+    lines.push(`- ${DIGEST_FIELD.stage}: ${d.stage}`);
+    if (d.lastCompleted)
+        lines.push(`- ${DIGEST_FIELD.lastCompleted}: ${d.lastCompleted}`);
+    lines.push(`- ${DIGEST_FIELD.nextAction}: ${d.nextAction}`);
+    if (typeof d.sprintN === "number")
+        lines.push(`- ${DIGEST_FIELD.sprintN}: ${d.sprintN}`);
+    if (typeof d.score === "number")
+        lines.push(`- ${DIGEST_FIELD.score}: ${d.score.toFixed(2)}`);
+    if (d.verify)
+        lines.push(`- ${DIGEST_FIELD.verify}: ${d.verify}`);
+    if (d.updatedAt)
+        lines.push(`- ${DIGEST_FIELD.updatedAt}: ${d.updatedAt}`);
+    if (d.openQuestions && d.openQuestions.length > 0) {
+        lines.push("");
+        lines.push("### Open questions");
+        for (const q of d.openQuestions)
+            lines.push(`- ${q}`);
+    }
+    if (d.eeSnapshot?.trim()) {
+        lines.push("");
+        lines.push("### Experience snapshot");
+        lines.push(d.eeSnapshot.trim());
+    }
+    return lines.join("\n");
+}
+/**
+ * Parse a `## Resume Digest` section body back into a ResumeDigest. Tolerant:
+ * returns null when the body has no recognizable `Stage:` line (e.g. the old
+ * empty digest or a legacy one-line string).
+ */
+export function parseResumeDigest(body) {
+    if (!body?.trim())
+        return null;
+    const lines = body.split("\n");
+    const kv = new Map();
+    const openQuestions = [];
+    let section = "root";
+    const eeLines = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (/^###\s+open questions/i.test(line)) {
+            section = "questions";
+            continue;
+        }
+        if (/^###\s+experience snapshot/i.test(line)) {
+            section = "ee";
+            continue;
+        }
+        if (section === "ee") {
+            eeLines.push(raw);
+            continue;
+        }
+        const m = line.match(/^-\s+([^:]+):\s*(.*)$/);
+        if (m && section === "root") {
+            kv.set(m[1].trim().toLowerCase(), m[2].trim());
+            continue;
+        }
+        if (section === "questions") {
+            const q = line.match(/^-\s+(.*)$/);
+            if (q?.[1]?.trim())
+                openQuestions.push(q[1].trim());
+        }
+    }
+    const stage = kv.get("stage");
+    if (!stage)
+        return null;
+    const num = (v) => {
+        if (v === undefined)
+            return undefined;
+        const n = Number.parseFloat(v);
+        return Number.isFinite(n) ? n : undefined;
+    };
+    return {
+        stage,
+        lastCompleted: kv.get("last completed") || undefined,
+        nextAction: kv.get("next action") ?? "",
+        sprintN: num(kv.get("sprint")),
+        score: num(kv.get("score")),
+        verify: kv.get("verify") || undefined,
+        openQuestions: openQuestions.length > 0 ? openQuestions : undefined,
+        eeSnapshot: eeLines.join("\n").trim() || undefined,
+        updatedAt: kv.get("updated") || undefined,
+    };
+}
+function runDirOf(flowDir, runId) {
+    return path.join(flowDir, "runs", runId);
+}
+/**
+ * Write `research.md` — the first-class home for the debate output. Previously
+ * this lived only in `delegations.md` sections; callers still write those for
+ * back-compat, but `research.md` is now the canonical, reviewable surface.
+ */
+export async function writeResearchDoc(flowDir, runId, doc) {
+    const parts = ["# Research\n"];
+    if (doc.eeSeed?.trim()) {
+        parts.push("## Experience seed (EE recall)\n");
+        parts.push(`${doc.eeSeed.trim()}\n`);
+    }
+    if (doc.webResearch) {
+        const line = doc.webResearch.confidence === "native"
+            ? `native — web-capable model${doc.webResearch.model ? ` (${doc.webResearch.model})` : ""}`
+            : "degraded — no native web model reachable; online facts via add-in fallback";
+        parts.push(`## Research Confidence: ${line}\n`);
+    }
+    parts.push("## Debate summary\n");
+    parts.push(`${doc.summary?.trim() || "(no summary produced)"}\n`);
+    if (doc.findings?.trim()) {
+        parts.push("## Findings\n");
+        parts.push(`${doc.findings.trim()}\n`);
+    }
+    await atomicWriteText(path.join(runDirOf(flowDir, runId), "research.md"), parts.join("\n"));
+}
+/**
+ * Write `context.md` — the prior-run digest + project context carried into a
+ * run. Prior context was previously computed then discarded (loop-driver noted
+ * it was dropped from the system prompt); persisting it here makes it a
+ * reviewable, resumable surface without re-bloating the live prompt.
+ */
+export async function writeContextDoc(flowDir, runId, content) {
+    const body = content?.trim() ? content.trim() : "(no prior context)";
+    await atomicWriteText(path.join(runDirOf(flowDir, runId), "context.md"), `# Context\n\n${body}\n`);
+}
+/** Read a whole-file run doc (research.md / context.md). Null when absent. */
+export async function readRunDoc(flowDir, runId, filename) {
+    try {
+        return await fs.readFile(path.join(runDirOf(flowDir, runId), filename), "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+/** Absolute path to a run's `sprints/` directory. */
+export function sprintsDir(flowDir, runId) {
+    return path.join(runDirOf(flowDir, runId), "sprints");
+}
+/** Persist a per-sprint outcome record as `sprints/<n>-outcome.json`. */
+export async function writeSprintOutcome(flowDir, runId, outcome) {
+    const dir = sprintsDir(flowDir, runId);
+    await fs.mkdir(dir, { recursive: true });
+    await atomicWriteJSON(path.join(dir, `${outcome.sprintN}-outcome.json`), outcome);
+}
+/** Persist a per-sprint verify report as `sprints/<n>-verify.md`. */
+export async function writeSprintVerify(flowDir, runId, sprintN, markdown) {
+    const dir = sprintsDir(flowDir, runId);
+    await fs.mkdir(dir, { recursive: true });
+    await atomicWriteText(path.join(dir, `${sprintN}-verify.md`), markdown);
+}
+/** Read all sprint outcomes for a run, sorted by sprint number ascending. */
+export async function readSprintOutcomes(flowDir, runId) {
+    const dir = sprintsDir(flowDir, runId);
+    let files;
+    try {
+        files = await fs.readdir(dir);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    const outcomes = [];
+    for (const f of files) {
+        if (!/^\d+-outcome\.json$/.test(f))
+            continue;
+        try {
+            const raw = await fs.readFile(path.join(dir, f), "utf8");
+            outcomes.push(JSON.parse(raw));
+        }
+        catch {
+            /* skip malformed outcome files — never throw on a corrupt artifact */
+        }
+    }
+    outcomes.sort((a, b) => a.sprintN - b.sprintN);
+    return outcomes;
+}
+//# sourceMappingURL=run-artifacts.js.map

package/dist/src/generated/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.8.4";
+export declare const PACKAGE_VERSION = "1.8.5";
 export declare const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";

package/dist/src/generated/version.js

@@ -1,5 +1,5 @@
 // AUTO-GENERATED by scripts/sync-version.cjs. DO NOT EDIT BY HAND.
 // Sourced from package.json at build time so it survives bun --compile bundling.
-export const PACKAGE_VERSION = "1.8.4";
+export const PACKAGE_VERSION = "1.8.5";
 export const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";
 //# sourceMappingURL=version.js.map

package/dist/src/gsd/assessment-schema.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Complexity-assessment verdict protocol for the GSD native complexity
+ * assessor pipeline.
+ *
+ * Mirrors `verdict-schema.ts` (plan-council verdict protocol): the decision
+ * is owned by the model and emitted as structured JSON; our code only
+ * parses + validates. `verdict-schema.ts` does not export its fence/brace
+ * helpers, so this module stays self-contained with the same algorithm
+ * under the `complexity-verdict` label (see task-3 brief DRY note).
+ *
+ * Extraction strategy (in priority order):
+ *   1. Last fenced block labeled ```complexity-verdict``` (preferred shape).
+ *   2. Last fenced block labeled ```json``` that validates.
+ *   3. Last fenced block (any / no label) that validates.
+ *   4. Last brace-balanced {...} substring that validates.
+ *   5. null — caller decides conservative fallback.
+ */
+import { z } from "zod";
+export declare const ComplexityVerdictSchema: z.ZodObject<{
+    depth: z.ZodEnum<{
+        quick: "quick";
+        standard: "standard";
+        heavy: "heavy";
+    }>;
+    autoCouncil: z.ZodCatch<z.ZodBoolean>;
+    rationale: z.ZodCatch<z.ZodString>;
+    quality: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        verdict: z.ZodEnum<{
+            enriched: "enriched";
+            adequate: "adequate";
+            "needs-user": "needs-user";
+        }>;
+        missing: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        noiseRisk: z.ZodDefault<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            med: "med";
+        }>>;
+    }, z.core.$strip>>>;
+    enrichedPrompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ComplexityVerdict = z.infer<typeof ComplexityVerdictSchema>;
+export declare function extractComplexityVerdict(raw: string): ComplexityVerdict | null;
+export declare const ASSESSMENT_OUTPUT_CONTRACT: string;

package/dist/src/gsd/assessment-schema.js

@@ -0,0 +1,134 @@
+/**
+ * Complexity-assessment verdict protocol for the GSD native complexity
+ * assessor pipeline.
+ *
+ * Mirrors `verdict-schema.ts` (plan-council verdict protocol): the decision
+ * is owned by the model and emitted as structured JSON; our code only
+ * parses + validates. `verdict-schema.ts` does not export its fence/brace
+ * helpers, so this module stays self-contained with the same algorithm
+ * under the `complexity-verdict` label (see task-3 brief DRY note).
+ *
+ * Extraction strategy (in priority order):
+ *   1. Last fenced block labeled ```complexity-verdict``` (preferred shape).
+ *   2. Last fenced block labeled ```json``` that validates.
+ *   3. Last fenced block (any / no label) that validates.
+ *   4. Last brace-balanced {...} substring that validates.
+ *   5. null — caller decides conservative fallback.
+ */
+import { z } from "zod";
+export const ComplexityVerdictSchema = z.object({
+    depth: z.enum(["quick", "standard", "heavy"]),
+    autoCouncil: z.boolean().catch(false),
+    rationale: z.string().catch(""),
+    quality: z
+        .object({
+        verdict: z.enum(["adequate", "enriched", "needs-user"]),
+        missing: z.array(z.string()).default([]),
+        noiseRisk: z.enum(["low", "med", "high"]).default("low"),
+    })
+        .optional()
+        .catch(undefined),
+    enrichedPrompt: z.string().optional(),
+});
+// Extraction mirrors verdict-schema.ts: prefer the LAST fenced `complexity-verdict`
+// block, then json, then bare {...}. Model emits reasoning first, verdict last.
+const FENCE_RE = /```([a-zA-Z0-9_+-]+)?\s*\n([\s\S]*?)\n?```/g;
+function tryParse(s) {
+    try {
+        const r = ComplexityVerdictSchema.safeParse(JSON.parse(s.trim()));
+        return r.success ? r.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function extractComplexityVerdict(raw) {
+    if (!raw?.trim())
+        return null;
+    const fences = [];
+    for (const m of raw.matchAll(FENCE_RE))
+        fences.push({ label: (m[1] ?? "").toLowerCase(), body: m[2] ?? "" });
+    const buckets = [
+        fences.filter((f) => f.label === "complexity-verdict"),
+        fences.filter((f) => f.label === "json"),
+        fences.filter((f) => f.label !== "complexity-verdict" && f.label !== "json"),
+    ];
+    for (const bucket of buckets) {
+        for (let i = bucket.length - 1; i >= 0; i -= 1) {
+            const v = tryParse(bucket[i].body);
+            if (v)
+                return v;
+        }
+    }
+    // Bare {...} right-to-left, string-aware (skip braces inside quoted values —
+    // free-form `rationale` text may contain literal `{`/`}`).
+    const bare = findBareObjects(raw);
+    for (let i = bare.length - 1; i >= 0; i -= 1) {
+        const v = tryParse(bare[i]);
+        if (v)
+            return v;
+    }
+    return null;
+}
+/** Top-level {...} substrings via string-aware brace-balanced scan, in document order. */
+function findBareObjects(raw) {
+    const out = [];
+    let i = 0;
+    while (i < raw.length) {
+        if (raw[i] !== "{") {
+            i += 1;
+            continue;
+        }
+        let depth = 0;
+        let inStr = false;
+        let esc = false;
+        let j = i;
+        for (; j < raw.length; j += 1) {
+            const ch = raw[j];
+            if (inStr) {
+                if (esc)
+                    esc = false;
+                else if (ch === "\\")
+                    esc = true;
+                else if (ch === '"')
+                    inStr = false;
+            }
+            else if (ch === '"') {
+                inStr = true;
+            }
+            else if (ch === "{") {
+                depth += 1;
+            }
+            else if (ch === "}") {
+                depth -= 1;
+                if (depth === 0) {
+                    out.push(raw.slice(i, j + 1));
+                    break;
+                }
+            }
+        }
+        i = j >= raw.length ? j : j + 1;
+    }
+    return out;
+}
+export const ASSESSMENT_OUTPUT_CONTRACT = [
+    "",
+    "Emit your final decision as a fenced block in EXACTLY this shape — no prose inside the fence:",
+    "```complexity-verdict",
+    '{"depth":"quick|standard|heavy","autoCouncil":true|false,"rationale":"one short sentence","quality":{"verdict":"adequate|enriched|needs-user","missing":["intent"|"target"|"scope"|"acceptance"],"noiseRisk":"low|med|high"},"enrichedPrompt":"the enriched brief, or empty string when adequate"}',
+    "```",
+    '- "quick"    = trivial single-shot (typo, rename, read-and-explain). No plan/review needed.',
+    '- "standard" = ordinary feature/bugfix. Short plan → review → implement → verify.',
+    '- "heavy"    = architectural / multi-file / wide / ambiguous. Full discuss → plan → plan-review → verify.',
+    "- autoCouncil = true only when the task benefits from multi-perspective debate before implementation.",
+    "",
+    'Prompt-quality rubric — a prompt is "adequate" when these BLOCKERS are present or confidently derivable WITHOUT padding: (1) Intent/Outcome, (2) Target/Locus, (3) Scope boundary, (4) Acceptance.',
+    "Enrichment rules (SIGNAL over noise):",
+    '- Every added line MUST change what the coding agent does; if it does not, omit it. Over-enrichment is a FAILURE — set noiseRisk="high" and cut.',
+    '- NEVER assert a file path as fact. Any area reference is an UNVERIFIED HINT: write "likely area: <dir> (confirm via grep before anchoring)". You cannot see the codebase.',
+    '- verdict="adequate" -> enrichedPrompt="" (use the raw prompt).',
+    '- verdict="enriched" -> a brief that fills derivable gaps + hedged hints only.',
+    '- verdict="needs-user" -> a blocker is NOT derivable from context; keep the brief minimal and list the open question(s) under "OPEN QUESTIONS:".',
+    "Keep enrichedPrompt under 1500 characters.",
+].join("\n");
+//# sourceMappingURL=assessment-schema.js.map

package/dist/src/gsd/capability-registry.d.ts

@@ -0,0 +1,45 @@
+/**
+ * capability-registry.ts — Native vendored byLoopPoint data from gsd-core
+ *
+ * ADR-894 §5 — role-partitioned Capability Registry.
+ * Contains the byLoopPoint data used by the loop resolver.
+ * This is the frozen first-party registry used as the fallback default.
+ */
+export interface LoopHook {
+    capId: string;
+    kind: "step" | "contribution" | "gate";
+    point?: string;
+    ref?: Record<string, unknown>;
+    fragment?: {
+        path?: string;
+        inline?: string;
+    };
+    when?: string;
+    onError?: string;
+    produces?: string[];
+    consumes?: string[];
+    into?: string;
+    check?: unknown;
+    blocking?: boolean;
+    configValues?: Record<string, unknown>;
+}
+export interface LoopPointEntry {
+    steps: LoopHook[];
+    contributions: LoopHook[];
+    gates: LoopHook[];
+}
+export interface CapabilityRegistry {
+    byLoopPoint: Record<string, LoopPointEntry>;
+}
+export declare const REGISTRY: CapabilityRegistry;
+/**
+ * debate:error — stubbed per Test-First Registry Specialist's strengthening.
+ * Handler is unwired in sprint 1. Drop recovery deferred to sprint 2.
+ * The fixture is assertable so the registry contract test catches both
+ * wrong-model dispatch AND missing error channel.
+ */
+export declare const debateErrorStub: {
+    kind: "debate:error";
+    onError: "halt";
+    blocking: true;
+};