mrvn-cli 0.5.7 → 0.5.9

package/dist/index.js

@@ -19392,7 +19392,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;
@@ -19401,7 +19401,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);
       }
     }
@@ -24895,13 +24895,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(path21, method = "GET", body) {
     const url2 = `${this.baseUrl}${path21}`;
+    return this.doRequest(url2, method, body);
+  }
+  async requestV3(path21, method = "GET", body) {
+    const url2 = `${this.baseUrlV3}${path21}`;
+    return this.doRequest(url2, method, body);
+  }
+  async doRequest(url2, method, body) {
     const headers = {
       Authorization: this.authHeader,
       "Content-Type": "application/json",
@@ -24915,18 +24925,26 @@ var JiraClient = class {
     if (!response.ok) {
       const text = await response.text().catch(() => "");
       throw new Error(
-        `Jira API error ${response.status} ${method} ${path21}: ${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)}`);
@@ -24941,6 +24959,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`,
@@ -24954,7 +24994,651 @@ 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_STATUSES14 = /* @__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_STATUSES14.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_STATUSES14.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_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 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;
+}
+async function syncJiraProgress(store, client, host, artifactId, statusMap) {
+  const fetchResult = await fetchJiraStatus(store, client, host, artifactId, statusMap);
+  const result = {
+    updated: [],
+    unchanged: 0,
+    errors: [...fetchResult.errors]
+  };
+  for (const artifact of fetchResult.artifacts) {
+    const hasChanges = artifact.statusChanged || artifact.progressChanged || artifact.linkedIssues.length > 0;
+    if (hasChanges) {
+      const updates = {
+        status: artifact.proposedMarvinStatus,
+        lastJiraSyncAt: (/* @__PURE__ */ new Date()).toISOString(),
+        jiraLinkedIssues: artifact.linkedIssues
+      };
+      if (artifact.proposedProgress !== void 0) {
+        updates.progress = artifact.proposedProgress;
+      }
+      store.update(artifact.id, updates);
+      if (artifact.type === "task") {
+        propagateProgressFromTask(store, artifact.id);
+      } else if (artifact.type === "action") {
+        propagateProgressToAction(store, artifact.id);
+      }
+      result.updated.push({
+        id: artifact.id,
+        jiraKey: artifact.jiraKey,
+        oldStatus: artifact.currentMarvinStatus,
+        newStatus: artifact.proposedMarvinStatus,
+        linkedIssues: artifact.linkedIssues
+      });
+    } else {
+      store.update(artifact.id, {
+        lastJiraSyncAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      result.unchanged++;
+    }
+  }
+  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_STATUSES15 = /* @__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_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 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
@@ -24998,6 +25682,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(
@@ -25158,9 +25843,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')")
       },
@@ -25201,6 +25886,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,
           {
@@ -25322,65 +26025,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`
   }
 };
 
@@ -30498,12 +31566,355 @@ Run "marvin doctor --fix" to auto-repair fixable issues.`));
   console.log();
 }
 
+// src/cli/commands/jira.ts
+import chalk20 from "chalk";
+async function jiraSyncCommand(artifactId, options = {}) {
+  const project = loadProject();
+  const plugin = resolvePlugin(project.config.methodology);
+  const registrations = plugin?.documentTypeRegistrations ?? [];
+  const jiReg = { type: "jira-issue", dirName: "jira-issues", idPrefix: "JI" };
+  const store = new DocumentStore(project.marvinDir, [...registrations, jiReg]);
+  const jiraUserConfig = loadUserConfig().jira;
+  const jira = createJiraClient(jiraUserConfig);
+  if (!jira) {
+    console.log(
+      chalk20.red(
+        'Jira is not configured. Run "marvin config jira" or set JIRA_HOST, JIRA_EMAIL, and JIRA_API_TOKEN environment variables.'
+      )
+    );
+    return;
+  }
+  const statusMap = project.config.jira?.statusMap;
+  const label = artifactId ? `Checking ${artifactId} against Jira...` : "Checking all Jira-linked actions/tasks...";
+  console.log(chalk20.dim(label));
+  if (options.dryRun) {
+    const fetchResult = await fetchJiraStatus(
+      store,
+      jira.client,
+      jira.host,
+      artifactId,
+      statusMap
+    );
+    const withChanges = fetchResult.artifacts.filter(
+      (a) => a.statusChanged || a.progressChanged
+    );
+    const noChanges = fetchResult.artifacts.filter(
+      (a) => !a.statusChanged && !a.progressChanged
+    );
+    if (withChanges.length > 0) {
+      console.log(chalk20.yellow(`
+Proposed changes for ${withChanges.length} artifact(s):`));
+      for (const a of withChanges) {
+        console.log(`  ${chalk20.bold(a.id)} (${a.jiraKey}) \u2014 Jira: "${a.jiraSummary}"`);
+        if (a.statusChanged) {
+          console.log(
+            `    status: ${chalk20.yellow(a.currentMarvinStatus)} \u2192 ${chalk20.green(a.proposedMarvinStatus)}`
+          );
+        }
+        if (a.progressChanged) {
+          console.log(
+            `    progress: ${chalk20.yellow(String(a.currentProgress ?? 0) + "%")} \u2192 ${chalk20.green(String(a.proposedProgress) + "%")}`
+          );
+        }
+        if (a.linkedIssues.length > 0) {
+          const done = a.linkedIssues.filter((l) => l.isDone).length;
+          console.log(chalk20.dim(`    ${done}/${a.linkedIssues.length} linked issues done`));
+        }
+      }
+      console.log(chalk20.dim("\nRun without --dry-run to apply these changes."));
+    }
+    if (noChanges.length > 0) {
+      console.log(chalk20.dim(`
+${noChanges.length} artifact(s) already in sync.`));
+    }
+    if (fetchResult.errors.length > 0) {
+      console.log(chalk20.red("\nErrors:"));
+      for (const err of fetchResult.errors) {
+        console.log(chalk20.red(`  ${err}`));
+      }
+    }
+    if (fetchResult.artifacts.length === 0 && fetchResult.errors.length === 0) {
+      console.log(chalk20.dim("\nNo Jira-linked actions/tasks found to check."));
+    }
+    return;
+  }
+  const result = await syncJiraProgress(
+    store,
+    jira.client,
+    jira.host,
+    artifactId,
+    statusMap
+  );
+  if (result.updated.length > 0) {
+    console.log(chalk20.green(`
+Updated ${result.updated.length} artifact(s):`));
+    for (const entry of result.updated) {
+      const statusChange = entry.oldStatus !== entry.newStatus ? `${chalk20.yellow(entry.oldStatus)} \u2192 ${chalk20.green(entry.newStatus)}` : chalk20.dim(entry.newStatus);
+      console.log(`  ${chalk20.bold(entry.id)} (${entry.jiraKey}): ${statusChange}`);
+      if (entry.linkedIssues.length > 0) {
+        const done = entry.linkedIssues.filter((l) => l.isDone).length;
+        console.log(
+          chalk20.dim(`    ${done}/${entry.linkedIssues.length} linked issues done`)
+        );
+        for (const li of entry.linkedIssues) {
+          const icon = li.isDone ? chalk20.green("\u2713") : chalk20.dim("\u25CB");
+          console.log(
+            chalk20.dim(`      ${icon} ${li.key} ${li.summary} [${li.relationship}]`)
+          );
+        }
+      }
+    }
+  }
+  if (result.unchanged > 0) {
+    console.log(chalk20.dim(`
+${result.unchanged} artifact(s) unchanged.`));
+  }
+  if (result.errors.length > 0) {
+    console.log(chalk20.red("\nErrors:"));
+    for (const err of result.errors) {
+      console.log(chalk20.red(`  ${err}`));
+    }
+  }
+  if (result.updated.length === 0 && result.unchanged === 0 && result.errors.length === 0) {
+    console.log(chalk20.dim("\nNo Jira-linked actions/tasks found to sync."));
+  }
+}
+async function jiraStatusesCommand(projectKey) {
+  const project = loadProject();
+  const jiraUserConfig = loadUserConfig().jira;
+  const jira = createJiraClient(jiraUserConfig);
+  if (!jira) {
+    console.log(
+      chalk20.red(
+        'Jira is not configured. Run "marvin config jira" or set JIRA_HOST, JIRA_EMAIL, and JIRA_API_TOKEN environment variables.'
+      )
+    );
+    return;
+  }
+  const resolvedProjectKey = projectKey ?? project.config.jira?.projectKey;
+  if (!resolvedProjectKey) {
+    console.log(
+      chalk20.red(
+        "No project key provided. Pass it as an argument or set jira.projectKey in .marvin/config.yaml."
+      )
+    );
+    return;
+  }
+  console.log(chalk20.dim(`Fetching statuses from Jira project ${resolvedProjectKey}...`));
+  const statusMap = project.config.jira?.statusMap;
+  const actionMap = statusMap?.action ?? DEFAULT_ACTION_STATUS_MAP;
+  const taskMap = statusMap?.task ?? DEFAULT_TASK_STATUS_MAP;
+  const email3 = jiraUserConfig?.email ?? process.env.JIRA_EMAIL;
+  const apiToken = jiraUserConfig?.apiToken ?? process.env.JIRA_API_TOKEN;
+  const auth = "Basic " + Buffer.from(`${email3}:${apiToken}`).toString("base64");
+  const params = new URLSearchParams({
+    jql: `project = ${resolvedProjectKey}`,
+    maxResults: "100",
+    fields: "status"
+  });
+  const resp = await fetch(`https://${jira.host}/rest/api/3/search/jql?${params}`, {
+    headers: { Authorization: auth, Accept: "application/json" }
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    console.log(chalk20.red(`Jira API error ${resp.status}: ${text}`));
+    return;
+  }
+  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 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);
+  }
+  console.log(
+    `
+Found ${chalk20.bold(String(statusCounts.size))} distinct statuses in ${chalk20.bold(resolvedProjectKey)} (scanned ${data.issues.length} of ${data.total} issues):
+`
+  );
+  const sorted = [...statusCounts.entries()].sort((a, b) => b[1] - a[1]);
+  let hasUnmapped = false;
+  for (const [status, count] of sorted) {
+    const actionTarget = actionLookup.get(status.toLowerCase());
+    const taskTarget = taskLookup.get(status.toLowerCase());
+    const actionLabel = actionTarget ? chalk20.green(`\u2192 ${actionTarget}`) : chalk20.yellow("UNMAPPED (\u2192 open)");
+    const taskLabel = taskTarget ? chalk20.green(`\u2192 ${taskTarget}`) : chalk20.yellow("UNMAPPED (\u2192 backlog)");
+    if (!actionTarget || !taskTarget) hasUnmapped = true;
+    console.log(`  ${chalk20.bold(status)} ${chalk20.dim(`(${count} issues)`)}`);
+    console.log(`    action: ${actionLabel}`);
+    console.log(`    task:   ${taskLabel}`);
+  }
+  if (hasUnmapped) {
+    console.log(chalk20.yellow("\nSome statuses are unmapped. Add jira.statusMap to .marvin/config.yaml:"));
+    console.log(chalk20.dim("  jira:"));
+    console.log(chalk20.dim("    statusMap:"));
+    console.log(chalk20.dim("      action:"));
+    console.log(chalk20.dim('        <marvin-status>: ["<Jira Status>", ...]'));
+    console.log(chalk20.dim("      task:"));
+    console.log(chalk20.dim('        <marvin-status>: ["<Jira Status>", ...]'));
+  } else {
+    console.log(chalk20.green("\nAll statuses are mapped."));
+  }
+  const usingConfig = statusMap?.action || statusMap?.task;
+  console.log(
+    chalk20.dim(
+      usingConfig ? "\nUsing status maps from .marvin/config.yaml." : "\nUsing built-in default status maps (no jira.statusMap in config)."
+    )
+  );
+}
+async function jiraDailyCommand(options) {
+  const proj = loadProject();
+  const plugin = resolvePlugin(proj.config.methodology);
+  const registrations = plugin?.documentTypeRegistrations ?? [];
+  const jiReg = { type: "jira-issue", dirName: "jira-issues", idPrefix: "JI" };
+  const store = new DocumentStore(proj.marvinDir, [...registrations, jiReg]);
+  const jiraUserConfig = loadUserConfig().jira;
+  const jira = createJiraClient(jiraUserConfig);
+  if (!jira) {
+    console.log(
+      chalk20.red(
+        'Jira is not configured. Run "marvin config jira" or set JIRA_HOST, JIRA_EMAIL, and JIRA_API_TOKEN environment variables.'
+      )
+    );
+    return;
+  }
+  const resolvedProjectKey = options.project ?? proj.config.jira?.projectKey;
+  if (!resolvedProjectKey) {
+    console.log(
+      chalk20.red(
+        "No project key provided. Use --project or set jira.projectKey in .marvin/config.yaml."
+      )
+    );
+    return;
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const fromDate = options.from ?? today;
+  const toDate = options.to ?? fromDate;
+  const statusMap = proj.config.jira?.statusMap;
+  const rangeLabel = fromDate === toDate ? fromDate : `${fromDate} to ${toDate}`;
+  console.log(
+    chalk20.dim(`Fetching Jira daily summary for ${resolvedProjectKey} \u2014 ${rangeLabel}...`)
+  );
+  const daily = await fetchJiraDaily(
+    store,
+    jira.client,
+    jira.host,
+    resolvedProjectKey,
+    { from: fromDate, to: toDate },
+    statusMap
+  );
+  console.log(
+    `
+${chalk20.bold(`Jira Daily \u2014 ${resolvedProjectKey} \u2014 ${rangeLabel}`)}`
+  );
+  console.log(`${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) {
+    console.log(chalk20.underline("Linked Issues (with Marvin artifacts):\n"));
+    for (const issue2 of linked) {
+      printIssueEntry(issue2);
+    }
+  }
+  if (unlinked.length > 0) {
+    console.log(chalk20.underline("Unlinked Issues (no Marvin artifact):\n"));
+    for (const issue2 of unlinked) {
+      printIssueEntry(issue2);
+    }
+  }
+  if (daily.proposedActions.length > 0) {
+    console.log(chalk20.underline("Proposed Actions:\n"));
+    for (const action of daily.proposedActions) {
+      const icon = action.type === "status-update" ? chalk20.yellow("\u21BB") : action.type === "unlinked-issue" ? chalk20.blue("+") : action.type === "link-suggestion" ? chalk20.cyan("\u{1F517}") : action.type === "question-candidate" ? chalk20.magenta("?") : action.type === "decision-candidate" ? chalk20.yellow("\u2696") : action.type === "blocker-detected" ? chalk20.red("\u{1F6AB}") : action.type === "resolution-detected" ? chalk20.green("\u2713") : chalk20.cyan("\u{1F4C4}");
+      console.log(`  ${icon} ${action.description}`);
+    }
+    console.log();
+  }
+  if (daily.errors.length > 0) {
+    console.log(chalk20.red("Errors:"));
+    for (const err of daily.errors) {
+      console.log(chalk20.red(`  ${err}`));
+    }
+  }
+  if (daily.issues.length === 0 && daily.errors.length === 0) {
+    console.log(chalk20.dim("No Jira activity found for this period."));
+  }
+}
+function printIssueEntry(issue2) {
+  const artifacts = issue2.marvinArtifacts.map((a) => a.id).join(", ");
+  const artifactLabel = artifacts ? chalk20.cyan(` \u2192 ${artifacts}`) : "";
+  console.log(
+    `  ${chalk20.bold(issue2.key)} \u2014 ${issue2.summary} [${chalk20.yellow(issue2.currentStatus)}]${artifactLabel}`
+  );
+  console.log(
+    chalk20.dim(`  Type: ${issue2.issueType} | Assignee: ${issue2.assignee ?? "unassigned"}`)
+  );
+  for (const a of issue2.marvinArtifacts) {
+    if (a.statusDrift) {
+      console.log(
+        chalk20.yellow(`  \u26A0 ${a.id} status drift: Marvin="${a.currentStatus}" vs proposed="${a.proposedStatus}"`)
+      );
+    }
+  }
+  if (issue2.changes.length > 0) {
+    console.log(chalk20.dim("  Changes:"));
+    for (const c of issue2.changes) {
+      console.log(
+        chalk20.dim(`    ${c.field}: ${c.from ?? "\u2205"} \u2192 ${c.to ?? "\u2205"} (${c.author}, ${c.timestamp.slice(0, 16)})`)
+      );
+    }
+  }
+  if (issue2.comments.length > 0) {
+    console.log(chalk20.dim(`  Comments (${issue2.comments.length}):`));
+    for (const c of issue2.comments) {
+      let signalLabel = "";
+      if (c.signals.length > 0) {
+        const labels = c.signals.map(
+          (s) => s.type === "blocker" ? chalk20.red("\u{1F6AB}blocker") : s.type === "decision" ? chalk20.yellow("\u2696decision") : s.type === "question" ? chalk20.magenta("?question") : chalk20.green("\u2713resolution")
+        );
+        signalLabel = ` ${labels.join(" ")}`;
+      }
+      console.log(chalk20.dim(`    ${c.author} (${c.created.slice(0, 16)})${signalLabel}: ${c.bodyPreview}`));
+    }
+  }
+  if (issue2.linkSuggestions.length > 0) {
+    console.log(chalk20.cyan("  Possible Marvin matches:"));
+    for (const s of issue2.linkSuggestions) {
+      console.log(
+        chalk20.cyan(`    \u{1F517} ${s.artifactId} ("${s.artifactTitle}") \u2014 ${Math.round(s.score * 100)}% match [${s.sharedTerms.join(", ")}]`)
+      );
+    }
+  }
+  if (issue2.linkedIssues.length > 0) {
+    console.log(chalk20.dim("  Linked issues:"));
+    for (const li of issue2.linkedIssues) {
+      const icon = li.isDone ? chalk20.green("\u2713") : chalk20.dim("\u25CB");
+      console.log(chalk20.dim(`    ${icon} ${li.key} ${li.summary} [${li.relationship}] \u2014 ${li.status}`));
+    }
+  }
+  if (issue2.confluenceLinks.length > 0) {
+    console.log(chalk20.dim("  Confluence pages:"));
+    for (const cl of issue2.confluenceLinks) {
+      console.log(chalk20.dim(`    \u{1F4C4} ${cl.title}: ${cl.url}`));
+    }
+  }
+  console.log();
+}
+
 // src/cli/program.ts
 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.7");
+  ).version("0.5.9");
   program.command("init").description("Initialize a new Marvin project in the current directory").action(async () => {
     await initCommand();
   });
@@ -30599,6 +32010,16 @@ function createProgram() {
   generateCmd.command("claude-md").description("Generate .marvin/CLAUDE.md project instruction file").option("--force", "Overwrite existing file without prompting").action(async (options) => {
     await generateClaudeMdCommand(options);
   });
+  const jiraCmd = program.command("jira").description("Jira integration commands");
+  jiraCmd.command("sync [artifactId]").description("Sync Jira-linked actions/tasks with their Jira issues").option("--dry-run", "Preview proposed changes without applying them").action(async (artifactId, options) => {
+    await jiraSyncCommand(artifactId, options);
+  });
+  jiraCmd.command("statuses [projectKey]").description("Show Jira project statuses and their Marvin status mappings").action(async (projectKey) => {
+    await jiraStatusesCommand(projectKey);
+  });
+  jiraCmd.command("daily").description("Show daily summary of Jira changes with Marvin cross-references").option("--from <date>", "Start date (YYYY-MM-DD, default: today)").option("--to <date>", "End date (YYYY-MM-DD, default: same as --from)").option("--project <key>", "Jira project key (falls back to config)").action(async (options) => {
+    await jiraDailyCommand(options);
+  });
   return program;
 }
 export {