mrvn-cli 0.3.5 → 0.3.7

package/dist/marvin.js

@@ -920,10 +920,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);
@@ -1306,11 +1306,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;
   });
 }
@@ -1493,7 +1493,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) {
@@ -1503,7 +1503,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;
@@ -1535,8 +1535,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")
@@ -13513,13 +13513,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}`);
     }
@@ -14124,7 +14124,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;
@@ -14525,7 +14525,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" });
@@ -14896,7 +14896,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;
@@ -15053,7 +15054,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;
@@ -16625,6 +16627,56 @@ function getPluginPromptFragment(plugin, personaId) {
   return plugin.promptFragments[personaId] ?? plugin.promptFragments["*"];
 }
 
+// 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();
@@ -16681,11 +16733,17 @@ async function initCommand() {
     YAML3.stringify(config2),
     "utf-8"
   );
+  fs4.writeFileSync(
+    path4.join(marvinDir, "CLAUDE.md"),
+    getDefaultClaudeMdContent(projectName),
+    "utf-8"
+  );
   console.log(chalk.green(`
 Initialized Marvin project "${projectName}" in ${cwd}`));
   console.log(chalk.dim(`Methodology: ${plugin?.name ?? methodology}`));
   console.log(chalk.dim("\nCreated:"));
   console.log(chalk.dim("  .marvin/config.yaml"));
+  console.log(chalk.dim("  .marvin/CLAUDE.md"));
   console.log(chalk.dim("  .marvin/docs/decisions/"));
   console.log(chalk.dim("  .marvin/docs/actions/"));
   console.log(chalk.dim("  .marvin/docs/questions/"));
@@ -16888,8 +16946,8 @@ function resolvePersonaId(input4) {
 }
 
 // src/agent/session.ts
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 import * as readline from "readline";
 import chalk2 from "chalk";
 import ora from "ora";
@@ -16898,9 +16956,24 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/personas/prompt-builder.ts
-function buildSystemPrompt(persona, projectConfig, pluginPromptFragment, skillPromptFragment) {
+import * as fs5 from "fs";
+import * as path5 from "path";
+function buildSystemPrompt(persona, projectConfig, pluginPromptFragment, skillPromptFragment, marvinDir) {
   const parts = [];
   parts.push(persona.systemPrompt);
+  if (marvinDir) {
+    const claudeMdPath = path5.join(marvinDir, "CLAUDE.md");
+    try {
+      const content = fs5.readFileSync(claudeMdPath, "utf-8").trim();
+      if (content) {
+        parts.push(`
+## Project Instructions
+${content}
+`);
+      }
+    } catch {
+    }
+  }
   parts.push(`
 ## Project Context
 - **Project Name:** ${projectConfig.name}
@@ -16947,8 +17020,8 @@ ${projectConfig.personas[persona.id].extraInstructions}
 }
 
 // src/storage/store.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 
 // src/storage/document.ts
 import matter from "gray-matter";
@@ -16986,7 +17059,7 @@ var DocumentStore = class {
   typeDirs;
   idPrefixes;
   constructor(marvinDir, registrations) {
-    this.docsDir = path5.join(marvinDir, "docs");
+    this.docsDir = path6.join(marvinDir, "docs");
     this.typeDirs = { ...CORE_TYPE_DIRS };
     this.idPrefixes = { ...CORE_ID_PREFIXES };
     for (const reg of registrations ?? []) {
@@ -17001,12 +17074,12 @@ var DocumentStore = class {
   buildIndex() {
     this.index.clear();
     for (const type of Object.keys(this.typeDirs)) {
-      const dir = path5.join(this.docsDir, this.typeDirs[type]);
-      if (!fs5.existsSync(dir)) continue;
-      const files = fs5.readdirSync(dir).filter((f) => f.endsWith(".md"));
+      const dir = path6.join(this.docsDir, this.typeDirs[type]);
+      if (!fs6.existsSync(dir)) continue;
+      const files = fs6.readdirSync(dir).filter((f) => f.endsWith(".md"));
       for (const file2 of files) {
-        const filePath = path5.join(dir, file2);
-        const raw = fs5.readFileSync(filePath, "utf-8");
+        const filePath = path6.join(dir, file2);
+        const raw = fs6.readFileSync(filePath, "utf-8");
         const doc = parseDocument(raw, filePath);
         if (doc.frontmatter.id) {
           if (this.index.has(doc.frontmatter.id)) {
@@ -17025,12 +17098,12 @@ var DocumentStore = class {
     for (const type of types) {
       const dirName = this.typeDirs[type];
       if (!dirName) continue;
-      const dir = path5.join(this.docsDir, dirName);
-      if (!fs5.existsSync(dir)) continue;
-      const files = fs5.readdirSync(dir).filter((f) => f.endsWith(".md"));
+      const dir = path6.join(this.docsDir, dirName);
+      if (!fs6.existsSync(dir)) continue;
+      const files = fs6.readdirSync(dir).filter((f) => f.endsWith(".md"));
       for (const file2 of files) {
-        const filePath = path5.join(dir, file2);
-        const raw = fs5.readFileSync(filePath, "utf-8");
+        const filePath = path6.join(dir, file2);
+        const raw = fs6.readFileSync(filePath, "utf-8");
         const doc = parseDocument(raw, filePath);
         if (query7?.status && doc.frontmatter.status !== query7.status) continue;
         if (query7?.owner && doc.frontmatter.owner !== query7.owner) continue;
@@ -17043,12 +17116,12 @@ var DocumentStore = class {
   }
   get(id) {
     for (const type of Object.keys(this.typeDirs)) {
-      const dir = path5.join(this.docsDir, this.typeDirs[type]);
-      if (!fs5.existsSync(dir)) continue;
-      const files = fs5.readdirSync(dir).filter((f) => f.endsWith(".md"));
+      const dir = path6.join(this.docsDir, this.typeDirs[type]);
+      if (!fs6.existsSync(dir)) continue;
+      const files = fs6.readdirSync(dir).filter((f) => f.endsWith(".md"));
       for (const file2 of files) {
-        const filePath = path5.join(dir, file2);
-        const raw = fs5.readFileSync(filePath, "utf-8");
+        const filePath = path6.join(dir, file2);
+        const raw = fs6.readFileSync(filePath, "utf-8");
         const doc = parseDocument(raw, filePath);
         if (doc.frontmatter.id === id) return doc;
       }
@@ -17062,8 +17135,8 @@ var DocumentStore = class {
     if (!dirName) {
       throw new Error(`Unknown document type: ${type}`);
     }
-    const dir = path5.join(this.docsDir, dirName);
-    fs5.mkdirSync(dir, { recursive: true });
+    const dir = path6.join(this.docsDir, dirName);
+    fs6.mkdirSync(dir, { recursive: true });
     const cleaned = Object.fromEntries(
       Object.entries(frontmatter).filter(([, v]) => v !== void 0)
     );
@@ -17077,13 +17150,13 @@ var DocumentStore = class {
       ...cleaned
     };
     const fileName = type === "meeting" ? `${cleaned.date?.slice(0, 10) ?? now.slice(0, 10)}-${slugify2(fullFrontmatter.title)}.md` : `${id}.md`;
-    const filePath = path5.join(dir, fileName);
+    const filePath = path6.join(dir, fileName);
     const doc = {
       frontmatter: fullFrontmatter,
       content,
       filePath
     };
-    fs5.writeFileSync(filePath, serializeDocument(doc), "utf-8");
+    fs6.writeFileSync(filePath, serializeDocument(doc), "utf-8");
     this.index.set(id, fullFrontmatter);
     return doc;
   }
@@ -17098,12 +17171,12 @@ var DocumentStore = class {
         `Document ${frontmatter.id} already exists. Resolve conflicts before importing.`
       );
     }
-    const dir = path5.join(this.docsDir, dirName);
-    fs5.mkdirSync(dir, { recursive: true });
+    const dir = path6.join(this.docsDir, dirName);
+    fs6.mkdirSync(dir, { recursive: true });
     const fileName = type === "meeting" ? `${frontmatter.date?.slice(0, 10) ?? frontmatter.created.slice(0, 10)}-${slugify2(frontmatter.title)}.md` : `${frontmatter.id}.md`;
-    const filePath = path5.join(dir, fileName);
+    const filePath = path6.join(dir, fileName);
     const doc = { frontmatter, content, filePath };
-    fs5.writeFileSync(filePath, serializeDocument(doc), "utf-8");
+    fs6.writeFileSync(filePath, serializeDocument(doc), "utf-8");
     this.index.set(frontmatter.id, frontmatter);
     return doc;
   }
@@ -17125,7 +17198,7 @@ var DocumentStore = class {
       content: content ?? existing.content,
       filePath: existing.filePath
     };
-    fs5.writeFileSync(existing.filePath, serializeDocument(doc), "utf-8");
+    fs6.writeFileSync(existing.filePath, serializeDocument(doc), "utf-8");
     this.index.set(id, updatedFrontmatter);
     return doc;
   }
@@ -17135,14 +17208,14 @@ var DocumentStore = class {
       throw new Error(`Unknown document type: ${type}`);
     }
     const dirName = this.typeDirs[type];
-    const dir = path5.join(this.docsDir, dirName);
-    if (!fs5.existsSync(dir)) return `${prefix}-001`;
+    const dir = path6.join(this.docsDir, dirName);
+    if (!fs6.existsSync(dir)) return `${prefix}-001`;
     const idPattern = new RegExp(`^${prefix}-(\\d+)$`);
-    const files = fs5.readdirSync(dir).filter((f) => f.endsWith(".md"));
+    const files = fs6.readdirSync(dir).filter((f) => f.endsWith(".md"));
     let maxNum = 0;
     for (const file2 of files) {
-      const filePath = path5.join(dir, file2);
-      const raw = fs5.readFileSync(filePath, "utf-8");
+      const filePath = path6.join(dir, file2);
+      const raw = fs6.readFileSync(filePath, "utf-8");
       const doc = parseDocument(raw, filePath);
       const match = doc.frontmatter.id?.match(idPattern);
       if (match) {
@@ -17155,12 +17228,12 @@ var DocumentStore = class {
   counts() {
     const result = {};
     for (const type of Object.keys(this.typeDirs)) {
-      const dir = path5.join(this.docsDir, this.typeDirs[type]);
-      if (!fs5.existsSync(dir)) {
+      const dir = path6.join(this.docsDir, this.typeDirs[type]);
+      if (!fs6.existsSync(dir)) {
         result[type] = 0;
         continue;
       }
-      result[type] = fs5.readdirSync(dir).filter((f) => f.endsWith(".md")).length;
+      result[type] = fs6.readdirSync(dir).filter((f) => f.endsWith(".md")).length;
     }
     return result;
   }
@@ -17170,13 +17243,13 @@ function slugify2(text) {
 }
 
 // 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();
@@ -17217,9 +17290,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;
@@ -17228,11 +17301,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");
   }
 };
 
@@ -17329,7 +17402,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;
@@ -17480,11 +17554,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 {
@@ -17631,7 +17715,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;
@@ -19271,8 +19356,8 @@ import * as http from "http";
 import { exec } from "child_process";
 
 // src/skills/registry.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import { fileURLToPath } from "url";
 import * as YAML5 from "yaml";
 import matter2 from "gray-matter";
@@ -19325,8 +19410,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",
@@ -19340,7 +19425,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;
@@ -19820,13 +19905,13 @@ var GOVERNANCE_TOOL_NAMES = [
 ];
 function getBuiltinSkillsDir() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path7.join(path7.dirname(thisFile), "builtin");
+  return path8.join(path8.dirname(thisFile), "builtin");
 }
 function loadSkillFromDirectory(dirPath) {
-  const skillMdPath = path7.join(dirPath, "SKILL.md");
-  if (!fs7.existsSync(skillMdPath)) return void 0;
+  const skillMdPath = path8.join(dirPath, "SKILL.md");
+  if (!fs8.existsSync(skillMdPath)) return void 0;
   try {
-    const raw = fs7.readFileSync(skillMdPath, "utf-8");
+    const raw = fs8.readFileSync(skillMdPath, "utf-8");
     const { data, content } = matter2(raw);
     if (!data.name || !data.description) return void 0;
     const metadata = data.metadata ?? {};
@@ -19837,13 +19922,13 @@ function loadSkillFromDirectory(dirPath) {
     if (wildcardPrompt) {
       promptFragments["*"] = wildcardPrompt;
     }
-    const personasDir = path7.join(dirPath, "personas");
-    if (fs7.existsSync(personasDir)) {
+    const personasDir = path8.join(dirPath, "personas");
+    if (fs8.existsSync(personasDir)) {
       try {
-        for (const file2 of fs7.readdirSync(personasDir)) {
+        for (const file2 of fs8.readdirSync(personasDir)) {
           if (!file2.endsWith(".md")) continue;
           const personaId = file2.replace(/\.md$/, "");
-          const personaPrompt = fs7.readFileSync(path7.join(personasDir, file2), "utf-8").trim();
+          const personaPrompt = fs8.readFileSync(path8.join(personasDir, file2), "utf-8").trim();
           if (personaPrompt) {
             promptFragments[personaId] = personaPrompt;
           }
@@ -19852,10 +19937,10 @@ function loadSkillFromDirectory(dirPath) {
       }
     }
     let actions;
-    const actionsPath = path7.join(dirPath, "actions.yaml");
-    if (fs7.existsSync(actionsPath)) {
+    const actionsPath = path8.join(dirPath, "actions.yaml");
+    if (fs8.existsSync(actionsPath)) {
       try {
-        const actionsRaw = fs7.readFileSync(actionsPath, "utf-8");
+        const actionsRaw = fs8.readFileSync(actionsPath, "utf-8");
         actions = YAML5.parse(actionsRaw);
       } catch {
       }
@@ -19882,10 +19967,10 @@ function loadAllSkills(marvinDir) {
   }
   try {
     const builtinDir = getBuiltinSkillsDir();
-    if (fs7.existsSync(builtinDir)) {
-      for (const entry of fs7.readdirSync(builtinDir)) {
-        const entryPath = path7.join(builtinDir, entry);
-        if (!fs7.statSync(entryPath).isDirectory()) continue;
+    if (fs8.existsSync(builtinDir)) {
+      for (const entry of fs8.readdirSync(builtinDir)) {
+        const entryPath = path8.join(builtinDir, entry);
+        if (!fs8.statSync(entryPath).isDirectory()) continue;
         if (skills.has(entry)) continue;
         const skill = loadSkillFromDirectory(entryPath);
         if (skill) skills.set(skill.id, skill);
@@ -19894,18 +19979,18 @@ function loadAllSkills(marvinDir) {
   } catch {
   }
   if (marvinDir) {
-    const skillsDir = path7.join(marvinDir, "skills");
-    if (fs7.existsSync(skillsDir)) {
+    const skillsDir = path8.join(marvinDir, "skills");
+    if (fs8.existsSync(skillsDir)) {
       let entries;
       try {
-        entries = fs7.readdirSync(skillsDir);
+        entries = fs8.readdirSync(skillsDir);
       } catch {
         entries = [];
       }
       for (const entry of entries) {
-        const entryPath = path7.join(skillsDir, entry);
+        const entryPath = path8.join(skillsDir, entry);
         try {
-          if (fs7.statSync(entryPath).isDirectory()) {
+          if (fs8.statSync(entryPath).isDirectory()) {
             const skill = loadSkillFromDirectory(entryPath);
             if (skill) skills.set(skill.id, skill);
             continue;
@@ -19915,7 +20000,7 @@ function loadAllSkills(marvinDir) {
         }
         if (!entry.endsWith(".yaml") && !entry.endsWith(".yml")) continue;
         try {
-          const raw = fs7.readFileSync(entryPath, "utf-8");
+          const raw = fs8.readFileSync(entryPath, "utf-8");
           const parsed = YAML5.parse(raw);
           if (!parsed?.id || !parsed?.name || !parsed?.version) continue;
           const skill = {
@@ -20020,12 +20105,12 @@ function getSkillAgentDefinitions(skillIds, allSkills) {
   return agents;
 }
 function migrateYamlToSkillMd(yamlPath, outputDir) {
-  const raw = fs7.readFileSync(yamlPath, "utf-8");
+  const raw = fs8.readFileSync(yamlPath, "utf-8");
   const parsed = YAML5.parse(raw);
   if (!parsed?.id || !parsed?.name) {
     throw new Error(`Invalid skill YAML: missing required fields (id, name)`);
   }
-  fs7.mkdirSync(outputDir, { recursive: true });
+  fs8.mkdirSync(outputDir, { recursive: true });
   const frontmatter = {
     name: parsed.id,
     description: parsed.description ?? ""
@@ -20039,15 +20124,15 @@ function migrateYamlToSkillMd(yamlPath, outputDir) {
   const skillMd = matter2.stringify(wildcardPrompt ? `
 ${wildcardPrompt}
 ` : "\n", frontmatter);
-  fs7.writeFileSync(path7.join(outputDir, "SKILL.md"), skillMd, "utf-8");
+  fs8.writeFileSync(path8.join(outputDir, "SKILL.md"), skillMd, "utf-8");
   if (promptFragments) {
     const personaKeys = Object.keys(promptFragments).filter((k) => k !== "*");
     if (personaKeys.length > 0) {
-      const personasDir = path7.join(outputDir, "personas");
-      fs7.mkdirSync(personasDir, { recursive: true });
+      const personasDir = path8.join(outputDir, "personas");
+      fs8.mkdirSync(personasDir, { recursive: true });
       for (const personaId of personaKeys) {
-        fs7.writeFileSync(
-          path7.join(personasDir, `${personaId}.md`),
+        fs8.writeFileSync(
+          path8.join(personasDir, `${personaId}.md`),
           `${promptFragments[personaId]}
 `,
           "utf-8"
@@ -20057,8 +20142,8 @@ ${wildcardPrompt}
   }
   const actions = parsed.actions;
   if (actions && actions.length > 0) {
-    fs7.writeFileSync(
-      path7.join(outputDir, "actions.yaml"),
+    fs8.writeFileSync(
+      path8.join(outputDir, "actions.yaml"),
       YAML5.stringify(actions),
       "utf-8"
     );
@@ -20332,8 +20417,8 @@ function slugify3(text) {
 }
 
 // src/sources/manifest.ts
-import * as fs8 from "fs";
-import * as path8 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 import * as crypto from "crypto";
 import * as YAML6 from "yaml";
 var MANIFEST_FILE = ".manifest.yaml";
@@ -20346,37 +20431,37 @@ var SourceManifestManager = class {
   manifestPath;
   sourcesDir;
   constructor(marvinDir) {
-    this.sourcesDir = path8.join(marvinDir, "sources");
-    this.manifestPath = path8.join(this.sourcesDir, MANIFEST_FILE);
+    this.sourcesDir = path9.join(marvinDir, "sources");
+    this.manifestPath = path9.join(this.sourcesDir, MANIFEST_FILE);
     this.manifest = this.load();
   }
   load() {
-    if (!fs8.existsSync(this.manifestPath)) {
+    if (!fs9.existsSync(this.manifestPath)) {
       return emptyManifest();
     }
-    const raw = fs8.readFileSync(this.manifestPath, "utf-8");
+    const raw = fs9.readFileSync(this.manifestPath, "utf-8");
     const parsed = YAML6.parse(raw);
     return parsed ?? emptyManifest();
   }
   save() {
-    fs8.mkdirSync(this.sourcesDir, { recursive: true });
-    fs8.writeFileSync(this.manifestPath, YAML6.stringify(this.manifest), "utf-8");
+    fs9.mkdirSync(this.sourcesDir, { recursive: true });
+    fs9.writeFileSync(this.manifestPath, YAML6.stringify(this.manifest), "utf-8");
   }
   scan() {
     const added = [];
     const changed = [];
     const removed = [];
-    if (!fs8.existsSync(this.sourcesDir)) {
+    if (!fs9.existsSync(this.sourcesDir)) {
       return { added, changed, removed };
     }
     const onDisk = new Set(
-      fs8.readdirSync(this.sourcesDir).filter((f) => {
-        const ext = path8.extname(f).toLowerCase();
+      fs9.readdirSync(this.sourcesDir).filter((f) => {
+        const ext = path9.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.includes(ext);
       })
     );
     for (const fileName of onDisk) {
-      const filePath = path8.join(this.sourcesDir, fileName);
+      const filePath = path9.join(this.sourcesDir, fileName);
       const hash2 = this.hashFile(filePath);
       const existing = this.manifest.files[fileName];
       if (!existing) {
@@ -20439,7 +20524,7 @@ var SourceManifestManager = class {
     this.save();
   }
   hashFile(filePath) {
-    const content = fs8.readFileSync(filePath);
+    const content = fs9.readFileSync(filePath);
     return crypto.createHash("sha256").update(content).digest("hex");
   }
 };
@@ -20454,8 +20539,8 @@ async function startSession(options) {
   const skillRegistrations = collectSkillRegistrations(skillIds, allSkills);
   const store = new DocumentStore(marvinDir, [...pluginRegistrations, ...skillRegistrations]);
   const sessionStore = new SessionStore(marvinDir);
-  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 pluginPromptFragment = plugin ? getPluginPromptFragment(plugin, persona.id) : void 0;
@@ -20478,7 +20563,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);
@@ -20931,13 +21016,13 @@ async function setApiKey() {
 }
 
 // src/cli/commands/ingest.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs12 from "fs";
+import * as path12 from "path";
 import chalk8 from "chalk";
 
 // src/sources/ingest.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 import chalk7 from "chalk";
 import ora2 from "ora";
 import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
@@ -21040,15 +21125,15 @@ async function ingestFile(options) {
   const persona = getPersona(personaId);
   const manifest = new SourceManifestManager(marvinDir);
   const sourcesDir = manifest.sourcesDir;
-  const filePath = path10.join(sourcesDir, fileName);
-  if (!fs10.existsSync(filePath)) {
+  const filePath = path11.join(sourcesDir, fileName);
+  if (!fs11.existsSync(filePath)) {
     throw new Error(`Source file not found: ${filePath}`);
   }
-  const ext = path10.extname(fileName).toLowerCase();
+  const ext = path11.extname(fileName).toLowerCase();
   const isPdf = ext === ".pdf";
   let fileContent = null;
   if (!isPdf) {
-    fileContent = fs10.readFileSync(filePath, "utf-8");
+    fileContent = fs11.readFileSync(filePath, "utf-8");
   }
   const store = new DocumentStore(marvinDir);
   const createdArtifacts = [];
@@ -21151,9 +21236,9 @@ Ingest ended with error: ${message.subtype}`)
 async function ingestCommand(file2, options) {
   const project = loadProject();
   const marvinDir = project.marvinDir;
-  const sourcesDir = path11.join(marvinDir, "sources");
-  if (!fs11.existsSync(sourcesDir)) {
-    fs11.mkdirSync(sourcesDir, { recursive: true });
+  const sourcesDir = path12.join(marvinDir, "sources");
+  if (!fs12.existsSync(sourcesDir)) {
+    fs12.mkdirSync(sourcesDir, { recursive: true });
   }
   const manifest = new SourceManifestManager(marvinDir);
   manifest.scan();
@@ -21164,8 +21249,8 @@ async function ingestCommand(file2, options) {
     return;
   }
   if (file2) {
-    const filePath = path11.join(sourcesDir, file2);
-    if (!fs11.existsSync(filePath)) {
+    const filePath = path12.join(sourcesDir, file2);
+    if (!fs12.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.`));
@@ -21232,7 +21317,7 @@ import ora3 from "ora";
 import { input as input3 } from "@inquirer/prompts";
 
 // src/git/repository.ts
-import * as path12 from "path";
+import * as path13 from "path";
 import simpleGit from "simple-git";
 var MARVIN_GITIGNORE = `node_modules/
 .DS_Store
@@ -21252,7 +21337,7 @@ var DIR_TYPE_LABELS = {
 function buildCommitMessage(files) {
   const counts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const parts2 = f.split(path12.sep).join("/").split("/");
+    const parts2 = f.split(path13.sep).join("/").split("/");
     const docsIdx = parts2.indexOf("docs");
     if (docsIdx !== -1 && docsIdx + 1 < parts2.length) {
       const dirName = parts2[docsIdx + 1];
@@ -21292,9 +21377,9 @@ var MarvinGit = class {
       );
     }
     await this.git.init();
-    const { writeFileSync: writeFileSync9 } = await import("fs");
-    writeFileSync9(
-      path12.join(this.marvinDir, ".gitignore"),
+    const { writeFileSync: writeFileSync10 } = await import("fs");
+    writeFileSync10(
+      path13.join(this.marvinDir, ".gitignore"),
       MARVIN_GITIGNORE,
       "utf-8"
     );
@@ -21414,9 +21499,9 @@ var MarvinGit = class {
     }
   }
   static async clone(url2, targetDir) {
-    const marvinDir = path12.join(targetDir, ".marvin");
-    const { existsSync: existsSync16 } = await import("fs");
-    if (existsSync16(marvinDir)) {
+    const marvinDir = path13.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.`
       );
@@ -21594,8 +21679,8 @@ async function cloneCommand(url2, directory) {
 }
 
 // src/mcp/stdio-server.ts
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
@@ -21893,8 +21978,8 @@ function collectTools(marvinDir) {
   const plugin = resolvePlugin(config2.methodology);
   const registrations = plugin?.documentTypeRegistrations ?? [];
   const store = new DocumentStore(marvinDir, registrations);
-  const sourcesDir = path13.join(marvinDir, "sources");
-  const hasSourcesDir = fs12.existsSync(sourcesDir);
+  const sourcesDir = path14.join(marvinDir, "sources");
+  const hasSourcesDir = fs13.existsSync(sourcesDir);
   const manifest = hasSourcesDir ? new SourceManifestManager(marvinDir) : void 0;
   const pluginTools = plugin ? getPluginTools(plugin, store, marvinDir) : [];
   const sessionStore = new SessionStore(marvinDir);
@@ -21902,8 +21987,14 @@ 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 = path13.dirname(marvinDir);
+  const projectRoot = path14.dirname(marvinDir);
   const actionTools = createSkillActionTools(skillsWithActions, { store, marvinDir, projectRoot });
+  const allSkillRegs = collectSkillRegistrations(allSkillIds, allSkills);
+  const navGroups = buildNavGroups({
+    pluginRegs: registrations,
+    skillRegs: allSkillRegs,
+    pluginName: plugin?.name
+  });
   return [
     ...createDecisionTools(store),
     ...createActionTools(store),
@@ -21911,6 +22002,7 @@ function collectTools(marvinDir) {
     ...createDocumentTools(store),
     ...manifest ? createSourceTools(manifest) : [],
     ...createSessionTools(sessionStore),
+    ...createWebTools(store, config2.name, navGroups),
     ...pluginTools,
     ...codeSkillTools,
     ...actionTools
@@ -21965,8 +22057,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";
@@ -22072,14 +22164,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,
@@ -22093,7 +22185,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",
@@ -22103,7 +22195,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"));
@@ -22111,14 +22203,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;
@@ -22130,16 +22222,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) {
@@ -22153,35 +22245,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 };
@@ -22190,7 +22282,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 {
@@ -22204,14 +22296,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 };
@@ -22336,9 +22428,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;
     }
@@ -22374,19 +22466,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) {
@@ -22419,11 +22511,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({
@@ -22479,23 +22571,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);
@@ -22505,10 +22597,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));
     }
   }
@@ -22517,7 +22609,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 [];
@@ -22533,14 +22625,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",
@@ -22551,8 +22643,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 [
     {
@@ -22563,25 +22655,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();
@@ -22633,7 +22725,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({
@@ -23036,7 +23128,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.
@@ -23520,12 +23613,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 program2 = new Command();
   program2.name("marvin").description(
     "AI-powered product development assistant with Product Owner, Delivery Manager, and Technical Lead personas"
-  ).version("0.3.5");
+  ).version("0.3.7");
   program2.command("init").description("Initialize a new Marvin project in the current directory").action(async () => {
     await initCommand();
   });
@@ -23611,6 +23730,10 @@ function createProgram() {
   program2.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 = program2.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 program2;
 }