@rsaglobaltech/specgate 0.25.0 → 0.26.0

package/dist/scripts/lib/studio-route.js

@@ -0,0 +1,933 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.profilesView = profilesView;
+exports.currentJob = currentJob;
+exports.stopJob = stopJob;
+exports.isProject = isProject;
+exports.isEmptyFolder = isEmptyFolder;
+exports.route = route;
+exports.presetProfiles = presetProfiles;
+exports.agentsInstalled = agentsInstalled;
+exports.writeProfiles = writeProfiles;
+exports.createProject = createProject;
+exports.briefForm = briefForm;
+exports.saveBriefForm = saveBriefForm;
+exports.saveBriefMarkdown = saveBriefMarkdown;
+exports.fillBrief = fillBrief;
+exports.draftsRoute = draftsRoute;
+exports.startDraft = startDraft;
+exports.report = report;
+exports.reportHtml = reportHtml;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const YamlLite_1 = require("../../packages/core/src/domain/YamlLite");
+const BriefCards_1 = require("../../packages/core/src/domain/BriefCards");
+const DraftChecklist_1 = require("../../packages/core/src/domain/DraftChecklist");
+const HarnessConfigFile_1 = require("../../packages/core/src/infrastructure/HarnessConfigFile");
+const ChangeWorkspace_1 = require("../../packages/core/src/infrastructure/ChangeWorkspace");
+const brief_check_1 = require("../draft/brief-check");
+const brief_setup_1 = require("../draft/brief-setup");
+const DraftCommand_1 = require("../cli/commands/spec/DraftCommand");
+const clarification_1 = require("./clarification");
+const live_detail_1 = require("./live-detail");
+const live_model_1 = require("./live-model");
+const change_review_1 = require("./change-review");
+const studio_app_1 = require("./studio-app");
+const project_root_1 = require("./project-root");
+/**
+ * The studio's route from an empty folder to the report (REQ-211..217). As in
+ * studio-app.ts, every read is what a specgate command reads and every write
+ * runs the command that makes it.
+ */
+const DELIVERED = new Set(["Implemented", "Verified", "Released"]);
+const cli = () => path.join((0, project_root_1.findCliRoot)(__dirname), "bin", "specgate.js");
+const PROFILES = path.join(".harness", "profiles.yaml");
+const JOB = path.join(".harness", "events", "studio-job.json");
+function read(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** The profile harness.config.yaml names with `agent_profile:`, if any. */
+function defaultProfile(projectDir) {
+    const cfg = read(path.join(projectDir, HarnessConfigFile_1.HARNESS_CONFIG_FILE)) || "";
+    const m = /^agent_profile:\s*["']?([^"'\s#]+)/m.exec(cfg);
+    return m ? m[1] : "";
+}
+/** The profiles a person may pick, the default first marked (REQ-211). */
+function profilesView(projectDir) {
+    const text = read(path.join(projectDir, PROFILES));
+    const out = [];
+    if (text) {
+        let doc = {};
+        try {
+            doc = ((0, YamlLite_1.parseYamlLite)(text) || {});
+        }
+        catch {
+            doc = {};
+        }
+        const profiles = (doc.profiles || {});
+        const chosen = defaultProfile(projectDir);
+        for (const [name, p] of Object.entries(profiles)) {
+            if (!p || !p.agent || p.advisory === true)
+                continue;
+            const agent = String(p.agent);
+            const hint = Number(p.cost_per_run_hint);
+            out.push({
+                name,
+                agent,
+                default: name === chosen,
+                costHint: p.cost_per_run_hint !== undefined && Number.isFinite(hint) ? hint : null,
+                streams: /harness\s+events\s+--from\s+claude/.test(agent),
+            });
+        }
+        if (out.length && !out.some((p) => p.default))
+            out[0].default = true;
+    }
+    return out;
+}
+/** The arguments that run an agent: the profile picked, else the configured one. */
+function agentArgs(projectDir, profile) {
+    if (profile) {
+        return profilesView(projectDir).some((p) => p.name === profile) ? ["--profile", profile] : null;
+    }
+    const chosen = profilesView(projectDir).find((p) => p.default);
+    if (chosen)
+        return ["--profile", chosen.name];
+    const cfg = read(path.join(projectDir, HarnessConfigFile_1.HARNESS_CONFIG_FILE)) || "";
+    const m = /^agent:\s*(.+)$/m.exec(cfg);
+    if (!m)
+        return null;
+    const raw = m[1].trim();
+    let agent = raw;
+    if (raw.startsWith('"')) {
+        try {
+            agent = JSON.parse(raw);
+        }
+        catch {
+            agent = raw.slice(1, -1);
+        }
+    }
+    else if (raw.startsWith("'"))
+        agent = raw.slice(1, -1).replace(/''/g, "'");
+    return agent ? ["--agent", agent] : null;
+}
+/** The brief or draft job in progress, if its process is still alive. */
+function currentJob(projectDir) {
+    try {
+        const job = JSON.parse(fs.readFileSync(path.join(projectDir, JOB), "utf8"));
+        return Number.isInteger(job.pid) && job.pid > 0 && alive(job.pid) ? job : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The last job, alive or not: how it ended is in its log. */
+function lastJob(projectDir) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(projectDir, JOB), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function startJob(projectDir, kind, module, profile, args) {
+    const running = currentJob(projectDir);
+    if (running) {
+        return {
+            ok: false,
+            code: "job_running",
+            message: running.kind === "draft"
+                ? `The module ${running.module} is being drafted. Wait for it, or stop it.`
+                : "The agent is working on the brief. Wait for it, or stop it.",
+        };
+    }
+    const dir = path.join(projectDir, ".harness", "events");
+    fs.mkdirSync(dir, { recursive: true });
+    const ignore = path.join(dir, ".gitignore");
+    if (!fs.existsSync(ignore))
+        fs.writeFileSync(ignore, "*\n", "utf8");
+    const log = path.join(dir, `studio-${kind}.log`);
+    fs.writeFileSync(log, "", "utf8");
+    const out = fs.openSync(log, "a");
+    const child = (0, node_child_process_1.spawn)(process.execPath, [cli(), ...args, "--project-dir", projectDir], {
+        cwd: projectDir,
+        detached: true,
+        stdio: ["ignore", out, out],
+        env: {
+            ...process.env,
+            NO_COLOR: "1",
+            // A streaming agent reports what it does; the page shows its last step.
+            AGENT_EVENTS_FILE: path.join(dir, `studio-${kind}.jsonl`),
+        },
+    });
+    child.unref();
+    fs.closeSync(out);
+    const job = {
+        kind,
+        module,
+        profile,
+        pid: child.pid || 0,
+        started: Math.floor(Date.now() / 1000),
+        log: path.relative(projectDir, log).split(path.sep).join("/"),
+    };
+    fs.writeFileSync(path.join(projectDir, JOB), JSON.stringify(job), "utf8");
+    return { ok: true, job };
+}
+/** Stop the brief or draft job in progress, with the processes it started. */
+function stopJob(projectDir) {
+    const job = currentJob(projectDir);
+    if (!job)
+        return { ok: false, code: "job_not_running", message: "Nothing is being drafted." };
+    if (process.platform === "win32") {
+        (0, node_child_process_1.spawnSync)("taskkill", ["/pid", String(job.pid), "/T", "/F"]);
+    }
+    else {
+        try {
+            process.kill(-job.pid, "SIGTERM");
+        }
+        catch {
+            /* already gone */
+        }
+    }
+    return { ok: true };
+}
+/** What the job's agent said last, from its events, for the page. */
+function lastStep(projectDir, kind) {
+    const text = read(path.join(projectDir, ".harness", "events", `studio-${kind}.jsonl`)) || "";
+    const lines = text.trim().split("\n").reverse();
+    for (const l of lines) {
+        try {
+            const e = JSON.parse(l);
+            if (e.type === "tool" && e.summary)
+                return String(e.summary);
+            if (e.type === "message" && e.text)
+                return String(e.text);
+        }
+        catch {
+            /* a line being written */
+        }
+    }
+    return "";
+}
+function isProject(projectDir) {
+    return fs.existsSync(path.join(projectDir, "spec.md"));
+}
+/** A folder with nothing in it but, at most, a git repository. */
+function isEmptyFolder(dir) {
+    try {
+        return fs.readdirSync(dir).filter((f) => f !== ".git").length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** Requirements by id with their status and module, REQ-001 left out as Home does. */
+function requirements(projectDir) {
+    const reqs = new Map();
+    for (const r of (0, live_detail_1.liveMatrix)(projectDir))
+        if (!reqs.has(r.requirement))
+            reqs.set(r.requirement, { status: r.status, group: r.group });
+    reqs.delete("REQ-001");
+    return reqs;
+}
+/** Where the project is on its seven steps, and the next one (REQ-212). */
+function route(projectDir) {
+    const project = path.basename(projectDir);
+    const keys = ["project", "brief", "drafts", "questions", "review", "build", "report"];
+    if (!isProject(projectDir)) {
+        return {
+            project,
+            isProject: false,
+            empty: isEmptyFolder(projectDir),
+            steps: keys.map((key) => ({
+                key,
+                state: key === "project" ? "current" : "locked",
+                counts: {},
+            })),
+            next: "project",
+        };
+    }
+    const states = {};
+    states.project = { state: "done", counts: {} };
+    const briefText = read(path.join(projectDir, DraftCommand_1.DEFAULT_BRIEF));
+    const modules = briefText ? (0, DraftChecklist_1.briefModules)(briefText) : [];
+    const briefOk = Boolean(briefText) && modules.length > 0 && (0, brief_check_1.briefReady)((0, brief_check_1.checkBrief)(briefText, DraftCommand_1.DEFAULT_BRIEF));
+    states.brief = { state: briefOk ? "done" : "open", counts: { modules: modules.length } };
+    const statuses = modules.map((m) => (0, DraftCommand_1.moduleStatus)(projectDir, m, briefText || ""));
+    const drafted = statuses.filter((s) => s.state === "ready" || s.state === "archived").length;
+    const anyDraft = statuses.some((s) => s.state !== "not started") || (0, ChangeWorkspace_1.listChangeIds)(projectDir).length > 0;
+    states.drafts = {
+        state: !briefOk ? "locked" : drafted === modules.length ? "done" : "open",
+        counts: { done: drafted, total: modules.length },
+    };
+    const questions = (0, clarification_1.waiting)(projectDir).questions.length;
+    const reqs = requirements(projectDir);
+    const built = [...reqs.values()].filter((r) => DELIVERED.has(r.status)).length;
+    const started = anyDraft || reqs.size > 0;
+    states.questions = {
+        state: !started ? "locked" : questions ? "open" : "done",
+        counts: { open: questions },
+    };
+    const toReview = (0, studio_app_1.drafts)(projectDir).length;
+    states.review = {
+        state: !started ? "locked" : toReview ? "open" : "done",
+        counts: { open: toReview },
+    };
+    const ready = reqs.size ? (0, studio_app_1.buildView)(projectDir).ready.length : 0;
+    states.build = {
+        state: reqs.size === 0 ? "locked" : ready ? "open" : built ? "done" : "locked",
+        counts: { ready, built, total: reqs.size },
+    };
+    states.report = { state: built ? "open" : "locked", counts: { built, total: reqs.size } };
+    const next = keys.find((k) => states[k].state === "open") || null;
+    return {
+        project,
+        isProject: true,
+        empty: false,
+        steps: keys.map((key) => ({
+            key,
+            state: key === next ? "current" : states[key].state,
+            counts: states[key].counts,
+        })),
+        next,
+    };
+}
+const STACKS = {
+    "node-react": { stack: "Node.js, React", testing: "npm test" },
+    "java-spring": {
+        stack: "Java 21, Spring Boot 3.x, PostgreSQL",
+        testing: "JUnit 5, Testcontainers, Cucumber",
+    },
+    "python-fastapi": { stack: "Python 3.12, FastAPI, PostgreSQL", testing: "pytest" },
+};
+const CLAUDE = (model) => `claude -p --model ${model} --output-format stream-json --verbose --permission-mode acceptEdits < {prompt_file} | specgate harness events --from claude`;
+/** The profiles a preset writes, the first of them the default. */
+function presetProfiles(agent) {
+    if (agent === "claude") {
+        return [
+            { name: "claude-sonnet", agent: CLAUDE("sonnet") },
+            { name: "claude-opus", agent: CLAUDE("opus") },
+        ];
+    }
+    if (agent === "codex")
+        return [{ name: "codex", agent: "codex exec --full-auto - < {prompt_file}" }];
+    return [];
+}
+/** Which agent CLIs this machine has on its PATH. */
+function agentsInstalled() {
+    const has = (cmd) => (0, node_child_process_1.spawnSync)(process.platform === "win32" ? "where" : "which", [cmd], { encoding: "utf8" })
+        .status === 0;
+    return { claude: has("claude"), codex: has("codex") };
+}
+const slugOf = (name) => name
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[̀-ͯ]/g, "")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "") || "project";
+const yamlValue = (v) => JSON.stringify(v);
+/** Write the profiles and point harness.config.yaml at the first. */
+function writeProfiles(projectDir, profiles) {
+    if (profiles.length === 0)
+        return;
+    const file = path.join(projectDir, PROFILES);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const lines = ["profiles_version: 1", "profiles:"];
+    for (const p of profiles)
+        lines.push(`  ${p.name}:`, `    agent: ${yamlValue(p.agent)}`);
+    fs.writeFileSync(file, lines.join("\n") + "\n", "utf8");
+    const cfgFile = path.join(projectDir, HarnessConfigFile_1.HARNESS_CONFIG_FILE);
+    const cfg = read(cfgFile) || "harness_version: 1\n";
+    const line = `agent_profile: ${profiles[0].name}`;
+    const next = /^#?\s*agent_profile:.*$/m.test(cfg)
+        ? cfg.replace(/^#?\s*agent_profile:.*$/m, line)
+        : `${cfg.trimEnd()}\n${line}\n`;
+    fs.writeFileSync(cfgFile, next, "utf8");
+}
+/** Create the project in an empty folder: init, harness, profiles, a brief to fill (REQ-213). */
+function createProject(dir, p) {
+    if (isProject(dir)) {
+        return {
+            ok: false,
+            code: "project_exists",
+            message: "This folder already holds a specgate project.",
+        };
+    }
+    if (!isEmptyFolder(dir)) {
+        return {
+            ok: false,
+            code: "project_folder_not_empty",
+            message: "This folder already holds files. Adopt it from a terminal with `specgate init`, which keeps them.",
+        };
+    }
+    const name = String(p.name || "").trim();
+    if (!name)
+        return { ok: false, code: "project_no_name", message: "Give the project a name." };
+    const preset = p.stack === "custom"
+        ? { stack: String(p.customStack || "").trim(), testing: String(p.customTesting || "").trim() }
+        : STACKS[p.stack];
+    if (!preset || !preset.stack) {
+        return { ok: false, code: "project_no_stack", message: "Choose a stack, or write yours." };
+    }
+    const slug = slugOf(name);
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "specgate-new-"));
+    try {
+        const config = path.join(tmp, "project.yaml");
+        fs.writeFileSync(config, [
+            `PROJECT_NAME: ${yamlValue(name)}`,
+            `PROJECT_SLUG: ${slug}`,
+            `PROJECT_TYPE: ${p.kind === "api" ? "backend" : p.kind === "mobile" ? "mobile" : "frontend"}`,
+            "DOMAIN: general",
+            `STACK: ${yamlValue(preset.stack)}`,
+            "API_STYLE: REST with DTO boundaries",
+            `TESTING: ${yamlValue(preset.testing || "npm test")}`,
+        ].join("\n") + "\n", "utf8");
+        const init = (0, node_child_process_1.spawnSync)(process.execPath, [cli(), "init", "--config", config, "--out", tmp, "--new", "--no-git"], { encoding: "utf8", env: { ...process.env, NO_COLOR: "1" } });
+        const made = path.join(tmp, slug);
+        if (init.status !== 0 || !fs.existsSync(path.join(made, "spec.md"))) {
+            return {
+                ok: false,
+                code: "project_init_failed",
+                message: `specgate init failed: ${(init.stderr || init.stdout || "").trim().split("\n").slice(-3).join(" ")}`,
+            };
+        }
+        fs.cpSync(made, dir, { recursive: true });
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true, maxRetries: 3 });
+    }
+    const run = (args) => (0, node_child_process_1.spawnSync)(process.execPath, [cli(), ...args, "--project-dir", dir], {
+        cwd: dir,
+        encoding: "utf8",
+        env: { ...process.env, NO_COLOR: "1" },
+    });
+    run(["harness", "init"]);
+    writeProfiles(dir, presetProfiles(p.agent));
+    // A brief with nothing to delete: the studio's form fills it, so the
+    // template's examples and blanks would only be in the way.
+    const brief = path.join(dir, DraftCommand_1.DEFAULT_BRIEF);
+    if (!fs.existsSync(brief)) {
+        const surface = p.kind === "api" ? "api" : p.kind === "mobile" ? "mobile" : "web";
+        fs.mkdirSync(path.dirname(brief), { recursive: true });
+        fs.writeFileSync(brief, `---\nproduct: ${name}\nsurfaces: [${surface}]\nactors:\nmodules: []\n---\n\n# ${name}\n`, "utf8");
+    }
+    // The harness needs a clean tree and a first commit to branch from.
+    if (!fs.existsSync(path.join(dir, ".git")))
+        (0, node_child_process_1.spawnSync)("git", ["init", "-q"], { cwd: dir });
+    (0, node_child_process_1.spawnSync)("git", ["add", "-A"], { cwd: dir });
+    (0, node_child_process_1.spawnSync)("git", ["commit", "-q", "-m", "chore: start the project with specgate"], { cwd: dir });
+    return { ok: true, dir };
+}
+function findingsOf(text) {
+    return (0, brief_check_1.checkBrief)(text, DraftCommand_1.DEFAULT_BRIEF).map((d) => ({
+        severity: d.severity,
+        code: d.code,
+        message: d.message,
+        fix: d.fix || "",
+    }));
+}
+/** docs/brief.md read as the form the studio edits (REQ-214). */
+function briefForm(projectDir) {
+    const text = read(path.join(projectDir, DraftCommand_1.DEFAULT_BRIEF));
+    if (text === undefined) {
+        return { exists: false, product: "", actors: [], modules: [], markdown: "", findings: [] };
+    }
+    const fm = (0, brief_setup_1.frontMatter)(text) || "";
+    const product = (/^product:[ \t]*(.*)$/m.exec(fm) || ["", ""])[1]
+        .trim()
+        .replace(/^["']|["']$/g, "");
+    // As written: actorSurfaces lowercases the names it compares.
+    const actors = [...fm.matchAll(/\{\s*name:\s*([^,}]+?)\s*,\s*surfaces:\s*\[([^\]]*)\]/g)]
+        .map((m) => ({
+        name: m[1].replace(/^["']|["']$/g, ""),
+        surfaces: m[2]
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean),
+    }))
+        .filter((a) => !a.name.includes("<"));
+    // A template's `## Module: <first-module>` is a blank, not a module.
+    const sections = new Map((0, BriefCards_1.readBriefBody)(text)
+        .modules.filter((m) => !m.name.startsWith("<"))
+        .map((m) => [(0, BriefCards_1.moduleKey)(m.name), m]));
+    const keys = (0, DraftChecklist_1.briefModules)(text);
+    for (const k of sections.keys())
+        if (!keys.includes(k))
+            keys.push(k);
+    const modules = keys.map((key) => {
+        const s = sections.get(key);
+        return {
+            key,
+            name: s ? s.name : key,
+            prose: s ? s.prose : "",
+            rules: s ? s.rules.map((c) => c.text) : [],
+            examples: s ? s.examples.map((c) => c.text) : [],
+            questions: s ? s.questions.map((c) => c.text) : [],
+        };
+    });
+    return { exists: true, product, actors, modules, markdown: text, findings: findingsOf(text) };
+}
+/** Replace a top-level front matter field and its indented lines, or add it. */
+function setField(fm, name, block) {
+    const lines = fm.split("\n");
+    const at = lines.findIndex((l) => new RegExp(`^${name}:`).test(l));
+    if (at < 0)
+        return `${fm.trimEnd()}\n${block}`;
+    let end = at + 1;
+    while (end < lines.length && /^[ \t]+\S/.test(lines[end]))
+        end += 1;
+    // Comments indented under the field are the author's notes on it: kept.
+    const notes = lines.slice(at + 1, end).filter((l) => /^[ \t]+#/.test(l));
+    const [head, ...rest] = block.split("\n");
+    return [...lines.slice(0, at), head, ...notes, ...rest, ...lines.slice(end)].join("\n");
+}
+function moduleSectionText(form, cards) {
+    const list = (items) => items.map((t) => `- ${t.trim()}`).join("\n");
+    // A card the form left empty is not a card.
+    const filled = (items) => (items || []).filter((t) => String(t).trim());
+    const m = {
+        ...form,
+        prose: form.prose || "",
+        rules: filled(form.rules),
+        examples: filled(form.examples),
+        questions: filled(form.questions),
+    };
+    const parts = [`## Module: ${m.name.trim() || m.key}`];
+    if (m.prose.trim())
+        parts.push(m.prose.trim());
+    if (m.rules.length)
+        parts.push(`${cards.rules}\n\n${list(m.rules)}`);
+    if (m.examples.length)
+        parts.push(`${cards.examples}\n\n${list(m.examples)}`);
+    if (m.questions.length)
+        parts.push(`${cards.questions}\n\n${list(m.questions)}`);
+    return parts.join("\n\n");
+}
+/** The form written back into docs/brief.md, keeping every other line (REQ-214). */
+function saveBriefForm(projectDir, form) {
+    const file = path.join(projectDir, DraftCommand_1.DEFAULT_BRIEF);
+    const text = (read(file) || "").replace(/\r\n/g, "\n");
+    const fmMatch = /^---\n([\s\S]*?)\n---[ \t]*\n?/.exec(text);
+    let fm = fmMatch ? fmMatch[1] : "";
+    let body = fmMatch ? text.slice(fmMatch[0].length) : text;
+    const modules = form.modules.filter((m) => (m.name || m.key).trim());
+    const keys = modules.map((m) => (0, BriefCards_1.moduleKey)(m.key || m.name));
+    const actors = form.actors.filter((a) => a.name.trim());
+    const surfaces = [...new Set(actors.flatMap((a) => a.surfaces))].filter((s) => !s.includes("<"));
+    fm = setField(fm, "product", `product: ${form.product.trim()}`);
+    fm = setField(fm, "surfaces", `surfaces: [${surfaces.join(", ")}]`);
+    fm = setField(fm, "actors", [
+        "actors:",
+        ...actors.map((a) => `  - { name: ${a.name.trim()}, surfaces: [${a.surfaces.join(", ")}] }`),
+    ].join("\n"));
+    fm = setField(fm, "modules", `modules: [${keys.join(", ")}]`);
+    const sections = (0, BriefCards_1.readBriefBody)(text).modules;
+    const spanish = sections.some((s) => /^\s*\**reglas/im.test(s.source));
+    const cards = spanish
+        ? { rules: "Reglas", examples: "Ejemplos", questions: "Preguntas" }
+        : { rules: "Rules", examples: "Examples", questions: "Questions" };
+    const byKey = new Map(sections.map((s) => [(0, BriefCards_1.moduleKey)(s.name), s]));
+    for (const s of sections) {
+        if (!keys.includes((0, BriefCards_1.moduleKey)(s.name)))
+            body = body.replace(s.source, "").replace(/\n{3,}/g, "\n\n");
+    }
+    for (const m of modules) {
+        const key = (0, BriefCards_1.moduleKey)(m.key || m.name);
+        const existing = byKey.get(key);
+        const hasCards = m.rules.length || m.examples.length || m.questions.length || m.prose.trim();
+        if (existing)
+            body = body.replace(existing.source, moduleSectionText(m, cards));
+        else if (hasCards)
+            body = `${body.trimEnd()}\n\n${moduleSectionText(m, cards)}\n`;
+    }
+    const out = `---\n${fm.replace(/^\n+/, "")}\n---\n${body.startsWith("\n") ? "" : "\n"}${body.trimEnd()}\n`;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, out, "utf8");
+    return briefForm(projectDir);
+}
+/** The brief saved as markdown, as written (REQ-214). */
+function saveBriefMarkdown(projectDir, markdown) {
+    const file = path.join(projectDir, DraftCommand_1.DEFAULT_BRIEF);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, String(markdown).replace(/\r\n/g, "\n"), "utf8");
+    return briefForm(projectDir);
+}
+/** A client's text saved as the brief, and the agent asked to structure it (REQ-215). */
+function fillBrief(projectDir, text, profile, replace = false) {
+    const file = path.join(projectDir, DraftCommand_1.DEFAULT_BRIEF);
+    if (fs.existsSync(file) && !replace) {
+        return {
+            ok: false,
+            code: "brief_exists",
+            message: "There is a brief already. Replace it, or edit it in the form.",
+        };
+    }
+    if (!String(text || "").trim()) {
+        return { ok: false, code: "brief_empty", message: "Paste the client's text first." };
+    }
+    const agent = agentArgs(projectDir, profile);
+    if (!agent) {
+        return {
+            ok: false,
+            code: "brief_no_agent",
+            message: "No agent is configured to read the text.",
+        };
+    }
+    if (currentJob(projectDir)) {
+        return {
+            ok: false,
+            code: "job_running",
+            message: "The agent is busy. Wait for it, or stop it.",
+        };
+    }
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, String(text).replace(/\r\n/g, "\n"), "utf8");
+    return startJob(projectDir, "brief", "", agent[1], ["propose", "--from-brief", ...agent]);
+}
+function deltaCounts(projectDir, change) {
+    const dir = path.join(projectDir, "docs", "specs", "changes", change, "specs");
+    let requirements = 0;
+    let scenarios = 0;
+    const walk = (d) => {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = path.join(d, e.name);
+            if (e.isDirectory())
+                walk(full);
+            else if (e.name.endsWith(".md")) {
+                const t = read(full) || "";
+                requirements += (t.match(/^###\s+Requirement:\s*REQ-\d+/gm) || []).length;
+                scenarios += (t.match(/^####\s+Scenario:\s*SCN-/gm) || []).length;
+            }
+        }
+    };
+    walk(dir);
+    return { requirements, scenarios };
+}
+/** Each module of the brief with where it stands, and the job drafting one (REQ-216). */
+function draftsRoute(projectDir) {
+    const briefText = read(path.join(projectDir, DraftCommand_1.DEFAULT_BRIEF));
+    const job = currentJob(projectDir);
+    const ended = job ? null : lastJob(projectDir);
+    const step = job ? lastStep(projectDir, job.kind) : "";
+    if (!briefText)
+        return { brief: false, modules: [], job, step, lastJob: null };
+    const open = (0, clarification_1.waiting)(projectDir).questions;
+    // An archived draft's requirements live in the specification now, by module.
+    const delivered = new Map();
+    for (const r of (0, live_detail_1.liveMatrix)(projectDir)) {
+        if (r.source !== "spec")
+            continue;
+        const g = delivered.get(r.group) || { requirements: new Set(), scenarios: 0 };
+        g.requirements.add(r.requirement);
+        g.scenarios += r.scenario ? 1 : 0;
+        delivered.set(r.group, g);
+    }
+    const modules = (0, DraftChecklist_1.briefModules)(briefText).map((key) => {
+        const s = (0, DraftCommand_1.moduleStatus)(projectDir, key, briefText);
+        const inSpec = delivered.get(key);
+        const counts = s.state === "archived" && inSpec
+            ? { requirements: inSpec.requirements.size, scenarios: inSpec.scenarios }
+            : deltaCounts(projectDir, s.change);
+        const questions = open.filter((q) => q.change === s.change).length;
+        const drafting = job && job.kind === "draft" && job.module === key;
+        let findings = [];
+        if (s.state === "drafting" || s.state === "ready") {
+            const r = (0, DraftCommand_1.draftReport)(projectDir, s.change, briefText);
+            if (!("failure" in r)) {
+                findings = r.report.status.map((d) => ({
+                    severity: d.severity,
+                    code: d.code,
+                    message: d.message,
+                }));
+            }
+        }
+        const stage = drafting
+            ? "drafting"
+            : s.state === "archived"
+                ? "archived"
+                : s.state === "not started" || (s.state === "not written" && counts.requirements === 0)
+                    ? s.state === "not written" && ended && ended.kind === "draft" && ended.module === key
+                        ? "stopped"
+                        : "todo"
+                    : (0, change_review_1.approvedOn)(projectDir, s.change)
+                        ? "approved"
+                        : "review";
+        return {
+            key,
+            stage,
+            ...counts,
+            questions,
+            findings,
+            progress: drafting
+                ? {
+                    seconds: Math.floor(Date.now() / 1000) - job.started,
+                    ...counts,
+                    notes: fs.existsSync(path.join(projectDir, "docs", "specs", "changes", s.change, "questions.md")) ||
+                        fs.existsSync(path.join(projectDir, "docs", "specs", "changes", s.change, "assumptions.md")),
+                    lastStep: lastStep(projectDir, "draft"),
+                }
+                : null,
+        };
+    });
+    const tail = ended
+        ? (read(path.join(projectDir, ended.log)) || "").trim().split("\n").slice(-4).join("\n")
+        : "";
+    return {
+        brief: true,
+        modules,
+        job,
+        step,
+        lastJob: ended ? { kind: ended.kind, module: ended.module, log: ended.log, tail } : null,
+    };
+}
+/** Draft a module with the agent picked, in the background (REQ-216). */
+function startDraft(projectDir, module, profile) {
+    const briefText = read(path.join(projectDir, DraftCommand_1.DEFAULT_BRIEF));
+    if (!briefText || !(0, DraftChecklist_1.briefModules)(briefText).includes(module)) {
+        return {
+            ok: false,
+            code: "draft_unknown_module",
+            message: `The brief has no module ${module}.`,
+        };
+    }
+    const agent = agentArgs(projectDir, profile);
+    if (!agent) {
+        return {
+            ok: false,
+            code: "draft_no_agent",
+            message: profile
+                ? `No profile ${profile} in .harness/profiles.yaml.`
+                : "No agent is configured.",
+        };
+    }
+    return startJob(projectDir, "draft", module, agent[0] === "--profile" ? agent[1] : "", [
+        "propose",
+        "--from-brief",
+        module,
+        ...agent,
+    ]);
+}
+/** Every scenario's title, by id, from the specification's files. */
+function scenarioTitles(projectDir) {
+    const titles = new Map();
+    const files = [path.join(projectDir, "spec.md")];
+    const walk = (d) => {
+        let entries = [];
+        try {
+            entries = fs.readdirSync(d, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = path.join(d, e.name);
+            if (e.isDirectory())
+                walk(full);
+            else if (e.name.endsWith(".md"))
+                files.push(full);
+        }
+    };
+    walk(path.join(projectDir, "docs", "specs"));
+    for (const f of files) {
+        for (const m of (read(f) || "").matchAll(/^#{3,5}\s+Scenario:\s*(SCN-[\w.]+)\s*[—–-]+\s*(.+)$/gm)) {
+            if (!titles.has(m[1]))
+                titles.set(m[1], m[2].trim());
+        }
+    }
+    return titles;
+}
+/** What was built, how it was proven, and what is missing (REQ-217). */
+function report(projectDir, withGate = true) {
+    const matrix = (0, live_detail_1.liveMatrix)(projectDir).filter((r) => r.requirement !== "REQ-001");
+    const titles = scenarioTitles(projectDir);
+    const byReq = new Map();
+    for (const r of matrix) {
+        const e = byReq.get(r.requirement) || {
+            title: r.title,
+            group: r.group,
+            status: r.status,
+            scenarios: [],
+        };
+        if (r.scenario && !e.scenarios.includes(r.scenario))
+            e.scenarios.push(r.scenario);
+        byReq.set(r.requirement, e);
+    }
+    const questions = (0, clarification_1.allQuestions)(projectDir);
+    const holding = new Map();
+    for (const q of questions.filter((q) => !q.answered))
+        for (const b of q.blocks)
+            holding.set(b, q.text);
+    const delivered = [];
+    const missing = [];
+    const modules = new Map();
+    for (const [id, r] of byReq) {
+        const name = r.group || "spec";
+        const m = modules.get(name) || { name, built: 0, total: 0, waiting: 0, scenarios: 0 };
+        m.total += 1;
+        if (DELIVERED.has(r.status)) {
+            m.built += 1;
+            m.scenarios += r.scenarios.length;
+            delivered.push({
+                id,
+                title: r.title,
+                module: name,
+                scenarios: r.scenarios.map((s) => ({ id: s, title: titles.get(s) || "" })),
+            });
+        }
+        else {
+            const waitingFor = r.status === "Needs Clarification" || holding.has(id);
+            if (waitingFor)
+                m.waiting += 1;
+            missing.push({
+                id,
+                title: r.title,
+                module: name,
+                why: waitingFor ? "waiting" : "not built",
+                question: holding.get(id) || "",
+            });
+        }
+        modules.set(name, m);
+    }
+    let minutes = 0;
+    const runs = path.join(projectDir, ".harness", "runs");
+    let files = [];
+    try {
+        files = fs.readdirSync(runs).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        /* no runs */
+    }
+    for (const f of files) {
+        try {
+            const doc = JSON.parse(fs.readFileSync(path.join(runs, f), "utf8"));
+            for (const r of doc.results || [])
+                minutes += Number(r.durationMs) > 0 ? Number(r.durationMs) / 60000 : 0;
+        }
+        catch {
+            /* a record being written */
+        }
+    }
+    const costs = (0, live_model_1.readLive)(projectDir)
+        .requirements.map((r) => (r.usage && r.usage.cost !== null ? r.usage.cost : null))
+        .filter((c) => c !== null);
+    let assumptions = 0;
+    const countRows = (file) => ((read(file) || "").match(/^\|\s*A\d+\s*\|/gm) || []).length;
+    assumptions += countRows(path.join(projectDir, "docs", "specs", "assumptions.md"));
+    for (const id of (0, ChangeWorkspace_1.listArchivedIds)(projectDir)) {
+        assumptions += countRows(path.join(projectDir, "docs", "specs", "changes", "archive", id, "assumptions.md"));
+    }
+    return {
+        project: path.basename(projectDir),
+        date: new Date().toISOString().slice(0, 10),
+        built: delivered.length,
+        total: byReq.size,
+        scenarios: delivered.reduce((n, d) => n + d.scenarios.length, 0),
+        gate: withGate ? (0, studio_app_1.gate)(projectDir) : { ok: true, findings: [] },
+        cost: costs.length ? Math.round(costs.reduce((a, b) => a + b, 0) * 100) / 100 : null,
+        minutes: Math.round(minutes),
+        modules: [...modules.values()].sort((a, b) => a.name.localeCompare(b.name)),
+        delivered,
+        missing,
+        answered: questions.filter((q) => q.answered).length,
+        assumptions,
+    };
+}
+const esc = (s) => String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+/** The report as one HTML page that opens on its own (REQ-217). */
+function reportHtml(r) {
+    const rows = r.modules
+        .map((m) => `<tr><td>${esc(m.name)}</td><td>${m.built} / ${m.total}</td><td>${m.scenarios}</td><td>${m.waiting ? `${m.waiting} waiting` : m.built === m.total ? "complete" : ""}</td></tr>`)
+        .join("");
+    const delivered = r.delivered
+        .map((d) => `<li><strong>${esc(d.id)} — ${esc(d.title)}</strong> <span class="m">${esc(d.module)}</span><ul>${d.scenarios
+        .map((s) => `<li>${esc(s.id)} ${esc(s.title)}</li>`)
+        .join("")}</ul></li>`)
+        .join("");
+    const missing = r.missing
+        .map((m) => `<li>${esc(m.id)} — ${esc(m.title)} <span class="m">${esc(m.module)} · ${m.why === "waiting" ? `waiting: ${esc(m.question)}` : "not built"}</span></li>`)
+        .join("");
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(r.project)} — report</title>
+<style>
+body{margin:0;background:#f6f8fa;color:#1f2328;font:14px/1.5 -apple-system,"Segoe UI","Noto Sans",Helvetica,Arial,sans-serif}
+main{max-width:960px;margin:0 auto;padding:28px 16px}
+h1{font-size:26px;margin:0 0 4px}h2{font-size:16px;margin:0 0 10px}
+.k{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin:20px 0}
+.c,section{background:#fff;border:1px solid #d1d9e0;border-radius:8px;padding:16px 18px;margin-bottom:16px}
+.c b{display:block;font-size:24px}.m{color:#59636e;font-size:13px}
+table{width:100%;border-collapse:collapse}td,th{text-align:left;padding:8px;border-top:1px solid #d1d9e0}
+ul{padding-left:18px}
+</style></head><body><main>
+<p class="m">${esc(r.date)}</p>
+<h1>${esc(r.project)}</h1>
+<p class="m">Built from the specification and its tests with specgate.</p>
+<div class="k">
+<div class="c">Built<b>${r.built} / ${r.total}</b></div>
+<div class="c">Examples proven<b>${r.scenarios}</b></div>
+<div class="c">Gate<b>${r.gate.ok ? "passes" : "fails"}</b></div>
+<div class="c">Agent<b>${r.cost === null ? "—" : `$${r.cost.toFixed(2)}`}</b><span class="m">${r.minutes} min</span></div>
+</div>
+<section><h2>By module</h2><table><tr><th>Module</th><th>Built</th><th>Examples</th><th></th></tr>${rows}</table></section>
+<section><h2>What the app does</h2><ul>${delivered || "<li>Nothing built yet.</li>"}</ul></section>
+<section><h2>What is missing</h2><ul>${missing || "<li>Nothing.</li>"}</ul></section>
+<section><h2>Decisions</h2><p>${r.answered} questions answered · ${r.assumptions} assumptions recorded.</p></section>
+</main></body></html>
+`;
+}
+//# sourceMappingURL=studio-route.js.map