mrvn-cli 0.2.5 → 0.2.8

package/dist/marvin-serve.js

@@ -14971,6 +14971,128 @@ function createMeetingTools(store) {
 
 // src/plugins/builtin/tools/reports.ts
 import { tool as tool8 } from "@anthropic-ai/claude-agent-sdk";
+
+// src/reports/gar/collector.ts
+function collectGarMetrics(store) {
+  const allActions = store.list({ type: "action" });
+  const openActions = allActions.filter((d) => d.frontmatter.status === "open");
+  const doneActions = allActions.filter((d) => d.frontmatter.status === "done");
+  const allDocs = store.list();
+  const blockedItems = allDocs.filter(
+    (d) => d.frontmatter.tags?.includes("blocked")
+  );
+  const overdueItems = allDocs.filter(
+    (d) => d.frontmatter.tags?.includes("overdue")
+  );
+  const openQuestions = store.list({ type: "question", status: "open" });
+  const riskItems = allDocs.filter(
+    (d) => d.frontmatter.tags?.includes("risk")
+  );
+  const unownedActions = openActions.filter((d) => !d.frontmatter.owner);
+  const total = allActions.length;
+  const done = doneActions.length;
+  const completionPct = total > 0 ? Math.round(done / total * 100) : 100;
+  const scheduleItems = [
+    ...blockedItems,
+    ...overdueItems
+  ].filter(
+    (d, i, arr) => arr.findIndex((x) => x.frontmatter.id === d.frontmatter.id) === i
+  ).map((d) => ({ id: d.frontmatter.id, title: d.frontmatter.title }));
+  const qualityItems = [
+    ...riskItems,
+    ...openQuestions
+  ].filter(
+    (d, i, arr) => arr.findIndex((x) => x.frontmatter.id === d.frontmatter.id) === i
+  ).map((d) => ({ id: d.frontmatter.id, title: d.frontmatter.title }));
+  const resourceItems = unownedActions.map((d) => ({
+    id: d.frontmatter.id,
+    title: d.frontmatter.title
+  }));
+  return {
+    scope: {
+      total,
+      open: openActions.length,
+      done,
+      completionPct
+    },
+    schedule: {
+      blocked: blockedItems.length,
+      overdue: overdueItems.length,
+      items: scheduleItems
+    },
+    quality: {
+      risks: riskItems.length,
+      openQuestions: openQuestions.length,
+      items: qualityItems
+    },
+    resources: {
+      unowned: unownedActions.length,
+      items: resourceItems
+    }
+  };
+}
+
+// src/reports/gar/evaluator.ts
+function worstStatus(statuses) {
+  if (statuses.includes("red")) return "red";
+  if (statuses.includes("amber")) return "amber";
+  return "green";
+}
+function evaluateGar(projectName, metrics) {
+  const areas = [];
+  const scopePct = metrics.scope.completionPct;
+  const scopeStatus = scopePct >= 70 ? "green" : scopePct >= 40 ? "amber" : "red";
+  areas.push({
+    name: "Scope",
+    status: scopeStatus,
+    summary: `${scopePct}% complete (${metrics.scope.done}/${metrics.scope.total})`,
+    items: []
+  });
+  const scheduleCount = metrics.schedule.blocked + metrics.schedule.overdue;
+  const scheduleStatus = scheduleCount === 0 ? "green" : scheduleCount <= 2 ? "amber" : "red";
+  const scheduleParts = [];
+  if (metrics.schedule.blocked > 0)
+    scheduleParts.push(`${metrics.schedule.blocked} blocked`);
+  if (metrics.schedule.overdue > 0)
+    scheduleParts.push(`${metrics.schedule.overdue} overdue`);
+  areas.push({
+    name: "Schedule",
+    status: scheduleStatus,
+    summary: scheduleParts.length > 0 ? scheduleParts.join(", ") : "on track",
+    items: metrics.schedule.items
+  });
+  const qualityCount = metrics.quality.risks + metrics.quality.openQuestions;
+  const qualityStatus = qualityCount === 0 ? "green" : qualityCount <= 2 ? "amber" : "red";
+  const qualityParts = [];
+  if (metrics.quality.risks > 0)
+    qualityParts.push(`${metrics.quality.risks} risk(s)`);
+  if (metrics.quality.openQuestions > 0)
+    qualityParts.push(`${metrics.quality.openQuestions} open question(s)`);
+  areas.push({
+    name: "Quality",
+    status: qualityStatus,
+    summary: qualityParts.length > 0 ? qualityParts.join(", ") : "no issues",
+    items: metrics.quality.items
+  });
+  const resourceCount = metrics.resources.unowned;
+  const resourceStatus = resourceCount === 0 ? "green" : resourceCount <= 2 ? "amber" : "red";
+  areas.push({
+    name: "Resources",
+    status: resourceStatus,
+    summary: resourceCount > 0 ? `${resourceCount} unowned action(s)` : "all assigned",
+    items: metrics.resources.items
+  });
+  const overall = worstStatus(areas.map((a) => a.status));
+  return {
+    projectName,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    overall,
+    areas,
+    metrics
+  };
+}
+
+// src/plugins/builtin/tools/reports.ts
 function createReportTools(store) {
   return [
     tool8(
@@ -15059,41 +15181,10 @@ function createReportTools(store) {
       "Generate a Green-Amber-Red report with metrics across scope, schedule, quality, and resources",
       {},
       async () => {
-        const allActions = store.list({ type: "action" });
-        const openActions = allActions.filter((d) => d.frontmatter.status === "open");
-        const doneActions = allActions.filter((d) => d.frontmatter.status === "done");
-        const allDocs = store.list();
-        const blockedItems = allDocs.filter(
-          (d) => d.frontmatter.tags?.includes("blocked")
-        );
-        const overdueItems = allDocs.filter(
-          (d) => d.frontmatter.tags?.includes("overdue")
-        );
-        const openQuestions = store.list({ type: "question", status: "open" });
-        const riskItems = allDocs.filter(
-          (d) => d.frontmatter.tags?.includes("risk")
-        );
-        const unownedActions = openActions.filter((d) => !d.frontmatter.owner);
-        const areas = {
-          scope: {
-            total: allActions.length,
-            open: openActions.length,
-            done: doneActions.length
-          },
-          schedule: {
-            blocked: blockedItems.length,
-            overdue: overdueItems.length
-          },
-          quality: {
-            openQuestions: openQuestions.length,
-            risks: riskItems.length
-          },
-          resources: {
-            unowned: unownedActions.length
-          }
-        };
+        const metrics = collectGarMetrics(store);
+        const report = evaluateGar("project", metrics);
         return {
-          content: [{ type: "text", text: JSON.stringify({ areas }, null, 2) }]
+          content: [{ type: "text", text: JSON.stringify(report, null, 2) }]
         };
       },
       { annotations: { readOnly: true } }
@@ -15873,6 +15964,188 @@ function createSprintTools(store) {
   ];
 }
 
+// src/plugins/builtin/tools/sprint-planning.ts
+import { tool as tool13 } from "@anthropic-ai/claude-agent-sdk";
+var PRIORITY_ORDER = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+function priorityRank(p) {
+  return PRIORITY_ORDER[p ?? ""] ?? 99;
+}
+function createSprintPlanningTools(store) {
+  return [
+    tool13(
+      "gather_sprint_planning_context",
+      "Aggregate all planning-relevant data for proposing the next sprint: approved features, backlog epics, active sprint, velocity reference, blockers, and summary stats",
+      {
+        focusFeature: external_exports.string().optional().describe("Filter backlog to epics of a specific feature ID (e.g. 'F-001')"),
+        sprintDurationDays: external_exports.number().optional().describe("Expected sprint duration in days \u2014 passed through for capacity reasoning")
+      },
+      async (args) => {
+        const features = store.list({ type: "feature" });
+        const epics = store.list({ type: "epic" });
+        const sprints = store.list({ type: "sprint" });
+        const questions = store.list({ type: "question", status: "open" });
+        const contributions = store.list({ type: "contribution" });
+        const approvedFeatures = features.filter((f) => f.frontmatter.status === "approved").sort((a, b) => priorityRank(a.frontmatter.priority) - priorityRank(b.frontmatter.priority)).map((f) => {
+          const linkedEpics = epics.filter((e) => e.frontmatter.linkedFeature === f.frontmatter.id);
+          const epicsByStatus = {};
+          for (const e of linkedEpics) {
+            epicsByStatus[e.frontmatter.status] = (epicsByStatus[e.frontmatter.status] ?? 0) + 1;
+          }
+          return {
+            id: f.frontmatter.id,
+            title: f.frontmatter.title,
+            priority: f.frontmatter.priority,
+            owner: f.frontmatter.owner,
+            epicCount: linkedEpics.length,
+            epicsByStatus
+          };
+        });
+        const assignedEpicIds = /* @__PURE__ */ new Set();
+        for (const sp of sprints) {
+          const linked = sp.frontmatter.linkedEpics ?? [];
+          for (const id of linked) assignedEpicIds.add(id);
+        }
+        const featureMap = new Map(features.map((f) => [f.frontmatter.id, f]));
+        let backlogEpics = epics.filter(
+          (e) => !assignedEpicIds.has(e.frontmatter.id) && e.frontmatter.status !== "done"
+        );
+        if (args.focusFeature) {
+          backlogEpics = backlogEpics.filter(
+            (e) => e.frontmatter.linkedFeature === args.focusFeature
+          );
+        }
+        const backlog = backlogEpics.sort((a, b) => {
+          const fa = featureMap.get(a.frontmatter.linkedFeature);
+          const fb = featureMap.get(b.frontmatter.linkedFeature);
+          return priorityRank(fa?.frontmatter.priority) - priorityRank(fb?.frontmatter.priority);
+        }).map((e) => {
+          const parent = featureMap.get(e.frontmatter.linkedFeature);
+          return {
+            id: e.frontmatter.id,
+            title: e.frontmatter.title,
+            status: e.frontmatter.status,
+            linkedFeature: e.frontmatter.linkedFeature,
+            featureTitle: parent?.frontmatter.title ?? null,
+            featurePriority: parent?.frontmatter.priority ?? null,
+            estimatedEffort: e.frontmatter.estimatedEffort ?? null,
+            targetDate: e.frontmatter.targetDate ?? null
+          };
+        });
+        const activeSprintDoc = sprints.find((s) => s.frontmatter.status === "active") ?? null;
+        let activeSprint = null;
+        if (activeSprintDoc) {
+          const linkedEpicIds = activeSprintDoc.frontmatter.linkedEpics ?? [];
+          const linkedEpics = linkedEpicIds.map((epicId) => {
+            const epic = store.get(epicId);
+            return epic ? { id: epicId, title: epic.frontmatter.title, status: epic.frontmatter.status } : { id: epicId, title: "(not found)", status: "unknown" };
+          });
+          const allDocs = store.list();
+          const sprintTag = `sprint:${activeSprintDoc.frontmatter.id}`;
+          const workItems = allDocs.filter(
+            (d) => d.frontmatter.type !== "sprint" && d.frontmatter.type !== "epic" && d.frontmatter.tags?.includes(sprintTag)
+          );
+          const doneCount = workItems.filter(
+            (d) => d.frontmatter.status === "done" || d.frontmatter.status === "resolved" || d.frontmatter.status === "closed"
+          ).length;
+          const completionPct = workItems.length > 0 ? Math.round(doneCount / workItems.length * 100) : 0;
+          activeSprint = {
+            id: activeSprintDoc.frontmatter.id,
+            title: activeSprintDoc.frontmatter.title,
+            goal: activeSprintDoc.frontmatter.goal,
+            startDate: activeSprintDoc.frontmatter.startDate,
+            endDate: activeSprintDoc.frontmatter.endDate,
+            linkedEpics,
+            workItems: { total: workItems.length, done: doneCount, completionPct }
+          };
+        }
+        const completedSprints = sprints.filter((s) => s.frontmatter.status === "completed").sort((a, b) => {
+          const da = a.frontmatter.endDate ?? "";
+          const db = b.frontmatter.endDate ?? "";
+          return da < db ? 1 : da > db ? -1 : 0;
+        }).slice(0, 2);
+        const velocityReference = completedSprints.map((sp) => {
+          const linkedEpicIds = sp.frontmatter.linkedEpics ?? [];
+          const efforts = [];
+          for (const epicId of linkedEpicIds) {
+            const epic = store.get(epicId);
+            if (epic?.frontmatter.estimatedEffort) {
+              efforts.push(String(epic.frontmatter.estimatedEffort));
+            }
+          }
+          const allDocs = store.list();
+          const sprintTag = `sprint:${sp.frontmatter.id}`;
+          const workItems = allDocs.filter(
+            (d) => d.frontmatter.type !== "sprint" && d.frontmatter.type !== "epic" && d.frontmatter.tags?.includes(sprintTag)
+          );
+          return {
+            id: sp.frontmatter.id,
+            title: sp.frontmatter.title,
+            startDate: sp.frontmatter.startDate,
+            endDate: sp.frontmatter.endDate,
+            epicCount: linkedEpicIds.length,
+            efforts,
+            workItemCount: workItems.length
+          };
+        });
+        const openBlockerContributions = contributions.filter(
+          (c) => c.frontmatter.status === "open" && (c.frontmatter.contributionType === "risk-finding" || c.frontmatter.contributionType === "blocker-report")
+        );
+        const blockers = {
+          openQuestions: questions.map((q) => ({
+            id: q.frontmatter.id,
+            title: q.frontmatter.title
+          })),
+          openRiskAndBlockerContributions: openBlockerContributions.map((c) => ({
+            id: c.frontmatter.id,
+            title: c.frontmatter.title,
+            contributionType: c.frontmatter.contributionType
+          }))
+        };
+        const totalBacklogEfforts = backlog.filter((e) => e.estimatedEffort !== null).map((e) => String(e.estimatedEffort));
+        const approvedFeaturesWithNoEpics = approvedFeatures.filter((f) => f.epicCount === 0).map((f) => ({ id: f.id, title: f.title }));
+        const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        const epicsAtRisk = epics.filter((e) => {
+          if (e.frontmatter.status === "done") return false;
+          if (e.frontmatter.targetDate && e.frontmatter.targetDate < now) return true;
+          const parent = featureMap.get(e.frontmatter.linkedFeature);
+          if (parent?.frontmatter.status === "deferred") return true;
+          return false;
+        }).map((e) => ({
+          id: e.frontmatter.id,
+          title: e.frontmatter.title,
+          reason: e.frontmatter.targetDate && e.frontmatter.targetDate < now ? "past-target-date" : "deferred-feature"
+        }));
+        const plannedSprintCount = sprints.filter((s) => s.frontmatter.status === "planned").length;
+        const summary = {
+          totalBacklogEpics: backlog.length,
+          totalBacklogEfforts,
+          approvedFeaturesWithNoEpics,
+          epicsAtRisk,
+          plannedSprintCount
+        };
+        const result = {
+          approvedFeatures,
+          backlog,
+          activeSprint,
+          velocityReference,
+          blockers,
+          summary,
+          ...args.sprintDurationDays !== void 0 ? { sprintDurationDays: args.sprintDurationDays } : {}
+        };
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      },
+      { annotations: { readOnly: true } }
+    )
+  ];
+}
+
 // src/plugins/common.ts
 var COMMON_REGISTRATIONS = [
   { type: "meeting", dirName: "meetings", idPrefix: "M" },
@@ -15889,7 +16162,8 @@ function createCommonTools(store) {
     ...createFeatureTools(store),
     ...createEpicTools(store),
     ...createContributionTools(store),
-    ...createSprintTools(store)
+    ...createSprintTools(store),
+    ...createSprintPlanningTools(store)
   ];
 }
 
@@ -15962,7 +16236,12 @@ var genericAgilePlugin = {
 - **list_sprints** / **get_sprint**: View sprints to understand iteration scope and delivery dates.
 - **update_sprint**: Assign epics to sprints by updating linkedEpics when breaking features into work.
 - Tag technical actions and decisions with \`sprint:SP-xxx\` to associate them with a sprint.
-- Use **generate_sprint_progress** to track technical work completion within an iteration.`,
+- Use **generate_sprint_progress** to track technical work completion within an iteration.
+
+**Sprint Planning:**
+- When asked to plan or propose a sprint, ALWAYS call **gather_sprint_planning_context** first.
+- Focus on: technical readiness of each epic, open technical questions or spikes, effort balance across the sprint, and feature coverage.
+- Present a structured sprint proposal with technical rationale for each selected epic, known technical risks, and any prerequisite work that should be completed first.`,
     "delivery-manager": `You track delivery across features and epics, manage schedules, and report on progress.
 
 **Report Tools:**
@@ -16010,7 +16289,13 @@ var genericAgilePlugin = {
 - Assign epics to sprints via linkedEpics.
 - Tag work items (actions, decisions, questions) with \`sprint:SP-xxx\` for sprint scoping.
 - Track delivery dates and flag at-risk sprints.
-- Register past/completed sprints for historical tracking.`,
+- Register past/completed sprints for historical tracking.
+
+**Sprint Planning:**
+- When asked to plan or propose a sprint, ALWAYS call **gather_sprint_planning_context** first. It aggregates approved features, backlog epics, active sprint status, velocity from recent sprints, blockers, and summary stats in one call.
+- Reason through: priority (critical/high features first), capacity (compare backlog effort to velocity reference), dependencies and blockers, balance across features, and risk.
+- Present a structured sprint proposal: title, goal, suggested dates, selected epics with rationale for each, excluded epics with reason, and identified risks.
+- After user confirmation, use **create_sprint** with the agreed epics to persist the sprint.`,
     "*": `You have access to feature, epic, sprint, and meeting tools for project coordination:
 
 **Features** (F-xxx): Product capabilities defined by the Product Owner. Features progress through draft \u2192 approved \u2192 done.
@@ -16033,10 +16318,10 @@ var genericAgilePlugin = {
 };
 
 // src/plugins/builtin/tools/use-cases.ts
-import { tool as tool13 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool14 } from "@anthropic-ai/claude-agent-sdk";
 function createUseCaseTools(store) {
   return [
-    tool13(
+    tool14(
       "list_use_cases",
       "List all extension use cases, optionally filtered by status or extension type",
       {
@@ -16066,7 +16351,7 @@ function createUseCaseTools(store) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool13(
+    tool14(
       "get_use_case",
       "Get the full content of a specific use case by ID",
       { id: external_exports.string().describe("Use case ID (e.g. 'UC-001')") },
@@ -16093,7 +16378,7 @@ function createUseCaseTools(store) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool13(
+    tool14(
       "create_use_case",
       "Create a new extension use case definition (Phase 1: Assess Extension Use Case)",
       {
@@ -16127,7 +16412,7 @@ function createUseCaseTools(store) {
         };
       }
     ),
-    tool13(
+    tool14(
       "update_use_case",
       "Update an existing extension use case",
       {
@@ -16157,10 +16442,10 @@ function createUseCaseTools(store) {
 }
 
 // src/plugins/builtin/tools/tech-assessments.ts
-import { tool as tool14 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool15 } from "@anthropic-ai/claude-agent-sdk";
 function createTechAssessmentTools(store) {
   return [
-    tool14(
+    tool15(
       "list_tech_assessments",
       "List all technology assessments, optionally filtered by status",
       {
@@ -16191,7 +16476,7 @@ function createTechAssessmentTools(store) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool14(
+    tool15(
       "get_tech_assessment",
       "Get the full content of a specific technology assessment by ID",
       { id: external_exports.string().describe("Tech assessment ID (e.g. 'TA-001')") },
@@ -16218,7 +16503,7 @@ function createTechAssessmentTools(store) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool14(
+    tool15(
       "create_tech_assessment",
       "Create a new technology assessment linked to an assessed/approved use case (Phase 2: Assess Extension Technology)",
       {
@@ -16289,7 +16574,7 @@ function createTechAssessmentTools(store) {
         };
       }
     ),
-    tool14(
+    tool15(
       "update_tech_assessment",
       "Update an existing technology assessment. The linked use case cannot be changed.",
       {
@@ -16319,10 +16604,10 @@ function createTechAssessmentTools(store) {
 }
 
 // src/plugins/builtin/tools/extension-designs.ts
-import { tool as tool15 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool16 } from "@anthropic-ai/claude-agent-sdk";
 function createExtensionDesignTools(store) {
   return [
-    tool15(
+    tool16(
       "list_extension_designs",
       "List all extension designs, optionally filtered by status",
       {
@@ -16352,7 +16637,7 @@ function createExtensionDesignTools(store) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool15(
+    tool16(
       "get_extension_design",
       "Get the full content of a specific extension design by ID",
       { id: external_exports.string().describe("Extension design ID (e.g. 'XD-001')") },
@@ -16379,7 +16664,7 @@ function createExtensionDesignTools(store) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool15(
+    tool16(
       "create_extension_design",
       "Create a new extension design linked to a recommended tech assessment (Phase 3: Define Extension Target Solution)",
       {
@@ -16447,7 +16732,7 @@ function createExtensionDesignTools(store) {
         };
       }
     ),
-    tool15(
+    tool16(
       "update_extension_design",
       "Update an existing extension design. The linked tech assessment cannot be changed.",
       {
@@ -16476,10 +16761,10 @@ function createExtensionDesignTools(store) {
 }
 
 // src/plugins/builtin/tools/aem-reports.ts
-import { tool as tool16 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool17 } from "@anthropic-ai/claude-agent-sdk";
 function createAemReportTools(store) {
   return [
-    tool16(
+    tool17(
       "generate_extension_portfolio",
       "Generate a portfolio view of all use cases with their linked tech assessments and extension designs",
       {},
@@ -16531,7 +16816,7 @@ function createAemReportTools(store) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool16(
+    tool17(
       "generate_tech_readiness",
       "Generate a BTP technology readiness report showing service coverage and gaps across assessments",
       {},
@@ -16583,7 +16868,7 @@ function createAemReportTools(store) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool16(
+    tool17(
       "generate_phase_status",
       "Generate a phase progress report showing artifact counts and readiness per AEM phase",
       {},
@@ -16645,11 +16930,11 @@ function createAemReportTools(store) {
 import * as fs6 from "fs";
 import * as path6 from "path";
 import * as YAML4 from "yaml";
-import { tool as tool17 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool18 } from "@anthropic-ai/claude-agent-sdk";
 var PHASES = ["assess-use-case", "assess-technology", "define-solution"];
 function createAemPhaseTools(store, marvinDir) {
   return [
-    tool17(
+    tool18(
       "get_current_phase",
       "Get the current AEM phase from project configuration",
       {},
@@ -16670,7 +16955,7 @@ function createAemPhaseTools(store, marvinDir) {
       },
       { annotations: { readOnly: true } }
     ),
-    tool17(
+    tool18(
       "advance_phase",
       "Advance to the next AEM phase. Performs soft gate checks and warns if artifacts are incomplete, but does not block.",
       {
@@ -16977,9 +17262,495 @@ Be thorough but concise. Focus on actionable insights.`,
   ]
 };
 
+// src/skills/builtin/jira/tools.ts
+import { tool as tool19 } from "@anthropic-ai/claude-agent-sdk";
+
+// src/skills/builtin/jira/client.ts
+var JiraClient = class {
+  baseUrl;
+  authHeader;
+  constructor(config2) {
+    this.baseUrl = `https://${config2.host}/rest/api/2`;
+    this.authHeader = "Basic " + Buffer.from(`${config2.email}:${config2.apiToken}`).toString("base64");
+  }
+  async request(path10, method = "GET", body) {
+    const url2 = `${this.baseUrl}${path10}`;
+    const headers = {
+      Authorization: this.authHeader,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    const response = await fetch(url2, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new Error(
+        `Jira API error ${response.status} ${method} ${path10}: ${text}`
+      );
+    }
+    if (response.status === 204) return void 0;
+    return response.json();
+  }
+  async searchIssues(jql, maxResults = 50) {
+    const params = new URLSearchParams({
+      jql,
+      maxResults: String(maxResults)
+    });
+    return this.request(`/search?${params}`);
+  }
+  async getIssue(key) {
+    return this.request(`/issue/${encodeURIComponent(key)}`);
+  }
+  async createIssue(fields) {
+    return this.request("/issue", "POST", { fields });
+  }
+  async updateIssue(key, fields) {
+    await this.request(
+      `/issue/${encodeURIComponent(key)}`,
+      "PUT",
+      { fields }
+    );
+  }
+  async addComment(key, body) {
+    await this.request(
+      `/issue/${encodeURIComponent(key)}/comment`,
+      "POST",
+      { body }
+    );
+  }
+};
+function createJiraClient() {
+  const host = process.env.JIRA_HOST;
+  const email3 = process.env.JIRA_EMAIL;
+  const apiToken = process.env.JIRA_API_TOKEN;
+  if (!host || !email3 || !apiToken) return null;
+  return new JiraClient({ host, email: email3, apiToken });
+}
+
+// src/skills/builtin/jira/tools.ts
+var JIRA_TYPE = "jira-issue";
+function jiraNotConfiguredError() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: "Jira is not configured. Set JIRA_HOST, JIRA_EMAIL, and JIRA_API_TOKEN environment variables."
+      }
+    ],
+    isError: true
+  };
+}
+function mapJiraStatus(jiraStatus) {
+  const lower = jiraStatus.toLowerCase();
+  if (lower === "done" || lower === "closed" || lower === "resolved") return "done";
+  if (lower === "in progress" || lower === "in review") return "in-progress";
+  return "open";
+}
+function jiraIssueToFrontmatter(issue2, host, linkedArtifacts) {
+  return {
+    title: issue2.fields.summary,
+    status: mapJiraStatus(issue2.fields.status.name),
+    jiraKey: issue2.key,
+    jiraUrl: `https://${host}/browse/${issue2.key}`,
+    issueType: issue2.fields.issuetype.name,
+    priority: issue2.fields.priority?.name ?? "None",
+    assignee: issue2.fields.assignee?.displayName ?? "",
+    labels: issue2.fields.labels ?? [],
+    linkedArtifacts: linkedArtifacts ?? [],
+    tags: [`jira:${issue2.key}`],
+    lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function findByJiraKey(store, jiraKey) {
+  const docs = store.list({ type: JIRA_TYPE });
+  return docs.find((d) => d.frontmatter.jiraKey === jiraKey);
+}
+function createJiraTools(store) {
+  return [
+    // --- Local read tools ---
+    tool19(
+      "list_jira_issues",
+      "List locally synced Jira issues (JI-xxx documents), optionally filtered by status or Jira key",
+      {
+        status: external_exports.enum(["open", "in-progress", "done"]).optional().describe("Filter by local status"),
+        jiraKey: external_exports.string().optional().describe("Filter by Jira issue key (e.g. 'PROJ-123')")
+      },
+      async (args) => {
+        let docs = store.list({ type: JIRA_TYPE, status: args.status });
+        if (args.jiraKey) {
+          docs = docs.filter((d) => d.frontmatter.jiraKey === args.jiraKey);
+        }
+        const summary = docs.map((d) => ({
+          id: d.frontmatter.id,
+          title: d.frontmatter.title,
+          status: d.frontmatter.status,
+          jiraKey: d.frontmatter.jiraKey,
+          issueType: d.frontmatter.issueType,
+          priority: d.frontmatter.priority,
+          assignee: d.frontmatter.assignee,
+          linkedArtifacts: d.frontmatter.linkedArtifacts
+        }));
+        return {
+          content: [{ type: "text", text: JSON.stringify(summary, null, 2) }]
+        };
+      },
+      { annotations: { readOnly: true } }
+    ),
+    tool19(
+      "get_jira_issue",
+      "Get the full content of a locally synced Jira issue by local ID (JI-xxx) or Jira key (PROJ-123)",
+      {
+        id: external_exports.string().describe("Local ID (e.g. 'JI-001') or Jira key (e.g. 'PROJ-123')")
+      },
+      async (args) => {
+        let doc = store.get(args.id);
+        if (!doc) {
+          doc = findByJiraKey(store, args.id);
+        }
+        if (!doc) {
+          return {
+            content: [{ type: "text", text: `Jira issue ${args.id} not found locally` }],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                { ...doc.frontmatter, content: doc.content },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      },
+      { annotations: { readOnly: true } }
+    ),
+    // --- Jira → Local tools ---
+    tool19(
+      "pull_jira_issue",
+      "Fetch a single Jira issue by key and create/update a local JI-xxx document",
+      {
+        key: external_exports.string().describe("Jira issue key (e.g. 'PROJ-123')")
+      },
+      async (args) => {
+        const client = createJiraClient();
+        if (!client) return jiraNotConfiguredError();
+        const issue2 = await client.getIssue(args.key);
+        const host = process.env.JIRA_HOST;
+        const existing = findByJiraKey(store, args.key);
+        if (existing) {
+          const fm2 = jiraIssueToFrontmatter(
+            issue2,
+            host,
+            existing.frontmatter.linkedArtifacts
+          );
+          const doc2 = store.update(
+            existing.frontmatter.id,
+            fm2,
+            issue2.fields.description ?? ""
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Updated ${doc2.frontmatter.id} from Jira ${args.key}`
+              }
+            ]
+          };
+        }
+        const fm = jiraIssueToFrontmatter(issue2, host);
+        const doc = store.create(
+          JIRA_TYPE,
+          fm,
+          issue2.fields.description ?? ""
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Created ${doc.frontmatter.id} from Jira ${args.key}`
+            }
+          ]
+        };
+      }
+    ),
+    tool19(
+      "pull_jira_issues_jql",
+      "Bulk fetch Jira issues via JQL query and create/update local JI-xxx documents",
+      {
+        jql: external_exports.string().describe(`JQL query (e.g. 'project = PROJ AND status = "In Progress"')`),
+        maxResults: external_exports.number().optional().describe("Max issues to fetch (default 50)")
+      },
+      async (args) => {
+        const client = createJiraClient();
+        if (!client) return jiraNotConfiguredError();
+        const result = await client.searchIssues(args.jql, args.maxResults);
+        const host = process.env.JIRA_HOST;
+        const created = [];
+        const updated = [];
+        for (const issue2 of result.issues) {
+          const existing = findByJiraKey(store, issue2.key);
+          if (existing) {
+            const fm = jiraIssueToFrontmatter(
+              issue2,
+              host,
+              existing.frontmatter.linkedArtifacts
+            );
+            store.update(
+              existing.frontmatter.id,
+              fm,
+              issue2.fields.description ?? ""
+            );
+            updated.push(`${existing.frontmatter.id} (${issue2.key})`);
+          } else {
+            const fm = jiraIssueToFrontmatter(issue2, host);
+            const doc = store.create(
+              JIRA_TYPE,
+              fm,
+              issue2.fields.description ?? ""
+            );
+            created.push(`${doc.frontmatter.id} (${issue2.key})`);
+          }
+        }
+        const parts = [
+          `Fetched ${result.issues.length} of ${result.total} matching issues.`
+        ];
+        if (created.length > 0) parts.push(`Created: ${created.join(", ")}`);
+        if (updated.length > 0) parts.push(`Updated: ${updated.join(", ")}`);
+        return {
+          content: [{ type: "text", text: parts.join("\n") }]
+        };
+      }
+    ),
+    // --- Local → Jira tools ---
+    tool19(
+      "push_artifact_to_jira",
+      "Create a Jira issue from any Marvin artifact (D/A/Q/F/E) and create a tracking JI-xxx document",
+      {
+        artifactId: external_exports.string().describe("Marvin artifact ID (e.g. 'D-001', 'F-003', 'E-002')"),
+        projectKey: external_exports.string().describe("Jira project key (e.g. 'PROJ')"),
+        issueType: external_exports.enum(["Story", "Task", "Bug", "Epic"]).optional().describe("Jira issue type (default: 'Task')")
+      },
+      async (args) => {
+        const client = createJiraClient();
+        if (!client) return jiraNotConfiguredError();
+        const artifact = store.get(args.artifactId);
+        if (!artifact) {
+          return {
+            content: [
+              { type: "text", text: `Artifact ${args.artifactId} not found` }
+            ],
+            isError: true
+          };
+        }
+        const description = [
+          artifact.content,
+          "",
+          `---`,
+          `Marvin artifact: ${artifact.frontmatter.id} (${artifact.frontmatter.type})`,
+          `Status: ${artifact.frontmatter.status}`
+        ].join("\n");
+        const jiraResult = await client.createIssue({
+          project: { key: args.projectKey },
+          summary: artifact.frontmatter.title,
+          description,
+          issuetype: { name: args.issueType ?? "Task" }
+        });
+        const host = process.env.JIRA_HOST;
+        const jiDoc = store.create(
+          JIRA_TYPE,
+          {
+            title: artifact.frontmatter.title,
+            status: "open",
+            jiraKey: jiraResult.key,
+            jiraUrl: `https://${host}/browse/${jiraResult.key}`,
+            issueType: args.issueType ?? "Task",
+            priority: "Medium",
+            assignee: "",
+            labels: [],
+            linkedArtifacts: [args.artifactId],
+            tags: [`jira:${jiraResult.key}`],
+            lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          ""
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Created Jira ${jiraResult.key} from ${args.artifactId}. Tracking locally as ${jiDoc.frontmatter.id}.`
+            }
+          ]
+        };
+      }
+    ),
+    // --- Bidirectional sync ---
+    tool19(
+      "sync_jira_issue",
+      "Bidirectional sync: push local title/description to Jira, pull latest status/assignee/labels back",
+      {
+        id: external_exports.string().describe("Local JI-xxx ID")
+      },
+      async (args) => {
+        const client = createJiraClient();
+        if (!client) return jiraNotConfiguredError();
+        const doc = store.get(args.id);
+        if (!doc || doc.frontmatter.type !== JIRA_TYPE) {
+          return {
+            content: [
+              { type: "text", text: `Jira issue ${args.id} not found locally` }
+            ],
+            isError: true
+          };
+        }
+        const jiraKey = doc.frontmatter.jiraKey;
+        await client.updateIssue(jiraKey, {
+          summary: doc.frontmatter.title,
+          description: doc.content || void 0
+        });
+        const issue2 = await client.getIssue(jiraKey);
+        const host = process.env.JIRA_HOST;
+        const fm = jiraIssueToFrontmatter(
+          issue2,
+          host,
+          doc.frontmatter.linkedArtifacts
+        );
+        store.update(args.id, fm, issue2.fields.description ?? "");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Synced ${args.id} \u2194 ${jiraKey}. Status: ${fm.status}, Assignee: ${fm.assignee || "unassigned"}`
+            }
+          ]
+        };
+      }
+    ),
+    // --- Local link tool ---
+    tool19(
+      "link_artifact_to_jira",
+      "Add a Marvin artifact ID to a JI-xxx document's linkedArtifacts field",
+      {
+        jiraIssueId: external_exports.string().describe("Local JI-xxx ID"),
+        artifactId: external_exports.string().describe("Marvin artifact ID to link (e.g. 'D-001', 'F-003')")
+      },
+      async (args) => {
+        const doc = store.get(args.jiraIssueId);
+        if (!doc || doc.frontmatter.type !== JIRA_TYPE) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Jira issue ${args.jiraIssueId} not found locally`
+              }
+            ],
+            isError: true
+          };
+        }
+        const artifact = store.get(args.artifactId);
+        if (!artifact) {
+          return {
+            content: [
+              { type: "text", text: `Artifact ${args.artifactId} not found` }
+            ],
+            isError: true
+          };
+        }
+        const linked = doc.frontmatter.linkedArtifacts ?? [];
+        if (linked.includes(args.artifactId)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${args.artifactId} is already linked to ${args.jiraIssueId}`
+              }
+            ]
+          };
+        }
+        store.update(args.jiraIssueId, {
+          linkedArtifacts: [...linked, args.artifactId]
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Linked ${args.artifactId} to ${args.jiraIssueId}`
+            }
+          ]
+        };
+      }
+    )
+  ];
+}
+
+// src/skills/builtin/jira/index.ts
+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) => createJiraTools(store),
+  promptFragments: {
+    "product-owner": `You have the **Jira Integration** skill. You can pull issues from Jira and push Marvin artifacts to Jira.
+
+**Available tools:**
+- \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues
+- \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
+- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, feature, etc.)
+- \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
+- \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
+
+**As Product Owner, use Jira integration to:**
+- 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.
+
+**Available tools:**
+- \`list_jira_issues\` / \`get_jira_issue\` \u2014 browse locally synced Jira issues
+- \`pull_jira_issue\` / \`pull_jira_issues_jql\` \u2014 import issues from Jira by key or JQL query
+- \`push_artifact_to_jira\` \u2014 create a Jira issue from a Marvin artifact (decision, action, epic, etc.)
+- \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
+- \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
+
+**As Tech Lead, use Jira integration to:**
+- Pull technical issues and bugs for sprint planning and estimation
+- Push epics and technical decisions to Jira for cross-team visibility
+- 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.
+
+**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.)
+- \`sync_jira_issue\` \u2014 bidirectional sync of a local JI-xxx with Jira
+- \`link_artifact_to_jira\` \u2014 link a Marvin artifact to an existing JI-xxx
+
+**As Delivery Manager, use Jira integration to:**
+- Pull sprint issues for tracking progress and blockers
+- Push actions and decisions to Jira for stakeholder visibility
+- Use JQL queries for reporting (e.g. \`sprint in openSprints() AND assignee = currentUser()\`)
+- Sync status between Marvin governance items and Jira issues`
+  }
+};
+
 // src/skills/registry.ts
 var BUILTIN_SKILLS = {
-  "governance-review": governanceReviewSkill
+  "governance-review": governanceReviewSkill,
+  "jira": jiraSkill
 };
 function getBuiltinSkillsDir() {
   const thisFile = fileURLToPath(import.meta.url);
@@ -17136,7 +17907,7 @@ ${fragment}`);
 }
 
 // src/skills/action-tools.ts
-import { tool as tool18 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool20 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/skills/action-runner.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
@@ -17226,7 +17997,7 @@ function createSkillActionTools(skills, context) {
     if (!skill.actions) continue;
     for (const action of skill.actions) {
       tools.push(
-        tool18(
+        tool20(
           `${skill.id}__${action.id}`,
           action.description,
           {
@@ -17453,10 +18224,10 @@ ${lines.join("\n\n")}`;
 }
 
 // src/mcp/persona-tools.ts
-import { tool as tool19 } from "@anthropic-ai/claude-agent-sdk";
+import { tool as tool21 } from "@anthropic-ai/claude-agent-sdk";
 function createPersonaTools(ctx, marvinDir) {
   return [
-    tool19(
+    tool21(
       "set_persona",
       "Set the active persona for this session. Returns full guidance for the selected persona including behavioral rules, allowed document types, and scope. Call this before working to ensure persona-appropriate behavior.",
       {
@@ -17486,7 +18257,7 @@ ${summaries}`
         };
       }
     ),
-    tool19(
+    tool21(
       "get_persona_guidance",
       "Get guidance for a persona without changing the active persona. If no persona is specified, lists all available personas with summaries.",
       {