sigmap 7.12.0 → 7.14.0

package/CHANGELOG.md

@@ -10,6 +10,24 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [7.14.0] — 2026-06-17
+
+Minor release — `sigmap conventions --report` (grounded codegen, Layer 3 polish).
+
+### Added
+- **`sigmap conventions --report` — consistency audit + trend vs last run (#319):** the next `conventions` flag (IMPL.md §4). Reports a per-convention consistency score (file naming, export style) and a single file-count-weighted **overall consistency score**, each with a delta vs the previous run — a trackable "how consistent is our style, and is it improving?" number. New zero-dependency, bundle-safe `src/conventions/report.js` (`scoreReport`, `snapshot`, `overallScore`); the command compares against the last snapshot in `.context/conventions-history.ndjson`, prints the audit with ▲/▼ trend arrows, and appends a fresh snapshot. `--json` for machine output. The remaining `conventions` flags (`--fix`, `--update`, `--ci`) and the §9 LLM A/B benchmark are follow-ups.
+
+---
+
+## [7.13.0] — 2026-06-17
+
+Minor release — `sigmap create` (grounded codegen, Gap 2 — the pipeline capstone).
+
+### Added
+- **`sigmap create "<task>"` — orchestrate the 4-stage grounded-creation pipeline (#316):** the capstone of the grounded-codegen work. One command sequences the four guard stages — `scaffold` → `verify-plan` → `verify-ai-output` → `review-pr` — with `1/4`…`4/4` numbering and a single pass/fail summary. Each stage runs only when its input is present (`--name` → scaffold, `--plan` → verify-plan, `--answer` → verify-ai-output, the git diff → review-pr); a stage with no input is skipped and does not fail the run. New zero-dependency, bundle-safe `src/create/orchestrate.js` (`orchestrate`) delegates to the real stage modules — no logic duplication. CLI supports `--name`, `--plan`, `--answer`, `--staged`/`--base`, and `--json`, and exits non-zero when a ran stage fails. This completes the grounded-creation loop: every root cause (1–4) is closed and all four guard stages are now sequenced by one command.
+
+---
+
 ## [7.12.0] — 2026-06-17
 
 Minor release — `sigmap review-pr` (grounded codegen, Gap 2 — last guard stage).

package/gen-context.js

@@ -28,6 +28,175 @@ function __require(key) {
 // ── ./src/plan/verify-plan ──
 // ── ./src/cache/freshen ──
 // ── ./src/review/review-pr ──
+// ── ./src/create/orchestrate ──
+// ── ./src/conventions/report ──
+__factories["./src/conventions/report"] = function(module, exports) {
+  
+  /**
+   * Convention audit + trend (IMPL.md §4 — `conventions --report`).
+   *
+   * Turns an `extractConventions` result into an audit: a consistency score per
+   * convention plus a single file-count-weighted overall score, each with a delta
+   * vs the previous run (the trend). Pure, zero-dependency, bundle-safe.
+   */
+
+  const NAMES = { fileNaming: 'file naming', exportStyle: 'export style' };
+
+  /** File-count-weighted mean of the scored conventions' dominant shares (0–1). */
+  function overallScore(result) {
+    let num = 0;
+    let den = 0;
+    for (const key of ['fileNaming', 'exportStyle']) {
+      const c = result && result[key];
+      if (c && c.total > 0) { num += c.dominantPct * c.total; den += c.total; }
+    }
+    return den > 0 ? num / den : 0;
+  }
+
+  /**
+   * Build a consistency report with trend vs a prior snapshot.
+   * @param {object} result an `extractConventions` result
+   * @param {object|null} [prior] a previous snapshot (this module's `snapshot` shape)
+   * @returns {{ conventions: object[], testFramework: string|null,
+   *   score: number, prevScore: number|null, scoreDelta: number|null }}
+   */
+  function scoreReport(result, prior) {
+    const conventions = [];
+    for (const key of ['fileNaming', 'exportStyle']) {
+      const c = (result && result[key]) || { dominant: null, dominantPct: 0, total: 0, tier: 'unknown' };
+      const priorPct = prior && prior[key] && typeof prior[key].dominantPct === 'number' ? prior[key].dominantPct : null;
+      conventions.push({
+        key,
+        name: NAMES[key] || key,
+        dominant: c.dominant,
+        dominantPct: c.dominantPct,
+        tier: c.tier,
+        total: c.total,
+        delta: priorPct == null ? null : c.dominantPct - priorPct,
+      });
+    }
+    const score = overallScore(result);
+    const prevScore = prior && typeof prior.score === 'number' ? prior.score : null;
+    return {
+      conventions,
+      testFramework: (result && result.testFramework) || null,
+      score,
+      prevScore,
+      scoreDelta: prevScore == null ? null : score - prevScore,
+    };
+  }
+
+  /**
+   * A compact, persistable snapshot of a run (one line in the history log).
+   * @param {object} result an `extractConventions` result
+   * @param {string} [ts] ISO timestamp (caller supplies — keeps this pure)
+   */
+  function snapshot(result, ts) {
+    const pick = (c) => (c && c.total > 0
+      ? { dominant: c.dominant, dominantPct: c.dominantPct, tier: c.tier, total: c.total }
+      : { dominant: null, dominantPct: 0, tier: 'unknown', total: 0 });
+    return {
+      ts: ts || null,
+      fileNaming: pick(result && result.fileNaming),
+      exportStyle: pick(result && result.exportStyle),
+      testFramework: (result && result.testFramework) || null,
+      score: overallScore(result),
+    };
+  }
+
+  module.exports = { scoreReport, snapshot, overallScore };
+  
+};
+
+__factories["./src/create/orchestrate"] = function(module, exports) {
+  
+  /**
+   * create orchestrator (IMPL.md §6.2 — the capstone of the grounded-creation loop).
+   *
+   * Sequences the four guard stages — scaffold → verify-plan → verify-ai-output →
+   * review-pr — in one pass with `n/4` numbering and a single pass/fail summary.
+   * The agent does the LLM writing between stages; `create` runs the deterministic
+   * guards it owns. A stage runs only when its input is present (else it is
+   * skipped, which does not fail the run). Zero-dependency, bundle-safe; delegates
+   * to the real stage modules.
+   */
+
+  const { proposeScaffold } = __require('./src/scaffold/propose');
+  const { verifyPlan } = __require('./src/plan/verify-plan');
+  const { verify } = __require('./src/verify/hallucination-guard');
+  const { reviewPr } = __require('./src/review/review-pr');
+
+  const TOTAL = 4;
+
+  /**
+   * Run the create pipeline over whatever inputs are available.
+   * @param {object} ctx
+   * @param {string} [ctx.task] free-text task label (echoed back)
+   * @param {string} [ctx.name] module name → enables the scaffold stage
+   * @param {object} [ctx.conventions] an `extractConventions` result (for scaffold)
+   * @param {object} [ctx.scaffoldOpts] options forwarded to `proposeScaffold`
+   * @param {string} [ctx.plan] plan markdown → enables verify-plan
+   * @param {string} [ctx.answer] AI answer markdown → enables verify-ai-output
+   * @param {Array<{path:string,status:string}>} [ctx.changedFiles] → enables review-pr
+   * @param {string} cwd repo root
+   * @returns {{ task: string|null, steps: object[], summary: object }}
+   */
+  function orchestrate(ctx = {}, cwd) {
+    const steps = [];
+
+    // 1/4 — scaffold (needs a name + conventions)
+    if (ctx.name && ctx.conventions) {
+      const d = proposeScaffold(ctx.name, ctx.conventions, ctx.scaffoldOpts || {});
+      steps.push({ n: 1, total: TOTAL, name: 'scaffold', ran: true, ok: !!d.ok, skipped: false, detail: d });
+    } else {
+      steps.push({ n: 1, total: TOTAL, name: 'scaffold', ran: false, ok: null, skipped: true, reason: 'no --name' });
+    }
+
+    // 2/4 — verify-plan (needs a plan)
+    if (ctx.plan != null && String(ctx.plan).trim() !== '') {
+      const r = verifyPlan(ctx.plan, cwd);
+      steps.push({ n: 2, total: TOTAL, name: 'verify-plan', ran: true, ok: !!r.summary.ok, skipped: false, detail: r });
+    } else {
+      steps.push({ n: 2, total: TOTAL, name: 'verify-plan', ran: false, ok: null, skipped: true, reason: 'no --plan' });
+    }
+
+    // 3/4 — verify-ai-output (needs an answer)
+    if (ctx.answer != null && String(ctx.answer).trim() !== '') {
+      const r = verify(ctx.answer, cwd);
+      steps.push({ n: 3, total: TOTAL, name: 'verify-ai-output', ran: true, ok: r.summary.total === 0, skipped: false, detail: r });
+    } else {
+      steps.push({ n: 3, total: TOTAL, name: 'verify-ai-output', ran: false, ok: null, skipped: true, reason: 'no --answer' });
+    }
+
+    // 4/4 — review-pr (needs changed files)
+    if (Array.isArray(ctx.changedFiles) && ctx.changedFiles.length) {
+      const r = reviewPr(ctx.changedFiles, cwd);
+      steps.push({ n: 4, total: TOTAL, name: 'review-pr', ran: true, ok: !!r.summary.ok, skipped: false, detail: r });
+    } else {
+      steps.push({ n: 4, total: TOTAL, name: 'review-pr', ran: false, ok: null, skipped: true, reason: 'no changes' });
+    }
+
+    const ran = steps.filter((s) => s.ran);
+    const passed = ran.filter((s) => s.ok).length;
+    const failed = ran.length - passed;
+    return {
+      task: ctx.task || null,
+      steps,
+      summary: {
+        total: TOTAL,
+        ran: ran.length,
+        skipped: steps.length - ran.length,
+        passed,
+        failed,
+        ok: failed === 0,
+      },
+    };
+  }
+
+  module.exports = { orchestrate, TOTAL };
+  
+};
+
 __factories["./src/review/review-pr"] = function(module, exports) {
   
   /**
@@ -7369,7 +7538,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
 
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '7.12.0',
+    version: '7.14.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
 
@@ -13047,7 +13216,7 @@ function __tryGit(args, opts = {}) {
   catch (_) { return ''; }
 }
 
-const VERSION = '7.12.0';
+const VERSION = '7.14.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -16242,6 +16411,38 @@ function main() {
       process.exit(0);
     }
 
+    // `--report`: consistency audit + score + trend vs the last run.
+    if (args.includes('--report')) {
+      const { scoreReport, snapshot } = requireSourceOrBundled('./src/conventions/report');
+      const histPath = path.join(cwd, '.context', 'conventions-history.ndjson');
+      let prior = null;
+      try {
+        const lines = fs.readFileSync(histPath, 'utf8').split('\n').filter(Boolean);
+        if (lines.length) prior = JSON.parse(lines[lines.length - 1]);
+      } catch (_) {}
+      const report = scoreReport(result, prior);
+      // Append the new snapshot to the history log.
+      try {
+        fs.mkdirSync(path.join(cwd, '.context'), { recursive: true });
+        fs.appendFileSync(histPath, JSON.stringify(snapshot(result, new Date().toISOString())) + '\n');
+      } catch (_) {}
+
+      if (jsonOut) {
+        process.stdout.write(JSON.stringify(report) + '\n');
+        process.exit(0);
+      }
+      const pctR = (n) => `${(n * 100).toFixed(0)}%`;
+      const arrow = (d) => (d == null ? '' : d > 0.0005 ? ` ▲${(d * 100).toFixed(0)}pp` : d < -0.0005 ? ` ▼${(Math.abs(d) * 100).toFixed(0)}pp` : ' =');
+      console.log('[sigmap] conventions --report  (TS/JS/Python)');
+      console.log(`  overall consistency: ${pctR(report.score)}${arrow(report.scoreDelta)}${report.prevScore == null ? '  (first run)' : ''}`);
+      for (const c of report.conventions) {
+        if (c.total === 0) { console.log(`  ${c.name.padEnd(14)} n/a (no samples)`); continue; }
+        console.log(`  ${c.name.padEnd(14)} ${c.dominant} ${pctR(c.dominantPct)} [${c.tier}]${arrow(c.delta)}`);
+      }
+      console.log(`  ${'test framework'.padEnd(14)} ${report.testFramework || 'none detected'}`);
+      process.exit(0);
+    }
+
     // `--conflicts`: surface why a convention is mixed (breakdown + rename suggestions).
     if (args.includes('--conflicts')) {
       const { analyzeConflicts } = requireSourceOrBundled('./src/conventions/conflicts');
@@ -16553,6 +16754,71 @@ function main() {
     process.exit(1);
   }
 
+  // Gap 2 (capstone): `sigmap create "<task>"` — orchestrate the 4 guard stages
+  // (scaffold → verify-plan → verify-ai-output → review-pr) with n/4 numbering.
+  if (args[0] === 'create') {
+    const jsonOut = args.includes('--json');
+    const task = args[1] && !args[1].startsWith('--') ? args[1] : null;
+    const flagVal = (flag) => { const i = args.indexOf(flag); return i !== -1 && args[i + 1] && !args[i + 1].startsWith('--') ? args[i + 1] : null; };
+    const nameArg = flagVal('--name');
+    const planFile = flagVal('--plan');
+    const answerFile = flagVal('--answer');
+    const staged = args.includes('--staged');
+    const baseArg = flagVal('--base');
+
+    const ctx = { task };
+
+    if (nameArg) {
+      ctx.name = nameArg;
+      try {
+        const { extractConventions } = requireSourceOrBundled('./src/conventions/extract');
+        ctx.conventions = extractConventions(cwd, buildFileList(cwd, config));
+      } catch (_) {}
+    }
+    for (const [flag, file, key] of [['--plan', planFile, 'plan'], ['--answer', answerFile, 'answer']]) {
+      if (!file) continue;
+      try { ctx[key] = fs.readFileSync(path.resolve(cwd, file), 'utf8'); }
+      catch (e) { console.error(`[sigmap] cannot read ${flag} file: ${e.message}`); process.exit(1); }
+    }
+
+    // review-pr inputs: changed files from git (same collection as review-pr).
+    let nameStatus = '';
+    if (staged) {
+      nameStatus = __tryGit(['diff', '--cached', '--name-status'], { cwd });
+    } else {
+      let base = baseArg;
+      if (!base) {
+        for (const ref of ['main', 'develop']) {
+          if (__tryGit(['rev-parse', '--verify', '--quiet', ref], { cwd })) { base = ref; break; }
+        }
+      }
+      const mb = base ? (__tryGit(['merge-base', 'HEAD', base], { cwd }) || base) : 'HEAD~1';
+      nameStatus = __tryGit(['diff', '--name-status', `${mb}..HEAD`], { cwd });
+    }
+    ctx.changedFiles = nameStatus.split('\n').filter(Boolean).map((line) => {
+      const parts = line.split('\t');
+      return { path: parts[parts.length - 1], status: parts[0][0] };
+    });
+
+    const { orchestrate } = requireSourceOrBundled('./src/create/orchestrate');
+    const result = orchestrate(ctx, cwd);
+
+    if (jsonOut) {
+      process.stdout.write(JSON.stringify(result) + '\n');
+      process.exit(result.summary.ok ? 0 : 1);
+    }
+
+    console.log(`[sigmap] create${result.task ? ` "${result.task}"` : ''} — grounded-creation pipeline`);
+    for (const st of result.steps) {
+      const mark = st.skipped ? '–' : (st.ok ? '✓' : '✗');
+      const status = st.skipped ? `skipped (${st.reason})` : (st.ok ? 'ok' : 'FAILED');
+      console.log(`  ${st.n}/${st.total} ${mark} ${st.name.padEnd(16)} ${status}`);
+    }
+    const su = result.summary;
+    console.log(`\n  ${su.ran}/${su.total} ran · ${su.passed} passed · ${su.failed} failed · ${su.skipped} skipped`);
+    process.exit(su.ok ? 0 : 1);
+  }
+
   // Feature 1: `sigmap explain <file>` — why a file is included or excluded
   if (args[0] === 'explain' || args.includes('--explain')) {
     const target = args[0] === 'explain'

package/llms-full.txt

@@ -9,7 +9,7 @@ the files relevant to the task — cutting tokens ~97% while keeping answers
 grounded. Deterministic, offline, no embeddings or vector database. Works with
 Claude, Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 7.12.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.14.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
 # Source: auto-generated from package.json, version.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 

package/llms.txt

@@ -9,7 +9,7 @@ the files relevant to the task — cutting tokens ~97% while keeping answers
 grounded. Deterministic, offline, no embeddings or vector database. Works with
 Claude, Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 7.12.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.14.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
 # Source: auto-generated from package.json, version.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "7.12.0",
+  "version": "7.14.0",
   "description": "97% token reduction for AI coding. Extracts function & class signatures with TF-IDF ranking to feed only the right files to Claude, Cursor, Copilot, Aider, Windsurf, local LLMs & MCP. Zero dependencies, runs offline via npx.",
   "main": "packages/core/index.js",
   "exports": {

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "7.12.0",
+  "version": "7.14.0",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "7.12.0",
+  "version": "7.14.0",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/conventions/report.js

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * Convention audit + trend (IMPL.md §4 — `conventions --report`).
+ *
+ * Turns an `extractConventions` result into an audit: a consistency score per
+ * convention plus a single file-count-weighted overall score, each with a delta
+ * vs the previous run (the trend). Pure, zero-dependency, bundle-safe.
+ */
+
+const NAMES = { fileNaming: 'file naming', exportStyle: 'export style' };
+
+/** File-count-weighted mean of the scored conventions' dominant shares (0–1). */
+function overallScore(result) {
+  let num = 0;
+  let den = 0;
+  for (const key of ['fileNaming', 'exportStyle']) {
+    const c = result && result[key];
+    if (c && c.total > 0) { num += c.dominantPct * c.total; den += c.total; }
+  }
+  return den > 0 ? num / den : 0;
+}
+
+/**
+ * Build a consistency report with trend vs a prior snapshot.
+ * @param {object} result an `extractConventions` result
+ * @param {object|null} [prior] a previous snapshot (this module's `snapshot` shape)
+ * @returns {{ conventions: object[], testFramework: string|null,
+ *   score: number, prevScore: number|null, scoreDelta: number|null }}
+ */
+function scoreReport(result, prior) {
+  const conventions = [];
+  for (const key of ['fileNaming', 'exportStyle']) {
+    const c = (result && result[key]) || { dominant: null, dominantPct: 0, total: 0, tier: 'unknown' };
+    const priorPct = prior && prior[key] && typeof prior[key].dominantPct === 'number' ? prior[key].dominantPct : null;
+    conventions.push({
+      key,
+      name: NAMES[key] || key,
+      dominant: c.dominant,
+      dominantPct: c.dominantPct,
+      tier: c.tier,
+      total: c.total,
+      delta: priorPct == null ? null : c.dominantPct - priorPct,
+    });
+  }
+  const score = overallScore(result);
+  const prevScore = prior && typeof prior.score === 'number' ? prior.score : null;
+  return {
+    conventions,
+    testFramework: (result && result.testFramework) || null,
+    score,
+    prevScore,
+    scoreDelta: prevScore == null ? null : score - prevScore,
+  };
+}
+
+/**
+ * A compact, persistable snapshot of a run (one line in the history log).
+ * @param {object} result an `extractConventions` result
+ * @param {string} [ts] ISO timestamp (caller supplies — keeps this pure)
+ */
+function snapshot(result, ts) {
+  const pick = (c) => (c && c.total > 0
+    ? { dominant: c.dominant, dominantPct: c.dominantPct, tier: c.tier, total: c.total }
+    : { dominant: null, dominantPct: 0, tier: 'unknown', total: 0 });
+  return {
+    ts: ts || null,
+    fileNaming: pick(result && result.fileNaming),
+    exportStyle: pick(result && result.exportStyle),
+    testFramework: (result && result.testFramework) || null,
+    score: overallScore(result),
+  };
+}
+
+module.exports = { scoreReport, snapshot, overallScore };

package/src/create/orchestrate.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * create orchestrator (IMPL.md §6.2 — the capstone of the grounded-creation loop).
+ *
+ * Sequences the four guard stages — scaffold → verify-plan → verify-ai-output →
+ * review-pr — in one pass with `n/4` numbering and a single pass/fail summary.
+ * The agent does the LLM writing between stages; `create` runs the deterministic
+ * guards it owns. A stage runs only when its input is present (else it is
+ * skipped, which does not fail the run). Zero-dependency, bundle-safe; delegates
+ * to the real stage modules.
+ */
+
+const { proposeScaffold } = require('../scaffold/propose');
+const { verifyPlan } = require('../plan/verify-plan');
+const { verify } = require('../verify/hallucination-guard');
+const { reviewPr } = require('../review/review-pr');
+
+const TOTAL = 4;
+
+/**
+ * Run the create pipeline over whatever inputs are available.
+ * @param {object} ctx
+ * @param {string} [ctx.task] free-text task label (echoed back)
+ * @param {string} [ctx.name] module name → enables the scaffold stage
+ * @param {object} [ctx.conventions] an `extractConventions` result (for scaffold)
+ * @param {object} [ctx.scaffoldOpts] options forwarded to `proposeScaffold`
+ * @param {string} [ctx.plan] plan markdown → enables verify-plan
+ * @param {string} [ctx.answer] AI answer markdown → enables verify-ai-output
+ * @param {Array<{path:string,status:string}>} [ctx.changedFiles] → enables review-pr
+ * @param {string} cwd repo root
+ * @returns {{ task: string|null, steps: object[], summary: object }}
+ */
+function orchestrate(ctx = {}, cwd) {
+  const steps = [];
+
+  // 1/4 — scaffold (needs a name + conventions)
+  if (ctx.name && ctx.conventions) {
+    const d = proposeScaffold(ctx.name, ctx.conventions, ctx.scaffoldOpts || {});
+    steps.push({ n: 1, total: TOTAL, name: 'scaffold', ran: true, ok: !!d.ok, skipped: false, detail: d });
+  } else {
+    steps.push({ n: 1, total: TOTAL, name: 'scaffold', ran: false, ok: null, skipped: true, reason: 'no --name' });
+  }
+
+  // 2/4 — verify-plan (needs a plan)
+  if (ctx.plan != null && String(ctx.plan).trim() !== '') {
+    const r = verifyPlan(ctx.plan, cwd);
+    steps.push({ n: 2, total: TOTAL, name: 'verify-plan', ran: true, ok: !!r.summary.ok, skipped: false, detail: r });
+  } else {
+    steps.push({ n: 2, total: TOTAL, name: 'verify-plan', ran: false, ok: null, skipped: true, reason: 'no --plan' });
+  }
+
+  // 3/4 — verify-ai-output (needs an answer)
+  if (ctx.answer != null && String(ctx.answer).trim() !== '') {
+    const r = verify(ctx.answer, cwd);
+    steps.push({ n: 3, total: TOTAL, name: 'verify-ai-output', ran: true, ok: r.summary.total === 0, skipped: false, detail: r });
+  } else {
+    steps.push({ n: 3, total: TOTAL, name: 'verify-ai-output', ran: false, ok: null, skipped: true, reason: 'no --answer' });
+  }
+
+  // 4/4 — review-pr (needs changed files)
+  if (Array.isArray(ctx.changedFiles) && ctx.changedFiles.length) {
+    const r = reviewPr(ctx.changedFiles, cwd);
+    steps.push({ n: 4, total: TOTAL, name: 'review-pr', ran: true, ok: !!r.summary.ok, skipped: false, detail: r });
+  } else {
+    steps.push({ n: 4, total: TOTAL, name: 'review-pr', ran: false, ok: null, skipped: true, reason: 'no changes' });
+  }
+
+  const ran = steps.filter((s) => s.ran);
+  const passed = ran.filter((s) => s.ok).length;
+  const failed = ran.length - passed;
+  return {
+    task: ctx.task || null,
+    steps,
+    summary: {
+      total: TOTAL,
+      ran: ran.length,
+      skipped: steps.length - ran.length,
+      passed,
+      failed,
+      ok: failed === 0,
+    },
+  };
+}
+
+module.exports = { orchestrate, TOTAL };

package/src/mcp/server.js

@@ -18,7 +18,7 @@ const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, exp
 
 const SERVER_INFO = {
   name: 'sigmap',
-  version: '7.12.0',
+  version: '7.14.0',
   description: 'SigMap MCP server — code signatures on demand',
 };