gcf-aif-ext 0.7.15 → 0.9.0

package/commands/gcf.js

@@ -731,6 +731,27 @@ function registerItem(gcf) {
     });
 }
 
+function registerDepends(gcf) {
+  gcf
+    .command('depends <id>')
+    .description(
+      'Change the items it waits for: refuses an unknown or killed id and a cycle (commit)',
+    )
+    .option('--add <ids>', 'ids to add, comma-separated')
+    .option('--remove <ids>', 'ids to remove, comma-separated')
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (id, o) => {
+      const r = await (
+        await lib('work-ops')
+      ).setDepends(process.cwd(), id, {
+        add: splitList(o.add),
+        remove: splitList(o.remove),
+        commit: o.commit,
+      });
+      console.log(`${id} depends on ${r.depends.join(', ') || 'nothing'}${shortHash(r.hash)}`);
+    });
+}
+
 function registerItemMoves(gcf) {
   const ops = () => lib('work-ops');
   gcf
@@ -741,6 +762,7 @@ function registerItemMoves(gcf) {
       const r = await (await ops()).prioritizeItems(process.cwd(), ids, { commit: o.commit });
       console.log(`ranked ${r.ids.join(', ')}${shortHash(r.hash)}`);
     });
+  registerDepends(gcf);
   const question = gcf.command('question').description('Open questions (gcf/open-questions.md)');
   question
     .command('answer <qid>')
@@ -861,6 +883,26 @@ async function inboxMove(commit, message, edit) {
   });
 }
 
+function registerInboxTag(inbox) {
+  inbox
+    .command('tag <in-id>')
+    .description('Add tags to an entry and remove others')
+    .option('--add <tags>', 'tags to add, comma-separated')
+    .option('--remove <tags>', 'tags to remove, comma-separated')
+    .option('--commit', 'commit it (gcf(inbox)): for a caller with no console, e.g. a board')
+    .action(async (id, o) => {
+      const { tagInbox } = await lib('inbox');
+      let tags = [];
+      const hash = await inboxMove(o.commit, `gcf(inbox): tag ${id}`, async (root) => {
+        ({ tags } = await tagInbox(root, id, {
+          add: splitList(o.add),
+          remove: splitList(o.remove),
+        }));
+      });
+      console.log(`${id} tags: ${tags.join(', ') || 'none'}${shortHash(hash)}`);
+    });
+}
+
 function registerInbox(gcf) {
   const inbox = gcf
     .command('inbox')
@@ -874,8 +916,9 @@ function registerInbox(gcf) {
           ? l
               .map((e) => {
                 const source = e.kind ? `lesson:${e.kind}:${e.item}` : e.source;
+                const tags = e.tags.length ? ` (tags: ${e.tags.join(', ')})` : '';
 
-                return `${e.id} [${source}] ${e.text}`;
+                return `${e.id} [${source}] ${e.text}${tags}`;
               })
               .join('\n')
           : 'inbox empty',
@@ -888,6 +931,7 @@ function registerInbox(gcf) {
     // A text that starts with a hyphen ("-5 fps on level 3") reads as a flag at every level of
     // ai-factory's commands, `--` included: as `--text=<text>` it stays one value.
     .option('--text <text>', 'the entry, when it starts with a hyphen')
+    .option('--tags <tags>', 'its tags, comma-separated: idea, later, ui:hud')
     .option('--commit', 'commit it (gcf(inbox)): for a caller with no console, e.g. a board')
     .action(async (arg, o) => {
       const text = o.text ?? arg;
@@ -896,10 +940,11 @@ function registerInbox(gcf) {
       const { addInbox } = await lib('inbox');
       let id = '';
       const hash = await inboxMove(o.commit, 'gcf(inbox): add', async (root) => {
-        id = (await addInbox(root, text, o.source)).id;
+        id = (await addInbox(root, text, o.source, { tags: splitList(o.tags) })).id;
       });
       console.log(`${id}${shortHash(hash)}`);
     });
+  registerInboxTag(inbox);
   inbox
     .command('drop <in-id>')
     .description('Erase an entry: triaged as noise, a duplicate, or turned into an item')
@@ -1061,12 +1106,18 @@ function registerBoard(gcf) {
       const tag = (i) =>
         `${i.id}${i.plan?.tasks !== undefined ? ` ${i.plan.done}/${i.plan.tasks}` : ''}` +
         `${i.running ? ' (running)' : ''}${i.verified ? ' (verified)' : ''}`;
-      const byId = new Map(r.items.map((i) => [i.id, i]));
       out(o.json, r, (x) =>
         [
           `phase: ${x.phase.phase ?? x.phase.error}`,
-          ...Object.entries(x.columns).map(
-            ([s, ids]) => `${s}: ${ids.map((id) => tag(byId.get(id))).join(', ') || '-'}`,
+          // Items come in run order, so each column lists its own in that order.
+          ...x.domain.columns.map(
+            ({ status }) =>
+              `${status}: ${
+                x.items
+                  .filter((i) => i.status === status)
+                  .map(tag)
+                  .join(', ') || '-'
+              }`,
           ),
           `wip: ${x.wip.count}/${x.wip.limit}`,
           `inbox: ${x.inbox.length}, open questions: ${x.questions.length}`,

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.7.15",
+  "version": "0.9.0",
   "description": "Game Context Framework for AI Factory",
   "skills": [
     "skills/gcf-init",

package/lib/aif-config.js

@@ -0,0 +1,22 @@
+// The language AI Factory sets in `.ai-factory/config.yaml` for what an agent writes to the
+// human: `language.ui`. GCF adds no setting of its own (Methodology §5.2.3); agents read the
+// file themselves, the core reads it only for the prompts it writes.
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+
+/**
+ * The project's `language.ui`, `en` by default. A missing or unreadable file gives `en`: the
+ * language is a preference, and a broken one must not stop the work.
+ */
+export async function uiLanguage(projectDir) {
+  try {
+    const file = path.join(path.resolve(projectDir), '.ai-factory', 'config.yaml');
+    const ui = YAML.parse(await readFile(file, 'utf8'))?.language?.ui;
+
+    // A language name or code, one word: anything else would break the prompt line it goes in.
+    return typeof ui === 'string' && /^[\w-]{2,32}$/.test(ui.trim()) ? ui.trim() : 'en';
+  } catch {
+    return 'en';
+  }
+}

package/lib/board.js

@@ -14,7 +14,7 @@ import { resolveInside } from './safe-path.js';
 import { wipOf } from './audit-core.js';
 import { runHolder } from './main-lock.js';
 import { ITEM_TYPES } from './validate-item.js';
-import { movesOf } from './transitions.js';
+import { domainOf, movesOf } from './transitions.js';
 import { openDepends } from './work-ops.js';
 import { listQuestions } from './questions.js';
 import { sessionActive } from './session-mark.js';
@@ -23,9 +23,7 @@ import { settingsOf } from './config-set.js';
 
 // The version of the JSON below (Methodology §11): a board refuses one it does not know. Bump it
 // when a field changes meaning or goes away; a new field does not bump it.
-export const BOARD_SCHEMA = 1;
-
-const COLUMNS = ['ready', 'blocked', 'awaiting-verdict', 'awaiting-decision', 'unplayed', 'parked'];
+export const BOARD_SCHEMA = 2;
 
 /**
  * Plan progress `{tasks, done}` from its checkboxes and the plan's project path, both null
@@ -134,6 +132,26 @@ async function phaseOf(projectDir) {
   }
 }
 
+/**
+ * The AI Factory extensions the project has, name → version, from `.ai-factory.json`: the board
+ * shows which framework packages a project runs. `{}` when the file is missing or unreadable.
+ */
+async function extensionsOf(projectDir) {
+  try {
+    const cfg = JSON.parse(
+      await readFile(path.join(path.resolve(projectDir), '.ai-factory.json'), 'utf8'),
+    );
+
+    return Object.fromEntries(
+      (cfg.extensions ?? [])
+        .filter((e) => typeof e?.name === 'string')
+        .map((e) => [e.name, typeof e.version === 'string' ? e.version : null]),
+    );
+  } catch {
+    return {};
+  }
+}
+
 /** The release block with every field: one a malformed block lacks is null (live check says so). */
 const releaseOf = (r) =>
   r && {
@@ -274,6 +292,9 @@ export async function board(projectDir) {
   const inbox = await listInbox(root);
   // Where agents struggle: the lessons in the inbox each item's sessions left.
   for (const i of items) i.lessons = inbox.filter((e) => e.item === i.id).length;
+  // The reverse of depends: the items on the board that wait for this one.
+  for (const i of items)
+    i.needed_by = items.filter((o) => o.depends.includes(i.id)).map((o) => o.id);
 
   const config = await readConfig(root);
   const live = await readLive(root);
@@ -291,11 +312,11 @@ export async function board(projectDir) {
       compact_pct: config.auto_compact_pct,
     },
     phase: await phaseOf(projectDir),
+    extensions: await extensionsOf(projectDir),
     // A malformed block reads with fields missing (live check names it): null, not absent.
     release: releaseOf(live.release),
-    columns: Object.fromEntries(
-      COLUMNS.map((s) => [s, items.filter((i) => i.status === s).map((i) => i.id)]),
-    ),
+    // The columns and the moves as data (Board-PRD decision 16): the board hard-codes neither.
+    domain: domainOf(),
     items,
     wip: wipOf(ledger.items, config),
     inbox,

package/lib/design-check.js

@@ -557,10 +557,10 @@ function ledgerIssues(ledger) {
 }
 
 /**
- * M2 over `depends:` of units and items together: a cycle never gets played — every id in it
- * waits for the next one. Each cycle is reported once, from the id DFS meets it at.
+ * `depends:` of every unit and item: id → the ids it waits for. A feature also waits for its
+ * children: it closes only after them, so a child that depends on it never gets played.
  */
-export function dependsCycles(ledger) {
+export function dependsGraph(ledger) {
   /** @type {Map<string, string[]>} */
   const graph = new Map();
   for (const u of ledger.design.flatMap((d) => d.units)) {
@@ -568,7 +568,43 @@ export function dependsCycles(ledger) {
     graph.set(u.id, Array.isArray(list) ? list : []);
   }
 
-  for (const c of ledger.items) graph.set(String(c.data.id), c.data.depends ?? []);
+  for (const c of ledger.items) {
+    const children = c.data.type === 'feature' ? (c.data.children ?? []) : [];
+    graph.set(String(c.data.id), [...(c.data.depends ?? []), ...children]);
+  }
+
+  return graph;
+}
+
+/** The ids from `from` to `to` over `graph`, both included, or null when there is no way. */
+export function pathTo(graph, from, to, seen = new Set()) {
+  if (from === to) return [to];
+  if (seen.has(from)) return null;
+  seen.add(from);
+  for (const next of graph.get(from) ?? []) {
+    const rest = pathTo(graph, next, to, seen);
+    if (rest) return [from, ...rest];
+  }
+
+  return null;
+}
+
+/** Why a depends `cycle` (its ids, the first again at the end) never gets played. */
+export function cycleMessage(ledger, cycle) {
+  const feature = cycle.some((id) => ledger.item(id)?.data.type === 'feature');
+
+  return (
+    `depends cycle ${cycle.join(' -> ')}: none of them can be played first` +
+    (feature ? ' (a feature waits for its children)' : '')
+  );
+}
+
+/**
+ * M2 over `depends:` of units and items together: a cycle never gets played — every id in it
+ * waits for the next one. Each cycle is reported once, from the id DFS meets it at.
+ */
+export function dependsCycles(ledger) {
+  const graph = dependsGraph(ledger);
   /** @type {Issue[]} */
   const out = [];
   const state = new Map(); // id → 'open' while on the DFS path, 'done' after
@@ -583,7 +619,7 @@ export function dependsCycles(ledger) {
         file,
         line: 1,
         id,
-        message: `depends cycle ${cycle.join(' -> ')}: none of them can be played first`,
+        message: cycleMessage(ledger, cycle),
       });
 
       return;

package/lib/inbox.js

@@ -1,6 +1,8 @@
 // gcf/inbox.md (Methodology §5.1): raw input waiting for triage — playtest notes, CI failures,
-// the agent's ideas and requests. One line per entry, `- <in-id> | <source> | <text>`; a triaged
-// line is erased, not marked: the file holds what is still waiting, not what happened to it.
+// the agent's ideas and requests, the operator's ideas and notes. One line per entry,
+// `- <in-id> | <source> | <text>[ | tags: a, b]`; a triaged line is erased, not marked: the file
+// holds what is still waiting, not what happened to it. Tags sort it; an older core reads the
+// tags field as part of the text, which loses nothing.
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { createHash } from 'node:crypto';
@@ -8,48 +10,136 @@ import path from 'node:path';
 import { atomicWrite } from './safe-path.js';
 
 export const INBOX_HEAD =
-  '# Inbox — `- <in-id> | <source> | <text>`, raw input waiting for triage; a triaged line ' +
-  'is erased\n';
+  '# Inbox — `- <in-id> | <source> | <text>[ | tags: a, b]`, raw input waiting for triage; a ' +
+  'triaged line is erased\n';
 export const SOURCES = ['playtest', 'ci', 'agent', 'operator'];
 const LINE = /^- (in-[0-9a-f]+) \| (\S+) \| (.+)$/;
+// The text may hold ` | ` itself: the tags are only the field at the very end.
+const TAGS = / \| tags: ([^|]*)$/;
+const TAG = /^[a-z0-9][a-z0-9:-]{0,39}$/;
 // An agent's lesson (lessons.js): `lesson:<kind>:<item-id>`.
 const LESSON = /^lesson:([a-z]+):([a-z0-9][a-z0-9-]*)$/;
 
 const inboxFile = (root) => path.join(root, 'inbox.md');
 
+/**
+ * The text and the tags of a line's last field. A field that is not a clean tag list (a bad
+ * tag, a tag twice, no text before it) stays part of the text: nothing written is lost.
+ */
+function textAndTags(rest) {
+  const m = rest.match(TAGS);
+  const tags = m ? m[1].split(',').map((t) => t.trim()) : [];
+  const text = m ? rest.slice(0, m.index).trim() : '';
+  const clean = tags.every((t) => TAG.test(t)) && new Set(tags).size === tags.length;
+  if (!m || !clean || !text) return { text: rest.trim(), tags: [] };
+
+  return { text, tags };
+}
+
+const lineOf = (e) =>
+  `- ${e.id} | ${e.source} | ${e.text}${e.tags.length ? ` | tags: ${e.tags.join(', ')}` : ''}`;
+
+/** The entry of one line as written, or null. */
+function rawOf(line) {
+  const m = line.match(LINE);
+
+  return m ? { id: m[1], source: m[2], ...textAndTags(m[3]) } : null;
+}
+
+/**
+ * One entry per id. A union merge of two branches that tagged an entry differently leaves two
+ * lines with its id: they read as one, its first line's text with the tags of both.
+ */
+function mergeById(raws) {
+  /** @type {Map<string, {id: string, source: string, text: string, tags: string[]}>} */
+  const byId = new Map();
+  for (const r of raws) {
+    const seen = byId.get(r.id);
+    if (seen) seen.tags = [...new Set([...seen.tags, ...r.tags])];
+    else byId.set(r.id, { ...r });
+  }
+
+  return [...byId.values()];
+}
+
 /**
  * Every entry; a lesson reads as source `lesson` with its `kind` and the `item` it came from.
- * @typedef {{id: string, source: string, text: string, kind?: string, item?: string}} Entry
+ * @typedef {{id: string, source: string, text: string, tags: string[], kind?: string,
+ *   item?: string}} Entry
  * @returns {Promise<Entry[]>}
  */
 export async function listInbox(root) {
   const file = inboxFile(root);
   if (!existsSync(file)) return [];
+  const raws = (await readFile(file, 'utf8')).split(/\r?\n/).map(rawOf).filter(Boolean);
 
-  return (await readFile(file, 'utf8')).split(/\r?\n/).flatMap((l) => {
-    const m = l.match(LINE);
-    if (!m) return [];
-    const lesson = m[2].match(LESSON);
-    const entry = { id: m[1], source: m[2], text: m[3].trim() };
+  return mergeById(/** @type {any[]} */ (raws)).map((entry) => {
+    const lesson = entry.source.match(LESSON);
 
-    return [lesson ? { ...entry, source: 'lesson', kind: lesson[1], item: lesson[2] } : entry];
+    return lesson ? { ...entry, source: 'lesson', kind: lesson[1], item: lesson[2] } : entry;
   });
 }
 
-/** Append an entry; its id hashes the text and the moment, so two branches never collide. */
-export async function addInbox(root, text, source = 'operator', now = new Date().toISOString()) {
+/** Refuse a tag that is not a lowercase word (`idea`, `later`, `ui:hud`). */
+function checkTags(tags) {
+  const bad = tags.find((t) => !TAG.test(t));
+  if (bad !== undefined)
+    throw new Error(`tag "${bad}" must be a lowercase word: letters, digits, - and :`);
+  if (new Set(tags).size !== tags.length) throw new Error('a tag is named twice');
+}
+
+/**
+ * Append an entry with its `tags`; its id hashes the text and the moment (`now`), so two
+ * branches never collide.
+ */
+export async function addInbox(
+  root,
+  text,
+  source = 'operator',
+  { now = new Date().toISOString(), tags = [] } = {},
+) {
   const clean = String(text).replace(/\s+/g, ' ').trim();
   if (!clean) throw new Error('an inbox entry needs text');
   if (!SOURCES.includes(source) && !LESSON.test(source))
     throw new Error(`source must be ${SOURCES.join(' | ')}`);
+  if (textAndTags(clean).tags.length)
+    throw new Error('the text ends like a tags field: give tags as tags');
+  checkTags(tags);
   const id = `in-${createHash('sha1').update(`${now}\n${clean}`).digest('hex').slice(0, 8)}`;
   const file = inboxFile(root);
   const old = existsSync(file) ? await readFile(file, 'utf8') : INBOX_HEAD;
   const eol = old.includes('\r\n') ? '\r\n' : '\n';
   const head = old.endsWith('\n') ? old : old + eol;
-  await atomicWrite(file, `${head}- ${id} | ${source} | ${clean}${eol}`);
+  const entry = { id, source, text: clean, tags };
+  await atomicWrite(file, `${head}${lineOf(entry)}${eol}`);
+
+  return entry;
+}
+
+/**
+ * Add tags to entry `id` and remove others; refuses one it has, or lacks, already. Lines a
+ * union merge doubled become one again, at the first one's place.
+ */
+export async function tagInbox(root, id, { add = [], remove = [] }) {
+  if (!add.length && !remove.length) throw new Error('name tags to --add or --remove');
+  checkTags([...add, ...remove]);
+  const file = inboxFile(root);
+  const lines = (existsSync(file) ? await readFile(file, 'utf8') : '').split(/(?<=\n)/);
+  const bodyOf = (l) => l.replace(/\r?\n$/, '');
+  const mine = lines.flatMap((l, i) => (rawOf(bodyOf(l))?.id === id ? [i] : []));
+  if (!mine.length) throw new Error(`${id} is not in gcf/inbox.md`);
+  const [entry] = mergeById(mine.map((i) => /** @type {any} */ (rawOf(bodyOf(lines[i])))));
+  const had = add.filter((x) => entry.tags.includes(x));
+  if (had.length) throw new Error(`${id} is tagged ${had.join(', ')} already`);
+  const missing = remove.filter((x) => !entry.tags.includes(x));
+  if (missing.length) throw new Error(`${id} has no tag ${missing.join(', ')}`);
+  entry.tags = [...entry.tags.filter((x) => !remove.includes(x)), ...add];
+  // The line keeps its own ending: a CRLF file stays CRLF.
+  const first = lines[mine[0]];
+  lines[mine[0]] = `${lineOf(entry)}${first.slice(bodyOf(first).length)}`;
+  await atomicWrite(file, lines.filter((_, i) => !mine.slice(1).includes(i)).join(''));
 
-  return { id, source, text: clean };
+  return entry;
 }
 
 /** Erase entry `id`; refuses an id the inbox does not hold. */

package/lib/lessons.js

@@ -5,6 +5,7 @@
 // the session ends: the harness asks them in one more turn, `/gcf-run` asks them at its close.
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
+import { uiLanguage } from './aif-config.js';
 import { readRawConfig } from './gcf-paths.js';
 import { addInbox } from './inbox.js';
 import { isValidId } from './id.js';
@@ -66,6 +67,7 @@ function questionsOf(config) {
 export async function lessonsPrompt(projectDir, id, { reply = 'cli' } = {}) {
   if (!isValidId(id)) throw new Error(`${id} is not an item id`);
   const config = lessonsConfig(await readRawConfig(path.join(path.resolve(projectDir), 'gcf')));
+  const ui = await uiLanguage(projectDir);
   const asked = questionsOf(config)
     .map((q, i) => `${i + 1}. ${q.kind}: ${q.text}`)
     .join('\n');
@@ -83,6 +85,10 @@ export async function lessonsPrompt(projectDir, id, { reply = 'cli' } = {}) {
       'what got in your way, so it can be removed.',
     'Answer from this session only, one finding per entry, in a sentence or two; skip a ' +
       'question with nothing to say, and never invent one.',
+    // The operator reads the answers: they go in the project's language.ui (Methodology §5.2.3).
+    ...(ui === 'en'
+      ? []
+      : [`Write each finding in the language "${ui}"; keep the kinds as they are.`]),
     asked,
     // The harness's turn comes after the item's commit and its verified trailer: an edit then
     // would leave the checkout dirty or move the trailer off the tip.
@@ -104,7 +110,10 @@ function lessonOf(raw, i) {
   if (!text) throw new Error(`lesson ${i + 1} has no text`);
   const where = raw?.where ? String(raw.where).replace(/\s+/g, ' ').trim() : '';
 
-  return { kind, text: where ? `${text} (${where})` : text };
+  // An agent's free text must not read as an inbox tags field, nor fail the whole batch on it.
+  const full = (where ? `${text} (${where})` : text).replace(/ \| tags:/g, ' / tags:');
+
+  return { kind, text: full };
 }
 
 /**

package/lib/transitions.js

@@ -1,13 +1,14 @@
 // Methodology §4. A work item FILE carries one of the stored statuses; `running` and `verify` are
 // read from the run (worktree + session), never written. A terminal move deletes the file and
 // writes a history or graveyard line in the same commit, so no terminal status is ever stored.
+// The order is the board's column order.
 export const STORED = [
   'ready',
+  'blocked',
   'awaiting-verdict',
   'awaiting-decision',
-  'blocked',
-  'parked',
   'unplayed',
+  'parked',
 ];
 
 // The status each command takes an item from (§4.1). `drop` leaves from any stored status.
@@ -66,3 +67,133 @@ export const movesOf = (data) =>
 export function isStorable(status) {
   return STORED.includes(status);
 }
+
+// The board's words for each stored status (Board-PRD decision 16): a column's label and tooltip.
+const COLUMN_TEXT = {
+  ready: ['ready', 'Waits for a run; the order here is the run order'],
+  blocked: ['blocked', 'Stopped: waits for an answer, an asset or a fix of a failed check'],
+  'awaiting-verdict': ['awaiting verdict', 'Built; waits for a playtest and a keep, tune or kill'],
+  'awaiting-decision': ['awaiting decision', 'Waits for the operator to decide: go, no, close…'],
+  unplayed: ['unplayed', 'Closed without a playtest; waits for one'],
+  parked: ['parked', 'A bug kept as a known issue; unblock takes it back to ready'],
+};
+
+// The form of each move (§4.1) for a board: the `ai-factory gcf` words with `{id}` for the item,
+// and the fields the operator fills. A field goes as `--<flag or key>=<value>`; a list repeats
+// it; `remove` is `--remove` / `--no-remove`, or the command's own rule when left empty.
+const REASON = { key: 'reason', label: 'Reason', kind: 'longtext', required: true };
+const OPTIONAL_REASON = { ...REASON, required: false };
+const REMOVE = { key: 'remove', label: 'Removal item for its code', kind: 'remove' };
+const CONSTRAINT = { key: 'constraint', label: 'Constraint lines', kind: 'list' };
+// close and submit need a green gcf verify of the code as it is now; the operator may say why
+// they go without one, and the reason goes into the move's commit.
+const UNVERIFIED = {
+  key: 'unverified',
+  label: 'No green gcf verify? Why it goes anyway',
+  kind: 'text',
+};
+
+const verdict = (v, help, fields, danger) => ({
+  label: v,
+  help,
+  args: ['verdict', '{id}', v],
+  fields,
+  ...(danger && { danger }),
+});
+const decide = (choice, help, fields = [], danger) => ({
+  label: choice,
+  help,
+  args: ['decide', '{id}', choice],
+  fields,
+  ...(danger && { danger }),
+});
+
+const SPECS = {
+  submit: {
+    label: 'submit',
+    help: 'Built: on to awaiting verdict or awaiting decision, by its gate',
+    args: ['submit', '{id}'],
+    fields: [UNVERIFIED],
+    rare: true,
+  },
+  close: {
+    label: 'close',
+    help: 'Done, gate auto: to history; a mechanic or a resource waits unplayed',
+    args: ['close', '{id}'],
+    fields: [CONSTRAINT, UNVERIFIED],
+    rare: true,
+  },
+  'verdict:keep': verdict('keep', 'Played and kept: it goes to history', [
+    { key: 'note', label: 'Note', kind: 'text' },
+    CONSTRAINT,
+  ]),
+  'verdict:tune': verdict('tune', 'Played; needs a change: back to ready with the note', [
+    { key: 'note', label: 'What to change', kind: 'longtext', required: true },
+  ]),
+  'verdict:kill': verdict(
+    'kill',
+    'Played and rejected: it goes to the graveyard',
+    [{ key: 'note', label: 'Why', kind: 'longtext' }, REMOVE],
+    true,
+  ),
+  'decide:go': decide('go', 'Approved: it goes to history as decided'),
+  'decide:no': decide(
+    'no',
+    'Not doing it: it goes to the graveyard',
+    [OPTIONAL_REASON, REMOVE],
+    true,
+  ),
+  'decide:wontfix': decide(
+    'wontfix',
+    'A bug left as it is: it goes to the graveyard',
+    [OPTIONAL_REASON, REMOVE],
+    true,
+  ),
+  'decide:known': decide('known', 'A bug kept as a known issue: it goes to parked'),
+  'decide:close': decide('close', 'The feature is done: it goes to history'),
+  'decide:continue': decide('continue', 'The feature goes on: back to ready for more children'),
+  'decide:kill': decide(
+    'kill',
+    'The feature is dropped: it goes to the graveyard with its live children',
+    [OPTIONAL_REASON],
+    true,
+  ),
+  block: {
+    label: 'block',
+    help: 'Stop it until the operator answers',
+    args: ['block', '{id}'],
+    fields: [REASON],
+  },
+  unblock: {
+    label: 'unblock',
+    help: 'The answer is given: back to ready (a feature with a dead child: to a decision)',
+    args: ['unblock', '{id}'],
+    fields: [{ key: 'note', label: 'Answer or "file: <path>"', kind: 'longtext' }],
+    drag: 'ready',
+  },
+  drop: {
+    label: 'drop',
+    help: 'Off the board into the graveyard, from any status',
+    args: ['drop', '{id}'],
+    fields: [REASON, { key: 'tags', label: 'Graveyard tags', kind: 'text' }, REMOVE],
+    danger: true,
+    rare: true,
+    drag: 'graveyard',
+  },
+};
+
+/**
+ * The GCF domain of the board read (Board-PRD decision 16): its columns in order, the status a
+ * run starts from, and the form of every move `movesOf` may name. A board draws these and
+ * builds each command from `args` and `fields`; it hard-codes none of them.
+ */
+export const domainOf = () => ({
+  kind: 'gcf',
+  runs_from: 'ready',
+  columns: STORED.map((status) => ({
+    status,
+    label: COLUMN_TEXT[status][0],
+    help: COLUMN_TEXT[status][1],
+  })),
+  moves: Object.fromEntries(Object.keys(FROM).map((m) => [m, SPECS[m]])),
+});