gcf-aif-ext 0.2.7 → 0.4.0

package/lib/design.js

@@ -0,0 +1,179 @@
+// Design Model (GCF-PRD §5.7): gcf/design/<system>.md holds design units, one `## <id>`
+// section each. A unit's body is the body its work item carries once it is taken into work,
+// so one CNL-P profile per type serves both places.
+import { readFile, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseBlocks, itemsOf, readRecords, loadProfileAt } from 'cnlp-kit';
+
+export const SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+export const UNIT_TYPES = ['mechanic', 'resource', 'rule', 'constraint', 'entity'];
+// A soft unit waits for a verdict by default; a hard one closes by its tests.
+export const CARD_TYPES = ['mechanic', 'resource'];
+export const HEADER_KEYS = [
+  'type',
+  'title',
+  'route',
+  'system',
+  'milestone',
+  'pillars',
+  'depends',
+  'source',
+  'flags',
+  'reopens',
+];
+// Engineering decisions of the agent, not words of the designer: no provenance needed.
+export const AGENT_SLOTS = ['check', 'measure', 'contract', 'interactions'];
+
+const PROFILES_DIR = fileURLToPath(new URL('../profiles/', import.meta.url));
+
+/** The CNL-P profile of a document kind shipped in profiles/ (`unit-mechanic`, `game`, …). */
+export const loadDocProfile = (name) => loadProfileAt(path.join(PROFILES_DIR, `${name}.md`));
+
+/** `[a, b]`, `a, b` → ['a', 'b']; `none` and `[]` → []; `TBD` stays the string 'TBD'. */
+export function listOf(value) {
+  const v = String(value ?? '').trim();
+  if (v === 'TBD') return 'TBD';
+  const inner = v.replace(/^\[|\]$/g, '').trim();
+  if (!inner || inner === 'none') return [];
+
+  return inner
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * @typedef {object} Unit
+ * @property {string} id
+ * @property {string} file    gcf-relative path of the design file
+ * @property {string} system  the subsystem the file names
+ * @property {number} line    1-based line of the `## <id>` heading
+ * @property {Record<string, string>} header
+ * @property {Record<string, number>} headerLines
+ * @property {string} body    the blocks below the header
+ * @property {number} bodyLine 1-based file line the body starts at
+ */
+
+/** Header fields at the top of a unit: `key: value` lines until the first other key. */
+function splitHeader(lines, start) {
+  /** @type {Record<string, string>} */
+  const header = {};
+  /** @type {Record<string, number>} */
+  const headerLines = {};
+  let i = 0;
+  for (; i < lines.length; i++) {
+    if (!lines[i].trim()) continue;
+    const m = lines[i].match(/^([a-z_]+):\s*(.*)$/);
+    if (!m || !HEADER_KEYS.includes(m[1]) || m[1] in header) break;
+    header[m[1]] = m[2].trim();
+    headerLines[m[1]] = start + i;
+  }
+
+  return { header, headerLines, rest: i };
+}
+
+/**
+ * One design file → `{ system, file, preamble, units }`. The preamble is everything above the
+ * first `## <id>`: the `# <system>` title and the subsystem's `purpose:` block.
+ */
+export function parseDesign(text, system, file = `design/${system}.md`) {
+  const lines = String(text).split(/\r?\n/);
+  const starts = lines.flatMap((l, i) => (/^## \S/.test(l) ? [i] : []));
+  const preamble = lines.slice(0, starts[0] ?? lines.length).join('\n');
+  /** @type {Unit[]} */
+  const units = starts.map((at, n) => {
+    const chunk = lines.slice(at + 1, starts[n + 1] ?? lines.length);
+    const { header, headerLines, rest } = splitHeader(chunk, at + 2);
+
+    return {
+      id: lines[at].slice(3).trim(),
+      file,
+      system,
+      line: at + 1,
+      header,
+      headerLines,
+      body: chunk.slice(rest).join('\n'),
+      bodyLine: at + 2 + rest,
+    };
+  });
+
+  return { system, file, preamble, units };
+}
+
+/** Every design file of a project, parsed; [] when gcf/design/ does not exist. */
+export async function readDesign(root) {
+  const dir = path.join(root, 'design');
+  if (!existsSync(dir)) return [];
+  const names = (await readdir(dir)).filter((n) => n.endsWith('.md')).sort();
+
+  return Promise.all(
+    names.map(async (n) =>
+      parseDesign(await readFile(path.join(dir, n), 'utf8'), n.slice(0, -3), `design/${n}`),
+    ),
+  );
+}
+
+/** A scalar `key:` value from a preamble or a body. */
+export function scalarIn(text, key) {
+  return parseBlocks(text).sections.find((s) => s.key === key)?.value ?? '';
+}
+
+/**
+ * Every value a body's slots carry: a scalar, a bullet, or a record value other than `name`
+ * (a record's name addresses it, it states nothing). `provenance` is metadata, not a slot.
+ */
+export function slotValues(body, profile) {
+  const { lines, sections } = parseBlocks(body);
+  const forms = new Map(profile.sections.map((s) => [s.key, s.form]));
+  const out = [];
+  for (const s of sections.filter((x) => x.key !== 'provenance')) {
+    if (s.value) {
+      out.push({ block: s.key, value: s.value, line: s.line, name: null });
+      continue;
+    }
+
+    const items = itemsOf(lines, s.line);
+    if (forms.get(s.key) === 'record-list') out.push(...recordValues(s.key, items));
+    else
+      out.push(
+        ...items.map((i) => ({
+          block: s.key,
+          value: i.text.replace(/^- /, ''),
+          line: i.line,
+          name: null,
+        })),
+      );
+  }
+
+  return out;
+}
+
+function recordValues(block, items) {
+  const out = [];
+  for (const rec of readRecords(items).records) {
+    const name = rec.values.name ?? null;
+    for (const k of rec.keys.filter((x) => x !== 'name')) {
+      out.push({ block, value: rec.values[k], line: rec.line, name });
+    }
+  }
+
+  return out;
+}
+
+/** The provenance records of a body: `{ slot, src, quote, answer, assumed, line }`. */
+export function provenanceOf(body) {
+  const { lines, sections } = parseBlocks(body);
+  const at = sections.find((s) => s.key === 'provenance');
+  if (!at) return [];
+
+  return readRecords(itemsOf(lines, at.line)).records.map((r) => ({
+    ...r.values,
+    quote: r.values.quote?.replace(/^"/, '').replace(/"$/, ''),
+    line: r.line,
+  }));
+}
+
+/** A value that says "not known yet": the whole value, or the tail of `- <subject>: TBD`. */
+export const isTbd = (v) => v === 'TBD' || /: TBD$/.test(v);

package/lib/gcf-paths.js

@@ -1,5 +1,5 @@
 import { readFile, readdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import path from 'node:path';
 import YAML from 'yaml';
 import { parse } from './frontmatter.js';
@@ -13,6 +13,9 @@ const DEFAULT_CONFIG = {
   context_budget: 30000,
   pillars_budget: 1500,
   envelope_default_spread: 0.3,
+  unplayed_warn_after: 5,
+  plan_passes: 5,
+  dod_attempts: 2,
 };
 
 /** `gcf/` lives at the repository root (GCF-PRD §5.1). Throws when absent. */
@@ -64,7 +67,15 @@ async function listDocs(dir) {
   return out;
 }
 
-export const listCards = (root) => listDocs(path.join(root, 'cards'));
+export const listItems = (root) => listDocs(path.join(root, 'work'));
+
+/** Schema 2 card files left in gcf/cards/: GCF 0.4 reads gcf/work/ and does not migrate them. */
+export function legacyCards(root) {
+  const dir = path.join(root, 'cards');
+
+  return existsSync(dir) ? readdirSync(dir).filter((n) => n.endsWith('.md')) : [];
+}
+
 export const listSystems = (root) => listDocs(path.join(root, 'systems'));
 
 /** First bullet of a `key:` block in a CNL-P body, for one-line descriptions. */

package/lib/git.js

@@ -1,6 +1,69 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 
+// `git commit --only <paths>` is a partial commit, which git refuses outright while a merge
+// or a sequencer operation is in progress. Detect it up front so the failure has a reason.
+const IN_PROGRESS = [
+  'MERGE_HEAD',
+  'CHERRY_PICK_HEAD',
+  'REVERT_HEAD',
+  'rebase-merge',
+  'rebase-apply',
+];
+
+/** The name of the merge or sequencer operation in progress, or null. */
+export function operationInProgress(projectDir) {
+  const gitDir = spawnSync('git', ['rev-parse', '--git-dir'], {
+    cwd: projectDir,
+    encoding: 'utf8',
+  });
+  if (gitDir.status !== 0) return null;
+  const dir = path.resolve(projectDir, gitDir.stdout.trim());
+
+  return IN_PROGRESS.find((name) => existsSync(path.join(dir, name))) ?? null;
+}
+
+const tracked = (projectDir, p) =>
+  spawnSync('git', ['ls-files', '--error-unmatch', '--', p], { cwd: projectDir, stdio: 'ignore' })
+    .status === 0;
+
+/**
+ * Paths with uncommitted changes, staged or not. A move stages whole files, so a user's own
+ * edit in one of them would ride along in the move's commit unseen.
+ */
+export function dirtyPaths(projectDir, paths) {
+  // No existence filter: a staged deletion is neither on disk nor in the index, and a move
+  // writing that file anew would commit away every line the deleted file held.
+  if (!paths.length) return [];
+  const res = spawnSync('git', ['status', '--porcelain', '--', ...paths], {
+    cwd: projectDir,
+    encoding: 'utf8',
+  });
+
+  return res.status === 0 ? res.stdout.split('\n').filter(Boolean) : [];
+}
+
+/**
+ * Stage and commit exactly `paths`: `git add -- gcf/` would stage a user's unrelated edits
+ * under gcf/, and a rollback only restores what it snapshotted. A path that neither exists nor
+ * is tracked is left out — git refuses a pathspec that matches nothing. Returns the new HEAD.
+ */
+export function commitPaths(projectDir, message, paths) {
+  const real = paths.filter((p) => existsSync(p) || tracked(projectDir, p));
+  for (const p of real) spawnSync('git', ['add', '--', p], { cwd: projectDir, stdio: 'ignore' });
+  const res = spawnSync('git', ['commit', '-m', message, '--only', '--', ...real], {
+    cwd: projectDir,
+    encoding: 'utf8',
+  });
+  if (res.status !== 0) throw new Error(`commit failed: ${res.stderr || res.stdout}`);
+
+  return spawnSync('git', ['rev-parse', 'HEAD'], {
+    cwd: projectDir,
+    encoding: 'utf8',
+  }).stdout.trim();
+}
+
 /**
  * The stage-0 index entry (mode + blob) of each file, or `entry: null` when the index
  * holds none. Paths are taken relative to `cwd` (an existing directory inside the work

package/lib/id.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
 
-// GCF-PRD §5.2/§5.5: candidates are `cand-NNN`, cards are `card-NNN`; a card keeps the
-// candidate's number on materialization. The slug lives next to the id, not inside it.
-const ID_RE = /^(card|cand)-\d{3}$/;
+// GCF-PRD §5.8: a unit's id is a slug, one for every stage — the `## <id>` section in design/,
+// the work item work/<id>.md, the history or graveyard line, the move's commit. Frozen once made.
+const ID_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 
-/** Derive a stable slug from a free-text name. Created once; never re-derived. */
+/** Derive a slug from a free-text name. Created once; never re-derived. */
 export function slugify(name) {
   const slug = String(name)
     .toLowerCase()
@@ -19,15 +19,7 @@ export function isValidId(id) {
   return ID_RE.test(String(id ?? ''));
 }
 
-/** `cand-012` → `card-012`: materialization keeps the number (GCF-PRD §5.2). */
-export function candToCard(candId) {
-  const m = String(candId).match(/^cand-(\d{3})$/);
-  if (!m) throw new Error(`Not a candidate id: ${candId}`);
-
-  return `card-${m[1]}`;
-}
-
-/** Card filename invariant: `cards/<id>-<slug>.md`. */
-export function stemMatches(file, id, slug) {
-  return path.basename(file, '.md') === `${id}-${slug}`;
+/** Work item filename invariant: `work/<id>.md`. */
+export function stemMatches(file, id) {
+  return path.basename(file, '.md') === id;
 }

package/lib/inbox.js

@@ -0,0 +1,54 @@
+// 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.
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+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';
+export const SOURCES = ['playtest', 'ci', 'agent', 'operator'];
+const LINE = /^- (in-[0-9a-f]+) \| (\S+) \| (.+)$/;
+
+const inboxFile = (root) => path.join(root, 'inbox.md');
+
+/** @returns {Promise<Array<{id: string, source: string, text: string}>>} */
+export async function listInbox(root) {
+  const file = inboxFile(root);
+  if (!existsSync(file)) return [];
+
+  return (await readFile(file, 'utf8')).split(/\r?\n/).flatMap((l) => {
+    const m = l.match(LINE);
+
+    return m ? [{ id: m[1], source: m[2], text: m[3].trim() }] : [];
+  });
+}
+
+/** 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()) {
+  const clean = String(text).replace(/\s+/g, ' ').trim();
+  if (!clean) throw new Error('an inbox entry needs text');
+  if (!SOURCES.includes(source)) throw new Error(`source must be ${SOURCES.join(' | ')}`);
+  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}`);
+
+  return { id, source, text: clean };
+}
+
+/** Erase entry `id`; refuses an id the inbox does not hold. */
+export async function dropInbox(root, id) {
+  const file = inboxFile(root);
+  const text = existsSync(file) ? await readFile(file, 'utf8') : '';
+  const lines = text.split(/(?<=\n)/);
+  // Each split line keeps its own ending, and `$` without the m flag does not stop before it.
+  const kept = lines.filter((l) => l.replace(/\r?\n$/, '').match(LINE)?.[1] !== id);
+  if (kept.length === lines.length) throw new Error(`${id} is not in gcf/inbox.md`);
+  await atomicWrite(file, kept.join(''));
+}

package/lib/index-gen.js

@@ -1,23 +1,39 @@
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { listCards, listSystems, firstBullet } from './gcf-paths.js';
+import { listItems, listSystems, firstBullet } from './gcf-paths.js';
+import { parseLive } from './live.js';
 import { atomicWrite } from './safe-path.js';
+import { readDesign, slotValues, loadDocProfile, isTbd, UNIT_TYPES } from './design.js';
 
 /**
  * INDEX.md is a deterministic function of gcf/ contents (GCF-PRD §5.1): generated,
  * never hand-written. The pre-commit hook regenerates it and stages the result.
  */
+const SINGLETONS = [
+  ['pillars', 'PILLARS.md', 'pillars and negative invariants'],
+  ['game', 'game.md', 'vision, scope and milestones'],
+  ['glossary', 'glossary.md', 'terms and forbidden synonyms'],
+];
+
 export async function generate(root) {
   const lines = ['# INDEX — generated, do not edit', ''];
   const row = ([type, file, status, system, descr]) =>
     lines.push(`${type} | gcf/${file} | ${status} | ${system} | ${descr}`);
 
-  if (existsSync(path.join(root, 'PILLARS.md')))
-    row(['pillars', 'PILLARS.md', '-', '-', 'pillars and negative invariants']);
+  for (const [type, file, descr] of SINGLETONS) {
+    if (existsSync(path.join(root, file))) row([type, file, '-', '-', descr]);
+  }
+
   const backlog = await readIfExists(root, 'backlog.md');
   if (backlog !== null) {
-    row(['backlog', 'backlog.md', '-', '-', `${count(backlog, /^- cand-/gm)} candidates`]);
+    row(['backlog', 'backlog.md', '-', '-', `${count(backlog, /^- \S+/gm)} units in order`]);
+  }
+
+  // One row per subsystem, not per unit: INDEX is the one file read whole.
+  for (const d of await readDesign(root)) {
+    const tbd = await tbdCount(d.units);
+    row(['design', d.file, '-', d.system, `${d.units.length} units, ${tbd} TBD`]);
   }
 
   for (const s of await listSystems(root)) {
@@ -25,15 +41,8 @@ export async function generate(root) {
     row(['system', `systems/${s.name}`, '-', s.data.system ?? '-', purpose]);
   }
 
-  for (const c of await listCards(root)) {
-    const system = (c.data.system ?? []).join(',');
-    row(['card', `cards/${c.name}`, c.data.status ?? '?', system, firstBullet(c.body, 'behavior')]);
-  }
-
-  const graveyard = await readIfExists(root, 'graveyard.md');
-  if (graveyard !== null) {
-    row(['graveyard', 'graveyard.md', '-', '-', `${count(graveyard, /^- card-/gm)} killed ideas`]);
-  }
+  await workRows(root, row);
+  await endRows(root, row);
 
   const txt = await readIfExists(root, 'open-questions.md');
   if (txt !== null) {
@@ -45,6 +54,35 @@ export async function generate(root) {
   return `${lines.join('\n')}\n`;
 }
 
+/** One row per work item, then the inbox and LIVE.md counts. */
+async function workRows(root, row) {
+  for (const c of await listItems(root)) {
+    const system = (c.data.system ?? []).join(',') || '-';
+    const kind = `${c.data.type ?? '?'}/${c.data.gate ?? '?'}`;
+    const descr = `${kind}: ${c.data.title ?? firstBullet(c.body, 'intent')}`;
+    row(['item', `work/${c.name}`, c.data.status ?? '?', system, descr]);
+  }
+
+  const inbox = await readIfExists(root, 'inbox.md');
+  if (inbox !== null)
+    row(['inbox', 'inbox.md', '-', '-', `${count(inbox, /^- in-\S+ \|/gm)} entries to triage`]);
+  const live = await readIfExists(root, 'LIVE.md');
+  if (live === null) return;
+  const { capabilities: caps, knownIssues: known } = parseLive(live);
+  row(['live', 'LIVE.md', '-', '-', `${caps.length} capabilities, ${known.length} known issues`]);
+}
+
+/** The rows of the files that record how lives ended: one count per file. */
+async function endRows(root, row) {
+  for (const [type, what] of [
+    ['history', 'ended accepted'],
+    ['graveyard', 'killed or dropped'],
+  ]) {
+    const text = await readIfExists(root, `${type}.md`);
+    if (text !== null) row([type, `${type}.md`, '-', '-', `${count(text, /^- \S+ \|/gm)} ${what}`]);
+  }
+}
+
 async function readIfExists(root, rel) {
   const file = path.join(root, rel);
 
@@ -53,6 +91,17 @@ async function readIfExists(root, rel) {
 
 const count = (text, re) => (text.match(re) ?? []).length;
 
+/** TBD values across units, read with each unit's own profile; an unknown type counts none. */
+async function tbdCount(units) {
+  let n = 0;
+  for (const u of units.filter((x) => UNIT_TYPES.includes(x.header.type))) {
+    const values = slotValues(u.body, await loadDocProfile(`unit-${u.header.type}`));
+    n += values.filter((v) => isTbd(v.value)).length;
+  }
+
+  return n;
+}
+
 export async function writeIndex(root) {
   const content = await generate(root);
   await atomicWrite(path.join(root, 'INDEX.md'), content);

package/lib/ledger.js

@@ -0,0 +1,94 @@
+// Where an id lives (Methodology §2, §9): a live place is a section of design/ or a work item of
+// work/, an end is the line the move wrote in the commit that ended the life — history.md for
+// done, collapsed and decided, graveyard.md for every drop and kill. Files, not commit messages:
+// a squash, a shallow clone or a rewritten history keeps them, and a revert of the move takes
+// its line out with it.
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { readDesign } from './design.js';
+import { listItems } from './gcf-paths.js';
+
+export const HISTORY_EVENTS = ['done', 'collapsed', 'decided'];
+
+/** `[id, second field]` of each line `- <id> | <field> | …` of a gcf file. */
+async function recordLines(root, name) {
+  const file = path.join(root, name);
+  if (!existsSync(file)) return [];
+
+  return (await readFile(file, 'utf8')).split('\n').flatMap((l) => {
+    const m = l.match(/^- (\S+) \|\s*([^|]*?)\s*(?:\||$)/);
+
+    return m ? [[m[1], m[2]]] : [];
+  });
+}
+
+const gitOut = (args, cwd) => {
+  const res = spawnSync('git', args, { cwd, encoding: 'utf8' });
+
+  return res.status === 0 ? res.stdout : null;
+};
+
+/** Ids HEAD holds as a work item file or a design section. */
+function headIds(projectDir) {
+  const files = gitOut(
+    ['ls-tree', '-r', '--name-only', 'HEAD', '--', 'gcf/work', 'gcf/design'],
+    projectDir,
+  );
+  const ids = new Set();
+  // Top level only, as readDesign and listItems read: a nested archive file is not a unit.
+  for (const f of (files ?? '')
+    .split('\n')
+    .filter((x) => /^gcf\/(work|design)\/[^/]+\.md$/.test(x))) {
+    if (f.startsWith('gcf/work/')) ids.add(path.basename(f, '.md'));
+    // `./` makes the path relative to the cwd, as ls-tree printed it.
+    else
+      for (const m of (gitOut(['show', `HEAD:./${f}`], projectDir) ?? '').matchAll(/^## (\S+)/gm))
+        ids.add(m[1]);
+  }
+
+  return ids;
+}
+
+/**
+ * @typedef {object} Place
+ * @property {'design' | 'item'} state
+ * @property {string} file gcf-relative
+ */
+
+/**
+ * Build the ledger of a project: `where(id)` answers `{ live, terminal }` — the live places
+ * (a design section, a work item) and the terminal events (done, collapsed, decided, killed).
+ */
+export async function buildLedger(projectDir) {
+  const root = path.join(path.resolve(projectDir), 'gcf');
+  const design = await readDesign(root);
+  const items = await listItems(root);
+  /** @type {Map<string, Place[]>} */
+  const live = new Map();
+  const add = (id, place) => live.set(id, [...(live.get(id) ?? []), place]);
+  for (const d of design) for (const u of d.units) add(u.id, { state: 'design', file: d.file });
+  for (const c of items) add(String(c.data.id), { state: 'item', file: `work/${c.name}` });
+
+  /** @type {Map<string, Set<string>>} */
+  const terminal = new Map();
+  const mark = (id, event) => terminal.set(id, (terminal.get(id) ?? new Set()).add(event));
+  for (const [id, event] of await recordLines(root, 'history.md'))
+    if (HISTORY_EVENTS.includes(event)) mark(id, event);
+  for (const [id] of await recordLines(root, 'graveyard.md')) mark(id, 'killed');
+  // An id HEAD holds that has no live place and no terminal line is vanishing in this commit:
+  // it is not known, so an item or unit still citing it fails M2 in this very commit, and
+  // `vanished()` lets the gate warn that its reason was lost.
+  const vanished = [...headIds(projectDir)].filter((id) => !live.has(id) && !terminal.has(id));
+
+  return {
+    design,
+    items,
+    item: (id) => items.find((c) => c.data.id === id),
+    where: (id) => ({ id, live: live.get(id) ?? [], terminal: [...(terminal.get(id) ?? [])] }),
+    known: (id) => live.has(id) || terminal.has(id),
+    ids: () => [...new Set([...live.keys(), ...terminal.keys()])].sort(),
+    vanished: () => vanished,
+  };
+}

package/lib/linter.js

@@ -1,9 +1,15 @@
 // П2 linter (GCF-PRD §13.2): explicit patterns over systems docs, no ML.
 // `<!-- gcf:allow <reason> -->` on the preceding line suppresses the next line's finding;
 // a pragma without a reason is itself a finding. cnlp check runs separately (form/lexicon).
-
-const UNIT_NUM = /\d+(?:[.,]\d+)?\s?(?:ms|мс|s|с|dmg|hp|px|сек)\b/;
-const SIGNATURE = /\w+\s*\([^)]*\b(?:int|float|bool|string|void|var|ref|out)\b[^)]*\)/;
+import { UNITS, closingComparison } from './design-check.js';
+
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+// One unit list with the design check (M5), plus the units balance values come in. The end of
+// a unit is any non-letter in any script: `\w` is ASCII-only, and "5 слотов" is not "5 с".
+const UNIT_WORDS = [...UNITS, 'мс', 'с', 'сек', 'dmg', 'hp', 'px'].map(esc).join('|');
+const UNIT_NUM = new RegExp(`\\d+(?:[.,]\\d+)?\\s?(?:${UNIT_WORDS})(?![\\p{L}\\p{N}_-])`, 'u');
+// No space before the paren: "respawn the player (out of the arena)" is prose, not a call.
+const SIGNATURE = /\w+\([^)]*\b(?:int|float|bool|string|void|var|ref|out)\b[^)]*\)/;
 const CAMEL = /\b[A-Z][a-z0-9]+(?:[A-Z][a-z0-9]+)+\b/;
 const ENVELOPE_FIELD = /^\s*(?:- )?(?:question|assumed|proposed):/;
 
@@ -26,8 +32,10 @@ function blockOf(lines, i) {
 }
 
 export function lint(content) {
+  // CRLF from a Windows checkout: a trailing `\r` would defeat every end-anchored pattern.
+  const lines = String(content).replace(/\r\n/g, '\n').split('\n');
   /** @type {LintState} */
-  const st = { lines: String(content).split('\n'), issues: [], pragmas: [], fenceStart: -1 };
+  const st = { lines, issues: [], pragmas: [], fenceStart: -1 };
 
   for (let i = 0; i < st.lines.length; i++) {
     const allowed = readPragma(st, i);
@@ -85,7 +93,11 @@ function checkLine(st, i) {
 
   // Envelopes are legal where the spec puts them: the feel block, and the question/assumed/
   // proposed fields of an open-questions record, where import parks D2 envelopes for the human.
-  if (blockOf(st.lines, i) !== 'feel' && !ENVELOPE_FIELD.test(line) && UNIT_NUM.test(line)) {
+  // An exact limit is legal as a closing comparison in any block (GCF-PRD §11.3), as in the
+  // card M5 accepted: a boundary collapses into `behavior:` and must not fail its own verdict.
+  const block = blockOf(st.lines, i);
+  const limit = closingComparison(line);
+  if (block !== 'feel' && !limit && !ENVELOPE_FIELD.test(line) && UNIT_NUM.test(line)) {
     flag('number-with-unit-outside-feel');
   }