mrvn-cli 0.5.7 → 0.5.9

package/dist/marvin-serve.js

@@ -19023,13 +19023,23 @@ import { tool as tool20 } from "@anthropic-ai/claude-agent-sdk";
 // src/skills/builtin/jira/client.ts
 var JiraClient = class {
   baseUrl;
+  baseUrlV3;
   authHeader;
   constructor(config2) {
-    this.baseUrl = `https://${config2.host}/rest/api/2`;
+    const host = config2.host.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+    this.baseUrl = `https://${host}/rest/api/2`;
+    this.baseUrlV3 = `https://${host}/rest/api/3`;
     this.authHeader = "Basic " + Buffer.from(`${config2.email}:${config2.apiToken}`).toString("base64");
   }
   async request(path11, method = "GET", body) {
     const url2 = `${this.baseUrl}${path11}`;
+    return this.doRequest(url2, method, body);
+  }
+  async requestV3(path11, method = "GET", body) {
+    const url2 = `${this.baseUrlV3}${path11}`;
+    return this.doRequest(url2, method, body);
+  }
+  async doRequest(url2, method, body) {
     const headers = {
       Authorization: this.authHeader,
       "Content-Type": "application/json",
@@ -19043,18 +19053,26 @@ var JiraClient = class {
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       throw new Error(
-        `Jira API error ${response.status} ${method} ${path11}: ${text}`
+        `Jira API error ${response.status} ${method} ${url2}: ${text}`
       );
     }
     if (response.status === 204) return void 0;
     return response.json();
   }
   async searchIssues(jql, maxResults = 50) {
+    return this.searchIssuesV3(
+      jql,
+      ["summary", "description", "status", "issuetype", "priority", "assignee", "labels", "created", "updated"],
+      maxResults
+    );
+  }
+  async searchIssuesV3(jql, fields = ["summary", "status", "issuetype", "priority", "assignee", "labels"], maxResults = 50) {
     const params = new URLSearchParams({
       jql,
-      maxResults: String(maxResults)
+      maxResults: String(maxResults),
+      fields: fields.join(",")
     });
-    return this.request(`/search?${params}`);
+    return this.requestV3(`/search/jql?${params}`);
   }
   async getIssue(key) {
     return this.request(`/issue/${encodeURIComponent(key)}`);
@@ -19069,6 +19087,28 @@ var JiraClient = class {
       { fields }
     );
   }
+  async getIssueWithLinks(key) {
+    return this.request(
+      `/issue/${encodeURIComponent(key)}?fields=summary,status,issuetype,priority,assignee,labels,subtasks,issuelinks`
+    );
+  }
+  async getChangelog(key) {
+    const result = await this.request(
+      `/issue/${encodeURIComponent(key)}/changelog?maxResults=100`
+    );
+    return result.values;
+  }
+  async getComments(key) {
+    const result = await this.request(
+      `/issue/${encodeURIComponent(key)}/comment?maxResults=100`
+    );
+    return result.comments;
+  }
+  async getRemoteLinks(key) {
+    return this.request(
+      `/issue/${encodeURIComponent(key)}/remotelink`
+    );
+  }
   async addComment(key, body) {
     await this.request(
       `/issue/${encodeURIComponent(key)}/comment`,
@@ -19082,7 +19122,611 @@ function createJiraClient(jiraUserConfig) {
   const email3 = jiraUserConfig?.email ?? process.env.JIRA_EMAIL;
   const apiToken = jiraUserConfig?.apiToken ?? process.env.JIRA_API_TOKEN;
   if (!host || !email3 || !apiToken) return null;
-  return { client: new JiraClient({ host, email: email3, apiToken }), host };
+  const normalizedHost = host.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  return { client: new JiraClient({ host, email: email3, apiToken }), host: normalizedHost };
+}
+
+// src/skills/builtin/jira/sync.ts
+var DONE_STATUSES5 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "obsolete", "wont do"]);
+var DEFAULT_ACTION_STATUS_MAP = {
+  done: ["Done", "Closed", "Resolved", "Obsolete", "Wont Do"],
+  "in-progress": ["In Progress", "In Review", "Reviewing", "Testing"],
+  blocked: ["Blocked"],
+  open: ["To Do", "Open", "Backlog", "New"]
+};
+var DEFAULT_TASK_STATUS_MAP = {
+  done: ["Done", "Closed", "Resolved", "Obsolete", "Wont Do"],
+  review: ["In Review", "Code Review", "Reviewing", "Testing"],
+  "in-progress": ["In Progress"],
+  ready: ["Ready", "Selected for Development"],
+  blocked: ["Blocked"],
+  backlog: ["To Do", "Open", "Backlog", "New"]
+};
+function buildStatusLookup(configMap, defaults) {
+  const map2 = configMap ?? defaults;
+  const lookup = /* @__PURE__ */ new Map();
+  for (const [marvinStatus, jiraStatuses] of Object.entries(map2)) {
+    for (const js of jiraStatuses) {
+      lookup.set(js.toLowerCase(), marvinStatus);
+    }
+  }
+  return lookup;
+}
+function mapJiraStatusForAction(status, configMap) {
+  const lookup = buildStatusLookup(configMap, DEFAULT_ACTION_STATUS_MAP);
+  return lookup.get(status.toLowerCase()) ?? "open";
+}
+function mapJiraStatusForTask(status, configMap) {
+  const lookup = buildStatusLookup(configMap, DEFAULT_TASK_STATUS_MAP);
+  return lookup.get(status.toLowerCase()) ?? "backlog";
+}
+function computeSubtaskProgress(subtasks) {
+  if (subtasks.length === 0) return 0;
+  const done = subtasks.filter(
+    (s) => DONE_STATUSES5.has(s.fields.status.name.toLowerCase())
+  ).length;
+  return Math.round(done / subtasks.length * 100);
+}
+async function fetchJiraStatus(store, client, host, artifactId, statusMap) {
+  const result = { artifacts: [], errors: [] };
+  const actions = store.list({ type: "action" });
+  const tasks = store.list({ type: "task" });
+  let candidates = [...actions, ...tasks].filter(
+    (d) => d.frontmatter.jiraKey
+  );
+  if (artifactId) {
+    candidates = candidates.filter((d) => d.frontmatter.id === artifactId);
+    if (candidates.length === 0) {
+      const doc = store.get(artifactId);
+      if (doc) {
+        result.errors.push(
+          `${artifactId} has no jiraKey \u2014 use push_artifact_to_jira or link_to_jira first`
+        );
+      } else {
+        result.errors.push(`Artifact ${artifactId} not found`);
+      }
+      return result;
+    }
+  }
+  candidates = candidates.filter(
+    (d) => !DONE_STATUSES5.has(d.frontmatter.status)
+  );
+  for (const doc of candidates) {
+    const jiraKey = doc.frontmatter.jiraKey;
+    const artifactType = doc.frontmatter.type;
+    try {
+      const issue2 = await client.getIssueWithLinks(jiraKey);
+      const proposedStatus = artifactType === "task" ? mapJiraStatusForTask(issue2.fields.status.name, statusMap?.task) : mapJiraStatusForAction(issue2.fields.status.name, statusMap?.action);
+      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 subtasks = issue2.fields.subtasks ?? [];
+      let proposedProgress;
+      if (subtasks.length > 0 && !doc.frontmatter.progressOverride) {
+        proposedProgress = computeSubtaskProgress(subtasks);
+      }
+      const currentProgress = doc.frontmatter.progress;
+      result.artifacts.push({
+        id: doc.frontmatter.id,
+        type: artifactType,
+        jiraKey,
+        jiraUrl: `https://${host}/browse/${jiraKey}`,
+        jiraSummary: issue2.fields.summary,
+        jiraStatus: issue2.fields.status.name,
+        currentMarvinStatus: currentStatus,
+        proposedMarvinStatus: proposedStatus,
+        statusChanged: currentStatus !== proposedStatus,
+        currentProgress,
+        proposedProgress,
+        progressChanged: proposedProgress !== void 0 && proposedProgress !== currentProgress,
+        linkedIssues
+      });
+    } catch (err) {
+      result.errors.push(
+        `${doc.frontmatter.id} (${jiraKey}): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return result;
+}
+
+// src/skills/builtin/jira/daily.ts
+var BLOCKER_PATTERNS = [
+  /\bblocked\b/i,
+  /\bblocking\b/i,
+  /\bwaiting\s+for\b/i,
+  /\bon\s+hold\b/i,
+  /\bcan'?t\s+proceed\b/i,
+  /\bdepends?\s+on\b/i,
+  /\bstuck\b/i,
+  /\bneed[s]?\s+(to\s+wait|approval|input|clarification)\b/i
+];
+var DECISION_PATTERNS = [
+  /\bdecided\b/i,
+  /\bagreed\b/i,
+  /\bapproved?\b/i,
+  /\blet'?s?\s+go\s+with\b/i,
+  /\bwe('ll|\s+will)\s+(use|go|proceed|adopt)\b/i,
+  /\bsigned\s+off\b/i,
+  /\bconfirmed\b/i
+];
+var QUESTION_PATTERNS = [
+  /\?/,
+  /\bdoes\s+anyone\s+know\b/i,
+  /\bhow\s+should\s+we\b/i,
+  /\bneed\s+clarification\b/i,
+  /\bwhat('s|\s+is)\s+the\s+(plan|approach|status)\b/i,
+  /\bshould\s+we\b/i,
+  /\bany\s+(idea|thought|suggestion)s?\b/i,
+  /\bopen\s+question\b/i
+];
+var RESOLUTION_PATTERNS = [
+  /\bfixed\b/i,
+  /\bresolved\b/i,
+  /\bmerged\b/i,
+  /\bdeployed\b/i,
+  /\bcompleted?\b/i,
+  /\bshipped\b/i,
+  /\bimplemented\b/i,
+  /\bclosed\b/i
+];
+function detectCommentSignals(text) {
+  const signals = [];
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    for (const pattern of BLOCKER_PATTERNS) {
+      if (pattern.test(trimmed)) {
+        signals.push({ type: "blocker", snippet: truncate(trimmed, 120) });
+        break;
+      }
+    }
+    for (const pattern of DECISION_PATTERNS) {
+      if (pattern.test(trimmed)) {
+        signals.push({ type: "decision", snippet: truncate(trimmed, 120) });
+        break;
+      }
+    }
+    for (const pattern of QUESTION_PATTERNS) {
+      if (pattern.test(trimmed)) {
+        signals.push({ type: "question", snippet: truncate(trimmed, 120) });
+        break;
+      }
+    }
+    for (const pattern of RESOLUTION_PATTERNS) {
+      if (pattern.test(trimmed)) {
+        signals.push({ type: "resolution", snippet: truncate(trimmed, 120) });
+        break;
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return signals.filter((s) => {
+    if (seen.has(s.type)) return false;
+    seen.add(s.type);
+    return true;
+  });
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "this",
+  "that",
+  "it",
+  "its",
+  "as",
+  "not",
+  "no",
+  "if",
+  "do",
+  "does",
+  "new",
+  "via",
+  "use",
+  "using",
+  "based",
+  "into",
+  "e.g",
+  "etc"
+]);
+function tokenize(text) {
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/[\s-]+/).filter((w) => w.length > 2 && !STOP_WORDS.has(w))
+  );
+}
+function computeTitleSimilarity(jiraSummary, artifactTitle) {
+  const jiraTokens = tokenize(jiraSummary);
+  const artifactTokens = tokenize(artifactTitle);
+  if (jiraTokens.size === 0 || artifactTokens.size === 0) {
+    return { score: 0, sharedTerms: [] };
+  }
+  const shared = [];
+  for (const token of jiraTokens) {
+    if (artifactTokens.has(token)) {
+      shared.push(token);
+    }
+  }
+  const union2 = /* @__PURE__ */ new Set([...jiraTokens, ...artifactTokens]);
+  const score = shared.length / union2.size;
+  return { score, sharedTerms: shared };
+}
+var LINK_SUGGESTION_THRESHOLD = 0.15;
+var MAX_LINK_SUGGESTIONS = 3;
+function findLinkSuggestions(jiraSummary, allDocs) {
+  const suggestions = [];
+  for (const doc of allDocs) {
+    const fm = doc.frontmatter;
+    if (fm.jiraKey) continue;
+    const { score, sharedTerms } = computeTitleSimilarity(
+      jiraSummary,
+      fm.title
+    );
+    if (score >= LINK_SUGGESTION_THRESHOLD && sharedTerms.length >= 2) {
+      suggestions.push({
+        artifactId: fm.id,
+        artifactType: fm.type,
+        artifactTitle: fm.title,
+        score,
+        sharedTerms
+      });
+    }
+  }
+  return suggestions.sort((a, b) => b.score - a.score).slice(0, MAX_LINK_SUGGESTIONS);
+}
+function extractCommentText(body) {
+  if (typeof body === "string") return body;
+  if (!body || typeof body !== "object") return "";
+  const parts = [];
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    const n = node;
+    if (n.type === "text" && typeof n.text === "string") {
+      parts.push(n.text);
+    }
+    if (Array.isArray(n.content)) {
+      for (const child of n.content) walk(child);
+    }
+  }
+  walk(body);
+  return parts.join(" ");
+}
+function truncate(text, maxLen = 200) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "\u2026";
+}
+function isWithinRange(timestamp, range) {
+  const date5 = timestamp.slice(0, 10);
+  return date5 >= range.from && date5 <= range.to;
+}
+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,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectKey,
+    issues: [],
+    proposedActions: [],
+    errors: []
+  };
+  const jql = `project = ${projectKey} AND updated >= "${dateRange.from}" AND updated <= "${dateRange.to} 23:59" ORDER BY updated DESC`;
+  let searchResult;
+  try {
+    searchResult = await client.searchIssuesV3(
+      jql,
+      ["summary", "status", "issuetype", "priority", "assignee", "labels"],
+      100
+    );
+  } catch (err) {
+    summary.errors.push(
+      `Search failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return summary;
+  }
+  const allDocs = [
+    ...store.list({ type: "action" }),
+    ...store.list({ type: "task" }),
+    ...store.list({ type: "decision" }),
+    ...store.list({ type: "question" })
+  ];
+  const otherTypes = store.registeredTypes.filter(
+    (t) => !["action", "task", "decision", "question"].includes(t)
+  );
+  for (const t of otherTypes) {
+    allDocs.push(...store.list({ type: t }));
+  }
+  const jiraKeyToArtifacts = /* @__PURE__ */ new Map();
+  for (const doc of allDocs) {
+    const jk = doc.frontmatter.jiraKey;
+    if (jk) {
+      const list = jiraKeyToArtifacts.get(jk) ?? [];
+      list.push(doc);
+      jiraKeyToArtifacts.set(jk, list);
+    }
+  }
+  const BATCH_SIZE = 5;
+  const issues = searchResult.issues;
+  for (let i = 0; i < issues.length; i += BATCH_SIZE) {
+    const batch = issues.slice(i, i + BATCH_SIZE);
+    const results = await Promise.allSettled(
+      batch.map(
+        (issue2) => processIssue(issue2, client, host, dateRange, jiraKeyToArtifacts, allDocs, statusMap)
+      )
+    );
+    for (let j = 0; j < results.length; j++) {
+      const r = results[j];
+      if (r.status === "fulfilled") {
+        summary.issues.push(r.value);
+      } else {
+        summary.errors.push(
+          `${batch[j].key}: ${r.reason instanceof Error ? r.reason.message : String(r.reason)}`
+        );
+      }
+    }
+  }
+  summary.proposedActions = generateProposedActions(summary.issues);
+  return summary;
+}
+async function processIssue(issue2, client, host, dateRange, jiraKeyToArtifacts, allDocs, statusMap) {
+  const [changelogResult, commentsResult, remoteLinksResult, issueWithLinks] = await Promise.all([
+    client.getChangelog(issue2.key).catch(() => []),
+    client.getComments(issue2.key).catch(() => []),
+    client.getRemoteLinks(issue2.key).catch(() => []),
+    client.getIssueWithLinks(issue2.key).catch(() => null)
+  ]);
+  const changes = [];
+  for (const entry of changelogResult) {
+    if (!isWithinRange(entry.created, dateRange)) continue;
+    for (const item of entry.items) {
+      changes.push({
+        field: item.field,
+        from: item.fromString,
+        to: item.toString,
+        author: entry.author.displayName,
+        timestamp: entry.created
+      });
+    }
+  }
+  const comments = [];
+  for (const comment of commentsResult) {
+    if (!isWithinRange(comment.created, dateRange) && !isWithinRange(comment.updated, dateRange)) {
+      continue;
+    }
+    const fullText = extractCommentText(comment.body);
+    const signals = detectCommentSignals(fullText);
+    comments.push({
+      author: comment.author.displayName,
+      created: comment.created,
+      bodyPreview: truncate(fullText),
+      signals
+    });
+  }
+  const confluenceLinks = [];
+  for (const rl of remoteLinksResult) {
+    if (isConfluenceUrl(rl.object.url)) {
+      confluenceLinks.push({
+        url: rl.object.url,
+        title: rl.object.title
+      });
+    }
+  }
+  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 marvinArtifacts = [];
+  const artifacts = jiraKeyToArtifacts.get(issue2.key) ?? [];
+  for (const doc of artifacts) {
+    const fm = doc.frontmatter;
+    const artifactType = fm.type;
+    let proposedStatus = null;
+    if (artifactType === "action" || artifactType === "task") {
+      const jiraStatus = issue2.fields.status?.name;
+      if (jiraStatus) {
+        proposedStatus = artifactType === "task" ? mapJiraStatusForTask(jiraStatus, statusMap?.task) : mapJiraStatusForAction(jiraStatus, statusMap?.action);
+      }
+    }
+    marvinArtifacts.push({
+      id: fm.id,
+      type: artifactType,
+      title: fm.title,
+      currentStatus: fm.status,
+      proposedStatus,
+      statusDrift: proposedStatus !== null && proposedStatus !== fm.status
+    });
+  }
+  const linkSuggestions = marvinArtifacts.length === 0 ? findLinkSuggestions(issue2.fields.summary, allDocs) : [];
+  return {
+    key: issue2.key,
+    summary: issue2.fields.summary,
+    currentStatus: issue2.fields.status?.name ?? "Unknown",
+    issueType: issue2.fields.issuetype?.name ?? "Unknown",
+    assignee: issue2.fields.assignee?.displayName ?? null,
+    changes,
+    comments,
+    linkedIssues,
+    confluenceLinks,
+    marvinArtifacts,
+    linkSuggestions
+  };
+}
+function generateProposedActions(issues) {
+  const actions = [];
+  for (const issue2 of issues) {
+    for (const artifact of issue2.marvinArtifacts) {
+      if (artifact.statusDrift && artifact.proposedStatus) {
+        actions.push({
+          type: "status-update",
+          description: `Update ${artifact.id} (${artifact.type}) status: ${artifact.currentStatus} \u2192 ${artifact.proposedStatus} (Jira ${issue2.key} is "${issue2.currentStatus}")`,
+          artifactId: artifact.id,
+          jiraKey: issue2.key
+        });
+      }
+    }
+    if (issue2.marvinArtifacts.length === 0 && (issue2.changes.length > 0 || issue2.comments.length > 0)) {
+      actions.push({
+        type: "unlinked-issue",
+        description: `${issue2.key} ("${issue2.summary}") has activity but no Marvin artifact \u2014 consider linking or creating one`,
+        jiraKey: issue2.key
+      });
+    }
+    for (const suggestion of issue2.linkSuggestions) {
+      actions.push({
+        type: "link-suggestion",
+        description: `${issue2.key} ("${issue2.summary}") may match ${suggestion.artifactId} ("${suggestion.artifactTitle}") \u2014 shared terms: ${suggestion.sharedTerms.join(", ")} (${Math.round(suggestion.score * 100)}% similarity)`,
+        artifactId: suggestion.artifactId,
+        jiraKey: issue2.key
+      });
+    }
+    for (const comment of issue2.comments) {
+      for (const signal of comment.signals) {
+        if (signal.type === "blocker") {
+          actions.push({
+            type: "blocker-detected",
+            description: `Blocker in ${issue2.key} comment by ${comment.author}: "${signal.snippet}"`,
+            jiraKey: issue2.key
+          });
+        }
+        if (signal.type === "decision") {
+          actions.push({
+            type: "decision-candidate",
+            description: `Possible decision in ${issue2.key} comment by ${comment.author}: "${signal.snippet}" \u2014 consider creating a decision artifact`,
+            jiraKey: issue2.key
+          });
+        }
+        if (signal.type === "question") {
+          const linkedQuestion = issue2.marvinArtifacts.find(
+            (a) => a.type === "question" && a.currentStatus !== "answered"
+          );
+          if (linkedQuestion) {
+            actions.push({
+              type: "question-candidate",
+              description: `Question in ${issue2.key} comment by ${comment.author} \u2014 may relate to ${linkedQuestion.id} ("${linkedQuestion.title}"): "${signal.snippet}"`,
+              artifactId: linkedQuestion.id,
+              jiraKey: issue2.key
+            });
+          } else {
+            actions.push({
+              type: "question-candidate",
+              description: `Question in ${issue2.key} comment by ${comment.author}: "${signal.snippet}" \u2014 consider creating a question artifact`,
+              jiraKey: issue2.key
+            });
+          }
+        }
+        if (signal.type === "resolution") {
+          const linkedQuestion = issue2.marvinArtifacts.find(
+            (a) => a.type === "question" && a.currentStatus !== "answered"
+          );
+          if (linkedQuestion) {
+            actions.push({
+              type: "resolution-detected",
+              description: `Resolution in ${issue2.key} by ${comment.author} may answer ${linkedQuestion.id} ("${linkedQuestion.title}"): "${signal.snippet}"`,
+              artifactId: linkedQuestion.id,
+              jiraKey: issue2.key
+            });
+          }
+        }
+      }
+    }
+    for (const cl of issue2.confluenceLinks) {
+      actions.push({
+        type: "confluence-review",
+        description: `Confluence page "${cl.title}" linked from ${issue2.key} \u2014 review for relevant updates`,
+        jiraKey: issue2.key
+      });
+    }
+  }
+  return actions;
 }
 
 // src/skills/builtin/jira/tools.ts
@@ -19126,6 +19770,7 @@ function findByJiraKey(store, jiraKey) {
 function createJiraTools(store, projectConfig) {
   const jiraUserConfig = loadUserConfig().jira;
   const defaultProjectKey = projectConfig?.jira?.projectKey;
+  const statusMap = projectConfig?.jira?.statusMap;
   return [
     // --- Local read tools ---
     tool20(
@@ -19286,9 +19931,9 @@ function createJiraTools(store, projectConfig) {
     // --- Local → Jira tools ---
     tool20(
       "push_artifact_to_jira",
-      "Create a Jira issue from any Marvin artifact (D/A/Q/F/E) and create a tracking JI-xxx document",
+      "Create a Jira issue from a Marvin artifact. For actions/tasks, links directly via jiraKey on the artifact. For other types, creates a JI-xxx tracking document.",
       {
-        artifactId: external_exports.string().describe("Marvin artifact ID (e.g. 'D-001', 'F-003', 'E-002')"),
+        artifactId: external_exports.string().describe("Marvin artifact ID (e.g. 'D-001', 'A-003', 'T-002')"),
         projectKey: external_exports.string().optional().describe("Jira project key (e.g. 'PROJ'). Falls back to jira.projectKey from .marvin/config.yaml if not provided."),
         issueType: external_exports.enum(["Story", "Task", "Bug", "Epic"]).optional().describe("Jira issue type (default: 'Task')")
       },
@@ -19329,6 +19974,24 @@ function createJiraTools(store, projectConfig) {
           description,
           issuetype: { name: args.issueType ?? "Task" }
         });
+        const isDirectLink = artifact.frontmatter.type === "action" || artifact.frontmatter.type === "task";
+        if (isDirectLink) {
+          const existingTags = artifact.frontmatter.tags ?? [];
+          store.update(args.artifactId, {
+            jiraKey: jiraResult.key,
+            jiraUrl: `https://${jira.host}/browse/${jiraResult.key}`,
+            lastJiraSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+            tags: [...existingTags.filter((t) => !t.startsWith("jira:")), `jira:${jiraResult.key}`]
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Created Jira ${jiraResult.key} from ${args.artifactId}. Linked directly on the artifact.`
+              }
+            ]
+          };
+        }
         const jiDoc = store.create(
           JIRA_TYPE,
           {
@@ -19450,65 +20113,430 @@ function createJiraTools(store, projectConfig) {
           ]
         };
       }
+    ),
+    // --- Direct Jira linking for actions/tasks ---
+    tool20(
+      "link_to_jira",
+      "Link an existing Jira issue to a Marvin action or task (sets jiraKey directly on the artifact)",
+      {
+        artifactId: external_exports.string().describe("Marvin artifact ID (e.g. 'A-001', 'T-003')"),
+        jiraKey: external_exports.string().describe("Jira issue key (e.g. 'PROJ-123')")
+      },
+      async (args) => {
+        const jira = createJiraClient(jiraUserConfig);
+        if (!jira) return jiraNotConfiguredError();
+        const artifact = store.get(args.artifactId);
+        if (!artifact) {
+          return {
+            content: [
+              { type: "text", text: `Artifact ${args.artifactId} not found` }
+            ],
+            isError: true
+          };
+        }
+        if (artifact.frontmatter.type !== "action" && artifact.frontmatter.type !== "task") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `link_to_jira only supports action and task artifacts. ${args.artifactId} is type "${artifact.frontmatter.type}". Use link_artifact_to_jira for JI-xxx documents instead.`
+              }
+            ],
+            isError: true
+          };
+        }
+        const issue2 = await jira.client.getIssue(args.jiraKey);
+        const existingTags = artifact.frontmatter.tags ?? [];
+        store.update(args.artifactId, {
+          jiraKey: args.jiraKey,
+          jiraUrl: `https://${jira.host}/browse/${args.jiraKey}`,
+          lastJiraSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+          tags: [...existingTags.filter((t) => !t.startsWith("jira:")), `jira:${args.jiraKey}`]
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Linked ${args.artifactId} to Jira ${args.jiraKey} ("${issue2.fields.summary}").`
+            }
+          ]
+        };
+      }
+    ),
+    // --- Jira status fetch (read-only) ---
+    tool20(
+      "fetch_jira_status",
+      "Fetch current Jira status for actions/tasks with jiraKey. Read-only \u2014 returns proposed changes for review. Use update_action/update_task to apply changes.",
+      {
+        artifactId: external_exports.string().optional().describe("Specific artifact ID to check, or omit to check all Jira-linked actions/tasks")
+      },
+      async (args) => {
+        const jira = createJiraClient(jiraUserConfig);
+        if (!jira) return jiraNotConfiguredError();
+        const fetchResult = await fetchJiraStatus(
+          store,
+          jira.client,
+          jira.host,
+          args.artifactId,
+          statusMap
+        );
+        const parts = [];
+        if (fetchResult.artifacts.length > 0) {
+          for (const a of fetchResult.artifacts) {
+            const changes = [];
+            if (a.statusChanged) {
+              changes.push(`status: ${a.currentMarvinStatus} \u2192 ${a.proposedMarvinStatus}`);
+            }
+            if (a.progressChanged) {
+              changes.push(`progress: ${a.currentProgress ?? 0}% \u2192 ${a.proposedProgress}%`);
+            }
+            const header = `${a.id} (${a.jiraKey}) \u2014 Jira: "${a.jiraSummary}" [${a.jiraStatus}]`;
+            if (changes.length > 0) {
+              parts.push(`${header}
+  Proposed changes: ${changes.join(", ")}`);
+            } else {
+              parts.push(`${header}
+  No status/progress changes.`);
+            }
+            if (a.linkedIssues.length > 0) {
+              const done = a.linkedIssues.filter((l) => l.isDone).length;
+              parts.push(`  Linked issues (${done}/${a.linkedIssues.length} done):`);
+              for (const li of a.linkedIssues) {
+                const icon = li.isDone ? "\u2713" : "\u25CB";
+                parts.push(`    ${icon} ${li.key} ${li.summary} [${li.relationship}] \u2014 ${li.status}`);
+              }
+            }
+          }
+          parts.push("");
+          parts.push("This is a read-only preview. Use update_action or update_task to apply the proposed status/progress changes.");
+        }
+        if (fetchResult.errors.length > 0) {
+          parts.push("Errors:");
+          for (const err of fetchResult.errors) {
+            parts.push(`  ${err}`);
+          }
+        }
+        if (fetchResult.artifacts.length === 0 && fetchResult.errors.length === 0) {
+          parts.push("No Jira-linked actions/tasks found.");
+        }
+        return {
+          content: [{ type: "text", text: parts.join("\n") }],
+          isError: fetchResult.errors.length > 0 && fetchResult.artifacts.length === 0
+        };
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    // --- Jira status discovery ---
+    tool20(
+      "fetch_jira_statuses",
+      "Fetch all distinct issue statuses from a Jira project and show which are mapped vs unmapped to Marvin statuses. Helps configure jira.statusMap in .marvin/config.yaml.",
+      {
+        projectKey: external_exports.string().optional().describe("Jira project key (e.g. 'MCB1'). Falls back to jira.projectKey from config."),
+        maxResults: external_exports.number().optional().describe("Max issues to scan (default 100)")
+      },
+      async (args) => {
+        const resolvedProjectKey = args.projectKey ?? defaultProjectKey;
+        if (!resolvedProjectKey) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No projectKey provided and no default configured."
+              }
+            ],
+            isError: true
+          };
+        }
+        const jira = createJiraClient(jiraUserConfig);
+        if (!jira) return jiraNotConfiguredError();
+        const host = jira.host;
+        const auth = "Basic " + Buffer.from(
+          `${jiraUserConfig?.email ?? process.env.JIRA_EMAIL}:${jiraUserConfig?.apiToken ?? process.env.JIRA_API_TOKEN}`
+        ).toString("base64");
+        const params = new URLSearchParams({
+          jql: `project = ${resolvedProjectKey}`,
+          maxResults: String(args.maxResults ?? 100),
+          fields: "status"
+        });
+        const resp = await fetch(`https://${host}/rest/api/3/search/jql?${params}`, {
+          headers: { Authorization: auth, Accept: "application/json" }
+        });
+        if (!resp.ok) {
+          const text = await resp.text().catch(() => "");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Jira API error ${resp.status}: ${text}`
+              }
+            ],
+            isError: true
+          };
+        }
+        const data = await resp.json();
+        const statusCounts = /* @__PURE__ */ new Map();
+        for (const issue2 of data.issues) {
+          const s = issue2.fields.status.name;
+          statusCounts.set(s, (statusCounts.get(s) ?? 0) + 1);
+        }
+        const actionMap = statusMap?.action ?? DEFAULT_ACTION_STATUS_MAP;
+        const taskMap = statusMap?.task ?? DEFAULT_TASK_STATUS_MAP;
+        const actionLookup = /* @__PURE__ */ new Map();
+        for (const [marvin, jiraStatuses] of Object.entries(actionMap)) {
+          for (const js of jiraStatuses) actionLookup.set(js.toLowerCase(), marvin);
+        }
+        const taskLookup = /* @__PURE__ */ new Map();
+        for (const [marvin, jiraStatuses] of Object.entries(taskMap)) {
+          for (const js of jiraStatuses) taskLookup.set(js.toLowerCase(), marvin);
+        }
+        const parts = [
+          `Found ${statusCounts.size} distinct statuses in ${resolvedProjectKey} (scanned ${data.issues.length} of ${data.total} issues):`,
+          ""
+        ];
+        const sorted = [...statusCounts.entries()].sort((a, b) => b[1] - a[1]);
+        const unmappedAction = [];
+        const unmappedTask = [];
+        for (const [status, count] of sorted) {
+          const actionTarget = actionLookup.get(status.toLowerCase());
+          const taskTarget = taskLookup.get(status.toLowerCase());
+          const actionLabel = actionTarget ? `\u2192 ${actionTarget}` : "UNMAPPED (\u2192 open)";
+          const taskLabel = taskTarget ? `\u2192 ${taskTarget}` : "UNMAPPED (\u2192 backlog)";
+          parts.push(`  ${status} (${count} issues)`);
+          parts.push(`    action: ${actionLabel}`);
+          parts.push(`    task:   ${taskLabel}`);
+          if (!actionTarget) unmappedAction.push(status);
+          if (!taskTarget) unmappedTask.push(status);
+        }
+        if (unmappedAction.length > 0 || unmappedTask.length > 0) {
+          parts.push("");
+          parts.push("To fix unmapped statuses, add jira.statusMap to .marvin/config.yaml:");
+          parts.push("  jira:");
+          parts.push("    statusMap:");
+          if (unmappedAction.length > 0) {
+            parts.push("      action:");
+            parts.push(`        # Map these: ${unmappedAction.join(", ")}`);
+            parts.push("        # <marvin-status>: [<jira-status>, ...]");
+          }
+          if (unmappedTask.length > 0) {
+            parts.push("      task:");
+            parts.push(`        # Map these: ${unmappedTask.join(", ")}`);
+            parts.push("        # <marvin-status>: [<jira-status>, ...]");
+          }
+        } else {
+          parts.push("");
+          parts.push("All statuses are mapped.");
+        }
+        const usingConfig = statusMap?.action || statusMap?.task;
+        parts.push("");
+        parts.push(usingConfig ? "Using status maps from .marvin/config.yaml." : "Using built-in default status maps (no jira.statusMap in config).");
+        return {
+          content: [{ type: "text", text: parts.join("\n") }]
+        };
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    // --- Jira daily summary ---
+    tool20(
+      "fetch_jira_daily",
+      "Fetch a daily summary of Jira changes: status transitions, comments, linked Confluence pages, and cross-referenced Marvin artifacts. Read-only \u2014 returns proposed actions for review.",
+      {
+        from: external_exports.string().optional().describe("Start date (YYYY-MM-DD). Defaults to today."),
+        to: external_exports.string().optional().describe("End date (YYYY-MM-DD). Defaults to same as 'from'."),
+        projectKey: external_exports.string().optional().describe("Jira project key. Falls back to jira.projectKey from config.")
+      },
+      async (args) => {
+        const resolvedProjectKey = args.projectKey ?? defaultProjectKey;
+        if (!resolvedProjectKey) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No projectKey provided and no default configured."
+              }
+            ],
+            isError: true
+          };
+        }
+        const jira = createJiraClient(jiraUserConfig);
+        if (!jira) return jiraNotConfiguredError();
+        const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        const fromDate = args.from ?? today;
+        const toDate = args.to ?? fromDate;
+        const daily = await fetchJiraDaily(
+          store,
+          jira.client,
+          jira.host,
+          resolvedProjectKey,
+          { from: fromDate, to: toDate },
+          statusMap
+        );
+        return {
+          content: [{ type: "text", text: formatDailySummary(daily) }],
+          isError: daily.errors.length > 0 && daily.issues.length === 0
+        };
+      },
+      { annotations: { readOnlyHint: true } }
     )
   ];
 }
+function formatDailySummary(daily) {
+  const parts = [];
+  const rangeLabel = daily.dateRange.from === daily.dateRange.to ? daily.dateRange.from : `${daily.dateRange.from} to ${daily.dateRange.to}`;
+  parts.push(`Jira Daily Summary \u2014 ${daily.projectKey} \u2014 ${rangeLabel}`);
+  parts.push(`${daily.issues.length} issue(s) updated.
+`);
+  const linked = daily.issues.filter((i) => i.marvinArtifacts.length > 0);
+  const unlinked = daily.issues.filter((i) => i.marvinArtifacts.length === 0);
+  if (linked.length > 0) {
+    parts.push("## Linked Issues (with Marvin artifacts)\n");
+    for (const issue2 of linked) {
+      parts.push(formatIssueEntry(issue2));
+    }
+  }
+  if (unlinked.length > 0) {
+    parts.push("## Unlinked Issues (no Marvin artifact)\n");
+    for (const issue2 of unlinked) {
+      parts.push(formatIssueEntry(issue2));
+    }
+  }
+  if (daily.proposedActions.length > 0) {
+    parts.push("## Proposed Actions\n");
+    for (const action of daily.proposedActions) {
+      const icon = action.type === "status-update" ? "\u21BB" : action.type === "unlinked-issue" ? "+" : action.type === "link-suggestion" ? "\u{1F517}" : action.type === "question-candidate" ? "?" : action.type === "decision-candidate" ? "\u2696" : action.type === "blocker-detected" ? "\u{1F6AB}" : action.type === "resolution-detected" ? "\u2713" : "\u{1F4C4}";
+      parts.push(`  ${icon} ${action.description}`);
+    }
+    parts.push("");
+    parts.push("These are suggestions. Use update_action, update_task, or other tools to apply changes.");
+  }
+  if (daily.errors.length > 0) {
+    parts.push("\n## Errors\n");
+    for (const err of daily.errors) {
+      parts.push(`  ${err}`);
+    }
+  }
+  return parts.join("\n");
+}
+function formatIssueEntry(issue2) {
+  const lines = [];
+  const artifacts = issue2.marvinArtifacts.map((a) => a.id).join(", ");
+  const artifactLabel = artifacts ? ` \u2192 ${artifacts}` : "";
+  lines.push(`### ${issue2.key} \u2014 ${issue2.summary} [${issue2.currentStatus}]${artifactLabel}`);
+  lines.push(`  Type: ${issue2.issueType} | Assignee: ${issue2.assignee ?? "unassigned"}`);
+  for (const a of issue2.marvinArtifacts) {
+    if (a.statusDrift) {
+      lines.push(`  \u26A0 ${a.id} status drift: Marvin="${a.currentStatus}" vs proposed="${a.proposedStatus}"`);
+    }
+  }
+  if (issue2.changes.length > 0) {
+    lines.push("  Changes:");
+    for (const c of issue2.changes) {
+      lines.push(`    ${c.field}: ${c.from ?? "\u2205"} \u2192 ${c.to ?? "\u2205"} (${c.author}, ${c.timestamp.slice(0, 16)})`);
+    }
+  }
+  if (issue2.comments.length > 0) {
+    lines.push(`  Comments (${issue2.comments.length}):`);
+    for (const c of issue2.comments) {
+      let signalIcons = "";
+      if (c.signals.length > 0) {
+        const icons = c.signals.map(
+          (s) => s.type === "blocker" ? "\u{1F6AB}" : s.type === "decision" ? "\u2696" : s.type === "question" ? "?" : "\u2713"
+        );
+        signalIcons = ` [${icons.join("")}]`;
+      }
+      lines.push(`    ${c.author} (${c.created.slice(0, 16)})${signalIcons}: ${c.bodyPreview}`);
+    }
+  }
+  if (issue2.linkSuggestions.length > 0) {
+    lines.push("  Possible Marvin matches:");
+    for (const s of issue2.linkSuggestions) {
+      lines.push(`    \u{1F517} ${s.artifactId} ("${s.artifactTitle}") \u2014 ${Math.round(s.score * 100)}% match [${s.sharedTerms.join(", ")}]`);
+    }
+  }
+  if (issue2.linkedIssues.length > 0) {
+    lines.push("  Linked issues:");
+    for (const li of issue2.linkedIssues) {
+      const icon = li.isDone ? "\u2713" : "\u25CB";
+      lines.push(`    ${icon} ${li.key} ${li.summary} [${li.relationship}] \u2014 ${li.status}`);
+    }
+  }
+  if (issue2.confluenceLinks.length > 0) {
+    lines.push("  Confluence pages:");
+    for (const cl of issue2.confluenceLinks) {
+      lines.push(`    \u{1F4C4} ${cl.title}: ${cl.url}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
 
 // src/skills/builtin/jira/index.ts
+var COMMON_TOOLS = `**Available tools:**
+- \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues (JI-xxx documents)
+- \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
+- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact. For **actions and tasks**, links directly via \`jiraKey\` on the artifact (no JI-xxx intermediary). For other types, creates a JI-xxx tracking document.
+- \`link_to_jira\` \u2014 link an existing Jira issue to a Marvin action or task (sets \`jiraKey\` directly on the artifact)
+- \`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).
+- \`fetch_jira_statuses\` \u2014 **read-only**: discover all Jira statuses in a project and show their Marvin mappings (mapped vs unmapped).
+- \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
+- \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx`;
+var COMMON_WORKFLOW = `**Jira sync workflow:**
+1. Call \`fetch_jira_status\` to see what Jira reports for linked artifacts
+2. Analyze the proposed changes (status transitions, subtask progress, blockers from linked issues)
+3. Use \`update_action\` / \`update_task\` to apply the changes you agree with
+
+**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
+3. Use existing tools to apply changes, create new artifacts, or link untracked issues`;
 var jiraSkill = {
   id: "jira",
   name: "Jira Integration",
   description: "Bidirectional sync between Marvin artifacts and Jira issues",
   version: "1.0.0",
   format: "builtin-ts",
-  // No default persona affinity — opt-in via config.yaml skills section
   documentTypeRegistrations: [
     { type: "jira-issue", dirName: "jira-issues", idPrefix: "JI" }
   ],
   tools: (store, projectConfig) => createJiraTools(store, projectConfig),
   promptFragments: {
-    "product-owner": `You have the **Jira Integration** skill. You can pull issues from Jira and push Marvin artifacts to Jira.
+    "product-owner": `You have the **Jira Integration** skill.
 
-**Available tools:**
-- \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues
-- \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
-- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, feature, etc.). The \`projectKey\` parameter is optional when a default is configured in \`.marvin/config.yaml\` under \`jira.projectKey\`.
-- \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
-- \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
+${COMMON_TOOLS}
+
+${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
 - 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
-- Use JQL queries to review backlog status (e.g. \`project = PROJ AND status = "To Do"\`)`,
-    "tech-lead": `You have the **Jira Integration** skill. You can pull issues from Jira and push Marvin artifacts to Jira.
+- Use \`fetch_jira_statuses\` when setting up a new project to configure status mappings`,
+    "tech-lead": `You have the **Jira Integration** skill.
 
-**Available tools:**
-- \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues
-- \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
-- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, action, epic, task, etc.). The \`projectKey\` parameter is optional when a default is configured in \`.marvin/config.yaml\` under \`jira.projectKey\`.
-- \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
-- \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
+${COMMON_TOOLS}
+
+${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
 - Pull technical issues and bugs for sprint planning and estimation
 - Push epics, tasks, and technical decisions to Jira for cross-team visibility
-- Bidirectional sync to keep local governance and Jira in alignment
-- Use JQL queries to track technical debt (e.g. \`labels = "tech-debt" AND status != "Done"\`)`,
-    "delivery-manager": `You have the **Jira Integration** skill. You can pull issues from Jira and push Marvin artifacts to Jira.
+- Use \`link_to_jira\` to connect Marvin tasks to existing Jira tickets
+- Use \`fetch_jira_statuses\` to verify status mappings match the team's Jira workflow`,
+    "delivery-manager": `You have the **Jira Integration** skill.
 
-**Available tools:**
-- \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues
-- \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
-- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, action, etc.). The \`projectKey\` parameter is optional when a default is configured in \`.marvin/config.yaml\` under \`jira.projectKey\`.
-- \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
-- \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
+${COMMON_TOOLS}
+
+${COMMON_WORKFLOW}
+This is a third path for progress tracking alongside Contributions and Meetings.
 
 **As Delivery Manager, use Jira integration to:**
+- Use \`fetch_jira_daily\` for daily progress reports \u2014 track what moved, identify blockers, spot untracked work
 - Pull sprint issues for tracking progress and blockers
-- Push actions, decisions, and tasks to Jira for stakeholder visibility
-- Use JQL queries for reporting (e.g. \`sprint in openSprints() AND assignee = currentUser()\`)
-- Sync status between Marvin governance items and Jira issues`
+- 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"\`)
+- Use \`fetch_jira_statuses\` to ensure Jira workflow statuses are properly mapped`
   }
 };
 
@@ -22857,7 +23885,7 @@ function buildHealthGauge(categories) {
 }
 
 // src/web/templates/pages/po/dashboard.ts
-var DONE_STATUSES5 = /* @__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);
@@ -22902,7 +23930,7 @@ function poDashboardPage(ctx) {
       sprintTimelinePct = Math.min(100, Math.max(0, Math.round((Date.now() - startMs) / totalDays * 100)));
     }
   }
-  const featuresDone = features.filter((d) => DONE_STATUSES5.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;
@@ -22971,7 +23999,7 @@ function poDashboardPage(ctx) {
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const atRiskItems = [];
   for (const f of features) {
-    if (DONE_STATUSES5.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;
@@ -22983,7 +24011,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_STATUSES5.has(epic.frontmatter.status)) {
+      if (td && td < today && !DONE_STATUSES7.has(epic.frontmatter.status)) {
         reasons.push(`${epic.frontmatter.id} overdue`);
       }
     }
@@ -23261,7 +24289,7 @@ function poBacklogPage(ctx) {
       }
     }
   }
-  const DONE_STATUSES14 = /* @__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;
@@ -23270,7 +24298,7 @@ function poBacklogPage(ctx) {
     for (const epic of fEpics) {
       for (const t of epicToTasks.get(epic.frontmatter.id) ?? []) {
         total++;
-        if (DONE_STATUSES14.has(t.frontmatter.status)) done++;
+        if (DONE_STATUSES16.has(t.frontmatter.status)) done++;
         progressSum += getEffectiveProgress(t.frontmatter);
       }
     }
@@ -23624,7 +24652,7 @@ function renderWorkItemsTable(items, options) {
     { titleTag: "h3", defaultCollapsed }
   );
 }
-var DONE_STATUSES6 = /* @__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;
@@ -23632,7 +24660,7 @@ function computeOwnerCompletionPct(items, owner) {
     for (const w of list) {
       if (w.type !== "contribution" && w.owner === owner) {
         total++;
-        progressSum += w.progress ?? (DONE_STATUSES6.has(w.status) ? 100 : 0);
+        progressSum += w.progress ?? (DONE_STATUSES8.has(w.status) ? 100 : 0);
       }
       if (w.children) walk(w.children);
     }
@@ -23653,7 +24681,7 @@ function filterItemsByOwner(items, owner) {
 }
 
 // src/web/templates/pages/po/delivery.ts
-var DONE_STATUSES7 = /* @__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) {
@@ -23794,7 +24822,7 @@ function poDeliveryPage(ctx) {
     }
     return total > 0 ? Math.round(progressSum / total) : 0;
   }
-  const nonDoneFeatures = features.filter((f) => !DONE_STATUSES7.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;
@@ -24003,7 +25031,7 @@ registerPersonaPage("po", "delivery", poDeliveryPage);
 registerPersonaPage("po", "stakeholders", poStakeholdersPage);
 
 // src/web/templates/pages/dm/dashboard.ts
-var DONE_STATUSES8 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES10 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 function progressBar2(pct) {
   return `<div class="sprint-progress-bar">
     <div class="sprint-progress-fill" style="width: ${pct}%"></div>
@@ -24014,7 +25042,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_STATUSES8.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">
@@ -24235,7 +25263,7 @@ function dmSprintPage(ctx) {
 }
 
 // src/web/templates/pages/dm/actions.ts
-var DONE_STATUSES9 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
+var DONE_STATUSES11 = /* @__PURE__ */ new Set(["done", "closed", "resolved", "cancelled"]);
 function urgencyBadge(tier) {
   const labels = {
     overdue: "Overdue",
@@ -24255,7 +25283,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_STATUSES9.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);
@@ -24340,7 +25368,7 @@ function dmActionsPage(ctx) {
 }
 
 // src/web/templates/pages/dm/risks.ts
-var DONE_STATUSES10 = /* @__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);
@@ -24351,7 +25379,7 @@ function dmRisksPage(ctx) {
   const todayMs = new Date(today).getTime();
   const fourteenDaysMs = 14 * 864e5;
   const agingItems = allDocs.filter((d) => {
-    if (DONE_STATUSES10.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;
@@ -24465,7 +25493,7 @@ function dmRisksPage(ctx) {
 }
 
 // src/web/templates/pages/dm/meetings.ts
-var DONE_STATUSES11 = /* @__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" });
@@ -24511,7 +25539,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_STATUSES11.has(a.frontmatter.status)).length;
+    const openCount = relatedActions.filter((a) => !DONE_STATUSES13.has(a.frontmatter.status)).length;
     return `
             <tr>
               <td>${formatDate(date5)}</td>
@@ -24526,7 +25554,7 @@ function dmMeetingsPage(ctx) {
   const recentMeetingActions = [];
   for (const [mid, acts] of meetingActionMap) {
     for (const act of acts) {
-      if (!DONE_STATUSES11.has(act.frontmatter.status)) {
+      if (!DONE_STATUSES13.has(act.frontmatter.status)) {
         recentMeetingActions.push({ action: act, meetingId: mid });
       }
     }
@@ -24721,7 +25749,7 @@ registerPersonaPage("dm", "meetings", dmMeetingsPage);
 registerPersonaPage("dm", "governance", dmGovernancePage);
 
 // src/web/templates/pages/tl/dashboard.ts
-var DONE_STATUSES12 = /* @__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" });
@@ -24729,8 +25757,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_STATUSES12.has(d.frontmatter.status));
-  const openTasks = tasks.filter((d) => !DONE_STATUSES12.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) => {
@@ -24788,7 +25816,7 @@ function tlDashboardPage(ctx) {
 }
 
 // src/web/templates/pages/tl/backlog.ts
-var DONE_STATUSES13 = /* @__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" });
@@ -24825,7 +25853,7 @@ function tlBacklogPage(ctx) {
           <tbody>
             ${sortedEpics.map((e) => {
     const eTasks = epicToTasks.get(e.frontmatter.id) ?? [];
-    const done = eTasks.filter((t) => DONE_STATUSES13.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 `
@@ -24845,7 +25873,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_STATUSES13.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",