infernoflow 0.17.0 → 0.19.0

package/dist/lib/commands/dashboard.mjs

@@ -80,6 +80,92 @@ function runCheck(infernoDir) {
   }
 }
 
+// ── Analytics data loaders ────────────────────────────────────────────────────
+
+function loadAudit(infernoDir) {
+  const p = path.join(infernoDir, "audit.json");
+  if (!fs.existsSync(p)) return null;
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return null; }
+}
+
+function loadLinks(infernoDir) {
+  const p = path.join(infernoDir, "links.json");
+  if (!fs.existsSync(p)) return [];
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return []; }
+}
+
+/**
+ * Parse git log for inferno/ directory to build analytics:
+ *   - capability velocity (caps added/removed per week)
+ *   - contributor activity (commits per author)
+ *   - health score trend (from check logs or heuristic via commit frequency)
+ */
+function loadGitAnalytics(cwd, infernoDir) {
+  try {
+    // Commits touching inferno/ in past 90 days (iso date, author email, subject)
+    const raw = execSync(
+      `git log --since="90 days ago" --format="%aI|%ae|%s" -- inferno/`,
+      { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 8000 }
+    ).trim();
+
+    if (!raw) return { velocity: [], contributors: [], healthTrend: [] };
+
+    const commits = raw.split("\n").filter(Boolean).map(line => {
+      const [date, email, ...subjectParts] = line.split("|");
+      return { date: new Date(date), email: email || "unknown", subject: subjectParts.join("|") };
+    });
+
+    // Bucket by ISO week (YYYY-Www)
+    function isoWeek(d) {
+      const dt  = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+      const day = dt.getUTCDay() || 7;
+      dt.setUTCDate(dt.getUTCDate() + 4 - day);
+      const yearStart = new Date(Date.UTC(dt.getUTCFullYear(), 0, 1));
+      const week = Math.ceil((((dt - yearStart) / 86400000) + 1) / 7);
+      return `${dt.getUTCFullYear()}-W${String(week).padStart(2, "0")}`;
+    }
+
+    // Velocity: commits per week
+    const weekMap = new Map();
+    for (const c of commits) {
+      const w = isoWeek(c.date);
+      weekMap.set(w, (weekMap.get(w) || 0) + 1);
+    }
+    // Fill in the last 13 weeks
+    const velocity = [];
+    const now = new Date();
+    for (let i = 12; i >= 0; i--) {
+      const d = new Date(now);
+      d.setDate(d.getDate() - i * 7);
+      const w = isoWeek(d);
+      velocity.push({ week: w, commits: weekMap.get(w) || 0 });
+    }
+
+    // Contributors: unique authors, sorted by commit count
+    const authorMap = new Map();
+    for (const c of commits) {
+      const name = c.email.split("@")[0];
+      authorMap.set(name, (authorMap.get(name) || 0) + 1);
+    }
+    const contributors = [...authorMap.entries()]
+      .map(([name, count]) => ({ name, count }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 8);
+
+    // Health trend: simple heuristic from commit density per week
+    // More commits → more drift activity. We mark weeks with >3 commits as "busy" (amber), 0 = stale, else ok
+    const healthTrend = velocity.map(v => ({
+      week:  v.week,
+      score: v.commits === 0 ? 40 : v.commits <= 2 ? 75 : v.commits <= 5 ? 90 : 85,
+      label: v.commits === 0 ? "stale" : v.commits <= 2 ? "ok" : v.commits <= 5 ? "healthy" : "busy",
+    }));
+
+    return { velocity, contributors, healthTrend };
+  } catch {
+    return { velocity: [], contributors: [], healthTrend: [] };
+  }
+}
+
 function gatherData(infernoDir) {
   const caps     = loadCapabilities(infernoDir);
   const contract = loadContract(infernoDir);
@@ -87,19 +173,74 @@ function gatherData(infernoDir) {
   const agents   = loadAgents(infernoDir);
   const hookLog  = loadHookLog(infernoDir);
   const check    = runCheck(infernoDir);
+  const audit    = loadAudit(infernoDir);
+  const links    = loadLinks(infernoDir);
   const sessions = profile?.recentSessions?.slice(-10) || [];
   const candidates = [
     ...(profile?.agentCandidates || []),
     ...(profile?.skillCandidates || []),
   ];
+  const cwd       = path.dirname(infernoDir);
+  const analytics = loadGitAnalytics(cwd, infernoDir);
+
+  return { caps, contract, agents, hookLog, check, sessions, candidates, audit, links, analytics, infernoDir };
+}
+
+// ── HTML builder ──────────────────────────────────────────────────────────────
+
+// ── SVG chart builders ────────────────────────────────────────────────────────
+
+function barChart(values, labels, color = "#f97316", height = 80) {
+  const W = 600, H = height;
+  const n = values.length;
+  if (!n) return `<svg width="${W}" height="${H}"></svg>`;
+  const max   = Math.max(...values, 1);
+  const bw    = Math.floor(W / n) - 4;
+  const bars  = values.map((v, i) => {
+    const bh = Math.max(2, Math.round((v / max) * (H - 20)));
+    const x  = i * (W / n) + 2;
+    const y  = H - bh - 10;
+    return `<rect x="${x}" y="${y}" width="${bw}" height="${bh}" fill="${color}" rx="2" opacity="0.85"/>
+            <title>${labels[i]}: ${v}</title>`;
+  }).join("\n");
+  return `<svg viewBox="0 0 ${W} ${H}" width="100%" height="${H}" xmlns="http://www.w3.org/2000/svg">${bars}</svg>`;
+}
 
-  return { caps, contract, agents, hookLog, check, sessions, candidates, infernoDir };
+function lineChart(values, color = "#3b82f6", height = 80) {
+  const W = 600, H = height;
+  const n = values.length;
+  if (n < 2) return `<svg width="${W}" height="${H}"></svg>`;
+  const max  = Math.max(...values, 1);
+  const min  = Math.min(...values, 0);
+  const range = max - min || 1;
+  const pts  = values.map((v, i) => {
+    const x = Math.round((i / (n - 1)) * (W - 20)) + 10;
+    const y = Math.round(H - 10 - ((v - min) / range) * (H - 20));
+    return `${x},${y}`;
+  }).join(" ");
+  return `<svg viewBox="0 0 ${W} ${H}" width="100%" height="${H}" xmlns="http://www.w3.org/2000/svg">
+    <polyline points="${pts}" fill="none" stroke="${color}" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
+    ${values.map((v, i) => {
+      const [px, py] = pts.split(" ")[i].split(",");
+      return `<circle cx="${px}" cy="${py}" r="4" fill="${color}"><title>${v}</title></circle>`;
+    }).join("")}
+  </svg>`;
+}
+
+function heatRow(name, count, maxCount) {
+  const pct  = maxCount > 0 ? Math.round((count / maxCount) * 100) : 0;
+  const fill = pct > 70 ? "#f97316" : pct > 40 ? "#f59e0b" : pct > 10 ? "#3b82f6" : "#2d3148";
+  return `<div class="heat-row">
+    <span class="heat-name">${esc(name)}</span>
+    <div class="heat-bar-wrap"><div class="heat-bar" style="width:${pct}%;background:${fill}"></div></div>
+    <span class="heat-count">${count}</span>
+  </div>`;
 }
 
 // ── HTML builder ──────────────────────────────────────────────────────────────
 
 function buildHtml(data, projectName) {
-  const { caps, agents, check, sessions, candidates } = data;
+  const { caps, agents, check, sessions, candidates, audit, links, analytics } = data;
 
   const statusColor = check?.status === "ok"      ? "#22c55e"
                     : check?.status === "warning"  ? "#f59e0b"
@@ -153,6 +294,29 @@ function buildHtml(data, projectName) {
     `<li class="candidate">${esc(c.name || c.id || "unnamed")}: ${esc(c.description || "")}</li>`
   ).join("\n");
 
+  // ── Analytics ─────────────────────────────────────────────────────────────
+  const vel    = analytics?.velocity    || [];
+  const contribs = analytics?.contributors || [];
+  const trend  = analytics?.healthTrend || [];
+
+  const velValues  = vel.map(v => v.commits);
+  const velLabels  = vel.map(v => v.week);
+  const velChart   = barChart(velValues, velLabels, "#f97316", 90);
+
+  const trendValues = trend.map(t => t.score);
+  const trendChart  = lineChart(trendValues, "#3b82f6", 80);
+
+  const maxContrib = contribs.length ? Math.max(...contribs.map(c => c.count)) : 1;
+  const heatRows   = contribs.length
+    ? contribs.map(c => heatRow(c.name, c.count, maxContrib)).join("\n")
+    : `<div class="empty">No git history in inferno/ yet</div>`;
+
+  // Audit summary card
+  const auditStats   = audit?.stats || null;
+  const auditHigh    = auditStats?.high ?? "—";
+  const auditMedium  = auditStats?.medium ?? "—";
+  const linkedCount  = links.length;
+
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -200,6 +364,22 @@ function buildHtml(data, projectName) {
   .session-item:last-child { border-bottom: none; }
   .session-date { font-size: 11px; color: var(--muted); white-space: nowrap; min-width: 140px; }
   .session-cmds { font-size: 12px; color: var(--text); }
+  /* Analytics */
+  .chart-wrap { padding: 16px 18px; }
+  .chart-label { font-size: 11px; color: var(--muted); margin-top: 6px; text-align: center; }
+  .analytics-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
+  .heat-row { display: flex; align-items: center; gap: 10px; padding: 6px 18px; border-bottom: 1px solid var(--border); }
+  .heat-row:last-child { border-bottom: none; }
+  .heat-name  { min-width: 110px; font-size: 12px; color: var(--text); font-family: monospace; }
+  .heat-bar-wrap { flex: 1; height: 10px; background: var(--border); border-radius: 5px; overflow: hidden; }
+  .heat-bar   { height: 100%; border-radius: 5px; transition: width 0.3s; }
+  .heat-count { font-size: 12px; color: var(--muted); min-width: 30px; text-align: right; }
+  .audit-tags { display: flex; gap: 8px; padding: 14px 18px; flex-wrap: wrap; }
+  .tag { font-size: 12px; padding: 4px 10px; border-radius: 9px; font-weight: 600; }
+  .tag-high   { background: rgba(239,68,68,0.15);  color: #ef4444; }
+  .tag-medium { background: rgba(245,158,11,0.15); color: #f59e0b; }
+  .tag-low    { background: rgba(34,197,94,0.15);  color: #22c55e; }
+  .tag-link   { background: rgba(59,130,246,0.15); color: #3b82f6; }
   footer { text-align: center; color: var(--muted); font-size: 11px; padding: 24px; }
 </style>
 </head>
@@ -236,6 +416,17 @@ function buildHtml(data, projectName) {
       <div class="value">${sessions.length}</div>
       <div class="sub">recent sessions logged</div>
     </div>
+    ${auditStats ? `
+    <div class="card">
+      <div class="label">Security surface</div>
+      <div class="value" style="color:${auditHigh > 0 ? "var(--red)" : "var(--green)"}">${auditHigh}</div>
+      <div class="sub">${auditHigh} high · ${auditMedium} medium risk caps</div>
+    </div>` : ""}
+    <div class="card">
+      <div class="label">Linked tickets</div>
+      <div class="value" style="color:var(--blue)">${linkedCount}</div>
+      <div class="sub">caps linked to Jira/Linear/GitHub</div>
+    </div>
   </div>
 
   ${issueCount > 0 ? `
@@ -279,6 +470,61 @@ function buildHtml(data, projectName) {
       : `<div class="empty">No session data yet — sessions are logged automatically as you use infernoflow</div>`}
   </section>
 
+  <!-- Analytics: velocity + health trend -->
+  ${vel.length > 0 ? `
+  <div class="analytics-grid">
+    <section>
+      <h2>📈 Capability Velocity (13 weeks)</h2>
+      <div class="chart-wrap">
+        ${velChart}
+        <div class="chart-label">Commits touching inferno/ per week</div>
+      </div>
+    </section>
+    <section>
+      <h2>💚 Health Score Trend</h2>
+      <div class="chart-wrap">
+        ${trendChart}
+        <div class="chart-label">Heuristic health score over last 13 weeks</div>
+      </div>
+    </section>
+  </div>` : ""}
+
+  <!-- Contributor heatmap -->
+  ${contribs.length > 0 ? `
+  <section>
+    <h2>👥 Contributor Heatmap (90 days)</h2>
+    ${heatRows}
+  </section>` : ""}
+
+  <!-- Audit surface map (if audit.json exists) -->
+  ${auditStats ? `
+  <section>
+    <h2>🔐 Security Surface (last audit)</h2>
+    <div class="audit-tags">
+      <span class="tag tag-high">🔴 ${auditStats.high} HIGH</span>
+      <span class="tag tag-medium">🟡 ${auditStats.medium} MEDIUM</span>
+      <span class="tag tag-low">🟢 ${auditStats.low} LOW</span>
+      ${linkedCount > 0 ? `<span class="tag tag-link">🔗 ${linkedCount} linked to tickets</span>` : ""}
+    </div>
+    ${audit.capabilities ? `
+    <table>
+      <thead><tr><th>Severity</th><th>Capability</th><th>Tags</th></tr></thead>
+      <tbody>
+        ${audit.capabilities.filter(c => c.severity === "high" || c.severity === "medium").slice(0, 10).map(c => `
+        <tr>
+          <td style="color:${c.severity === "high" ? "var(--red)" : "var(--yellow)"}">${c.severity}</td>
+          <td><code>${esc(c.id)}</code></td>
+          <td>${esc((c.tags || []).join(", "))}</td>
+        </tr>`).join("")}
+      </tbody>
+    </table>` : ""}
+    <div style="padding:8px 18px;font-size:11px;color:var(--muted)">Run <code>infernoflow audit</code> to refresh · Last run: ${esc(audit.runAt ? new Date(audit.runAt).toLocaleString() : "unknown")}</div>
+  </section>` : `
+  <section>
+    <h2>🔐 Security Surface</h2>
+    <div class="empty">No audit data yet — run <code>infernoflow audit</code> to classify capabilities by security sensitivity</div>
+  </section>`}
+
 </main>
 <footer>infernoflow dashboard · auto-refreshes every 10s · <a href="/" style="color:var(--muted)">refresh now</a></footer>
 <script>

package/dist/lib/commands/link.mjs

@@ -0,0 +1,342 @@
+/**
+ * infernoflow link
+ *
+ * Link capabilities to tickets in Jira, Linear, or GitHub Issues.
+ * Stored in inferno/links.json — travels with the repo.
+ *
+ * Usage:
+ *   infernoflow link --jira PROJ-123 --capability CreateTask
+ *   infernoflow link --linear LIN-456 --capability FilterByTag
+ *   infernoflow link --github 78 --capability ExportToCsv
+ *   infernoflow link list                    Show all links
+ *   infernoflow link status                  Show which caps have open tickets
+ *   infernoflow link remove --capability CreateTask
+ *   infernoflow link --json                  Machine-readable
+ *
+ * Config (inferno/integrations.json):
+ *   {
+ *     "jira":   { "baseUrl": "https://myorg.atlassian.net", "token": "...", "email": "..." },
+ *     "linear": { "apiKey": "lin_api_..." },
+ *     "github": { "repo": "owner/repo", "token": "ghp_..." }
+ *   }
+ *
+ * Env vars (override config):
+ *   JIRA_BASE_URL, JIRA_TOKEN, JIRA_EMAIL
+ *   LINEAR_API_KEY
+ *   GITHUB_TOKEN, GITHUB_REPOSITORY
+ */
+
+import * as fs    from "node:fs";
+import * as path  from "node:path";
+import * as https from "node:https";
+import { done, warn, info, bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
+
+const LINKS_FILE = "links.json";
+const CONFIG_FILE = "integrations.json";
+
+// ── Storage ───────────────────────────────────────────────────────────────────
+
+function readLinks(infernoDir) {
+  const p = path.join(infernoDir, LINKS_FILE);
+  if (!fs.existsSync(p)) return [];
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return []; }
+}
+
+function writeLinks(infernoDir, links) {
+  fs.writeFileSync(path.join(infernoDir, LINKS_FILE), JSON.stringify(links, null, 2) + "\n");
+}
+
+function readIntegrationConfig(infernoDir) {
+  const p = path.join(infernoDir, CONFIG_FILE);
+  if (!fs.existsSync(p)) return {};
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch { return {}; }
+}
+
+// ── HTTP helper ───────────────────────────────────────────────────────────────
+
+function httpsGet(url, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    https.get({
+      hostname: parsed.hostname,
+      path:     parsed.pathname + (parsed.search || ""),
+      headers:  { "User-Agent": "infernoflow-cli", "Accept": "application/json", ...headers },
+    }, (res) => {
+      let data = "";
+      res.on("data", d => (data += d));
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(data) }); }
+        catch { resolve({ status: res.statusCode, body: data }); }
+      });
+    }).on("error", reject);
+  });
+}
+
+// ── Ticket fetchers ───────────────────────────────────────────────────────────
+
+async function fetchJiraTicket(ticketId, config) {
+  const base  = process.env.JIRA_BASE_URL || config.jira?.baseUrl;
+  const token = process.env.JIRA_TOKEN    || config.jira?.token;
+  const email = process.env.JIRA_EMAIL    || config.jira?.email;
+  if (!base || !token) return null;
+
+  try {
+    const creds = Buffer.from(`${email}:${token}`).toString("base64");
+    const resp  = await httpsGet(`${base}/rest/api/3/issue/${ticketId}`, {
+      "Authorization": `Basic ${creds}`,
+    });
+    if (resp.status === 200) {
+      return {
+        id:     ticketId,
+        title:  resp.body.fields?.summary || ticketId,
+        status: resp.body.fields?.status?.name || "unknown",
+        url:    `${base}/browse/${ticketId}`,
+      };
+    }
+  } catch {}
+  return { id: ticketId, title: ticketId, status: "unknown", url: null };
+}
+
+async function fetchLinearTicket(ticketId, config) {
+  const apiKey = process.env.LINEAR_API_KEY || config.linear?.apiKey;
+  if (!apiKey) return null;
+
+  try {
+    const query = JSON.stringify({
+      query: `{ issue(id: "${ticketId}") { title state { name } url } }`
+    });
+    const resp = await new Promise((resolve, reject) => {
+      const body = query;
+      const req  = https.request({
+        hostname: "api.linear.app",
+        path:     "/graphql",
+        method:   "POST",
+        headers:  { "Content-Type": "application/json", "Authorization": apiKey, "Content-Length": Buffer.byteLength(body) },
+      }, (res) => {
+        let data = "";
+        res.on("data", d => (data += d));
+        res.on("end", () => resolve(JSON.parse(data)));
+      });
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+    const issue = resp.data?.issue;
+    if (issue) return { id: ticketId, title: issue.title, status: issue.state?.name || "unknown", url: issue.url };
+  } catch {}
+  return { id: ticketId, title: ticketId, status: "unknown", url: null };
+}
+
+async function fetchGithubIssue(issueNum, config) {
+  const token = process.env.GITHUB_TOKEN     || config.github?.token;
+  const repo  = process.env.GITHUB_REPOSITORY || config.github?.repo;
+  if (!repo) return null;
+
+  try {
+    const headers = { "Authorization": token ? `Bearer ${token}` : undefined };
+    const resp    = await httpsGet(`https://api.github.com/repos/${repo}/issues/${issueNum}`, headers);
+    if (resp.status === 200) {
+      return {
+        id:     `#${issueNum}`,
+        title:  resp.body.title || `Issue #${issueNum}`,
+        status: resp.body.state || "unknown",
+        url:    resp.body.html_url,
+      };
+    }
+  } catch {}
+  return { id: `#${issueNum}`, title: `Issue #${issueNum}`, status: "unknown", url: null };
+}
+
+// ── Sub-commands ──────────────────────────────────────────────────────────────
+
+async function subcmdAdd(args, infernoDir, config) {
+  const jsonMode    = args.includes("--json");
+  const capIdx      = args.indexOf("--capability");
+  const jiraIdx     = args.indexOf("--jira");
+  const linearIdx   = args.indexOf("--linear");
+  const githubIdx   = args.indexOf("--github");
+
+  const capability  = capIdx !== -1  ? args[capIdx + 1]   : null;
+  const jiraId      = jiraIdx !== -1  ? args[jiraIdx + 1]  : null;
+  const linearId    = linearIdx !== -1 ? args[linearIdx + 1] : null;
+  const githubNum   = githubIdx !== -1 ? args[githubIdx + 1] : null;
+
+  if (!capability) {
+    const msg = "Usage: infernoflow link --capability <id> --jira <TICKET> | --linear <ID> | --github <NUM>";
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); } else { warn(msg); }
+    return;
+  }
+
+  let ticket = null;
+  let platform = null;
+
+  if (jiraId) {
+    if (!jsonMode) process.stdout.write(`  Fetching Jira ${jiraId}… `);
+    ticket   = await fetchJiraTicket(jiraId, config);
+    platform = "jira";
+  } else if (linearId) {
+    if (!jsonMode) process.stdout.write(`  Fetching Linear ${linearId}… `);
+    ticket   = await fetchLinearTicket(linearId, config);
+    platform = "linear";
+  } else if (githubNum) {
+    if (!jsonMode) process.stdout.write(`  Fetching GitHub #${githubNum}… `);
+    ticket   = await fetchGithubIssue(githubNum, config);
+    platform = "github";
+  } else {
+    const msg = "Specify --jira, --linear, or --github";
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: msg })); } else { warn(msg); }
+    return;
+  }
+
+  const links = readLinks(infernoDir);
+  const existing = links.findIndex(l => l.capability === capability);
+
+  const link = {
+    capability,
+    platform,
+    ticketId:   ticket?.id   || jiraId || linearId || `#${githubNum}`,
+    title:      ticket?.title || "",
+    status:     ticket?.status || "unknown",
+    url:        ticket?.url   || null,
+    linkedAt:   new Date().toISOString(),
+  };
+
+  if (existing !== -1) {
+    links[existing] = link;
+  } else {
+    links.push(link);
+  }
+
+  writeLinks(infernoDir, links);
+
+  if (!jsonMode) console.log(green("done"));
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, link }));
+  } else {
+    done(`Linked: ${bold(capability)} → ${cyan(link.ticketId)} (${link.status})`);
+    if (link.url) console.log(`  ${gray(link.url)}`);
+    console.log();
+  }
+}
+
+async function subcmdList(args, infernoDir) {
+  const jsonMode = args.includes("--json");
+  const links    = readLinks(infernoDir);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, links }));
+    return;
+  }
+
+  if (!links.length) {
+    info("No links yet. Use: infernoflow link --capability <id> --jira <TICKET>");
+    return;
+  }
+
+  console.log();
+  console.log(`  ${bold(`${links.length} capability link${links.length !== 1 ? "s" : ""}`)}`);
+  console.log();
+
+  const w = Math.max(...links.map(l => l.capability.length), 10) + 2;
+  for (const l of links) {
+    const statusColor = l.status?.toLowerCase() === "done" || l.status?.toLowerCase() === "closed"
+      ? green : l.status?.toLowerCase() === "in progress" ? yellow : gray;
+    console.log(`  ${bold(l.capability.padEnd(w))} ${cyan(l.ticketId.padEnd(14))} ${statusColor(l.status || "unknown")}`);
+    if (l.title && l.title !== l.ticketId) console.log(`  ${" ".repeat(w + 2)}${gray(l.title)}`);
+  }
+  console.log();
+}
+
+async function subcmdStatus(args, infernoDir) {
+  const jsonMode = args.includes("--json");
+  const links    = readLinks(infernoDir);
+
+  // Load contract to find unlinked capabilities
+  let contract = null;
+  for (const f of ["contract.json", "capabilities.json"]) {
+    const p = path.join(infernoDir, f);
+    if (fs.existsSync(p)) { try { contract = JSON.parse(fs.readFileSync(p, "utf8")); break; } catch {} }
+  }
+  const allCaps   = (contract?.capabilities || []).map(c => typeof c === "string" ? c : c.id);
+  const linkedIds = new Set(links.map(l => l.capability));
+  const unlinked  = allCaps.filter(id => !linkedIds.has(id));
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: true, linked: links.length, unlinked: unlinked.length, links, unlinkedCapabilities: unlinked }));
+    return;
+  }
+
+  console.log();
+  console.log(`  ${bold("Capability link status")}`);
+  console.log();
+
+  if (links.length) {
+    console.log(`  ${gray("Linked:")}`);
+    for (const l of links) {
+      const icon = l.status?.toLowerCase() === "done" ? green("✔") : l.status?.toLowerCase() === "in progress" ? yellow("⟳") : gray("○");
+      console.log(`  ${icon}  ${bold(l.capability)}  ${cyan(l.ticketId)}  ${gray(l.status || "")}`);
+    }
+    console.log();
+  }
+
+  if (unlinked.length) {
+    console.log(`  ${gray("Unlinked capabilities:")}`);
+    unlinked.forEach(id => console.log(`  ${gray("·")}  ${id}`));
+    console.log();
+  }
+
+  console.log(`  ${green(String(links.length))} linked · ${gray(String(unlinked.length))} unlinked`);
+  console.log();
+}
+
+async function subcmdRemove(args, infernoDir) {
+  const jsonMode = args.includes("--json");
+  const capIdx   = args.indexOf("--capability");
+  const capId    = capIdx !== -1 ? args[capIdx + 1] : null;
+
+  if (!capId) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: "Usage: infernoflow link remove --capability <id>" })); }
+    else { warn("Usage: infernoflow link remove --capability <id>"); }
+    return;
+  }
+
+  const links   = readLinks(infernoDir);
+  const before  = links.length;
+  const updated = links.filter(l => l.capability !== capId);
+
+  if (updated.length === before) {
+    if (jsonMode) { console.log(JSON.stringify({ ok: false, error: `No link found for: ${capId}` })); }
+    else { warn(`No link found for: ${capId}`); }
+    return;
+  }
+
+  writeLinks(infernoDir, updated);
+  if (jsonMode) { console.log(JSON.stringify({ ok: true, removed: capId })); }
+  else { done(`Removed link for ${bold(capId)}`); console.log(); }
+}
+
+// ── Entry ─────────────────────────────────────────────────────────────────────
+
+export async function linkCommand(rawArgs) {
+  const args       = rawArgs.slice(1);
+  const cwd        = process.cwd();
+  const infernoDir = path.join(cwd, "inferno");
+
+  if (!fs.existsSync(infernoDir)) {
+    const msg = "inferno/ not found. Run: infernoflow init";
+    if (args.includes("--json")) { console.log(JSON.stringify({ ok: false, error: msg })); }
+    else { warn(msg); }
+    process.exit(1);
+  }
+
+  const config = readIntegrationConfig(infernoDir);
+  const subcmd = args[0];
+
+  if (subcmd === "list")   return subcmdList(args.slice(1), infernoDir);
+  if (subcmd === "status") return subcmdStatus(args.slice(1), infernoDir);
+  if (subcmd === "remove") return subcmdRemove(args.slice(1), infernoDir);
+
+  // Default: add a link
+  return subcmdAdd(args, infernoDir, config);
+}