gcf-aif-ext 0.2.4 → 0.2.7

package/README.md

@@ -25,12 +25,14 @@ ai-factory extension add gcf-aif-ext                        # npm
 This installs the 8 skills into each configured runtime, registers the `gcf` command and appends the injections to `aif-plan`, `aif-review` and `aif-commit`. Then set up the project — two steps, run once:
 
 ```bash
-ai-factory gcf init            # seeds gcf/ and cnlp.config.json
+ai-factory gcf init            # seeds gcf/ and cnlp.config.json (PILLARS.md is written by /gcf-init)
 ai-factory gcf hooks-install   # arms the pre-commit gate
 ```
 
 `gcf init` is idempotent: it creates what is missing and overwrites nothing.
 
+It then offers the optional [harness](../gcf-harness-aif-ext) — orchestration and a readset guard for **Claude Code only** — and on yes runs `ai-factory extension add gcf-harness-aif-ext` and `ai-factory gcf-harness init`. It asks only in a terminal and only when `.ai-factory.json` lists the Claude Code agent; an agent or CI run is never asked and installs nothing. `--harness` installs it without asking, `--no-harness` skips the question.
+
 `hooks-install` is a separate step because an AI Factory manifest can declare skills, commands and injections but cannot install a git hook — and because arming a gate that can break your commits is your call, not the extension's. It needs a git repository, and it will not overwrite a `pre-commit` it did not write: if husky or lefthook already owns the hook, it prints the one line to chain from it instead. Without the hook GCF still works; nothing enforces it at commit time.
 
 Then `/gcf-vision` for a brand-new game, `/gcf-adopt` for a project that already has code, `/gcf-ingest <gdd.md>` for an existing design doc, or `/gcf-card` to start a feature by hand.
@@ -56,7 +58,7 @@ Removal leaves `gcf/` and `cnlp.config.json` in place. It also leaves the pre-co
 
 **Skills** — `gcf-init`, `gcf-adopt`, `gcf-card`, `gcf-verdict`, `gcf-audit`, `gcf-vision`, `gcf-debate`, `gcf-ingest`.
 
-**A deterministic core** behind `ai-factory gcf …` — `init`, `index`, `context`, `audit`, `playtest`, `verdict`, `anchor`, `lint`, `hooks-install`. These are plain Node scripts with no LLM in the loop: the same functions the skills call, the pre-commit gate runs, and the harness gates against.
+**A deterministic core** behind `ai-factory gcf …` — `init`, `index`, `context`, `audit`, `playtest`, `verdict`, `anchor`, `section`, `quotes`, `lint`, `hooks-install`. These are plain Node scripts with no LLM in the loop: the same functions the skills call, the pre-commit gate runs, and the harness gates against.
 
 **A pre-commit gate** that breaks the commit on a terminal status stored in a card file, a malformed `[until:]` annotation, a card built on an unplayed dependency, a dependency that names no known card, or a П2 linter finding in a subsystem document. It regenerates `gcf/INDEX.md` and stages it for you.
 

package/commands/gcf.js

@@ -7,46 +7,143 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const EXT_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
-const lib = (name) => import(new URL(`../lib/${name}.js`, import.meta.url));
+const lib = (name) => import(new URL(`../lib/${name}.js`, import.meta.url).href);
 
 // Must stay byte-identical to the comment line inside the shim below: hooks-install
 // refuses to overwrite a pre-commit hook that does not carry it.
 const MARKER = 'gcf-aif-ext pre-commit gate';
 
-const out = (json, value, human) => console.log(json ? JSON.stringify(value, null, 2) : human(value));
+const out = (json, value, human) =>
+  console.log(json ? JSON.stringify(value, null, 2) : human(value));
 
-export function register(program) {
-  const gcf = program.command('gcf').description('Game Context Framework core');
+const HARNESS = 'gcf-harness-aif-ext';
 
-  gcf.command('init')
-    .description('Create the gcf/ skeleton from templates (idempotent, never overwrites)')
-    .action(async () => {
+/**
+ * `--harness` / `--no-harness` decide. Without either, ask only when someone can answer
+ * and the answer matters: an agent, CI or MinTTY run has no terminal, and a project
+ * without the Claude Code agent has no use for a Claude-Code-only extension.
+ */
+export async function harnessWanted(flag, ask, canAsk) {
+  if (flag !== undefined) return flag;
+
+  return canAsk ? ask() : false;
+}
+
+async function claudeConfigured() {
+  try {
+    const { agents } = JSON.parse(
+      await readFile(path.join(process.cwd(), '.ai-factory.json'), 'utf8'),
+    );
+
+    return agents.some((a) => a?.id === 'claude');
+  } catch {
+    return true; // unknown config shape: let the human decide
+  }
+}
+
+async function askHarness() {
+  const { createInterface } = await import('node:readline/promises');
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question(
+      `Also install ${HARNESS} (orchestration + readset guard, Claude Code only)? [y/N] `,
+    );
+
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+
+// Re-enter the AIF CLI that is running this command, not whatever `ai-factory` PATH holds
+// (an npx run has none on PATH).
+function aif(args) {
+  const res = spawnSync(process.execPath, [process.argv[1], ...args], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+  });
+  if (res.status !== 0)
+    throw new Error(
+      `ai-factory ${args.join(' ')} failed — gcf/ is ready; retry that command by hand`,
+    );
+}
+
+const today = () => new Date().toISOString().slice(0, 10);
+
+async function seedSkeleton(root) {
+  for (const dir of ['cards', 'systems', 'source', '.metrics']) {
+    await mkdir(path.join(root, dir), { recursive: true });
+  }
+
+  // No PILLARS.md: a seeded example would be read as the game's truth in every readset
+  // until someone replaced it. The pillars interview writes the file; until then it is absent.
+  const seed = [
+    ['backlog.md', 'backlog.md'],
+    ['config.yml', 'config.yml'],
+  ];
+  for (const [tpl, dst] of seed) {
+    const target = path.join(root, dst);
+    if (!existsSync(target)) await copyFile(path.join(EXT_ROOT, 'templates', tpl), target);
+  }
+
+  for (const [name, header] of [
+    ['graveyard.md', '# Graveyard — one line per killed idea, written by gcf verdict kill\n'],
+    [
+      'open-questions.md',
+      '# Open questions — records with id/lens/sections/sys/class/question/proposed, ' +
+        'a D2 also assumed/until; answers move out, records die\n',
+    ],
+  ]) {
+    const target = path.join(root, name);
+    if (!existsSync(target))
+      await (await import('node:fs/promises')).writeFile(target, header, 'utf8');
+  }
+
+  const cnlpCfg = path.join(process.cwd(), 'cnlp.config.json');
+  if (!existsSync(cnlpCfg))
+    await copyFile(path.join(EXT_ROOT, 'templates', 'cnlp.config.json'), cnlpCfg);
+}
+
+async function offerHarness(program, opts) {
+  const installed = program.commands?.some(
+    (c) => (typeof c?.name === 'function' ? c.name() : c?.name) === 'gcf-harness',
+  );
+  if (installed) {
+    if (opts.harness) aif(['gcf-harness', 'init']);
+
+    return;
+  }
+
+  const canAsk = Boolean(process.stdin.isTTY && process.stdout.isTTY) && (await claudeConfigured());
+  if (!(await harnessWanted(opts.harness, askHarness, canAsk))) return;
+  aif(['extension', 'add', HARNESS]);
+  aif(['gcf-harness', 'init']);
+}
+
+function registerInit(gcf, program) {
+  gcf
+    .command('init')
+    .description(
+      'Create the gcf/ skeleton from templates (idempotent, never overwrites); offers the harness',
+    )
+    .option('--harness', `also install ${HARNESS} and run gcf-harness init (Claude Code only)`)
+    .option('--no-harness', 'do not offer the harness')
+    .action(async (opts) => {
       const root = path.join(process.cwd(), 'gcf');
-      for (const dir of ['cards', 'systems', 'source', '.metrics']) {
-        await mkdir(path.join(root, dir), { recursive: true });
-      }
-      const seed = [
-        ['PILLARS.md', 'PILLARS.md'], ['backlog.md', 'backlog.md'], ['config.yml', 'config.yml'],
-      ];
-      for (const [tpl, dst] of seed) {
-        const target = path.join(root, dst);
-        if (!existsSync(target)) await copyFile(path.join(EXT_ROOT, 'templates', tpl), target);
-      }
-      for (const [name, header] of [
-        ['graveyard.md', '# Graveyard — one line per killed idea, written by gcf verdict kill\n'],
-        ['open-questions.md', '# Open questions — records with id/lens/sections/sys/class/proposed; answers move out, records die\n'],
-      ]) {
-        const target = path.join(root, name);
-        if (!existsSync(target)) await (await import('node:fs/promises')).writeFile(target, header, 'utf8');
-      }
-      const cnlpCfg = path.join(process.cwd(), 'cnlp.config.json');
-      if (!existsSync(cnlpCfg)) await copyFile(path.join(EXT_ROOT, 'templates', 'cnlp.config.json'), cnlpCfg);
+      await seedSkeleton(root);
       const { writeIndex } = await lib('index-gen');
       await writeIndex(root);
-      console.log('gcf/ ready. Edit PILLARS.md, then add candidates to backlog.md.');
+      console.log(
+        'gcf/ ready. Write PILLARS.md through /gcf-init, then add candidates to backlog.md ' +
+          'or import a GDD with /gcf-ingest.',
+      );
+      await offerHarness(program, opts);
     });
+}
 
-  gcf.command('index')
+function registerIndex(gcf) {
+  gcf
+    .command('index')
     .description('Regenerate gcf/INDEX.md (deterministic)')
     .action(async () => {
       const { gcfRoot } = await lib('gcf-paths');
@@ -54,8 +151,11 @@ export function register(program) {
       await writeIndex(gcfRoot());
       console.log('INDEX.md regenerated');
     });
+}
 
-  gcf.command('context <card-id>')
+function registerContext(gcf) {
+  gcf
+    .command('context <card-id>')
     .description('Assemble the readset for a card (GCF-PRD §9.1)')
     .option('--json', 'machine output')
     .action(async (cardId, opts) => {
@@ -65,60 +165,106 @@ export function register(program) {
       const { appendFile, mkdir } = await import('node:fs/promises');
       const metricsDir = path.join(process.cwd(), 'gcf', '.metrics');
       await mkdir(metricsDir, { recursive: true });
-      await appendFile(path.join(metricsDir, 'context-log.csv'),
-        `${new Date().toISOString().slice(0, 10)},${cardId},${ctx.files.length},${ctx.total_tokens_est}\n`, 'utf8');
+      await appendFile(
+        path.join(metricsDir, 'context-log.csv'),
+        `${today()},${cardId},${ctx.files.length},${ctx.total_tokens_est}\n`,
+        'utf8',
+      );
       out(opts.json, ctx, (c) =>
         [
           ...c.files.map((f) => `${f.path} (${f.tokens_est})`),
           ...(c.graveyard_hits.length ? ['graveyard hits:', ...c.graveyard_hits] : []),
           `total ~${c.total_tokens_est} / ${c.budget}${c.over_budget ? ' OVER BUDGET' : ''}`,
-        ].join('\n'));
+        ].join('\n'),
+      );
       if (ctx.over_budget) process.exitCode = 2;
     });
+}
 
-  gcf.command('audit')
+function registerAudit(gcf) {
+  gcf
+    .command('audit')
     .description('Deterministic consistency audit (GCF-PRD §10.1)')
     .option('--json', 'machine output')
     .action(async (opts) => {
       const { audit } = await lib('audit-core');
       const report = await audit(process.cwd());
       // Metric 2 (GCF-PRD §14): findings per audit run.
-      const findings = report.stale_built.length + report.tune_limit.length
-        + report.until.filter((u) => u.status === 'stale').length + Object.keys(report.linter).length;
+      const findings =
+        report.stale_built.length +
+        report.tune_limit.length +
+        report.until.filter((u) => u.status === 'stale').length +
+        Object.keys(report.linter).length;
       const { appendFile, mkdir } = await import('node:fs/promises');
       const metricsDir = path.join(process.cwd(), 'gcf', '.metrics');
       if (existsSync(path.join(process.cwd(), 'gcf'))) {
         await mkdir(metricsDir, { recursive: true });
-        await appendFile(path.join(metricsDir, 'audit-log.csv'), `${new Date().toISOString().slice(0, 10)},${findings}\n`, 'utf8');
+        await appendFile(
+          path.join(metricsDir, 'audit-log.csv'),
+          `${today()},${findings}\n`,
+          'utf8',
+        );
       }
+
       out(opts.json, report, (r) => r.first_line);
       if (report.first_line !== 'clean') process.exitCode = 1;
     });
+}
 
-  gcf.command('playtest')
+function registerPlaytest(gcf) {
+  gcf
+    .command('playtest')
     .description('List built cards with their miss-criterion questions')
     .option('--json', 'machine output')
     .action(async (opts) => {
       const { gcfRoot } = await lib('gcf-paths');
       const { playtestList } = await lib('playtest-list');
       const list = await playtestList(gcfRoot());
-      out(opts.json, list, (l) => (l.length
-        ? l.map((c) => `${c.id} ${c.slug} [${c.system.join(',')}]: ${c.question}`).join('\n')
-        : 'nothing in built — nothing to playtest'));
+      out(opts.json, list, (l) =>
+        l.length
+          ? l.map((c) => `${c.id} ${c.slug} [${c.system.join(',')}]: ${c.question}`).join('\n')
+          : 'nothing in built — nothing to playtest',
+      );
     });
+}
 
-  gcf.command('verdict <card-id> <verdict>')
+function registerVerdict(gcf) {
+  gcf
+    .command('verdict <card-id> <verdict>')
     .description('Apply a human verdict: keep | tune | kill (GCF-PRD §8)')
     .option('--note <text>', 'tune remark or kill reason')
     .option('--no-commit', 'skip the verdict commit (tests only)')
     .action(async (cardId, verdict, opts) => {
       const { applyVerdict } = await lib('verdict-fs');
-      const res = await applyVerdict(process.cwd(), cardId, verdict, { note: opts.note ?? '', commit: opts.commit });
-      console.log(`${res.verdict} ${res.card} → ${res.systems.join(',')}${res.hash ? ` (${res.hash.slice(0, 7)})` : ''}`);
+      const res = await applyVerdict(process.cwd(), cardId, verdict, {
+        note: opts.note ?? '',
+        commit: opts.commit,
+      });
+      const hash = res.hash ? ` (${res.hash.slice(0, 7)})` : '';
+      console.log(`${res.verdict} ${res.card} → ${res.systems.join(',')}${hash}`);
     });
+}
 
-  gcf.command('anchor <file>')
-    .description('Import a GDD into gcf/source/ with stable section anchors; on re-import prints the delta')
+function anchorDeltaLine(r) {
+  if (r.delta) {
+    const { added, changed, removed, renamed } = r.delta;
+
+    return (
+      `delta: +${added.length} ~${changed.length} -${removed.length} ` + `renamed ${renamed.length}`
+    );
+  }
+
+  return r.rebaselined
+    ? 're-baselined: the stored anchor map predates the current hashing, no delta computed'
+    : 'first import';
+}
+
+function registerAnchor(gcf) {
+  gcf
+    .command('anchor <file>')
+    .description(
+      'Import a GDD into gcf/source/ with stable section anchors; on re-import prints the delta',
+    )
     .option('--json', 'machine output')
     .action(async (file, opts) => {
       const { splitSections, importSource, loadAnchorMap, classifyDelta } = await lib('anchors');
@@ -129,40 +275,88 @@ export function register(program) {
       const delta = oldMap?.anchors ? classifyDelta(oldMap.anchors, sections) : null;
       await importSource(process.cwd(), file);
       const rebaselined = Boolean(oldMap?.rebaselined);
-      const result = { file: `gcf/source/${base}`, sections: sections.map((s) => ({ anchor: s.anchor, heading: s.heading })), delta, rebaselined };
-      out(opts.json, result, (r) => [
-        ...r.sections.map((s) => `${s.anchor}  ${s.heading ?? '(preamble)'}`),
-        r.delta
-          ? `delta: +${r.delta.added.length} ~${r.delta.changed.length} -${r.delta.removed.length} renamed ${r.delta.renamed.length}`
-          : (r.rebaselined ? 're-baselined: the stored anchor map predates the current hashing, no delta computed' : 'first import'),
-      ].join('\n'));
+      const result = {
+        file: `gcf/source/${base}`,
+        sections: sections.map((s) => ({ anchor: s.anchor, heading: s.heading, lines: s.lines })),
+        delta,
+        rebaselined,
+      };
+      out(opts.json, result, (r) =>
+        [
+          ...r.sections.map(
+            (s) => `${s.anchor}  L${s.lines[0]}-${s.lines[1]}  ${s.heading ?? '(preamble)'}`,
+          ),
+          anchorDeltaLine(r),
+        ].join('\n'),
+      );
     });
+}
 
-  gcf.command('hooks-install')
+function registerSection(gcf) {
+  gcf
+    .command('section <source> <anchor>')
+    .description('Print one anchored section of a gcf/source/ file (read by anchor, not whole)')
+    .action(async (source, anchor) => {
+      const { readSection } = await lib('anchors');
+      const s = await readSection(process.cwd(), source, anchor);
+      if (!s) throw new Error(`${anchor} is not a section of gcf/source/${path.basename(source)}`);
+      console.log(`${s.anchor}  L${s.lines[0]}-${s.lines[1]}  ${s.heading ?? '(preamble)'}`);
+      console.log(s.body);
+    });
+}
+
+function registerQuotes(gcf) {
+  gcf
+    .command('quotes')
+    .description('Verify each backlog q: quote is verbatim in its src: section (GCF-PRD §11.2)')
+    .option('--json', 'machine output')
+    .action(async (opts) => {
+      const { checkQuotes } = await lib('anchors');
+      const problems = await checkQuotes(process.cwd());
+      out(opts.json, problems, (l) =>
+        l.length ? l.map((p) => `${p.id} ${p.anchor}: ${p.problem}`).join('\n') : 'clean',
+      );
+      if (problems.length) process.exitCode = 1;
+    });
+}
+
+function registerHooksInstall(gcf) {
+  gcf
+    .command('hooks-install')
     .description('Install the gcf pre-commit gate into the repository hooks dir (idempotent)')
     .action(async () => {
       const { writeFile } = await import('node:fs/promises');
       // --git-path resolves the hooks dir for a plain repo, a worktree and a submodule alike,
       // where a bare existsSync('.git') passes on a worktree and then fails with ENOTDIR.
-      const res = spawnSync('git', ['rev-parse', '--git-path', 'hooks'], { cwd: process.cwd(), encoding: 'utf8' });
+      const res = spawnSync('git', ['rev-parse', '--git-path', 'hooks'], {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+      });
       if (res.status !== 0) throw new Error('not a git repository');
       const hookScript = path.join(EXT_ROOT, 'hooks', 'pre-commit.js');
-      const shim = `#!/bin/sh\n# gcf-aif-ext pre-commit gate\nnode "${hookScript.replaceAll('\\', '/')}" || exit 1\n`;
+      const gateLine = `node "${hookScript.replaceAll('\\', '/')}" || exit 1`;
+      const shim = `#!/bin/sh\n# ${MARKER}\n${gateLine}\n`;
       const target = path.resolve(process.cwd(), res.stdout.trim(), 'pre-commit');
       if (existsSync(target) && !(await readFile(target, 'utf8')).includes(MARKER)) {
         // Brownfield repos usually arrive with husky or lefthook already owning pre-commit,
         // so the refusal hands over the exact line to chain instead of just naming the file.
-        throw new Error(`${target} already exists and is not ours - back it up, or chain the gate from it with:\n`
-          + `node "${hookScript.replaceAll('\\', '/')}" || exit 1`);
+        throw new Error(
+          `${target} already exists and is not ours - back it up, ` +
+            `or chain the gate from it with:\n${gateLine}`,
+        );
       }
+
       await mkdir(path.dirname(target), { recursive: true });
       // Mode on creation, not a chmod afterwards that can fail with the hook already in place.
       // A file being replaced is our own earlier shim, already executable.
       await writeFile(target, shim, { encoding: 'utf8', mode: 0o755 });
       console.log(`pre-commit hook installed → ${target}`);
     });
+}
 
-  gcf.command('lint <file>')
+function registerLint(gcf) {
+  gcf
+    .command('lint <file>')
     .description('П2 linter over one document (GCF-PRD §13.2)')
     .action(async (file) => {
       const { lint } = await lib('linter');
@@ -172,3 +366,18 @@ export function register(program) {
       else console.log('clean');
     });
 }
+
+export function register(program) {
+  const gcf = program.command('gcf').description('Game Context Framework core');
+  registerInit(gcf, program);
+  registerIndex(gcf);
+  registerContext(gcf);
+  registerAudit(gcf);
+  registerPlaytest(gcf);
+  registerVerdict(gcf);
+  registerAnchor(gcf);
+  registerSection(gcf);
+  registerQuotes(gcf);
+  registerHooksInstall(gcf);
+  registerLint(gcf);
+}

package/extension.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://raw.githubusercontent.com/lee-to/ai-factory/2.x/schemas/extension.schema.json",
   "name": "gcf-aif-ext",
-  "version": "0.2.4",
+  "version": "0.2.7",
   "description": "Game Context Framework for AI Factory",
   "skills": [
     "skills/gcf-init",

package/hooks/pre-commit.js

@@ -26,6 +26,7 @@ const fail = (msg) => {
 // rather than letting a broken probe wave a commit past every check.
 function git(args) {
   const res = spawnSync('git', args, { cwd: projectDir, encoding: 'utf8' });
+
   return res.status === 0 ? res.stdout.trim() : null;
 }
 
@@ -37,7 +38,10 @@ if (staged !== null) {
   const unstaged = git(['diff', '--name-only', '--', root]);
   const untracked = git(['ls-files', '--others', '--exclude-standard', '--', root]);
   if (unstaged || untracked) {
-    fail('gcf/ has changes outside the index — stage them, or commit gcf/ separately (the gate reads the working tree)');
+    fail(
+      'gcf/ has changes outside the index — stage them, or commit gcf/ separately ' +
+        '(the gate reads the working tree)',
+    );
   }
 }
 
@@ -50,10 +54,13 @@ for (const c of cards) {
   const errors = [
     ...validateCard(c.data),
     ...validateUntil(c.body),
-    ...(stemMatches(c.file, c.data.id, c.data.slug) ? [] : [`filename must be ${c.data.id}-${c.data.slug}.md`]),
+    ...(stemMatches(c.file, c.data.id, c.data.slug)
+      ? []
+      : [`filename must be ${c.data.id}-${c.data.slug}.md`]),
   ];
   if (errors.length) fail(`${c.name}: ${errors[0]}`);
 }
+
 for (const s of systemDocs) {
   const errors = validateUntil(s.body);
   if (errors.length) fail(`systems/${s.name}: ${errors[0]}`);
@@ -64,30 +71,37 @@ for (const s of systemDocs) {
 const verdictLog = git(['log', '--grep', '^gcf(verdict):', '--format=%s']) ?? '';
 const gyFile = path.join(root, 'graveyard.md');
 const graveyard = existsSync(gyFile) ? await readFile(gyFile, 'utf8') : '';
-const collapsed = (id) => new RegExp(`^gcf\\(verdict\\): \\w+ ${id}\\b`, 'm').test(verdictLog)
-  || new RegExp(`^- ${id} \\|`, 'm').test(graveyard);
+const collapsed = (id) =>
+  new RegExp(`^gcf\\(verdict\\): \\w+ ${id}\\b`, 'm').test(verdictLog) ||
+  new RegExp(`^- ${id} \\|`, 'm').test(graveyard);
 
-for (const c of cards) {
-  for (const dep of c.data.depends ?? []) {
-    if (cardIds.has(dep)) {
-      if (c.data.status === 'built') {
-        fail(`${c.data.id} is built on top of unplayed ${dep} (collapse it first — GCF-PRD §7.2)`);
-      }
-    } else if (!collapsed(dep)) {
-      fail(`${c.data.id} depends on unknown ${dep} (no card, no verdict, no graveyard line)`);
+function checkDep(c, dep) {
+  if (cardIds.has(dep)) {
+    if (c.data.status === 'built') {
+      fail(`${c.data.id} is built on top of unplayed ${dep} (collapse it first — GCF-PRD §7.2)`);
     }
+  } else if (!collapsed(dep)) {
+    fail(`${c.data.id} depends on unknown ${dep} (no card, no verdict, no graveyard line)`);
   }
 }
 
+for (const c of cards) {
+  for (const dep of c.data.depends ?? []) checkDep(c, dep);
+}
+
 // 5: П2 linter over systems docs.
 for (const s of systemDocs) {
   const { issues } = lint(s.body);
-  if (issues.length) fail(`systems/${s.name}:${issues[0].line}: ${issues[0].rule}: ${issues[0].text}`);
+  if (issues.length)
+    fail(`systems/${s.name}:${issues[0].line}: ${issues[0].rule}: ${issues[0].text}`);
 }
 
 // 3: regenerate INDEX and stage it (deterministic artifact, not a human error).
 await writeIndex(root);
 // An unstaged INDEX (gitignored, locked index) would leave the commit without the row it validated.
-const added = spawnSync('git', ['add', '--', path.join(root, 'INDEX.md')], { cwd: projectDir, stdio: 'ignore' });
+const added = spawnSync('git', ['add', '--', path.join(root, 'INDEX.md')], {
+  cwd: projectDir,
+  stdio: 'ignore',
+});
 if (added.status !== 0) fail('could not stage gcf/INDEX.md — is it gitignored?');
 process.exit(0);

package/injections/review-pillars.md

@@ -1,7 +1,7 @@
 ## GCF: pillar and constraint review (from gcf-aif-ext)
 
 gcf_review:
-- when `gcf/` exists and the change implements a card, read `gcf/PILLARS.md` and the card
+- when `gcf/` exists and the change implements a card, read the card and `gcf/PILLARS.md` when it exists (it stays absent until the pillars interview)
 - check the diff against every negative constraint of the card: name each violation with file and line
 - check the diff against each pillar's review question: a contradiction is a finding, not a note
 - numeric feel values in code outside the card's envelope: report the value and the envelope bounds