mrvn-cli 0.5.17 → 0.5.18

package/dist/marvin-serve.js

@@ -15635,6 +15635,14 @@ function evaluateHealth(projectName, metrics) {
 
 // src/reports/sprint-summary/collector.ts
 var DONE_STATUSES2 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var COMPLEXITY_WEIGHTS = {
+  trivial: 1,
+  simple: 2,
+  moderate: 3,
+  complex: 5,
+  "very-complex": 8
+};
+var DEFAULT_WEIGHT = 3;
 function collectSprintSummaryData(store, sprintId) {
   const allDocs = store.list();
   const sprintDocs = allDocs.filter((d) => d.frontmatter.type === "sprint");
@@ -15720,12 +15728,14 @@ function collectSprintSummaryData(store, sprintId) {
   for (const doc of workItemDocs) {
     const about = doc.frontmatter.aboutArtifact;
     const focusTag = (doc.frontmatter.tags ?? []).find((t) => t.startsWith("focus:"));
+    const complexity = doc.frontmatter.complexity;
     const item = {
       id: doc.frontmatter.id,
       title: doc.frontmatter.title,
       type: doc.frontmatter.type,
       status: doc.frontmatter.status,
       progress: getEffectiveProgress(doc.frontmatter),
+      weight: complexity && complexity in COMPLEXITY_WEIGHTS ? COMPLEXITY_WEIGHTS[complexity] : DEFAULT_WEIGHT,
       owner: doc.frontmatter.owner,
       workFocus: focusTag ? focusTag.slice(6) : void 0,
       aboutArtifact: about,
@@ -19271,6 +19281,47 @@ function extractJiraKeyFromTags(tags) {
   const tag = tags.find((t) => /^jira:[A-Z]+-\d+$/i.test(t));
   return tag ? tag.slice(5) : void 0;
 }
+function collectLinkedIssues(issue2) {
+  const linkedIssues = [];
+  if (issue2.fields.subtasks) {
+    for (const sub of issue2.fields.subtasks) {
+      linkedIssues.push({
+        key: sub.key,
+        summary: sub.fields.summary,
+        status: sub.fields.status.name,
+        relationship: "subtask",
+        isDone: DONE_STATUSES5.has(sub.fields.status.name.toLowerCase())
+      });
+    }
+  }
+  if (issue2.fields.issuelinks) {
+    for (const link of issue2.fields.issuelinks) {
+      if (link.outwardIssue) {
+        linkedIssues.push({
+          key: link.outwardIssue.key,
+          summary: link.outwardIssue.fields.summary,
+          status: link.outwardIssue.fields.status.name,
+          relationship: link.type.outward,
+          isDone: DONE_STATUSES5.has(
+            link.outwardIssue.fields.status.name.toLowerCase()
+          )
+        });
+      }
+      if (link.inwardIssue) {
+        linkedIssues.push({
+          key: link.inwardIssue.key,
+          summary: link.inwardIssue.fields.summary,
+          status: link.inwardIssue.fields.status.name,
+          relationship: link.type.inward,
+          isDone: DONE_STATUSES5.has(
+            link.inwardIssue.fields.status.name.toLowerCase()
+          )
+        });
+      }
+    }
+  }
+  return linkedIssues;
+}
 function computeSubtaskProgress(subtasks) {
   if (subtasks.length === 0) return 0;
   const done = subtasks.filter(
@@ -19311,44 +19362,7 @@ async function fetchJiraStatus(store, client, host, artifactId, statusMap) {
       const resolved = statusMap ?? {};
       const proposedStatus = artifactType === "task" ? mapJiraStatusForTask(issue2.fields.status.name, resolved, inSprint) : mapJiraStatusForAction(issue2.fields.status.name, resolved, inSprint);
       const currentStatus = doc.frontmatter.status;
-      const linkedIssues = [];
-      if (issue2.fields.subtasks) {
-        for (const sub of issue2.fields.subtasks) {
-          linkedIssues.push({
-            key: sub.key,
-            summary: sub.fields.summary,
-            status: sub.fields.status.name,
-            relationship: "subtask",
-            isDone: DONE_STATUSES5.has(sub.fields.status.name.toLowerCase())
-          });
-        }
-      }
-      if (issue2.fields.issuelinks) {
-        for (const link of issue2.fields.issuelinks) {
-          if (link.outwardIssue) {
-            linkedIssues.push({
-              key: link.outwardIssue.key,
-              summary: link.outwardIssue.fields.summary,
-              status: link.outwardIssue.fields.status.name,
-              relationship: link.type.outward,
-              isDone: DONE_STATUSES5.has(
-                link.outwardIssue.fields.status.name.toLowerCase()
-              )
-            });
-          }
-          if (link.inwardIssue) {
-            linkedIssues.push({
-              key: link.inwardIssue.key,
-              summary: link.inwardIssue.fields.summary,
-              status: link.inwardIssue.fields.status.name,
-              relationship: link.type.inward,
-              isDone: DONE_STATUSES5.has(
-                link.inwardIssue.fields.status.name.toLowerCase()
-              )
-            });
-          }
-        }
-      }
+      const linkedIssues = collectLinkedIssues(issue2);
       const subtasks = issue2.fields.subtasks ?? [];
       let proposedProgress;
       if (subtasks.length > 0 && !doc.frontmatter.progressOverride) {
@@ -19570,7 +19584,6 @@ function isWithinRange(timestamp, range) {
 function isConfluenceUrl(url2) {
   return /atlassian\.net\/wiki\//i.test(url2) || /\/confluence\//i.test(url2);
 }
-var DONE_STATUSES6 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "obsolete", "wont do"]);
 async function fetchJiraDaily(store, client, host, projectKey, dateRange, statusMap) {
   const summary = {
     dateRange,
@@ -19681,42 +19694,7 @@ async function processIssue(issue2, client, host, dateRange, jiraKeyToArtifacts,
       });
     }
   }
-  const linkedIssues = [];
-  if (issueWithLinks) {
-    if (issueWithLinks.fields.subtasks) {
-      for (const sub of issueWithLinks.fields.subtasks) {
-        linkedIssues.push({
-          key: sub.key,
-          summary: sub.fields.summary,
-          status: sub.fields.status.name,
-          relationship: "subtask",
-          isDone: DONE_STATUSES6.has(sub.fields.status.name.toLowerCase())
-        });
-      }
-    }
-    if (issueWithLinks.fields.issuelinks) {
-      for (const link of issueWithLinks.fields.issuelinks) {
-        if (link.outwardIssue) {
-          linkedIssues.push({
-            key: link.outwardIssue.key,
-            summary: link.outwardIssue.fields.summary,
-            status: link.outwardIssue.fields.status.name,
-            relationship: link.type.outward,
-            isDone: DONE_STATUSES6.has(link.outwardIssue.fields.status.name.toLowerCase())
-          });
-        }
-        if (link.inwardIssue) {
-          linkedIssues.push({
-            key: link.inwardIssue.key,
-            summary: link.inwardIssue.fields.summary,
-            status: link.inwardIssue.fields.status.name,
-            relationship: link.type.inward,
-            isDone: DONE_STATUSES6.has(link.inwardIssue.fields.status.name.toLowerCase())
-          });
-        }
-      }
-    }
-  }
+  const linkedIssues = issueWithLinks ? collectLinkedIssues(issueWithLinks) : [];
   const marvinArtifacts = [];
   const artifacts = jiraKeyToArtifacts.get(issue2.key) ?? [];
   for (const doc of artifacts) {
@@ -19846,22 +19824,23 @@ function generateProposedActions(issues) {
 
 // src/skills/builtin/jira/sprint-progress.ts
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
-var DONE_STATUSES7 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "obsolete", "wont do", "cancelled"]);
+var DONE_STATUSES6 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "obsolete", "wont do", "cancelled"]);
 var BATCH_SIZE = 5;
+var MAX_LINKED_ISSUES = 50;
 var BLOCKED_WEIGHT_RISK_THRESHOLD = 0.3;
-var COMPLEXITY_WEIGHTS = {
+var COMPLEXITY_WEIGHTS2 = {
   trivial: 1,
   simple: 2,
   moderate: 3,
   complex: 5,
   "very-complex": 8
 };
-var DEFAULT_WEIGHT = 3;
+var DEFAULT_WEIGHT2 = 3;
 function resolveWeight(complexity) {
-  if (complexity && complexity in COMPLEXITY_WEIGHTS) {
-    return { weight: COMPLEXITY_WEIGHTS[complexity], weightSource: "complexity" };
+  if (complexity && complexity in COMPLEXITY_WEIGHTS2) {
+    return { weight: COMPLEXITY_WEIGHTS2[complexity], weightSource: "complexity" };
   }
-  return { weight: DEFAULT_WEIGHT, weightSource: "default" };
+  return { weight: DEFAULT_WEIGHT2, weightSource: "default" };
 }
 function resolveProgress(frontmatter, commentAnalysisProgress) {
   const hasExplicitProgress = "progress" in frontmatter && typeof frontmatter.progress === "number";
@@ -19950,6 +19929,52 @@ async function assessSprintProgress(store, client, host, options = {}) {
       }
     }
   }
+  const linkedJiraIssues = /* @__PURE__ */ new Map();
+  if (options.traverseLinks) {
+    const visited = new Set(jiraIssues.keys());
+    const queue = [];
+    for (const [, data] of jiraIssues) {
+      const links = collectLinkedIssues(data.issue);
+      for (const link of links) {
+        if (link.relationship !== "subtask" && !visited.has(link.key)) {
+          visited.add(link.key);
+          queue.push(link.key);
+        }
+      }
+    }
+    while (queue.length > 0 && linkedJiraIssues.size < MAX_LINKED_ISSUES) {
+      const remaining = MAX_LINKED_ISSUES - linkedJiraIssues.size;
+      const batch = queue.splice(0, Math.min(BATCH_SIZE, remaining));
+      const results = await Promise.allSettled(
+        batch.map(async (key) => {
+          const [issue2, comments] = await Promise.all([
+            client.getIssueWithLinks(key),
+            client.getComments(key)
+          ]);
+          return { key, issue: issue2, comments };
+        })
+      );
+      for (const result of results) {
+        if (result.status === "fulfilled") {
+          const { key, issue: issue2, comments } = result.value;
+          linkedJiraIssues.set(key, { issue: issue2, comments });
+          const newLinks = collectLinkedIssues(issue2);
+          for (const link of newLinks) {
+            if (link.relationship !== "subtask" && !visited.has(link.key)) {
+              visited.add(link.key);
+              queue.push(link.key);
+            }
+          }
+        } else {
+          const batchKey = batch[results.indexOf(result)];
+          errors.push(`Failed to fetch linked issue ${batchKey}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+        }
+      }
+    }
+    if (queue.length > 0) {
+      errors.push(`Link traversal capped at ${MAX_LINKED_ISSUES} linked issues (${queue.length} remaining undiscovered)`);
+    }
+  }
   const proposedUpdates = [];
   const itemReports = [];
   const childReportsByParent = /* @__PURE__ */ new Map();
@@ -20015,6 +20040,23 @@ async function assessSprintProgress(store, client, host, options = {}) {
     const focusTag = tags.find((t) => t.startsWith("focus:"));
     const { weight, weightSource } = resolveWeight(fm.complexity);
     const { progress: resolvedProgress, progressSource } = resolveProgress(fm, null);
+    let itemLinkedIssues = [];
+    const itemLinkedIssueSignals = [];
+    if (options.traverseLinks && jiraData) {
+      const { allLinks, allSignals } = collectTransitiveLinks(
+        jiraData.issue,
+        jiraIssues,
+        linkedJiraIssues
+      );
+      itemLinkedIssues = allLinks;
+      itemLinkedIssueSignals.push(...allSignals);
+      analyzeLinkedIssueSignals(
+        allLinks,
+        fm,
+        jiraKey,
+        proposedUpdates
+      );
+    }
     const report = {
       id: fm.id,
       title: fm.title,
@@ -20033,6 +20075,8 @@ async function assessSprintProgress(store, client, host, options = {}) {
       progressDrift,
       commentSignals,
       commentSummary: null,
+      linkedIssues: itemLinkedIssues,
+      linkedIssueSignals: itemLinkedIssueSignals,
       children: [],
       owner: fm.owner ?? null,
       focusArea: focusTag ? focusTag.slice(6) : null
@@ -20076,7 +20120,7 @@ async function assessSprintProgress(store, client, host, options = {}) {
   const focusAreas = [];
   for (const [name, items] of focusAreaMap) {
     const allFlatItems = items.flatMap((i) => [i, ...i.children]);
-    const doneCount = allFlatItems.filter((i) => DONE_STATUSES7.has(i.marvinStatus)).length;
+    const doneCount = allFlatItems.filter((i) => DONE_STATUSES6.has(i.marvinStatus)).length;
     const blockedCount = allFlatItems.filter((i) => i.marvinStatus === "blocked").length;
     const progress = computeWeightedProgress(items);
     const totalWeight = items.reduce((s, i) => s + i.weight, 0);
@@ -20128,6 +20172,26 @@ async function assessSprintProgress(store, client, host, options = {}) {
         errors.push(`Comment analysis failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
+    if (options.traverseLinks) {
+      try {
+        const linkedSummaries = await analyzeLinkedIssueComments(
+          itemReports,
+          linkedJiraIssues
+        );
+        for (const [artifactId, signalSummaries] of linkedSummaries) {
+          const report = itemReports.find((r) => r.id === artifactId);
+          if (!report) continue;
+          for (const [sourceKey, summary] of signalSummaries) {
+            const signal = report.linkedIssueSignals.find((s) => s.sourceKey === sourceKey);
+            if (signal) {
+              signal.commentSummary = summary;
+            }
+          }
+        }
+      } catch (err) {
+        errors.push(`Linked issue comment analysis failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
   }
   const appliedUpdates = [];
   if (options.applyUpdates && proposedUpdates.length > 0) {
@@ -20244,6 +20308,155 @@ ${commentTexts}`);
   }
   return summaries;
 }
+function collectTransitiveLinks(primaryIssue, primaryIssues, linkedJiraIssues) {
+  const allLinks = [];
+  const allSignals = [];
+  const visited = /* @__PURE__ */ new Set([primaryIssue.key]);
+  const directLinks = collectLinkedIssues(primaryIssue).filter((l) => l.relationship !== "subtask");
+  const queue = [...directLinks];
+  for (const link of directLinks) {
+    visited.add(link.key);
+  }
+  while (queue.length > 0) {
+    const link = queue.shift();
+    allLinks.push(link);
+    const linkedData = linkedJiraIssues.get(link.key) ?? primaryIssues.get(link.key);
+    if (!linkedData) continue;
+    const linkedCommentSignals = [];
+    for (const comment of linkedData.comments) {
+      const text = extractCommentText(comment.body);
+      const signals = detectCommentSignals(text);
+      linkedCommentSignals.push(...signals);
+    }
+    if (linkedCommentSignals.length > 0 || linkedData.comments.length > 0) {
+      allSignals.push({
+        sourceKey: link.key,
+        linkType: link.relationship,
+        commentSignals: linkedCommentSignals,
+        commentSummary: null
+      });
+    }
+    const nextLinks = collectLinkedIssues(linkedData.issue).filter((l) => l.relationship !== "subtask" && !visited.has(l.key));
+    for (const next of nextLinks) {
+      visited.add(next.key);
+      queue.push(next);
+    }
+  }
+  return { allLinks, allSignals };
+}
+var BLOCKER_LINK_PATTERNS = ["blocks", "is blocked by"];
+var WONT_DO_STATUSES = /* @__PURE__ */ new Set(["wont do", "won't do", "cancelled"]);
+function analyzeLinkedIssueSignals(linkedIssues, frontmatter, jiraKey, proposedUpdates) {
+  if (linkedIssues.length === 0) return;
+  const blockerLinks = linkedIssues.filter(
+    (l) => BLOCKER_LINK_PATTERNS.some((p) => l.relationship.toLowerCase().includes(p.split(" ")[0]))
+  );
+  if (blockerLinks.length > 0 && blockerLinks.every((l) => l.isDone) && frontmatter.status === "blocked") {
+    proposedUpdates.push({
+      artifactId: frontmatter.id,
+      field: "status",
+      currentValue: "blocked",
+      proposedValue: "in-progress",
+      reason: `All blocking issues resolved: ${blockerLinks.map((l) => l.key).join(", ")}`
+    });
+  }
+  const wontDoLinks = linkedIssues.filter(
+    (l) => WONT_DO_STATUSES.has(l.status.toLowerCase())
+  );
+  if (wontDoLinks.length > 0) {
+    proposedUpdates.push({
+      artifactId: frontmatter.id,
+      field: "review",
+      currentValue: null,
+      proposedValue: "needs-review",
+      reason: `Linked issue(s) cancelled/won't do: ${wontDoLinks.map((l) => `${l.key} "${l.summary}"`).join(", ")}`
+    });
+  }
+}
+var LINKED_COMMENT_ANALYSIS_PROMPT = `You are a delivery management assistant analyzing Jira comments from linked issues for progress signals.
+
+For each linked issue below, read the comments and produce a 1-sentence summary focused on: impact on the parent issue, blockers, or decisions.
+
+Return your response as a JSON object mapping artifact IDs to objects mapping linked issue keys to summary strings.
+Example: {"T-001": {"PROJ-301": "DBA review scheduled for Thursday."}}
+
+IMPORTANT: Only return the JSON object, no other text.`;
+async function analyzeLinkedIssueComments(items, linkedJiraIssues) {
+  const results = /* @__PURE__ */ new Map();
+  const promptParts = [];
+  const itemsWithLinkedComments = [];
+  for (const item of items) {
+    if (item.linkedIssueSignals.length === 0) continue;
+    const linkedParts = [];
+    for (const signal of item.linkedIssueSignals) {
+      const linkedData = linkedJiraIssues.get(signal.sourceKey);
+      if (!linkedData || linkedData.comments.length === 0) continue;
+      const commentTexts = linkedData.comments.map((c) => {
+        const text = extractCommentText(c.body);
+        return `    [${c.author.displayName}, ${c.created.slice(0, 10)}]: ${text.slice(0, 300)}`;
+      }).join("\n");
+      linkedParts.push(`  ### ${signal.sourceKey} (${signal.linkType})
+${commentTexts}`);
+    }
+    if (linkedParts.length > 0) {
+      itemsWithLinkedComments.push(item);
+      promptParts.push(`## ${item.id} \u2014 ${item.title}
+Linked issues:
+${linkedParts.join("\n")}`);
+    }
+  }
+  if (promptParts.length === 0) return results;
+  const prompt = promptParts.join("\n\n");
+  const llmResult = query2({
+    prompt,
+    options: {
+      systemPrompt: LINKED_COMMENT_ANALYSIS_PROMPT,
+      maxTurns: 1,
+      tools: [],
+      allowedTools: []
+    }
+  });
+  for await (const msg of llmResult) {
+    if (msg.type === "assistant") {
+      const textBlock = msg.message.content.find(
+        (b) => b.type === "text"
+      );
+      if (textBlock) {
+        const parsed = parseLlmJson(textBlock.text);
+        if (parsed) {
+          for (const [artifactId, linkedSummaries] of Object.entries(parsed)) {
+            if (typeof linkedSummaries === "object" && linkedSummaries !== null) {
+              const signalMap = /* @__PURE__ */ new Map();
+              for (const [key, summary] of Object.entries(linkedSummaries)) {
+                if (typeof summary === "string") {
+                  signalMap.set(key, summary);
+                }
+              }
+              if (signalMap.size > 0) {
+                results.set(artifactId, signalMap);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function parseLlmJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    const match = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (match) {
+      try {
+        return JSON.parse(match[1]);
+      } catch {
+      }
+    }
+    return null;
+  }
+}
 function formatProgressReport(report) {
   const parts = [];
   parts.push(`# Sprint Progress Assessment \u2014 ${report.sprintId}`);
@@ -20327,7 +20540,7 @@ function formatProgressReport(report) {
 }
 function formatItemLine(parts, item, depth) {
   const indent = "  ".repeat(depth + 1);
-  const statusIcon = DONE_STATUSES7.has(item.marvinStatus) ? "\u2713" : item.marvinStatus === "blocked" ? "\u{1F6AB}" : item.marvinStatus === "in-progress" ? "\u25B6" : "\u25CB";
+  const statusIcon = DONE_STATUSES6.has(item.marvinStatus) ? "\u2713" : item.marvinStatus === "blocked" ? "\u{1F6AB}" : item.marvinStatus === "in-progress" ? "\u25B6" : "\u25CB";
   const jiraLabel = item.jiraKey ? ` [${item.jiraKey}: ${item.jiraStatus}]` : "";
   const driftFlag = item.statusDrift ? " \u26A0drift" : "";
   const progressLabel = ` ${item.progress}%`;
@@ -20337,6 +20550,19 @@ function formatItemLine(parts, item, depth) {
   if (item.commentSummary) {
     parts.push(`${indent}  \u{1F4AC} ${item.commentSummary}`);
   }
+  if (item.linkedIssues.length > 0) {
+    parts.push(`${indent}  \u{1F517} Linked Issues:`);
+    for (const link of item.linkedIssues) {
+      const doneMarker = link.isDone ? " \u2713" : "";
+      const blockerResolved = link.isDone && BLOCKER_LINK_PATTERNS.some((p) => link.relationship.toLowerCase().includes(p.split(" ")[0])) ? " unblock signal" : "";
+      const wontDo = WONT_DO_STATUSES.has(link.status.toLowerCase()) ? " \u26A0 needs review" : "";
+      parts.push(`${indent}    ${link.relationship} ${link.key} "${link.summary}" [${link.status}]${doneMarker}${blockerResolved}${wontDo}`);
+      const signal = item.linkedIssueSignals.find((s) => s.sourceKey === link.key);
+      if (signal?.commentSummary) {
+        parts.push(`${indent}      \u{1F4AC} ${signal.commentSummary}`);
+      }
+    }
+  }
   for (const child of item.children) {
     formatItemLine(parts, child, depth + 1);
   }
@@ -20346,6 +20572,506 @@ function progressBar(pct) {
   const empty = 10 - filled;
   return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}]`;
 }
+var MAX_ARTIFACT_NODES = 50;
+var MAX_LLM_DEPTH = 3;
+var MAX_LLM_COMMENT_CHARS = 8e3;
+async function assessArtifact(store, client, host, options) {
+  const visited = /* @__PURE__ */ new Set();
+  return _assessArtifactRecursive(store, client, host, options, visited, 0);
+}
+async function _assessArtifactRecursive(store, client, host, options, visited, depth) {
+  const errors = [];
+  if (visited.has(options.artifactId)) {
+    return emptyArtifactReport(options.artifactId, [`Cycle detected: ${options.artifactId} already visited`]);
+  }
+  if (visited.size >= MAX_ARTIFACT_NODES) {
+    return emptyArtifactReport(options.artifactId, [`Node cap reached (${MAX_ARTIFACT_NODES}), skipping ${options.artifactId}`]);
+  }
+  visited.add(options.artifactId);
+  const doc = store.get(options.artifactId);
+  if (!doc) {
+    return emptyArtifactReport(options.artifactId, [`Artifact ${options.artifactId} not found`]);
+  }
+  const fm = doc.frontmatter;
+  const jiraKey = fm.jiraKey ?? extractJiraKeyFromTags(fm.tags) ?? null;
+  const tags = fm.tags ?? [];
+  const sprintTag = tags.find((t) => t.startsWith("sprint:"));
+  const sprint = sprintTag ? sprintTag.slice(7) : null;
+  const parent = fm.aboutArtifact ?? null;
+  let jiraStatus = null;
+  let jiraAssignee = null;
+  let proposedMarvinStatus = null;
+  let jiraSubtaskProgress = null;
+  const commentSignals = [];
+  let commentSummary = null;
+  let linkedIssues = [];
+  let linkedIssueSignals = [];
+  const proposedUpdates = [];
+  const jiraIssues = /* @__PURE__ */ new Map();
+  const linkedJiraIssues = /* @__PURE__ */ new Map();
+  if (jiraKey) {
+    try {
+      const [issue2, comments] = await Promise.all([
+        client.getIssueWithLinks(jiraKey),
+        client.getComments(jiraKey)
+      ]);
+      jiraIssues.set(jiraKey, { issue: issue2, comments });
+      jiraStatus = issue2.fields.status.name;
+      jiraAssignee = issue2.fields.assignee?.displayName ?? null;
+      const inSprint = isInActiveSprint(store, fm.tags);
+      const resolved = options.statusMap ?? {};
+      proposedMarvinStatus = fm.type === "task" ? mapJiraStatusForTask(jiraStatus, resolved, inSprint) : mapJiraStatusForAction(jiraStatus, resolved, inSprint);
+      const subtasks = issue2.fields.subtasks ?? [];
+      if (subtasks.length > 0) {
+        jiraSubtaskProgress = computeSubtaskProgress(subtasks);
+      }
+      for (const comment of comments) {
+        const text = extractCommentText(comment.body);
+        const signals2 = detectCommentSignals(text);
+        commentSignals.push(...signals2);
+      }
+      const jiraVisited = /* @__PURE__ */ new Set([jiraKey]);
+      const queue = [];
+      const directLinks = collectLinkedIssues(issue2).filter((l) => l.relationship !== "subtask");
+      for (const link of directLinks) {
+        if (!jiraVisited.has(link.key)) {
+          jiraVisited.add(link.key);
+          queue.push(link.key);
+        }
+      }
+      while (queue.length > 0 && linkedJiraIssues.size < MAX_LINKED_ISSUES) {
+        const remaining = MAX_LINKED_ISSUES - linkedJiraIssues.size;
+        const batch = queue.splice(0, Math.min(BATCH_SIZE, remaining));
+        const results = await Promise.allSettled(
+          batch.map(async (key) => {
+            const [li, lc] = await Promise.all([
+              client.getIssueWithLinks(key),
+              client.getComments(key)
+            ]);
+            return { key, issue: li, comments: lc };
+          })
+        );
+        for (const result of results) {
+          if (result.status === "fulfilled") {
+            const { key, issue: li, comments: lc } = result.value;
+            linkedJiraIssues.set(key, { issue: li, comments: lc });
+            const newLinks = collectLinkedIssues(li).filter((l) => l.relationship !== "subtask" && !jiraVisited.has(l.key));
+            for (const nl of newLinks) {
+              jiraVisited.add(nl.key);
+              queue.push(nl.key);
+            }
+          } else {
+            const batchKey = batch[results.indexOf(result)];
+            errors.push(`Failed to fetch linked issue ${batchKey}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+          }
+        }
+      }
+      const { allLinks, allSignals } = collectTransitiveLinks(
+        issue2,
+        jiraIssues,
+        linkedJiraIssues
+      );
+      linkedIssues = allLinks;
+      linkedIssueSignals = allSignals;
+      analyzeLinkedIssueSignals(allLinks, fm, jiraKey, proposedUpdates);
+    } catch (err) {
+      errors.push(`Failed to fetch ${jiraKey}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const currentProgress = getEffectiveProgress(fm);
+  const statusDrift = proposedMarvinStatus !== null && proposedMarvinStatus !== fm.status;
+  const progressDrift = jiraSubtaskProgress !== null && !fm.progressOverride && jiraSubtaskProgress !== currentProgress;
+  if (statusDrift && proposedMarvinStatus) {
+    proposedUpdates.push({
+      artifactId: fm.id,
+      field: "status",
+      currentValue: fm.status,
+      proposedValue: proposedMarvinStatus,
+      reason: `Jira ${jiraKey} is "${jiraStatus}" \u2192 maps to "${proposedMarvinStatus}"`
+    });
+  }
+  if (progressDrift && jiraSubtaskProgress !== null) {
+    proposedUpdates.push({
+      artifactId: fm.id,
+      field: "progress",
+      currentValue: currentProgress,
+      proposedValue: jiraSubtaskProgress,
+      reason: `Jira ${jiraKey} subtask progress is ${jiraSubtaskProgress}%`
+    });
+  } else if (statusDrift && proposedMarvinStatus && !fm.progressOverride) {
+    const hasExplicitProgress = "progress" in fm && typeof fm.progress === "number";
+    if (!hasExplicitProgress) {
+      const proposedProgress = STATUS_PROGRESS_DEFAULTS[proposedMarvinStatus] ?? 0;
+      if (proposedProgress !== currentProgress) {
+        proposedUpdates.push({
+          artifactId: fm.id,
+          field: "progress",
+          currentValue: currentProgress,
+          proposedValue: proposedProgress,
+          reason: `Status changing to "${proposedMarvinStatus}" \u2192 default progress ${proposedProgress}%`
+        });
+      }
+    }
+  }
+  const primaryHasComments = jiraKey ? (jiraIssues.get(jiraKey)?.comments.length ?? 0) > 0 : false;
+  if (depth < MAX_LLM_DEPTH && jiraKey && primaryHasComments) {
+    const estimatedChars = estimateCommentTextSize(jiraIssues, linkedJiraIssues, linkedIssueSignals);
+    if (estimatedChars <= MAX_LLM_COMMENT_CHARS) {
+      try {
+        const summary = await analyzeSingleArtifactComments(
+          fm.id,
+          fm.title,
+          jiraKey,
+          jiraStatus,
+          jiraIssues,
+          linkedJiraIssues,
+          linkedIssueSignals
+        );
+        commentSummary = summary;
+      } catch (err) {
+        errors.push(`Comment analysis failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  const childIds = findChildIds(store, fm);
+  const children = [];
+  for (const childId of childIds) {
+    if (visited.size >= MAX_ARTIFACT_NODES) {
+      errors.push(`Node cap reached (${MAX_ARTIFACT_NODES}), ${childIds.length - children.length} children skipped`);
+      break;
+    }
+    const childReport = await _assessArtifactRecursive(
+      store,
+      client,
+      host,
+      { ...options, artifactId: childId },
+      visited,
+      depth + 1
+    );
+    children.push(childReport);
+  }
+  const signals = buildSignals(commentSignals, linkedIssues, statusDrift, proposedMarvinStatus);
+  const appliedUpdates = [];
+  if (options.applyUpdates && proposedUpdates.length > 0) {
+    for (const update of proposedUpdates) {
+      if (update.field === "review") continue;
+      try {
+        store.update(update.artifactId, {
+          [update.field]: update.proposedValue,
+          lastJiraSyncAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const updatedDoc = store.get(update.artifactId);
+        if (updatedDoc) {
+          if (updatedDoc.frontmatter.type === "task") {
+            propagateProgressFromTask(store, update.artifactId);
+          } else if (updatedDoc.frontmatter.type === "action") {
+            propagateProgressToAction(store, update.artifactId);
+          }
+        }
+        appliedUpdates.push(update);
+      } catch (err) {
+        errors.push(`Failed to apply update: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  return {
+    artifactId: fm.id,
+    title: fm.title,
+    type: fm.type,
+    marvinStatus: fm.status,
+    marvinProgress: currentProgress,
+    sprint,
+    parent,
+    jiraKey,
+    jiraStatus,
+    jiraAssignee,
+    jiraSubtaskProgress,
+    proposedMarvinStatus,
+    statusDrift,
+    progressDrift,
+    commentSignals,
+    commentSummary,
+    linkedIssues,
+    linkedIssueSignals,
+    children,
+    proposedUpdates: options.applyUpdates ? [] : proposedUpdates,
+    appliedUpdates,
+    signals,
+    errors
+  };
+}
+function findChildIds(store, fm) {
+  if (fm.type === "action") {
+    return store.list({ type: "task" }).filter((d) => d.frontmatter.aboutArtifact === fm.id).map((d) => d.frontmatter.id);
+  }
+  if (fm.type === "epic") {
+    const epicTag = `epic:${fm.id}`;
+    const isLinked = (d) => {
+      const le = d.frontmatter.linkedEpic;
+      if (le?.includes(fm.id)) return true;
+      const t = d.frontmatter.tags ?? [];
+      return t.includes(epicTag);
+    };
+    return [
+      ...store.list({ type: "action" }).filter(isLinked),
+      ...store.list({ type: "task" }).filter(isLinked)
+    ].map((d) => d.frontmatter.id);
+  }
+  return [];
+}
+function buildSignals(commentSignals, linkedIssues, statusDrift, proposedStatus) {
+  const signals = [];
+  const blockerSignals = commentSignals.filter((s) => s.type === "blocker");
+  if (blockerSignals.length > 0) {
+    for (const s of blockerSignals) {
+      signals.push(`\u{1F6AB} Blocker \u2014 "${s.snippet}"`);
+    }
+  }
+  const blockingLinks = linkedIssues.filter(
+    (l) => l.relationship.toLowerCase().includes("block")
+  );
+  const activeBlockers = blockingLinks.filter((l) => !l.isDone);
+  const resolvedBlockers = blockingLinks.filter((l) => l.isDone);
+  if (activeBlockers.length > 0) {
+    for (const b of activeBlockers) {
+      signals.push(`\u{1F6AB} Blocker \u2014 ${b.relationship} ${b.key} "${b.summary}" [${b.status}]`);
+    }
+  }
+  if (resolvedBlockers.length > 0 && activeBlockers.length === 0) {
+    signals.push(`\u2705 Unblocked \u2014 all blocking issues resolved: ${resolvedBlockers.map((l) => l.key).join(", ")}`);
+  }
+  const wontDoLinks = linkedIssues.filter((l) => WONT_DO_STATUSES.has(l.status.toLowerCase()));
+  for (const l of wontDoLinks) {
+    signals.push(`\u{1F504} Superseded \u2014 ${l.key} "${l.summary}" is ${l.status}`);
+  }
+  const questionSignals = commentSignals.filter((s) => s.type === "question");
+  for (const s of questionSignals) {
+    signals.push(`\u23F3 Waiting \u2014 "${s.snippet}"`);
+  }
+  const relatedInProgress = linkedIssues.filter(
+    (l) => l.relationship.toLowerCase().includes("relate") && !l.isDone
+  );
+  if (relatedInProgress.length > 0) {
+    for (const l of relatedInProgress) {
+      signals.push(`\u{1F4CB} Handoff \u2014 related work on ${l.key} "${l.summary}" [${l.status}]`);
+    }
+  }
+  if (signals.length === 0) {
+    if (statusDrift && proposedStatus) {
+      signals.push(`\u26A0 Drift detected \u2014 Marvin and Jira statuses diverge`);
+    } else {
+      signals.push(`\u2705 No active blockers or concerns detected`);
+    }
+  }
+  return signals;
+}
+function estimateCommentTextSize(jiraIssues, linkedJiraIssues, linkedIssueSignals) {
+  let total = 0;
+  for (const [, data] of jiraIssues) {
+    for (const c of data.comments) {
+      total += typeof c.body === "string" ? c.body.length : JSON.stringify(c.body).length;
+    }
+  }
+  for (const signal of linkedIssueSignals) {
+    const linkedData = linkedJiraIssues.get(signal.sourceKey);
+    if (!linkedData) continue;
+    for (const c of linkedData.comments) {
+      total += typeof c.body === "string" ? c.body.length : JSON.stringify(c.body).length;
+    }
+  }
+  return total;
+}
+var SINGLE_ARTIFACT_COMMENT_PROMPT = `You are a delivery management assistant analyzing Jira comments for a single work item.
+
+Produce a 2-3 sentence progress summary covering:
+- What work has been completed
+- What is pending or blocked
+- Any decisions, handoffs, or scheduling mentioned
+- Relevant context from linked issue comments (if provided)
+
+Return ONLY the summary text, no JSON or formatting.`;
+async function analyzeSingleArtifactComments(artifactId, title, jiraKey, jiraStatus, jiraIssues, linkedJiraIssues, linkedIssueSignals) {
+  const promptParts = [];
+  const primaryData = jiraIssues.get(jiraKey);
+  if (primaryData && primaryData.comments.length > 0) {
+    const commentTexts = primaryData.comments.map((c) => {
+      const text = extractCommentText(c.body);
+      return `[${c.author.displayName}, ${c.created.slice(0, 10)}]: ${text.slice(0, 500)}`;
+    }).join("\n");
+    promptParts.push(`## ${artifactId} \u2014 ${title} (${jiraKey}, status: ${jiraStatus})
+Comments:
+${commentTexts}`);
+  }
+  for (const signal of linkedIssueSignals) {
+    const linkedData = linkedJiraIssues.get(signal.sourceKey);
+    if (!linkedData || linkedData.comments.length === 0) continue;
+    const commentTexts = linkedData.comments.map((c) => {
+      const text = extractCommentText(c.body);
+      return `  [${c.author.displayName}, ${c.created.slice(0, 10)}]: ${text.slice(0, 300)}`;
+    }).join("\n");
+    promptParts.push(`### Linked: ${signal.sourceKey} (${signal.linkType})
+${commentTexts}`);
+  }
+  if (promptParts.length === 0) return null;
+  const prompt = promptParts.join("\n\n");
+  const result = query2({
+    prompt,
+    options: {
+      systemPrompt: SINGLE_ARTIFACT_COMMENT_PROMPT,
+      maxTurns: 1,
+      tools: [],
+      allowedTools: []
+    }
+  });
+  for await (const msg of result) {
+    if (msg.type === "assistant") {
+      const textBlock = msg.message.content.find(
+        (b) => b.type === "text"
+      );
+      if (textBlock) {
+        return textBlock.text.trim();
+      }
+    }
+  }
+  return null;
+}
+function emptyArtifactReport(artifactId, errors) {
+  return {
+    artifactId,
+    title: "Not found",
+    type: "unknown",
+    marvinStatus: "unknown",
+    marvinProgress: 0,
+    sprint: null,
+    parent: null,
+    jiraKey: null,
+    jiraStatus: null,
+    jiraAssignee: null,
+    jiraSubtaskProgress: null,
+    proposedMarvinStatus: null,
+    statusDrift: false,
+    progressDrift: false,
+    commentSignals: [],
+    commentSummary: null,
+    linkedIssues: [],
+    linkedIssueSignals: [],
+    children: [],
+    proposedUpdates: [],
+    appliedUpdates: [],
+    signals: [],
+    errors
+  };
+}
+function formatArtifactReport(report) {
+  const parts = [];
+  parts.push(`# Artifact Assessment \u2014 ${report.artifactId}`);
+  parts.push(report.title);
+  parts.push("");
+  parts.push(`## Marvin State`);
+  const marvinParts = [`Status: ${report.marvinStatus}`, `Progress: ${report.marvinProgress}%`];
+  if (report.sprint) marvinParts.push(`Sprint: ${report.sprint}`);
+  if (report.parent) marvinParts.push(`Parent: ${report.parent}`);
+  parts.push(marvinParts.join(" | "));
+  parts.push("");
+  if (report.jiraKey) {
+    parts.push(`## Jira State (${report.jiraKey})`);
+    const jiraParts = [`Status: ${report.jiraStatus ?? "unknown"}`];
+    if (report.jiraAssignee) jiraParts.push(`Assignee: ${report.jiraAssignee}`);
+    if (report.jiraSubtaskProgress !== null) jiraParts.push(`Subtask progress: ${report.jiraSubtaskProgress}%`);
+    parts.push(jiraParts.join(" | "));
+    if (report.statusDrift) {
+      parts.push(`\u26A0 Drift: ${report.marvinStatus} \u2192 ${report.proposedMarvinStatus}`);
+    }
+    if (report.progressDrift && report.jiraSubtaskProgress !== null) {
+      parts.push(`\u26A0 Progress drift: ${report.marvinProgress}% \u2192 ${report.jiraSubtaskProgress}%`);
+    }
+    parts.push("");
+  }
+  if (report.commentSummary) {
+    parts.push(`## Comments`);
+    parts.push(report.commentSummary);
+    parts.push("");
+  }
+  if (report.children.length > 0) {
+    const doneCount = report.children.filter((c) => DONE_STATUSES6.has(c.marvinStatus)).length;
+    const childWeights = report.children.map((c) => {
+      const { weight } = resolveWeight(void 0);
+      return { weight, progress: c.marvinProgress };
+    });
+    const childProgress = childWeights.length > 0 ? Math.round(childWeights.reduce((s, c) => s + c.weight * c.progress, 0) / childWeights.reduce((s, c) => s + c.weight, 0)) : 0;
+    const bar = progressBar(childProgress);
+    parts.push(`## Children (${doneCount}/${report.children.length} done) ${bar} ${childProgress}%`);
+    for (const child of report.children) {
+      formatArtifactChild(parts, child, 1);
+    }
+    parts.push("");
+  }
+  if (report.linkedIssues.length > 0) {
+    parts.push(`## Linked Issues (${report.linkedIssues.length})`);
+    for (const link of report.linkedIssues) {
+      const doneMarker = link.isDone ? " \u2713" : "";
+      parts.push(`  ${link.relationship} ${link.key} "${link.summary}" [${link.status}]${doneMarker}`);
+      const signal = report.linkedIssueSignals.find((s) => s.sourceKey === link.key);
+      if (signal?.commentSummary) {
+        parts.push(`    \u{1F4AC} ${signal.commentSummary}`);
+      }
+    }
+    parts.push("");
+  }
+  if (report.signals.length > 0) {
+    parts.push(`## Signals`);
+    for (const s of report.signals) {
+      parts.push(`  ${s}`);
+    }
+    parts.push("");
+  }
+  if (report.proposedUpdates.length > 0) {
+    parts.push(`## Proposed Updates (${report.proposedUpdates.length})`);
+    for (const update of report.proposedUpdates) {
+      parts.push(`  ${update.artifactId}.${update.field}: ${String(update.currentValue)} \u2192 ${String(update.proposedValue)}`);
+      parts.push(`    Reason: ${update.reason}`);
+    }
+    parts.push("");
+    parts.push("Run with applyUpdates=true to apply these changes.");
+    parts.push("");
+  }
+  if (report.appliedUpdates.length > 0) {
+    parts.push(`## Applied Updates (${report.appliedUpdates.length})`);
+    for (const update of report.appliedUpdates) {
+      parts.push(`  \u2713 ${update.artifactId}.${update.field}: ${String(update.currentValue)} \u2192 ${String(update.proposedValue)}`);
+    }
+    parts.push("");
+  }
+  if (report.errors.length > 0) {
+    parts.push(`## Errors`);
+    for (const err of report.errors) {
+      parts.push(`  ${err}`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function formatArtifactChild(parts, child, depth) {
+  const indent = "  ".repeat(depth);
+  const icon = DONE_STATUSES6.has(child.marvinStatus) ? "\u2713" : child.marvinStatus === "blocked" ? "\u{1F6AB}" : child.marvinStatus === "in-progress" ? "\u25B6" : "\u25CB";
+  const jiraLabel = child.jiraKey ? ` [${child.jiraKey}: ${child.jiraStatus ?? "?"}]` : "";
+  const driftLabel = child.statusDrift ? ` \u26A0drift \u2192 ${child.proposedMarvinStatus}` : "";
+  const signalHints = [];
+  for (const s of child.signals) {
+    if (s.startsWith("\u2705 No active")) continue;
+    signalHints.push(s);
+  }
+  parts.push(`${indent}${icon} ${child.artifactId} \u2014 ${child.title} [${child.marvinStatus}] ${child.marvinProgress}%${jiraLabel}${driftLabel}`);
+  if (child.commentSummary) {
+    parts.push(`${indent}  \u{1F4AC} ${child.commentSummary}`);
+  }
+  for (const hint of signalHints) {
+    parts.push(`${indent}  ${hint}`);
+  }
+  for (const grandchild of child.children) {
+    formatArtifactChild(parts, grandchild, depth + 1);
+  }
+}
 
 // src/skills/builtin/jira/tools.ts
 var JIRA_TYPE = "jira-issue";
@@ -21132,7 +21858,8 @@ function createJiraTools(store, projectConfig) {
       {
         sprintId: external_exports.string().optional().describe("Sprint ID (e.g. 'SP-001'). Defaults to active sprint."),
         analyzeComments: external_exports.boolean().optional().describe("Use LLM to summarize Jira comments for progress signals (default false)"),
-        applyUpdates: external_exports.boolean().optional().describe("Apply proposed status/progress updates to Marvin artifacts (default false)")
+        applyUpdates: external_exports.boolean().optional().describe("Apply proposed status/progress updates to Marvin artifacts (default false)"),
+        traverseLinks: external_exports.boolean().optional().describe("Traverse Jira issue links (1 hop) to surface context from connected issues \u2014 blockers, related work, cancelled items (default false)")
       },
       async (args) => {
         const jira = createJiraClient(jiraUserConfig);
@@ -21145,6 +21872,7 @@ function createJiraTools(store, projectConfig) {
             sprintId: args.sprintId,
             analyzeComments: args.analyzeComments ?? false,
             applyUpdates: args.applyUpdates ?? false,
+            traverseLinks: args.traverseLinks ?? false,
             statusMap
           }
         );
@@ -21154,6 +21882,34 @@ function createJiraTools(store, projectConfig) {
         };
       },
       { annotations: { readOnlyHint: false } }
+    ),
+    // --- Single-artifact assessment ---
+    tool20(
+      "assess_artifact",
+      "Deep assessment of a single Marvin artifact (task, action, or epic). Fetches live Jira status, analyzes comments with LLM, traverses all linked issues, detects drift, rolls up child progress, and extracts contextual signals (blockers, unblocks, handoffs, superseded work).",
+      {
+        artifactId: external_exports.string().describe("Marvin artifact ID (e.g. 'T-063', 'A-151', 'E-003')"),
+        applyUpdates: external_exports.boolean().optional().describe("Apply proposed status/progress updates to the artifact (default false)")
+      },
+      async (args) => {
+        const jira = createJiraClient(jiraUserConfig);
+        if (!jira) return jiraNotConfiguredError();
+        const report = await assessArtifact(
+          store,
+          jira.client,
+          jira.host,
+          {
+            artifactId: args.artifactId,
+            applyUpdates: args.applyUpdates ?? false,
+            statusMap
+          }
+        );
+        return {
+          content: [{ type: "text", text: formatArtifactReport(report) }],
+          isError: report.errors.length > 0 && report.type === "unknown"
+        };
+      },
+      { annotations: { readOnlyHint: false } }
     )
   ];
 }
@@ -21255,7 +22011,8 @@ var COMMON_TOOLS = `**Available tools:**
 - \`read_confluence_page\` \u2014 **read-only**: fetch and return the content of a Confluence page by URL or page ID. Use this to review Confluence content for updating tasks, generating contributions, or answering questions.
 - \`fetch_jira_status\` \u2014 **read-only**: fetch current Jira status, subtask progress, and linked issues for Jira-linked actions/tasks. Returns proposed changes without applying them.
 - \`fetch_jira_daily\` \u2014 **read-only**: fetch a daily/range summary of all Jira changes \u2014 status transitions, comments, linked Confluence pages, and cross-references with Marvin artifacts. Returns proposed actions (status updates, unlinked issues, question candidates, Confluence pages to review).
-- \`assess_sprint_progress\` \u2014 fetch live Jira statuses for all sprint-scoped items, detect drift, group by focus area with rollup progress, and extract comment signals. Use \`analyzeComments=true\` for LLM summaries, \`applyUpdates=true\` to apply changes.
+- \`assess_sprint_progress\` \u2014 fetch live Jira statuses for all sprint-scoped items, detect drift, group by focus area with rollup progress, and extract comment signals. Use \`analyzeComments=true\` for LLM summaries, \`applyUpdates=true\` to apply changes, \`traverseLinks=true\` to walk Jira issue links recursively.
+- \`assess_artifact\` \u2014 deep assessment of a single artifact (task, action, or epic). Fetches Jira status, LLM-summarizes comments, recursively traverses linked issues, detects drift, rolls up child progress, and extracts contextual signals (blockers, unblocks, handoffs, superseded work). Use \`applyUpdates=true\` to apply proposed changes.
 - \`fetch_jira_statuses\` \u2014 **read-only**: discover all Jira statuses in a project and show their Marvin mappings (mapped vs unmapped).
 - \`search_jira\` \u2014 **read-only**: search Jira via JQL and return results with Marvin cross-references. No documents created \u2014 use to preview before importing or find issues for linking.
 - \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import Jira issues as local JI-xxx documents (for Jira-originated items with no existing Marvin artifact).
@@ -21272,6 +22029,11 @@ var COMMON_WORKFLOW = `**Jira sync workflow:**
 2. Review focus area rollups, status drift, and blockers
 3. Optionally run with \`applyUpdates=true\` to bulk-sync statuses, or \`analyzeComments=true\` for LLM-powered comment summaries
 
+**Single-artifact deep dive:**
+1. Call \`assess_artifact\` with an artifact ID to get a focused assessment with Jira sync, comment analysis, link traversal, and child rollup
+2. Review signals (blockers, unblocks, handoffs) and proposed updates
+3. Use \`applyUpdates=true\` to apply changes
+
 **Daily review workflow:**
 1. Call \`fetch_jira_daily\` (optionally with \`from\`/\`to\` date range) to get a summary of all Jira activity
 2. Review the proposed actions: status updates, unlinked issues to track, questions that may be answered, Confluence pages to review
@@ -21296,6 +22058,7 @@ ${COMMON_WORKFLOW}
 **As Product Owner, use Jira integration to:**
 - Use \`fetch_jira_daily\` for daily standups \u2014 review what changed, identify status drift, spot untracked work
 - Use \`assess_sprint_progress\` for sprint reviews \u2014 see overall progress by focus area, detect drift, and identify blockers
+- Use \`assess_artifact\` for deep dives into specific features or epics \u2014 full Jira context, linked issues, and child rollup
 - Pull stakeholder-reported issues for triage and prioritization
 - Push approved features as Stories for development tracking
 - Link decisions to Jira issues for audit trail and traceability
@@ -21309,6 +22072,7 @@ ${COMMON_WORKFLOW}
 **As Tech Lead, use Jira integration to:**
 - Use \`fetch_jira_daily\` to review technical progress \u2014 status transitions, new comments, Confluence design docs
 - Use \`assess_sprint_progress\` for sprint health checks \u2014 focus area rollups, Jira drift detection, blocker tracking
+- Use \`assess_artifact\` to investigate a specific task \u2014 see full dependency chain, comment context, and blocker status
 - Pull technical issues and bugs for sprint planning and estimation
 - Push epics, tasks, and technical decisions to Jira for cross-team visibility
 - Use \`link_to_jira\` to connect Marvin tasks to existing Jira tickets
@@ -21324,6 +22088,7 @@ This is a third path for progress tracking alongside Contributions and Meetings.
 - Use \`fetch_jira_daily\` for daily progress reports \u2014 track what moved, identify blockers, spot untracked work
 - Use \`assess_sprint_progress\` for sprint reviews and stakeholder updates \u2014 comprehensive progress by focus area with Jira enrichment
 - Use \`assess_sprint_progress\` with \`applyUpdates=true\` to bulk-sync Marvin statuses from Jira
+- Use \`assess_artifact\` for focused status checks on critical items \u2014 full Jira context without running the whole sprint assessment
 - Pull sprint issues for tracking progress and blockers
 - Push actions and tasks to Jira for stakeholder visibility
 - Use \`fetch_jira_daily\` with a date range for sprint retrospectives (e.g. \`from: "2026-03-10", to: "2026-03-21"\`)
@@ -24718,7 +25483,7 @@ function buildHealthGauge(categories) {
 }
 
 // src/web/templates/pages/po/dashboard.ts
-var DONE_STATUSES8 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES7 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 var RESOLVED_DECISION_STATUSES = /* @__PURE__ */ new Set(["decided", "superseded", "dismissed"]);
 function poDashboardPage(ctx) {
   const overview = getOverviewData(ctx.store);
@@ -24763,7 +25528,7 @@ function poDashboardPage(ctx) {
       sprintTimelinePct = Math.min(100, Math.max(0, Math.round((Date.now() - startMs) / totalDays * 100)));
     }
   }
-  const featuresDone = features.filter((d) => DONE_STATUSES8.has(d.frontmatter.status)).length;
+  const featuresDone = features.filter((d) => DONE_STATUSES7.has(d.frontmatter.status)).length;
   const featuresOpen = features.filter((d) => d.frontmatter.status === "open").length;
   const featuresInProgress = features.filter((d) => d.frontmatter.status === "in-progress").length;
   const decisionsOpen = decisions.filter((d) => !RESOLVED_DECISION_STATUSES.has(d.frontmatter.status)).length;
@@ -24832,7 +25597,7 @@ function poDashboardPage(ctx) {
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const atRiskItems = [];
   for (const f of features) {
-    if (DONE_STATUSES8.has(f.frontmatter.status)) continue;
+    if (DONE_STATUSES7.has(f.frontmatter.status)) continue;
     const fEpics = featureToEpics.get(f.frontmatter.id) ?? [];
     const reasons = [];
     let blocked = 0;
@@ -24844,7 +25609,7 @@ function poDashboardPage(ctx) {
     if (blocked > 0) reasons.push(`${blocked} blocked task${blocked > 1 ? "s" : ""}`);
     for (const epic of fEpics) {
       const td = epic.frontmatter.targetDate;
-      if (td && td < today && !DONE_STATUSES8.has(epic.frontmatter.status)) {
+      if (td && td < today && !DONE_STATUSES7.has(epic.frontmatter.status)) {
         reasons.push(`${epic.frontmatter.id} overdue`);
       }
     }
@@ -25122,7 +25887,7 @@ function poBacklogPage(ctx) {
       }
     }
   }
-  const DONE_STATUSES17 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+  const DONE_STATUSES16 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
   function featureTaskStats(featureId) {
     const fEpics = featureToEpics.get(featureId) ?? [];
     let total = 0;
@@ -25131,7 +25896,7 @@ function poBacklogPage(ctx) {
     for (const epic of fEpics) {
       for (const t of epicToTasks.get(epic.frontmatter.id) ?? []) {
         total++;
-        if (DONE_STATUSES17.has(t.frontmatter.status)) done++;
+        if (DONE_STATUSES16.has(t.frontmatter.status)) done++;
         progressSum += getEffectiveProgress(t.frontmatter);
       }
     }
@@ -25377,23 +26142,34 @@ function hashString(s) {
   }
   return Math.abs(h);
 }
+var DONE_STATUS_SET = /* @__PURE__ */ new Set(["done", "closed", "resolved", "decided"]);
+var DEFAULT_WEIGHT3 = 3;
 function countFocusStats(items) {
   let total = 0;
   let done = 0;
   let inProgress = 0;
-  function walk(list) {
+  let totalWeight = 0;
+  let weightedSum = 0;
+  function walkStats(list) {
     for (const w of list) {
       if (w.type !== "contribution") {
         total++;
         const s = w.status.toLowerCase();
-        if (s === "done" || s === "closed" || s === "resolved" || s === "decided") done++;
+        if (DONE_STATUS_SET.has(s)) done++;
         else if (s === "in-progress" || s === "in progress") inProgress++;
       }
-      if (w.children) walk(w.children);
+      if (w.children) walkStats(w.children);
     }
   }
-  walk(items);
-  return { total, done, inProgress };
+  walkStats(items);
+  for (const w of items) {
+    if (w.type === "contribution") continue;
+    const weight = w.weight ?? DEFAULT_WEIGHT3;
+    const progress = w.progress ?? (DONE_STATUS_SET.has(w.status.toLowerCase()) ? 100 : 0);
+    totalWeight += weight;
+    weightedSum += weight * progress;
+  }
+  return { total, done, inProgress, weightedProgress: totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0 };
 }
 var KNOWN_OWNERS2 = /* @__PURE__ */ new Set(["po", "tl", "dm"]);
 function ownerBadge2(owner) {
@@ -25442,7 +26218,7 @@ function renderWorkItemsTable(items, options) {
   for (const [focus, groupItems] of focusGroups) {
     const color = focusColorMap.get(focus);
     const stats = countFocusStats(groupItems);
-    const pct = stats.total > 0 ? Math.round(stats.done / stats.total * 100) : 0;
+    const pct = stats.weightedProgress;
     const summaryParts = [];
     if (stats.done > 0) summaryParts.push(`${stats.done} done`);
     if (stats.inProgress > 0) summaryParts.push(`${stats.inProgress} in progress`);
@@ -25485,7 +26261,7 @@ function renderWorkItemsTable(items, options) {
     { titleTag: "h3", defaultCollapsed }
   );
 }
-var DONE_STATUSES9 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled", "decided"]);
+var DONE_STATUSES8 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled", "decided"]);
 function computeOwnerCompletionPct(items, owner) {
   let total = 0;
   let progressSum = 0;
@@ -25493,7 +26269,7 @@ function computeOwnerCompletionPct(items, owner) {
     for (const w of list) {
       if (w.type !== "contribution" && w.owner === owner) {
         total++;
-        progressSum += w.progress ?? (DONE_STATUSES9.has(w.status) ? 100 : 0);
+        progressSum += w.progress ?? (DONE_STATUSES8.has(w.status) ? 100 : 0);
       }
       if (w.children) walk(w.children);
     }
@@ -25514,7 +26290,7 @@ function filterItemsByOwner(items, owner) {
 }
 
 // src/web/templates/pages/po/delivery.ts
-var DONE_STATUSES10 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES9 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 var priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
 var statusOrder = { "in-progress": 0, open: 1, draft: 2, blocked: 3, done: 4, closed: 5, resolved: 6 };
 function priorityClass2(p) {
@@ -25655,7 +26431,7 @@ function poDeliveryPage(ctx) {
     }
     return total > 0 ? Math.round(progressSum / total) : 0;
   }
-  const nonDoneFeatures = features.filter((f) => !DONE_STATUSES10.has(f.frontmatter.status)).sort((a, b) => {
+  const nonDoneFeatures = features.filter((f) => !DONE_STATUSES9.has(f.frontmatter.status)).sort((a, b) => {
     const pa = priorityOrder[a.frontmatter.priority?.toLowerCase()] ?? 99;
     const pb = priorityOrder[b.frontmatter.priority?.toLowerCase()] ?? 99;
     if (pa !== pb) return pa - pb;
@@ -25864,7 +26640,7 @@ registerPersonaPage("po", "delivery", poDeliveryPage);
 registerPersonaPage("po", "stakeholders", poStakeholdersPage);
 
 // src/web/templates/pages/dm/dashboard.ts
-var DONE_STATUSES11 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES10 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 function progressBar3(pct) {
   return `<div class="sprint-progress-bar">
     <div class="sprint-progress-fill" style="width: ${pct}%"></div>
@@ -25875,7 +26651,7 @@ function dmDashboardPage(ctx) {
   const sprintData = getSprintSummaryData(ctx.store);
   const upcoming = getUpcomingData(ctx.store);
   const actions = ctx.store.list({ type: "action" });
-  const openActions = actions.filter((d) => !DONE_STATUSES11.has(d.frontmatter.status));
+  const openActions = actions.filter((d) => !DONE_STATUSES10.has(d.frontmatter.status));
   const overdueActions = upcoming.dueSoonActions.filter((a) => a.urgency === "overdue");
   const statsCards = `
     <div class="cards">
@@ -26096,7 +26872,7 @@ function dmSprintPage(ctx) {
 }
 
 // src/web/templates/pages/dm/actions.ts
-var DONE_STATUSES12 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES11 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 function urgencyBadge(tier) {
   const labels = {
     overdue: "Overdue",
@@ -26116,7 +26892,7 @@ function urgencyRowClass(tier) {
 function dmActionsPage(ctx) {
   const upcoming = getUpcomingData(ctx.store);
   const allActions = ctx.store.list({ type: "action" });
-  const openActions = allActions.filter((d) => !DONE_STATUSES12.has(d.frontmatter.status));
+  const openActions = allActions.filter((d) => !DONE_STATUSES11.has(d.frontmatter.status));
   const overdueActions = upcoming.dueSoonActions.filter((a) => a.urgency === "overdue");
   const dueThisWeek = upcoming.dueSoonActions.filter((a) => a.urgency === "due-3d" || a.urgency === "due-7d");
   const unownedActions = openActions.filter((d) => !d.frontmatter.owner);
@@ -26201,7 +26977,7 @@ function dmActionsPage(ctx) {
 }
 
 // src/web/templates/pages/dm/risks.ts
-var DONE_STATUSES13 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES12 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 function dmRisksPage(ctx) {
   const allDocs = ctx.store.list();
   const upcoming = getUpcomingData(ctx.store);
@@ -26212,7 +26988,7 @@ function dmRisksPage(ctx) {
   const todayMs = new Date(today).getTime();
   const fourteenDaysMs = 14 * 864e5;
   const agingItems = allDocs.filter((d) => {
-    if (DONE_STATUSES13.has(d.frontmatter.status)) return false;
+    if (DONE_STATUSES12.has(d.frontmatter.status)) return false;
     if (!["action", "question"].includes(d.frontmatter.type)) return false;
     const createdMs = new Date(d.frontmatter.created).getTime();
     return todayMs - createdMs > fourteenDaysMs;
@@ -26326,7 +27102,7 @@ function dmRisksPage(ctx) {
 }
 
 // src/web/templates/pages/dm/meetings.ts
-var DONE_STATUSES14 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES13 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 function dmMeetingsPage(ctx) {
   const meetings = ctx.store.list({ type: "meeting" });
   const actions = ctx.store.list({ type: "action" });
@@ -26372,7 +27148,7 @@ function dmMeetingsPage(ctx) {
             ${sortedMeetings.map((m) => {
     const date5 = m.frontmatter.date ?? m.frontmatter.created;
     const relatedActions = meetingActionMap.get(m.frontmatter.id) ?? [];
-    const openCount = relatedActions.filter((a) => !DONE_STATUSES14.has(a.frontmatter.status)).length;
+    const openCount = relatedActions.filter((a) => !DONE_STATUSES13.has(a.frontmatter.status)).length;
     return `
             <tr>
               <td>${formatDate(date5)}</td>
@@ -26387,7 +27163,7 @@ function dmMeetingsPage(ctx) {
   const recentMeetingActions = [];
   for (const [mid, acts] of meetingActionMap) {
     for (const act of acts) {
-      if (!DONE_STATUSES14.has(act.frontmatter.status)) {
+      if (!DONE_STATUSES13.has(act.frontmatter.status)) {
         recentMeetingActions.push({ action: act, meetingId: mid });
       }
     }
@@ -26582,7 +27358,7 @@ registerPersonaPage("dm", "meetings", dmMeetingsPage);
 registerPersonaPage("dm", "governance", dmGovernancePage);
 
 // src/web/templates/pages/tl/dashboard.ts
-var DONE_STATUSES15 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES14 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 var RESOLVED_DECISION_STATUSES2 = /* @__PURE__ */ new Set(["decided", "superseded", "dismissed"]);
 function tlDashboardPage(ctx) {
   const epics = ctx.store.list({ type: "epic" });
@@ -26590,8 +27366,8 @@ function tlDashboardPage(ctx) {
   const decisions = ctx.store.list({ type: "decision" });
   const questions = ctx.store.list({ type: "question" });
   const diagrams = getDiagramData(ctx.store);
-  const openEpics = epics.filter((d) => !DONE_STATUSES15.has(d.frontmatter.status));
-  const openTasks = tasks.filter((d) => !DONE_STATUSES15.has(d.frontmatter.status));
+  const openEpics = epics.filter((d) => !DONE_STATUSES14.has(d.frontmatter.status));
+  const openTasks = tasks.filter((d) => !DONE_STATUSES14.has(d.frontmatter.status));
   const technicalDecisions = decisions.filter((d) => {
     const tags = d.frontmatter.tags ?? [];
     return tags.some((t) => {
@@ -26649,7 +27425,7 @@ function tlDashboardPage(ctx) {
 }
 
 // src/web/templates/pages/tl/backlog.ts
-var DONE_STATUSES16 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES15 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 function tlBacklogPage(ctx) {
   const epics = ctx.store.list({ type: "epic" });
   const tasks = ctx.store.list({ type: "task" });
@@ -26686,7 +27462,7 @@ function tlBacklogPage(ctx) {
           <tbody>
             ${sortedEpics.map((e) => {
     const eTasks = epicToTasks.get(e.frontmatter.id) ?? [];
-    const done = eTasks.filter((t) => DONE_STATUSES16.has(t.frontmatter.status)).length;
+    const done = eTasks.filter((t) => DONE_STATUSES15.has(t.frontmatter.status)).length;
     const featureIds = epicFeatureMap.get(e.frontmatter.id) ?? [];
     const featureLinks = featureIds.map((fid) => `<a href="/docs/feature/${escapeHtml(fid)}">${escapeHtml(fid)}</a>`).join(", ");
     return `
@@ -26706,7 +27482,7 @@ function tlBacklogPage(ctx) {
     for (const t of taskList) assignedTaskIds.add(t.frontmatter.id);
   }
   const unassignedTasks = tasks.filter(
-    (t) => !assignedTaskIds.has(t.frontmatter.id) && !DONE_STATUSES16.has(t.frontmatter.status)
+    (t) => !assignedTaskIds.has(t.frontmatter.id) && !DONE_STATUSES15.has(t.frontmatter.status)
   );
   const unassignedSection = unassignedTasks.length > 0 ? collapsibleSection(
     "tl-backlog-unassigned",