mrvn-cli 0.4.2 → 0.4.5

package/dist/index.js

@@ -453,7 +453,7 @@ var deliveryManager = {
     "Epic scheduling and tracking",
     "Sprint planning and tracking"
   ],
-  documentTypes: ["action", "decision", "meeting", "question", "feature", "epic", "sprint"],
+  documentTypes: ["action", "decision", "meeting", "question", "feature", "epic", "task", "sprint"],
   contributionTypes: ["risk-finding", "blocker-report", "dependency-update", "status-assessment"]
 };
 
@@ -491,9 +491,10 @@ var techLead = {
     "Implementation guidance",
     "Non-functional requirements",
     "Epic creation and scoping",
+    "Task creation and breakdown",
     "Sprint scoping and technical execution"
   ],
-  documentTypes: ["decision", "action", "question", "epic", "sprint"],
+  documentTypes: ["decision", "action", "question", "epic", "task", "sprint"],
   contributionTypes: ["action-result", "spike-findings", "technical-assessment", "architecture-review"]
 };
 
@@ -1361,10 +1362,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path20) {
-  if (!path20)
+function getElementAtPath(obj, path21) {
+  if (!path21)
     return obj;
-  return path20.reduce((acc, key) => acc?.[key], obj);
+  return path21.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1747,11 +1748,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path20, issues) {
+function prefixIssues(path21, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path20);
+    iss.path.unshift(path21);
     return iss;
   });
 }
@@ -1934,7 +1935,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path20 = []) => {
+  const processError = (error49, path21 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -1944,7 +1945,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path20, ...issue2.path];
+        const fullpath = [...path21, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1976,8 +1977,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path20) {
+  const path21 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path21) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13954,13 +13955,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path20 = ref.slice(1).split("/").filter(Boolean);
-  if (path20.length === 0) {
+  const path21 = ref.slice(1).split("/").filter(Boolean);
+  if (path21.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path20[0] === defsKey) {
-    const key = path20[1];
+  if (path21[0] === defsKey) {
+    const key = path21[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -14998,7 +14999,7 @@ function createSessionTools(store) {
 
 // src/agent/tools/web.ts
 import * as http2 from "http";
-import { tool as tool20 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool22 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/plugins/builtin/tools/epic-utils.ts
 function normalizeLinkedFeatures(value) {
@@ -15018,132 +15019,22 @@ function generateFeatureTags(features) {
   return features.map((id) => `feature:${id}`);
 }
 
-// src/reports/gar/collector.ts
-function collectGarMetrics(store) {
-  const allActions = store.list({ type: "action" });
-  const openActions = allActions.filter((d) => d.frontmatter.status === "open");
-  const doneActions = allActions.filter((d) => d.frontmatter.status === "done");
-  const allDocs = store.list();
-  const blockedItems = allDocs.filter(
-    (d) => d.frontmatter.tags?.includes("blocked")
-  );
-  const tagOverdueItems = allDocs.filter(
-    (d) => d.frontmatter.tags?.includes("overdue")
-  );
-  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const dateOverdueActions = openActions.filter((d) => {
-    const dueDate = d.frontmatter.dueDate;
-    return typeof dueDate === "string" && dueDate < today;
-  });
-  const overdueItems = [...tagOverdueItems, ...dateOverdueActions].filter(
-    (d, i, arr) => arr.findIndex((x) => x.frontmatter.id === d.frontmatter.id) === i
-  );
-  const openQuestions = store.list({ type: "question", status: "open" });
-  const riskItems = allDocs.filter(
-    (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;
-  const done = doneActions.length;
-  const completionPct = total > 0 ? Math.round(done / total * 100) : 100;
-  const scheduleItems = [
-    ...blockedItems,
-    ...overdueItems
-  ].filter(
-    (d, i, arr) => arr.findIndex((x) => x.frontmatter.id === d.frontmatter.id) === i
-  ).map((d) => ({ id: d.frontmatter.id, title: d.frontmatter.title }));
-  const qualityItems = [
-    ...riskItems,
-    ...openQuestions
-  ].filter(
-    (d, i, arr) => arr.findIndex((x) => x.frontmatter.id === d.frontmatter.id) === i
-  ).map((d) => ({ id: d.frontmatter.id, title: d.frontmatter.title }));
-  const resourceItems = unownedActions.map((d) => ({
-    id: d.frontmatter.id,
-    title: d.frontmatter.title
-  }));
-  return {
-    scope: {
-      total,
-      open: openActions.length,
-      done,
-      completionPct
-    },
-    schedule: {
-      blocked: blockedItems.length,
-      overdue: overdueItems.length,
-      items: scheduleItems
-    },
-    quality: {
-      risks: riskItems.length,
-      openQuestions: openQuestions.length,
-      items: qualityItems
-    },
-    resources: {
-      unowned: unownedActions.length,
-      items: resourceItems
+// src/plugins/builtin/tools/task-utils.ts
+function normalizeLinkedEpics(value) {
+  if (value === void 0 || value === null) return [];
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) return parsed.filter((v) => typeof v === "string");
+    } catch {
     }
-  };
+    return [value];
+  }
+  if (Array.isArray(value)) return value.filter((v) => typeof v === "string");
+  return [];
 }
-
-// src/reports/gar/evaluator.ts
-function worstStatus(statuses) {
-  if (statuses.includes("red")) return "red";
-  if (statuses.includes("amber")) return "amber";
-  return "green";
-}
-function evaluateGar(projectName, metrics) {
-  const areas = [];
-  const scopePct = metrics.scope.completionPct;
-  const scopeStatus = scopePct >= 70 ? "green" : scopePct >= 40 ? "amber" : "red";
-  areas.push({
-    name: "Scope",
-    status: scopeStatus,
-    summary: `${scopePct}% complete (${metrics.scope.done}/${metrics.scope.total})`,
-    items: []
-  });
-  const scheduleCount = metrics.schedule.blocked + metrics.schedule.overdue;
-  const scheduleStatus = scheduleCount === 0 ? "green" : scheduleCount <= 2 ? "amber" : "red";
-  const scheduleParts = [];
-  if (metrics.schedule.blocked > 0)
-    scheduleParts.push(`${metrics.schedule.blocked} blocked`);
-  if (metrics.schedule.overdue > 0)
-    scheduleParts.push(`${metrics.schedule.overdue} overdue`);
-  areas.push({
-    name: "Schedule",
-    status: scheduleStatus,
-    summary: scheduleParts.length > 0 ? scheduleParts.join(", ") : "on track",
-    items: metrics.schedule.items
-  });
-  const qualityCount = metrics.quality.risks + metrics.quality.openQuestions;
-  const qualityStatus = qualityCount === 0 ? "green" : qualityCount <= 2 ? "amber" : "red";
-  const qualityParts = [];
-  if (metrics.quality.risks > 0)
-    qualityParts.push(`${metrics.quality.risks} risk(s)`);
-  if (metrics.quality.openQuestions > 0)
-    qualityParts.push(`${metrics.quality.openQuestions} open question(s)`);
-  areas.push({
-    name: "Quality",
-    status: qualityStatus,
-    summary: qualityParts.length > 0 ? qualityParts.join(", ") : "no issues",
-    items: metrics.quality.items
-  });
-  const resourceCount = metrics.resources.unowned;
-  const resourceStatus = resourceCount === 0 ? "green" : resourceCount <= 2 ? "amber" : "red";
-  areas.push({
-    name: "Resources",
-    status: resourceStatus,
-    summary: resourceCount > 0 ? `${resourceCount} unowned action(s)` : "all assigned",
-    items: metrics.resources.items
-  });
-  const overall = worstStatus(areas.map((a) => a.status));
-  return {
-    projectName,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
-    overall,
-    areas,
-    metrics
-  };
+function generateEpicTags(epics) {
+  return epics.map((id) => `epic:${id}`);
 }
 
 // src/reports/health/collector.ts
@@ -15285,6 +15176,134 @@ function collectHealthMetrics(store) {
   };
 }
 
+// src/reports/gar/collector.ts
+function collectGarMetrics(store) {
+  const allActions = store.list({ type: "action" });
+  const openActions = allActions.filter((d) => d.frontmatter.status === "open");
+  const doneActions = allActions.filter((d) => d.frontmatter.status === "done");
+  const allDocs = store.list();
+  const blockedItems = allDocs.filter(
+    (d) => d.frontmatter.tags?.includes("blocked")
+  );
+  const tagOverdueItems = allDocs.filter(
+    (d) => d.frontmatter.tags?.includes("overdue")
+  );
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const dateOverdueActions = openActions.filter((d) => {
+    const dueDate = d.frontmatter.dueDate;
+    return typeof dueDate === "string" && dueDate < today;
+  });
+  const overdueItems = [...tagOverdueItems, ...dateOverdueActions].filter(
+    (d, i, arr) => arr.findIndex((x) => x.frontmatter.id === d.frontmatter.id) === i
+  );
+  const openQuestions = store.list({ type: "question", status: "open" });
+  const riskItems = allDocs.filter(
+    (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;
+  const done = doneActions.length;
+  const completionPct = total > 0 ? Math.round(done / total * 100) : 100;
+  const scheduleItems = [
+    ...blockedItems,
+    ...overdueItems
+  ].filter(
+    (d, i, arr) => arr.findIndex((x) => x.frontmatter.id === d.frontmatter.id) === i
+  ).map((d) => ({ id: d.frontmatter.id, title: d.frontmatter.title }));
+  const qualityItems = [
+    ...riskItems,
+    ...openQuestions
+  ].filter(
+    (d, i, arr) => arr.findIndex((x) => x.frontmatter.id === d.frontmatter.id) === i
+  ).map((d) => ({ id: d.frontmatter.id, title: d.frontmatter.title }));
+  const resourceItems = unownedActions.map((d) => ({
+    id: d.frontmatter.id,
+    title: d.frontmatter.title
+  }));
+  return {
+    scope: {
+      total,
+      open: openActions.length,
+      done,
+      completionPct
+    },
+    schedule: {
+      blocked: blockedItems.length,
+      overdue: overdueItems.length,
+      items: scheduleItems
+    },
+    quality: {
+      risks: riskItems.length,
+      openQuestions: openQuestions.length,
+      items: qualityItems
+    },
+    resources: {
+      unowned: unownedActions.length,
+      items: resourceItems
+    }
+  };
+}
+
+// src/reports/gar/evaluator.ts
+function worstStatus(statuses) {
+  if (statuses.includes("red")) return "red";
+  if (statuses.includes("amber")) return "amber";
+  return "green";
+}
+function evaluateGar(projectName, metrics) {
+  const areas = [];
+  const scopePct = metrics.scope.completionPct;
+  const scopeStatus = scopePct >= 70 ? "green" : scopePct >= 40 ? "amber" : "red";
+  areas.push({
+    name: "Scope",
+    status: scopeStatus,
+    summary: `${scopePct}% complete (${metrics.scope.done}/${metrics.scope.total})`,
+    items: []
+  });
+  const scheduleCount = metrics.schedule.blocked + metrics.schedule.overdue;
+  const scheduleStatus = scheduleCount === 0 ? "green" : scheduleCount <= 2 ? "amber" : "red";
+  const scheduleParts = [];
+  if (metrics.schedule.blocked > 0)
+    scheduleParts.push(`${metrics.schedule.blocked} blocked`);
+  if (metrics.schedule.overdue > 0)
+    scheduleParts.push(`${metrics.schedule.overdue} overdue`);
+  areas.push({
+    name: "Schedule",
+    status: scheduleStatus,
+    summary: scheduleParts.length > 0 ? scheduleParts.join(", ") : "on track",
+    items: metrics.schedule.items
+  });
+  const qualityCount = metrics.quality.risks + metrics.quality.openQuestions;
+  const qualityStatus = qualityCount === 0 ? "green" : qualityCount <= 2 ? "amber" : "red";
+  const qualityParts = [];
+  if (metrics.quality.risks > 0)
+    qualityParts.push(`${metrics.quality.risks} risk(s)`);
+  if (metrics.quality.openQuestions > 0)
+    qualityParts.push(`${metrics.quality.openQuestions} open question(s)`);
+  areas.push({
+    name: "Quality",
+    status: qualityStatus,
+    summary: qualityParts.length > 0 ? qualityParts.join(", ") : "no issues",
+    items: metrics.quality.items
+  });
+  const resourceCount = metrics.resources.unowned;
+  const resourceStatus = resourceCount === 0 ? "green" : resourceCount <= 2 ? "amber" : "red";
+  areas.push({
+    name: "Resources",
+    status: resourceStatus,
+    summary: resourceCount > 0 ? `${resourceCount} unowned action(s)` : "all assigned",
+    items: metrics.resources.items
+  });
+  const overall = worstStatus(areas.map((a) => a.status));
+  return {
+    projectName,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    overall,
+    areas,
+    metrics
+  };
+}
+
 // src/reports/health/evaluator.ts
 function worstStatus2(statuses) {
   if (statuses.includes("red")) return "red";
@@ -15504,6 +15523,204 @@ function getDiagramData(store) {
   }
   return { sprints, epics, features, statusCounts };
 }
+function computeUrgency(dueDateStr, todayStr) {
+  const due = new Date(dueDateStr).getTime();
+  const today = new Date(todayStr).getTime();
+  const diffDays = Math.floor((due - today) / 864e5);
+  if (diffDays < 0) return "overdue";
+  if (diffDays <= 3) return "due-3d";
+  if (diffDays <= 7) return "due-7d";
+  if (diffDays <= 14) return "upcoming";
+  return "later";
+}
+var DONE_STATUSES = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+function getUpcomingData(store) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const allDocs = store.list();
+  const docById = /* @__PURE__ */ new Map();
+  for (const doc of allDocs) {
+    docById.set(doc.frontmatter.id, doc);
+  }
+  const actions = allDocs.filter(
+    (d) => d.frontmatter.type === "action" && !DONE_STATUSES.has(d.frontmatter.status)
+  );
+  const actionsWithDue = actions.filter((d) => d.frontmatter.dueDate);
+  const sprints = allDocs.filter((d) => d.frontmatter.type === "sprint");
+  const epics = allDocs.filter((d) => d.frontmatter.type === "epic");
+  const tasks = allDocs.filter((d) => d.frontmatter.type === "task");
+  const epicToTasks = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const tags = task.frontmatter.tags ?? [];
+    for (const tag of tags) {
+      if (tag.startsWith("epic:")) {
+        const epicId = tag.slice(5);
+        if (!epicToTasks.has(epicId)) epicToTasks.set(epicId, []);
+        epicToTasks.get(epicId).push(task);
+      }
+    }
+  }
+  function getSprintTasks(sprintDoc) {
+    const linkedEpics = normalizeLinkedEpics(sprintDoc.frontmatter.linkedEpics);
+    const result = [];
+    for (const epicId of linkedEpics) {
+      const epicTasks = epicToTasks.get(epicId) ?? [];
+      result.push(...epicTasks);
+    }
+    return result;
+  }
+  function countRelatedTasks(actionDoc) {
+    const actionTags = actionDoc.frontmatter.tags ?? [];
+    const relatedTaskIds = /* @__PURE__ */ new Set();
+    for (const tag of actionTags) {
+      if (tag.startsWith("sprint:")) {
+        const sprintId = tag.slice(7);
+        const sprint = docById.get(sprintId);
+        if (sprint) {
+          const sprintTaskDocs = getSprintTasks(sprint);
+          for (const t of sprintTaskDocs) relatedTaskIds.add(t.frontmatter.id);
+        }
+      }
+    }
+    return relatedTaskIds.size;
+  }
+  const dueSoonActions = actionsWithDue.map((d) => ({
+    id: d.frontmatter.id,
+    title: d.frontmatter.title,
+    status: d.frontmatter.status,
+    owner: d.frontmatter.owner,
+    dueDate: d.frontmatter.dueDate,
+    urgency: computeUrgency(d.frontmatter.dueDate, today),
+    relatedTaskCount: countRelatedTasks(d)
+  })).sort((a, b) => a.dueDate.localeCompare(b.dueDate));
+  const todayMs = new Date(today).getTime();
+  const fourteenDaysMs = 14 * 864e5;
+  const nearSprints = sprints.filter((s) => {
+    const endDate = s.frontmatter.endDate;
+    if (!endDate) return false;
+    const endMs = new Date(endDate).getTime();
+    const diff = endMs - todayMs;
+    return diff >= 0 && diff <= fourteenDaysMs;
+  });
+  const taskSprintMap = /* @__PURE__ */ new Map();
+  for (const sprint of nearSprints) {
+    const sprintEnd = sprint.frontmatter.endDate;
+    const sprintTaskDocs = getSprintTasks(sprint);
+    for (const task of sprintTaskDocs) {
+      if (DONE_STATUSES.has(task.frontmatter.status)) continue;
+      const existing = taskSprintMap.get(task.frontmatter.id);
+      if (!existing || sprintEnd < existing.sprintEnd) {
+        taskSprintMap.set(task.frontmatter.id, { task, sprint, sprintEnd });
+      }
+    }
+  }
+  const dueSoonSprintTasks = [...taskSprintMap.values()].map(({ task, sprint, sprintEnd }) => ({
+    id: task.frontmatter.id,
+    title: task.frontmatter.title,
+    status: task.frontmatter.status,
+    sprintId: sprint.frontmatter.id,
+    sprintTitle: sprint.frontmatter.title,
+    sprintEndDate: sprintEnd,
+    urgency: computeUrgency(sprintEnd, today)
+  })).sort((a, b) => a.sprintEndDate.localeCompare(b.sprintEndDate));
+  const openItems = allDocs.filter(
+    (d) => ["action", "question", "task"].includes(d.frontmatter.type) && !DONE_STATUSES.has(d.frontmatter.status)
+  );
+  const fourteenDaysAgo = new Date(todayMs - fourteenDaysMs).toISOString().slice(0, 10);
+  const recentMeetings = allDocs.filter(
+    (d) => d.frontmatter.type === "meeting" && (d.frontmatter.updated ?? d.frontmatter.created) >= fourteenDaysAgo
+  );
+  const crossRefCounts = /* @__PURE__ */ new Map();
+  for (const doc of allDocs) {
+    const content = doc.content ?? "";
+    for (const item of openItems) {
+      if (doc.frontmatter.id === item.frontmatter.id) continue;
+      if (content.includes(item.frontmatter.id)) {
+        crossRefCounts.set(
+          item.frontmatter.id,
+          (crossRefCounts.get(item.frontmatter.id) ?? 0) + 1
+        );
+      }
+    }
+  }
+  const activeSprints = sprints.filter((s) => {
+    const status = s.frontmatter.status;
+    if (status === "active") return true;
+    const startDate = s.frontmatter.startDate;
+    if (!startDate) return false;
+    const startMs = new Date(startDate).getTime();
+    const diff = startMs - todayMs;
+    return diff >= 0 && diff <= fourteenDaysMs;
+  });
+  const activeSprintIds = new Set(activeSprints.map((s) => s.frontmatter.id));
+  const activeEpicIds = /* @__PURE__ */ new Set();
+  for (const s of activeSprints) {
+    for (const epicId of normalizeLinkedEpics(s.frontmatter.linkedEpics)) {
+      activeEpicIds.add(epicId);
+    }
+  }
+  const trending = openItems.map((doc) => {
+    const signals = [];
+    let score = 0;
+    const updated = doc.frontmatter.updated ?? doc.frontmatter.created;
+    const ageDays = daysBetween(updated, today);
+    const recencyPts = Math.max(0, Math.round(20 * (1 - ageDays / 30)));
+    if (recencyPts > 0) {
+      signals.push({ factor: "recency", points: recencyPts });
+      score += recencyPts;
+    }
+    const tags = doc.frontmatter.tags ?? [];
+    const linkedToActiveSprint = tags.some(
+      (t) => t.startsWith("sprint:") && activeSprintIds.has(t.slice(7))
+    );
+    const linkedToActiveEpic = tags.some(
+      (t) => t.startsWith("epic:") && activeEpicIds.has(t.slice(5))
+    );
+    if (linkedToActiveSprint) {
+      signals.push({ factor: "sprint proximity", points: 25 });
+      score += 25;
+    } else if (linkedToActiveEpic) {
+      signals.push({ factor: "sprint proximity", points: 15 });
+      score += 15;
+    }
+    const mentionCount = recentMeetings.filter(
+      (m) => (m.content ?? "").includes(doc.frontmatter.id)
+    ).length;
+    if (mentionCount > 0) {
+      const meetingPts = Math.min(15, mentionCount * 5);
+      signals.push({ factor: "meeting mentions", points: meetingPts });
+      score += meetingPts;
+    }
+    const priority = doc.frontmatter.priority?.toLowerCase();
+    const priorityPts = priority === "critical" ? 15 : priority === "high" ? 10 : priority === "medium" ? 3 : 0;
+    if (priorityPts > 0) {
+      signals.push({ factor: "priority", points: priorityPts });
+      score += priorityPts;
+    }
+    if (["action", "question"].includes(doc.frontmatter.type)) {
+      const createdDays = daysBetween(doc.frontmatter.created, today);
+      if (createdDays >= 14) {
+        const agingPts = Math.min(10, Math.floor((createdDays - 14) / 7) * 3 + 5);
+        signals.push({ factor: "aging", points: agingPts });
+        score += agingPts;
+      }
+    }
+    const refs = crossRefCounts.get(doc.frontmatter.id) ?? 0;
+    if (refs > 0) {
+      const crossRefPts = Math.min(15, refs * 5);
+      signals.push({ factor: "cross-references", points: crossRefPts });
+      score += crossRefPts;
+    }
+    return {
+      id: doc.frontmatter.id,
+      title: doc.frontmatter.title,
+      type: doc.frontmatter.type,
+      status: doc.frontmatter.status,
+      score,
+      signals
+    };
+  }).filter((item) => item.score > 0).sort((a, b) => b.score - a.score).slice(0, 15);
+  return { dueSoonActions, dueSoonSprintTasks, trending };
+}
 
 // src/web/templates/layout.ts
 function escapeHtml(str) {
@@ -15627,6 +15844,8 @@ function inline(text) {
 function layout(opts, body) {
   const topItems = [
     { href: "/", label: "Overview" },
+    { href: "/upcoming", label: "Upcoming" },
+    { href: "/timeline", label: "Timeline" },
     { href: "/board", label: "Board" },
     { href: "/gar", label: "GAR Report" },
     { href: "/health", label: "Health" }
@@ -15663,7 +15882,7 @@ function layout(opts, body) {
         ${groupsHtml}
       </nav>
     </aside>
-    <main class="main">
+    <main class="main${opts.mainClass ? ` ${opts.mainClass}` : ""}">
       <button class="expand-toggle" onclick="document.querySelector('.main').classList.toggle('expanded')" title="Toggle wide view">
         <svg class="icon-expand" viewBox="0 0 16 16" width="16" height="16" fill="currentColor"><path d="M1 1h5v1.5H3.56l3.72 3.72-1.06 1.06L2.5 3.56V6H1V1zm14 14h-5v-1.5h2.44l-3.72-3.72 1.06-1.06 3.72 3.72V10H15v5z"/></svg>
         <svg class="icon-collapse" viewBox="0 0 16 16" width="16" height="16" fill="currentColor"><path d="M6 7H1V5.5h2.44L0.22 2.28l1.06-1.06L4.5 4.44V2H6v5zm4-1h5v1.5h-2.44l3.22 3.22-1.06 1.06L11.5 8.56V11H10V6z"/></svg>
@@ -15672,7 +15891,36 @@ function layout(opts, body) {
     </main>
   </div>
   <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
-  <script>mermaid.initialize({ startOnLoad: true, theme: 'dark' });</script>
+  <script>mermaid.initialize({
+    startOnLoad: true,
+    theme: 'dark',
+    themeVariables: {
+      background: '#1a1d27',
+      primaryColor: '#2a2e3a',
+      sectionBkgColor: '#1a1d27',
+      sectionBkgColor2: '#222632',
+      altSectionBkgColor: '#222632',
+      gridColor: '#2a2e3a',
+      taskBorderColor: '#475569',
+      doneTaskBkgColor: '#065f46',
+      doneTaskBorderColor: '#34d399',
+      activeTaskBkgColor: '#78350f',
+      activeTaskBorderColor: '#fbbf24',
+      taskTextColor: '#e1e4ea',
+      sectionBkgColor: '#1a1d27',
+      pie1: '#34d399',
+      pie2: '#475569',
+      pie3: '#fbbf24',
+      pie4: '#f87171',
+      pie5: '#6c8cff',
+      pie6: '#a78bfa',
+      pie7: '#f472b6',
+      pieTitleTextColor: '#e1e4ea',
+      pieSectionTextColor: '#e1e4ea',
+      pieLegendTextColor: '#e1e4ea',
+      pieStrokeColor: '#1a1d27'
+    }
+  });</script>
 </body>
 </html>`;
 }
@@ -15919,6 +16167,10 @@ a:hover { text-decoration: underline; }
 /* Table */
 .table-wrap {
   overflow-x: auto;
+  overflow-y: auto;
+  max-height: calc(100vh - 280px);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
 }
 
 table {
@@ -15934,6 +16186,10 @@ th {
   letter-spacing: 0.05em;
   color: var(--text-dim);
   border-bottom: 1px solid var(--border);
+  position: sticky;
+  top: 0;
+  background: var(--bg-card);
+  z-index: 1;
 }
 
 td {
@@ -15981,6 +16237,8 @@ tr:hover td {
   border: 1px solid var(--border);
   border-radius: var(--radius);
   padding: 1.25rem;
+  display: flex;
+  flex-direction: column;
 }
 
 .gar-area .area-header {
@@ -16011,6 +16269,9 @@ tr:hover td {
 .gar-area ul {
   list-style: none;
   font-size: 0.8rem;
+  max-height: 200px;
+  overflow-y: auto;
+  scrollbar-width: thin;
 }
 
 .gar-area li {
@@ -16033,13 +16294,14 @@ tr:hover td {
   display: flex;
   gap: 1rem;
   overflow-x: auto;
+  scrollbar-width: thin;
   padding-bottom: 1rem;
 }
 
 .board-column {
   min-width: 240px;
   max-width: 300px;
-  flex: 1;
+  flex: 0 0 auto;
 }
 
 .board-column-header {
@@ -16052,6 +16314,7 @@ tr:hover td {
   margin-bottom: 0.5rem;
   display: flex;
   justify-content: space-between;
+  flex-shrink: 0;
 }
 
 .board-column-header .count {
@@ -16230,9 +16493,294 @@ tr:hover td {
   gap: 1rem;
 }
 
-.mermaid-row .mermaid-container {
-  margin: 0;
-}
+.mermaid-row .mermaid-container {
+  margin: 0;
+}
+
+/* Three-column artifact flow */
+.flow-diagram {
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 1.25rem;
+  position: relative;
+  overflow-x: auto;
+}
+
+.flow-lines {
+  position: absolute;
+  top: 0;
+  left: 0;
+  pointer-events: none;
+}
+
+.flow-columns {
+  display: flex;
+  gap: 3rem;
+  position: relative;
+  min-width: 600px;
+}
+
+.flow-column {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.flow-column-header {
+  font-size: 0.7rem;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-dim);
+  font-weight: 600;
+  padding-bottom: 0.4rem;
+  border-bottom: 1px solid var(--border);
+  margin-bottom: 0.25rem;
+}
+
+.flow-node {
+  padding: 0.5rem 0.65rem;
+  border-radius: 6px;
+  border-left: 3px solid var(--border);
+  background: var(--bg);
+  transition: border-color 0.15s, background 0.15s;
+}
+
+.flow-node:hover {
+  background: var(--bg-hover);
+}
+
+.flow-node-id {
+  display: inline-block;
+  font-family: var(--mono);
+  font-size: 0.65rem;
+  color: var(--accent);
+  margin-bottom: 0.15rem;
+  text-decoration: none;
+}
+
+.flow-node-id:hover {
+  text-decoration: underline;
+}
+
+.flow-node-title {
+  display: block;
+  font-size: 0.8rem;
+}
+
+.flow-done { border-left-color: var(--green); }
+.flow-active { border-left-color: var(--amber); }
+.flow-blocked { border-left-color: var(--red); }
+.flow-default { border-left-color: var(--accent-dim); }
+
+.flow-node { cursor: pointer; transition: opacity 0.2s, border-color 0.15s, background 0.15s; }
+.flow-dim { opacity: 0.2; }
+.flow-lit { background: var(--bg-hover); }
+.flow-line-lit { stroke: var(--accent) !important; stroke-width: 2 !important; }
+.flow-line-dim { opacity: 0.08; }
+
+/* Gantt truncation note */
+.mermaid-note {
+  font-size: 0.75rem;
+  color: var(--text-dim);
+  text-align: right;
+  margin-bottom: 0.5rem;
+}
+
+/* HTML Gantt chart */
+.gantt {
+  background: var(--bg-card);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 1.25rem 1.25rem 1.25rem 0;
+  position: relative;
+  overflow-x: auto;
+}
+
+.gantt-chart {
+  min-width: 600px;
+}
+
+.gantt-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  pointer-events: none;
+  display: flex;
+}
+
+.gantt-header,
+.gantt-section-row,
+.gantt-row,
+.gantt-overlay {
+  display: flex;
+  align-items: center;
+}
+
+.gantt-label {
+  width: 200px;
+  min-width: 200px;
+  padding: 0.3rem 0.75rem;
+  font-size: 0.8rem;
+  color: var(--text-dim);
+  text-align: right;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.gantt-section-label {
+  font-weight: 600;
+  color: var(--text);
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+  padding-top: 0.6rem;
+}
+
+.gantt-track {
+  flex: 1;
+  position: relative;
+  height: 28px;
+  min-width: 0;
+}
+
+.gantt-section-row .gantt-track {
+  height: 20px;
+}
+
+.gantt-section-bg {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  background: var(--bg-hover);
+  border-radius: 3px;
+  opacity: 0.4;
+}
+
+.gantt-bar {
+  position: absolute;
+  top: 4px;
+  bottom: 4px;
+  border-radius: 4px;
+  min-width: 6px;
+  transition: opacity 0.15s;
+}
+
+.gantt-bar:hover {
+  opacity: 0.85;
+}
+
+.gantt-bar-done {
+  background: var(--green);
+}
+
+.gantt-bar-active {
+  background: var(--amber);
+}
+
+.gantt-bar-blocked {
+  background: var(--red);
+}
+
+.gantt-bar-default {
+  background: var(--accent-dim);
+}
+
+.gantt-dates {
+  height: 24px;
+  border-bottom: 1px solid var(--border);
+  margin-bottom: 0.25rem;
+}
+
+.gantt-marker {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  border-left: 1px solid var(--border);
+}
+
+.gantt-marker span {
+  position: absolute;
+  top: 2px;
+  left: 6px;
+  font-size: 0.65rem;
+  color: var(--text-dim);
+  white-space: nowrap;
+}
+
+.gantt-today {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  width: 2px;
+  background: var(--red);
+  opacity: 0.7;
+}
+
+/* Pie chart color overrides */
+.mermaid-container .pieCircle {
+  stroke: var(--bg-card);
+}
+
+.mermaid-container text.slice {
+  fill: var(--bg) !important;
+  font-weight: 600;
+}
+
+/* Urgency row indicators */
+.urgency-row-overdue { border-left: 3px solid var(--red); }
+.urgency-row-due-3d { border-left: 3px solid var(--amber); }
+.urgency-row-due-7d { border-left: 3px solid #e2a308; }
+
+/* Urgency badge pills */
+.urgency-badge-overdue { background: rgba(248, 113, 113, 0.15); color: var(--red); }
+.urgency-badge-due-3d { background: rgba(251, 191, 36, 0.15); color: var(--amber); }
+.urgency-badge-due-7d { background: rgba(226, 163, 8, 0.15); color: #e2a308; }
+.urgency-badge-upcoming { background: rgba(108, 140, 255, 0.15); color: var(--accent); }
+.urgency-badge-later { background: rgba(139, 143, 164, 0.1); color: var(--text-dim); }
+
+/* Trending */
+.trending-rank {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 24px;
+  height: 24px;
+  border-radius: 50%;
+  background: var(--bg-hover);
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: var(--text-dim);
+}
+
+.trending-score {
+  display: inline-block;
+  padding: 0.15rem 0.6rem;
+  border-radius: 999px;
+  font-size: 0.7rem;
+  font-weight: 700;
+  background: rgba(108, 140, 255, 0.15);
+  color: var(--accent);
+}
+
+.signal-tag {
+  display: inline-block;
+  padding: 0.1rem 0.45rem;
+  border-radius: 4px;
+  font-size: 0.65rem;
+  background: var(--bg-hover);
+  color: var(--text-dim);
+  margin-right: 0.25rem;
+  margin-bottom: 0.15rem;
+  white-space: nowrap;
+}
+
+.text-dim { color: var(--text-dim); }
 `;
 }
 
@@ -16241,98 +16789,290 @@ function sanitize(text, maxLen = 40) {
   const cleaned = text.replace(/["'`]/g, "").replace(/[\r\n]+/g, " ");
   return cleaned.length > maxLen ? cleaned.slice(0, maxLen - 1) + "\u2026" : cleaned;
 }
-function mermaidBlock(definition) {
-  return `<div class="mermaid-container"><pre class="mermaid">
+function mermaidBlock(definition, extraClass) {
+  const cls = ["mermaid-container", extraClass].filter(Boolean).join(" ");
+  return `<div class="${cls}"><pre class="mermaid">
 ${definition}
 </pre></div>`;
 }
 function placeholder(message) {
   return `<div class="mermaid-container mermaid-empty"><p>${message}</p></div>`;
 }
-function buildTimelineGantt(data) {
-  const sprintsWithDates = data.sprints.filter((s) => s.startDate && s.endDate);
+function toMs(date5) {
+  return (/* @__PURE__ */ new Date(date5 + "T00:00:00")).getTime();
+}
+function fmtDate(ms) {
+  const d = new Date(ms);
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  return `${months[d.getMonth()]} ${d.getDate()}`;
+}
+function buildTimelineGantt(data, maxSprints = 6) {
+  const sprintsWithDates = data.sprints.filter((s) => s.startDate && s.endDate).sort((a, b) => a.startDate < b.startDate ? -1 : 1);
   if (sprintsWithDates.length === 0) {
     return placeholder("No timeline data available \u2014 sprints need start and end dates.");
   }
+  const truncated = sprintsWithDates.length > maxSprints;
+  const visibleSprints = truncated ? sprintsWithDates.slice(-maxSprints) : sprintsWithDates;
+  const hiddenCount = sprintsWithDates.length - visibleSprints.length;
   const epicMap = new Map(data.epics.map((e) => [e.id, e]));
-  const lines = ["gantt", "  title Project Timeline", "  dateFormat YYYY-MM-DD"];
-  for (const sprint of sprintsWithDates) {
-    lines.push(`  section ${sanitize(sprint.id + " " + sprint.title, 50)}`);
+  const allStarts = visibleSprints.map((s) => toMs(s.startDate));
+  const allEnds = visibleSprints.map((s) => toMs(s.endDate));
+  const timelineStart = Math.min(...allStarts);
+  const timelineEnd = Math.max(...allEnds);
+  const span = timelineEnd - timelineStart || 1;
+  const pct = (ms) => (ms - timelineStart) / span * 100;
+  const DAY = 864e5;
+  const markers = [];
+  let tick = timelineStart;
+  const startDay = new Date(tick).getDay();
+  tick += (8 - startDay) % 7 * DAY;
+  while (tick <= timelineEnd) {
+    const left = pct(tick);
+    markers.push(
+      `<div class="gantt-marker" style="left:${left.toFixed(2)}%"><span>${fmtDate(tick)}</span></div>`
+    );
+    tick += 7 * DAY;
+  }
+  const now = Date.now();
+  let todayMarker = "";
+  if (now >= timelineStart && now <= timelineEnd) {
+    todayMarker = `<div class="gantt-today" style="left:${pct(now).toFixed(2)}%"></div>`;
+  }
+  const rows = [];
+  for (const sprint of visibleSprints) {
+    const sStart = toMs(sprint.startDate);
+    const sEnd = toMs(sprint.endDate);
+    rows.push(`<div class="gantt-section-row">
+      <div class="gantt-label gantt-section-label">${sanitize(sprint.id + " " + sprint.title, 50)}</div>
+      <div class="gantt-track">
+        <div class="gantt-section-bg" style="left:${pct(sStart).toFixed(2)}%;width:${(pct(sEnd) - pct(sStart)).toFixed(2)}%"></div>
+      </div>
+    </div>`);
     const linked = sprint.linkedEpics.map((eid) => epicMap.get(eid)).filter(Boolean);
-    if (linked.length === 0) {
-      lines.push(`    ${sanitize(sprint.title)} :${sprint.startDate}, ${sprint.endDate}`);
-    } else {
-      for (const epic of linked) {
-        const tag = epic.status === "in-progress" ? "active, " : epic.status === "done" ? "done, " : "";
-        lines.push(`    ${sanitize(epic.id + " " + epic.title)} :${tag}${sprint.startDate}, ${sprint.endDate}`);
-      }
+    const items = linked.length > 0 ? linked.map((e) => ({ label: sanitize(e.id + " " + e.title), status: e.status })) : [{ label: sanitize(sprint.title), status: sprint.status }];
+    for (const item of items) {
+      const cls = item.status === "done" || item.status === "completed" ? "gantt-bar-done" : item.status === "in-progress" || item.status === "active" ? "gantt-bar-active" : item.status === "blocked" ? "gantt-bar-blocked" : "gantt-bar-default";
+      const left = pct(sStart).toFixed(2);
+      const width = (pct(sEnd) - pct(sStart)).toFixed(2);
+      rows.push(`<div class="gantt-row">
+        <div class="gantt-label">${item.label}</div>
+        <div class="gantt-track">
+          <div class="gantt-bar ${cls}" style="left:${left}%;width:${width}%"></div>
+        </div>
+      </div>`);
     }
   }
-  return mermaidBlock(lines.join("\n"));
+  const note = truncated ? `<div class="mermaid-note">${hiddenCount} earlier sprint${hiddenCount > 1 ? "s" : ""} not shown</div>` : "";
+  return `${note}
+    <div class="gantt">
+      <div class="gantt-chart">
+        <div class="gantt-header">
+          <div class="gantt-label"></div>
+          <div class="gantt-track gantt-dates">${markers.join("")}</div>
+        </div>
+        ${rows.join("\n")}
+      </div>
+      <div class="gantt-overlay">
+        <div class="gantt-label"></div>
+        <div class="gantt-track">${todayMarker}</div>
+      </div>
+    </div>`;
+}
+function statusClass(status) {
+  const s = status.toLowerCase();
+  if (s === "done" || s === "completed") return "flow-done";
+  if (s === "in-progress" || s === "active") return "flow-active";
+  if (s === "blocked") return "flow-blocked";
+  return "flow-default";
 }
 function buildArtifactFlowchart(data) {
   if (data.features.length === 0 && data.epics.length === 0) {
     return placeholder("No artifact relationships found \u2014 create features and epics to see the hierarchy.");
   }
-  const lines = ["graph TD"];
-  lines.push("  classDef done fill:#065f46,stroke:#34d399,color:#d1fae5");
-  lines.push("  classDef inprogress fill:#78350f,stroke:#fbbf24,color:#fef3c7");
-  lines.push("  classDef blocked fill:#7f1d1d,stroke:#f87171,color:#fee2e2");
-  lines.push("  classDef default fill:#1e293b,stroke:#475569,color:#e2e8f0");
-  const nodeIds = /* @__PURE__ */ new Set();
+  const edges = [];
+  const epicsByFeature = /* @__PURE__ */ new Map();
   for (const epic of data.epics) {
-    for (const featureId of epic.linkedFeature) {
-      const feature = data.features.find((f) => f.id === featureId);
-      if (feature) {
-        const fNode = feature.id.replace(/-/g, "_");
-        const eNode = epic.id.replace(/-/g, "_");
-        if (!nodeIds.has(fNode)) {
-          lines.push(`  ${fNode}["${sanitize(feature.id + " " + feature.title)}"]`);
-          nodeIds.add(fNode);
-        }
-        if (!nodeIds.has(eNode)) {
-          lines.push(`  ${eNode}["${sanitize(epic.id + " " + epic.title)}"]`);
-          nodeIds.add(eNode);
-        }
-        lines.push(`  ${fNode} --> ${eNode}`);
-      }
+    for (const fid of epic.linkedFeature) {
+      if (!epicsByFeature.has(fid)) epicsByFeature.set(fid, []);
+      epicsByFeature.get(fid).push(epic.id);
+      edges.push({ from: fid, to: epic.id });
     }
   }
+  const sprintsByEpic = /* @__PURE__ */ new Map();
   for (const sprint of data.sprints) {
-    const sNode = sprint.id.replace(/-/g, "_");
-    for (const epicId of sprint.linkedEpics) {
-      const epic = data.epics.find((e) => e.id === epicId);
-      if (epic) {
-        const eNode = epic.id.replace(/-/g, "_");
-        if (!nodeIds.has(eNode)) {
-          lines.push(`  ${eNode}["${sanitize(epic.id + " " + epic.title)}"]`);
-          nodeIds.add(eNode);
+    for (const eid of sprint.linkedEpics) {
+      if (!sprintsByEpic.has(eid)) sprintsByEpic.set(eid, []);
+      sprintsByEpic.get(eid).push(sprint.id);
+      edges.push({ from: eid, to: sprint.id });
+    }
+  }
+  const connectedFeatureIds = new Set(epicsByFeature.keys());
+  const connectedEpicIds = /* @__PURE__ */ new Set();
+  for (const ids of epicsByFeature.values()) ids.forEach((id) => connectedEpicIds.add(id));
+  for (const ids of sprintsByEpic.values()) ids.forEach(() => {
+  });
+  for (const eid of sprintsByEpic.keys()) connectedEpicIds.add(eid);
+  const connectedSprintIds = /* @__PURE__ */ new Set();
+  for (const ids of sprintsByEpic.values()) ids.forEach((id) => connectedSprintIds.add(id));
+  const features = data.features.filter((f) => connectedFeatureIds.has(f.id));
+  const epics = data.epics.filter((e) => connectedEpicIds.has(e.id));
+  const sprints = data.sprints.filter((s) => connectedSprintIds.has(s.id)).sort((a, b) => (a.startDate ?? "").localeCompare(b.startDate ?? ""));
+  if (features.length === 0 && epics.length === 0) {
+    return placeholder("No artifact relationships found \u2014 link epics to features and sprints.");
+  }
+  const renderNode = (id, title, status, type) => `<div class="flow-node ${statusClass(status)}" data-flow-id="${id}">
+      <a class="flow-node-id" href="/docs/${type}/${id}">${id}</a>
+      <span class="flow-node-title">${sanitize(title, 35)}</span>
+    </div>`;
+  const featuresHtml = features.map((f) => renderNode(f.id, f.title, f.status, "feature")).join("\n");
+  const epicsHtml = epics.map((e) => renderNode(e.id, e.title, e.status, "epic")).join("\n");
+  const sprintsHtml = sprints.map((s) => renderNode(s.id, s.title, s.status, "sprint")).join("\n");
+  const edgesJson = JSON.stringify(edges);
+  return `
+    <div class="flow-diagram" id="flow-diagram">
+      <svg class="flow-lines" id="flow-lines"></svg>
+      <div class="flow-columns">
+        <div class="flow-column">
+          <div class="flow-column-header">Features</div>
+          ${featuresHtml}
+        </div>
+        <div class="flow-column">
+          <div class="flow-column-header">Epics</div>
+          ${epicsHtml}
+        </div>
+        <div class="flow-column">
+          <div class="flow-column-header">Sprints</div>
+          ${sprintsHtml}
+        </div>
+      </div>
+    </div>
+    <script>
+    (function() {
+      var edges = ${edgesJson};
+      var container = document.getElementById('flow-diagram');
+      var svg = document.getElementById('flow-lines');
+      if (!container || !svg) return;
+
+      // Build directed adjacency maps for traversal
+      var fwd = {};   // from \u2192 [to] (Feature\u2192Epic, Epic\u2192Sprint)
+      var bwd = {};   // to \u2192 [from] (Sprint\u2192Epic, Epic\u2192Feature)
+      edges.forEach(function(e) {
+        if (!fwd[e.from]) fwd[e.from] = [];
+        if (!bwd[e.to]) bwd[e.to] = [];
+        fwd[e.from].push(e.to);
+        bwd[e.to].push(e.from);
+      });
+
+      function drawLines() {
+        var rect = container.getBoundingClientRect();
+        svg.setAttribute('width', rect.width);
+        svg.setAttribute('height', rect.height);
+        svg.innerHTML = '';
+
+        edges.forEach(function(edge) {
+          var fromEl = container.querySelector('[data-flow-id="' + edge.from + '"]');
+          var toEl = container.querySelector('[data-flow-id="' + edge.to + '"]');
+          if (!fromEl || !toEl) return;
+
+          var fr = fromEl.getBoundingClientRect();
+          var tr = toEl.getBoundingClientRect();
+          var x1 = fr.right - rect.left;
+          var y1 = fr.top + fr.height / 2 - rect.top;
+          var x2 = tr.left - rect.left;
+          var y2 = tr.top + tr.height / 2 - rect.top;
+          var mx = (x1 + x2) / 2;
+
+          var path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+          path.setAttribute('d', 'M' + x1 + ',' + y1 + ' C' + mx + ',' + y1 + ' ' + mx + ',' + y2 + ' ' + x2 + ',' + y2);
+          path.setAttribute('fill', 'none');
+          path.setAttribute('stroke', '#2a2e3a');
+          path.setAttribute('stroke-width', '1.5');
+          path.dataset.from = edge.from;
+          path.dataset.to = edge.to;
+          svg.appendChild(path);
+        });
+      }
+
+      // Find directly related nodes via directed traversal
+      // Follows forward edges (Feature\u2192Epic\u2192Sprint) and backward edges
+      // (Sprint\u2192Epic\u2192Feature) separately to avoid sideways expansion
+      function findConnected(startId) {
+        var visited = {};
+        visited[startId] = true;
+        // Traverse forward (from\u2192to direction)
+        var queue = [startId];
+        while (queue.length) {
+          var id = queue.shift();
+          (fwd[id] || []).forEach(function(neighbor) {
+            if (!visited[neighbor]) {
+              visited[neighbor] = true;
+              queue.push(neighbor);
+            }
+          });
         }
-        if (!nodeIds.has(sNode)) {
-          lines.push(`  ${sNode}["${sanitize(sprint.id + " " + sprint.title)}"]`);
-          nodeIds.add(sNode);
+        // Traverse backward (to\u2192from direction)
+        queue = [startId];
+        while (queue.length) {
+          var id = queue.shift();
+          (bwd[id] || []).forEach(function(neighbor) {
+            if (!visited[neighbor]) {
+              visited[neighbor] = true;
+              queue.push(neighbor);
+            }
+          });
         }
-        lines.push(`  ${eNode} --> ${sNode}`);
+        return visited;
       }
-    }
-  }
-  if (nodeIds.size === 0) {
-    return placeholder("No artifact relationships found \u2014 link epics to features and sprints.");
-  }
-  const allItems = [
-    ...data.features.map((f) => ({ id: f.id, status: f.status })),
-    ...data.epics.map((e) => ({ id: e.id, status: e.status })),
-    ...data.sprints.map((s) => ({ id: s.id, status: s.status }))
-  ];
-  for (const item of allItems) {
-    const node = item.id.replace(/-/g, "_");
-    if (!nodeIds.has(node)) continue;
-    const cls = item.status === "done" || item.status === "completed" ? "done" : item.status === "in-progress" || item.status === "active" ? "inprogress" : item.status === "blocked" ? "blocked" : null;
-    if (cls) {
-      lines.push(`  class ${node} ${cls}`);
-    }
-  }
-  return mermaidBlock(lines.join("\n"));
+
+      function highlight(hoveredId) {
+        var connected = findConnected(hoveredId);
+        container.querySelectorAll('.flow-node').forEach(function(n) {
+          if (connected[n.dataset.flowId]) {
+            n.classList.add('flow-lit');
+            n.classList.remove('flow-dim');
+          } else {
+            n.classList.add('flow-dim');
+            n.classList.remove('flow-lit');
+          }
+        });
+        svg.querySelectorAll('path').forEach(function(p) {
+          if (connected[p.dataset.from] && connected[p.dataset.to]) {
+            p.classList.add('flow-line-lit');
+            p.classList.remove('flow-line-dim');
+          } else {
+            p.classList.add('flow-line-dim');
+            p.classList.remove('flow-line-lit');
+          }
+        });
+      }
+
+      function clearHighlight() {
+        container.querySelectorAll('.flow-node').forEach(function(n) { n.classList.remove('flow-lit', 'flow-dim'); });
+        svg.querySelectorAll('path').forEach(function(p) { p.classList.remove('flow-line-lit', 'flow-line-dim'); });
+      }
+
+      var activeId = null;
+      container.addEventListener('click', function(e) {
+        // Let the ID link navigate normally
+        if (e.target.closest('a')) return;
+
+        var node = e.target.closest('.flow-node');
+        var clickedId = node ? node.dataset.flowId : null;
+
+        if (!clickedId || clickedId === activeId) {
+          activeId = null;
+          clearHighlight();
+          return;
+        }
+
+        activeId = clickedId;
+        highlight(clickedId);
+      });
+
+      requestAnimationFrame(function() { setTimeout(drawLines, 100); });
+      window.addEventListener('resize', drawLines);
+    })();
+    </script>`;
 }
 function buildStatusPie(title, counts) {
   const entries = Object.entries(counts).filter(([, v]) => v > 0);
@@ -16412,8 +17152,7 @@ function overviewPage(data, diagrams, navGroups) {
     ${groupSections}
     ${ungroupedSection}
 
-    <div class="section-title">Project Timeline</div>
-    ${buildTimelineGantt(diagrams)}
+    <div class="section-title"><a href="/timeline">Project Timeline &rarr;</a></div>
 
     <div class="section-title">Artifact Relationships</div>
     ${buildArtifactFlowchart(diagrams)}
@@ -16668,6 +17407,7 @@ function boardPage(data) {
           <span>${escapeHtml(col.status)}</span>
           <span class="count">${col.docs.length}</span>
         </div>
+        <div class="board-column-cards">
         ${col.docs.map(
       (doc) => `
           <div class="board-card">
@@ -16678,6 +17418,7 @@ function boardPage(data) {
             </a>
           </div>`
     ).join("\n")}
+        </div>
       </div>`
   ).join("\n");
   return `
@@ -16703,6 +17444,143 @@ function boardPage(data) {
   `;
 }
 
+// src/web/templates/pages/timeline.ts
+function timelinePage(diagrams) {
+  return `
+    <div class="page-header">
+      <h2>Project Timeline</h2>
+      <div class="subtitle">Sprint schedule with linked epics</div>
+    </div>
+
+    ${buildTimelineGantt(diagrams)}
+  `;
+}
+
+// src/web/templates/pages/upcoming.ts
+function urgencyBadge(tier) {
+  const labels = {
+    overdue: "Overdue",
+    "due-3d": "Due in 3d",
+    "due-7d": "Due in 7d",
+    upcoming: "Upcoming",
+    later: "Later"
+  };
+  return `<span class="badge urgency-badge-${tier}">${labels[tier]}</span>`;
+}
+function urgencyRowClass(tier) {
+  if (tier === "overdue") return " urgency-row-overdue";
+  if (tier === "due-3d") return " urgency-row-due-3d";
+  if (tier === "due-7d") return " urgency-row-due-7d";
+  return "";
+}
+function upcomingPage(data) {
+  const hasActions = data.dueSoonActions.length > 0;
+  const hasSprintTasks = data.dueSoonSprintTasks.length > 0;
+  const hasTrending = data.trending.length > 0;
+  const actionsTable = hasActions ? `
+    <h3 class="section-title">Due Soon \u2014 Actions</h3>
+    <div class="table-wrap">
+      <table>
+        <thead>
+          <tr>
+            <th>ID</th>
+            <th>Title</th>
+            <th>Status</th>
+            <th>Owner</th>
+            <th>Due Date</th>
+            <th>Urgency</th>
+            <th>Tasks</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${data.dueSoonActions.map(
+    (a) => `
+          <tr class="${urgencyRowClass(a.urgency)}">
+            <td><a href="/docs/action/${escapeHtml(a.id)}">${escapeHtml(a.id)}</a></td>
+            <td>${escapeHtml(a.title)}</td>
+            <td>${statusBadge(a.status)}</td>
+            <td>${a.owner ? escapeHtml(a.owner) : '<span class="text-dim">\u2014</span>'}</td>
+            <td>${formatDate(a.dueDate)}</td>
+            <td>${urgencyBadge(a.urgency)}</td>
+            <td>${a.relatedTaskCount > 0 ? a.relatedTaskCount : "\u2014"}</td>
+          </tr>`
+  ).join("")}
+        </tbody>
+      </table>
+    </div>` : "";
+  const sprintTasksTable = hasSprintTasks ? `
+    <h3 class="section-title">Due Soon \u2014 Sprint Tasks</h3>
+    <div class="table-wrap">
+      <table>
+        <thead>
+          <tr>
+            <th>ID</th>
+            <th>Title</th>
+            <th>Status</th>
+            <th>Sprint</th>
+            <th>Sprint Ends</th>
+            <th>Urgency</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${data.dueSoonSprintTasks.map(
+    (t) => `
+          <tr class="${urgencyRowClass(t.urgency)}">
+            <td><a href="/docs/task/${escapeHtml(t.id)}">${escapeHtml(t.id)}</a></td>
+            <td>${escapeHtml(t.title)}</td>
+            <td>${statusBadge(t.status)}</td>
+            <td><a href="/docs/sprint/${escapeHtml(t.sprintId)}">${escapeHtml(t.sprintId)}</a></td>
+            <td>${formatDate(t.sprintEndDate)}</td>
+            <td>${urgencyBadge(t.urgency)}</td>
+          </tr>`
+  ).join("")}
+        </tbody>
+      </table>
+    </div>` : "";
+  const trendingTable = hasTrending ? `
+    <h3 class="section-title">Trending</h3>
+    <div class="table-wrap">
+      <table>
+        <thead>
+          <tr>
+            <th>#</th>
+            <th>ID</th>
+            <th>Title</th>
+            <th>Type</th>
+            <th>Status</th>
+            <th>Score</th>
+            <th>Signals</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${data.trending.map(
+    (t, i) => `
+          <tr>
+            <td><span class="trending-rank">${i + 1}</span></td>
+            <td><a href="/docs/${escapeHtml(t.type)}/${escapeHtml(t.id)}">${escapeHtml(t.id)}</a></td>
+            <td>${escapeHtml(t.title)}</td>
+            <td>${escapeHtml(typeLabel(t.type))}</td>
+            <td>${statusBadge(t.status)}</td>
+            <td><span class="trending-score">${t.score}</span></td>
+            <td>${t.signals.map((s) => `<span class="signal-tag">${escapeHtml(s.factor)} +${s.points}</span>`).join(" ")}</td>
+          </tr>`
+  ).join("")}
+        </tbody>
+      </table>
+    </div>` : "";
+  const emptyState = !hasActions && !hasSprintTasks && !hasTrending ? '<div class="empty"><p>No upcoming items or trending activity found.</p></div>' : "";
+  return `
+    <div class="page-header">
+      <h2>Upcoming</h2>
+      <div class="subtitle">Time-sensitive items and trending activity</div>
+    </div>
+    ${actionsTable}
+    ${sprintTasksTable}
+    ${trendingTable}
+    ${emptyState}
+  `;
+}
+
 // src/web/router.ts
 function handleRequest(req, res, store, projectName, navGroups) {
   const parsed = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
@@ -16724,6 +17602,12 @@ function handleRequest(req, res, store, projectName, navGroups) {
       respond(res, layout({ title: "Overview", activePath: "/", projectName, navGroups }, body));
       return;
     }
+    if (pathname === "/timeline") {
+      const diagrams = getDiagramData(store);
+      const body = timelinePage(diagrams);
+      respond(res, layout({ title: "Timeline", activePath: "/timeline", projectName, navGroups, mainClass: "expanded" }, body));
+      return;
+    }
     if (pathname === "/gar") {
       const report = getGarData(store, projectName);
       const body = garPage(report);
@@ -16737,6 +17621,12 @@ function handleRequest(req, res, store, projectName, navGroups) {
       respond(res, layout({ title: "Health Check", activePath: "/health", projectName, navGroups }, body));
       return;
     }
+    if (pathname === "/upcoming") {
+      const data = getUpcomingData(store);
+      const body = upcomingPage(data);
+      respond(res, layout({ title: "Upcoming", activePath: "/upcoming", projectName, navGroups }, body));
+      return;
+    }
     const boardMatch = pathname.match(/^\/board(?:\/([^/]+))?$/);
     if (boardMatch) {
       const type = boardMatch[1];
@@ -18107,6 +18997,185 @@ function createSprintPlanningTools(store) {
   ];
 }
 
+// src/plugins/builtin/tools/tasks.ts
+import { tool as tool14 } from "@anthropic-ai/claude-agent-sdk";
+var linkedEpicArray = external_exports.preprocess(
+  (val) => {
+    if (typeof val === "string") {
+      try {
+        const parsed = JSON.parse(val);
+        if (Array.isArray(parsed)) return parsed;
+      } catch {
+      }
+      return [val];
+    }
+    return val;
+  },
+  external_exports.array(external_exports.string())
+);
+function createTaskTools(store) {
+  return [
+    tool14(
+      "list_tasks",
+      "List all tasks in the project, optionally filtered by status, linked epic, or priority",
+      {
+        status: external_exports.enum(["backlog", "ready", "in-progress", "review", "done"]).optional().describe("Filter by task status"),
+        linkedEpic: external_exports.string().optional().describe("Filter by linked epic ID (e.g. 'E-001')"),
+        priority: external_exports.enum(["critical", "high", "medium", "low"]).optional().describe("Filter by priority")
+      },
+      async (args) => {
+        let docs = store.list({ type: "task", status: args.status });
+        if (args.linkedEpic) {
+          docs = docs.filter(
+            (d) => normalizeLinkedEpics(d.frontmatter.linkedEpic).includes(args.linkedEpic)
+          );
+        }
+        if (args.priority) {
+          docs = docs.filter((d) => d.frontmatter.priority === args.priority);
+        }
+        const summary = docs.map((d) => ({
+          id: d.frontmatter.id,
+          title: d.frontmatter.title,
+          status: d.frontmatter.status,
+          linkedEpic: normalizeLinkedEpics(d.frontmatter.linkedEpic),
+          priority: d.frontmatter.priority,
+          complexity: d.frontmatter.complexity,
+          estimatedPoints: d.frontmatter.estimatedPoints,
+          tags: d.frontmatter.tags
+        }));
+        return {
+          content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
+        };
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool14(
+      "get_task",
+      "Get the full content of a specific task by ID",
+      { id: external_exports.string().describe("Task ID (e.g. 'T-001')") },
+      async (args) => {
+        const doc = store.get(args.id);
+        if (!doc) {
+          return {
+            content: [{ type: "text", text: `Task ${args.id} not found` }],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { ...doc.frontmatter, content: doc.content },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool14(
+      "create_task",
+      "Create a new implementation task linked to one or more epics. The linked epic is soft-validated (warns if not found, but does not block creation).",
+      {
+        title: external_exports.string().describe("Task title"),
+        content: external_exports.string().describe("Task description and implementation details"),
+        linkedEpic: linkedEpicArray.describe("Epic ID(s) to link this task to (e.g. ['E-001'] or ['E-001', 'E-002'])"),
+        status: external_exports.enum(["backlog", "ready", "in-progress", "review", "done"]).optional().describe("Task status (default: 'backlog')"),
+        acceptanceCriteria: external_exports.string().optional().describe("Acceptance criteria for the task"),
+        technicalNotes: external_exports.string().optional().describe("Technical implementation notes"),
+        estimatedPoints: external_exports.number().optional().describe("Story point estimate"),
+        complexity: external_exports.enum(["trivial", "simple", "moderate", "complex", "very-complex"]).optional().describe("Task complexity"),
+        priority: external_exports.enum(["critical", "high", "medium", "low"]).optional().describe("Task priority"),
+        tags: external_exports.array(external_exports.string()).optional().describe("Additional tags")
+      },
+      async (args) => {
+        const linkedEpics = normalizeLinkedEpics(args.linkedEpic);
+        const warnings = [];
+        for (const epicId of linkedEpics) {
+          const epic = store.get(epicId);
+          if (!epic) {
+            warnings.push(`Warning: Epic ${epicId} not found`);
+          } else if (epic.frontmatter.type !== "epic") {
+            warnings.push(`Warning: ${epicId} is a ${epic.frontmatter.type}, not an epic`);
+          }
+        }
+        const frontmatter = {
+          title: args.title,
+          status: args.status ?? "backlog",
+          linkedEpic: linkedEpics,
+          tags: [...generateEpicTags(linkedEpics), ...args.tags ?? []]
+        };
+        if (args.acceptanceCriteria) frontmatter.acceptanceCriteria = args.acceptanceCriteria;
+        if (args.technicalNotes) frontmatter.technicalNotes = args.technicalNotes;
+        if (args.estimatedPoints !== void 0) frontmatter.estimatedPoints = args.estimatedPoints;
+        if (args.complexity) frontmatter.complexity = args.complexity;
+        if (args.priority) frontmatter.priority = args.priority;
+        const doc = store.create("task", frontmatter, args.content);
+        const parts = [
+          `Created task ${doc.frontmatter.id}: ${doc.frontmatter.title} (linked to ${linkedEpics.join(", ")})`
+        ];
+        if (warnings.length > 0) {
+          parts.push(warnings.join("; "));
+        }
+        return {
+          content: [{ type: "text", text: parts.join("\n") }]
+        };
+      }
+    ),
+    tool14(
+      "update_task",
+      "Update an existing task, including its linked epics.",
+      {
+        id: external_exports.string().describe("Task ID to update"),
+        title: external_exports.string().optional().describe("New title"),
+        status: external_exports.enum(["backlog", "ready", "in-progress", "review", "done"]).optional().describe("New status"),
+        content: external_exports.string().optional().describe("New content"),
+        linkedEpic: linkedEpicArray.optional().describe("New linked epic ID(s)"),
+        acceptanceCriteria: external_exports.string().optional().describe("New acceptance criteria"),
+        technicalNotes: external_exports.string().optional().describe("New technical notes"),
+        estimatedPoints: external_exports.number().optional().describe("New story point estimate"),
+        complexity: external_exports.enum(["trivial", "simple", "moderate", "complex", "very-complex"]).optional().describe("New complexity"),
+        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 old tags, add new ones)")
+      },
+      async (args) => {
+        const { id, content, linkedEpic: rawLinkedEpic, tags: userTags, ...updates } = args;
+        const warnings = [];
+        if (rawLinkedEpic !== void 0) {
+          const linkedEpics = normalizeLinkedEpics(rawLinkedEpic);
+          for (const epicId of linkedEpics) {
+            const epic = store.get(epicId);
+            if (!epic) {
+              warnings.push(`Warning: Epic ${epicId} not found`);
+            } else if (epic.frontmatter.type !== "epic") {
+              warnings.push(`Warning: ${epicId} is a ${epic.frontmatter.type}, not an epic`);
+            }
+          }
+          updates.linkedEpic = linkedEpics;
+          const existingDoc = store.get(id);
+          const existingTags = existingDoc?.frontmatter.tags ?? [];
+          const nonEpicTags = existingTags.filter((t) => !t.startsWith("epic:"));
+          const baseTags = userTags ?? nonEpicTags;
+          updates.tags = [...generateEpicTags(linkedEpics), ...baseTags];
+        } else if (userTags !== void 0) {
+          updates.tags = userTags;
+        }
+        const doc = store.update(id, updates, content);
+        const parts = [`Updated task ${doc.frontmatter.id}: ${doc.frontmatter.title}`];
+        if (warnings.length > 0) {
+          parts.push(warnings.join("; "));
+        }
+        return {
+          content: [{ type: "text", text: parts.join("\n") }]
+        };
+      }
+    )
+  ];
+}
+
 // src/plugins/common.ts
 var COMMON_REGISTRATIONS = [
   { type: "meeting", dirName: "meetings", idPrefix: "M" },
@@ -18114,7 +19183,8 @@ var COMMON_REGISTRATIONS = [
   { type: "feature", dirName: "features", idPrefix: "F" },
   { type: "epic", dirName: "epics", idPrefix: "E" },
   { type: "contribution", dirName: "contributions", idPrefix: "C" },
-  { type: "sprint", dirName: "sprints", idPrefix: "SP" }
+  { type: "sprint", dirName: "sprints", idPrefix: "SP" },
+  { type: "task", dirName: "tasks", idPrefix: "T" }
 ];
 function createCommonTools(store) {
   return [
@@ -18124,7 +19194,8 @@ function createCommonTools(store) {
     ...createEpicTools(store),
     ...createContributionTools(store),
     ...createSprintTools(store),
-    ...createSprintPlanningTools(store)
+    ...createSprintPlanningTools(store),
+    ...createTaskTools(store)
   ];
 }
 
@@ -18134,7 +19205,7 @@ var genericAgilePlugin = {
   name: "Generic Agile",
   description: "Default methodology plugin providing standard agile governance patterns for decisions, actions, and questions.",
   version: "0.1.0",
-  documentTypes: ["decision", "action", "question", "meeting", "report", "feature", "epic", "contribution", "sprint"],
+  documentTypes: ["decision", "action", "question", "meeting", "report", "feature", "epic", "contribution", "sprint", "task"],
   documentTypeRegistrations: [...COMMON_REGISTRATIONS],
   tools: (store) => [...createCommonTools(store)],
   promptFragments: {
@@ -18173,6 +19244,11 @@ var genericAgilePlugin = {
 - **create_epic**: Create implementation epics linked to approved features. The system enforces that the linked feature must exist and be approved \u2014 if it's still "draft", ask the Product Owner to approve it first.
 - **update_epic**: Update epic status (planned \u2192 in-progress \u2192 done), owner, and other fields.
 
+**Task Tools:**
+- **list_tasks** / **get_task**: Browse and read implementation tasks.
+- **create_task**: Create implementation tasks linked to epics. Linked epics are soft-validated (warns if not found, does not block). Tasks auto-generate \`epic:E-xxx\` tags. Default status: "backlog".
+- **update_task**: Update task status (backlog \u2192 ready \u2192 in-progress \u2192 review \u2192 done), acceptance criteria, technical notes, complexity, priority, and estimated points.
+
 **Feature Tools (read-only for awareness):**
 - **list_features** / **get_feature**: View features to understand what needs to be broken into epics.
 
@@ -18184,6 +19260,7 @@ var genericAgilePlugin = {
 
 **Key Workflow Rules:**
 - Only create epics against approved features \u2014 create_epic enforces this.
+- Break epics into tasks (T-xxx) with clear acceptance criteria and complexity estimates.
 - Tag work items (actions, decisions, questions) with \`epic:E-xxx\` to group them under an epic.
 - Collaborate with the Delivery Manager on target dates and effort estimates.
 - Each epic should have a clear scope and definition of done.
@@ -18219,6 +19296,9 @@ var genericAgilePlugin = {
 - **list_epics** / **get_epic**: View epics and their current status.
 - **update_epic**: Set targetDate and estimatedEffort on epics. Flag epics linked to deferred features.
 
+**Task Tools (read-only for tracking):**
+- **list_tasks** / **get_task**: View tasks and their statuses. Filter by linkedEpic to see implementation breakdown.
+
 **Feature Tools (tracking focus):**
 - **list_features** / **get_feature**: View features and their priorities.
 
@@ -18264,14 +19344,15 @@ var genericAgilePlugin = {
 - Reason through: priority (critical/high features first), capacity (compare backlog effort to velocity reference), dependencies and blockers, balance across features, and risk.
 - Present a structured sprint proposal: title, goal, suggested dates, selected epics with rationale for each, excluded epics with reason, and identified risks.
 - After user confirmation, use **create_sprint** with the agreed epics to persist the sprint.`,
-    "*": `You have access to feature, epic, sprint, and meeting tools for project coordination:
+    "*": `You have access to feature, epic, task, sprint, and meeting tools for project coordination:
 
 **Features** (F-xxx): Product capabilities defined by the Product Owner. Features progress through draft \u2192 approved \u2192 done.
 **Epics** (E-xxx): Implementation work packages created by the Tech Lead, linked to approved features. Epics progress through planned \u2192 in-progress \u2192 done.
+**Tasks** (T-xxx): Concrete implementation items created by the Tech Lead, linked to epics. Tasks progress through backlog \u2192 ready \u2192 in-progress \u2192 review \u2192 done.
 **Sprints** (SP-xxx): Time-boxed iterations that group epics and work items with delivery dates. Sprints progress through planned \u2192 active \u2192 completed (or cancelled).
 **Meetings**: Meeting records with attendees, agendas, and notes.
 
-**Key workflow rule:** Epics must link to approved features \u2014 the system enforces this. The Product Owner defines and approves features, the Tech Lead breaks them into epics, the Delivery Manager plans sprints and tracks dates and progress. Work items are associated with sprints via \`sprint:SP-xxx\` tags. Actions support a \`dueDate\` field for schedule tracking \u2014 actions with a past due date are automatically flagged as overdue in GAR reports. Use the \`sprints\` parameter on create_action/update_action to assign actions to sprints.
+**Key workflow rule:** Epics must link to approved features \u2014 the system enforces this. The Product Owner defines and approves features, the Tech Lead breaks them into epics and tasks, the Delivery Manager plans sprints and tracks dates and progress. Work items are associated with sprints via \`sprint:SP-xxx\` tags. Actions support a \`dueDate\` field for schedule tracking \u2014 actions with a past due date are automatically flagged as overdue in GAR reports. Use the \`sprints\` parameter on create_action/update_action to assign actions to sprints.
 
 - **list_meetings** / **get_meeting**: Browse and read meeting records.
 - **create_meeting**: Record meetings with attendees, date, and agenda. The meeting date is required \u2014 extract it from the meeting content or ask the user if not found.
@@ -18286,10 +19367,10 @@ var genericAgilePlugin = {
 };
 
 // src/plugins/builtin/tools/use-cases.ts
-import { tool as tool14 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool15 } from "@anthropic-ai/claude-agent-sdk";
 function createUseCaseTools(store) {
   return [
-    tool14(
+    tool15(
       "list_use_cases",
       "List all extension use cases, optionally filtered by status or extension type",
       {
@@ -18319,7 +19400,7 @@ function createUseCaseTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool14(
+    tool15(
       "get_use_case",
       "Get the full content of a specific use case by ID",
       { id: external_exports.string().describe("Use case ID (e.g. 'UC-001')") },
@@ -18346,7 +19427,7 @@ function createUseCaseTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool14(
+    tool15(
       "create_use_case",
       "Create a new extension use case definition (Phase 1: Assess Extension Use Case)",
       {
@@ -18380,7 +19461,7 @@ function createUseCaseTools(store) {
         };
       }
     ),
-    tool14(
+    tool15(
       "update_use_case",
       "Update an existing extension use case",
       {
@@ -18410,10 +19491,10 @@ function createUseCaseTools(store) {
 }
 
 // src/plugins/builtin/tools/tech-assessments.ts
-import { tool as tool15 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool16 } from "@anthropic-ai/claude-agent-sdk";
 function createTechAssessmentTools(store) {
   return [
-    tool15(
+    tool16(
       "list_tech_assessments",
       "List all technology assessments, optionally filtered by status",
       {
@@ -18444,7 +19525,7 @@ function createTechAssessmentTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool15(
+    tool16(
       "get_tech_assessment",
       "Get the full content of a specific technology assessment by ID",
       { id: external_exports.string().describe("Tech assessment ID (e.g. 'TA-001')") },
@@ -18471,7 +19552,7 @@ function createTechAssessmentTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool15(
+    tool16(
       "create_tech_assessment",
       "Create a new technology assessment linked to an assessed/approved use case (Phase 2: Assess Extension Technology)",
       {
@@ -18542,7 +19623,7 @@ function createTechAssessmentTools(store) {
         };
       }
     ),
-    tool15(
+    tool16(
       "update_tech_assessment",
       "Update an existing technology assessment. The linked use case cannot be changed.",
       {
@@ -18572,10 +19653,10 @@ function createTechAssessmentTools(store) {
 }
 
 // src/plugins/builtin/tools/extension-designs.ts
-import { tool as tool16 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool17 } from "@anthropic-ai/claude-agent-sdk";
 function createExtensionDesignTools(store) {
   return [
-    tool16(
+    tool17(
       "list_extension_designs",
       "List all extension designs, optionally filtered by status",
       {
@@ -18605,7 +19686,7 @@ function createExtensionDesignTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool16(
+    tool17(
       "get_extension_design",
       "Get the full content of a specific extension design by ID",
       { id: external_exports.string().describe("Extension design ID (e.g. 'XD-001')") },
@@ -18632,7 +19713,7 @@ function createExtensionDesignTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool16(
+    tool17(
       "create_extension_design",
       "Create a new extension design linked to a recommended tech assessment (Phase 3: Define Extension Target Solution)",
       {
@@ -18700,7 +19781,7 @@ function createExtensionDesignTools(store) {
         };
       }
     ),
-    tool16(
+    tool17(
       "update_extension_design",
       "Update an existing extension design. The linked tech assessment cannot be changed.",
       {
@@ -18729,10 +19810,10 @@ function createExtensionDesignTools(store) {
 }
 
 // src/plugins/builtin/tools/aem-reports.ts
-import { tool as tool17 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool18 } from "@anthropic-ai/claude-agent-sdk";
 function createAemReportTools(store) {
   return [
-    tool17(
+    tool18(
       "generate_extension_portfolio",
       "Generate a portfolio view of all use cases with their linked tech assessments and extension designs",
       {},
@@ -18784,7 +19865,7 @@ function createAemReportTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool17(
+    tool18(
       "generate_tech_readiness",
       "Generate a BTP technology readiness report showing service coverage and gaps across assessments",
       {},
@@ -18836,7 +19917,7 @@ function createAemReportTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool17(
+    tool18(
       "generate_phase_status",
       "Generate a phase progress report showing artifact counts and readiness per AEM phase",
       {},
@@ -18898,11 +19979,11 @@ function createAemReportTools(store) {
 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";
+import { tool as tool19 } from "@anthropic-ai/claude-agent-sdk";
 var PHASES = ["assess-use-case", "assess-technology", "define-solution"];
 function createAemPhaseTools(store, marvinDir) {
   return [
-    tool18(
+    tool19(
       "get_current_phase",
       "Get the current AEM phase from project configuration",
       {},
@@ -18923,7 +20004,7 @@ function createAemPhaseTools(store, marvinDir) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool18(
+    tool19(
       "advance_phase",
       "Advance to the next AEM phase. Performs soft gate checks and warns if artifacts are incomplete, but does not block.",
       {
@@ -19187,8 +20268,8 @@ function getPluginPromptFragment(plugin, personaId) {
 }
 
 // src/skills/registry.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import { fileURLToPath } from "url";
 import * as YAML3 from "yaml";
 import matter2 from "gray-matter";
@@ -19231,7 +20312,7 @@ Be thorough but concise. Focus on actionable insights.`,
 };
 
 // src/skills/builtin/jira/tools.ts
-import { tool as tool19 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool20 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/skills/builtin/jira/client.ts
 var JiraClient = class {
@@ -19241,8 +20322,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(path20, method = "GET", body) {
-    const url2 = `${this.baseUrl}${path20}`;
+  async request(path21, method = "GET", body) {
+    const url2 = `${this.baseUrl}${path21}`;
     const headers = {
       Authorization: this.authHeader,
       "Content-Type": "application/json",
@@ -19256,7 +20337,7 @@ var JiraClient = class {
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       throw new Error(
-        `Jira API error ${response.status} ${method} ${path20}: ${text}`
+        `Jira API error ${response.status} ${method} ${path21}: ${text}`
       );
     }
     if (response.status === 204) return void 0;
@@ -19336,11 +20417,12 @@ function findByJiraKey(store, jiraKey) {
   const docs = store.list({ type: JIRA_TYPE });
   return docs.find((d) => d.frontmatter.jiraKey === jiraKey);
 }
-function createJiraTools(store) {
+function createJiraTools(store, projectConfig) {
   const jiraUserConfig = loadUserConfig().jira;
+  const defaultProjectKey = projectConfig?.jira?.projectKey;
   return [
     // --- Local read tools ---
-    tool19(
+    tool20(
       "list_jira_issues",
       "List locally synced Jira issues (JI-xxx documents), optionally filtered by status or Jira key",
       {
@@ -19368,7 +20450,7 @@ function createJiraTools(store) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool19(
+    tool20(
       "get_jira_issue",
       "Get the full content of a locally synced Jira issue by local ID (JI-xxx) or Jira key (PROJ-123)",
       {
@@ -19401,7 +20483,7 @@ function createJiraTools(store) {
       { annotations: { readOnlyHint: true } }
     ),
     // --- Jira → Local tools ---
-    tool19(
+    tool20(
       "pull_jira_issue",
       "Fetch a single Jira issue by key and create/update a local JI-xxx document",
       {
@@ -19448,7 +20530,7 @@ function createJiraTools(store) {
         };
       }
     ),
-    tool19(
+    tool20(
       "pull_jira_issues_jql",
       "Bulk fetch Jira issues via JQL query and create/update local JI-xxx documents",
       {
@@ -19496,15 +20578,27 @@ function createJiraTools(store) {
       }
     ),
     // --- Local → Jira tools ---
-    tool19(
+    tool20(
       "push_artifact_to_jira",
       "Create a Jira issue from any Marvin artifact (D/A/Q/F/E) and create a tracking JI-xxx document",
       {
         artifactId: external_exports.string().describe("Marvin artifact ID (e.g. 'D-001', 'F-003', 'E-002')"),
-        projectKey: external_exports.string().describe("Jira project key (e.g. 'PROJ')"),
+        projectKey: external_exports.string().optional().describe("Jira project key (e.g. 'PROJ'). Falls back to jira.projectKey from .marvin/config.yaml if not provided."),
         issueType: external_exports.enum(["Story", "Task", "Bug", "Epic"]).optional().describe("Jira issue type (default: 'Task')")
       },
       async (args) => {
+        const resolvedProjectKey = args.projectKey ?? defaultProjectKey;
+        if (!resolvedProjectKey) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No projectKey provided and no default configured. Either pass projectKey or set jira.projectKey in .marvin/config.yaml."
+              }
+            ],
+            isError: true
+          };
+        }
         const jira = createJiraClient(jiraUserConfig);
         if (!jira) return jiraNotConfiguredError();
         const artifact = store.get(args.artifactId);
@@ -19524,7 +20618,7 @@ function createJiraTools(store) {
           `Status: ${artifact.frontmatter.status}`
         ].join("\n");
         const jiraResult = await jira.client.createIssue({
-          project: { key: args.projectKey },
+          project: { key: resolvedProjectKey },
           summary: artifact.frontmatter.title,
           description,
           issuetype: { name: args.issueType ?? "Task" }
@@ -19557,7 +20651,7 @@ function createJiraTools(store) {
       }
     ),
     // --- Bidirectional sync ---
-    tool19(
+    tool20(
       "sync_jira_issue",
       "Bidirectional sync: push local title/description to Jira, pull latest status/assignee/labels back",
       {
@@ -19598,7 +20692,7 @@ function createJiraTools(store) {
       }
     ),
     // --- Local link tool ---
-    tool19(
+    tool20(
       "link_artifact_to_jira",
       "Add a Marvin artifact ID to a JI-xxx document's linkedArtifacts field",
       {
@@ -19665,14 +20759,14 @@ var jiraSkill = {
   documentTypeRegistrations: [
     { type: "jira-issue", dirName: "jira-issues", idPrefix: "JI" }
   ],
-  tools: (store) => createJiraTools(store),
+  tools: (store, projectConfig) => createJiraTools(store, projectConfig),
   promptFragments: {
     "product-owner": `You have the **Jira Integration** skill. You can pull issues from Jira and push Marvin artifacts to Jira.
 
 **Available tools:**
 - \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues
 - \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
-- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, feature, etc.)
+- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, feature, etc.). The \`projectKey\` parameter is optional when a default is configured in \`.marvin/config.yaml\` under \`jira.projectKey\`.
 - \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
 - \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
 
@@ -19686,13 +20780,13 @@ var jiraSkill = {
 **Available tools:**
 - \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues
 - \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
-- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, action, epic, etc.)
+- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, action, epic, task, etc.). The \`projectKey\` parameter is optional when a default is configured in \`.marvin/config.yaml\` under \`jira.projectKey\`.
 - \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
 - \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
 
 **As Tech Lead, use Jira integration to:**
 - Pull technical issues and bugs for sprint planning and estimation
-- Push epics and technical decisions to Jira for cross-team visibility
+- Push epics, tasks, and technical decisions to Jira for cross-team visibility
 - Bidirectional sync to keep local governance and Jira in alignment
 - Use JQL queries to track technical debt (e.g. \`labels = "tech-debt" AND status != "Done"\`)`,
     "delivery-manager": `You have the **Jira Integration** skill. You can pull issues from Jira and push Marvin artifacts to Jira.
@@ -19700,22 +20794,426 @@ var jiraSkill = {
 **Available tools:**
 - \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues
 - \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
-- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, action, etc.)
+- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, action, etc.). The \`projectKey\` parameter is optional when a default is configured in \`.marvin/config.yaml\` under \`jira.projectKey\`.
 - \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
 - \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
 
 **As Delivery Manager, use Jira integration to:**
 - Pull sprint issues for tracking progress and blockers
-- Push actions and decisions to Jira for stakeholder visibility
+- Push actions, decisions, and tasks to Jira for stakeholder visibility
 - Use JQL queries for reporting (e.g. \`sprint in openSprints() AND assignee = currentUser()\`)
 - Sync status between Marvin governance items and Jira issues`
   }
 };
 
+// src/skills/builtin/prd-generator/tools.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { tool as tool21 } from "@anthropic-ai/claude-agent-sdk";
+var PRIORITY_ORDER2 = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+function priorityRank2(p) {
+  return PRIORITY_ORDER2[p ?? ""] ?? 99;
+}
+function gatherContext(store, focusFeature, includeDecisions = true, includeQuestions = true) {
+  const allFeatures = store.list({ type: "feature" });
+  const allEpics = store.list({ type: "epic" });
+  const allTasks = store.list({ type: "task" });
+  const allDecisions = includeDecisions ? store.list({ type: "decision" }) : [];
+  const allQuestions = includeQuestions ? store.list({ type: "question" }) : [];
+  const allActions = store.list({ type: "action" });
+  let features = allFeatures;
+  let epics = allEpics;
+  let tasks = allTasks;
+  if (focusFeature) {
+    features = features.filter((f) => f.frontmatter.id === focusFeature);
+    const featureIds = new Set(features.map((f) => f.frontmatter.id));
+    epics = epics.filter(
+      (e) => normalizeLinkedFeatures(e.frontmatter.linkedFeature).some((id) => featureIds.has(id))
+    );
+    const epicIds2 = new Set(epics.map((e) => e.frontmatter.id));
+    tasks = tasks.filter(
+      (t) => normalizeLinkedEpics(t.frontmatter.linkedEpic).some((id) => epicIds2.has(id))
+    );
+  }
+  const featuresByStatus = {};
+  for (const f of features) {
+    featuresByStatus[f.frontmatter.status] = (featuresByStatus[f.frontmatter.status] ?? 0) + 1;
+  }
+  const epicsByStatus = {};
+  for (const e of epics) {
+    epicsByStatus[e.frontmatter.status] = (epicsByStatus[e.frontmatter.status] ?? 0) + 1;
+  }
+  const epicIds = new Set(epics.map((e) => e.frontmatter.id));
+  return {
+    features: features.sort((a, b) => priorityRank2(a.frontmatter.priority) - priorityRank2(b.frontmatter.priority)).map((f) => ({
+      id: f.frontmatter.id,
+      title: f.frontmatter.title,
+      status: f.frontmatter.status,
+      priority: f.frontmatter.priority ?? "medium",
+      content: f.content,
+      linkedEpicCount: epics.filter(
+        (e) => normalizeLinkedFeatures(e.frontmatter.linkedFeature).includes(f.frontmatter.id)
+      ).length
+    })),
+    epics: epics.map((e) => ({
+      id: e.frontmatter.id,
+      title: e.frontmatter.title,
+      status: e.frontmatter.status,
+      linkedFeature: normalizeLinkedFeatures(e.frontmatter.linkedFeature),
+      targetDate: e.frontmatter.targetDate ?? null,
+      estimatedEffort: e.frontmatter.estimatedEffort ?? null,
+      content: e.content,
+      linkedTaskCount: tasks.filter(
+        (t) => normalizeLinkedEpics(t.frontmatter.linkedEpic).includes(e.frontmatter.id)
+      ).length
+    })),
+    tasks: tasks.map((t) => ({
+      id: t.frontmatter.id,
+      title: t.frontmatter.title,
+      status: t.frontmatter.status,
+      linkedEpic: normalizeLinkedEpics(t.frontmatter.linkedEpic),
+      acceptanceCriteria: t.frontmatter.acceptanceCriteria ?? null,
+      technicalNotes: t.frontmatter.technicalNotes ?? null,
+      complexity: t.frontmatter.complexity ?? null,
+      estimatedPoints: t.frontmatter.estimatedPoints ?? null,
+      priority: t.frontmatter.priority ?? null
+    })),
+    decisions: allDecisions.map((d) => ({
+      id: d.frontmatter.id,
+      title: d.frontmatter.title,
+      status: d.frontmatter.status,
+      content: d.content
+    })),
+    questions: allQuestions.map((q) => ({
+      id: q.frontmatter.id,
+      title: q.frontmatter.title,
+      status: q.frontmatter.status,
+      content: q.content
+    })),
+    actions: allActions.filter((a) => {
+      if (!focusFeature) return true;
+      const tags = a.frontmatter.tags ?? [];
+      return tags.some((t) => t.startsWith("epic:") && epicIds.has(t.replace("epic:", "")));
+    }).map((a) => ({
+      id: a.frontmatter.id,
+      title: a.frontmatter.title,
+      status: a.frontmatter.status,
+      owner: a.frontmatter.owner ?? null,
+      priority: a.frontmatter.priority ?? null,
+      dueDate: a.frontmatter.dueDate ?? null
+    })),
+    summary: {
+      totalFeatures: features.length,
+      totalEpics: epics.length,
+      totalTasks: tasks.length,
+      featuresByStatus,
+      epicsByStatus
+    }
+  };
+}
+function generateTaskMasterPrd(title, ctx, projectOverview) {
+  const lines = [];
+  lines.push(`# ${title}`);
+  lines.push("");
+  lines.push("## Project Overview");
+  if (projectOverview) {
+    lines.push(projectOverview);
+  } else if (ctx.features.length > 0) {
+    lines.push(`This project encompasses ${ctx.features.length} feature(s) spanning ${ctx.epics.length} epic(s) and ${ctx.tasks.length} implementation task(s).`);
+  }
+  lines.push("");
+  lines.push("## Goals");
+  for (const f of ctx.features) {
+    lines.push(`- **${f.title}** (${f.id}, Priority: ${f.priority}) \u2014 ${f.status}`);
+  }
+  lines.push("");
+  lines.push("## Features and Requirements");
+  lines.push("");
+  for (const feature of ctx.features) {
+    lines.push(`### ${feature.title} (${feature.id}) \u2014 Priority: ${feature.priority}`);
+    lines.push("");
+    if (feature.content) {
+      lines.push(feature.content);
+      lines.push("");
+    }
+    const featureEpics = ctx.epics.filter((e) => e.linkedFeature.includes(feature.id));
+    if (featureEpics.length > 0) {
+      lines.push("#### User Stories / Epics");
+      lines.push("");
+      for (const epic of featureEpics) {
+        const effort = epic.estimatedEffort ? `, Effort: ${epic.estimatedEffort}` : "";
+        lines.push(`- **${epic.id}: ${epic.title}** \u2014 Status: ${epic.status}${effort}`);
+        if (epic.content) {
+          lines.push(`  ${epic.content.split("\n")[0]}`);
+        }
+        const epicTasks = ctx.tasks.filter((t) => t.linkedEpic.includes(epic.id));
+        if (epicTasks.length > 0) {
+          lines.push("");
+          lines.push("#### Implementation Tasks");
+          lines.push("");
+          for (const task of epicTasks) {
+            const complexity = task.complexity ? `, Complexity: ${task.complexity}` : "";
+            const points = task.estimatedPoints != null ? `, Points: ${task.estimatedPoints}` : "";
+            lines.push(`- **${task.id}: ${task.title}**${complexity}${points}`);
+            if (task.acceptanceCriteria) {
+              lines.push(`  Acceptance Criteria: ${task.acceptanceCriteria}`);
+            }
+          }
+        }
+      }
+      lines.push("");
+    }
+  }
+  const approvedDecisions = ctx.decisions.filter((d) => d.status === "approved" || d.status === "accepted");
+  const openQuestions = ctx.questions.filter((q) => q.status === "open");
+  const technicalNotes = ctx.tasks.filter((t) => t.technicalNotes).map((t) => `- **${t.id}**: ${t.technicalNotes}`);
+  if (approvedDecisions.length > 0 || openQuestions.length > 0 || technicalNotes.length > 0) {
+    lines.push("## Technical Considerations");
+    lines.push("");
+    if (approvedDecisions.length > 0) {
+      lines.push("### Key Decisions");
+      for (const d of approvedDecisions) {
+        lines.push(`- **${d.id}: ${d.title}** \u2014 ${d.content.split("\n")[0]}`);
+      }
+      lines.push("");
+    }
+    if (technicalNotes.length > 0) {
+      lines.push("### Technical Notes");
+      for (const note of technicalNotes) {
+        lines.push(note);
+      }
+      lines.push("");
+    }
+    if (openQuestions.length > 0) {
+      lines.push("### Open Questions");
+      for (const q of openQuestions) {
+        lines.push(`- **${q.id}: ${q.title}** \u2014 ${q.content.split("\n")[0]}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("## Implementation Priorities");
+  lines.push("");
+  let priorityIdx = 1;
+  for (const feature of ctx.features) {
+    const featureEpics = ctx.epics.filter((e) => e.linkedFeature.includes(feature.id)).sort((a, b) => {
+      const statusOrder = { "in-progress": 0, planned: 1, done: 2 };
+      return (statusOrder[a.status] ?? 99) - (statusOrder[b.status] ?? 99);
+    });
+    if (featureEpics.length === 0) continue;
+    lines.push(`${priorityIdx}. **${feature.title}** (${feature.priority})`);
+    for (const epic of featureEpics) {
+      const epicTasks = ctx.tasks.filter((t) => t.linkedEpic.includes(epic.id));
+      lines.push(`   - ${epic.id}: ${epic.title} (${epic.status}) \u2014 ${epicTasks.length} task(s)`);
+    }
+    priorityIdx++;
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function generateClaudeCodePrd(title, ctx, projectOverview) {
+  const lines = [];
+  lines.push(`# ${title}`);
+  lines.push("");
+  lines.push("## Overview");
+  if (projectOverview) {
+    lines.push(projectOverview);
+  } else if (ctx.features.length > 0) {
+    lines.push(`This project encompasses ${ctx.features.length} feature(s) spanning ${ctx.epics.length} epic(s) and ${ctx.tasks.length} implementation task(s).`);
+  }
+  lines.push("");
+  const approvedDecisions = ctx.decisions.filter((d) => d.status === "approved" || d.status === "accepted");
+  if (approvedDecisions.length > 0) {
+    lines.push("## Architecture & Technical Decisions");
+    lines.push("");
+    for (const d of approvedDecisions) {
+      lines.push(`### ${d.id}: ${d.title}`);
+      lines.push(d.content);
+      lines.push("");
+    }
+  }
+  lines.push("## Implementation Plan");
+  lines.push("");
+  const priorityGroups = {};
+  for (const f of ctx.features) {
+    const group = f.priority === "critical" || f.priority === "high" ? "Phase 1: High Priority" : "Phase 2: Medium & Low Priority";
+    if (!priorityGroups[group]) priorityGroups[group] = [];
+    priorityGroups[group].push(f);
+  }
+  for (const [phase, features] of Object.entries(priorityGroups)) {
+    lines.push(`### ${phase}`);
+    lines.push("");
+    for (const feature of features) {
+      const featureEpics = ctx.epics.filter((e) => e.linkedFeature.includes(feature.id));
+      for (const epic of featureEpics) {
+        lines.push(`- [ ] ${epic.id}: ${epic.title}`);
+        const epicTasks = ctx.tasks.filter((t) => t.linkedEpic.includes(epic.id));
+        for (const task of epicTasks) {
+          const complexity = task.complexity ? `complexity: ${task.complexity}` : "";
+          const points = task.estimatedPoints != null ? `points: ${task.estimatedPoints}` : "";
+          const meta3 = [complexity, points].filter(Boolean).join(", ");
+          lines.push(`  - [ ] ${task.id}: ${task.title}${meta3 ? ` (${meta3})` : ""}`);
+          if (task.acceptanceCriteria) {
+            lines.push(`    - Acceptance: ${task.acceptanceCriteria}`);
+          }
+          if (task.technicalNotes) {
+            lines.push(`    - Notes: ${task.technicalNotes}`);
+          }
+        }
+      }
+    }
+    lines.push("");
+  }
+  const openQuestions = ctx.questions.filter((q) => q.status === "open");
+  if (openQuestions.length > 0) {
+    lines.push("## Open Questions");
+    lines.push("");
+    for (const q of openQuestions) {
+      lines.push(`- **${q.id}: ${q.title}** \u2014 ${q.content.split("\n")[0]}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function createPrdTools(store) {
+  return [
+    tool21(
+      "gather_prd_context",
+      "Aggregate all governance artifacts (features, epics, tasks, decisions, questions, actions) into structured JSON for PRD generation",
+      {
+        focusFeature: external_exports.string().optional().describe("Filter context to a specific feature ID (e.g. 'F-001')"),
+        includeDecisions: external_exports.boolean().optional().describe("Include decisions in context (default: true)"),
+        includeQuestions: external_exports.boolean().optional().describe("Include questions in context (default: true)")
+      },
+      async (args) => {
+        const ctx = gatherContext(store, args.focusFeature, args.includeDecisions ?? true, args.includeQuestions ?? true);
+        return {
+          content: [{ type: "text", text: JSON.stringify(ctx, null, 2) }]
+        };
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    tool21(
+      "generate_prd",
+      "Generate a PRD document from governance artifacts and save it as a PRD-xxx document",
+      {
+        title: external_exports.string().describe("PRD title"),
+        format: external_exports.enum(["taskmaster", "claude-code"]).describe("Output format: 'taskmaster' for Claude TaskMaster parse_prd, 'claude-code' for Claude Code consumption"),
+        projectOverview: external_exports.string().optional().describe("Project overview text (synthesized from features if not provided)"),
+        focusFeature: external_exports.string().optional().describe("Focus on a specific feature ID (e.g. 'F-001')"),
+        tags: external_exports.array(external_exports.string()).optional().describe("Tags for the PRD document")
+      },
+      async (args) => {
+        const ctx = gatherContext(store, args.focusFeature);
+        const prdContent = args.format === "taskmaster" ? generateTaskMasterPrd(args.title, ctx, args.projectOverview) : generateClaudeCodePrd(args.title, ctx, args.projectOverview);
+        const frontmatter = {
+          title: args.title,
+          status: "draft",
+          format: args.format
+        };
+        if (args.focusFeature) frontmatter.focusFeature = args.focusFeature;
+        if (args.tags) frontmatter.tags = args.tags;
+        const doc = store.create("prd", frontmatter, prdContent);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Generated PRD ${doc.frontmatter.id}: "${args.title}" (format: ${args.format}, ${ctx.summary.totalFeatures} features, ${ctx.summary.totalEpics} epics, ${ctx.summary.totalTasks} tasks)`
+            }
+          ]
+        };
+      }
+    ),
+    tool21(
+      "export_prd",
+      "Export a PRD document to a file path for external consumption (e.g. by Claude TaskMaster or Claude Code)",
+      {
+        prdId: external_exports.string().describe("PRD document ID (e.g. 'PRD-001')"),
+        outputPath: external_exports.string().describe("File path to write the PRD content to")
+      },
+      async (args) => {
+        const doc = store.get(args.prdId);
+        if (!doc) {
+          return {
+            content: [{ type: "text", text: `PRD ${args.prdId} not found` }],
+            isError: true
+          };
+        }
+        const outputDir = path6.dirname(args.outputPath);
+        fs6.mkdirSync(outputDir, { recursive: true });
+        fs6.writeFileSync(args.outputPath, doc.content, "utf-8");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Exported PRD ${args.prdId} to ${args.outputPath}`
+            }
+          ]
+        };
+      }
+    )
+  ];
+}
+
+// src/skills/builtin/prd-generator/index.ts
+var prdGeneratorSkill = {
+  id: "prd-generator",
+  name: "PRD Generator",
+  description: "Generate PRDs from governance artifacts for TaskMaster or Claude Code",
+  version: "1.0.0",
+  format: "builtin-ts",
+  documentTypeRegistrations: [
+    { type: "prd", dirName: "prds", idPrefix: "PRD" }
+  ],
+  tools: (store) => createPrdTools(store),
+  promptFragments: {
+    "tech-lead": `You have the **PRD Generator** skill. You can generate Product Requirements Documents from governance artifacts.
+
+**Available tools:**
+- \`gather_prd_context\` \u2014 aggregate features, epics, tasks, decisions, questions, and actions into structured JSON for analysis
+- \`generate_prd\` \u2014 generate a formatted PRD document and save it as PRD-xxx. Supports "taskmaster" format (for Claude TaskMaster parse_prd) and "claude-code" format (for Claude Code consumption)
+- \`export_prd\` \u2014 export a PRD document to a file path for external use
+
+**As Tech Lead, use PRD generation to:**
+- Create comprehensive PRDs that capture the full governance context
+- Export TaskMaster-format PRDs for automated task breakdown via \`parse_prd\`
+- Export Claude Code-format PRDs as implementation plans with checklists
+- Focus PRDs on specific features using the focusFeature parameter`,
+    "delivery-manager": `You have the **PRD Generator** skill. You can generate Product Requirements Documents from governance artifacts.
+
+**Available tools:**
+- \`gather_prd_context\` \u2014 aggregate all governance artifacts into structured JSON for review
+- \`generate_prd\` \u2014 generate a formatted PRD document (taskmaster or claude-code format)
+- \`export_prd\` \u2014 export a PRD to a file path
+
+**As Delivery Manager, use PRD generation to:**
+- Generate PRDs for stakeholder communication and project documentation
+- Review aggregated project context before sprint planning
+- Export PRDs to share with external teams or tools`,
+    "product-owner": `You have the **PRD Generator** skill. You can generate Product Requirements Documents from governance artifacts.
+
+**Available tools:**
+- \`gather_prd_context\` \u2014 aggregate features, epics, tasks, and decisions into structured JSON
+- \`generate_prd\` \u2014 generate a formatted PRD document
+- \`export_prd\` \u2014 export a PRD to a file path
+
+**As Product Owner, use PRD generation to:**
+- Generate PRDs that capture feature requirements and priorities
+- Review the complete governance context for product planning
+- Export PRDs for stakeholder review and sign-off`
+  }
+};
+
 // src/skills/registry.ts
 var BUILTIN_SKILLS = {
   "governance-review": governanceReviewSkill,
-  "jira": jiraSkill
+  "jira": jiraSkill,
+  "prd-generator": prdGeneratorSkill
 };
 var GOVERNANCE_TOOL_NAMES = [
   "mcp__marvin-governance__list_decisions",
@@ -19736,13 +21234,13 @@ var GOVERNANCE_TOOL_NAMES = [
 ];
 function getBuiltinSkillsDir() {
   const thisFile = fileURLToPath(import.meta.url);
-  return path6.join(path6.dirname(thisFile), "builtin");
+  return path7.join(path7.dirname(thisFile), "builtin");
 }
 function loadSkillFromDirectory(dirPath) {
-  const skillMdPath = path6.join(dirPath, "SKILL.md");
-  if (!fs6.existsSync(skillMdPath)) return void 0;
+  const skillMdPath = path7.join(dirPath, "SKILL.md");
+  if (!fs7.existsSync(skillMdPath)) return void 0;
   try {
-    const raw = fs6.readFileSync(skillMdPath, "utf-8");
+    const raw = fs7.readFileSync(skillMdPath, "utf-8");
     const { data, content } = matter2(raw);
     if (!data.name || !data.description) return void 0;
     const metadata = data.metadata ?? {};
@@ -19753,13 +21251,13 @@ function loadSkillFromDirectory(dirPath) {
     if (wildcardPrompt) {
       promptFragments["*"] = wildcardPrompt;
     }
-    const personasDir = path6.join(dirPath, "personas");
-    if (fs6.existsSync(personasDir)) {
+    const personasDir = path7.join(dirPath, "personas");
+    if (fs7.existsSync(personasDir)) {
       try {
-        for (const file2 of fs6.readdirSync(personasDir)) {
+        for (const file2 of fs7.readdirSync(personasDir)) {
           if (!file2.endsWith(".md")) continue;
           const personaId = file2.replace(/\.md$/, "");
-          const personaPrompt = fs6.readFileSync(path6.join(personasDir, file2), "utf-8").trim();
+          const personaPrompt = fs7.readFileSync(path7.join(personasDir, file2), "utf-8").trim();
           if (personaPrompt) {
             promptFragments[personaId] = personaPrompt;
           }
@@ -19768,10 +21266,10 @@ function loadSkillFromDirectory(dirPath) {
       }
     }
     let actions;
-    const actionsPath = path6.join(dirPath, "actions.yaml");
-    if (fs6.existsSync(actionsPath)) {
+    const actionsPath = path7.join(dirPath, "actions.yaml");
+    if (fs7.existsSync(actionsPath)) {
       try {
-        const actionsRaw = fs6.readFileSync(actionsPath, "utf-8");
+        const actionsRaw = fs7.readFileSync(actionsPath, "utf-8");
         actions = YAML3.parse(actionsRaw);
       } catch {
       }
@@ -19798,10 +21296,10 @@ function loadAllSkills(marvinDir) {
   }
   try {
     const builtinDir = getBuiltinSkillsDir();
-    if (fs6.existsSync(builtinDir)) {
-      for (const entry of fs6.readdirSync(builtinDir)) {
-        const entryPath = path6.join(builtinDir, entry);
-        if (!fs6.statSync(entryPath).isDirectory()) continue;
+    if (fs7.existsSync(builtinDir)) {
+      for (const entry of fs7.readdirSync(builtinDir)) {
+        const entryPath = path7.join(builtinDir, entry);
+        if (!fs7.statSync(entryPath).isDirectory()) continue;
         if (skills.has(entry)) continue;
         const skill = loadSkillFromDirectory(entryPath);
         if (skill) skills.set(skill.id, skill);
@@ -19810,18 +21308,18 @@ function loadAllSkills(marvinDir) {
   } catch {
   }
   if (marvinDir) {
-    const skillsDir = path6.join(marvinDir, "skills");
-    if (fs6.existsSync(skillsDir)) {
+    const skillsDir = path7.join(marvinDir, "skills");
+    if (fs7.existsSync(skillsDir)) {
       let entries;
       try {
-        entries = fs6.readdirSync(skillsDir);
+        entries = fs7.readdirSync(skillsDir);
       } catch {
         entries = [];
       }
       for (const entry of entries) {
-        const entryPath = path6.join(skillsDir, entry);
+        const entryPath = path7.join(skillsDir, entry);
         try {
-          if (fs6.statSync(entryPath).isDirectory()) {
+          if (fs7.statSync(entryPath).isDirectory()) {
             const skill = loadSkillFromDirectory(entryPath);
             if (skill) skills.set(skill.id, skill);
             continue;
@@ -19831,7 +21329,7 @@ function loadAllSkills(marvinDir) {
         }
         if (!entry.endsWith(".yaml") && !entry.endsWith(".yml")) continue;
         try {
-          const raw = fs6.readFileSync(entryPath, "utf-8");
+          const raw = fs7.readFileSync(entryPath, "utf-8");
           const parsed = YAML3.parse(raw);
           if (!parsed?.id || !parsed?.name || !parsed?.version) continue;
           const skill = {
@@ -19874,12 +21372,12 @@ function collectSkillRegistrations(skillIds, allSkills) {
   }
   return registrations;
 }
-function getSkillTools(skillIds, allSkills, store) {
+function getSkillTools(skillIds, allSkills, store, projectConfig) {
   const tools = [];
   for (const id of skillIds) {
     const skill = allSkills.get(id);
     if (skill?.tools) {
-      tools.push(...skill.tools(store));
+      tools.push(...skill.tools(store, projectConfig));
     }
   }
   return tools;
@@ -19936,12 +21434,12 @@ function getSkillAgentDefinitions(skillIds, allSkills) {
   return agents;
 }
 function migrateYamlToSkillMd(yamlPath, outputDir) {
-  const raw = fs6.readFileSync(yamlPath, "utf-8");
+  const raw = fs7.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)`);
   }
-  fs6.mkdirSync(outputDir, { recursive: true });
+  fs7.mkdirSync(outputDir, { recursive: true });
   const frontmatter = {
     name: parsed.id,
     description: parsed.description ?? ""
@@ -19955,15 +21453,15 @@ function migrateYamlToSkillMd(yamlPath, outputDir) {
   const skillMd = matter2.stringify(wildcardPrompt ? `
 ${wildcardPrompt}
 ` : "\n", frontmatter);
-  fs6.writeFileSync(path6.join(outputDir, "SKILL.md"), skillMd, "utf-8");
+  fs7.writeFileSync(path7.join(outputDir, "SKILL.md"), skillMd, "utf-8");
   if (promptFragments) {
     const personaKeys = Object.keys(promptFragments).filter((k) => k !== "*");
     if (personaKeys.length > 0) {
-      const personasDir = path6.join(outputDir, "personas");
-      fs6.mkdirSync(personasDir, { recursive: true });
+      const personasDir = path7.join(outputDir, "personas");
+      fs7.mkdirSync(personasDir, { recursive: true });
       for (const personaId of personaKeys) {
-        fs6.writeFileSync(
-          path6.join(personasDir, `${personaId}.md`),
+        fs7.writeFileSync(
+          path7.join(personasDir, `${personaId}.md`),
           `${promptFragments[personaId]}
 `,
           "utf-8"
@@ -19973,8 +21471,8 @@ ${wildcardPrompt}
   }
   const actions = parsed.actions;
   if (actions && actions.length > 0) {
-    fs6.writeFileSync(
-      path6.join(outputDir, "actions.yaml"),
+    fs7.writeFileSync(
+      path7.join(outputDir, "actions.yaml"),
       YAML3.stringify(actions),
       "utf-8"
     );
@@ -20053,7 +21551,7 @@ function openBrowser(url2) {
 var runningServer = null;
 function createWebTools(store, projectName, navGroups) {
   return [
-    tool20(
+    tool22(
       "start_web_dashboard",
       "Start the Marvin web dashboard on a local port. Returns the base URL. If already running, returns the existing URL.",
       {
@@ -20085,7 +21583,7 @@ function createWebTools(store, projectName, navGroups) {
         };
       }
     ),
-    tool20(
+    tool22(
       "stop_web_dashboard",
       "Stop the running Marvin web dashboard.",
       {},
@@ -20105,7 +21603,7 @@ function createWebTools(store, projectName, navGroups) {
         };
       }
     ),
-    tool20(
+    tool22(
       "get_web_dashboard_urls",
       "Get all available dashboard page URLs. The dashboard must be running.",
       {},
@@ -20119,6 +21617,7 @@ function createWebTools(store, projectName, navGroups) {
         const base = `http://localhost:${runningServer.port}`;
         const urls = {
           overview: base,
+          upcoming: `${base}/upcoming`,
           gar: `${base}/gar`,
           board: `${base}/board`
         };
@@ -20131,7 +21630,7 @@ function createWebTools(store, projectName, navGroups) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool20(
+    tool22(
       "get_dashboard_overview",
       "Get the project overview data: document type counts and recent activity. Works without the web server running.",
       {},
@@ -20153,7 +21652,7 @@ function createWebTools(store, projectName, navGroups) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool20(
+    tool22(
       "get_dashboard_gar",
       "Get the GAR (Governance, Actions, Risks) report as JSON. Works without the web server running.",
       {},
@@ -20165,7 +21664,7 @@ function createWebTools(store, projectName, navGroups) {
       },
       { annotations: { readOnlyHint: true } }
     ),
-    tool20(
+    tool22(
       "get_dashboard_board",
       "Get board data showing documents grouped by status. Optionally filter by document type. Works without the web server running.",
       {
@@ -20192,6 +21691,18 @@ function createWebTools(store, projectName, navGroups) {
         };
       },
       { annotations: { readOnlyHint: true } }
+    ),
+    tool22(
+      "get_dashboard_upcoming",
+      "Get upcoming data: due-soon actions and sprint tasks, plus trending items scored by relevance signals. Works without the web server running.",
+      {},
+      async () => {
+        const data = getUpcomingData(store);
+        return {
+          content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+        };
+      },
+      { annotations: { readOnlyHint: true } }
     )
   ];
 }
@@ -20217,8 +21728,8 @@ function createMarvinMcpServer(store, options) {
 }
 
 // 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 chalk from "chalk";
 import ora from "ora";
@@ -20227,13 +21738,13 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/storage/session-store.ts
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 import * as YAML4 from "yaml";
 var SessionStore = class {
   filePath;
   constructor(marvinDir) {
-    this.filePath = path7.join(marvinDir, "sessions.yaml");
+    this.filePath = path8.join(marvinDir, "sessions.yaml");
   }
   list() {
     const entries = this.load();
@@ -20274,9 +21785,9 @@ var SessionStore = class {
     this.write(entries);
   }
   load() {
-    if (!fs7.existsSync(this.filePath)) return [];
+    if (!fs8.existsSync(this.filePath)) return [];
     try {
-      const raw = fs7.readFileSync(this.filePath, "utf-8");
+      const raw = fs8.readFileSync(this.filePath, "utf-8");
       const parsed = YAML4.parse(raw);
       if (!Array.isArray(parsed)) return [];
       return parsed;
@@ -20285,11 +21796,11 @@ var SessionStore = class {
     }
   }
   write(entries) {
-    const dir = path7.dirname(this.filePath);
-    if (!fs7.existsSync(dir)) {
-      fs7.mkdirSync(dir, { recursive: true });
+    const dir = path8.dirname(this.filePath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
     }
-    fs7.writeFileSync(this.filePath, YAML4.stringify(entries), "utf-8");
+    fs8.writeFileSync(this.filePath, YAML4.stringify(entries), "utf-8");
   }
 };
 
@@ -20325,8 +21836,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 YAML5 from "yaml";
 var MANIFEST_FILE = ".manifest.yaml";
@@ -20339,37 +21850,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 = YAML5.parse(raw);
     return parsed ?? emptyManifest();
   }
   save() {
-    fs8.mkdirSync(this.sourcesDir, { recursive: true });
-    fs8.writeFileSync(this.manifestPath, YAML5.stringify(this.manifest), "utf-8");
+    fs9.mkdirSync(this.sourcesDir, { recursive: true });
+    fs9.writeFileSync(this.manifestPath, YAML5.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) {
@@ -20432,7 +21943,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");
   }
 };
@@ -20447,12 +21958,12 @@ 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;
-  const codeSkillTools = getSkillTools(skillIds, allSkills, store);
+  const codeSkillTools = getSkillTools(skillIds, allSkills, store, config2.project);
   const skillAgents = getSkillAgentDefinitions(skillIds, allSkills);
   const skillPromptFragment = getSkillPromptFragment(skillIds, allSkills, persona.id);
   const allSkillIds = [...allSkills.keys()];
@@ -20564,6 +22075,7 @@ Marvin \u2014 ${persona.name}
       "mcp__marvin-governance__get_dashboard_overview",
       "mcp__marvin-governance__get_dashboard_gar",
       "mcp__marvin-governance__get_dashboard_board",
+      "mcp__marvin-governance__get_dashboard_upcoming",
       ...pluginTools.map((t) => `mcp__marvin-governance__${t.name}`),
       ...codeSkillTools.map((t) => `mcp__marvin-governance__${t.name}`)
     ]
@@ -20657,13 +22169,13 @@ Session ended with error: ${message.subtype}`));
 }
 
 // src/mcp/stdio-server.ts
-import * as fs10 from "fs";
-import * as path10 from "path";
+import * as fs11 from "fs";
+import * as path11 from "path";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
 // src/skills/action-tools.ts
-import { tool as tool21 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool23 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/skills/action-runner.ts
 import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
@@ -20729,7 +22241,7 @@ function createSkillActionTools(skills, context) {
     if (!skill.actions) continue;
     for (const action of skill.actions) {
       tools.push(
-        tool21(
+        tool23(
           `${skill.id}__${action.id}`,
           action.description,
           {
@@ -20821,10 +22333,10 @@ ${lines.join("\n\n")}`;
 }
 
 // src/mcp/persona-tools.ts
-import { tool as tool22 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool24 } from "@anthropic-ai/claude-agent-sdk";
 function createPersonaTools(ctx, marvinDir) {
   return [
-    tool22(
+    tool24(
       "set_persona",
       "Set the active persona for this session. Returns full guidance for the selected persona including behavioral rules, allowed document types, and scope. Call this before working to ensure persona-appropriate behavior.",
       {
@@ -20854,7 +22366,7 @@ ${summaries}`
         };
       }
     ),
-    tool22(
+    tool24(
       "get_persona_guidance",
       "Get guidance for a persona without changing the active persona. If no persona is specified, lists all available personas with summaries.",
       {
@@ -20956,16 +22468,16 @@ function collectTools(marvinDir) {
   const plugin = resolvePlugin(config2.methodology);
   const registrations = plugin?.documentTypeRegistrations ?? [];
   const store = new DocumentStore(marvinDir, registrations);
-  const sourcesDir = path10.join(marvinDir, "sources");
-  const hasSourcesDir = fs10.existsSync(sourcesDir);
+  const sourcesDir = path11.join(marvinDir, "sources");
+  const hasSourcesDir = fs11.existsSync(sourcesDir);
   const manifest = hasSourcesDir ? new SourceManifestManager(marvinDir) : void 0;
   const pluginTools = plugin ? getPluginTools(plugin, store, marvinDir) : [];
   const sessionStore = new SessionStore(marvinDir);
   const allSkills = loadAllSkills(marvinDir);
   const allSkillIds = [...allSkills.keys()];
-  const codeSkillTools = getSkillTools(allSkillIds, allSkills, store);
+  const codeSkillTools = getSkillTools(allSkillIds, allSkills, store, config2);
   const skillsWithActions = allSkillIds.map((id) => allSkills.get(id)).filter((s) => s.actions && s.actions.length > 0);
-  const projectRoot = path10.dirname(marvinDir);
+  const projectRoot = path11.dirname(marvinDir);
   const actionTools = createSkillActionTools(skillsWithActions, { store, marvinDir, projectRoot });
   const allSkillRegs = collectSkillRegistrations(allSkillIds, allSkills);
   const navGroups = buildNavGroups({
@@ -21032,8 +22544,8 @@ async function startStdioServer(options) {
 import { Command } from "commander";
 
 // src/cli/commands/init.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs12 from "fs";
+import * as path12 from "path";
 import * as YAML6 from "yaml";
 import chalk2 from "chalk";
 import { input, confirm, select } from "@inquirer/prompts";
@@ -21099,7 +22611,7 @@ async function initCommand() {
   }
   const projectName = await input({
     message: "Project name:",
-    default: path11.basename(cwd)
+    default: path12.basename(cwd)
   });
   const methodology = await select({
     message: "Methodology:",
@@ -21111,21 +22623,21 @@ async function initCommand() {
   });
   const plugin = resolvePlugin(methodology);
   const registrations = plugin?.documentTypeRegistrations ?? [];
-  const marvinDir = path11.join(cwd, ".marvin");
+  const marvinDir = path12.join(cwd, ".marvin");
   const dirs = [
     marvinDir,
-    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")
+    path12.join(marvinDir, "templates"),
+    path12.join(marvinDir, "docs", "decisions"),
+    path12.join(marvinDir, "docs", "actions"),
+    path12.join(marvinDir, "docs", "questions"),
+    path12.join(marvinDir, "sources"),
+    path12.join(marvinDir, "skills")
   ];
   for (const reg of registrations) {
-    dirs.push(path11.join(marvinDir, "docs", reg.dirName));
+    dirs.push(path12.join(marvinDir, "docs", reg.dirName));
   }
   for (const dir of dirs) {
-    fs11.mkdirSync(dir, { recursive: true });
+    fs12.mkdirSync(dir, { recursive: true });
   }
   const config2 = {
     name: projectName,
@@ -21139,13 +22651,13 @@ async function initCommand() {
   if (methodology === "sap-aem") {
     config2.aem = { currentPhase: "assess-use-case" };
   }
-  fs11.writeFileSync(
-    path11.join(marvinDir, "config.yaml"),
+  fs12.writeFileSync(
+    path12.join(marvinDir, "config.yaml"),
     YAML6.stringify(config2),
     "utf-8"
   );
-  fs11.writeFileSync(
-    path11.join(marvinDir, "CLAUDE.md"),
+  fs12.writeFileSync(
+    path12.join(marvinDir, "CLAUDE.md"),
     getDefaultClaudeMdContent(projectName),
     "utf-8"
   );
@@ -21172,18 +22684,18 @@ Initialized Marvin project "${projectName}" in ${cwd}`));
     const sourceDir = await input({
       message: "Path to directory containing source documents:"
     });
-    const resolvedDir = path11.resolve(sourceDir);
-    if (fs11.existsSync(resolvedDir) && fs11.statSync(resolvedDir).isDirectory()) {
+    const resolvedDir = path12.resolve(sourceDir);
+    if (fs12.existsSync(resolvedDir) && fs12.statSync(resolvedDir).isDirectory()) {
       const sourceExts = [".pdf", ".md", ".txt"];
-      const files = fs11.readdirSync(resolvedDir).filter((f) => {
-        const ext = path11.extname(f).toLowerCase();
+      const files = fs12.readdirSync(resolvedDir).filter((f) => {
+        const ext = path12.extname(f).toLowerCase();
         return sourceExts.includes(ext);
       });
       let copied = 0;
       for (const file2 of files) {
-        const src = path11.join(resolvedDir, file2);
-        const dest = path11.join(marvinDir, "sources", file2);
-        fs11.copyFileSync(src, dest);
+        const src = path12.join(resolvedDir, file2);
+        const dest = path12.join(marvinDir, "sources", file2);
+        fs12.copyFileSync(src, dest);
         copied++;
       }
       if (copied > 0) {
@@ -21473,13 +22985,13 @@ async function setApiKey() {
 }
 
 // src/cli/commands/ingest.ts
-import * as fs13 from "fs";
-import * as path13 from "path";
+import * as fs14 from "fs";
+import * as path14 from "path";
 import chalk8 from "chalk";
 
 // src/sources/ingest.ts
-import * as fs12 from "fs";
-import * as path12 from "path";
+import * as fs13 from "fs";
+import * as path13 from "path";
 import chalk7 from "chalk";
 import ora2 from "ora";
 import { query as query4 } from "@anthropic-ai/claude-agent-sdk";
@@ -21582,15 +23094,15 @@ async function ingestFile(options) {
   const persona = getPersona(personaId);
   const manifest = new SourceManifestManager(marvinDir);
   const sourcesDir = manifest.sourcesDir;
-  const filePath = path12.join(sourcesDir, fileName);
-  if (!fs12.existsSync(filePath)) {
+  const filePath = path13.join(sourcesDir, fileName);
+  if (!fs13.existsSync(filePath)) {
     throw new Error(`Source file not found: ${filePath}`);
   }
-  const ext = path12.extname(fileName).toLowerCase();
+  const ext = path13.extname(fileName).toLowerCase();
   const isPdf = ext === ".pdf";
   let fileContent = null;
   if (!isPdf) {
-    fileContent = fs12.readFileSync(filePath, "utf-8");
+    fileContent = fs13.readFileSync(filePath, "utf-8");
   }
   const store = new DocumentStore(marvinDir);
   const createdArtifacts = [];
@@ -21693,9 +23205,9 @@ Ingest ended with error: ${message.subtype}`)
 async function ingestCommand(file2, options) {
   const project = loadProject();
   const marvinDir = project.marvinDir;
-  const sourcesDir = path13.join(marvinDir, "sources");
-  if (!fs13.existsSync(sourcesDir)) {
-    fs13.mkdirSync(sourcesDir, { recursive: true });
+  const sourcesDir = path14.join(marvinDir, "sources");
+  if (!fs14.existsSync(sourcesDir)) {
+    fs14.mkdirSync(sourcesDir, { recursive: true });
   }
   const manifest = new SourceManifestManager(marvinDir);
   manifest.scan();
@@ -21706,8 +23218,8 @@ async function ingestCommand(file2, options) {
     return;
   }
   if (file2) {
-    const filePath = path13.join(sourcesDir, file2);
-    if (!fs13.existsSync(filePath)) {
+    const filePath = path14.join(sourcesDir, file2);
+    if (!fs14.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.`));
@@ -21774,7 +23286,7 @@ import ora3 from "ora";
 import { input as input3 } from "@inquirer/prompts";
 
 // src/git/repository.ts
-import * as path14 from "path";
+import * as path15 from "path";
 import simpleGit from "simple-git";
 var MARVIN_GITIGNORE = `node_modules/
 .DS_Store
@@ -21794,7 +23306,7 @@ var DIR_TYPE_LABELS = {
 function buildCommitMessage(files) {
   const counts = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const parts2 = f.split(path14.sep).join("/").split("/");
+    const parts2 = f.split(path15.sep).join("/").split("/");
     const docsIdx = parts2.indexOf("docs");
     if (docsIdx !== -1 && docsIdx + 1 < parts2.length) {
       const dirName = parts2[docsIdx + 1];
@@ -21834,9 +23346,9 @@ var MarvinGit = class {
       );
     }
     await this.git.init();
-    const { writeFileSync: writeFileSync10 } = await import("fs");
-    writeFileSync10(
-      path14.join(this.marvinDir, ".gitignore"),
+    const { writeFileSync: writeFileSync11 } = await import("fs");
+    writeFileSync11(
+      path15.join(this.marvinDir, ".gitignore"),
       MARVIN_GITIGNORE,
       "utf-8"
     );
@@ -21956,7 +23468,7 @@ var MarvinGit = class {
     }
   }
   static async clone(url2, targetDir) {
-    const marvinDir = path14.join(targetDir, ".marvin");
+    const marvinDir = path15.join(targetDir, ".marvin");
     const { existsSync: existsSync17 } = await import("fs");
     if (existsSync17(marvinDir)) {
       throw new GitSyncError(
@@ -22142,8 +23654,8 @@ async function serveCommand() {
 }
 
 // src/cli/commands/skills.ts
-import * as fs14 from "fs";
-import * as path15 from "path";
+import * as fs15 from "fs";
+import * as path16 from "path";
 import * as YAML7 from "yaml";
 import matter3 from "gray-matter";
 import chalk10 from "chalk";
@@ -22249,14 +23761,14 @@ async function skillsRemoveCommand(skillId, options) {
 }
 async function skillsCreateCommand(name) {
   const project = loadProject();
-  const skillsDir = path15.join(project.marvinDir, "skills");
-  fs14.mkdirSync(skillsDir, { recursive: true });
-  const skillDir = path15.join(skillsDir, name);
-  if (fs14.existsSync(skillDir)) {
+  const skillsDir = path16.join(project.marvinDir, "skills");
+  fs15.mkdirSync(skillsDir, { recursive: true });
+  const skillDir = path16.join(skillsDir, name);
+  if (fs15.existsSync(skillDir)) {
     console.log(chalk10.yellow(`Skill directory already exists: ${skillDir}`));
     return;
   }
-  fs14.mkdirSync(skillDir, { recursive: true });
+  fs15.mkdirSync(skillDir, { recursive: true });
   const displayName = name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
   const frontmatter = {
     name,
@@ -22270,7 +23782,7 @@ async function skillsCreateCommand(name) {
 You have the **${displayName}** skill.
 `;
   const skillMd = matter3.stringify(body, frontmatter);
-  fs14.writeFileSync(path15.join(skillDir, "SKILL.md"), skillMd, "utf-8");
+  fs15.writeFileSync(path16.join(skillDir, "SKILL.md"), skillMd, "utf-8");
   const actions = [
     {
       id: "run",
@@ -22280,7 +23792,7 @@ You have the **${displayName}** skill.
       maxTurns: 5
     }
   ];
-  fs14.writeFileSync(path15.join(skillDir, "actions.yaml"), YAML7.stringify(actions), "utf-8");
+  fs15.writeFileSync(path16.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"));
@@ -22288,14 +23800,14 @@ You have the **${displayName}** skill.
 }
 async function skillsMigrateCommand() {
   const project = loadProject();
-  const skillsDir = path15.join(project.marvinDir, "skills");
-  if (!fs14.existsSync(skillsDir)) {
+  const skillsDir = path16.join(project.marvinDir, "skills");
+  if (!fs15.existsSync(skillsDir)) {
     console.log(chalk10.dim("No skills directory found."));
     return;
   }
   let entries;
   try {
-    entries = fs14.readdirSync(skillsDir);
+    entries = fs15.readdirSync(skillsDir);
   } catch {
     console.log(chalk10.red("Could not read skills directory."));
     return;
@@ -22307,16 +23819,16 @@ async function skillsMigrateCommand() {
   }
   let migrated = 0;
   for (const file2 of yamlFiles) {
-    const yamlPath = path15.join(skillsDir, file2);
+    const yamlPath = path16.join(skillsDir, file2);
     const baseName = file2.replace(/\.(yaml|yml)$/, "");
-    const outputDir = path15.join(skillsDir, baseName);
-    if (fs14.existsSync(outputDir)) {
+    const outputDir = path16.join(skillsDir, baseName);
+    if (fs15.existsSync(outputDir)) {
       console.log(chalk10.yellow(`Skipping "${file2}" \u2014 directory "${baseName}/" already exists.`));
       continue;
     }
     try {
       migrateYamlToSkillMd(yamlPath, outputDir);
-      fs14.renameSync(yamlPath, `${yamlPath}.bak`);
+      fs15.renameSync(yamlPath, `${yamlPath}.bak`);
       console.log(chalk10.green(`Migrated "${file2}" \u2192 "${baseName}/"`));
       migrated++;
     } catch (err) {
@@ -22330,35 +23842,35 @@ ${migrated} skill(s) migrated. Original files renamed to *.bak`));
 }
 
 // src/cli/commands/import.ts
-import * as fs17 from "fs";
-import * as path18 from "path";
+import * as fs18 from "fs";
+import * as path19 from "path";
 import chalk11 from "chalk";
 
 // src/import/engine.ts
-import * as fs16 from "fs";
-import * as path17 from "path";
+import * as fs17 from "fs";
+import * as path18 from "path";
 import matter5 from "gray-matter";
 
 // src/import/classifier.ts
-import * as fs15 from "fs";
-import * as path16 from "path";
+import * as fs16 from "fs";
+import * as path17 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 = path16.resolve(inputPath);
-  const stat = fs15.statSync(resolved);
+  const resolved = path17.resolve(inputPath);
+  const stat = fs16.statSync(resolved);
   if (!stat.isDirectory()) {
     return classifyFile(resolved, knownTypes);
   }
-  if (path16.basename(resolved) === ".marvin" || fs15.existsSync(path16.join(resolved, "config.yaml"))) {
+  if (path17.basename(resolved) === ".marvin" || fs16.existsSync(path17.join(resolved, "config.yaml"))) {
     return { type: "marvin-project", inputPath: resolved };
   }
   const allDirNames = /* @__PURE__ */ new Set([...CORE_DIR_NAMES, ...knownDirNames]);
-  const entries = fs15.readdirSync(resolved);
+  const entries = fs16.readdirSync(resolved);
   const hasDocSubdirs = entries.some(
-    (e) => allDirNames.has(e) && fs15.statSync(path16.join(resolved, e)).isDirectory()
+    (e) => allDirNames.has(e) && fs16.statSync(path17.join(resolved, e)).isDirectory()
   );
   if (hasDocSubdirs) {
     return { type: "docs-directory", inputPath: resolved };
@@ -22367,7 +23879,7 @@ function classifyPath(inputPath, knownTypes, knownDirNames) {
   if (mdFiles.length > 0) {
     const hasMarvinDocs = mdFiles.some((f) => {
       try {
-        const raw = fs15.readFileSync(path16.join(resolved, f), "utf-8");
+        const raw = fs16.readFileSync(path17.join(resolved, f), "utf-8");
         const { data } = matter4(raw);
         return isValidMarvinDocument(data, knownTypes);
       } catch {
@@ -22381,14 +23893,14 @@ function classifyPath(inputPath, knownTypes, knownDirNames) {
   return { type: "raw-source-dir", inputPath: resolved };
 }
 function classifyFile(filePath, knownTypes) {
-  const resolved = path16.resolve(filePath);
-  const ext = path16.extname(resolved).toLowerCase();
+  const resolved = path17.resolve(filePath);
+  const ext = path17.extname(resolved).toLowerCase();
   if (RAW_SOURCE_EXTENSIONS.has(ext)) {
     return { type: "raw-source-file", inputPath: resolved };
   }
   if (ext === ".md") {
     try {
-      const raw = fs15.readFileSync(resolved, "utf-8");
+      const raw = fs16.readFileSync(resolved, "utf-8");
       const { data } = matter4(raw);
       if (isValidMarvinDocument(data, knownTypes)) {
         return { type: "marvin-document", inputPath: resolved };
@@ -22513,9 +24025,9 @@ function executeImportPlan(plan, store, marvinDir, options) {
       continue;
     }
     if (item.action === "copy") {
-      const targetDir = path17.dirname(item.targetPath);
-      fs16.mkdirSync(targetDir, { recursive: true });
-      fs16.copyFileSync(item.sourcePath, item.targetPath);
+      const targetDir = path18.dirname(item.targetPath);
+      fs17.mkdirSync(targetDir, { recursive: true });
+      fs17.copyFileSync(item.sourcePath, item.targetPath);
       copied++;
       continue;
     }
@@ -22551,19 +24063,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}  ${path17.basename(item.sourcePath)}`);
+      lines.push(`  ${idInfo}  ${path18.basename(item.sourcePath)}`);
     }
   }
   if (copies.length > 0) {
     lines.push(`Files to copy to sources/: ${copies.length}`);
     for (const item of copies) {
-      lines.push(`  ${path17.basename(item.sourcePath)} \u2192 ${path17.basename(item.targetPath)}`);
+      lines.push(`  ${path18.basename(item.sourcePath)} \u2192 ${path18.basename(item.targetPath)}`);
     }
   }
   if (skips.length > 0) {
     lines.push(`Skipped (conflict): ${skips.length}`);
     for (const item of skips) {
-      lines.push(`  ${item.originalId ?? path17.basename(item.sourcePath)}  ${item.reason ?? ""}`);
+      lines.push(`  ${item.originalId ?? path18.basename(item.sourcePath)}  ${item.reason ?? ""}`);
     }
   }
   if (plan.items.length === 0) {
@@ -22596,11 +24108,11 @@ function getDirNameForType(store, type) {
 }
 function collectMarvinDocs(dir, knownTypes) {
   const docs = [];
-  const files = fs16.readdirSync(dir).filter((f) => f.endsWith(".md"));
+  const files = fs17.readdirSync(dir).filter((f) => f.endsWith(".md"));
   for (const file2 of files) {
-    const filePath = path17.join(dir, file2);
+    const filePath = path18.join(dir, file2);
     try {
-      const raw = fs16.readFileSync(filePath, "utf-8");
+      const raw = fs17.readFileSync(filePath, "utf-8");
       const { data, content } = matter5(raw);
       if (isValidMarvinDocument(data, knownTypes)) {
         docs.push({
@@ -22656,23 +24168,23 @@ function planDocImports(docs, store, options) {
 }
 function planFromMarvinProject(classification, store, _marvinDir, options) {
   let projectDir = classification.inputPath;
-  if (path17.basename(projectDir) !== ".marvin") {
-    const inner = path17.join(projectDir, ".marvin");
-    if (fs16.existsSync(inner)) {
+  if (path18.basename(projectDir) !== ".marvin") {
+    const inner = path18.join(projectDir, ".marvin");
+    if (fs17.existsSync(inner)) {
       projectDir = inner;
     }
   }
-  const docsDir = path17.join(projectDir, "docs");
-  if (!fs16.existsSync(docsDir)) {
+  const docsDir = path18.join(projectDir, "docs");
+  if (!fs17.existsSync(docsDir)) {
     return [];
   }
   const knownTypes = store.registeredTypes;
   const allDocs = [];
-  const subdirs = fs16.readdirSync(docsDir).filter(
-    (d) => fs16.statSync(path17.join(docsDir, d)).isDirectory()
+  const subdirs = fs17.readdirSync(docsDir).filter(
+    (d) => fs17.statSync(path18.join(docsDir, d)).isDirectory()
   );
   for (const subdir of subdirs) {
-    const docs = collectMarvinDocs(path17.join(docsDir, subdir), knownTypes);
+    const docs = collectMarvinDocs(path18.join(docsDir, subdir), knownTypes);
     allDocs.push(...docs);
   }
   return planDocImports(allDocs, store, options);
@@ -22682,10 +24194,10 @@ function planFromDocsDirectory(classification, store, _marvinDir, options) {
   const knownTypes = store.registeredTypes;
   const allDocs = [];
   allDocs.push(...collectMarvinDocs(dir, knownTypes));
-  const entries = fs16.readdirSync(dir);
+  const entries = fs17.readdirSync(dir);
   for (const entry of entries) {
-    const entryPath = path17.join(dir, entry);
-    if (fs16.statSync(entryPath).isDirectory()) {
+    const entryPath = path18.join(dir, entry);
+    if (fs17.statSync(entryPath).isDirectory()) {
       allDocs.push(...collectMarvinDocs(entryPath, knownTypes));
     }
   }
@@ -22694,7 +24206,7 @@ function planFromDocsDirectory(classification, store, _marvinDir, options) {
 function planFromSingleDocument(classification, store, _marvinDir, options) {
   const filePath = classification.inputPath;
   const knownTypes = store.registeredTypes;
-  const raw = fs16.readFileSync(filePath, "utf-8");
+  const raw = fs17.readFileSync(filePath, "utf-8");
   const { data, content } = matter5(raw);
   if (!isValidMarvinDocument(data, knownTypes)) {
     return [];
@@ -22710,14 +24222,14 @@ function planFromSingleDocument(classification, store, _marvinDir, options) {
 }
 function planFromRawSourceDir(classification, marvinDir) {
   const dir = classification.inputPath;
-  const sourcesDir = path17.join(marvinDir, "sources");
+  const sourcesDir = path18.join(marvinDir, "sources");
   const items = [];
-  const files = fs16.readdirSync(dir).filter((f) => {
-    const stat = fs16.statSync(path17.join(dir, f));
+  const files = fs17.readdirSync(dir).filter((f) => {
+    const stat = fs17.statSync(path18.join(dir, f));
     return stat.isFile();
   });
   for (const file2 of files) {
-    const sourcePath = path17.join(dir, file2);
+    const sourcePath = path18.join(dir, file2);
     const targetPath = resolveSourceFileName(sourcesDir, file2);
     items.push({
       action: "copy",
@@ -22728,8 +24240,8 @@ function planFromRawSourceDir(classification, marvinDir) {
   return items;
 }
 function planFromRawSourceFile(classification, marvinDir) {
-  const sourcesDir = path17.join(marvinDir, "sources");
-  const fileName = path17.basename(classification.inputPath);
+  const sourcesDir = path18.join(marvinDir, "sources");
+  const fileName = path18.basename(classification.inputPath);
   const targetPath = resolveSourceFileName(sourcesDir, fileName);
   return [
     {
@@ -22740,25 +24252,25 @@ function planFromRawSourceFile(classification, marvinDir) {
   ];
 }
 function resolveSourceFileName(sourcesDir, fileName) {
-  const targetPath = path17.join(sourcesDir, fileName);
-  if (!fs16.existsSync(targetPath)) {
+  const targetPath = path18.join(sourcesDir, fileName);
+  if (!fs17.existsSync(targetPath)) {
     return targetPath;
   }
-  const ext = path17.extname(fileName);
-  const base = path17.basename(fileName, ext);
+  const ext = path18.extname(fileName);
+  const base = path18.basename(fileName, ext);
   let counter = 1;
   let candidate;
   do {
-    candidate = path17.join(sourcesDir, `${base}-${counter}${ext}`);
+    candidate = path18.join(sourcesDir, `${base}-${counter}${ext}`);
     counter++;
-  } while (fs16.existsSync(candidate));
+  } while (fs17.existsSync(candidate));
   return candidate;
 }
 
 // src/cli/commands/import.ts
 async function importCommand(inputPath, options) {
-  const resolved = path18.resolve(inputPath);
-  if (!fs17.existsSync(resolved)) {
+  const resolved = path19.resolve(inputPath);
+  if (!fs18.existsSync(resolved)) {
     throw new ImportError(`Path not found: ${resolved}`);
   }
   const project = loadProject();
@@ -22810,7 +24322,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) => path18.basename(i.targetPath));
+    const copiedFileNames = result.items.filter((i) => i.action === "copy").map((i) => path19.basename(i.targetPath));
     for (const fileName of copiedFileNames) {
       try {
         await ingestFile({
@@ -23699,14 +25211,14 @@ async function webCommand(options) {
 }
 
 // src/cli/commands/generate.ts
-import * as fs18 from "fs";
-import * as path19 from "path";
+import * as fs19 from "fs";
+import * as path20 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 filePath = path20.join(project.marvinDir, "CLAUDE.md");
+  if (fs19.existsSync(filePath) && !options.force) {
     const overwrite = await confirm2({
       message: ".marvin/CLAUDE.md already exists. Overwrite?",
       default: false
@@ -23716,7 +25228,7 @@ async function generateClaudeMdCommand(options) {
       return;
     }
   }
-  fs18.writeFileSync(
+  fs19.writeFileSync(
     filePath,
     getDefaultClaudeMdContent(project.config.name),
     "utf-8"
@@ -23729,7 +25241,7 @@ 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.4.2");
+  ).version("0.4.5");
   program.command("init").description("Initialize a new Marvin project in the current directory").action(async () => {
     await initCommand();
   });