@llman-sdd/core 0.1.0

package/src/report/collect.ts

@@ -0,0 +1,164 @@
+/**
+ * Change collection + rendering (peripheral-commands capability, r20).
+ * Port of v1 commands/list.rs shapes. Pure — IO injected.
+ */
+import { readBinding } from '../change/frontmatter.ts';
+import { CHANGES_DIR } from '../change/lifecycle.ts';
+
+export interface ChangeFsIo {
+  exists(path: string): boolean;
+  readText(path: string): string;
+  listDir(path: string): string[];
+  isDirectory(path: string): boolean;
+  mtimeMs(path: string): number;
+}
+
+export interface ChangeSummary {
+  name: string;
+  path: string;
+  title: string;
+  stage: 'draft' | 'designed' | 'planned' | 'full';
+  hasBinding: boolean;
+  completedTasks: number;
+  totalTasks: number;
+  lastModified: Date;
+  idleDays: number;
+}
+
+export type ChangeStatus = 'no-tasks' | 'complete' | 'in-progress';
+
+export function statusFor(total: number, completed: number): ChangeStatus {
+  if (total === 0) return 'no-tasks';
+  return completed >= total ? 'complete' : 'in-progress';
+}
+
+export function stageFor(
+  hasDesign: boolean,
+  hasTasks: boolean,
+  hasBinding: boolean,
+): ChangeSummary['stage'] {
+  if (hasBinding) return 'full';
+  if (hasTasks) return 'planned';
+  if (hasDesign) return 'designed';
+  return 'draft';
+}
+
+function countTasks(tasksMd: string): { completed: number; total: number } {
+  let completed = 0;
+  let total = 0;
+  for (const line of tasksMd.split('\n')) {
+    const m = line.match(/^\s*-\s+\[( |x|X)\]/u);
+    if (m) {
+      total += 1;
+      if (m[1] !== ' ') completed += 1;
+    }
+  }
+  return { completed, total };
+}
+
+function firstH1(md: string): string {
+  for (const line of md.split('\n')) {
+    const m = line.match(/^#\s+(.*)$/u);
+    if (m?.[1]) return m[1].trim();
+  }
+  return '';
+}
+
+export function collectChanges(io: ChangeFsIo, root: string, now: Date): ChangeSummary[] {
+  const changesDir = `${root}/${CHANGES_DIR}`;
+  if (!io.exists(changesDir) || !io.isDirectory(changesDir)) return [];
+  const out: ChangeSummary[] = [];
+  for (const name of io.listDir(changesDir).toSorted()) {
+    if (name === 'archive') continue;
+    const dir = `${changesDir}/${name}`;
+    if (!io.isDirectory(dir)) continue;
+    const proposal = `${dir}/proposal.md`;
+    if (!io.exists(proposal)) continue;
+
+    const hasDesign = io.exists(`${dir}/design.md`);
+    const hasTasks = io.exists(`${dir}/tasks.md`);
+    const hasBinding = readBinding(io.readText(proposal)) !== null;
+    const { completed, total } = hasTasks
+      ? countTasks(io.readText(`${dir}/tasks.md`))
+      : { completed: 0, total: 0 };
+
+    // lastModified = newest mtime across the change dir
+    let latest = io.mtimeMs(proposal);
+    for (const f of [hasDesign ? `${dir}/design.md` : null, hasTasks ? `${dir}/tasks.md` : null]) {
+      if (f) latest = Math.max(latest, io.mtimeMs(f));
+    }
+    const lastModified = new Date(latest);
+    const idleDays = Math.floor((now.getTime() - lastModified.getTime()) / 86_400_000);
+
+    out.push({
+      name,
+      path: name,
+      title: firstH1(io.readText(proposal)),
+      stage: stageFor(hasDesign, hasTasks, hasBinding),
+      hasBinding,
+      completedTasks: completed,
+      totalTasks: total,
+      lastModified,
+      idleDays,
+    });
+  }
+  // v1 lists newest-first
+  return out.toSorted((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+}
+
+export function statusHuman(c: ChangeSummary): string {
+  const s = statusFor(c.totalTasks, c.completedTasks);
+  if (s === 'no-tasks') return 'no tasks';
+  if (s === 'complete') return 'complete';
+  return `${c.completedTasks}/${c.totalTasks} tasks`;
+}
+
+export function relativeTime(from: Date, now: Date): string {
+  const ms = now.getTime() - from.getTime();
+  const minutes = Math.floor(ms / 60_000);
+  if (minutes < 1) return 'just now';
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+
+function pad(s: string, width: number): string {
+  return s.length >= width ? s : s + ' '.repeat(width - s.length);
+}
+
+export function renderChangesList(changes: readonly ChangeSummary[], now: Date): string[] {
+  const lines = ['Active changes:'];
+  if (changes.length === 0) return lines;
+  const nameWidth = Math.max(...changes.map((c) => c.name.length)) + 2;
+  const stageWidth = Math.max(...changes.map((c) => c.stage.length)) + 7;
+  const statusWidth = Math.max(...changes.map((c) => statusHuman(c).length)) + 5;
+  for (const c of changes) {
+    lines.push(
+      `  ${pad(c.name, nameWidth)}${pad(c.stage, stageWidth)}${pad(statusHuman(c), statusWidth)}${relativeTime(
+        c.lastModified,
+        now,
+      )}${statusFor(c.totalTasks, c.completedTasks) === 'no-tasks' ? ` (idle ${c.idleDays}d)` : ''}`,
+    );
+  }
+  return lines;
+}
+
+export function renderChangesJson(changes: readonly ChangeSummary[]): string {
+  return JSON.stringify(
+    {
+      changes: changes.map((c) => ({
+        name: c.name,
+        path: c.path,
+        stage: c.stage,
+        completedTasks: c.completedTasks,
+        totalTasks: c.totalTasks,
+        lastModified: c.lastModified.toISOString(),
+        idleDays: c.idleDays,
+        status: statusFor(c.totalTasks, c.completedTasks),
+      })),
+    },
+    null,
+    2,
+  );
+}

package/src/report/graph.ts

@@ -0,0 +1,103 @@
+/**
+ * Change dependency graph (peripheral-commands capability, r21):
+ * mermaid output with v1 conventions — node ids dash→underscore, archived
+ * changes annotated "✓ done" with the archived class, depends_on edges.
+ */
+import { CHANGES_DIR } from '../change/lifecycle.ts';
+
+export interface GraphFsIo {
+  exists(path: string): boolean;
+  readText(path: string): string;
+  listDir(path: string): string[];
+  isDirectory(path: string): boolean;
+}
+
+interface GraphNode {
+  id: string;
+  archived: boolean;
+  dependsOn: string[];
+}
+
+function collectNodes(io: GraphFsIo, root: string): GraphNode[] {
+  const nodes: GraphNode[] = [];
+  const scan = (dir: string, archived: boolean, stripDatePrefix: boolean): void => {
+    if (!io.exists(dir) || !io.isDirectory(dir)) return;
+    for (const name of io.listDir(dir).toSorted()) {
+      if (name === 'archive') continue;
+      const full = `${dir}/${name}`;
+      if (!io.isDirectory(full)) continue;
+      const proposal = `${full}/proposal.md`;
+      if (!io.exists(proposal)) continue;
+      const id = archived && stripDatePrefix ? name.replace(/^\d{4}-\d{2}-\d{2}-/u, '') : name;
+      const deps: string[] = [];
+      const fm = io.readText(proposal).match(/^---\n([\s\S]*?)\n---/u);
+      if (fm?.[1]) {
+        const lines = fm[1].split('\n');
+        let inDeps = false;
+        for (const line of lines) {
+          if (/^depends_on:\s*$/u.test(line)) {
+            inDeps = true;
+            continue;
+          }
+          if (inDeps) {
+            const m = line.match(/^\s*-\s+(\S+)/u);
+            if (m?.[1]) deps.push(m[1]);
+            else if (line.trim() !== '') inDeps = false;
+          }
+        }
+      }
+      nodes.push({ id, archived, dependsOn: deps });
+    }
+  };
+  scan(`${root}/${CHANGES_DIR}`, false, false);
+  // archived nodes appear only when referenced by an active depends_on
+  const referenced = new Set(nodes.flatMap((n) => n.dependsOn));
+  const archiveDir = `${root}/${CHANGES_DIR}/archive`;
+  if (io.exists(archiveDir) && io.isDirectory(archiveDir)) {
+    for (const name of io.listDir(archiveDir).toSorted()) {
+      if (!/\d{4}-\d{2}-\d{2}-/u.test(name)) continue;
+      const id = name.replace(/^\d{4}-\d{2}-\d{2}-/u, '');
+      if (!referenced.has(id)) continue;
+      // archived nodes keep their real depends_on — v1 emits their edges too
+      const deps: string[] = [];
+      const proposal = `${archiveDir}/${name}/proposal.md`;
+      if (io.exists(proposal)) {
+        const fm = io.readText(proposal).match(/^---\n([\s\S]*?)\n---/u);
+        let inDeps = false;
+        for (const line of fm?.[1]?.split('\n') ?? []) {
+          if (/^depends_on:\s*$/u.test(line)) {
+            inDeps = true;
+            continue;
+          }
+          if (inDeps) {
+            const m = line.match(/^\s*-\s+(\S+)/u);
+            if (m?.[1]) deps.push(m[1]);
+            else if (line.trim() !== '') inDeps = false;
+          }
+        }
+      }
+      nodes.push({ id, archived: true, dependsOn: deps });
+    }
+  }
+  return nodes;
+}
+
+export function graphMermaid(io: GraphFsIo, root: string): string[] {
+  const nodes = collectNodes(io, root);
+  const lines: string[] = ['flowchart TD'];
+  for (const node of nodes) {
+    const nid = node.id.replaceAll('-', '_');
+    const label = node.archived ? `${node.id} ✓ done` : node.id;
+    lines.push(`    ${nid}["${label}"]${node.archived ? ':::archived' : ''}`);
+  }
+  const byId = new Set(nodes.map((n) => n.id));
+  for (const node of nodes) {
+    for (const dep of node.dependsOn) {
+      // edges render only when both endpoints are shown nodes
+      if (!byId.has(dep)) continue;
+      lines.push(`    ${node.id.replaceAll('-', '_')} -->|depends on| ${dep.replaceAll('-', '_')}`);
+    }
+  }
+  lines.push('    classDef archived fill:#d4edda,stroke:#28a745,color:#333');
+  return lines;
+}

package/src/report/show.ts

@@ -0,0 +1,138 @@
+import { readBinding } from '../change/frontmatter.ts';
+import { CHANGES_DIR } from '../change/lifecycle.ts';
+import { isCleanTree, currentBranch, makeSpawnGit } from '../git/spawnGit.ts';
+import { discoverSpecs, type DiscoveryIo } from '../validation/discover.ts';
+/**
+ * show change JSON (peripheral-commands capability, r21): v1 field set and
+ * gate structure (clean-tree / on-bound-branch / stage-complete /
+ * specs-landed / tasks-done / validate). Object keys are inserted in v1's
+ * order; consumers compare structurally.
+ */
+import { validateAllSpecs } from '../validation/validate.ts';
+import { stageFor, type ChangeFsIo } from './collect.ts';
+
+export interface ShowFsIo extends ChangeFsIo {
+  readText(path: string): string;
+}
+
+export interface ShowDeps {
+  io: ShowFsIo;
+  discovery: DiscoveryIo;
+  root: string;
+  specsDir: string;
+  now: Date;
+}
+
+function parseTasks(md: string): { completed: number; total: number } {
+  let completed = 0;
+  let total = 0;
+  for (const line of md.split('\n')) {
+    const m = line.match(/^\s*-\s+\[( |x|X)\]/u);
+    if (m) {
+      total += 1;
+      if (m[1] !== ' ') completed += 1;
+    }
+  }
+  return { completed, total };
+}
+
+function existsSyncLike(deps: ShowDeps, p: string): boolean {
+  return deps.io.exists(p) || deps.discovery.exists(p);
+}
+
+export function showChangeJson(deps: ShowDeps, id: string): Record<string, unknown> {
+  const { io, discovery, root, now } = deps;
+  const dir = `${root}/${CHANGES_DIR}/${id}`;
+  const proposalPath = `${dir}/proposal.md`;
+  if (!io.exists(proposalPath)) throw new Error(`change not found: ${id}`);
+
+  const proposal = io.readText(proposalPath);
+  const titleMatch = proposal.match(/^#\s+(.*)$/mu);
+  const hasDesign = io.exists(`${dir}/design.md`);
+  const hasTasks = io.exists(`${dir}/tasks.md`);
+  const binding = readBinding(proposal);
+  const stage = stageFor(hasDesign, hasTasks, binding !== null);
+
+  const artifacts = ['proposal.md', 'design.md', 'tasks.md'].filter((f) =>
+    io.exists(`${dir}/${f}`),
+  );
+  const { completed, total } = hasTasks
+    ? parseTasks(io.readText(`${dir}/tasks.md`))
+    : { completed: 0, total: 0 };
+
+  const git = makeSpawnGit(root);
+  const cleanTree = isCleanTree(git);
+  const onBoundBranch = binding !== null && currentBranch(git) === binding.branch;
+
+  // specs landing: bound changes must have touched llmanspec/specs/ since base
+  let specsLanded = false;
+  if (binding !== null) {
+    const touched =
+      git.runOpt(['diff', '--name-only', `${binding.baseBranch}...${binding.branch}`]) ?? '';
+    specsLanded = touched.includes('llmanspec/specs/');
+  }
+  // needs_specs_change is an explicit frontmatter declaration (default true)
+  const fmMatch = proposal.match(/^---\n([\s\S]*?)\n---/u);
+  const declaredNeeds = fmMatch?.[1]?.match(/^needs_specs_change:\s*(true|false)\s*$/mu)?.[1];
+  const needsSpecsChange = declaredNeeds !== undefined ? declaredNeeds === 'true' : true;
+
+  const tasksDone = total > 0 && completed >= total;
+  const specReport = validateAllSpecs(discoverSpecs(deps.specsDir, discovery), {
+    exists: (p: string) => existsSyncLike(deps, p),
+  });
+  const validateOk = !specReport.failed && (total === 0 || tasksDone);
+
+  const stageComplete = stage === 'full';
+
+  const gateChecks = [
+    {
+      name: 'clean-tree',
+      pass: cleanTree,
+      hint: cleanTree ? '' : 'commit/stash before change start',
+    },
+    {
+      name: 'on-bound-branch',
+      pass: onBoundBranch,
+      hint: onBoundBranch ? '' : 'change is not attached; run `llman sdd change start <id>`',
+    },
+    {
+      name: 'stage-complete',
+      pass: stageComplete,
+      hint: stageComplete ? '' : `add ${!hasDesign ? 'design.md' : 'tasks.md'} (current: ${stage})`,
+    },
+    {
+      name: 'specs-landed',
+      pass: specsLanded,
+      hint: specsLanded
+        ? ''
+        : 'edit live specs on the bound branch and commit (or needs_specs_change: false)',
+    },
+    {
+      name: 'tasks-done',
+      pass: tasksDone,
+      hint: tasksDone ? '' : `${total - completed} unchecked tasks`,
+    },
+    {
+      name: 'validate',
+      pass: validateOk,
+      hint: validateOk ? '' : 'fix issues reported by `llman sdd validate <id> --strict`',
+    },
+  ];
+  void now;
+
+  return {
+    id,
+    path: id,
+    title: titleMatch?.[1]?.trim() ?? '',
+    stage,
+    artifacts,
+    readyToImplement: gateChecks.every((g) => g.pass),
+    specsLanded,
+    needsSpecsChange,
+    attached: binding !== null,
+    deltaCount: 0,
+    deltas: [] as string[],
+    gateChecks,
+    matchedViaPrefix: false,
+  };
+}

package/src/report/specHelpers.ts

@@ -0,0 +1,63 @@
+import { parseCapability } from '../spec/parser.ts';
+/**
+ * Spec authoring helpers (peripheral-commands capability, r22):
+ * skeleton generation + global next req id. Pure, IO injected.
+ */
+import { localeFallbacks } from '../templates/locale.ts';
+
+export interface SpecHelperIo {
+  exists(path: string): boolean;
+  readText(path: string): string;
+  writeText(path: string, content: string): void;
+  mkdirp(path: string): void;
+  isDirectory(path: string): boolean;
+  listDir(path: string): string[];
+}
+
+/** Scan all specs under `specsDir` for @req:rN TAGS (not step text) and return the next free id. */
+export function nextReqId(io: SpecHelperIo, specsDir: string): string {
+  let max = 0;
+  const walk = (dir: string): void => {
+    if (!io.exists(dir)) return;
+    for (const name of io.listDir(dir)) {
+      const full = `${dir}/${name}`;
+      if (name.endsWith('.feature')) {
+        const doc = parseCapability(io.readText(full), full);
+        for (const scenario of doc.scenarios) {
+          for (const reqId of scenario.reqIds) {
+            max = Math.max(max, Math.trunc(Number(reqId.replace(/^r/u, ''))));
+          }
+        }
+      } else if (io.isDirectory(full)) {
+        walk(full);
+      }
+    }
+  };
+  walk(specsDir);
+  return `r${max + 1}`;
+}
+
+export function skeletonContent(capability: string, reqId: string, locale: string): string {
+  const zh = localeFallbacks(locale)[0] === 'zh-Hans';
+  const header = zh
+    ? `# language: zh-CN\n# capability: ${capability}\n# purpose: TODO: 一句话描述该能力与其目的。\n# scope: src/`
+    : `# language: en\n# capability: ${capability}\n# purpose: TODO: Describe this capability and its purpose.\n# scope: src/`;
+  const feature = zh ? `功能: ${capability}` : `Feature: ${capability}`;
+  const scenario = zh ? '场景: TODO-rule' : 'Scenario: TODO-rule';
+  return `${header}\n\n${feature}\n\n  @req:${reqId} @human\n  ${scenario}\n    System MUST ...\n`;
+}
+
+/** `spec skeleton <cap>`: write llmanspec/specs/<cap>.feature + scaffold scope dir. */
+export function scaffoldSpec(
+  io: SpecHelperIo,
+  specsDir: string,
+  capability: string,
+  locale: string,
+): string {
+  const reqId = nextReqId(io, specsDir);
+  const path = `${specsDir}/${capability}.feature`;
+  if (io.exists(path)) throw new Error(`spec already exists: ${path}`);
+  io.mkdirp('src/');
+  io.writeText(path, skeletonContent(capability, reqId, locale));
+  return path;
+}

package/src/report/specs.ts

@@ -0,0 +1,79 @@
+/**
+ * Specs listing (peripheral-commands capability, r20/r21): morphology counts
+ * aligned with v1 — rules = @human scenarios; enforced = rules carrying an
+ * @req link that has an executable acceptance scenario; pending = the rest.
+ */
+import type { CapabilityDoc, ScenarioIR } from '../spec/ir.ts';
+import type { SpecEntry } from '../validation/validate.ts';
+
+export interface SpecMorphology {
+  ruleCount: number;
+  ruleEnforcedCount: number;
+  ruleManualCount: number;
+  rulePendingCount: number;
+  acceptanceCount: number;
+  orphanAcceptanceCount: number;
+}
+
+export interface SpecSummary {
+  id: string;
+  title: string;
+  purpose: string;
+  validScope: string[];
+  requirementCount: number;
+  health: null;
+  staleness: null;
+  morphology: SpecMorphology;
+}
+
+function morphologyOf(doc: CapabilityDoc): SpecMorphology {
+  const rules = doc.scenarios.filter((s) => s.classification === 'human');
+  const acceptance = doc.scenarios.filter((s) => s.classification === 'executable');
+  const acceptanceReqIds = new Set(acceptance.flatMap((s) => s.reqIds));
+  const enforced = rules.filter((r) => r.reqIds.some((id) => acceptanceReqIds.has(id)));
+  const orphan = acceptance.filter((s) => s.reqIds.length === 0);
+  return {
+    ruleCount: rules.length,
+    ruleEnforcedCount: enforced.length,
+    ruleManualCount: rules.filter((r: ScenarioIR) => r.manual).length,
+    rulePendingCount: rules.length - enforced.length,
+    acceptanceCount: acceptance.length,
+    orphanAcceptanceCount: orphan.length,
+  };
+}
+
+export function collectSpecs(entries: readonly SpecEntry[]): SpecSummary[] {
+  return entries.map((e) => ({
+    id: e.doc.header.capability ?? e.fileName,
+    title: e.doc.header.capability ?? e.fileName,
+    purpose: e.doc.header.purpose ?? '',
+    validScope: (e.doc.header.scope ?? '')
+      .split(',')
+      .map((s) => s.trim())
+      .filter((s) => s !== ''),
+    requirementCount: morphologyOf(e.doc).ruleCount,
+    health: null,
+    staleness: null,
+    morphology: morphologyOf(e.doc),
+  }));
+}
+
+function pad(s: string, width: number): string {
+  return s.length >= width ? s : s + ' '.repeat(width - s.length);
+}
+
+export function renderSpecsList(summaries: readonly SpecSummary[]): string[] {
+  const lines = ['Available specs:'];
+  const idWidth = Math.max(...summaries.map((s) => s.id.length), 0) + 2;
+  for (const s of summaries) {
+    const m = s.morphology;
+    lines.push(
+      `  ${pad(s.id, idWidth)}rules ${m.ruleCount}  enforced ${m.ruleEnforcedCount}  manual ${m.ruleManualCount}  pending ${m.rulePendingCount}  acceptance ${m.acceptanceCount}`,
+    );
+  }
+  return lines;
+}
+
+export function renderSpecsJson(summaries: readonly SpecSummary[]): string {
+  return JSON.stringify(summaries, null, 2);
+}

package/src/review/review.ts

@@ -0,0 +1,142 @@
+/**
+ * Review aggregation (review-freeze capability, r23): five-signal review over
+ * spec IR + validate sweep. Port of v1 sdd/review.rs observable contract.
+ */
+import { validateAllSpecs, type SpecEntry, type SpecIo } from '../validation/validate.ts';
+
+export type ReviewKind = 'pending' | 'manual' | 'unbound' | 'stale' | 'locked' | 'validate';
+
+export interface ReviewSignal {
+  kind: ReviewKind;
+  capability: string;
+  count: number;
+  detail: string;
+}
+
+export interface TagBinding {
+  kind: 'tags';
+  tags: string[];
+}
+
+export interface ReviewInput {
+  entries: readonly SpecEntry[];
+  /** config bdd.bindings (tags sources); null/empty = every acceptance unbound. */
+  bindings: readonly TagBinding[] | null;
+  /** Active changes currently carrying a branch binding. */
+  boundChangeCount: number;
+  /** Active change summaries for the strict sweep (pending tasks → FAIL). */
+  activeChanges?: readonly { name: string; completedTasks: number; totalTasks: number }[];
+}
+
+export interface ReviewResult {
+  signals: ReviewSignal[];
+  summary: { criticalCount: number; warningCount: number };
+  lines: string[];
+  exitCode: number;
+}
+
+function executableBound(
+  scenarioTags: readonly string[],
+  bindings: readonly TagBinding[] | null,
+): boolean {
+  if (!bindings || bindings.length === 0) return false;
+  const has = (t: string): boolean => scenarioTags.includes(t);
+  return bindings.some((b) => (b.kind === 'tags' ? b.tags.every((t) => has(t)) : false));
+}
+
+export function buildReview(input: ReviewInput, io: SpecIo): ReviewResult {
+  const { entries, bindings, boundChangeCount } = input;
+  const strictChangeFails = (input.activeChanges ?? []).filter(
+    (c) => c.totalTasks > 0 && c.completedTasks < c.totalTasks,
+  );
+  const signals: ReviewSignal[] = [];
+  let critical = 0;
+  let warning = 0;
+  const push = (kind: ReviewKind, capability: string, count: number, detail = ''): void => {
+    signals.push({ kind, capability, count, detail });
+    if (kind === 'validate') {
+      critical += count;
+    } else if (count > 0) {
+      warning += count;
+    }
+  };
+
+  const sweep = validateAllSpecs(entries, io);
+  const sorted = [...entries].toSorted((a, b) => a.fileName.localeCompare(b.fileName));
+
+  for (const entry of sorted) {
+    const cap = entry.doc.header.capability ?? entry.fileName;
+    const rules = entry.doc.scenarios.filter((s) => s.classification === 'human');
+    const acceptance = entry.doc.scenarios.filter((s) => s.classification === 'executable');
+    const acceptanceReqIds = new Set(acceptance.flatMap((s) => s.reqIds));
+    const pending = rules.filter((r) => !r.reqIds.some((id) => acceptanceReqIds.has(id)));
+    const manual = rules.filter((r) => r.manual);
+    const unbound = acceptance.filter((s) => !executableBound(s.tags, bindings));
+
+    push('pending', cap, pending.length);
+    push('manual', cap, manual.length);
+    push('unbound', cap, unbound.length);
+    // staleness is deferred in v2 — placeholder signal (golden normalizes it)
+    push('stale', cap, 0, 'DEFERRED');
+  }
+
+  const failed = sweep.verdicts.filter((v) => !v.ok);
+  // v1 sweep = `validate --all --strict --no-check`: pending tasks escalate a
+  // change to FAIL, and that feeds the review critical count.
+  for (const c of strictChangeFails) {
+    failed.push({
+      fileName: c.name,
+      capability: c.name,
+      ok: false,
+      items: [
+        {
+          level: 'ERROR',
+          id: `${c.name}/tasks`,
+          message: `${c.totalTasks - c.completedTasks} unchecked tasks`,
+        },
+      ],
+    });
+  }
+  // v1 parity: `count` is the removed locked-rule-confirmation concept (always
+  // 0 now); the detail text carries the bound-change count separately.
+  push(
+    'locked',
+    '-',
+    0,
+    `${boundChangeCount} bound change(s); inspect with \`llman sdd change diff <id>\``,
+  );
+  push(
+    'validate',
+    '-',
+    failed.length,
+    failed.length > 0 ? 'validate --all failed; run `llman sdd validate --all` for details' : 'ok',
+  );
+
+  const warningCount = signals
+    .filter((s) => s.kind !== 'validate' && s.kind !== 'locked')
+    .reduce((acc, s) => acc + s.count, 0);
+  const criticalCount = failed.length;
+
+  const lines: string[] = [`Review: critical=${criticalCount} warning=${warningCount}`];
+  for (const cap of sorted.map((e) => e.doc.header.capability ?? e.fileName)) {
+    for (const kind of ['pending', 'manual', 'unbound', 'stale'] as const) {
+      const s = signals.find((x) => x.kind === kind && x.capability === cap);
+      if (!s) continue;
+      lines.push(`${kind}: ${cap} (${s.count})`);
+      if (s.detail !== '') lines.push(`  - ${s.detail}`);
+    }
+  }
+  for (const kind of ['locked', 'validate'] as const) {
+    const s = signals.find((x) => x.kind === kind);
+    if (!s) continue;
+    lines.push(`${kind}: ${s.capability} (${s.count})`);
+    if (s.detail !== '') lines.push(`  - ${s.detail}`);
+  }
+
+  return {
+    signals,
+    summary: { criticalCount, warningCount },
+    lines,
+    exitCode: criticalCount > 0 ? 1 : 0,
+  };
+}