mrvn-cli 0.3.5 → 0.3.6

package/dist/index.js

@@ -526,9 +526,24 @@ function resolvePersonaId(input4) {
 }
 
 // src/personas/prompt-builder.ts
-function buildSystemPrompt(persona, projectConfig, pluginPromptFragment, skillPromptFragment) {
+import * as fs4 from "fs";
+import * as path4 from "path";
+function buildSystemPrompt(persona, projectConfig, pluginPromptFragment, skillPromptFragment, marvinDir) {
   const parts = [];
   parts.push(persona.systemPrompt);
+  if (marvinDir) {
+    const claudeMdPath = path4.join(marvinDir, "CLAUDE.md");
+    try {
+      const content = fs4.readFileSync(claudeMdPath, "utf-8").trim();
+      if (content) {
+        parts.push(`
+## Project Instructions
+${content}
+`);
+      }
+    } catch {
+    }
+  }
   parts.push(`
 ## Project Context
 - **Project Name:** ${projectConfig.name}
@@ -1346,10 +1361,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path20) {
+  if (!path20)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path20.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1732,11 +1747,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path20, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path20);
     return iss;
   });
 }
@@ -1919,7 +1934,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path18 = []) => {
+  const processError = (error49, path20 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1929,7 +1944,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path20, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1961,8 +1976,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path20) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13939,13 +13954,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path20 = ref.slice(1).split("/").filter(Boolean);
+  if (path20.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path20[0] === defsKey) {
+    const key = path20[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14435,7 +14450,8 @@ function createDecisionTools(store) {
         title: external_exports.string().optional().describe("New title"),
         status: external_exports.string().optional().describe("New status"),
         content: external_exports.string().optional().describe("New content"),
-        owner: external_exports.string().optional().describe("New owner")
+        owner: external_exports.string().optional().describe("New owner"),
+        tags: external_exports.array(external_exports.string()).optional().describe("Replace tags (e.g. remove 'risk', add 'risk-mitigated')")
       },
       async (args) => {
         const { id, content, ...updates } = args;
@@ -14586,11 +14602,21 @@ function createActionTools(store) {
         owner: external_exports.string().optional().describe("New owner"),
         priority: external_exports.string().optional().describe("New priority"),
         dueDate: external_exports.string().optional().describe("Due date in ISO format (e.g. '2026-03-15')"),
+        tags: external_exports.array(external_exports.string()).optional().describe("Replace all tags. When provided with sprints, sprint tags are merged into this array."),
         sprints: external_exports.array(external_exports.string()).optional().describe("Sprint IDs to assign (replaces existing sprint tags). E.g. ['SP-001'].")
       },
       async (args) => {
-        const { id, content, sprints, ...updates } = args;
-        if (sprints !== void 0) {
+        const { id, content, sprints, tags, ...updates } = args;
+        if (tags !== void 0) {
+          const merged = [...tags];
+          if (sprints) {
+            for (const s of sprints) {
+              const tag = `sprint:${s}`;
+              if (!merged.includes(tag)) merged.push(tag);
+            }
+          }
+          updates.tags = merged;
+        } else if (sprints !== void 0) {
           const existing = store.get(id);
           if (!existing) {
             return {
@@ -14737,7 +14763,8 @@ function createQuestionTools(store) {
         title: external_exports.string().optional().describe("New title"),
         status: external_exports.string().optional().describe("New status (e.g. 'answered')"),
         content: external_exports.string().optional().describe("Updated content / answer"),
-        owner: external_exports.string().optional().describe("New owner")
+        owner: external_exports.string().optional().describe("New owner"),
+        tags: external_exports.array(external_exports.string()).optional().describe("Replace tags (e.g. remove 'risk', add 'risk-mitigated')")
       },
       async (args) => {
         const { id, content, ...updates } = args;
@@ -14995,7 +15022,7 @@ function collectGarMetrics(store) {
   );
   const openQuestions = store.list({ type: "question", status: "open" });
   const riskItems = allDocs.filter(
-    (d) => d.frontmatter.tags?.includes("risk")
+    (d) => d.frontmatter.tags?.includes("risk") && d.frontmatter.status !== "done" && d.frontmatter.status !== "closed"
   );
   const unownedActions = openActions.filter((d) => !d.frontmatter.owner);
   const total = allActions.length;
@@ -16978,7 +17005,7 @@ function createReportTools(store) {
       async () => {
         const allDocs = store.list();
         const taggedRisks = allDocs.filter(
-          (d) => d.frontmatter.tags?.includes("risk")
+          (d) => d.frontmatter.tags?.includes("risk") && d.frontmatter.status !== "done" && d.frontmatter.status !== "closed"
         );
         const highPriorityActions = store.list({ type: "action", status: "open" }).filter((d) => d.frontmatter.priority === "high");
         const unresolvedQuestions = store.list({ type: "question", status: "open" });
@@ -17349,7 +17376,8 @@ function createFeatureTools(store) {
         status: external_exports.enum(["draft", "approved", "deferred", "done"]).optional().describe("New status"),
         content: external_exports.string().optional().describe("New content"),
         owner: external_exports.string().optional().describe("New owner"),
-        priority: external_exports.enum(["critical", "high", "medium", "low"]).optional().describe("New priority")
+        priority: external_exports.enum(["critical", "high", "medium", "low"]).optional().describe("New priority"),
+        tags: external_exports.array(external_exports.string()).optional().describe("Replace tags (e.g. remove 'risk', add 'risk-mitigated')")
       },
       async (args) => {
         const { id, content, ...updates } = args;
@@ -17506,7 +17534,8 @@ function createEpicTools(store) {
         content: external_exports.string().optional().describe("New content"),
         owner: external_exports.string().optional().describe("New owner"),
         targetDate: external_exports.string().optional().describe("New target date"),
-        estimatedEffort: external_exports.string().optional().describe("New estimated effort")
+        estimatedEffort: external_exports.string().optional().describe("New estimated effort"),
+        tags: external_exports.array(external_exports.string()).optional().describe("Replace tags (e.g. remove 'risk', add 'risk-mitigated')")
       },
       async (args) => {
         const { id, content, ...updates } = args;
@@ -18787,8 +18816,8 @@ function createAemReportTools(store) {
 }
 
 // src/plugins/builtin/tools/aem-phase.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import * as YAML2 from "yaml";
 import { tool as tool18 } from "@anthropic-ai/claude-agent-sdk";
 var PHASES = ["assess-use-case", "assess-technology", "define-solution"];
@@ -18893,8 +18922,8 @@ function createAemPhaseTools(store, marvinDir) {
 function readPhase(marvinDir) {
   if (!marvinDir) return void 0;
   try {
-    const configPath = path4.join(marvinDir, "config.yaml");
-    const raw = fs4.readFileSync(configPath, "utf-8");
+    const configPath = path5.join(marvinDir, "config.yaml");
+    const raw = fs5.readFileSync(configPath, "utf-8");
     const config2 = YAML2.parse(raw);
     const aem = config2.aem;
     return aem?.currentPhase;
@@ -18904,14 +18933,14 @@ function readPhase(marvinDir) {
 }
 function writePhase(marvinDir, phase) {
   if (!marvinDir) return;
-  const configPath = path4.join(marvinDir, "config.yaml");
-  const raw = fs4.readFileSync(configPath, "utf-8");
+  const configPath = path5.join(marvinDir, "config.yaml");
+  const raw = fs5.readFileSync(configPath, "utf-8");
   const config2 = YAML2.parse(raw);
   if (!config2.aem) {
     config2.aem = {};
   }
   config2.aem.currentPhase = phase;
-  fs4.writeFileSync(configPath, YAML2.stringify(config2), "utf-8");
+  fs5.writeFileSync(configPath, YAML2.stringify(config2), "utf-8");
 }
 function getPhaseDescription(phase) {
   switch (phase) {
@@ -19079,8 +19108,8 @@ function getPluginPromptFragment(plugin, personaId) {
 }
 
 // src/skills/registry.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 import { fileURLToPath } from "url";
 import * as YAML3 from "yaml";
 import matter2 from "gray-matter";
@@ -19133,8 +19162,8 @@ var JiraClient = class {
     this.baseUrl = `https://${config2.host}/rest/api/2`;
     this.authHeader = "Basic " + Buffer.from(`${config2.email}:${config2.apiToken}`).toString("base64");
   }
-  async request(path18, method = "GET", body) {
-    const url2 = `${this.baseUrl}${path18}`;
+  async request(path20, method = "GET", body) {
+    const url2 = `${this.baseUrl}${path20}`;
     const headers = {
       Authorization: this.authHeader,
       "Content-Type": "application/json",
@@ -19148,7 +19177,7 @@ var JiraClient = class {
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       throw new Error(
-        `Jira API error ${response.status} ${method} ${path18}: ${text}`
+        `Jira API error ${response.status} ${method} ${path20}: ${text}`
       );
     }
     if (response.status === 204) return void 0;
@@ -19628,13 +19657,13 @@ var GOVERNANCE_TOOL_NAMES = [
 ];
 function getBuiltinSkillsDir() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path5.join(path5.dirname(thisFile), "builtin");
+  return path6.join(path6.dirname(thisFile), "builtin");
 }
 function loadSkillFromDirectory(dirPath) {
-  const skillMdPath = path5.join(dirPath, "SKILL.md");
-  if (!fs5.existsSync(skillMdPath)) return void 0;
+  const skillMdPath = path6.join(dirPath, "SKILL.md");
+  if (!fs6.existsSync(skillMdPath)) return void 0;
   try {
-    const raw = fs5.readFileSync(skillMdPath, "utf-8");
+    const raw = fs6.readFileSync(skillMdPath, "utf-8");
     const { data, content } = matter2(raw);
     if (!data.name || !data.description) return void 0;
     const metadata = data.metadata ?? {};
@@ -19645,13 +19674,13 @@ function loadSkillFromDirectory(dirPath) {
     if (wildcardPrompt) {
       promptFragments["*"] = wildcardPrompt;
     }
-    const personasDir = path5.join(dirPath, "personas");
-    if (fs5.existsSync(personasDir)) {
+    const personasDir = path6.join(dirPath, "personas");
+    if (fs6.existsSync(personasDir)) {
       try {
-        for (const file2 of fs5.readdirSync(personasDir)) {
+        for (const file2 of fs6.readdirSync(personasDir)) {
           if (!file2.endsWith(".md")) continue;
           const personaId = file2.replace(/\.md$/, "");
-          const personaPrompt = fs5.readFileSync(path5.join(personasDir, file2), "utf-8").trim();
+          const personaPrompt = fs6.readFileSync(path6.join(personasDir, file2), "utf-8").trim();
           if (personaPrompt) {
             promptFragments[personaId] = personaPrompt;
           }
@@ -19660,10 +19689,10 @@ function loadSkillFromDirectory(dirPath) {
       }
     }
     let actions;
-    const actionsPath = path5.join(dirPath, "actions.yaml");
-    if (fs5.existsSync(actionsPath)) {
+    const actionsPath = path6.join(dirPath, "actions.yaml");
+    if (fs6.existsSync(actionsPath)) {
       try {
-        const actionsRaw = fs5.readFileSync(actionsPath, "utf-8");
+        const actionsRaw = fs6.readFileSync(actionsPath, "utf-8");
         actions = YAML3.parse(actionsRaw);
       } catch {
       }
@@ -19690,10 +19719,10 @@ function loadAllSkills(marvinDir) {
   }
   try {
     const builtinDir = getBuiltinSkillsDir();
-    if (fs5.existsSync(builtinDir)) {
-      for (const entry of fs5.readdirSync(builtinDir)) {
-        const entryPath = path5.join(builtinDir, entry);
-        if (!fs5.statSync(entryPath).isDirectory()) continue;
+    if (fs6.existsSync(builtinDir)) {
+      for (const entry of fs6.readdirSync(builtinDir)) {
+        const entryPath = path6.join(builtinDir, entry);
+        if (!fs6.statSync(entryPath).isDirectory()) continue;
         if (skills.has(entry)) continue;
         const skill = loadSkillFromDirectory(entryPath);
         if (skill) skills.set(skill.id, skill);
@@ -19702,18 +19731,18 @@ function loadAllSkills(marvinDir) {
   } catch {
   }
   if (marvinDir) {
-    const skillsDir = path5.join(marvinDir, "skills");
-    if (fs5.existsSync(skillsDir)) {
+    const skillsDir = path6.join(marvinDir, "skills");
+    if (fs6.existsSync(skillsDir)) {
       let entries;
       try {
-        entries = fs5.readdirSync(skillsDir);
+        entries = fs6.readdirSync(skillsDir);
       } catch {
         entries = [];
       }
       for (const entry of entries) {
-        const entryPath = path5.join(skillsDir, entry);
+        const entryPath = path6.join(skillsDir, entry);
         try {
-          if (fs5.statSync(entryPath).isDirectory()) {
+          if (fs6.statSync(entryPath).isDirectory()) {
             const skill = loadSkillFromDirectory(entryPath);
             if (skill) skills.set(skill.id, skill);
             continue;
@@ -19723,7 +19752,7 @@ function loadAllSkills(marvinDir) {
         }
         if (!entry.endsWith(".yaml") && !entry.endsWith(".yml")) continue;
         try {
-          const raw = fs5.readFileSync(entryPath, "utf-8");
+          const raw = fs6.readFileSync(entryPath, "utf-8");
           const parsed = YAML3.parse(raw);
           if (!parsed?.id || !parsed?.name || !parsed?.version) continue;
           const skill = {
@@ -19828,12 +19857,12 @@ function getSkillAgentDefinitions(skillIds, allSkills) {
   return agents;
 }
 function migrateYamlToSkillMd(yamlPath, outputDir) {
-  const raw = fs5.readFileSync(yamlPath, "utf-8");
+  const raw = fs6.readFileSync(yamlPath, "utf-8");
   const parsed = YAML3.parse(raw);
   if (!parsed?.id || !parsed?.name) {
     throw new Error(`Invalid skill YAML: missing required fields (id, name)`);
   }
-  fs5.mkdirSync(outputDir, { recursive: true });
+  fs6.mkdirSync(outputDir, { recursive: true });
   const frontmatter = {
     name: parsed.id,
     description: parsed.description ?? ""
@@ -19847,15 +19876,15 @@ function migrateYamlToSkillMd(yamlPath, outputDir) {
   const skillMd = matter2.stringify(wildcardPrompt ? `
 ${wildcardPrompt}
 ` : "\n", frontmatter);
-  fs5.writeFileSync(path5.join(outputDir, "SKILL.md"), skillMd, "utf-8");
+  fs6.writeFileSync(path6.join(outputDir, "SKILL.md"), skillMd, "utf-8");
   if (promptFragments) {
     const personaKeys = Object.keys(promptFragments).filter((k) => k !== "*");
     if (personaKeys.length > 0) {
-      const personasDir = path5.join(outputDir, "personas");
-      fs5.mkdirSync(personasDir, { recursive: true });
+      const personasDir = path6.join(outputDir, "personas");
+      fs6.mkdirSync(personasDir, { recursive: true });
       for (const personaId of personaKeys) {
-        fs5.writeFileSync(
-          path5.join(personasDir, `${personaId}.md`),
+        fs6.writeFileSync(
+          path6.join(personasDir, `${personaId}.md`),
           `${promptFragments[personaId]}
 `,
           "utf-8"
@@ -19865,8 +19894,8 @@ ${wildcardPrompt}
   }
   const actions = parsed.actions;
   if (actions && actions.length > 0) {
-    fs5.writeFileSync(
-      path5.join(outputDir, "actions.yaml"),
+    fs6.writeFileSync(
+      path6.join(outputDir, "actions.yaml"),
       YAML3.stringify(actions),
       "utf-8"
     );
@@ -20109,8 +20138,8 @@ function createMarvinMcpServer(store, options) {
 }
 
 // src/agent/session.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 import * as readline from "readline";
 import chalk from "chalk";
 import ora from "ora";
@@ -20119,13 +20148,13 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/storage/session-store.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import * as YAML4 from "yaml";
 var SessionStore = class {
   filePath;
   constructor(marvinDir) {
-    this.filePath = path6.join(marvinDir, "sessions.yaml");
+    this.filePath = path7.join(marvinDir, "sessions.yaml");
   }
   list() {
     const entries = this.load();
@@ -20166,9 +20195,9 @@ var SessionStore = class {
     this.write(entries);
   }
   load() {
-    if (!fs6.existsSync(this.filePath)) return [];
+    if (!fs7.existsSync(this.filePath)) return [];
     try {
-      const raw = fs6.readFileSync(this.filePath, "utf-8");
+      const raw = fs7.readFileSync(this.filePath, "utf-8");
       const parsed = YAML4.parse(raw);
       if (!Array.isArray(parsed)) return [];
       return parsed;
@@ -20177,11 +20206,11 @@ var SessionStore = class {
     }
   }
   write(entries) {
-    const dir = path6.dirname(this.filePath);
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
+    const dir = path7.dirname(this.filePath);
+    if (!fs7.existsSync(dir)) {
+      fs7.mkdirSync(dir, { recursive: true });
     }
-    fs6.writeFileSync(this.filePath, YAML4.stringify(entries), "utf-8");
+    fs7.writeFileSync(this.filePath, YAML4.stringify(entries), "utf-8");
   }
 };
 
@@ -20217,8 +20246,8 @@ function slugify3(text) {
 }
 
 // src/sources/manifest.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import * as crypto from "crypto";
 import * as YAML5 from "yaml";
 var MANIFEST_FILE = ".manifest.yaml";
@@ -20231,37 +20260,37 @@ var SourceManifestManager = class {
   manifestPath;
   sourcesDir;
   constructor(marvinDir) {
-    this.sourcesDir = path7.join(marvinDir, "sources");
-    this.manifestPath = path7.join(this.sourcesDir, MANIFEST_FILE);
+    this.sourcesDir = path8.join(marvinDir, "sources");
+    this.manifestPath = path8.join(this.sourcesDir, MANIFEST_FILE);
     this.manifest = this.load();
   }
   load() {
-    if (!fs7.existsSync(this.manifestPath)) {
+    if (!fs8.existsSync(this.manifestPath)) {
       return emptyManifest();
     }
-    const raw = fs7.readFileSync(this.manifestPath, "utf-8");
+    const raw = fs8.readFileSync(this.manifestPath, "utf-8");
     const parsed = YAML5.parse(raw);
     return parsed ?? emptyManifest();
   }
   save() {
-    fs7.mkdirSync(this.sourcesDir, { recursive: true });
-    fs7.writeFileSync(this.manifestPath, YAML5.stringify(this.manifest), "utf-8");
+    fs8.mkdirSync(this.sourcesDir, { recursive: true });
+    fs8.writeFileSync(this.manifestPath, YAML5.stringify(this.manifest), "utf-8");
   }
   scan() {
     const added = [];
     const changed = [];
     const removed = [];
-    if (!fs7.existsSync(this.sourcesDir)) {
+    if (!fs8.existsSync(this.sourcesDir)) {
       return { added, changed, removed };
     }
     const onDisk = new Set(
-      fs7.readdirSync(this.sourcesDir).filter((f) => {
-        const ext = path7.extname(f).toLowerCase();
+      fs8.readdirSync(this.sourcesDir).filter((f) => {
+        const ext = path8.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.includes(ext);
       })
     );
     for (const fileName of onDisk) {
-      const filePath = path7.join(this.sourcesDir, fileName);
+      const filePath = path8.join(this.sourcesDir, fileName);
       const hash2 = this.hashFile(filePath);
       const existing = this.manifest.files[fileName];
       if (!existing) {
@@ -20324,7 +20353,7 @@ var SourceManifestManager = class {
     this.save();
   }
   hashFile(filePath) {
-    const content = fs7.readFileSync(filePath);
+    const content = fs8.readFileSync(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
   }
 };
@@ -20339,8 +20368,8 @@ async function startSession(options) {
   const skillRegistrations = collectSkillRegistrations(skillIds, allSkills);
   const store = new DocumentStore(marvinDir, [...pluginRegistrations, ...skillRegistrations]);
   const sessionStore = new SessionStore(marvinDir);
-  const sourcesDir = path8.join(marvinDir, "sources");
-  const hasSourcesDir = fs8.existsSync(sourcesDir);
+  const sourcesDir = path9.join(marvinDir, "sources");
+  const hasSourcesDir = fs9.existsSync(sourcesDir);
   const manifest = hasSourcesDir ? new SourceManifestManager(marvinDir) : void 0;
   const pluginTools = plugin ? getPluginTools(plugin, store, marvinDir) : [];
   const pluginPromptFragment = plugin ? getPluginPromptFragment(plugin, persona.id) : void 0;
@@ -20363,7 +20392,7 @@ async function startSession(options) {
     projectName: config2.project.name,
     navGroups
   });
-  const systemPrompt = buildSystemPrompt(persona, config2.project, pluginPromptFragment, skillPromptFragment);
+  const systemPrompt = buildSystemPrompt(persona, config2.project, pluginPromptFragment, skillPromptFragment, marvinDir);
   let existingSession;
   if (options.sessionName) {
     existingSession = sessionStore.get(options.sessionName);
@@ -20549,8 +20578,8 @@ Session ended with error: ${message.subtype}`));
 }
 
 // src/mcp/stdio-server.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -20848,8 +20877,8 @@ function collectTools(marvinDir) {
   const plugin = resolvePlugin(config2.methodology);
   const registrations = plugin?.documentTypeRegistrations ?? [];
   const store = new DocumentStore(marvinDir, registrations);
-  const sourcesDir = path9.join(marvinDir, "sources");
-  const hasSourcesDir = fs9.existsSync(sourcesDir);
+  const sourcesDir = path10.join(marvinDir, "sources");
+  const hasSourcesDir = fs10.existsSync(sourcesDir);
   const manifest = hasSourcesDir ? new SourceManifestManager(marvinDir) : void 0;
   const pluginTools = plugin ? getPluginTools(plugin, store, marvinDir) : [];
   const sessionStore = new SessionStore(marvinDir);
@@ -20857,7 +20886,7 @@ function collectTools(marvinDir) {
   const allSkillIds = [...allSkills.keys()];
   const codeSkillTools = getSkillTools(allSkillIds, allSkills, store);
   const skillsWithActions = allSkillIds.map((id) => allSkills.get(id)).filter((s) => s.actions && s.actions.length > 0);
-  const projectRoot = path9.dirname(marvinDir);
+  const projectRoot = path10.dirname(marvinDir);
   const actionTools = createSkillActionTools(skillsWithActions, { store, marvinDir, projectRoot });
   return [
     ...createDecisionTools(store),
@@ -20917,11 +20946,63 @@ async function startStdioServer(options) {
 import { Command } from "commander";
 
 // src/cli/commands/init.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 import * as YAML6 from "yaml";
 import chalk2 from "chalk";
 import { input, confirm, select } from "@inquirer/prompts";
+
+// src/templates/claude-md.ts
+function getDefaultClaudeMdContent(projectName) {
+  return `# Marvin \u2014 Project Instructions for "${projectName}"
+
+You are **Marvin**, an AI-powered product development assistant.
+You operate as one of three personas \u2014 stay in role and suggest switching when a question falls outside your scope.
+
+## Personas
+
+| Persona | Short | Focus |
+|---------|-------|-------|
+| Product Owner | po | Vision, backlog, requirements, features, acceptance criteria |
+| Delivery Manager | dm | Planning, risks, actions, timelines, sprints, status |
+| Tech Lead | tl | Architecture, trade-offs, technical decisions, code quality |
+
+## Proactive Governance
+
+When conversation implies a commitment, risk, or open question, **suggest creating the matching artifact**:
+- A decision was made \u2192 offer to create a **Decision (D-xxx)**
+- Someone committed to a task \u2192 offer an **Action (A-xxx)** with owner and due date
+- An unanswered question surfaced \u2192 offer a **Question (Q-xxx)**
+- A new capability is discussed \u2192 offer a **Feature (F-xxx)**
+- Implementation scope is agreed \u2192 offer an **Epic (E-xxx)** linked to a feature
+- Work is being time-boxed \u2192 offer a **Sprint (SP-xxx)**
+
+## Insights
+
+Proactively flag:
+- Overdue actions or unresolved questions
+- Decisions without rationale or linked features
+- Features without linked epics
+- Risks mentioned but not tracked
+- When a risk is resolved \u2192 remove the "risk" tag and add "risk-mitigated"
+
+## Tool Usage
+
+- **Search before creating** \u2014 avoid duplicate artifacts
+- **Reference IDs** (e.g. D-001, A-003) when discussing existing items
+- **Link artifacts** \u2014 epics to features, actions to decisions, etc.
+- Use \`search_documents\` to find related context before answering
+
+## Communication Style
+
+- Be concise and structured
+- State assumptions explicitly
+- Use bullet points and tables where they aid clarity
+- When uncertain, ask a clarifying question rather than guessing
+`;
+}
+
+// src/cli/commands/init.ts
 async function initCommand() {
   const cwd = process.cwd();
   if (isMarvinProject(cwd)) {
@@ -20932,7 +21013,7 @@ async function initCommand() {
   }
   const projectName = await input({
     message: "Project name:",
-    default: path10.basename(cwd)
+    default: path11.basename(cwd)
   });
   const methodology = await select({
     message: "Methodology:",
@@ -20944,21 +21025,21 @@ async function initCommand() {
   });
   const plugin = resolvePlugin(methodology);
   const registrations = plugin?.documentTypeRegistrations ?? [];
-  const marvinDir = path10.join(cwd, ".marvin");
+  const marvinDir = path11.join(cwd, ".marvin");
   const dirs = [
     marvinDir,
-    path10.join(marvinDir, "templates"),
-    path10.join(marvinDir, "docs", "decisions"),
-    path10.join(marvinDir, "docs", "actions"),
-    path10.join(marvinDir, "docs", "questions"),
-    path10.join(marvinDir, "sources"),
-    path10.join(marvinDir, "skills")
+    path11.join(marvinDir, "templates"),
+    path11.join(marvinDir, "docs", "decisions"),
+    path11.join(marvinDir, "docs", "actions"),
+    path11.join(marvinDir, "docs", "questions"),
+    path11.join(marvinDir, "sources"),
+    path11.join(marvinDir, "skills")
   ];
   for (const reg of registrations) {
-    dirs.push(path10.join(marvinDir, "docs", reg.dirName));
+    dirs.push(path11.join(marvinDir, "docs", reg.dirName));
   }
   for (const dir of dirs) {
-    fs10.mkdirSync(dir, { recursive: true });
+    fs11.mkdirSync(dir, { recursive: true });
   }
   const config2 = {
     name: projectName,
@@ -20972,16 +21053,22 @@ async function initCommand() {
   if (methodology === "sap-aem") {
     config2.aem = { currentPhase: "assess-use-case" };
   }
-  fs10.writeFileSync(
-    path10.join(marvinDir, "config.yaml"),
+  fs11.writeFileSync(
+    path11.join(marvinDir, "config.yaml"),
     YAML6.stringify(config2),
     "utf-8"
   );
+  fs11.writeFileSync(
+    path11.join(marvinDir, "CLAUDE.md"),
+    getDefaultClaudeMdContent(projectName),
+    "utf-8"
+  );
   console.log(chalk2.green(`
 Initialized Marvin project "${projectName}" in ${cwd}`));
   console.log(chalk2.dim(`Methodology: ${plugin?.name ?? methodology}`));
   console.log(chalk2.dim("\nCreated:"));
   console.log(chalk2.dim("  .marvin/config.yaml"));
+  console.log(chalk2.dim("  .marvin/CLAUDE.md"));
   console.log(chalk2.dim("  .marvin/docs/decisions/"));
   console.log(chalk2.dim("  .marvin/docs/actions/"));
   console.log(chalk2.dim("  .marvin/docs/questions/"));
@@ -20999,18 +21086,18 @@ Initialized Marvin project "${projectName}" in ${cwd}`));
     const sourceDir = await input({
       message: "Path to directory containing source documents:"
     });
-    const resolvedDir = path10.resolve(sourceDir);
-    if (fs10.existsSync(resolvedDir) && fs10.statSync(resolvedDir).isDirectory()) {
+    const resolvedDir = path11.resolve(sourceDir);
+    if (fs11.existsSync(resolvedDir) && fs11.statSync(resolvedDir).isDirectory()) {
       const sourceExts = [".pdf", ".md", ".txt"];
-      const files = fs10.readdirSync(resolvedDir).filter((f) => {
-        const ext = path10.extname(f).toLowerCase();
+      const files = fs11.readdirSync(resolvedDir).filter((f) => {
+        const ext = path11.extname(f).toLowerCase();
         return sourceExts.includes(ext);
       });
       let copied = 0;
       for (const file2 of files) {
-        const src = path10.join(resolvedDir, file2);
-        const dest = path10.join(marvinDir, "sources", file2);
-        fs10.copyFileSync(src, dest);
+        const src = path11.join(resolvedDir, file2);
+        const dest = path11.join(marvinDir, "sources", file2);
+        fs11.copyFileSync(src, dest);
         copied++;
       }
       if (copied > 0) {
@@ -21300,13 +21387,13 @@ async function setApiKey() {
 }
 
 // src/cli/commands/ingest.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 import chalk8 from "chalk";
 
 // src/sources/ingest.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs12 from "fs";
+import * as path12 from "path";
 import chalk7 from "chalk";
 import ora2 from "ora";
 import { query as query4 } from "@anthropic-ai/claude-agent-sdk";
@@ -21409,15 +21496,15 @@ async function ingestFile(options) {
   const persona = getPersona(personaId);
   const manifest = new SourceManifestManager(marvinDir);
   const sourcesDir = manifest.sourcesDir;
-  const filePath = path11.join(sourcesDir, fileName);
-  if (!fs11.existsSync(filePath)) {
+  const filePath = path12.join(sourcesDir, fileName);
+  if (!fs12.existsSync(filePath)) {
     throw new Error(`Source file not found: ${filePath}`);
   }
-  const ext = path11.extname(fileName).toLowerCase();
+  const ext = path12.extname(fileName).toLowerCase();
   const isPdf = ext === ".pdf";
   let fileContent = null;
   if (!isPdf) {
-    fileContent = fs11.readFileSync(filePath, "utf-8");
+    fileContent = fs12.readFileSync(filePath, "utf-8");
   }
   const store = new DocumentStore(marvinDir);
   const createdArtifacts = [];
@@ -21520,9 +21607,9 @@ Ingest ended with error: ${message.subtype}`)
 async function ingestCommand(file2, options) {
   const project = loadProject();
   const marvinDir = project.marvinDir;
-  const sourcesDir = path12.join(marvinDir, "sources");
-  if (!fs12.existsSync(sourcesDir)) {
-    fs12.mkdirSync(sourcesDir, { recursive: true });
+  const sourcesDir = path13.join(marvinDir, "sources");
+  if (!fs13.existsSync(sourcesDir)) {
+    fs13.mkdirSync(sourcesDir, { recursive: true });
   }
   const manifest = new SourceManifestManager(marvinDir);
   manifest.scan();
@@ -21533,8 +21620,8 @@ async function ingestCommand(file2, options) {
     return;
   }
   if (file2) {
-    const filePath = path12.join(sourcesDir, file2);
-    if (!fs12.existsSync(filePath)) {
+    const filePath = path13.join(sourcesDir, file2);
+    if (!fs13.existsSync(filePath)) {
       console.log(chalk8.red(`Source file not found: ${file2}`));
       console.log(chalk8.dim(`Expected at: ${filePath}`));
       console.log(chalk8.dim(`Drop files into .marvin/sources/ and try again.`));
@@ -21601,7 +21688,7 @@ import ora3 from "ora";
 import { input as input3 } from "@inquirer/prompts";
 
 // src/git/repository.ts
-import * as path13 from "path";
+import * as path14 from "path";
 import simpleGit from "simple-git";
 var MARVIN_GITIGNORE = `node_modules/
 .DS_Store
@@ -21621,7 +21708,7 @@ var DIR_TYPE_LABELS = {
 function buildCommitMessage(files) {
   const counts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const parts2 = f.split(path13.sep).join("/").split("/");
+    const parts2 = f.split(path14.sep).join("/").split("/");
     const docsIdx = parts2.indexOf("docs");
     if (docsIdx !== -1 && docsIdx + 1 < parts2.length) {
       const dirName = parts2[docsIdx + 1];
@@ -21661,9 +21748,9 @@ var MarvinGit = class {
       );
     }
     await this.git.init();
-    const { writeFileSync: writeFileSync9 } = await import("fs");
-    writeFileSync9(
-      path13.join(this.marvinDir, ".gitignore"),
+    const { writeFileSync: writeFileSync10 } = await import("fs");
+    writeFileSync10(
+      path14.join(this.marvinDir, ".gitignore"),
       MARVIN_GITIGNORE,
       "utf-8"
     );
@@ -21783,9 +21870,9 @@ var MarvinGit = class {
     }
   }
   static async clone(url2, targetDir) {
-    const marvinDir = path13.join(targetDir, ".marvin");
-    const { existsSync: existsSync16 } = await import("fs");
-    if (existsSync16(marvinDir)) {
+    const marvinDir = path14.join(targetDir, ".marvin");
+    const { existsSync: existsSync17 } = await import("fs");
+    if (existsSync17(marvinDir)) {
       throw new GitSyncError(
         `.marvin/ already exists at ${targetDir}. Remove it first or choose a different directory.`
       );
@@ -21969,8 +22056,8 @@ async function serveCommand() {
 }
 
 // src/cli/commands/skills.ts
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 import * as YAML7 from "yaml";
 import matter3 from "gray-matter";
 import chalk10 from "chalk";
@@ -22076,14 +22163,14 @@ async function skillsRemoveCommand(skillId, options) {
 }
 async function skillsCreateCommand(name) {
   const project = loadProject();
-  const skillsDir = path14.join(project.marvinDir, "skills");
-  fs13.mkdirSync(skillsDir, { recursive: true });
-  const skillDir = path14.join(skillsDir, name);
-  if (fs13.existsSync(skillDir)) {
+  const skillsDir = path15.join(project.marvinDir, "skills");
+  fs14.mkdirSync(skillsDir, { recursive: true });
+  const skillDir = path15.join(skillsDir, name);
+  if (fs14.existsSync(skillDir)) {
     console.log(chalk10.yellow(`Skill directory already exists: ${skillDir}`));
     return;
   }
-  fs13.mkdirSync(skillDir, { recursive: true });
+  fs14.mkdirSync(skillDir, { recursive: true });
   const displayName = name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
   const frontmatter = {
     name,
@@ -22097,7 +22184,7 @@ async function skillsCreateCommand(name) {
 You have the **${displayName}** skill.
 `;
   const skillMd = matter3.stringify(body, frontmatter);
-  fs13.writeFileSync(path14.join(skillDir, "SKILL.md"), skillMd, "utf-8");
+  fs14.writeFileSync(path15.join(skillDir, "SKILL.md"), skillMd, "utf-8");
   const actions = [
     {
       id: "run",
@@ -22107,7 +22194,7 @@ You have the **${displayName}** skill.
       maxTurns: 5
     }
   ];
-  fs13.writeFileSync(path14.join(skillDir, "actions.yaml"), YAML7.stringify(actions), "utf-8");
+  fs14.writeFileSync(path15.join(skillDir, "actions.yaml"), YAML7.stringify(actions), "utf-8");
   console.log(chalk10.green(`Created skill: ${skillDir}/`));
   console.log(chalk10.dim("  SKILL.md      \u2014 skill definition and prompt"));
   console.log(chalk10.dim("  actions.yaml  \u2014 action definitions"));
@@ -22115,14 +22202,14 @@ You have the **${displayName}** skill.
 }
 async function skillsMigrateCommand() {
   const project = loadProject();
-  const skillsDir = path14.join(project.marvinDir, "skills");
-  if (!fs13.existsSync(skillsDir)) {
+  const skillsDir = path15.join(project.marvinDir, "skills");
+  if (!fs14.existsSync(skillsDir)) {
     console.log(chalk10.dim("No skills directory found."));
     return;
   }
   let entries;
   try {
-    entries = fs13.readdirSync(skillsDir);
+    entries = fs14.readdirSync(skillsDir);
   } catch {
     console.log(chalk10.red("Could not read skills directory."));
     return;
@@ -22134,16 +22221,16 @@ async function skillsMigrateCommand() {
   }
   let migrated = 0;
   for (const file2 of yamlFiles) {
-    const yamlPath = path14.join(skillsDir, file2);
+    const yamlPath = path15.join(skillsDir, file2);
     const baseName = file2.replace(/\.(yaml|yml)$/, "");
-    const outputDir = path14.join(skillsDir, baseName);
-    if (fs13.existsSync(outputDir)) {
+    const outputDir = path15.join(skillsDir, baseName);
+    if (fs14.existsSync(outputDir)) {
       console.log(chalk10.yellow(`Skipping "${file2}" \u2014 directory "${baseName}/" already exists.`));
       continue;
     }
     try {
       migrateYamlToSkillMd(yamlPath, outputDir);
-      fs13.renameSync(yamlPath, `${yamlPath}.bak`);
+      fs14.renameSync(yamlPath, `${yamlPath}.bak`);
       console.log(chalk10.green(`Migrated "${file2}" \u2192 "${baseName}/"`));
       migrated++;
     } catch (err) {
@@ -22157,35 +22244,35 @@ ${migrated} skill(s) migrated. Original files renamed to *.bak`));
 }
 
 // src/cli/commands/import.ts
-import * as fs16 from "fs";
-import * as path17 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 import chalk11 from "chalk";
 
 // src/import/engine.ts
-import * as fs15 from "fs";
-import * as path16 from "path";
+import * as fs16 from "fs";
+import * as path17 from "path";
 import matter5 from "gray-matter";
 
 // src/import/classifier.ts
-import * as fs14 from "fs";
-import * as path15 from "path";
+import * as fs15 from "fs";
+import * as path16 from "path";
 import matter4 from "gray-matter";
 var RAW_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".pdf", ".txt"]);
 var CORE_DIR_NAMES = /* @__PURE__ */ new Set(["decisions", "actions", "questions"]);
 var ID_PATTERN = /^[A-Z]+-\d{3,}$/;
 function classifyPath(inputPath, knownTypes, knownDirNames) {
-  const resolved = path15.resolve(inputPath);
-  const stat = fs14.statSync(resolved);
+  const resolved = path16.resolve(inputPath);
+  const stat = fs15.statSync(resolved);
   if (!stat.isDirectory()) {
     return classifyFile(resolved, knownTypes);
   }
-  if (path15.basename(resolved) === ".marvin" || fs14.existsSync(path15.join(resolved, "config.yaml"))) {
+  if (path16.basename(resolved) === ".marvin" || fs15.existsSync(path16.join(resolved, "config.yaml"))) {
     return { type: "marvin-project", inputPath: resolved };
   }
   const allDirNames = /* @__PURE__ */ new Set([...CORE_DIR_NAMES, ...knownDirNames]);
-  const entries = fs14.readdirSync(resolved);
+  const entries = fs15.readdirSync(resolved);
   const hasDocSubdirs = entries.some(
-    (e) => allDirNames.has(e) && fs14.statSync(path15.join(resolved, e)).isDirectory()
+    (e) => allDirNames.has(e) && fs15.statSync(path16.join(resolved, e)).isDirectory()
   );
   if (hasDocSubdirs) {
     return { type: "docs-directory", inputPath: resolved };
@@ -22194,7 +22281,7 @@ function classifyPath(inputPath, knownTypes, knownDirNames) {
   if (mdFiles.length > 0) {
     const hasMarvinDocs = mdFiles.some((f) => {
       try {
-        const raw = fs14.readFileSync(path15.join(resolved, f), "utf-8");
+        const raw = fs15.readFileSync(path16.join(resolved, f), "utf-8");
         const { data } = matter4(raw);
         return isValidMarvinDocument(data, knownTypes);
       } catch {
@@ -22208,14 +22295,14 @@ function classifyPath(inputPath, knownTypes, knownDirNames) {
   return { type: "raw-source-dir", inputPath: resolved };
 }
 function classifyFile(filePath, knownTypes) {
-  const resolved = path15.resolve(filePath);
-  const ext = path15.extname(resolved).toLowerCase();
+  const resolved = path16.resolve(filePath);
+  const ext = path16.extname(resolved).toLowerCase();
   if (RAW_SOURCE_EXTENSIONS.has(ext)) {
     return { type: "raw-source-file", inputPath: resolved };
   }
   if (ext === ".md") {
     try {
-      const raw = fs14.readFileSync(resolved, "utf-8");
+      const raw = fs15.readFileSync(resolved, "utf-8");
       const { data } = matter4(raw);
       if (isValidMarvinDocument(data, knownTypes)) {
         return { type: "marvin-document", inputPath: resolved };
@@ -22340,9 +22427,9 @@ function executeImportPlan(plan, store, marvinDir, options) {
       continue;
     }
     if (item.action === "copy") {
-      const targetDir = path16.dirname(item.targetPath);
-      fs15.mkdirSync(targetDir, { recursive: true });
-      fs15.copyFileSync(item.sourcePath, item.targetPath);
+      const targetDir = path17.dirname(item.targetPath);
+      fs16.mkdirSync(targetDir, { recursive: true });
+      fs16.copyFileSync(item.sourcePath, item.targetPath);
       copied++;
       continue;
     }
@@ -22378,19 +22465,19 @@ function formatPlanSummary(plan) {
     lines.push(`Documents to import: ${imports.length}`);
     for (const item of imports) {
       const idInfo = item.originalId !== item.newId ? `${item.originalId} \u2192 ${item.newId}` : item.newId ?? item.originalId ?? "";
-      lines.push(`  ${idInfo}  ${path16.basename(item.sourcePath)}`);
+      lines.push(`  ${idInfo}  ${path17.basename(item.sourcePath)}`);
     }
   }
   if (copies.length > 0) {
     lines.push(`Files to copy to sources/: ${copies.length}`);
     for (const item of copies) {
-      lines.push(`  ${path16.basename(item.sourcePath)} \u2192 ${path16.basename(item.targetPath)}`);
+      lines.push(`  ${path17.basename(item.sourcePath)} \u2192 ${path17.basename(item.targetPath)}`);
     }
   }
   if (skips.length > 0) {
     lines.push(`Skipped (conflict): ${skips.length}`);
     for (const item of skips) {
-      lines.push(`  ${item.originalId ?? path16.basename(item.sourcePath)}  ${item.reason ?? ""}`);
+      lines.push(`  ${item.originalId ?? path17.basename(item.sourcePath)}  ${item.reason ?? ""}`);
     }
   }
   if (plan.items.length === 0) {
@@ -22423,11 +22510,11 @@ function getDirNameForType(store, type) {
 }
 function collectMarvinDocs(dir, knownTypes) {
   const docs = [];
-  const files = fs15.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  const files = fs16.readdirSync(dir).filter((f) => f.endsWith(".md"));
   for (const file2 of files) {
-    const filePath = path16.join(dir, file2);
+    const filePath = path17.join(dir, file2);
     try {
-      const raw = fs15.readFileSync(filePath, "utf-8");
+      const raw = fs16.readFileSync(filePath, "utf-8");
       const { data, content } = matter5(raw);
       if (isValidMarvinDocument(data, knownTypes)) {
         docs.push({
@@ -22483,23 +22570,23 @@ function planDocImports(docs, store, options) {
 }
 function planFromMarvinProject(classification, store, _marvinDir, options) {
   let projectDir = classification.inputPath;
-  if (path16.basename(projectDir) !== ".marvin") {
-    const inner = path16.join(projectDir, ".marvin");
-    if (fs15.existsSync(inner)) {
+  if (path17.basename(projectDir) !== ".marvin") {
+    const inner = path17.join(projectDir, ".marvin");
+    if (fs16.existsSync(inner)) {
       projectDir = inner;
     }
   }
-  const docsDir = path16.join(projectDir, "docs");
-  if (!fs15.existsSync(docsDir)) {
+  const docsDir = path17.join(projectDir, "docs");
+  if (!fs16.existsSync(docsDir)) {
     return [];
   }
   const knownTypes = store.registeredTypes;
   const allDocs = [];
-  const subdirs = fs15.readdirSync(docsDir).filter(
-    (d) => fs15.statSync(path16.join(docsDir, d)).isDirectory()
+  const subdirs = fs16.readdirSync(docsDir).filter(
+    (d) => fs16.statSync(path17.join(docsDir, d)).isDirectory()
   );
   for (const subdir of subdirs) {
-    const docs = collectMarvinDocs(path16.join(docsDir, subdir), knownTypes);
+    const docs = collectMarvinDocs(path17.join(docsDir, subdir), knownTypes);
     allDocs.push(...docs);
   }
   return planDocImports(allDocs, store, options);
@@ -22509,10 +22596,10 @@ function planFromDocsDirectory(classification, store, _marvinDir, options) {
   const knownTypes = store.registeredTypes;
   const allDocs = [];
   allDocs.push(...collectMarvinDocs(dir, knownTypes));
-  const entries = fs15.readdirSync(dir);
+  const entries = fs16.readdirSync(dir);
   for (const entry of entries) {
-    const entryPath = path16.join(dir, entry);
-    if (fs15.statSync(entryPath).isDirectory()) {
+    const entryPath = path17.join(dir, entry);
+    if (fs16.statSync(entryPath).isDirectory()) {
       allDocs.push(...collectMarvinDocs(entryPath, knownTypes));
     }
   }
@@ -22521,7 +22608,7 @@ function planFromDocsDirectory(classification, store, _marvinDir, options) {
 function planFromSingleDocument(classification, store, _marvinDir, options) {
   const filePath = classification.inputPath;
   const knownTypes = store.registeredTypes;
-  const raw = fs15.readFileSync(filePath, "utf-8");
+  const raw = fs16.readFileSync(filePath, "utf-8");
   const { data, content } = matter5(raw);
   if (!isValidMarvinDocument(data, knownTypes)) {
     return [];
@@ -22537,14 +22624,14 @@ function planFromSingleDocument(classification, store, _marvinDir, options) {
 }
 function planFromRawSourceDir(classification, marvinDir) {
   const dir = classification.inputPath;
-  const sourcesDir = path16.join(marvinDir, "sources");
+  const sourcesDir = path17.join(marvinDir, "sources");
   const items = [];
-  const files = fs15.readdirSync(dir).filter((f) => {
-    const stat = fs15.statSync(path16.join(dir, f));
+  const files = fs16.readdirSync(dir).filter((f) => {
+    const stat = fs16.statSync(path17.join(dir, f));
     return stat.isFile();
   });
   for (const file2 of files) {
-    const sourcePath = path16.join(dir, file2);
+    const sourcePath = path17.join(dir, file2);
     const targetPath = resolveSourceFileName(sourcesDir, file2);
     items.push({
       action: "copy",
@@ -22555,8 +22642,8 @@ function planFromRawSourceDir(classification, marvinDir) {
   return items;
 }
 function planFromRawSourceFile(classification, marvinDir) {
-  const sourcesDir = path16.join(marvinDir, "sources");
-  const fileName = path16.basename(classification.inputPath);
+  const sourcesDir = path17.join(marvinDir, "sources");
+  const fileName = path17.basename(classification.inputPath);
   const targetPath = resolveSourceFileName(sourcesDir, fileName);
   return [
     {
@@ -22567,25 +22654,25 @@ function planFromRawSourceFile(classification, marvinDir) {
   ];
 }
 function resolveSourceFileName(sourcesDir, fileName) {
-  const targetPath = path16.join(sourcesDir, fileName);
-  if (!fs15.existsSync(targetPath)) {
+  const targetPath = path17.join(sourcesDir, fileName);
+  if (!fs16.existsSync(targetPath)) {
     return targetPath;
   }
-  const ext = path16.extname(fileName);
-  const base = path16.basename(fileName, ext);
+  const ext = path17.extname(fileName);
+  const base = path17.basename(fileName, ext);
   let counter = 1;
   let candidate;
   do {
-    candidate = path16.join(sourcesDir, `${base}-${counter}${ext}`);
+    candidate = path17.join(sourcesDir, `${base}-${counter}${ext}`);
     counter++;
-  } while (fs15.existsSync(candidate));
+  } while (fs16.existsSync(candidate));
   return candidate;
 }
 
 // src/cli/commands/import.ts
 async function importCommand(inputPath, options) {
-  const resolved = path17.resolve(inputPath);
-  if (!fs16.existsSync(resolved)) {
+  const resolved = path18.resolve(inputPath);
+  if (!fs17.existsSync(resolved)) {
     throw new ImportError(`Path not found: ${resolved}`);
   }
   const project = loadProject();
@@ -22637,7 +22724,7 @@ async function importCommand(inputPath, options) {
     console.log(chalk11.bold("\nStarting ingest of copied sources...\n"));
     const manifest = new SourceManifestManager(marvinDir);
     manifest.scan();
-    const copiedFileNames = result.items.filter((i) => i.action === "copy").map((i) => path17.basename(i.targetPath));
+    const copiedFileNames = result.items.filter((i) => i.action === "copy").map((i) => path18.basename(i.targetPath));
     for (const fileName of copiedFileNames) {
       try {
         await ingestFile({
@@ -23040,7 +23127,8 @@ The contributor is identifying a project risk.
 - Create actions for risk mitigation tasks
 - Create decisions for risk response strategies
 - Create questions for risks needing further assessment
-- Tag all related artifacts with "risk" for tracking`,
+- Tag all related artifacts with "risk" for tracking
+- When a risk is resolved, use the update tool to remove the "risk" tag and add "risk-mitigated" so it no longer inflates the GAR quality metric`,
     "blocker-report": `
 ### Type-Specific Guidance: Blocker Report
 The contributor is reporting a blocker.
@@ -23524,12 +23612,38 @@ async function webCommand(options) {
   await startWebServer({ port, open: options.open });
 }
 
+// src/cli/commands/generate.ts
+import * as fs18 from "fs";
+import * as path19 from "path";
+import chalk18 from "chalk";
+import { confirm as confirm2 } from "@inquirer/prompts";
+async function generateClaudeMdCommand(options) {
+  const project = loadProject();
+  const filePath = path19.join(project.marvinDir, "CLAUDE.md");
+  if (fs18.existsSync(filePath) && !options.force) {
+    const overwrite = await confirm2({
+      message: ".marvin/CLAUDE.md already exists. Overwrite?",
+      default: false
+    });
+    if (!overwrite) {
+      console.log(chalk18.dim("Aborted."));
+      return;
+    }
+  }
+  fs18.writeFileSync(
+    filePath,
+    getDefaultClaudeMdContent(project.config.name),
+    "utf-8"
+  );
+  console.log(chalk18.green("Created .marvin/CLAUDE.md"));
+}
+
 // src/cli/program.ts
 function createProgram() {
   const program = new Command();
   program.name("marvin").description(
     "AI-powered product development assistant with Product Owner, Delivery Manager, and Technical Lead personas"
-  ).version("0.3.5");
+  ).version("0.3.6");
   program.command("init").description("Initialize a new Marvin project in the current directory").action(async () => {
     await initCommand();
   });
@@ -23615,6 +23729,10 @@ function createProgram() {
   program.command("web").description("Launch a local web dashboard for project data").option("-p, --port <port>", "Port to listen on (default: 3000)").option("--no-open", "Don't auto-open the browser").action(async (options) => {
     await webCommand(options);
   });
+  const generateCmd = program.command("generate").description("Generate project files");
+  generateCmd.command("claude-md").description("Generate .marvin/CLAUDE.md project instruction file").option("--force", "Overwrite existing file without prompting").action(async (options) => {
+    await generateClaudeMdCommand(options);
+  });
   return program;
 }
 export {