@llman-sdd/core 0.1.0

package/src/spec/ir.ts

@@ -0,0 +1,43 @@
+/**
+ * Spec IR (spec-parsing capability): pure data shapes produced by
+ * parseCapability() and consumed by validation (Phase 3) and downstream
+ * commands. No IO of any kind lives here.
+ */
+
+export interface CapabilityHeader {
+  capability: string | null;
+  purpose: string | null;
+  scope: string | null;
+}
+
+export type ScenarioClassification = 'human' | 'executable' | 'unclassified';
+
+export interface ScenarioIR {
+  name: string;
+  /** Tag names without the leading `@`. */
+  tags: string[];
+  /** `@req:rN` links, normalized to `rN`. */
+  reqIds: string[];
+  classification: ScenarioClassification;
+  manual: boolean;
+  /** Rule statement (description lines, trimmed) + step texts for executables. */
+  statement: string;
+  stepCount: number;
+  /** Executable-scenario steps with their keyword kinds (context-index tree). */
+  steps: { kind: 'given' | 'when' | 'then'; text: string }[];
+}
+
+export interface SpecStructuralError {
+  /** Machine-ish anchor, e.g. `missing-header:purpose` or `scenario:规则样例`. */
+  code: string;
+  message: string;
+}
+
+export interface CapabilityDoc {
+  fileName: string;
+  header: CapabilityHeader;
+  featureName: string;
+  language: string;
+  scenarios: ScenarioIR[];
+  errors: SpecStructuralError[];
+}

package/src/spec/parser.ts

@@ -0,0 +1,171 @@
+/**
+ * Single-track capability .feature parsing (spec-parsing capability).
+ *
+ * Language fallback chain (r7): start with the `en` matcher — a
+ * `# language:` header switches dialect automatically mid-scan; on failure
+ * retry with the zh-CN matcher (Chinese keywords without a header); only then
+ * surface a parse error. locale zh-Hans maps to gherkin zh-CN.
+ */
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from '@cucumber/gherkin';
+import type { GherkinDocument } from '@cucumber/messages';
+
+import type { CapabilityDoc, CapabilityHeader, ScenarioIR, SpecStructuralError } from './ir.ts';
+
+export class SpecParseError extends Error {}
+
+let nodeCounter = 0;
+
+export function localeToGherkinLang(locale: string): string {
+  return locale === 'zh-Hans' ? 'zh-CN' : locale;
+}
+
+const makeIdGenerator = (): (() => string) => {
+  const base = ++nodeCounter;
+  let i = 0;
+  return () => `n-${base}-${++i}`;
+};
+
+export function parseFeatureSource(source: string): { doc: GherkinDocument; language: string } {
+  let lastError: unknown = null;
+  for (const dialect of ['en', 'zh-CN'] as const) {
+    try {
+      const parser = new Parser(
+        new AstBuilder(makeIdGenerator()),
+        new GherkinClassicTokenMatcher(dialect),
+      );
+      return { doc: parser.parse(source), language: dialect };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw new SpecParseError(
+    `gherkin parse failed (tried en, zh-CN): ${lastError instanceof Error ? lastError.message : String(lastError)}`,
+  );
+}
+
+const REQ_TAG_RE = /^@?req:(r\d+)$/u;
+
+/** Gherkin keyword (zh-CN + en) → step kind; And/But/* inherit via fallback. */
+function stepKeywordToKind(keyword: string): 'given' | 'when' | 'then' {
+  const kw = keyword.trim();
+  if (/^(假如|Given)/iu.test(kw)) return 'given';
+  if (/^(当|When)/iu.test(kw)) return 'when';
+  if (/^(那么|Then)/iu.test(kw)) return 'then';
+  return 'given';
+}
+const HEADER_RE = /^#\s*(capability|purpose|scope):\s*(.*)$/u;
+
+function extractHeader(source: string): CapabilityHeader {
+  const header: CapabilityHeader = { capability: null, purpose: null, scope: null };
+  for (const line of source.split('\n')) {
+    if (line.trim() === '') continue;
+    if (!line.trimStart().startsWith('#')) break;
+    const m = line.trimStart().match(HEADER_RE);
+    if (m?.[1]) {
+      const key = m[1] as 'capability' | 'purpose' | 'scope';
+      header[key] = m[2]?.trim() ?? null;
+    }
+  }
+  return header;
+}
+
+function classify(tags: string[]): {
+  classification: ScenarioIR['classification'];
+  manual: boolean;
+  errors: SpecStructuralError[];
+  name: string;
+} {
+  const errors: SpecStructuralError[] = [];
+  const has = (t: string): boolean => tags.includes(t);
+  const human = has('human');
+  const executable = has('executable');
+  const manual = has('manual');
+  const label = tags.join(',');
+
+  if (manual && !human) {
+    errors.push({
+      code: 'tag:manual-orphan',
+      message: `@manual 必须与 @human 同用(tags: ${label})`,
+    });
+  }
+  if (human && executable) {
+    errors.push({
+      code: 'tag:mutually-exclusive',
+      message: `@human 与 @executable 互斥(tags: ${label})`,
+    });
+  }
+  const classification: ScenarioIR['classification'] = human
+    ? 'human'
+    : executable
+      ? 'executable'
+      : 'unclassified';
+  return { classification, manual, errors, name: label };
+}
+
+/** Parse one capability .feature source into the single-track IR. */
+export function parseCapability(source: string, fileName = '<inline>'): CapabilityDoc {
+  const errors: SpecStructuralError[] = [];
+  const header = extractHeader(source);
+  for (const key of ['capability', 'purpose', 'scope'] as const) {
+    if (header[key] === null) {
+      errors.push({ code: `missing-header:${key}`, message: `missing # ${key}: header comment` });
+    }
+  }
+
+  const { doc, language } = parseFeatureSource(source);
+  const feature = doc.feature;
+  const featureName = feature?.name ?? '';
+  const scenarios: ScenarioIR[] = [];
+
+  for (const child of feature?.children ?? []) {
+    const rule = child.rule;
+    if (rule && rule.children.some((c) => c.scenario)) {
+      errors.push({
+        code: 'rule:nested-scenario',
+        message: `Rule 块内嵌场景被拒绝(rule: ${rule.name})`,
+      });
+      continue;
+    }
+    const scenario = child.scenario;
+    if (!scenario) continue;
+
+    const tags = scenario.tags.map((t) => t.name.replace(/^@/u, ''));
+    const reqIds = scenario.tags
+      .map((t) => t.name.match(REQ_TAG_RE)?.[1])
+      .filter((v): v is string => v !== undefined);
+
+    const kind = classify(tags);
+    errors.push(...kind.errors);
+
+    const description = (scenario.description ?? '')
+      .split('\n')
+      .map((l) => l.trim())
+      .filter((l) => l !== '');
+    const stepTexts = scenario.steps.map((s) => s.text.trim());
+    const statement = [...description, ...stepTexts].join('\n');
+    const steps = scenario.steps.map((s) => ({
+      kind: stepKeywordToKind(s.keyword),
+      text: s.text.trim(),
+    }));
+
+    if (kind.classification === 'human' && !/\bMUST\b|\bSHALL\b/u.test(statement)) {
+      errors.push({
+        code: 'rule:missing-must-word',
+        message: `@human 规则场景描述必须含 MUST/SHALL(scenario: ${scenario.name})`,
+      });
+    }
+
+    scenarios.push({
+      name: scenario.name,
+      tags,
+      reqIds,
+      classification: kind.classification,
+      manual: kind.manual,
+      statement,
+      stepCount: stepTexts.length,
+      steps,
+    });
+  }
+
+  return { fileName, header, featureName, language, scenarios, errors };
+}

package/src/spec/reqRegistry.ts

@@ -0,0 +1,38 @@
+/**
+ * Global rN registry (spec-parsing capability): @req:rN ids form a single
+ * global namespace across all capability specs; duplicates are reported with
+ * the conflicting file pairs.
+ */
+import type { CapabilityDoc } from './ir.ts';
+
+export interface RegistryDuplicate {
+  reqId: string;
+  files: string[];
+}
+
+export interface ReqRegistry {
+  /** reqId → files referencing it (sorted). */
+  byId: Map<string, string[]>;
+  duplicates: RegistryDuplicate[];
+}
+
+export function buildReqRegistry(
+  docs: readonly { fileName: string; doc: CapabilityDoc }[],
+): ReqRegistry {
+  const byId = new Map<string, string[]>();
+  for (const { fileName, doc } of docs) {
+    for (const scenario of doc.scenarios) {
+      for (const reqId of scenario.reqIds) {
+        const files = byId.get(reqId) ?? [];
+        if (!files.includes(fileName)) files.push(fileName);
+        byId.set(reqId, files);
+      }
+    }
+  }
+  const duplicates: RegistryDuplicate[] = [];
+  for (const [reqId, files] of byId) {
+    if (files.length > 1) duplicates.push({ reqId, files: files.toSorted() });
+  }
+  duplicates.sort((a, b) => a.reqId.localeCompare(b.reqId));
+  return { byId, duplicates };
+}

package/src/templates/engine.ts

@@ -0,0 +1,51 @@
+/**
+ * Template engine (init-generators capability, r17): nunjucks adapter with
+ * minijinja-compatible semantics used by v1 — string-only globals, undefined
+ * renders empty (Lenient), nested `unit(id)` expansion capped at 32, and
+ * trailing whitespace trimmed from the final product.
+ */
+import * as nunjucks from 'nunjucks';
+
+export const MAX_UNIT_NESTING_DEPTH = 32;
+
+export type UnitRegistry = Map<string, string>;
+
+export class MissingUnitError extends Error {
+  constructor(id: string) {
+    super(`missing template unit '${id}'`);
+    this.name = 'MissingUnitError';
+  }
+}
+
+export function renderWithUnits(
+  raw: string,
+  units: UnitRegistry,
+  vars: Record<string, string>,
+  depth = 0,
+): string {
+  if (depth > MAX_UNIT_NESTING_DEPTH) {
+    throw new Error(`unit nesting exceeded ${MAX_UNIT_NESTING_DEPTH}`);
+  }
+  // minijinja keep_trailing_newline=false: a single trailing newline of the
+  // template SOURCE is stripped before rendering (v1 parity).
+  const source = raw.replace(/\n$/u, '').replace(/\r\n$/u, '');
+  const env = new nunjucks.Environment(null, { autoescape: false });
+  for (const [key, value] of Object.entries(vars)) {
+    env.addGlobal(key, value);
+  }
+  env.addGlobal('unit', (id: string): string => {
+    const content = units.get(id);
+    if (content === undefined) throw new MissingUnitError(id);
+    return renderWithUnits(content, units, vars, depth + 1);
+  });
+  return env.renderString(source, {});
+}
+
+/** Render a template product: lenient render + trailing-whitespace trim. */
+export function renderTemplate(
+  raw: string,
+  units: UnitRegistry,
+  vars: Record<string, string>,
+): string {
+  return renderWithUnits(raw, units, vars, 0).trimEnd();
+}

package/src/templates/locale.ts

@@ -0,0 +1,24 @@
+/**
+ * Locale normalization + fallback chain (init-generators capability, r18).
+ * Port of v1 config.rs normalize_locale / locale_fallbacks.
+ */
+export function normalizeLocale(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed === '') return 'en';
+  const lower = trimmed.toLowerCase();
+  if (lower === 'zh' || lower.startsWith('zh-hans') || lower === 'zh-cn') return 'zh-Hans';
+  if (lower.startsWith('en')) return 'en';
+  return trimmed;
+}
+
+export function localeFallbacks(locale: string): string[] {
+  const normalized = normalizeLocale(locale);
+  const locales: string[] = [normalized];
+  const dash = normalized.indexOf('-');
+  if (dash !== -1) {
+    const lang = normalized.slice(0, dash);
+    if (!locales.includes(lang)) locales.push(lang);
+  }
+  if (!locales.includes('en')) locales.push('en');
+  return locales;
+}

package/src/templates/skills.ts

@@ -0,0 +1,165 @@
+import type { SddConfig } from '../config/schema.ts';
+import { renderTemplate, type UnitRegistry } from './engine.ts';
+/**
+ * Skills rendering + init orchestration (init-generators capability, r19).
+ * Port of v1 templates.rs / update_skills.rs / init.rs semantics.
+ */
+import { localeFallbacks } from './locale.ts';
+
+export const DEFAULT_SKILL_FILES: readonly string[] = [
+  'llman-sdd-explore.md',
+  'llman-sdd-propose.md',
+  'llman-sdd-draft.md',
+  'llman-sdd-apply.md',
+  'llman-sdd-verify.md',
+  'llman-sdd-quick.md',
+  'llman-sdd-specs-compact.md',
+  'llman-sdd-archive.md',
+  'llman-sdd-graph.md',
+  'llman-sdd-apply-cycle.md',
+];
+
+export const OPTIONAL_SKILL_FILES: readonly string[] = [
+  'llman-sdd-continue.md',
+  'llman-sdd-ff.md',
+  'llman-sdd-validate.md',
+  'llman-sdd-arch-review.md',
+  'llman-sdd-wayfinder.md',
+  'llman-sdd-research.md',
+];
+
+export const UNIT_FILES: readonly string[] = [
+  'skills/validation-hints.md',
+  'skills/human-readable-summary.md',
+  'skills/git-native-flow.md',
+  'skills/git-native-flow-brief.md',
+  'skills/stage-guard.md',
+  'skills/ethics-governance.md',
+  'spec/feature-contract.md',
+  'skills/structured-protocol.md',
+  'workflow/archive-freeze-guidance.md',
+];
+
+export const ETHICS_KEYS: readonly string[] = [
+  'ethics.risk_level',
+  'ethics.prohibited_actions',
+  'ethics.required_evidence',
+  'ethics.refusal_contract',
+  'ethics.escalation_policy',
+];
+
+/** Framework-derived run_command (v1 config.rs effective_run_command). */
+export function effectiveRunCommand(bdd: NonNullable<SddConfig['bdd']>): string {
+  if (bdd.run_command) return bdd.run_command;
+  switch (bdd.framework ?? '') {
+    case 'pytest-bdd':
+      return 'pytest {feature_dir} -k {feature_name} -v';
+    case 'rstest-bdd':
+      return 'cargo test --features bdd';
+    case 'cucumber-js':
+      return 'npx cucumber-js {feature_path}';
+    case 'behave':
+      return 'behave {feature_path}';
+    default:
+      return "echo 'No run_command configured. Set bdd.run_command in config.yaml'";
+  }
+}
+
+/** All-string globals (v1 BTreeMap<String, String> semantics). */
+export function buildTemplateVars(config: SddConfig, version: string): Record<string, string> {
+  const vars: Record<string, string> = { llman_version: version };
+  if (config.bdd) {
+    vars['bdd_enabled'] = 'true';
+    vars['bdd_framework'] = config.bdd.framework ?? '';
+    if (config.bdd.feature_dir) vars['bdd_feature_dir'] = config.bdd.feature_dir;
+    vars['bdd_run_command'] = effectiveRunCommand(config.bdd);
+    if (config.bdd.default_language) vars['bdd_default_language'] = config.bdd.default_language;
+    if (config.bdd.verify_prompt) vars['bdd_verify_prompt'] = config.bdd.verify_prompt;
+  }
+  const extras = new Set<string>(config.extra_skills ?? []);
+  for (const name of OPTIONAL_SKILL_FILES) {
+    const stem = name.replace(/\.md$/u, '');
+    const key = `extra_skill_${stem.replace(/^llman-sdd-/u, '').replaceAll('-', '_')}`;
+    if (extras.has(stem)) vars[key] = 'true';
+  }
+  return vars;
+}
+
+export interface TemplateIo {
+  exists(path: string): boolean;
+  readText(path: string): string;
+}
+
+/** Locale-fallback resource load: first locale in the chain that has the file. */
+export function loadLocaleResource(
+  io: TemplateIo,
+  templatesRoot: string,
+  locales: readonly string[],
+  relativePath: string,
+): string | null {
+  for (const locale of locales) {
+    const path = `${templatesRoot}/${locale}/${relativePath}`;
+    if (io.exists(path)) return io.readText(path);
+  }
+  return null;
+}
+
+export function loadUnitRegistry(
+  io: TemplateIo,
+  templatesRoot: string,
+  locales: readonly string[],
+): UnitRegistry {
+  const units: UnitRegistry = new Map();
+  for (const unitFile of UNIT_FILES) {
+    const id = unitFile.replace(/\.md$/u, '');
+    const content = loadLocaleResource(io, templatesRoot, locales, `units/${unitFile}`);
+    if (content !== null) units.set(id, content);
+  }
+  return units;
+}
+
+export interface SkillTemplate {
+  name: string;
+  content: string;
+}
+
+export function skillCandidates(config: SddConfig): string[] {
+  const extras: readonly string[] = config.extra_skills ?? [];
+  return [
+    ...DEFAULT_SKILL_FILES,
+    ...OPTIONAL_SKILL_FILES.filter((f) => {
+      const stem = f.replace(/\.md$/u, '');
+      return extras.includes(stem);
+    }),
+  ];
+}
+
+export function loadSkillTemplates(
+  io: TemplateIo,
+  templatesRoot: string,
+  config: SddConfig,
+  vars: Record<string, string>,
+): SkillTemplate[] {
+  const locales = localeFallbacks(config.locale);
+  const units = loadUnitRegistry(io, templatesRoot, locales);
+  const templates: SkillTemplate[] = [];
+  for (const skillFile of skillCandidates(config)) {
+    const raw = loadLocaleResource(io, templatesRoot, locales, `skills/${skillFile}`);
+    if (raw === null) {
+      throw new Error(`template not found: skills/${skillFile}`);
+    }
+    templates.push({ name: skillFile, content: renderTemplate(raw, units, vars) });
+  }
+  return templates;
+}
+
+/** Ethics gate: every rendered skill must carry all five governance keys. */
+export function enforceEthicsGovernance(templates: readonly SkillTemplate[]): void {
+  for (const t of templates) {
+    for (const key of ETHICS_KEYS) {
+      if (!t.content.includes(key)) {
+        throw new Error(`missing required ethics governance key '${key}' in template '${t.name}'`);
+      }
+    }
+  }
+}

package/src/validation/discover.ts

@@ -0,0 +1,30 @@
+import { parseCapability } from '../spec/parser.ts';
+/**
+ * Spec discovery (validation capability): walk llmanspec/specs/** for
+ * .feature files via injected IO — core stays filesystem-free.
+ */
+import type { SpecEntry } from './validate.ts';
+
+export interface DiscoveryIo {
+  exists(path: string): boolean;
+  isDirectory(path: string): boolean;
+  listDir(path: string): string[];
+  readText(path: string): string;
+}
+
+export function discoverSpecs(specsDir: string, io: DiscoveryIo): SpecEntry[] {
+  const walk = (dir: string): string[] => {
+    if (!io.exists(dir) || !io.isDirectory(dir)) return [];
+    const out: string[] = [];
+    for (const name of io.listDir(dir).toSorted()) {
+      const full = dir.endsWith('/') ? `${dir}${name}` : `${dir}/${name}`;
+      if (io.isDirectory(full)) out.push(...walk(full));
+      else if (name.endsWith('.feature')) out.push(full);
+    }
+    return out;
+  };
+  return walk(specsDir).map((path) => ({
+    fileName: path,
+    doc: parseCapability(io.readText(path), path),
+  }));
+}

package/src/validation/validate.ts

@@ -0,0 +1,153 @@
+/**
+ * Validation engine (validation capability): aggregates Phase-2 parse errors
+ * plus the verdict-equivalent gates probed from v1 (r11/r12). Pure —
+ * filesystem access is injected via SpecIo.
+ */
+import type { CapabilityDoc } from '../spec/ir.ts';
+import { buildReqRegistry } from '../spec/reqRegistry.ts';
+
+export type ValidationLevel = 'ERROR' | 'WARNING' | 'INFO';
+
+export interface ValidationItem {
+  level: ValidationLevel;
+  /** Gate anchor, e.g. `t/rule/ok` or `t/valid_scope` (v1-style). */
+  id: string;
+  message: string;
+}
+
+export interface SpecEntry {
+  fileName: string;
+  doc: CapabilityDoc;
+}
+
+/** v1 wording: constraint statements must contain one of these tokens. */
+const MUST_WORD_RE = /\bMUST\b|\bSHALL\b|必须|不得|禁止/u;
+
+export interface SpecIo {
+  exists(path: string): boolean;
+}
+
+export interface SpecVerdict {
+  fileName: string;
+  capability: string;
+  ok: boolean;
+  items: ValidationItem[];
+}
+
+export interface ValidationReport {
+  verdicts: SpecVerdict[];
+  /** Report lines: `OK|FAIL spec/<cap>` entries, `[LEVEL]` details, Totals. */
+  lines: string[];
+  failed: boolean;
+}
+
+export function validateCapability(
+  entry: SpecEntry,
+  duplicatesFor: (reqId: string) => boolean,
+  io: SpecIo,
+): SpecVerdict {
+  const { doc } = entry;
+  const cap = doc.header.capability ?? entry.fileName;
+  const items: ValidationItem[] = [];
+
+  // Header gates (r12): capability header is an ERROR (v1 parity); missing
+  // purpose/scope degrade to WARNING.
+  if (doc.header.capability === null) {
+    items.push({
+      level: 'ERROR',
+      id: 'file',
+      message: 'missing `# capability:` header comment',
+    });
+  }
+  if (doc.header.purpose === null) {
+    items.push({ level: 'WARNING', id: 'file', message: 'missing `# purpose:` header comment' });
+  }
+  if (doc.header.scope === null) {
+    items.push({ level: 'WARNING', id: 'file', message: 'missing `# scope:` header comment' });
+  } else {
+    for (const p of doc.header.scope
+      .split(',')
+      .map((s) => s.trim())
+      .filter((s) => s !== '')) {
+      if (!io.exists(p)) {
+        items.push({
+          level: 'ERROR',
+          id: `${cap}/valid_scope`,
+          message: `valid_scope path(s) do not exist on disk: ${p}`,
+        });
+      }
+    }
+  }
+
+  // Structural errors from parsing (mutual exclusion, manual orphan, nested
+  // rule scenarios) — all ERROR level (v1 verdict parity). Header gates and
+  // the MUST-word gate are owned by this layer (mapped below), so the
+  // parser's duplicate findings are skipped here.
+  const OWNED_BY_THIS_LAYER = new Set(['missing-header:', 'rule:missing-must-word']);
+  for (const err of doc.errors) {
+    if ([...OWNED_BY_THIS_LAYER].some((prefix) => err.code.startsWith(prefix))) continue;
+    items.push({ level: 'ERROR', id: `${cap}/${err.code}`, message: err.message });
+  }
+
+  for (const scenario of doc.scenarios) {
+    const anchor = `${cap}/rule/${scenario.name}`;
+    if (scenario.classification === 'human') {
+      if (scenario.reqIds.length === 0) {
+        items.push({
+          level: 'ERROR',
+          id: anchor,
+          message: '@human constraint scenario must carry an @req:<req_id> tag',
+        });
+      }
+      if (!MUST_WORD_RE.test(scenario.statement)) {
+        items.push({
+          level: 'ERROR',
+          id: anchor,
+          message: 'constraint statement must contain MUST/SHALL (or 必须/不得/禁止)',
+        });
+      }
+    }
+    for (const reqId of scenario.reqIds) {
+      if (duplicatesFor(reqId)) {
+        items.push({
+          level: 'ERROR',
+          id: `${cap}/registry/${reqId}`,
+          message: `global duplicate req_id \`${reqId}\` used by multiple capabilities`,
+        });
+      }
+    }
+  }
+
+  return {
+    fileName: entry.fileName,
+    capability: cap,
+    ok: !items.some((i) => i.level === 'ERROR'),
+    items,
+  };
+}
+
+export function validateAllSpecs(entries: readonly SpecEntry[], io: SpecIo): ValidationReport {
+  const registry = buildReqRegistry(entries);
+  const duplicateIds = new Set(registry.duplicates.flatMap((d) => d.reqId));
+  // v1 parity: a structural error anywhere aborts the req_id index scan, so
+  // the duplicate gate only fires when every spec parses cleanly.
+  const structurallyClean = entries.every((e) => e.doc.errors.length === 0);
+  const duplicatesFor = (reqId: string): boolean => structurallyClean && duplicateIds.has(reqId);
+
+  const verdicts = entries.map((e) => validateCapability(e, duplicatesFor, io));
+  const failed = verdicts.some((v) => !v.ok);
+  const passed = verdicts.filter((v) => v.ok).length;
+
+  const lines: string[] = [];
+  for (const v of verdicts) {
+    lines.push(`${v.ok ? 'OK' : 'FAIL'} spec/${v.capability}`);
+    for (const item of v.items) {
+      lines.push(`  [${item.level}] ${item.id}: ${item.message}`);
+    }
+  }
+  lines.push(
+    `Totals: ${passed} passed, ${verdicts.length - passed} failed (${verdicts.length} items)`,
+  );
+
+  return { verdicts, lines, failed };
+}