gcf-aif-ext 0.2.7 → 0.4.0

package/commands/gcf.js

@@ -1,6 +1,6 @@
 // CLI wrapper over the deterministic core (GCF-PRD §10.1): harness and human call
 // the same functions. Registered by AIF via extension.json `commands`.
-import { mkdir, copyFile, readFile } from 'node:fs/promises';
+import { mkdir, copyFile, readFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
@@ -70,8 +70,29 @@ function aif(args) {
 
 const today = () => new Date().toISOString().slice(0, 10);
 
+const UNION = [
+  'gcf/history.md merge=union',
+  'gcf/graveyard.md merge=union',
+  'gcf/inbox.md merge=union',
+];
+
+/**
+ * Two branches that end different lives may add their lines at the same spot of history.md,
+ * graveyard.md or inbox.md: a union merge keeps both instead of a conflict whose "ours" loses
+ * one. Adds the missing rules to `<dir>/.gitattributes`; a project that ran an older init gets
+ * them on re-run.
+ */
+export async function unionAttributes(dir) {
+  const file = path.join(dir, '.gitattributes');
+  const text = existsSync(file) ? await readFile(file, 'utf8') : '';
+  const missing = UNION.filter((rule) => !text.split(/\r?\n/).includes(rule));
+  if (!missing.length) return;
+  const sep = text && !text.endsWith('\n') ? '\n' : '';
+  await writeFile(file, `${text}${sep}${missing.join('\n')}\n`, 'utf8');
+}
+
 async function seedSkeleton(root) {
-  for (const dir of ['cards', 'systems', 'source', '.metrics']) {
+  for (const dir of ['design', 'work', 'systems', 'source', '.metrics']) {
     await mkdir(path.join(root, dir), { recursive: true });
   }
 
@@ -86,8 +107,14 @@ async function seedSkeleton(root) {
     if (!existsSync(target)) await copyFile(path.join(EXT_ROOT, 'templates', tpl), target);
   }
 
+  const { HISTORY_HEAD, GRAVEYARD_HEAD } = await lib('verdict-fs');
+  const { INBOX_HEAD } = await lib('inbox');
+  const { serializeLive } = await lib('live');
   for (const [name, header] of [
-    ['graveyard.md', '# Graveyard — one line per killed idea, written by gcf verdict kill\n'],
+    ['history.md', HISTORY_HEAD],
+    ['graveyard.md', GRAVEYARD_HEAD],
+    ['inbox.md', INBOX_HEAD],
+    ['LIVE.md', serializeLive({ capabilities: [], knownIssues: [] })],
     [
       'open-questions.md',
       '# Open questions — records with id/lens/sections/sys/class/question/proposed, ' +
@@ -95,13 +122,13 @@ async function seedSkeleton(root) {
     ],
   ]) {
     const target = path.join(root, name);
-    if (!existsSync(target))
-      await (await import('node:fs/promises')).writeFile(target, header, 'utf8');
+    if (!existsSync(target)) await 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 unionAttributes(process.cwd());
 }
 
 async function offerHarness(program, opts) {
@@ -134,8 +161,8 @@ function registerInit(gcf, program) {
       const { writeIndex } = await lib('index-gen');
       await writeIndex(root);
       console.log(
-        'gcf/ ready. Write PILLARS.md through /gcf-init, then add candidates to backlog.md ' +
-          'or import a GDD with /gcf-ingest.',
+        'gcf/ ready. Write PILLARS.md through /gcf-init, then import a GDD with /gcf-ingest ' +
+          'or start the design with /gcf-vision.',
       );
       await offerHarness(program, opts);
     });
@@ -155,19 +182,19 @@ function registerIndex(gcf) {
 
 function registerContext(gcf) {
   gcf
-    .command('context <card-id>')
-    .description('Assemble the readset for a card (GCF-PRD §9.1)')
+    .command('context <item-id>')
+    .description('Assemble the readset for a work item (GCF-PRD §9.1)')
     .option('--json', 'machine output')
-    .action(async (cardId, opts) => {
+    .action(async (itemId, opts) => {
       const { buildContext } = await lib('context');
-      const ctx = await buildContext(process.cwd(), cardId);
+      const ctx = await buildContext(process.cwd(), itemId);
       // Metric 1 (GCF-PRD §14): readset size over time, one csv line per call.
       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'),
-        `${today()},${cardId},${ctx.files.length},${ctx.total_tokens_est}\n`,
+        `${today()},${itemId},${ctx.files.length},${ctx.total_tokens_est}\n`,
         'utf8',
       );
       out(opts.json, ctx, (c) =>
@@ -191,9 +218,10 @@ function registerAudit(gcf) {
       const report = await audit(process.cwd());
       // Metric 2 (GCF-PRD §14): findings per audit run.
       const findings =
-        report.stale_built.length +
+        report.stale_waiting.length +
         report.tune_limit.length +
         report.until.filter((u) => u.status === 'stale').length +
+        report.stale_questions.length +
         Object.keys(report.linter).length;
       const { appendFile, mkdir } = await import('node:fs/promises');
       const metricsDir = path.join(process.cwd(), 'gcf', '.metrics');
@@ -214,7 +242,7 @@ function registerAudit(gcf) {
 function registerPlaytest(gcf) {
   gcf
     .command('playtest')
-    .description('List built cards with their miss-criterion questions')
+    .description('List items awaiting a verdict and unplayed ones, with their questions')
     .option('--json', 'machine output')
     .action(async (opts) => {
       const { gcfRoot } = await lib('gcf-paths');
@@ -222,29 +250,60 @@ function registerPlaytest(gcf) {
       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',
+          ? l.map((c) => `${c.id} (${c.status}) [${c.system.join(',')}]: ${c.question}`).join('\n')
+          : 'nothing waits for a playtest',
       );
     });
 }
 
+const shortHash = (h) => (h ? ` (${h.slice(0, 7)})` : '');
+const removalLine = (r) => (r.removal ? `\nremoval item: gcf/work/${r.removal}.md` : '');
+
+/** `--remove` / `--no-remove` / neither (the move's default) for a move that may bury code. */
+const removeOptions = (cmd) =>
+  cmd
+    .option('--remove', 'also create a removal item: the code is in main')
+    .option('--no-remove', 'no removal item: the code never reached main');
+
 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')
+  removeOptions(
+    gcf
+      .command('verdict <item-id> <verdict>')
+      .description('Apply a human verdict: keep | tune | kill (Methodology §4.1)')
+      .option('--note <text>', 'tune remark or kill reason')
+      .option('--tags <list>', 'graveyard tags on kill, comma-separated (default: its systems)')
+      .option(
+        '--constraint <line>',
+        'keep of a hard unit: a line every reader of the subsystem must remember',
+        (v, p) => [...p, v],
+        [],
+      ),
+  )
     .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, {
+    .action(async (itemId, verdict, opts) => {
+      const { verdictItem } = await lib('work-ops');
+      const res = await verdictItem(process.cwd(), itemId, verdict, {
         note: opts.note ?? '',
+        tags: splitList(opts.tags),
+        remove: opts.remove,
+        constraints: opts.constraint,
         commit: opts.commit,
       });
-      const hash = res.hash ? ` (${res.hash.slice(0, 7)})` : '';
-      console.log(`${res.verdict} ${res.card} → ${res.systems.join(',')}${hash}`);
+      console.log(
+        `${res.verdict} ${res.id} → ${res.systems.join(',')}${shortHash(res.hash)}` +
+          removalLine(res),
+      );
     });
 }
 
+const splitList = (v) =>
+  v
+    ? String(v)
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : [];
+
 function anchorDeltaLine(r) {
   if (r.delta) {
     const { added, changed, removed, renamed } = r.delta;
@@ -267,19 +326,23 @@ function registerAnchor(gcf) {
     )
     .option('--json', 'machine output')
     .action(async (file, opts) => {
-      const { splitSections, importSource, loadAnchorMap, classifyDelta } = await lib('anchors');
+      const anchors = await lib('anchors');
+      const { splitSections, importSource, loadAnchorMap, classifyDelta } = anchors;
       const base = path.basename(file);
       const oldMap = await loadAnchorMap(process.cwd(), base);
       const { readFile } = await import('node:fs/promises');
       const sections = splitSections(await readFile(file, 'utf8'));
       const delta = oldMap?.anchors ? classifyDelta(oldMap.anchors, sections) : null;
       await importSource(process.cwd(), file);
+      // A renamed heading moves its anchor: provenance and source: follow it.
+      const rewritten = delta ? await anchors.rewriteAnchors(process.cwd(), delta.renamed) : [];
       const rebaselined = Boolean(oldMap?.rebaselined);
       const result = {
         file: `gcf/source/${base}`,
         sections: sections.map((s) => ({ anchor: s.anchor, heading: s.heading, lines: s.lines })),
         delta,
         rebaselined,
+        rewritten,
       };
       out(opts.json, result, (r) =>
         [
@@ -287,6 +350,7 @@ function registerAnchor(gcf) {
             (s) => `${s.anchor}  L${s.lines[0]}-${s.lines[1]}  ${s.heading ?? '(preamble)'}`,
           ),
           anchorDeltaLine(r),
+          ...r.rewritten.map((f) => `renamed anchors rewritten in gcf/${f}`),
         ].join('\n'),
       );
     });
@@ -308,18 +372,367 @@ function registerSection(gcf) {
 function registerQuotes(gcf) {
   gcf
     .command('quotes')
-    .description('Verify each backlog q: quote is verbatim in its src: section (GCF-PRD §11.2)')
+    .description('Provenance only: every quote verbatim in its src: section (design check M9)')
     .option('--json', 'machine output')
     .action(async (opts) => {
-      const { checkQuotes } = await lib('anchors');
-      const problems = await checkQuotes(process.cwd());
+      const { designCheck } = await lib('design-check');
+      const problems = (await designCheck(process.cwd())).issues.filter((i) => i.check === 'M9');
       out(opts.json, problems, (l) =>
-        l.length ? l.map((p) => `${p.id} ${p.anchor}: ${p.problem}`).join('\n') : 'clean',
+        l.length ? l.map((p) => `${p.file}:${p.line} ${p.id}: ${p.message}`).join('\n') : 'clean',
       );
       if (problems.length) process.exitCode = 1;
     });
 }
 
+const issueLine = (i) => `${i.severity} ${i.check} ${i.file}:${i.line} ${i.id ?? ''} ${i.message}`;
+
+function designSummary(r) {
+  const rows = Object.entries(r.systems).map(
+    ([s, t]) => `${s}: ${t.units} units, ${t.ready} ready, ${t.tbd}/${t.values} TBD`,
+  );
+  const blocking = r.issues.filter((i) => i.severity === 'block');
+  const notes = r.issues.filter((i) => i.severity === 'report');
+
+  return [
+    ...blocking.map(issueLine),
+    ...notes.map(issueLine),
+    ...rows,
+    blocking.length ? `${blocking.length} blocking finding(s)` : 'no blocking findings',
+  ].join('\n');
+}
+
+function registerDesign(gcf) {
+  const design = gcf.command('design').description('Design Model: units in gcf/design/');
+  design
+    .command('check')
+    .description(
+      'Mechanical checks over gcf/design/ and the work items; exit 1 on a blocking finding',
+    )
+    .option('--json', 'machine output')
+    .action(async (opts) => {
+      const { designCheck } = await lib('design-check');
+      const report = await designCheck(process.cwd());
+      out(opts.json, report, designSummary);
+      if (report.blocking) process.exitCode = 1;
+    });
+  design
+    .command('export')
+    .description('Glue game.md, glossary.md and the units into one bundle a designer edits')
+    .option('--system <name>', 'only this subsystem')
+    .option('--milestone <name>', 'only the units of this milestone')
+    .option('--out <file>', 'write the bundle here instead of stdout')
+    .action(async (opts) => {
+      const { exportBundle } = await lib('bundle');
+      const text = await exportBundle(process.cwd(), opts);
+      if (!opts.out) return void process.stdout.write(text);
+      const { writeFile } = await import('node:fs/promises');
+      await writeFile(opts.out, text, 'utf8');
+      console.log(`bundle written → ${opts.out}`);
+    });
+  design
+    .command('import <bundle>')
+    .description('Bring an edited bundle back: 3-way by base hash, conflicts reported, no commit')
+    .option('--json', 'machine output')
+    .action(async (bundle, opts) => {
+      const { importBundle } = await lib('bundle');
+      const r = await importBundle(process.cwd(), await readFile(bundle, 'utf8'));
+      out(opts.json, r, (x) =>
+        [
+          ...x.applied.map((a) => `applied ${a}`),
+          ...x.report.map((p) => `${p.outcome} ${p.part}: ${p.note}`),
+          x.applied.length || x.report.length ? '' : 'nothing changed',
+        ]
+          .filter(Boolean)
+          .join('\n'),
+      );
+      if (r.report.some((p) => p.outcome !== 'deleted')) process.exitCode = 1;
+    });
+  registerMigrate(design);
+}
+
+function registerMigrate(design) {
+  design
+    .command('migrate')
+    .description('One-shot: backlog cand-NNN lines become units in gcf/design/ (no commit)')
+    .option(
+      '--skip <ids>',
+      'converted by hand, comma-separated: cand-NNN, cand-NNN=<id> or cand-NNN=<id>+<id>',
+    )
+    .action(async (opts) => {
+      const { migrateBacklog } = await lib('migrate');
+      const skip = opts.skip ? opts.skip.split(',').map((s) => s.trim()) : [];
+      const r = await migrateBacklog(process.cwd(), { skip });
+      for (const l of r.lost_depends) console.log(`lost depends: ${l} (map it: --skip cand=id)`);
+      for (const l of r.maybe_duplicates) console.log(`maybe a duplicate: ${l}`);
+      for (const l of r.unmoved_gaps) console.log(`check its unit holds these gaps: ${l}`);
+      console.log(
+        `${r.units} units written, ${r.skipped} skipped, ${r.history} history lines from git; ` +
+          'run ai-factory gcf design check',
+      );
+    });
+}
+
+const placeLines = (x) => [...x.live.map((p) => `${p.state} gcf/${p.file}`), ...x.terminal];
+
+function registerWhere(gcf) {
+  gcf
+    .command('where [id]')
+    .description(
+      'Where an id lives: a design section, a work item, a terminal event; no id lists all',
+    )
+    .option('--json', 'machine output')
+    .action(async (id, opts) => {
+      const { buildLedger } = await lib('ledger');
+      const ledger = await buildLedger(process.cwd());
+      // Without an id: every id the project has used, so an import never mints a taken one.
+      if (!id) {
+        const all = ledger.ids().map((i) => ledger.where(i));
+        out(opts.json, all, (l) => l.map((x) => `${x.id}: ${placeLines(x).join(', ')}`).join('\n'));
+
+        return;
+      }
+
+      out(opts.json, ledger.where(id), (x) => placeLines(x).join('\n') || `${id} is unknown`);
+    });
+}
+
+function registerMoves(gcf) {
+  const ops = () => lib('unit-ops');
+  gcf
+    .command('take <ids...>')
+    .description('Move ready units from gcf/design/ into work items gcf/work/<id>.md (no commit)')
+    .option('--feature <id>', 'group them under this feature item, new or live')
+    .action(async (ids, o) => {
+      const r = await (await ops()).takeUnits(process.cwd(), ids, { feature: o.feature ?? null });
+      console.log(r.items.join('\n'));
+    });
+  gcf
+    .command('done <id>')
+    .description('A hard unit is built and tested: it leaves gcf/design/ (commit gcf(done))')
+    .option(
+      '--constraint <line>',
+      'a line every reader of the subsystem must remember',
+      (v, p) => [...p, v],
+      [],
+    )
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (id, o) => {
+      const r = await (
+        await ops()
+      ).doneUnit(process.cwd(), id, { constraints: o.constraint, commit: o.commit });
+      console.log(`done ${r.id}${r.hash ? ` (${r.hash.slice(0, 7)})` : ''}`);
+    });
+  removeOptions(
+    gcf
+      .command('drop <id>')
+      .description(
+        'Drop a unit or a work item: a graveyard line keeps the reason (commit gcf(drop))',
+      )
+      .requiredOption('--reason <text>', 'why it dies')
+      .option('--tags <list>', 'graveyard tags, comma-separated (default: its systems)'),
+  )
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (id, o) => {
+      const tags = splitList(o.tags);
+      const { buildLedger } = await lib('ledger');
+      const isItem = (await buildLedger(process.cwd())).item(id);
+      const r = isItem
+        ? await (
+            await lib('work-ops')
+          ).dropItem(process.cwd(), id, {
+            reason: o.reason,
+            tags,
+            remove: o.remove,
+            commit: o.commit,
+          })
+        : await (
+            await ops()
+          ).dropUnit(process.cwd(), id, { reason: o.reason, tags, commit: o.commit });
+      console.log(`dropped ${r.id}${shortHash(r.hash)}${removalLine(r)}`);
+    });
+}
+
+function registerItem(gcf) {
+  const item = gcf.command('item').description('Work items in gcf/work/ (Methodology §3)');
+  item
+    .command('new <id>')
+    .description('Create a work item in ready (or blocked), no commit; a design unit uses take')
+    .requiredOption(
+      '--type <type>',
+      'feature | tech | bug | spike | asset | content | perf | release',
+    )
+    .option('--gate <gate>', 'verdict | auto | decision (default: by type)')
+    .option('--title <text>', 'one line: what the item gives')
+    .option('--parent <feature>', 'a live feature item this one belongs to')
+    .option('--system <list>', 'subsystems it touches, comma-separated')
+    .option('--depends <list>', 'ids it waits for, comma-separated')
+    .option('--severity <level>', 'a bug: critical | high | medium | low')
+    .option('--blocked <why>', 'start blocked, e.g. "file needed" for an asset')
+    .option('--from <in-id>', 'the inbox entry it comes from: erased')
+    .option('--reopens <id>', 'the ended id this item reworks')
+    .action(async (id, o) => {
+      const { newItem } = await lib('work-ops');
+      const r = await newItem(process.cwd(), {
+        id,
+        type: o.type,
+        gate: o.gate,
+        title: o.title,
+        parent: o.parent,
+        system: splitList(o.system),
+        depends: splitList(o.depends),
+        severity: o.severity,
+        blocked: o.blocked,
+        from: o.from,
+        reopens: o.reopens,
+      });
+      console.log(r.item);
+    });
+}
+
+function registerItemMoves(gcf) {
+  const ops = () => lib('work-ops');
+  gcf
+    .command('submit <id>')
+    .description('ready → awaiting-verdict / awaiting-decision (commit gcf(submit))')
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (id, o) => {
+      const r = await (await ops()).submitItem(process.cwd(), id, { commit: o.commit });
+      console.log(`${r.id} → ${r.status}${shortHash(r.hash)}`);
+    });
+  gcf
+    .command('close <id>')
+    .description('A gate-auto item passed its DoD: it ends, or a soft unit goes unplayed')
+    .option(
+      '--constraint <line>',
+      'a hard unit: a line every reader of the subsystem must remember',
+      (v, p) => [...p, v],
+      [],
+    )
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (id, o) => {
+      const r = await (
+        await ops()
+      ).closeItem(process.cwd(), id, { constraints: o.constraint, commit: o.commit });
+      console.log(`closed ${r.id}${r.unplayed ? ' → unplayed' : ''}${shortHash(r.hash)}`);
+    });
+}
+
+function registerDecide(gcf) {
+  const ops = () => lib('work-ops');
+  removeOptions(
+    gcf
+      .command('decide <id> <choice>')
+      .description('go | no | wontfix | known | close | continue | kill (Methodology §4.1)')
+      .option('--reason <text>', 'why: the graveyard keeps it'),
+  )
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (id, choice, o) => {
+      const r = await (
+        await ops()
+      ).decideItem(process.cwd(), id, choice, {
+        reason: o.reason ?? '',
+        remove: o.remove,
+        commit: o.commit,
+      });
+      console.log(`${r.choice} ${r.id}${shortHash(r.hash)}${removalLine(r)}`);
+    });
+  gcf
+    .command('block <id>')
+    .description('ready → blocked, with the reason or the question (commit gcf(block))')
+    .requiredOption('--reason <text>', 'why it cannot go on, or the question for you')
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (id, o) => {
+      const r = await (
+        await ops()
+      ).blockItem(process.cwd(), id, { reason: o.reason, commit: o.commit });
+      console.log(`blocked ${r.id}${shortHash(r.hash)}`);
+    });
+  gcf
+    .command('unblock <id>')
+    .description('blocked | parked → ready (commit gcf(unblock))')
+    .option('--note <text>', 'the answer, or "file: <path>" for an asset')
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (id, o) => {
+      const r = await (
+        await ops()
+      ).unblockItem(process.cwd(), id, { note: o.note ?? '', commit: o.commit });
+      console.log(`unblocked ${r.id}${shortHash(r.hash)}`);
+    });
+}
+
+function registerInbox(gcf) {
+  const inbox = gcf
+    .command('inbox')
+    .description('Raw input waiting for triage (gcf/inbox.md); no commit')
+    .option('--json', 'machine output')
+    .action(async (o) => {
+      const { gcfRoot } = await lib('gcf-paths');
+      const list = await (await lib('inbox')).listInbox(gcfRoot());
+      out(o.json, list, (l) =>
+        l.length ? l.map((e) => `${e.id} [${e.source}] ${e.text}`).join('\n') : 'inbox empty',
+      );
+    });
+  inbox
+    .command('add <text>')
+    .description('Append an entry')
+    .option('--source <source>', 'playtest | ci | agent | operator', 'operator')
+    .action(async (text, o) => {
+      const { gcfRoot } = await lib('gcf-paths');
+      const e = await (await lib('inbox')).addInbox(gcfRoot(), text, o.source);
+      console.log(e.id);
+    });
+  inbox
+    .command('drop <in-id>')
+    .description('Erase an entry: triaged as noise, a duplicate, or turned into an item')
+    .action(async (id) => {
+      const { gcfRoot } = await lib('gcf-paths');
+      await (await lib('inbox')).dropInbox(gcfRoot(), id);
+      console.log(`erased ${id}`);
+    });
+}
+
+function registerLive(gcf) {
+  const live = gcf
+    .command('live')
+    .description('What the game is now: gcf/LIVE.md')
+    .option('--json', 'machine output')
+    .action(async (o) => {
+      const { gcfRoot } = await lib('gcf-paths');
+      const l = await (await lib('live')).readLive(gcfRoot());
+      const rows = (list) => list.map((r) => `  ${r.id}: ${r.summary}`);
+      out(o.json, l, (x) =>
+        ['capabilities:', ...rows(x.capabilities), 'known-issues:', ...rows(x.knownIssues)].join(
+          '\n',
+        ),
+      );
+    });
+  live
+    .command('check')
+    .description('Record form, refs that name no file, known issues against parked bugs')
+    .option('--json', 'machine output')
+    .action(async (o) => {
+      const r = await (await lib('live')).checkLive(process.cwd());
+      out(o.json, r.issues, (l) => (l.length ? l.join('\n') : 'clean'));
+      if (r.issues.length) process.exitCode = 1;
+    });
+}
+
+function registerPlan(gcf) {
+  gcf
+    .command('plan')
+    .description('The plan of a work item')
+    .command('check <id>')
+    .description('Deterministic plan check: it exists, has task checkboxes, readset in budget')
+    .option('--json', 'machine output')
+    .action(async (id, o) => {
+      const r = await (await lib('plan-check')).planCheck(process.cwd(), id);
+      out(o.json, r, (x) =>
+        x.ok ? `${x.plan}: ${x.done}/${x.tasks} tasks done` : x.problems.join('\n'),
+      );
+      if (!r.ok) process.exitCode = 1;
+    });
+}
+
 function registerHooksInstall(gcf) {
   gcf
     .command('hooks-install')
@@ -378,6 +791,15 @@ export function register(program) {
   registerAnchor(gcf);
   registerSection(gcf);
   registerQuotes(gcf);
+  registerDesign(gcf);
+  registerWhere(gcf);
+  registerMoves(gcf);
+  registerItem(gcf);
+  registerItemMoves(gcf);
+  registerDecide(gcf);
+  registerInbox(gcf);
+  registerLive(gcf);
+  registerPlan(gcf);
   registerHooksInstall(gcf);
   registerLint(gcf);
 }

package/extension.json

@@ -1,24 +1,41 @@
 {
   "$schema": "https://raw.githubusercontent.com/lee-to/ai-factory/2.x/schemas/extension.schema.json",
   "name": "gcf-aif-ext",
-  "version": "0.2.7",
+  "version": "0.4.0",
   "description": "Game Context Framework for AI Factory",
   "skills": [
     "skills/gcf-init",
     "skills/gcf-adopt",
     "skills/gcf-card",
     "skills/gcf-verdict",
+    "skills/gcf-triage",
     "skills/gcf-audit",
     "skills/gcf-vision",
     "skills/gcf-debate",
     "skills/gcf-ingest"
   ],
   "commands": [
-    { "name": "gcf", "description": "Game Context Framework core", "module": "commands/gcf.js" }
+    {
+      "name": "gcf",
+      "description": "Game Context Framework core",
+      "module": "commands/gcf.js"
+    }
   ],
   "injections": [
-    { "target": "aif-plan", "position": "append", "file": "./injections/plan-context.md" },
-    { "target": "aif-review", "position": "append", "file": "./injections/review-pillars.md" },
-    { "target": "aif-commit", "position": "append", "file": "./injections/commit-status.md" }
+    {
+      "target": "aif-plan",
+      "position": "append",
+      "file": "./injections/plan-context.md"
+    },
+    {
+      "target": "aif-review",
+      "position": "append",
+      "file": "./injections/review-pillars.md"
+    },
+    {
+      "target": "aif-commit",
+      "position": "append",
+      "file": "./injections/commit-status.md"
+    }
   ]
 }