@mmerterden/multi-agent-pipeline 20.11.1 → 20.13.0

package/pipeline/scripts/doctor.mjs

@@ -99,6 +99,7 @@ const CHECK_IDS = [
   "mcp-surface",
   "disk-space",
   "worktree-residue",
+  "usage-report",
 ];
 
 // Only under `--profile server`. Kept in their own list so `--list-checks`
@@ -883,6 +884,52 @@ function checkMcpSurface() {
   );
 }
 
+// usage-report.mjs runs detached with its output discarded, so the record it
+// writes after every send attempt is the one place a broken reporting path
+// becomes visible.
+const USAGE_STEPS = {
+  "no-login": () => `run node ${join(HERE, "usage-identity.mjs")} --refresh`,
+  "no-token": () => `run node ${join(HERE, "usage-register.mjs")}`,
+  "endpoint-not-allowed": () => "set usageLog.endpoint to an https address",
+  rejected: () => `run node ${join(HERE, "usage-register.mjs")}`,
+  "not-accepted": () => `run node ${join(HERE, "usage-identity.mjs")} --refresh`,
+  redirected: (r) =>
+    r.location
+      ? `set usageLog.endpoint to the address on ${r.location} it redirects to`
+      : `run node ${join(HERE, "migrate-prefs.mjs")}`,
+  failed: () => "re-run a phase once the reporting endpoint is reachable",
+};
+
+function checkUsageReport() {
+  const prefs = readJson(join(CLAUDE, "multi-agent-preferences.json"));
+  const usage = prefs?.global?.usageLog;
+  if (usage?.enabled !== true || usage?.optOut === true) {
+    skip("usage-report", "usage reporting is off");
+    return;
+  }
+  const last = readJson(join(CLAUDE, "logs", "multi-agent", "usage-last-send.json"));
+  if (!last || typeof last.outcome !== "string") {
+    skip("usage-report", "no report has been sent from this machine yet");
+    return;
+  }
+  if (last.outcome === "accepted") {
+    ok("usage-report");
+    return;
+  }
+  const key = last.outcome === "skipped" ? last.reason : last.outcome;
+  const stepFor = USAGE_STEPS[key] ?? USAGE_STEPS.failed;
+  const detail = [last.status, last.reason, last.location && `to ${last.location}`]
+    .filter(Boolean)
+    .join(", ");
+  const when = last.t ? ` at ${last.t}` : "";
+  report(
+    "usage-report",
+    "WARN",
+    `the last usage report${last.id ? ` for ${last.id}` : ""} was ${last.outcome}${detail ? ` (${detail})` : ""}${when}, so runs are missing from the usage panel`,
+    stepFor(last),
+  );
+}
+
 function checkDiskSpace() {
   let freeGb = null;
   try {
@@ -1175,6 +1222,7 @@ function main() {
   checkMcpSurface();
   checkDiskSpace();
   checkWorktreeResidue();
+  checkUsageReport();
   if (PROFILE === "server") checkServerProfile(resolved);
 
   const blocked = results.filter((r) => r.severity === "BLOCK");

package/pipeline/scripts/jira-wiki-escape.mjs

@@ -72,6 +72,46 @@ export function findUnescaped(text) {
   return hits;
 }
 
+// Every character that opens wiki markup: macros {..}, links and mentions [..],
+// table cells |, images !..!, and inline formatting * _ ^ ~ + - #.
+const MARKUP = /[\\{}[\]|!*_^~+\-#]/g;
+
+/**
+ * Escape plain text taken from a document so Jira renders it literally. The
+ * generator writes its own markup around the result; nothing inside the result
+ * can open a macro, a mention, an image, a link or formatting.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function escapeJiraWiki(text) {
+  const escaped = String(text ?? "")
+    .replace(MARKUP, (c) => `\\${c}`)
+    .replace(/^(h[1-6]|bq)\./gm, "$1\\.");
+  return escapeJiraEmoticons(escaped);
+}
+
+/**
+ * A wiki link to an http(s) URL, or the escaped label alone for any other
+ * scheme. The URL is percent-encoded where a character would end the link.
+ *
+ * @param {string} label
+ * @param {string} url
+ * @returns {string}
+ */
+export function wikiLink(label, url) {
+  const text = escapeJiraWiki(label);
+  let u;
+  try {
+    u = new URL(url);
+  } catch {
+    return text;
+  }
+  if (u.protocol !== "https:" && u.protocol !== "http:") return text;
+  const safe = u.href.replace(/[|[\]{}!\s]/g, (c) => encodeURIComponent(c));
+  return `[${text}|${safe}]`;
+}
+
 async function readStdin() {
   const chunks = [];
   for await (const chunk of process.stdin) chunks.push(chunk);

package/pipeline/scripts/migrate-prefs.mjs

@@ -15,6 +15,7 @@ import path from "node:path";
 import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { runMain } from "../lib/fatal.mjs";
+import { canonicalEndpoint } from "../lib/usage-endpoint.mjs";
 import { lockTimeoutFrom, withFileLockSync, writeJsonAtomicSync } from "../lib/json-file-lock.mjs";
 
 const DEFAULT_FILE = path.join(os.homedir(), ".claude", "multi-agent-preferences.json");
@@ -445,9 +446,22 @@ function migrate(prefs) {
   // reportContent / wikiScope structure. Idempotent  -  safe to re-run.
   migrateReportChannels(out, changes);
 
+  // 13. usageLog.endpoint on the platform host: it answers every request with a
+  // redirect, and the usage clients never follow one with a credential attached.
+  migrateUsageEndpoint(out, changes);
+
   return { out, changes, alreadyMigrated: changes.length === 0 };
 }
 
+function migrateUsageEndpoint(out, changes) {
+  const usage = out.global.usageLog;
+  if (!usage || typeof usage !== "object" || typeof usage.endpoint !== "string") return;
+  const next = canonicalEndpoint(usage.endpoint);
+  if (next === usage.endpoint) return;
+  changes.push(`usageLog.endpoint: ${usage.endpoint} → ${next}`);
+  usage.endpoint = next;
+}
+
 // v5.7+ sub-migration: legacy jiraCommentDefault / confluenceDefault / wikiDefault booleans
 // → new reportChannels {pr,jira,confluence,wiki} object + wikiScope array. Also initializes
 // reportContent + autopilotReportTimeoutSeconds with schema defaults. Old fields are removed

package/pipeline/scripts/unattended_policy.py

@@ -570,15 +570,22 @@ def _run_base_sha(env=None):
     return sha if re.match(r"^[0-9a-f]{7,40}$", sha) else None
 
 
+_TOP_CACHE = {}
+
+
 def _worktree_top(d):
+    if d in _TOP_CACHE:
+        return _TOP_CACHE[d]
     try:
         import subprocess
 
         r = subprocess.run(["git", "-C", d, "rev-parse", "--show-toplevel"],
                            capture_output=True, text=True, timeout=3)
-        return os.path.realpath(r.stdout.strip()) if r.returncode == 0 and r.stdout.strip() else None
+        top = os.path.realpath(r.stdout.strip()) if r.returncode == 0 and r.stdout.strip() else None
     except Exception:
-        return None
+        top = None
+    _TOP_CACHE[d] = top
+    return top
 
 
 def _tracked_clean(path, env=None, cwd=None):
@@ -609,11 +616,11 @@ def _tracked_clean(path, env=None, cwd=None):
 
             # The file's path relative to the worktree root, so the base lookup
             # names it correctly and a file outside this worktree is rejected.
-            top = g("rev-parse", "--show-toplevel")
+            top = _worktree_top(d)
             ls = g("ls-files", "--error-unmatch", "--", name)
             st = g("status", "--porcelain", "--untracked-files=all", "--", name)
-            in_worktree = top.returncode == 0 and bool(top.stdout.strip())
-            rel = os.path.relpath(p, os.path.realpath(top.stdout.strip())) if in_worktree else None
+            in_worktree = top is not None
+            rel = os.path.relpath(p, top) if in_worktree else None
             at_base = (
                 g("cat-file", "-e", f"{base}:{rel}").returncode == 0
                 and g("diff", "--quiet", base, "--", name).returncode == 0

package/pipeline/scripts/usage-report.mjs

@@ -27,7 +27,15 @@
  * @module pipeline/scripts/usage-report
  */
 
-import { readFileSync, existsSync, readdirSync, appendFileSync } from "fs";
+import {
+  readFileSync,
+  existsSync,
+  readdirSync,
+  appendFileSync,
+  mkdirSync,
+  renameSync,
+  writeFileSync,
+} from "fs";
 import { canonicalEndpoint } from "../lib/usage-endpoint.mjs";
 import { homedir, platform } from "os";
 import { dirname, join } from "path";
@@ -709,27 +717,78 @@ function buildEvent(state, { event = null, login = null } = {}) {
   };
 }
 
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The outcome of one POST. A redirect is never followed, because the ingest
+ * token would ride along to wherever it points; its target host is reported
+ * instead, so a moved endpoint is visible rather than silent.
+ */
 async function post(endpoint, token, event) {
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), TIMEOUT_MS);
   try {
-    await fetch(endpoint, {
+    const res = await fetch(endpoint, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         "X-Usage-Token": token,
       },
       body: JSON.stringify(event),
-      redirect: "error",
+      redirect: "manual",
       signal: ctrl.signal,
     });
-  } catch {
-    /* never break the run on a telemetry failure */
+    if (res.status >= 300 && res.status < 400) {
+      return {
+        outcome: "redirected",
+        status: res.status,
+        location: hostOf(res.headers.get("location") || ""),
+      };
+    }
+    if (!res.ok) return { outcome: "rejected", status: res.status };
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {
+      /* a 2xx without a JSON body is still a delivery */
+    }
+    return { outcome: body?.accepted === false ? "not-accepted" : "accepted", status: res.status };
+  } catch (err) {
+    const reason = ctrl.signal.aborted ? "timeout" : (err?.cause?.code ?? err?.name ?? "error");
+    return { outcome: "failed", reason: codeOf(String(reason), 40) };
   } finally {
     clearTimeout(timer);
   }
 }
 
+export const LAST_SEND_FILE = "usage-last-send.json";
+
+/**
+ * Overwrites the record of the most recent send attempt. The emitter runs
+ * detached with its output discarded, so this file is the only place a broken
+ * reporting path shows up; doctor reads it. It carries no token and no path.
+ */
+function recordSend(entry) {
+  const dir = join(homedir(), ".claude", "logs", "multi-agent");
+  const target = join(dir, LAST_SEND_FILE);
+  const tmp = `${target}.${process.pid}.tmp`;
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(tmp, JSON.stringify({ t: new Date().toISOString(), ...entry }) + "\n", {
+      mode: 0o600,
+    });
+    renameSync(tmp, target);
+  } catch {
+    /* logs dir unwritable - never break the run */
+  }
+}
+
 // The write-only ingest token rides in a header; sending it over http would
 // leak it in cleartext, contradicting the setup contract ("transmitted only
 // over TLS"). Accept https anywhere, and http ONLY for loopback (local dev).
@@ -759,10 +818,16 @@ async function main() {
   if (!args.dryRun) {
     if (prefs.optOut === true) return;
     if (prefs.enabled !== true) return;
-    if (!endpointAllowed(endpoint)) return;
+    if (!endpointAllowed(endpoint)) {
+      recordSend({ id: args.taskId, outcome: "skipped", reason: "endpoint-not-allowed" });
+      return;
+    }
   }
   const token = args.dryRun ? "" : resolveToken();
-  if (!args.dryRun && !token) return;
+  if (!args.dryRun && !token) {
+    recordSend({ id: args.taskId, outcome: "skipped", reason: "no-token" });
+    return;
+  }
 
   const statePath = resolveStatePath(args);
   let state = statePath ? readJson(statePath) : null;
@@ -782,7 +847,10 @@ async function main() {
   const who = resolveReportingLogin();
   if (!who.login) {
     process.stderr.write(`usage-report: not sent - ${who.reason}\n`);
-    if (!args.dryRun) return;
+    if (!args.dryRun) {
+      recordSend({ id: runId(state), ev: kind, outcome: "skipped", reason: "no-login" });
+      return;
+    }
   }
 
   const event = buildEvent(state, { event: kind, login: who.login });
@@ -793,7 +861,14 @@ async function main() {
   }
 
   if (event.st !== "in_progress") appendErrorLedger(event);
-  await post(endpoint, token, event);
+  const result = await post(endpoint, token, event);
+  recordSend({ id: event.id, ev: event.ev, host: hostOf(endpoint), ...result });
+  if (result.outcome !== "accepted") {
+    const detail = result.status ?? result.reason;
+    const where = result.location ? ` to ${result.location}` : "";
+    const verb = result.outcome === "not-accepted" ? "not accepted" : result.outcome;
+    process.stderr.write(`usage-report: ${verb}${where} (${detail}) by ${hostOf(endpoint)}\n`);
+  }
 }
 
 // Entry-point check: compare file URLs, never string-split a path.

package/pipeline/scripts/validate-analysis-doc.mjs

@@ -42,6 +42,15 @@
 
 import { readFileSync } from "node:fs";
 import { runMain } from "../lib/fatal.mjs";
+import { redesignSections, sectionBody, tableDataRows } from "../lib/analysis-sections.mjs";
+import {
+  businessLayerTechnical,
+  citedUndefined,
+  designFrameUnmapped,
+  exceptionFlow,
+  missingInputsFinal,
+  scopeOverlap,
+} from "../lib/analysis-quality.mjs";
 
 // A repo-less run (Locked 34) still splits by channel, derived from the evidence:
 // "mobile" and "web" are its platform values. "none" is the narrower case where the
@@ -51,7 +60,7 @@ const KNOWN_PLATFORMS = new Set(["ios", "android", "web", "backend", "mobile", "
 const REQUIRED_FM = ["feature", "platform", "language", "mode", "template_version"];
 
 // Never-omitted sections (Locked 2), matched by bilingual title keyword so the
-// re-flowed section numbering does not matter.
+// profile's own numbering does not matter.
 const REQUIRED_SECTIONS = [
   { key: "summary", any: ["Summary", "Özet", "Ozet"] },
   { key: "goals", any: ["Goals", "Hedefler"] },
@@ -108,6 +117,43 @@ const BANNED_PUNCT = [
 // that blocked a correctly closed document. English has the same trap in
 // "reopened" and "opened".
 const OPEN_STATUS = ["açık", "acik", "open", "girdi bekleniyor", "pending input"];
+// Words that make a requirement untestable because they carry no threshold.
+// Matched as whole words in either language, case-insensitively.
+const VAGUE_WORDS = [
+  "appropriate",
+  "appropriately",
+  "as needed",
+  "as appropriate",
+  "user-friendly",
+  "fast",
+  "quickly",
+  "etc.",
+  "and/or",
+  "various",
+  "if possible",
+  "reasonable",
+  "uygun şekilde",
+  "gerektiğinde",
+  "gerekirse",
+  "hızlı",
+  "hızlıca",
+  "vb.",
+  "vs.",
+  "çeşitli",
+  "mümkünse",
+  "kullanıcı dostu",
+  "makul",
+];
+
+function vagueWords(text) {
+  const found = [];
+  for (const w of VAGUE_WORDS) {
+    const esc = w.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+    if (new RegExp(`(?<![\\p{L}\\p{N}])${esc}(?![\\p{L}\\p{N}])`, "iu").test(text)) found.push(w);
+  }
+  return found;
+}
+
 function isOpenStatus(cell) {
   return String(cell)
     .split("/")
@@ -141,51 +187,6 @@ function parseFrontMatter(text) {
   return { fm, bodyStart: end + 1 };
 }
 
-function sectionBody(lines, keywords, level = 2) {
-  // Opened by a heading at exactly `level`; closed by the next heading at that
-  // level OR ANY SHALLOWER one. A sub-section that is the last of its parent has
-  // no sibling after it, so terminating only on equal depth runs the body into
-  // the following section and audits its rows as if they belonged here.
-  const open = new RegExp(`^#{${level}}\\s+\\d+(\\.\\d+)*\\.?\\s`);
-  const close = new RegExp(`^#{1,${level}}\\s`);
-  let start = -1;
-  for (let i = 0; i < lines.length; i++) {
-    if (open.test(lines[i]) && keywords.some((k) => lines[i].includes(k))) {
-      start = i;
-      break;
-    }
-  }
-  if (start < 0) return null;
-  let end = lines.length;
-  for (let i = start + 1; i < lines.length; i++) {
-    if (close.test(lines[i])) {
-      end = i;
-      break;
-    }
-  }
-  return lines.slice(start + 1, end);
-}
-
-// Data rows are the pipe-rows that follow a table's separator row, which is the
-// only shape that distinguishes them from the header without guessing at cell text.
-function tableDataRows(bodyLines) {
-  const rows = [];
-  let afterSeparator = false;
-  for (const line of bodyLines) {
-    const t = line.trim();
-    if (!t.startsWith("|")) {
-      afterSeparator = false;
-      continue;
-    }
-    if (/^\|[\s\-:|]+\|$/.test(t)) {
-      afterSeparator = true;
-      continue;
-    }
-    if (afterSeparator) rows.push(t);
-  }
-  return rows;
-}
-
 // The report registry. `--report` prints one line per check, and the reason a
 // check did not run is part of the answer: the traceability matrix is corporate
 // only, so on a global document it never executes - and until this existed the
@@ -763,29 +764,42 @@ function main() {
 
   mark("rule-to-test");
 
+  // 2g-2. Vague wording. A requirement two readers can pass differently is not
+  // testable, and these words carry no threshold. Only id-bearing requirement
+  // rows are read; summary prose may speak loosely. Code spans are skipped.
+  {
+    const ROW_ID = /\b(BR-[a-z0-9]+(?:-[a-z0-9]+)*-\d+|IG-\d{2,3}|FG-\d{2,3})\b/i;
+    for (const line of allLines) {
+      const t = line.trim();
+      if (!t.startsWith("|")) continue;
+      const id = t.match(ROW_ID);
+      if (!id) continue;
+      const words = vagueWords(t.replace(/`[^`]*`/g, ""));
+      if (words.length) {
+        warns.push(
+          `vague wording in ${id[1]}: ${words.map((w) => `"${w}"`).join(", ")} - state a threshold, a list or a condition instead`,
+        );
+      }
+    }
+    mark("vague-wording");
+  }
+
   // 2h. Redesign mode (Locked 36). Eight checks, live only when the front-matter
   // opts in. The contract they enforce is analysis/redesign.md, which loads only
   // on a redesign run; what is here is the enforcement, not the explanation.
   const redesign = String(parsed?.fm?.redesign || "false").toLowerCase() === "true";
-  const cbBody = sectionBody(
-    allLines,
-    ["Mevcut Davranış", "Mevcut Davranis", "Current Behaviour", "Current Behavior"],
-    3,
-  );
-  const epBody = sectionBody(
-    allLines,
-    ["Endpoint Eşlemesi", "Endpoint Eslemesi", "Endpoint Mapping"],
-    3,
-  );
-  const dlBody = sectionBody(allLines, ["Fark Listesi", "Difference List"], 3);
+  const rd = redesignSections(allLines, profile);
+  const cbBody = rd.cb.body;
+  const epBody = rd.ep.body;
+  const dlBody = rd.dl.body;
   if (redesign) {
     // 1. The sections themselves. Without this every row check below passes over
     // nothing, which is the specific defect that shows a gate green on an empty
     // document - the same shape the corporate matrix check guards against.
     for (const [body, name] of [
-      [cbBody, "4.5 Current Behaviour"],
-      [epBody, "4.6 Endpoint Mapping"],
-      [dlBody, "9.5 Difference List"],
+      [cbBody, rd.cb.label],
+      [epBody, rd.ep.label],
+      [dlBody, rd.dl.label],
     ]) {
       if (!body) errors.push(`redesign: true but Section ${name} is missing (Locked 36)`);
     }
@@ -866,7 +880,7 @@ function main() {
       const cellCount = (line) =>
         line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").length;
       if (!header) {
-        errors.push("Section 4.6 has no v1/v2 header row (Locked 36)");
+        errors.push(`Section ${rd.ep.label} has no v1/v2 header row (Locked 36)`);
       } else {
         const cols = cellCount(header);
         for (const row of tableDataRows(epBody)) {
@@ -883,8 +897,8 @@ function main() {
     //
     // The heading match alone is not enough to say that. sectionBody tests the
     // keyword as a raw substring of the heading line - deliberately, since Locked
-    // 2 re-flows section numbers and the corporate profile numbers them
-    // differently - so an unrelated `### 4.9 Notes on the old Current Behaviour
+    // 2 drops sections and the corporate profile numbers them differently - so
+    // an unrelated `### 4.9 Notes on the old Current Behaviour
     // audit process` matched, and Phase 3 runs --strict, which turns this warning
     // into a blocked document. The artefact itself is the honest signal: a
     // rendered current-behaviour table always carries `CB-<slug>-NN` ids, and a
@@ -900,6 +914,43 @@ function main() {
     mark("redesign-artifacts", "not a redesign");
   }
 
+  // 2e. Document quality (analysis-quality.mjs): each check returns its own
+  // errors and warnings, so it is testable without this file.
+  {
+    const isFinal = (parsed?.fm?.status || "draft").toLowerCase() === "final";
+    const corporate = profile === "corporate";
+    const run = (id, check, skipped) => {
+      if (!skipped) {
+        const r = check();
+        errors.push(...r.errors);
+        warns.push(...r.warns);
+      }
+      mark(id, skipped);
+    };
+    run(
+      "exception-flow",
+      () => exceptionFlow(allLines, { final: isFinal }),
+      corporate ? undefined : "global profile",
+    );
+    run("scope-overlap", () => scopeOverlap(allLines));
+    run("cited-undefined", () => citedUndefined(allLines));
+    run(
+      "design-frame-unmapped",
+      () => designFrameUnmapped(allLines),
+      corporate ? undefined : "global profile",
+    );
+    run(
+      "business-layer-technical",
+      () => businessLayerTechnical(allLines),
+      corporate ? "corporate profile" : undefined,
+    );
+    run(
+      "missing-inputs",
+      () => missingInputsFinal(allLines, { final: isFinal }),
+      isFinal ? undefined : "draft document",
+    );
+  }
+
   // 3. Humanizer punctuation. Scope mirrors the humanizer pass exactly
   // (analysis/render.md): front-matter, fenced code blocks, table rows and
   // URLs are exempt there, so flagging them here would raise an ERROR that no
@@ -937,11 +988,10 @@ function main() {
 
   // 4b. Locked 2's numbering half.
   //
-  // It is NOT "numbering re-flows 1..N", which could not hold: Locked 30
-  // threads ids across the document by section
-  // NUMBER ("Section 15.1 scenario", "Section 4.4", "Section 3/5 layout cells"),
-  // so a re-flowed document sends every one of those references to the wrong
-  // section. No emitted document ever re-flowed. The rule was the wrong half.
+  // Rendered sections keep their canonical template numbers and may leave
+  // gaps, because Locked 30 threads ids across the document by section NUMBER
+  // ("Section 15.1 scenario", "Section 4.4", "Section 3/5 layout cells"), and
+  // renumbering would send every one of those references to the wrong section.
   //
   // What holds instead: a rendered section keeps its canonical template number,
   // so gaps are correct and `1, 2, 4, 9, 13, 14, 21` is a valid document. Two
@@ -1018,8 +1068,8 @@ function main() {
   // audited - "used subset" means nothing without the set it is a subset of.
   let inVariant = false;
   for (const line of text.split("\n")) {
-    // Keyed on the heading text, not the number: Locked 2 re-flows numbering, so
-    // a literal "6.X" match silently stops running the moment the section moves.
+    // Keyed on the heading text, not the number: the corporate profile numbers
+    // this section differently, so a literal "6.X" match would skip it there.
     if (/^#{2,3}\s+\d+(\.[0-9X]+)*\.?\s/.test(line) && /Varyant|Variant/i.test(line)) {
       inVariant = true;
       continue;

package/pipeline/skills/.skill-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-09-29T13:31:43Z",
+  "generatedAt": "2026-10-01T20:47:44Z",
   "skillCount": 218,
   "entries": [
     {
@@ -13,7 +13,7 @@
     },
     {
       "path": "shared/core/multi-agent-analysis-jira/SKILL.md",
-      "sha256": "8c5916a32156bc4c75f97cac1b57dbfe9e49f16027178128d12e50f6e326ae12"
+      "sha256": "130543d1017115de351a1175b6b179778642ba0b3207034b54114b39d0546407"
     },
     {
       "path": "shared/core/multi-agent-analysis-resolve/SKILL.md",
@@ -21,7 +21,7 @@
     },
     {
       "path": "shared/core/multi-agent-analysis/SKILL.md",
-      "sha256": "fff7f2c2d4aa769a5c08beb776a848f91caf485c1d84dd5a4a3571ff02c35e0e"
+      "sha256": "a7cf677df00433583d5e2e1578223d1e1797a1bd4d07ff0d1d8596d94baa013a"
     },
     {
       "path": "shared/core/multi-agent-autopilot-off/SKILL.md",
@@ -37,7 +37,7 @@
     },
     {
       "path": "shared/core/multi-agent-autopilot/SKILL.md",
-      "sha256": "426158ddbb5e8d6e594cd2e02aceb197e1769d692602dfbd2a368a6707081bd3"
+      "sha256": "a9731771fbc1f45260f214f069b976eff16e7b25e2f1375b0d9a213575271bc6"
     },
     {
       "path": "shared/core/multi-agent-build-optimize/SKILL.md",
@@ -65,7 +65,7 @@
     },
     {
       "path": "shared/core/multi-agent-doctor/SKILL.md",
-      "sha256": "1b1450ead2c6ee6ff64a8cfd4fcefeba1084a46f2a2e5d8a8a1077b7ec3f4130"
+      "sha256": "2f6222cdef9c6b2b4e2e330ba0acee33ab0fb797029bb16c50bbb244be5fcbe6"
     },
     {
       "path": "shared/core/multi-agent-feedback/SKILL.md",
@@ -145,7 +145,7 @@
     },
     {
       "path": "shared/core/multi-agent-review-analysis/SKILL.md",
-      "sha256": "f55d3b28266001d150d0438e92f8bb5dfa9cdce517892cf12fe94beee8440c07"
+      "sha256": "5f90d2da227e1ffb7fedd00c3a0d094bb0e0e32a26aa25a7ec503ff6e4865503"
     },
     {
       "path": "shared/core/multi-agent-review-issue/SKILL.md",
@@ -157,7 +157,7 @@
     },
     {
       "path": "shared/core/multi-agent-review/SKILL.md",
-      "sha256": "23b38684ac14c65522ff3f1889ae2f8bab89f10a62db1d7f01f6b46228136157"
+      "sha256": "f1bad66314a55f35b7ac056a2f97e44c30702bebfbacc886b8efe7887eec5685"
     },
     {
       "path": "shared/core/multi-agent-route-off/SKILL.md",
@@ -201,7 +201,7 @@
     },
     {
       "path": "shared/core/multi-agent-setup/SKILL.md",
-      "sha256": "f73388e0a64ba8a1606e3364441b078f3df6f7e99e589fb9bc8b93269a2733b2"
+      "sha256": "38fdbe979ab2da87dcee55d1ce988cbda5bab92f5f751f448e2e64b18113c50e"
     },
     {
       "path": "shared/core/multi-agent-stack/SKILL.md",