mandrel 2.60.0 → 2.61.0

package/.agents/scripts/check-workflow-citations.js

@@ -1,218 +0,0 @@
-/**
- * CLI: provenance-citation **report** for workflow prose.
- *
- * Workflow documents ride resident in an executing agent's context. A
- * `(Story #1234)` aside costs the same tokens as instruction and teaches
- * the model Mandrel's own history instead of the task in front of it. The
- * citations that survive are the ones a reader must follow to act; the
- * rest belong in the commit trail and `docs/decisions.md`.
- *
- * This command counts every issue-shaped reference across
- * `.agents/workflows/**\/*.md` and prints the per-file tally. It **always
- * exits 0**: Story #5340 demoted it from a ratchet to a report and deleted
- * `baselines/workflow-citations.json` with it. The ratchet failed a rise
- * above a committed total, so a prose fix that added one pointer had to be
- * paid for with an unrelated trim in the same commit — and that is how three
- * reference sections came to describe mechanisms the code had already
- * retired. The count is still worth seeing on every change, so it stays a
- * report. See `docs/decisions.md`, ADR 20260917-5340.
- *
- * The counted token is the bare `#NNNN` form rather than the
- * `(Story|Epic|issue|refs) #NNNN` phrasing, because the same citation is
- * written both ways — `(Story #4593)` and a bare `(#4593)` — and a report
- * that only saw the prefixed form would undercount the other one.
- *
- * Flags:
- *   --root <path>      scan a different workflow root (default
- *                      `.agents/workflows`)
- *   --json             write the structured envelope to stdout
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { runAsCli } from './lib/cli-utils.js';
-
-/** Default workflow root, relative to the repository root. */
-const DEFAULT_ROOT = path.join('.agents', 'workflows');
-
-/**
- * Issue-shaped reference: a `#` followed by 3–5 digits. Narrow enough to
- * skip markdown headings and anchor links, wide enough to catch both the
- * `(Story #1234)` and bare `(#1234)` spellings of one citation.
- */
-const CITATION_RE = /#\d{3,5}\b/g;
-
-/**
- * Parse argv. Exported so unit tests can pin the parser.
- *
- * @param {string[]} argv
- * @returns {{ rootPath: string | null, json: boolean }}
- */
-export function parseArgv(argv = []) {
-  const out = { rootPath: null, json: false };
-  for (let i = 0; i < argv.length; i += 1) {
-    const flag = argv[i];
-    const next = argv[i + 1];
-    if (flag === '--root' && next && !next.startsWith('--')) {
-      out.rootPath = next;
-      i += 1;
-    } else if (flag === '--json') {
-      out.json = true;
-    }
-  }
-  return out;
-}
-
-/**
- * Recursively collect `.md` files under `rootDir`. Returns absolute paths,
- * sorted for determinism.
- *
- * @param {string} rootDir
- * @returns {string[]}
- */
-export function collectMarkdownFiles(rootDir) {
-  const out = [];
-  const walk = (dir) => {
-    let entries;
-    try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else if (entry.isFile() && entry.name.endsWith('.md')) out.push(full);
-    }
-  };
-  walk(rootDir);
-  return out.sort();
-}
-
-/**
- * Pure helper: count citations in source text.
- *
- * @param {string} source
- * @returns {number}
- */
-export function countCitations(source) {
-  return (String(source ?? '').match(CITATION_RE) ?? []).length;
-}
-
-/**
- * Count citations across a file set, relativizing paths against `cwd` so
- * the report serializes identically on every platform. Files with zero
- * citations are omitted — the report names where the tax lives.
- *
- * @param {string[]} files absolute paths
- * @param {string} cwd
- * @param {{ readFile?: (p: string) => string }} [opts]
- * @returns {{ total: number, files: Array<{ path: string, count: number }> }}
- */
-export function tallyCitations(files, cwd, { readFile } = {}) {
-  const read = readFile ?? ((p) => fs.readFileSync(p, 'utf-8'));
-  const rows = [];
-  let total = 0;
-  for (const file of files) {
-    let count;
-    try {
-      count = countCitations(read(file));
-    } catch {
-      continue;
-    }
-    if (count === 0) continue;
-    total += count;
-    rows.push({
-      path: path.relative(cwd, file).split(path.sep).join('/'),
-      count,
-    });
-  }
-  return { total, files: rows.sort((a, b) => a.path.localeCompare(b.path)) };
-}
-
-/**
- * Pure helper: render the human-readable report — one line per file that
- * carries a citation, then the total. No `+` / `-` ratchet vocabulary: there
- * is nothing to regress against.
- *
- * @param {{ total: number, files: Array<{ path: string, count: number }> }} tally
- * @returns {string}
- */
-export function renderReport(tally) {
-  const lines = tally.files.map((row) => `  ${row.path}: ${row.count}`);
-  lines.push(
-    `[workflow-citations] total=${tally.total} across ${tally.files.length} file(s) — report only, never gated`,
-  );
-  return lines.join('\n');
-}
-
-/**
- * Top-level CLI entry. Exported so tests can drive the pipeline against a
- * tmpdir fixture corpus.
- *
- * @param {{
- *   argv?: string[],
- *   cwd?: string,
- *   stdout?: { write: (s: string) => void },
- *   stderr?: { write: (s: string) => void },
- * }} [opts]
- * @returns {Promise<number>} always 0 — this is a report, not a gate
- */
-export async function runCli({
-  argv = process.argv.slice(2),
-  cwd = process.cwd(),
-  stdout = process.stdout,
-} = {}) {
-  const { rootPath, json } = parseArgv(argv);
-  const root = path.resolve(cwd, rootPath ?? DEFAULT_ROOT);
-  if (!fs.existsSync(root)) {
-    throw new Error(`[workflow-citations] workflow root not found: ${root}`);
-  }
-
-  const tally = tallyCitations(collectMarkdownFiles(root), cwd);
-
-  if (json) {
-    stdout.write(
-      `${JSON.stringify(
-        {
-          kind: 'workflow-citations-report',
-          root,
-          total: tally.total,
-          files: tally.files,
-          exitCode: 0,
-        },
-        null,
-        2,
-      )}\n`,
-    );
-    return 0;
-  }
-
-  stdout.write(`\n--- workflow-citations report ---\n`);
-  stdout.write(`${renderReport(tally)}\n`);
-  return 0;
-}
-
-async function main() {
-  return runCli();
-}
-
-runAsCli(import.meta.url, main, {
-  source: 'workflow-citations',
-  propagateExitCode: true,
-  errorPrefix: '[workflow-citations] ❌ Fatal error',
-  usage: {
-    invocation:
-      'node .agents/scripts/check-workflow-citations.js [--root <dir>] [--json]',
-    summary:
-      'Report provenance citations in workflow prose: count issue-shaped references across .agents/workflows/** and print the per-file tally. Never fails.',
-    flags: [
-      ['--root <dir>', 'Workflow root to scan (default: .agents/workflows).'],
-      ['--json', 'Emit the report envelope as JSON.'],
-    ],
-    notes: [
-      'Exit codes:\n  0  always — this is a report, not a gate (Story #5340)',
-    ],
-  },
-});

package/.agents/scripts/check-workflow-cli-lint.js

@@ -1,299 +0,0 @@
-#!/usr/bin/env node
-/* node:coverage ignore file */
-
-/**
- * check-workflow-cli-lint.js — enforce the "no workflow instructs a
- * no-CLI library call" rule (Epic #4474 PR5; sibling of
- * check-lifecycle-lint.js).
- *
- * The measured failure mode this rule kills: workflow prose that tells the
- * host LLM to "Call `someExportedFunction({...})` exported from
- * `lib/whatever.js`". There is no runnable form of that instruction, so the
- * model greps the framework source and writes throwaway `.mjs` shims to
- * invoke the export — the mandrel-bench N=2 cohort measured ~12–15 turns of
- * shim-writing per plan for exactly this pattern. Workflows must instruct
- * `node .agents/scripts/<cli>.js …` commands instead.
- *
- * Scope: every `*.md` under `.agents/workflows/`.
- *
- * Heuristic (tuned to zero false positives on the surviving corpus —
- * descriptive mentions like "the automatic paths call `foo()`" are prose
- * about script internals, not instructions, and are NOT flagged):
- *
- *   Rule 1 — imperative library call. A paragraph (fenced code blocks
- *     stripped; lines joined) matching /\b(Call|Invoke)\s+`ident\s*\(/ —
- *     a capitalized imperative directly instructing a function call.
- *
- *   Rule 2 — "exported from" instruction. A paragraph containing both a
- *     backticked call token (`ident(`) and the phrase "exported from" —
- *     the canonical shape of the retired Phase 2/3/4 prose.
- *
- *   Rule 3 — prose-level lib import. `import(` / `require(` naming a
- *     `scripts/lib/` path OUTSIDE a fenced code block. (A complete,
- *     runnable `node -e` one-liner inside a fenced block is exempt: it
- *     costs zero shim-writing turns because it is executable as written.)
- *
- * Exit codes:
- *   0 — clean.
- *   1 — at least one violation; offending file + paragraph line printed
- *       to stderr.
- *
- * Ships as part of `npm run lint` (run-lint.js task list), alongside the
- * lifecycle lint and the label-vocabulary lint.
- */
-
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { runAsCli } from './lib/cli-utils.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-export const DEFAULT_WORKFLOWS_DIR = path.join(
-  REPO_ROOT,
-  '.agents',
-  'workflows',
-);
-
-const IMPERATIVE_CALL_RE = /\b(?:Call|Invoke)\s+`[A-Za-z_$][\w$]*\s*\(/;
-const BACKTICK_CALL_RE = /`[A-Za-z_$][\w$]*\s*\(/;
-const EXPORTED_FROM_RE = /\bexported from\b/;
-const LIB_IMPORT_RE = /\b(?:import|require)\(\s*['"`][^'"`]*scripts\/lib\//;
-
-/** A markdown table row (leading pipe, optionally indented). */
-const TABLE_ROW_RE = /^\s*\|/;
-/** A markdown heading of any level — the lookback boundary for Rule 4. */
-const HEADING_RE = /^\s*#{1,6}\s/;
-/** A backticked `--flag` occupying a table row's first cell. */
-const FLAG_CELL_RE = /^\s*\|\s*`?--[\w-]+/;
-/** A `.js` script filename — bare or path-qualified. */
-const SCRIPT_NAME_RE = /([\w./-]*[\w-]+\.js)\b/;
-/** A markdown table's delimiter row (`| --- | --- |`). */
-const TABLE_DELIMITER_RE = /^\s*\|[\s|:-]+\|?\s*$/;
-/** Minimum `--flag` rows before a table counts as a flag *table*. */
-export const MIN_FLAG_ROWS = 2;
-
-/**
- * Strip fenced code blocks (``` / ~~~), replacing their lines with empty
- * strings so line numbers stay stable. Complete runnable commands live in
- * fences and are exempt by design (see header).
- *
- * @param {string} source
- * @returns {string[]} lines with fenced content blanked.
- */
-export function stripFences(source) {
-  const lines = source.split('\n');
-  let inFence = false;
-  return lines.map((line) => {
-    const fence = /^\s*(```|~~~)/.test(line);
-    if (fence) {
-      inFence = !inFence;
-      return '';
-    }
-    return inFence ? '' : line;
-  });
-}
-
-/**
- * Split blanked lines into paragraphs — runs of consecutive non-empty
- * lines — keeping the 1-based line number of each paragraph's first line.
- *
- * @param {string[]} lines
- * @returns {Array<{ text: string, line: number }>}
- */
-export function toParagraphs(lines) {
-  const paragraphs = [];
-  let buf = [];
-  let start = 0;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim().length > 0) {
-      if (buf.length === 0) start = i + 1;
-      buf.push(lines[i]);
-    } else if (buf.length > 0) {
-      paragraphs.push({ text: buf.join(' '), line: start });
-      buf = [];
-    }
-  }
-  if (buf.length > 0) paragraphs.push({ text: buf.join(' '), line: start });
-  return paragraphs;
-}
-
-/**
- * Rule 4 — CLI flag table. Find markdown tables that enumerate the `--flags`
- * of a script the repo already owns, and flag them as duplicated surface.
- *
- * The script's own argument parser is the source of truth for its flags, and
- * it prints them itself; a copy in prose is drift waiting to happen (the very
- * drift Story #4546 removed). Prose must point at the command instead.
- *
- * The signal is deliberately narrow, to stay at zero false positives:
- *
- *   1. The table has at least `MIN_FLAG_ROWS` data rows whose **first cell**
- *      is a `--flag`. One flag row among prose rows is a contract/behaviour
- *      table (e.g. "Default | …", "`--dry-run` | …"), not a flag enumeration.
- *   2. A `.js` script is named between the table and the nearest preceding
- *      heading (inclusive) — i.e. the section is *about* that script, so the
- *      table is restating its surface.
- *
- * A slash command's own argument table (`/mandrel-plan`, `/mandrel-deliver`) has no script
- * behind it — nothing owns those flags but the workflow prose itself — so
- * condition 2 leaves it alone by design.
- *
- * @param {string[]} rawLines unstripped source lines (fenced commands are the
- *   usual place a script is named, so this rule reads the original text).
- * @returns {Array<{ rule: string, line: number, hint: string }>}
- */
-export function lintFlagTables(rawLines) {
-  const violations = [];
-  let inFence = false;
-
-  for (let i = 0; i < rawLines.length; i++) {
-    if (/^\s*(```|~~~)/.test(rawLines[i])) {
-      inFence = !inFence;
-      continue;
-    }
-    if (inFence || !TABLE_ROW_RE.test(rawLines[i])) continue;
-
-    // Collect the contiguous table block starting here.
-    const start = i;
-    let end = i;
-    while (end + 1 < rawLines.length && TABLE_ROW_RE.test(rawLines[end + 1])) {
-      end += 1;
-    }
-    i = end; // continue scanning after this table
-
-    const flagRows = rawLines
-      .slice(start, end + 1)
-      .filter((l) => !TABLE_DELIMITER_RE.test(l) && FLAG_CELL_RE.test(l));
-    if (flagRows.length < MIN_FLAG_ROWS) continue;
-
-    // Look back to the nearest heading (inclusive) for a named script.
-    let script = null;
-    for (let j = start - 1; j >= 0; j--) {
-      const m = SCRIPT_NAME_RE.exec(rawLines[j]);
-      if (m) {
-        script = m[1];
-        break;
-      }
-      if (HEADING_RE.test(rawLines[j])) break;
-    }
-    if (!script) continue;
-
-    const base = script.split('/').pop();
-    violations.push({
-      rule: 'no-cli-flag-table',
-      line: start + 1,
-      hint:
-        `Workflow prose restates the flag surface of \`${base}\` as a table (${flagRows.length} flag rows). ` +
-        "The script's argument parser owns those flags, so a prose copy is drift waiting to happen. " +
-        `Delete the table and point at the command (\`node .agents/scripts/${base} …\`), keeping only the ` +
-        'judgement a reader cannot get from the command itself. If the script has no help output to point ' +
-        'at, add one — do not re-inline the table.',
-    });
-  }
-  return violations;
-}
-
-/**
- * Lint one markdown source. Returns violations
- * `{ rule, line, hint }[]` (empty when clean).
- *
- * @param {string} source markdown content.
- * @returns {Array<{ rule: string, line: number, hint: string }>}
- */
-export function lintWorkflowSource(source) {
-  const violations = [];
-  const rawLines = source.split('\n');
-  const lines = stripFences(source);
-  violations.push(...lintFlagTables(rawLines));
-  for (const para of toParagraphs(lines)) {
-    if (IMPERATIVE_CALL_RE.test(para.text)) {
-      violations.push({
-        rule: 'no-cli-library-call',
-        line: para.line,
-        hint:
-          'Workflow prose instructs calling a function directly ("Call/Invoke `fn(...)`"). ' +
-          'There is no runnable form of that instruction — the model must write a throwaway shim. ' +
-          'Instruct a `node .agents/scripts/<cli>.js …` command instead (add a CLI if none exists).',
-      });
-      continue;
-    }
-    if (EXPORTED_FROM_RE.test(para.text) && BACKTICK_CALL_RE.test(para.text)) {
-      violations.push({
-        rule: 'no-cli-library-call',
-        line: para.line,
-        hint:
-          'Workflow prose points at an exported library function ("`fn(...)` exported from …") ' +
-          'with no CLI entrypoint. Instruct a `node .agents/scripts/<cli>.js …` command instead.',
-      });
-      continue;
-    }
-    if (LIB_IMPORT_RE.test(para.text)) {
-      violations.push({
-        rule: 'no-prose-lib-import',
-        line: para.line,
-        hint:
-          'Workflow prose (outside a fenced code block) instructs importing a scripts/lib module. ' +
-          'Give a complete runnable command in a fenced block, or add a CLI entrypoint.',
-      });
-    }
-  }
-  return violations;
-}
-
-/**
- * Recursively collect `*.md` files under a directory.
- *
- * @param {string} dir
- * @returns {string[]} absolute paths.
- */
-export function collectMarkdown(dir) {
-  const out = [];
-  for (const entry of readdirSync(dir)) {
-    const abs = path.join(dir, entry);
-    const st = statSync(abs);
-    if (st.isDirectory()) out.push(...collectMarkdown(abs));
-    else if (entry.endsWith('.md')) out.push(abs);
-  }
-  return out;
-}
-
-/**
- * Run the check over a workflows directory. Exported for tests (pass a
- * fixture directory).
- *
- * @param {string} [workflowsDir]
- * @returns {Array<{ file: string, rule: string, line: number, hint: string }>}
- */
-export function runCheck(workflowsDir = DEFAULT_WORKFLOWS_DIR) {
-  const violations = [];
-  for (const file of collectMarkdown(workflowsDir)) {
-    const source = readFileSync(file, 'utf8');
-    for (const v of lintWorkflowSource(source)) {
-      violations.push({ file: path.relative(REPO_ROOT, file), ...v });
-    }
-  }
-  return violations;
-}
-
-async function main() {
-  const violations = runCheck();
-  if (violations.length === 0) {
-    process.stdout.write(
-      '[workflow-cli-lint] clean: no workflow instructs a no-CLI library call.\n',
-    );
-    return 0;
-  }
-  for (const v of violations) {
-    process.stderr.write(
-      `[workflow-cli-lint][${v.rule}] ${v.file}:${v.line}\n  ${v.hint}\n`,
-    );
-  }
-  return 1;
-}
-
-await runAsCli(import.meta.url, main, {
-  source: 'check-workflow-cli-lint',
-  propagateExitCode: true,
-});