@esneiderbravo/speclaw 0.3.11 → 0.3.13

package/dist/modules/lawbook/bugfix.js

@@ -0,0 +1,195 @@
+import fs from "node:fs";
+import path from "node:path";
+import { gatherSignals, loadCeremonyConfig, proposeLevel, setCeremonyLevel, writeCeremonyRecord, } from "./levels.js";
+export const BUGFIX_HEADINGS = [
+    "1. Observed symptom",
+    "2. Minimal reproduction",
+    "3. Root cause",
+    "4. Blast radius",
+    "5. Proposed fix",
+    "6. Regression test",
+    "7. Prevention",
+];
+/** Parsed section bodies keyed by heading label. */
+export function parseBugfixSections(content) {
+    const out = new Map();
+    for (const part of content.split(/^##\s+/m).slice(1)) {
+        const nl = part.indexOf("\n");
+        if (nl < 0) {
+            out.set(part.trim(), "");
+            continue;
+        }
+        out.set(part.slice(0, nl).trim(), part.slice(nl + 1).trim());
+    }
+    return out;
+}
+function sectionBody(sections, key) {
+    for (const [h, b] of sections) {
+        if (h.toLowerCase().startsWith(key.toLowerCase()))
+            return b;
+    }
+    return "";
+}
+function isFilled(body) {
+    const t = body.trim();
+    if (!t)
+        return false;
+    if (/^n\/a\s*:/i.test(t))
+        return true;
+    return t.length > 2;
+}
+/** True when prevention says a canonical requirement was missing. */
+export function preventionRequiresDelta(content) {
+    const prev = sectionBody(parseBugfixSections(content), "7. Prevention");
+    if (!prev)
+        return false;
+    return (/\b(requirement|spec)\b.*\b(miss|missing|absent|incomplete|add|update)\b/i.test(prev) ||
+        /\bfaltaba\b/i.test(prev) ||
+        /\bmissing requirement\b/i.test(prev));
+}
+/** Infer archive resolution from bugfix.md content. */
+export function inferBugResolution(content) {
+    if (/\bnot-a-bug\b/i.test(content) || /resolution:\s*not-a-bug/i.test(content)) {
+        return "not-a-bug";
+    }
+    const repro = sectionBody(parseBugfixSections(content), "2. Minimal reproduction");
+    if (/unreproducible\s*:/i.test(repro))
+        return "mitigated";
+    return "fixed";
+}
+/**
+ * Validate bugfix.md sections for a ceremony level.
+ *
+ * @returns Human-readable issues (empty when valid).
+ */
+export function validateBugfixContent(level, content) {
+    const issues = [];
+    const sections = parseBugfixSections(content);
+    for (const h of BUGFIX_HEADINGS) {
+        if (!sections.has(h) && ![...sections.keys()].some((k) => k.startsWith(h.split(".")[0]))) {
+            issues.push(`bugfix.md missing heading "## ${h}"`);
+        }
+    }
+    const repro = sectionBody(sections, "2. Minimal reproduction");
+    if (!isFilled(repro) && !/unreproducible\s*:/i.test(repro)) {
+        issues.push("bugfix.md §2 requires reproduction steps or an `unreproducible:` block");
+    }
+    const requiredAt0 = [
+        "1. Observed symptom",
+        "2. Minimal reproduction",
+        "3. Root cause",
+        "5. Proposed fix",
+        "6. Regression test",
+    ];
+    const optionalAt0 = ["4. Blast radius", "7. Prevention"];
+    const allRequired = level >= 1 ? [...BUGFIX_HEADINGS] : requiredAt0;
+    for (const key of allRequired) {
+        const body = sectionBody(sections, key);
+        if (!isFilled(body) && !/unreproducible\s*:/i.test(body)) {
+            issues.push(`bugfix.md §${key.split(".")[0]} (${key}) is empty`);
+        }
+    }
+    if (level === 0) {
+        for (const key of optionalAt0) {
+            const body = sectionBody(sections, key);
+            if (body && !isFilled(body) && !/^n\/a\s*:/i.test(body)) {
+                issues.push(`bugfix.md §${key.split(".")[0]} must be filled or start with \`n/a:\``);
+            }
+        }
+    }
+    const prevention = sectionBody(sections, "7. Prevention");
+    const resolution = inferBugResolution(content);
+    if (resolution === "not-a-bug" && !isFilled(prevention)) {
+        issues.push("not-a-bug resolution requires a prevention entry (usually a spec clarity fix)");
+    }
+    else if (level >= 1 && !isFilled(prevention)) {
+        issues.push("bugfix.md §7 Prevention must be answered (law, spec gap, or explicit none with reason)");
+    }
+    const regression = sectionBody(sections, "6. Regression test");
+    const mitigated = /unreproducible\s*:/i.test(repro);
+    if (!mitigated && !isFilled(regression)) {
+        issues.push("bugfix.md §6 Regression test is required unless reproduction is unreproducible");
+    }
+    if (mitigated && !isFilled(regression) && !/\binstrument/i.test(content)) {
+        issues.push("unreproducible bugs require instrumentation (§6 or explicit instrumentation reference)");
+    }
+    return issues;
+}
+function bugfixTemplate(name, level, seed) {
+    const symptom = seed?.inputSymptom ??
+        "<What you see: error message, wrong value, screenshot reference. Do not interpret yet.>";
+    const root = seed?.suspects?.[0] != null
+        ? `${seed.suspects[0].name} (${seed.suspects[0].file}:${seed.suspects[0].startLine}) **(candidate — verify)**`
+        : "<symbol (file:line) — must resolve against the graph>";
+    const blast = seed?.blastRadiusSummary ??
+        "<Run compass_impact on the confirmed root cause; list modules and call sites.>";
+    return `# Bugfix: ${name}
+
+**Level:** ${level} · **Type:** bug · **Severity:** normal
+
+## 1. Observed symptom
+${symptom}
+
+## 2. Minimal reproduction
+<!-- Steps to reproduce, or \`unreproducible: <reason and what was tried>\` -->
+
+## 3. Root cause
+${root}
+
+## 4. Blast radius
+${blast}
+
+## 5. Proposed fix
+<!-- The change; note discarded alternatives if any. -->
+
+## 6. Regression test
+<!-- test/path.test.ts::case name — must fail BEFORE the fix -->
+
+## 7. Prevention
+<!-- New law (executable-laws block), missing spec requirement, or "none: <reason>" -->
+`;
+}
+/**
+ * Scaffold a bug change: `bugfix.md`, `change.json`, and `reports/`.
+ */
+export function scaffoldBugfix(projectPath, name, opts = {}) {
+    const changeDir = path.join(projectPath, "lawbook", "changes", name);
+    if (fs.existsSync(changeDir)) {
+        throw new Error(`change "${name}" already exists under lawbook/changes/`);
+    }
+    const targets = opts.targets ?? { paths: [], symbols: [] };
+    const { thresholds } = loadCeremonyConfig(projectPath);
+    const signals = gatherSignals(projectPath, targets, thresholds);
+    const proposal = proposeLevel(signals, thresholds);
+    const level = opts.level ?? (proposal.level !== null && proposal.level <= 1 ? proposal.level : 1);
+    fs.mkdirSync(path.join(changeDir, "reports"), { recursive: true });
+    fs.writeFileSync(path.join(changeDir, "bugfix.md"), bugfixTemplate(name, level, opts.seed));
+    fs.writeFileSync(path.join(changeDir, "reports", "README.md"), `# Reports — ${name}\n\nBug reports MUST include the regression test **failing before the fix**.\n`);
+    if (level >= 1) {
+        fs.writeFileSync(path.join(changeDir, "tasks.md"), `- [ ] Reproduce and confirm root cause\n- [ ] Implement fix\n- [ ] Add regression test (red before, green after)\n- [ ] Complete prevention §7\n- [ ] Write discipline report under reports/\n`);
+    }
+    if (level >= 2) {
+        fs.writeFileSync(path.join(changeDir, "design.md"), `# Design — ${name}\n\n## Approach\n\n(structural bugfix — document the fix architecture)\n`);
+    }
+    const record = setCeremonyLevel(projectPath, name, {
+        proposal,
+        level,
+        confirmedBy: "human",
+    });
+    const updated = { ...record, changeType: "bug" };
+    writeCeremonyRecord(projectPath, name, updated);
+    return { change: name, proposal, record: updated, dir: changeDir };
+}
+/** Read change type from an archived folder path. */
+export function readChangeTypeFromDir(changeDir) {
+    const p = path.join(changeDir, "change.json");
+    if (!fs.existsSync(p))
+        return "feature";
+    try {
+        const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+        return raw.changeType === "bug" ? "bug" : "feature";
+    }
+    catch {
+        return "feature";
+    }
+}

package/dist/modules/lawbook/engine.js

@@ -2,6 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { coverageArchiveBlockers } from "./coverage.js";
 import { sealCapability } from "./anchors.js";
+import { artifactNeeds, confirmedLevel, countUncheckedTasks, gatherSignals, hasDisciplineReport, loadCeremonyConfig, proposeLevel, readChangeType, readCeremonyRecord, } from "./levels.js";
+import { inferBugResolution, preventionRequiresDelta, validateBugfixContent } from "./bugfix.js";
 // speclaw's own spec-driven workflow engine. Inspired by OpenSpec's model
 // (proposals, delta specs, changes, archive) but implemented from scratch and
 // deliberately simpler: a change's specs/ holds the full intended spec for each
@@ -33,25 +35,33 @@ mandatory_task_steps:
   - "Archive the change within the same PR (lawbook:archive)."
 
 # A change is required for new behavior, endpoints, schema changes, or UI flows;
-# one-line fixes need not have one.
+# one-line fixes may use ceremony level 0 (\`speclaw quick\`) instead of full artifacts.
+
+# Ceremony levels (adaptive). Defaults match speclaw's built-in thresholds.
+ceremony:
+  cuts: [3, 8, 15]
+  hotspotFloor: 0.7
 `;
 const README_MD = `# lawbook/ — the spec-driven workflow (speclaw)
 
 This directory is managed by speclaw's **lawbook** module.
 
 - \`specs/\` — the canonical specifications (the current source of truth).
-- \`changes/<name>/\` — an in-flight change: \`proposal.md\`, \`tasks.md\`,
-  \`design.md\`, and \`specs/<capability>/spec.md\` delta specs.
+- \`changes/<name>/\` — an in-flight change. Artifact volume follows the
+  confirmed ceremony level in \`change.json\` (0=quick … 3=full). Missing
+  \`change.json\` means level 3 (proposal, design, tasks, delta specs).
 - \`changes/archive/\` — completed, archived changes.
-- \`config.yaml\` — mandatory task steps and workflow rules.
+- \`config.yaml\` — mandatory task steps, coverage, and optional ceremony cuts.
 
 ## Workflow
 
-1. \`lawbook:draft\` — describe the change; generates proposal, delta specs, tasks.
-2. \`lawbook:build\` — implement the tasks.
-3. \`lawbook:sync\` — promote the change's delta specs into \`specs/\`.
-4. \`lawbook:archive\` — sync + move the change to \`changes/archive/\`.
-5. \`lawbook:explore\` — think through an idea before or during a change.
+1. \`lawbook:explore\` — think through an idea before or during a change.
+2. \`lawbook:draft\` / \`speclaw quick\` — propose/confirm a ceremony level, then
+   scaffold only the artifacts that level requires.
+3. \`lawbook:build\` — implement the tasks.
+4. \`lawbook:sync\` — promote the change's delta specs into \`specs/\` (when the
+   level requires specs).
+5. \`lawbook:archive\` — sync (if needed) + move the change to \`changes/archive/\`.
 `;
 /**
  * Initialize the spec/ workspace, creating the specs/, changes/, and archive
@@ -146,18 +156,17 @@ function deltaSpecFiles(changeDir) {
     return out;
 }
 /**
- * Validate a change's artifacts: proposal.md and tasks.md must be present, and
- * each delta spec must use normative language (SHALL/MUST), a "### Requirement:"
- * header, and a "#### Scenario:" acceptance criterion.
+ * Validate a change's artifacts against its confirmed ceremony level
+ * (missing `change.json` ⇒ level 3 / full ceremony).
  *
  * @param projectPath - Absolute path to the project root.
  * @param change - Change name (folder under lawbook/changes/).
- * @returns The validation verdict and the list of issues to fix; never throws
- *   for a missing change — it is reported as an issue with `valid: false`.
+ * @param remeasure - Optional targets to re-score scope growth (paths/symbols).
  */
-export function specValidate(projectPath, change) {
+export function specValidate(projectPath, change, remeasure) {
     const changeDir = path.join(specRoot(projectPath), "changes", change);
     const issues = [];
+    const warnings = [];
     if (!fs.existsSync(changeDir)) {
         return {
             change,
@@ -167,18 +176,64 @@ export function specValidate(projectPath, change) {
             deltaSpecs: [],
         };
     }
-    if (!fs.existsSync(path.join(changeDir, "proposal.md")))
-        issues.push("missing proposal.md");
-    const tasksPath = path.join(changeDir, "tasks.md");
-    if (!fs.existsSync(tasksPath))
-        issues.push("missing tasks.md");
+    const level = confirmedLevel(projectPath, change);
+    const changeType = readChangeType(projectPath, change);
+    const needs = artifactNeeds(level, changeType);
+    if (needs.bugfix) {
+        const bugPath = path.join(changeDir, "bugfix.md");
+        if (!fs.existsSync(bugPath)) {
+            issues.push(`missing bugfix.md (required for bug changes at level ${level})`);
+        }
+        else {
+            issues.push(...validateBugfixContent(level, fs.readFileSync(bugPath, "utf8")));
+        }
+        if (fs.existsSync(path.join(changeDir, "proposal.md"))) {
+            issues.push("bug changes must not include proposal.md — use bugfix.md");
+        }
+    }
+    if (needs.record && !fs.existsSync(path.join(changeDir, "record.md"))) {
+        issues.push(`missing record.md (required at ceremony level ${level})`);
+    }
+    if (needs.proposal && !fs.existsSync(path.join(changeDir, "proposal.md"))) {
+        issues.push(`missing proposal.md (required at ceremony level ${level})`);
+    }
+    if (needs.design && !fs.existsSync(path.join(changeDir, "design.md"))) {
+        issues.push(`missing design.md (required at ceremony level ${level})`);
+    }
+    if (needs.designOptionalWithJustification && !fs.existsSync(path.join(changeDir, "design.md"))) {
+        const record = path.join(changeDir, "record.md");
+        const text = fs.existsSync(record) ? fs.readFileSync(record, "utf8") : "";
+        if (!/design\s*(omitted|skipped|n\/a)/i.test(text) && !/why.*design/i.test(text)) {
+            issues.push(`level ${level}: design.md omitted without justification in record.md`);
+        }
+    }
+    if (needs.tasksFile && !fs.existsSync(path.join(changeDir, "tasks.md"))) {
+        issues.push(`missing tasks.md (required at ceremony level ${level})`);
+    }
     const deltas = deltaSpecFiles(changeDir);
-    if (deltas.length === 0)
-        issues.push("no delta specs under specs/ (a change should specify what it changes)");
+    if (needs.deltaSpecs && deltas.length === 0) {
+        issues.push(`no delta specs under specs/ (required at ceremony level ${level})`);
+    }
+    if (needs.bugfix) {
+        const bugPath = path.join(changeDir, "bugfix.md");
+        if (fs.existsSync(bugPath) && preventionRequiresDelta(fs.readFileSync(bugPath, "utf8"))) {
+            if (deltas.length === 0) {
+                issues.push("prevention §7 indicates a missing canonical requirement — add a delta spec under specs/");
+            }
+        }
+    }
+    // Scope-growth: when remeasure targets provided (or change.json has prior signals
+    // with paths we cannot recover), only check if caller passes targets.
+    if (remeasure && (remeasure.paths.length > 0 || remeasure.symbols.length > 0)) {
+        const { thresholds } = loadCeremonyConfig(projectPath);
+        const measured = proposeLevel(gatherSignals(projectPath, remeasure, thresholds), thresholds);
+        if (measured.level !== null && measured.level >= level + 2) {
+            issues.push(`scope grew: measured level ${measured.level}, recorded ${level} — run promote or justify (${measured.rationale})`);
+        }
+    }
     const root = specRoot(projectPath);
     const changeSpecs = path.join(changeDir, "specs");
     const capabilities = canonicalCapabilities(root);
-    const warnings = [];
     for (const file of deltas) {
         const rel = path.relative(changeDir, file);
         const content = fs.readFileSync(file, "utf8");
@@ -191,7 +246,6 @@ export function specValidate(projectPath, change) {
         if (!/^###\s+Requirement:/m.test(content)) {
             issues.push(`${rel}: no "### Requirement:" header`);
         }
-        // Advisory divergence checks against the canonical specs.
         const relFromSpecs = path.relative(changeSpecs, file);
         const capability = relFromSpecs.split(path.sep)[0];
         const nearMatch = nearMatchCapability(capability, capabilities);
@@ -268,10 +322,9 @@ export function specSync(projectPath, change) {
  * Deterministic completeness checks that gate archiving a change. Returns the
  * blocking reasons; an empty array means the change may be archived.
  *
- * A change is blocked when any task is still unchecked, when it has no discipline
- * report under reports/, or when its delta specs are not synced — the canonical
- * spec is missing for, or differs from, a delta (meaning sync was not run after
- * the last spec edit). The reports/README.md scaffold does not count as a report.
+ * Gates respect the confirmed ceremony level (missing `change.json` ⇒ level 3).
+ * Every level still requires checked tasks and a discipline report. Delta-spec
+ * sync is required only when the level demands delta specs.
  *
  * @param projectPath - Absolute path to the project root.
  * @param change - Change name (folder under lawbook/changes/).
@@ -283,33 +336,67 @@ export function specArchivePreconditions(projectPath, change) {
     if (!fs.existsSync(changeDir))
         return [`change "${change}" not found under lawbook/changes/`];
     const blockers = [];
-    // 1. Every task must be checked.
-    const tasksPath = path.join(changeDir, "tasks.md");
-    if (!fs.existsSync(tasksPath)) {
-        blockers.push("missing tasks.md");
+    const level = confirmedLevel(projectPath, change);
+    const changeType = readChangeType(projectPath, change);
+    const needs = artifactNeeds(level, changeType);
+    // 1. Every task must be checked (tasks.md, record.md, or bugfix checklist at level 0).
+    if (needs.tasksFile) {
+        const tasksPath = path.join(changeDir, "tasks.md");
+        if (!fs.existsSync(tasksPath)) {
+            blockers.push("missing tasks.md");
+        }
+        else {
+            const unchecked = countUncheckedTasks(fs.readFileSync(tasksPath, "utf8"));
+            if (unchecked > 0)
+                blockers.push(`${unchecked} unchecked task(s) in tasks.md`);
+        }
     }
-    else {
-        const unchecked = (fs.readFileSync(tasksPath, "utf8").match(/^\s*[-*]\s+\[ \]/gm) ?? []).length;
-        if (unchecked > 0)
-            blockers.push(`${unchecked} unchecked task(s) in tasks.md`);
+    else if (needs.record) {
+        const recordPath = path.join(changeDir, "record.md");
+        if (!fs.existsSync(recordPath)) {
+            blockers.push("missing record.md");
+        }
+        else {
+            const unchecked = countUncheckedTasks(fs.readFileSync(recordPath, "utf8"));
+            if (unchecked > 0)
+                blockers.push(`${unchecked} unchecked task(s) in record.md`);
+        }
+    }
+    else if (needs.bugfix && level === 0) {
+        const bugPath = path.join(changeDir, "bugfix.md");
+        if (fs.existsSync(bugPath)) {
+            const unchecked = countUncheckedTasks(fs.readFileSync(bugPath, "utf8"));
+            if (unchecked > 0)
+                blockers.push(`${unchecked} unchecked item(s) in bugfix.md checklist`);
+        }
+    }
+    if (needs.bugfix) {
+        const bugPath = path.join(changeDir, "bugfix.md");
+        if (fs.existsSync(bugPath)) {
+            const content = fs.readFileSync(bugPath, "utf8");
+            const bugIssues = validateBugfixContent(level, content);
+            blockers.push(...bugIssues.filter((i) => i.includes("Regression test") || i.includes("§6")));
+        }
     }
     // 2. At least one discipline report must exist (README.md scaffold aside).
-    const reportsDir = path.join(changeDir, "reports");
-    const reports = fs.existsSync(reportsDir)
-        ? fs.readdirSync(reportsDir).filter((n) => n.endsWith(".md") && n.toLowerCase() !== "readme.md")
-        : [];
-    if (reports.length === 0) {
+    if (!hasDisciplineReport(changeDir)) {
         blockers.push("no discipline report under reports/ (build must record what was tested)");
     }
-    // 3. Delta specs must already be synced into the canonical specs.
-    for (const file of deltaSpecFiles(changeDir)) {
-        const rel = path.relative(path.join(changeDir, "specs"), file);
-        const canonical = path.join(root, "specs", rel);
-        if (!fs.existsSync(canonical)) {
-            blockers.push(`spec not synced: lawbook/specs/${rel} missing (run sync first)`);
-        }
-        else if (fs.readFileSync(file, "utf8") !== fs.readFileSync(canonical, "utf8")) {
-            blockers.push(`spec not synced: lawbook/specs/${rel} differs from the delta (run sync first)`);
+    // 3. Delta specs must already be synced — when required or when bug prevention demands it.
+    const bugPath = path.join(changeDir, "bugfix.md");
+    const bugNeedsDelta = needs.bugfix &&
+        fs.existsSync(bugPath) &&
+        preventionRequiresDelta(fs.readFileSync(bugPath, "utf8"));
+    if (needs.deltaSpecs || bugNeedsDelta) {
+        for (const file of deltaSpecFiles(changeDir)) {
+            const rel = path.relative(path.join(changeDir, "specs"), file);
+            const canonical = path.join(root, "specs", rel);
+            if (!fs.existsSync(canonical)) {
+                blockers.push(`spec not synced: lawbook/specs/${rel} missing (run sync first)`);
+            }
+            else if (fs.readFileSync(file, "utf8") !== fs.readFileSync(canonical, "utf8")) {
+                blockers.push(`spec not synced: lawbook/specs/${rel} differs from the delta (run sync first)`);
+            }
         }
     }
     // 4. Opt-in coverage gate: only when the change's delta specs declare ids.
@@ -317,8 +404,8 @@ export function specArchivePreconditions(projectPath, change) {
     return blockers;
 }
 /**
- * Finalize a change: promote its delta specs (via {@link specSync}), then move
- * it to changes/archive/<date>-<name>/.
+ * Finalize a change: promote its delta specs (via {@link specSync}) when the
+ * ceremony level requires them, then move it to changes/archive/<date>-<name>/.
  *
  * @param projectPath - Absolute path to the project root.
  * @param change - Change name (folder under lawbook/changes/).
@@ -336,7 +423,31 @@ export function specArchive(projectPath, change, date) {
     if (blockers.length > 0) {
         throw new Error(`cannot archive "${change}" — resolve first:\n${blockers.map((b) => `  - ${b}`).join("\n")}`);
     }
-    const { promoted, created, updated } = specSync(projectPath, change);
+    const level = confirmedLevel(projectPath, change);
+    const changeType = readChangeType(projectPath, change);
+    const needs = artifactNeeds(level, changeType);
+    // Record bug resolution before move.
+    if (changeType === "bug") {
+        const bugPath = path.join(changeDir, "bugfix.md");
+        if (fs.existsSync(bugPath)) {
+            const rec = readCeremonyRecord(projectPath, change);
+            if (rec) {
+                rec.changeType = "bug";
+                rec.resolution = inferBugResolution(fs.readFileSync(bugPath, "utf8"));
+                const cj = path.join(changeDir, "change.json");
+                fs.writeFileSync(cj, JSON.stringify(rec, null, 2) + "\n");
+            }
+        }
+    }
+    const bugPath = path.join(changeDir, "bugfix.md");
+    const shouldSync = needs.deltaSpecs ||
+        (changeType === "bug" &&
+            fs.existsSync(bugPath) &&
+            preventionRequiresDelta(fs.readFileSync(bugPath, "utf8")));
+    const sync = shouldSync
+        ? specSync(projectPath, change)
+        : { change, promoted: [], created: [], updated: [] };
+    const { promoted, created, updated } = sync;
     const seals = sealPromotedCapabilities(projectPath, change, [
         ...promoted,
         ...created,
@@ -391,7 +502,13 @@ function sealPromotedCapabilities(projectPath, change, promotedPaths) {
 export function specList(projectPath) {
     const root = specRoot(projectPath);
     if (!fs.existsSync(root)) {
-        return { initialized: false, activeChanges: [], archivedChanges: [], capabilities: [] };
+        return {
+            initialized: false,
+            activeChanges: [],
+            activeLevels: {},
+            archivedChanges: [],
+            capabilities: [],
+        };
     }
     const dirsIn = (rel) => {
         const abs = path.join(root, rel);
@@ -402,9 +519,15 @@ export function specList(projectPath) {
             .filter((e) => e.isDirectory() && e.name !== "archive")
             .map((e) => e.name);
     };
+    const activeChanges = dirsIn("changes");
+    const activeLevels = {};
+    for (const name of activeChanges) {
+        activeLevels[name] = confirmedLevel(projectPath, name);
+    }
     return {
         initialized: true,
-        activeChanges: dirsIn("changes"),
+        activeChanges,
+        activeLevels,
         archivedChanges: dirsIn("changes/archive"),
         capabilities: dirsIn("specs"),
     };