@ritualai/cli 0.11.0 → 0.25.0

package/dist/lib/agents/providers.js

@@ -47,6 +47,11 @@ exports.PROVIDERS = [
         // closes the scope-mismatch FTUE bug where MCP was registered
         // user-global but the skill only loaded from the project dir.
         userSkillDir: (0, node_path_1.join)((0, node_os_1.homedir)(), '.claude', 'skills'),
+        // Claude Code loads `CLAUDE.md` (project + `~/.claude/CLAUDE.md` global)
+        // at the start of every session — the home for the always-on
+        // coding-discovery routing rule.
+        projectMemoryRule: { path: 'CLAUDE.md', mode: 'append' },
+        userMemoryRule: { path: (0, node_path_1.join)('.claude', 'CLAUDE.md'), mode: 'append' },
         // `claude mcp add-json` writes to ~/.claude.json itself; we
         // shell out so we don't fight its config-file format.
         mcpConfigMethod: 'cli-command',
@@ -64,10 +69,15 @@ exports.PROVIDERS = [
             (0, node_fs_1.existsSync)((0, node_path_1.join)((0, node_os_1.homedir)(), '.cursor', 'mcp.json')),
         projectSkillDir: '.cursor/rules',
         packageSkillDir: 'skills/cursor',
-        // Cursor's "User Rules" live in the app's settings DB (Cursor
-        // Settings → Rules), not in a filesystem path. A CLI cannot
-        // populate them. Project-local install is the only option.
-        // Doctor surfaces this asymmetry.
+        // Cursor reads project rules from `.cursor/rules/*.mdc` with YAML
+        // frontmatter; `alwaysApply: true` loads the rule every request.
+        // Dedicated file (we own it). User Rules live in the app's settings
+        // DB, not a file — no global variant a CLI can write.
+        projectMemoryRule: {
+            path: (0, node_path_1.join)('.cursor', 'rules', 'ritual-discovery.mdc'),
+            mode: 'dedicated',
+            frontmatter: '---\ndescription: Choose the right discovery tier before planning a coding task\nglobs:\nalwaysApply: true\n---',
+        },
         mcpConfigMethod: 'json-file',
         mcpConfigPath: (0, node_path_1.join)((0, node_os_1.homedir)(), '.cursor', 'mcp.json'),
     },
@@ -90,6 +100,16 @@ exports.PROVIDERS = [
         // integration ships MCP tools only — no `/ritual` skill install.
         // Doctor surfaces stale `.windsurf/rules/ritual/` from prior CLI
         // versions and tells the user it's safe to delete.
+        //
+        // The DISCOVERY RULE is different from the SKILL bundle: Windsurf's
+        // `.windsurf/rules/*.md` takes single rule files with a `trigger`
+        // frontmatter — `always_on` loads it every Cascade conversation. So
+        // the routing rule ships even though the multi-file SKILL bundle can't.
+        projectMemoryRule: {
+            path: (0, node_path_1.join)('.windsurf', 'rules', 'ritual-discovery.md'),
+            mode: 'dedicated',
+            frontmatter: '---\ntrigger: always_on\ndescription: Choose the right discovery tier before planning a coding task\n---',
+        },
         mcpConfigMethod: 'json-file',
         mcpConfigPath: (0, node_path_1.join)((0, node_os_1.homedir)(), '.codeium', 'windsurf', 'mcp_config.json'),
     },
@@ -100,6 +120,14 @@ exports.PROVIDERS = [
         projectSkillDir: '.kiro/skills',
         packageSkillDir: 'skills/kiro',
         userSkillDir: (0, node_path_1.join)((0, node_os_1.homedir)(), '.kiro', 'skills'),
+        // Kiro steering: `.kiro/steering/*.md` with `inclusion: always`
+        // frontmatter loads the file into context for every prompt. The
+        // frontmatter MUST be the first bytes (no leading blank line).
+        projectMemoryRule: {
+            path: (0, node_path_1.join)('.kiro', 'steering', 'ritual-discovery.md'),
+            mode: 'dedicated',
+            frontmatter: '---\ninclusion: always\n---',
+        },
         mcpConfigMethod: 'json-file',
         mcpConfigPath: (0, node_path_1.join)((0, node_os_1.homedir)(), '.kiro', 'mcp.json'),
     },
@@ -114,6 +142,10 @@ exports.PROVIDERS = [
         // `~/.gemini/skills/<name>/SKILL.md` — matches the Agent Skills
         // open standard.
         userSkillDir: (0, node_path_1.join)((0, node_os_1.homedir)(), '.gemini', 'skills'),
+        // Gemini CLI hierarchically loads `GEMINI.md` context files: project
+        // root + `~/.gemini/GEMINI.md` global, concatenated into every prompt.
+        projectMemoryRule: { path: 'GEMINI.md', mode: 'append' },
+        userMemoryRule: { path: (0, node_path_1.join)('.gemini', 'GEMINI.md'), mode: 'append' },
         mcpConfigMethod: 'json-file',
         mcpConfigPath: (0, node_path_1.join)((0, node_os_1.homedir)(), '.gemini', 'mcp.json'),
     },
@@ -132,6 +164,10 @@ exports.PROVIDERS = [
         // User-global per the VS Code Agent Skills docs:
         // https://code.visualstudio.com/docs/copilot/customization/agent-skills
         userSkillDir: (0, node_path_1.join)((0, node_os_1.homedir)(), '.copilot', 'skills'),
+        // VS Code auto-applies `.github/copilot-instructions.md` (repo root) to
+        // every Copilot chat request. User-level instructions live in VS Code
+        // settings, not a portable file — no global variant here.
+        projectMemoryRule: { path: (0, node_path_1.join)('.github', 'copilot-instructions.md'), mode: 'append' },
         mcpConfigMethod: 'json-file',
         mcpConfigPath: (0, node_path_1.join)((0, node_os_1.homedir)(), '.vscode', 'mcp.json'),
         // VS Code's quirk: top-level key is `servers`, not `mcpServers`.
@@ -146,6 +182,10 @@ exports.PROVIDERS = [
         projectSkillDir: '.agents/skills',
         packageSkillDir: 'skills/codex',
         userSkillDir: (0, node_path_1.join)((0, node_os_1.homedir)(), '.agents', 'skills'),
+        // Codex reads `AGENTS.md` (the cross-agent open standard): repo root +
+        // `~/.codex/AGENTS.md` global, concatenated root-down each session.
+        projectMemoryRule: { path: 'AGENTS.md', mode: 'append' },
+        userMemoryRule: { path: (0, node_path_1.join)('.codex', 'AGENTS.md'), mode: 'append' },
         mcpConfigMethod: 'json-file',
         mcpConfigPath: (0, node_path_1.join)((0, node_os_1.homedir)(), '.codex', 'mcp.json'),
     },

package/dist/lib/agents/providers.js.map

@@ -1 +1 @@
-{"version":3,"file":"providers.js","sourceRoot":"","sources":["../../../src/lib/agents/providers.ts"],"names":[],"mappings":";;;AAkPA,4CAEC;AApPD,qCAAqC;AACrC,qCAAkC;AAClC,yCAAiC;AACjC,2DAA8C;AA4F9C;;;;;;GAMG;AACH,SAAS,aAAa,CAAC,GAAW;IACjC,IAAI,CAAC;QACJ,MAAM,KAAK,GAAG,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC;QAC/D,IAAA,6BAAQ,EAAC,GAAG,KAAK,IAAI,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAC/C,OAAO,IAAI,CAAC;IACb,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,KAAK,CAAC;IACd,CAAC;AACF,CAAC;AAED;;;;;;;;GAQG;AACU,QAAA,SAAS,GAAoB;IACzC;QACC,IAAI,EAAE,aAAa;QACnB,EAAE,EAAE,aAAa;QACjB,iEAAiE;QACjE,4DAA4D;QAC5D,0DAA0D;QAC1D,MAAM,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,CAAC,CAAC;QAC/E,eAAe,EAAE,gBAAgB;QACjC,eAAe,EAAE,oBAAoB;QACrC,sEAAsE;QACtE,qEAAqE;QACrE,8DAA8D;QAC9D,8DAA8D;QAC9D,YAAY,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,QAAQ,CAAC;QAClD,4DAA4D;QAC5D,sDAAsD;QACtD,eAAe,EAAE,aAAa;KAC9B;IACD;QACC,IAAI,EAAE,QAAQ;QACd,EAAE,EAAE,QAAQ;QACZ,6DAA6D;QAC7D,8DAA8D;QAC9D,4DAA4D;QAC5D,+DAA+D;QAC/D,uDAAuD;QACvD,MAAM,EAAE,GAAG,EAAE,CACZ,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;YACpD,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC;YACvD,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QACnD,eAAe,EAAE,eAAe;QAChC,eAAe,EAAE,eAAe;QAChC,8DAA8D;QAC9D,4DAA4D;QAC5D,2DAA2D;QAC3D,kCAAkC;QAClC,eAAe,EAAE,WAAW;QAC5B,aAAa,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,UAAU,CAAC;KACrD;IACD;QACC,IAAI,EAAE,UAAU;QAChB,EAAE,EAAE,UAAU;QACd,+DAA+D;QAC/D,gEAAgE;QAChE,4DAA4D;QAC5D,6DAA6D;QAC7D,2CAA2C;QAC3C,MAAM,EAAE,GAAG,EAAE,CAAC,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;QACjE,mEAAmE;QACnE,oEAAoE;QACpE,sEAAsE;QACtE,6DAA6D;QAC7D,4DAA4D;QAC5D,iEAAiE;QACjE,8DAA8D;QAC9D,iEAAiE;QACjE,iEAAiE;QACjE,mDAAmD;QACnD,eAAe,EAAE,WAAW;QAC5B,aAAa,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,UAAU,EAAE,UAAU,EAAE,iBAAiB,CAAC;KACzE;IACD;QACC,IAAI,EAAE,MAAM;QACZ,EAAE,EAAE,MAAM;QACV,MAAM,EAAE,GAAG,EAAE,CAAC,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,OAAO,CAAC,CAAC,IAAI,aAAa,CAAC,MAAM,CAAC;QAC3E,eAAe,EAAE,cAAc;QAC/B,eAAe,EAAE,aAAa;QAC9B,YAAY,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,OAAO,EAAE,QAAQ,CAAC;QAChD,eAAe,EAAE,WAAW;QAC5B,aAAa,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,OAAO,EAAE,UAAU,CAAC;KACnD;IACD;QACC,IAAI,EAAE,YAAY;QAClB,EAAE,EAAE,QAAQ;QACZ,MAAM,EAAE,GAAG,EAAE,CAAC,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,CAAC,CAAC,IAAI,aAAa,CAAC,QAAQ,CAAC;QAC/E,eAAe,EAAE,gBAAgB;QACjC,eAAe,EAAE,eAAe;QAChC,0DAA0D;QAC1D,oDAAoD;QACpD,gEAAgE;QAChE,iBAAiB;QACjB,YAAY,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,QAAQ,CAAC;QAClD,eAAe,EAAE,WAAW;QAC5B,aAAa,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,UAAU,CAAC;KACrD;IACD;QACC,IAAI,EAAE,mBAAmB;QACzB,EAAE,EAAE,QAAQ;QACZ,+DAA+D;QAC/D,4DAA4D;QAC5D,mBAAmB;QACnB,MAAM,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,CAAC,CAAC;QAC7E,+DAA+D;QAC/D,kEAAkE;QAClE,+DAA+D;QAC/D,eAAe,EAAE,gBAAgB;QACjC,eAAe,EAAE,eAAe;QAChC,iDAAiD;QACjD,wEAAwE;QACxE,YAAY,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,UAAU,EAAE,QAAQ,CAAC;QACnD,eAAe,EAAE,WAAW;QAC5B,aAAa,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,UAAU,CAAC;QACrD,iEAAiE;QACjE,YAAY,EAAE,SAAS;KACvB;IACD;QACC,IAAI,EAAE,OAAO;QACb,EAAE,EAAE,OAAO;QACX,6DAA6D;QAC7D,2DAA2D;QAC3D,MAAM,EAAE,GAAG,EAAE,CAAC,IAAA,oBAAU,EAAC,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,QAAQ,CAAC,CAAC,IAAI,aAAa,CAAC,OAAO,CAAC;QAC7E,eAAe,EAAE,gBAAgB;QACjC,eAAe,EAAE,cAAc;QAC/B,YAAY,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,SAAS,EAAE,QAAQ,CAAC;QAClD,eAAe,EAAE,WAAW;QAC5B,aAAa,EAAE,IAAA,gBAAI,EAAC,IAAA,iBAAO,GAAE,EAAE,QAAQ,EAAE,UAAU,CAAC;KACpD;CACD,CAAC;AAEF,wEAAwE;AACxE,SAAgB,gBAAgB,CAAC,EAAU;IAC1C,OAAO,iBAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAC3C,CAAC"}
+{"version":3,"file":"providers.js","sourceRoot":"","sources":["../../../src/lib/agents/providers.ts"],"names":[],"mappings":"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"}

package/dist/lib/memory-update.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__MARKERS = exports.__ROUTER_BODY = void 0;
+exports.updateMemoryRules = updateMemoryRules;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+/**
+ * Write the always-on "coding discovery before planning" routing rule into
+ * each detected agent's instructions surface, so the agent reliably picks the
+ * right discovery TIER (no / lightweight / full Ritual discovery) before plan
+ * mode instead of jumping to a speculative plan.
+ *
+ * Why this matters more for non-Claude agents: Anthropic-style skill
+ * auto-invocation (loading a SKILL by its `description`) is largely
+ * Claude-Code-specific. For Cursor/Kiro/Windsurf/etc. the rule in their
+ * always-on instructions file is the primary routing signal, not a backup.
+ *
+ * Two write shapes, per `MemoryRuleTarget.mode`:
+ *   - `append`    → marker-bracketed block into a SHARED instructions file the
+ *                   agent already loads (CLAUDE.md / GEMINI.md / AGENTS.md /
+ *                   .github/copilot-instructions.md). Preserves the user's own
+ *                   content; re-runs replace the block in place.
+ *   - `dedicated` → a rule file we OWN (Cursor `.mdc`, Kiro steering, Windsurf
+ *                   rule), written wholesale as `frontmatter + body`. Like the
+ *                   scaffolded skill files, it's regenerated every init.
+ *
+ * Scopes: project (relative to the repo root) always; global (relative to
+ * $HOME) only when `ritual init --global-memory-rule` is passed.
+ *
+ * Mirrors `gitignore-update.ts`: byte-level string ops (preserve line endings),
+ * idempotent, fail-soft at the call site. Deliberately NOT gitignored — a
+ * routing rule is team-shareable guidance most repos want committed.
+ */
+/**
+ * Marker comments delimiting the block we own in `append`-mode files. Matched
+ * by string.indexOf — do NOT change casually; older blocks use this text.
+ */
+const BEGIN_MARKER = '<!-- Begin: ritual init — skill routing (regenerated on every init) -->';
+const END_MARKER = '<!-- End: ritual init -->';
+/**
+ * The routing rule body — three tiers, keyed off the same "ambiguous /
+ * cross-cutting / non-obvious constraints" language as the `/ritual` SKILL
+ * description so the two never drift. Tight scope is load-bearing: an
+ * over-eager rule that fires on every "build" word becomes noise. The rule is
+ * offer-not-auto and explicitly exempts trivial edits.
+ */
+const ROUTER_BODY = `## Coding discovery before planning
+
+Before entering plan mode for a coding task, decide how much repository
+discovery it needs — and don't jump straight into a speculative plan. Pick one
+of three tiers:
+
+- **No discovery** — tiny, local, mechanical edits where the target file and the
+  change are obvious (typo, copy change, formatting, replacing a clearly
+  specified value). Just make the change.
+- **Lightweight discovery** — bounded tasks where the user gave useful context
+  but repo conventions may still shape the plan (adding a DB column, renaming a
+  model, changing retry behavior, touching one known endpoint). Briefly inspect
+  the relevant files, symbols, tests, schemas, or similar implementations first.
+  Keep it inline — don't turn it into a separate process unless the task proves
+  broader or ambiguous. For a small but genuinely build-shaped dev task that
+  still benefits from Ritual's pipeline (recommendations → brief → implement →
+  PR) without the full discovery walk, offer \`/ritual lite "<their ask>"\` — the
+  same pipeline run fast/unattended, with only a job+persona front gate and a
+  non-blocking recommendation review.
+- **Full Ritual discovery** — non-trivial, ambiguous, architectural,
+  cross-cutting, multi-file, integration-heavy, or product/workflow-context-heavy
+  work. Offer to run \`/ritual build "<their ask>"\` first: it runs a structured
+  exploration that surfaces intent, constraints, and prior decisions and returns
+  a validated build brief — grounded context to fold into plan mode rather than a
+  speculative plan. Proceed from the brief into planning/implementation.
+
+When uncertain, prefer lightweight discovery over guessing. The user can always
+decline.`;
+/** The marker block (markers + body) for `append` mode. */
+function buildBlock() {
+    return `${BEGIN_MARKER}\n${ROUTER_BODY}\n${END_MARKER}`;
+}
+/**
+ * Replace the marker-bracketed block in `body` with `newBlock`. If absent,
+ * append it (separated by a blank line when the file has content). Byte-level
+ * so the user's content and line-endings survive.
+ */
+function replaceOrAppendBlock(body, newBlock) {
+    const beginIdx = body.indexOf(BEGIN_MARKER);
+    const endIdx = body.indexOf(END_MARKER);
+    if (beginIdx >= 0 && endIdx > beginIdx) {
+        const endLineEnd = endIdx + END_MARKER.length;
+        return body.slice(0, beginIdx) + newBlock + body.slice(endLineEnd);
+    }
+    const trimmed = body.replace(/\s+$/, '');
+    if (trimmed.length === 0)
+        return `${newBlock}\n`;
+    return `${trimmed}\n\n${newBlock}\n`;
+}
+/** The full contents of a `dedicated` rule file (frontmatter must be first). */
+function dedicatedContents(target) {
+    const fm = target.frontmatter ? `${target.frontmatter.replace(/\s+$/, '')}\n\n` : '';
+    return `${fm}${ROUTER_BODY}\n`;
+}
+/** Write one rule target under `rootDir`. Creates parent dirs as needed. */
+function writeRule(rootDir, target, scope) {
+    const abs = (0, node_path_1.join)(rootDir, target.path);
+    const preExisting = (0, node_fs_1.existsSync)(abs);
+    const current = preExisting ? (0, node_fs_1.readFileSync)(abs, 'utf8') : '';
+    const nextBody = target.mode === 'append'
+        ? replaceOrAppendBlock(current, buildBlock())
+        : dedicatedContents(target);
+    const base = {
+        path: abs,
+        relativePath: target.path,
+        scope,
+        mode: target.mode,
+        preExisting,
+    };
+    if (nextBody === current)
+        return { ...base, changed: false };
+    const dir = (0, node_path_1.dirname)(abs);
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.writeFileSync)(abs, nextBody, 'utf8');
+    return { ...base, changed: true };
+}
+/**
+ * Write the routing rule for every provider's `projectMemoryRule` (always) and
+ * `userMemoryRule` (only when `opts.global`). De-dupes by absolute path so two
+ * agents that share a file (e.g. both write `AGENTS.md`) get one write.
+ * Providers without a rule target for the requested scope are skipped.
+ *
+ * `opts.homeDir` overrides `$HOME` for the global scope (tests).
+ */
+function updateMemoryRules(projectRoot, providers, opts = {}) {
+    const home = opts.homeDir ?? (0, node_os_1.homedir)();
+    const seen = new Set();
+    const results = [];
+    for (const provider of providers) {
+        if (provider.projectMemoryRule) {
+            const abs = (0, node_path_1.join)(projectRoot, provider.projectMemoryRule.path);
+            if (!seen.has(abs)) {
+                seen.add(abs);
+                results.push(writeRule(projectRoot, provider.projectMemoryRule, 'project'));
+            }
+        }
+        if (opts.global && provider.userMemoryRule) {
+            const abs = (0, node_path_1.join)(home, provider.userMemoryRule.path);
+            if (!seen.has(abs)) {
+                seen.add(abs);
+                results.push(writeRule(home, provider.userMemoryRule, 'global'));
+            }
+        }
+    }
+    return results;
+}
+/** Exposed for tests + the skill-consistency guard. */
+exports.__ROUTER_BODY = ROUTER_BODY;
+exports.__MARKERS = { BEGIN_MARKER, END_MARKER };
+//# sourceMappingURL=memory-update.js.map

package/dist/lib/memory-update.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-update.js","sourceRoot":"","sources":["../../src/lib/memory-update.ts"],"names":[],"mappings":"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"}

package/dist/lib/uninstall-plan.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSafeRitualDir = assertSafeRitualDir;
+exports.stripRouterBlock = stripRouterBlock;
+exports.planUninstall = planUninstall;
+const node_path_1 = require("node:path");
+const memory_update_1 = require("./memory-update");
+const providers_1 = require("./agents/providers");
+/**
+ * Throw unless `target` is a Ritual-owned leaf directory strictly inside `cwd`.
+ * Defense-in-depth: the planner only ever constructs safe paths, but the
+ * executor re-checks every path immediately before `rm` so a future bug can't
+ * delete something it shouldn't.
+ */
+function assertSafeRitualDir(cwd, target) {
+    const root = (0, node_path_1.resolve)(cwd);
+    const t = (0, node_path_1.resolve)(target);
+    if (t === root)
+        throw new Error(`refusing to remove the project root: ${target}`);
+    if (!t.startsWith(root + node_path_1.sep)) {
+        throw new Error(`refusing to remove a path outside the project: ${target}`);
+    }
+    const base = (0, node_path_1.basename)(t);
+    if (base !== 'ritual' && base !== '.ritual') {
+        throw new Error(`refusing to remove a non-Ritual directory: ${target}`);
+    }
+}
+/**
+ * Remove the marker-bracketed `ritual init` router block from a shared memory
+ * file, leaving every other line (the user's own content) intact. No-op +
+ * `changed: false` when the markers aren't present.
+ */
+function stripRouterBlock(body) {
+    const { BEGIN_MARKER, END_MARKER } = memory_update_1.__MARKERS;
+    const begin = body.indexOf(BEGIN_MARKER);
+    const end = begin === -1 ? -1 : body.indexOf(END_MARKER, begin);
+    if (begin === -1 || end === -1)
+        return { body, changed: false };
+    const without = body.slice(0, begin) + body.slice(end + END_MARKER.length);
+    // Collapse the blank-line gap the block leaves behind; keep a single
+    // trailing newline. An otherwise-empty file collapses to "\n" (we never
+    // delete the user's memory file, only our block).
+    const cleaned = without.replace(/\n{3,}/g, '\n\n').replace(/[ \t\r\n]+$/, '') + '\n';
+    return { body: cleaned, changed: true };
+}
+/**
+ * Build the (side-effect-free) uninstall plan. `opts.project` adds the
+ * current repo's Ritual artifacts; without it, only the global, security-
+ * relevant items (credentials + MCP registrations) are planned.
+ */
+function planUninstall(cwd, opts, deps) {
+    const actions = [];
+    // 1. Credentials (security) — the stored PAT/token must not survive an
+    //    uninstall. Always first.
+    if (deps.exists(deps.credentialsPath)) {
+        actions.push({ kind: 'clear-credentials', path: deps.credentialsPath });
+    }
+    // 2. MCP registrations — surfaced as `claude mcp remove` commands (we don't
+    //    edit the user's MCP config directly; the canonical removal is safest).
+    for (const e of deps.mcpEntries) {
+        actions.push({ kind: 'manual-mcp-remove', command: e.command, scope: e.scope });
+    }
+    // 3. Per-project artifacts (opt-in).
+    if (opts.project) {
+        const dotRitual = (0, node_path_1.join)(cwd, '.ritual');
+        if (deps.exists(dotRitual)) {
+            actions.push({
+                kind: 'remove-dir',
+                path: dotRitual,
+                label: '.ritual/ (workspace binding + persona)',
+            });
+        }
+        for (const p of providers_1.PROVIDERS) {
+            if (p.projectSkillDir) {
+                const skillDir = (0, node_path_1.join)(cwd, p.projectSkillDir, 'ritual');
+                if (deps.exists(skillDir)) {
+                    actions.push({
+                        kind: 'remove-dir',
+                        path: skillDir,
+                        label: `${p.projectSkillDir}/ritual (${p.name} skill bundle)`,
+                    });
+                }
+            }
+            const memPath = p.projectMemoryRule?.path;
+            if (memPath) {
+                const mp = (0, node_path_1.join)(cwd, memPath);
+                if (deps.exists(mp) && deps.read(mp).includes(memory_update_1.__MARKERS.BEGIN_MARKER)) {
+                    actions.push({
+                        kind: 'strip-router',
+                        path: mp,
+                        label: `${memPath} (remove Ritual routing block, keep your content)`,
+                    });
+                }
+            }
+        }
+    }
+    // 4. The CLI binary itself — printed guidance; we can't reliably uninstall
+    //    the running process mid-run, and npm-global removal is the user's step.
+    actions.push({ kind: 'manual-npm-uninstall', command: 'npm uninstall -g @ritualai/cli' });
+    return actions;
+}
+//# sourceMappingURL=uninstall-plan.js.map

package/dist/lib/uninstall-plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uninstall-plan.js","sourceRoot":"","sources":["../../src/lib/uninstall-plan.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ritualai/cli",
-  "version": "0.11.0",
+  "version": "0.25.0",
   "description": "Ritual CLI — scaffold AI coding agent skills + register MCP servers. Connects Claude Code, Cursor, Windsurf, Kiro, Gemini CLI, VS Code/Copilot, and Codex to Ritual Cloud.",
   "private": false,
   "license": "Apache-2.0",

package/skills/claude-code/ritual/.ritual-bundle.json

@@ -1,4 +1,4 @@
 {
-  "cliVersion": "0.11.0",
-  "builtAt": "2026-05-25T00:20:36.318Z"
+  "cliVersion": "0.25.0",
+  "builtAt": "2026-06-09T00:58:35.759Z"
 }

package/skills/claude-code/ritual/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ritual
-description: "Use when an engineer wants a coding agent to plan or build a feature, refactor, or implementation-heavy change that depends on context the agent can't infer on its own — strategic intent, constraints, prior decisions, and trade-offs that live in the user's head. Ritual runs a structured exploration to surface that context through targeted discovery questions, combines it with codebase signals and prior explorations, and delivers a validated build brief (sub-problems, recommendations, dependencies) before the agent writes code. Prefer this over jumping straight to implementation when the problem is ambiguous, cross-cutting, or has non-obvious constraints. Subcommands: build (full planning-to-sync cycle — default for new features), resume (continue an in-flight exploration), lineage (file-path KG history — what decisions shaped this code), context-pulse (readiness and context-debt scoring — is this safe to build yet?)."
+description: "Use when an engineer wants a coding agent to plan or build a feature, refactor, or implementation-heavy change that depends on context the agent can't infer on its own — strategic intent, constraints, prior decisions, and trade-offs that live in the user's head. Ritual runs a structured exploration to surface that context through targeted discovery questions, combines it with codebase signals and prior explorations, and delivers a validated build brief (sub-problems, recommendations, dependencies) — additional context to fold into plan mode before the agent writes code. Prefer this over jumping straight to implementation or plan mode when the problem is ambiguous, cross-cutting, or has non-obvious constraints. Subcommands: build (full planning-to-sync cycle — default for new features), resume (continue an in-flight exploration), lineage (file-path KG history — what decisions shaped this code), context-pulse (readiness and context-debt scoring — is this safe to build yet?)."
 argument-hint: "[subcommand] <args>  (e.g. 'build Reduce T2 churn in Q3', 'resume', 'lineage src/checkout/views.py', 'context-pulse Add billing export')"
 user-invocable: true
 ---
@@ -15,6 +15,7 @@ Before executing any subcommand, read and follow:
 
 - `references/cli-output-contract.md` — terminal output, vocabulary, readability, pause policy
 - `references/async-polling.md` — harness-safe polling and timeout recovery
+- `references/change-preflight.md` — restate + confirm before any free-text change/add tool call (refine sub-problems, reframe scope, add anti-goal); hard pause, even in auto-mode
 
 Do not reintroduce `/ritual recon`. Use plain-language repo inspection, `/ritual resume`, or `/ritual lineage` depending on intent.
 
@@ -37,14 +38,15 @@ When two contract-strength rules genuinely conflict (rare): **stop, surface the
 
 This rule is the meta-pattern that closes the failure class we kept hitting before 2026-05-15: the SKILL named the right behavior in each step (Step 7 picker, Step 9 preview-verbatim, Step 9 action menu, picker numbering, etc.), but the agent treated the prose as advisory and freelanced anyway. Anti-patterns are **executable constraints, not taste guidance.** When an anti-pattern says "agent must NOT", read it as a hard error, not a preference.
 
-Examples of contract-strength rules currently in force (non-exhaustive):
+**One gate per turn — never batch the flow (load-bearing).** Each user-facing gate (workspace pick, scope, the discovery Area-walk, recommendation review, the build-brief confirm, …) is a STOP. Render **exactly one** gate, then **end your turn and wait for the user's reply** — do NOT render the next gate, multiple gates, or "the full flow, gate by gate" in a single message. Collapsing gates into one narrated pass erases the user's decision points (the entire value of the flow) and is a hard violation **even when you already have all the data to render them**. A gate's options only mean something if the user can actually answer before the next gate renders. This applies inside a gate too: the discovery picker is a turn-by-turn **walk**, one Area per turn (see build-flow.md § 7.3). Each render shows the **Area rail AND the current Area's questions together** (mirroring Spark's selected-tab-with-content) — the rail alone, with no questions under it (a bare index), is the *removed* failure mode. Render the rail + exactly ONE Area's questions, then STOP. Never render a second Area's questions or the Summary in the same message.
 
-- `references/build-flow.md` Step 7 transition lock — must NOT skip the Areas picker, must call `accept_discovery_questions` before `start_agentic_run`.
-- `references/build-flow.md` Step 7.3.1 rendering contract — Areas index has NO question previews, single numbering stream.
-- `references/build-flow.md` Step 7.4.5 fire-on-trigger — scope-classification gate is the contract, not a suggestion.
-- `references/build-flow.md` Step 9 action menu lock — blessed set is exactly `accept recommended` / `drop R{N}` / `drill R{N}` / `comment R{N}` / `pause` (+ `request admin review` for collaborators). NO freelance `dedupe` / `open the admin` / invented compound actions.
-- `references/build-flow.md` Step 9 rendering — use the server preview verbatim; no free-form summarization on top.
-- `references/resume-flow.md` § R2 picker rendering — ONE picker number per exploration; continuation prose indented; flat numbering across state buckets.
+**Single source of truth — this list POINTS, it does not RESTATE.** The detail of every rule below lives ONLY in the referenced file. This list names the authoritative sections and marks them HARD; it deliberately does **not** reproduce their shapes, option tokens, or values, because a restated rule drifts out of sync with its source. (That exact bug shipped on 2026-06-07: SKILL.md restated the Step 7 picker shape, the reference was rewritten, and the stale restatement won — the agent rendered the old picker.) So: **read the referenced section before executing that step, render it exactly as written, do not improvise or paraphrase it.** If you ever find the same rule stated in two places and they differ, the **referenced reference-file wins**, and the duplication is a bug to flag.
+
+Contract-strength rule sections currently in force (non-exhaustive):
+
+- `references/build-flow.md` **Step 7 transition lock + § 7.3 picker contract** — HARD. Render the discovery picker exactly as § 7.3 specifies (its shape, option tokens, and minimums — do not improvise it); commit picks via `accept_discovery_questions_batch` (one call across all Areas, never parallel per-Area) before `start_agentic_run`.
+- `references/build-flow.md` **Step 9 category-walk + action set** — HARD. Review recommendations one category per turn, rendering each rec's full content exactly as § 9 specifies; use exactly the three actions § 9 defines (refine-one / next-category / continue) and no others — no reject path, no freelance or invented actions, no free-form summarization on top. The refine action is a preview-then-apply flow; never persist an edit without the user accepting the previewed diff.
+- `references/resume-flow.md` **§ R2 picker rendering** — HARD. Render exactly as that section specifies.
 
 When you encounter a rule labeled with any of the marker words above, treat it the same way you'd treat a unit-test assertion: violating it is a regression, not a stylistic choice.
 
@@ -55,13 +57,14 @@ Parse the first token of the argument:
 | First token | Route to | One-liner |
 |---|---|---|
 | `build` | `references/build-flow.md` | Free-form problem → recommendations → build brief → code → sync. The full cycle. |
+| `lite` | `references/lite-flow.md` | Same pipeline as `build`, run fast/unattended — smaller discovery surface, fewer pauses (only the job+persona front gate and a non-blocking rec review). Use for small/well-scoped dev work, or when the coding agent triages minimal discovery. |
 | `resume` | `references/resume-flow.md` | "Pick up where I left off." Lists in-flight explorations with state badges and jumps to the right step. |
 | `lineage` | `references/lineage-flow.md` | Paste a file path (or set of paths); see every prior exploration / decision / deferral that touched those files. |
 | `context-pulse` | `references/context-pulse-flow.md` | Score readiness / context debt for a feature ask or exploration. Can seed a `CONTEXT-<feature>.md` file with relevant codebase + KG context that `/ritual build` picks up automatically. Also surfaces inline during build so the user watches debt drop. |
 | `status` | `references/status-flow.md` | Read-only mirror of the `ritual status` terminal CLI command (CLI 0.7.14+) for users who want a quick run-progress check inside the agent session instead of in a separate terminal. Calls `mcp__ritual__get_agentic_run` + renders the same run-first layout the CLI uses. |
 | (anything else, OR no subcommand) | default to `build` and treat the entire argument as the problem statement | |
 
-The Ritual CLI surface is intentionally narrow: `build`, `resume`, `lineage`, `context-pulse`, plus the read-only `status` mirror. Legacy exposed `explore`, `run`, `brief`, `gate`, `spec`, `questions`, `gherkin`, `recs` — all of which mapped 1:1 to MCP tool calls and provided no agent-CLI value over plain English. We don't replicate them; the agent can call any MCP tool directly when the user asks for "the recs on exp-X" or "decisions on file Y". (`/ritual recon` shipped briefly in PR #174 as a fifth command — retired because its unique value duplicated `/ritual resume` (workspace history) + `/ritual lineage` (decisions on files), and its non-duplicate parts (map repo, trace flow, explain file) are exactly what the agent does fluently in plain English without needing a SKILL-defined menu.)
+The Ritual CLI surface is intentionally narrow: `build`, `lite`, `resume`, `lineage`, `context-pulse`, plus the read-only `status` mirror. Legacy exposed `explore`, `run`, `brief`, `gate`, `spec`, `questions`, `gherkin`, `recs` — all of which mapped 1:1 to MCP tool calls and provided no agent-CLI value over plain English. We don't replicate them; the agent can call any MCP tool directly when the user asks for "the recs on exp-X" or "decisions on file Y". (`/ritual recon` shipped briefly in PR #174 as a fifth command — retired because its unique value duplicated `/ritual resume` (workspace history) + `/ritual lineage` (decisions on files), and its non-duplicate parts (map repo, trace flow, explain file) are exactly what the agent does fluently in plain English without needing a SKILL-defined menu.)
 
 
 ## Subcommand reference files
@@ -71,18 +74,18 @@ Load only the reference file needed for the selected subcommand:
 | Subcommand | Runtime file |
 |---|---|
 | `build` | `references/build-flow.md` |
+| `lite` | `references/lite-flow.md` |
 | `resume` | `references/resume-flow.md` |
 | `lineage` | `references/lineage-flow.md` |
 | `context-pulse` | `references/context-pulse-flow.md` |
 
 Additional runtime references:
 
-- `references/discovery-classification.md` — only when build question picking triggers scope classification
 - `references/scoring-fallback.md` — only if `mcp__ritual__score_context_pulse` is unavailable or errors
 
 ## Routing behavior
 
-- If the first token is one of the four subcommands, load the matching runtime file and follow it.
+- If the first token is one of the subcommands (`build`, `lite`, `resume`, `lineage`, `context-pulse`), load the matching runtime file and follow it.
 - If there is no subcommand or the token is unknown, default to `build` and treat the full argument as the problem statement.
 - If the user asks for retired or unsupported subcommands, answer in plain English and call the relevant MCP tool directly when appropriate; do not expand the slash-command surface.
 

package/skills/claude-code/ritual/manifest.json

@@ -39,11 +39,6 @@
     "lines": 357,
     "bytes": 25358
   },
-  {
-    "path": "references/discovery-classification.md",
-    "lines": 176,
-    "bytes": 10275
-  },
   {
     "path": "references/lineage-flow.md",
     "lines": 154,

package/skills/claude-code/ritual/references/async-polling.md

@@ -4,12 +4,12 @@ Use this for every long-running Ritual/MCP operation: discovery generation, agen
 
 ## Standard poll loop — single short sleep per turn, never escalate
 
-- **`Bash sleep 5` per poll iteration. Always 5. Never escalate.** Even if the operation has been running for minutes, the value stays `5`. The reason: the harness blocks "chained shorter sleeps" — successive `sleep N` calls across turns at increasing N (e.g. `sleep 5` → `sleep 15` → `sleep 20` → `sleep 25`) trip the same guard as `sleep 30+`. Treat the sleep duration as a constant, NOT a backoff knob.
-- **One sleep per turn**, not multiple in sequence. After `sleep 5`, take a fresh turn → call the status tool → decide continue or exit.
+- **A CONSTANT, non-escalating `Bash sleep` per poll iteration — sized to the operation.** Match the Spark UI's cadence so both surfaces observe the same job at the same rate: **`sleep 10`** for discovery-question generation (Spark polls every 10s), **`sleep 20`** for agentic-run polling (Spark polls every 20s), and `sleep 10` by default for any other status poll (requirements, build brief). Keep the value CONSTANT for the whole loop — **never escalate it** (e.g. `5` → `15` → `20` → `25`), because the harness blocks chained-increasing sleeps the same way it blocks `sleep ≥ 30`. The duration is a fixed per-operation constant, NOT a backoff knob. (All values are < 30 and non-escalating → guard-safe.)
+- **One sleep per turn**, not multiple in sequence. After the sleep, take a fresh turn → call the status tool → decide continue or exit.
 - **`sleep ≥ 30` is hard-blocked**, regardless of context.
-- **Do NOT use semicolons to chain** (`sleep 5; sleep 5`) — also blocked.
-- **The user sees progress every 5 seconds, total wall time is the same.** A slow operation taking 2 minutes is 24 turns of `sleep 5` + status, not 4 turns of `sleep 30`.
-- Print progress only when status/progress/current_step changes, or every ~3 polls (~15s) if unchanged.
+- **Do NOT use semicolons to chain** (`sleep 10; sleep 10`) — also blocked.
+- **Total wall time is the same** — a slow op taking 2 minutes is 12 turns of `sleep 10` + status, not 4 turns of `sleep 30`.
+- Print progress only when status/progress/current_step changes, or every ~2 polls (~20s) if unchanged.
 - Keep updates to one line unless an error occurs.
 
 ### Wrong vs right

package/skills/claude-code/ritual/references/brief-verification-checklist.md

@@ -4,7 +4,7 @@ Reference for `/ritual build` Step 10b.5 (the auto-fire verify-brief pass that r
 
 The brief generator runs server-side and **does not have repo access**. It writes assertions about cited files / functions / classes based on the agent's earlier recon summary — which is a text summary, not the actual code. When the brief says *"`is_allowed_to_see` is insufficient — needs token-based access"* but the code actually ships email-allowlist semantics, the contradiction is invisible to the brief generator and to the user reading the brief.
 
-Step 10b.5 closes this gap: **the agent (with repo access) reads the bodies of the specific symbols the brief cites and produces a structured list of findings before the user sees the brief.** Findings flow back into the brief via `refine_build_brief` if any contradictions are detected.
+Step 10b.5 closes this gap: **the agent (with repo access) reads the bodies of the specific symbols the brief cites and produces a structured list of findings before the user sees the brief.** Findings are written to a **separate** file (`BUILD-BRIEF-VERIFICATION.md`) and synced to Ritual's KG via `sync_brief_review` — they are **never** written back into `BUILD-BRIEF.md`. The brief stays the read-only historical artifact Ritual generated; the corrections reach the implementation through plan mode's KG `priorContext`, not through a brief rewrite. (There is **no** `refine_build_brief` tool — it was removed 2026-05-15 and replaced by `sync_brief_review`.)
 
 This is the **non-UI sibling of `references/ui-ux-checklist.md`** (Step 10.5 UX review). Same methodology shape (read brief → identify citations → find in repo → compare → fill schema → surface findings), different targets (functions / data shapes / model fields instead of UI components).
 
@@ -61,13 +61,18 @@ Three verdicts:
 - **`contradicted`** — the brief's claim is **wrong**. The code does something different. This is the verdict that drives a refinement.
 - **`not_found`** — the brief cited a symbol the agent could not locate in the repo. Either the symbol was renamed, deleted, or never existed. Either way: the brief is asserting against a phantom; surface to user.
 
+**Narrating a finding mid-verification — frame it as resolving drift, not as an error.** If you surface a `contradicted` / `not_found` finding in a progress line before the summary, lead with *resolving drift between the brief and the codebase*, then one plain sentence on the drift + where the real pattern lives. A caught gap is the verification doing its job, not a failure to alarm about — don't lead with "X doesn't exist" / "references a function that doesn't exist."
+
+- ❌ `get_core_apps is not in the codebase — the brief's RB-1 references a function that doesn't exist. The actual pattern is direct INSTALLED_APPS manipulation (index + replace), as seen in tests/settings.py.`
+- ✅ `Resolving drift between the brief and the codebase: RB-1 cites get_core_apps, but the repo edits INSTALLED_APPS directly (index + replace — see tests/settings.py). Noting it in the verification.`
+
 **5. Fill the output schema with evidence.**
 
 Write `BUILD-BRIEF-VERIFICATION.md` to disk alongside `BUILD-BRIEF.md`. Use the schema below. **Each finding cites the file + line range + the actual code snippet that justified the verdict.** The user reading this must be able to verify your verification — no hand-waving, no claims without evidence.
 
 **6. If any findings are `contradicted`, surface to the user inline at Step 10d.**
 
-The Step 10d gate normally reads *"Reply `go` to implement, `refine` for edits, `drill {N}` to inspect, `pause` to stop."* When `contradicted` findings exist, the gate's CTA shifts to highlight the contradictions:
+The Step 10d gate is `go` / `drill {N}` / `pause` (plus `ux-review`) — there is **no `refine` action**; the brief is read-only after generation. When `contradicted` findings exist, the gate prepends a summary so the user sees what the agent learned about the brief before deciding:
 
 ```text
 ⚠ Verification found {N} contradiction(s) between the brief and the actual code:
@@ -76,11 +81,12 @@ The Step 10d gate normally reads *"Reply `go` to implement, `refine` for edits,
     "{code_reality}" (see {cited_file}:{cited_lines}).
   · ...
 
-Reply `refine` to apply these corrections, `go` to proceed anyway,
-or `drill {N}` to inspect one rec.
+These are synced to Ritual; plan mode reads them when you `go`.
+Reply `go` to implement (corrections flow in via KG), `drill {N}` to
+inspect, or `pause` to stop.
 ```
 
-The user can `refine` (recommended) — at which point the SKILL calls `refine_build_brief` with the structured findings array, and the LLM produces an updated brief that incorporates the corrections authoritatively. Or `go` if the user has context the agent doesn't (e.g. "yes the brief is wrong but I want to ship it as-is for now"). The decision stays with the user; the agent surfaces the evidence.
+The findings do **not** rewrite the brief. They were already persisted via `sync_brief_review` (a durable `BriefReview` row) at step 5; when the user replies `go`, **plan mode reads the brief + that review via KG `priorContext`** and the implementation incorporates the corrections — without the brief text changing. If the user has context the agent doesn't ("yes the brief is wrong but ship as-is"), `go` proceeds the same way; the corrections are recorded regardless. The only path to *new brief content* is `generate_build_brief` with `force: true` (full regen from changed source data) — used when the underlying recs/requirements actually changed, never to patch a verification finding.
 
 ---
 
@@ -146,7 +152,7 @@ checked out, state that clearly.}
 
 - **Verify everything in the brief.** Only the symbol-citation slice. Pose-level claims, framing, and general direction are out of scope.
 - **Read the full file.** Read enough surrounding context to verify the symbol (~10 lines); not the whole file. Capped at ~15 citations total to keep this fast.
-- **Edit the brief directly.** Step 10b.5 only writes `BUILD-BRIEF-VERIFICATION.md`. The user decides whether to call `refine_build_brief` with the findings at Step 10d (recommended) or proceed with the brief as-is.
+- **Edit the brief directly.** Step 10b.5 only writes the **separate** `BUILD-BRIEF-VERIFICATION.md` and syncs it via `sync_brief_review`. `BUILD-BRIEF.md` is never touched — it stays the read-only historical artifact. Findings reach the implementation through plan mode's KG `priorContext` at Step 11, not through a brief rewrite. (Regenerating from changed source data is a different operation — `generate_build_brief` with `force: true` — not part of this step.)
 - **Persist findings to the KG.** Phase 1 is local-only. Phase 2 (filed at `memory/backlog_brief_verification_findings_kg_promotion.md`) adds the `BriefVerificationFinding` Prisma model + endpoint + priorContext injection so future briefs on overlapping files inherit verified facts.
 
 ---