mrvn-cli 0.5.17 → 0.5.18

package/dist/index.js

@@ -15699,6 +15699,14 @@ function evaluateHealth(projectName, metrics) {
 
 // src/reports/sprint-summary/collector.ts
 var DONE_STATUSES3 = /* @__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");
@@ -15784,12 +15792,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,
@@ -19457,7 +19467,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;
@@ -19466,7 +19476,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);
       }
     }
@@ -19712,23 +19722,34 @@ function hashString(s) {
   }
   return Math.abs(h);
 }
+var DONE_STATUS_SET = /* @__PURE__ */ new Set(["done", "closed", "resolved", "decided"]);
+var DEFAULT_WEIGHT2 = 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_WEIGHT2;
+    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) {
@@ -19777,7 +19798,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`);
@@ -25185,6 +25206,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_STATUSES14.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_STATUSES14.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_STATUSES14.has(
+            link.inwardIssue.fields.status.name.toLowerCase()
+          )
+        });
+      }
+    }
+  }
+  return linkedIssues;
+}
 function computeSubtaskProgress(subtasks) {
   if (subtasks.length === 0) return 0;
   const done = subtasks.filter(
@@ -25225,44 +25287,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_STATUSES14.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_STATUSES14.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_STATUSES14.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) {
@@ -25524,7 +25549,6 @@ function isWithinRange(timestamp, range) {
 function isConfluenceUrl(url2) {
   return /atlassian\.net\/wiki\//i.test(url2) || /\/confluence\//i.test(url2);
 }
-var DONE_STATUSES15 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "obsolete", "wont do"]);
 async function fetchJiraDaily(store, client, host, projectKey, dateRange, statusMap) {
   const summary = {
     dateRange,
@@ -25635,42 +25659,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_STATUSES15.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_STATUSES15.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_STATUSES15.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) {
@@ -25800,22 +25789,23 @@ function generateProposedActions(issues) {
 
 // src/skills/builtin/jira/sprint-progress.ts
 import { query as query3 } from "@anthropic-ai/claude-agent-sdk";
-var DONE_STATUSES16 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "obsolete", "wont do", "cancelled"]);
+var DONE_STATUSES15 = /* @__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_WEIGHT3 = 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_WEIGHT3, weightSource: "default" };
 }
 function resolveProgress(frontmatter, commentAnalysisProgress) {
   const hasExplicitProgress = "progress" in frontmatter && typeof frontmatter.progress === "number";
@@ -25904,6 +25894,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();
@@ -25969,6 +26005,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,
@@ -25987,6 +26040,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
@@ -26030,7 +26085,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_STATUSES16.has(i.marvinStatus)).length;
+    const doneCount = allFlatItems.filter((i) => DONE_STATUSES15.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);
@@ -26082,6 +26137,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) {
@@ -26198,6 +26273,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 = query3({
+    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}`);
@@ -26281,7 +26505,7 @@ function formatProgressReport(report) {
 }
 function formatItemLine(parts, item, depth) {
   const indent = "  ".repeat(depth + 1);
-  const statusIcon = DONE_STATUSES16.has(item.marvinStatus) ? "\u2713" : item.marvinStatus === "blocked" ? "\u{1F6AB}" : item.marvinStatus === "in-progress" ? "\u25B6" : "\u25CB";
+  const statusIcon = DONE_STATUSES15.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}%`;
@@ -26291,6 +26515,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);
   }
@@ -26300,6 +26537,506 @@ function progressBar6(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 = query3({
+    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_STATUSES15.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 = progressBar6(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_STATUSES15.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";
@@ -27086,7 +27823,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);
@@ -27099,6 +27837,7 @@ function createJiraTools(store, projectConfig) {
             sprintId: args.sprintId,
             analyzeComments: args.analyzeComments ?? false,
             applyUpdates: args.applyUpdates ?? false,
+            traverseLinks: args.traverseLinks ?? false,
             statusMap
           }
         );
@@ -27108,6 +27847,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 } }
     )
   ];
 }
@@ -27209,7 +27976,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).
@@ -27226,6 +27994,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
@@ -27250,6 +28023,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
@@ -27263,6 +28037,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
@@ -27278,6 +28053,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"\`)
@@ -32758,7 +33534,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.5.17");
+  ).version("0.5.18");
   program.command("init").description("Initialize a new Marvin project in the current directory").action(async () => {
     await initCommand();
   });