gcf-aif-ext 0.7.6 → 0.7.8

package/README.md

@@ -50,6 +50,19 @@ Updating preserves `gcf/`, `cnlp.config.json` and the pre-commit hook. Run `ai-f
 
 On Windows, run `extension add` and `extension update` from PowerShell or cmd, not Git Bash: the installer unpacks with `tar`, and Git Bash's GNU tar reads `C:\…` as a remote host (`Cannot connect to C: resolve failed`). The Windows `tar.exe` handles it.
 
+### 0.7.8
+
+- An open question's field written as a YAML block (`assumed: |` or `>`, and the lines under it) reads as its text: before, `gcf board --json` gave the block sign `|`. Every reader of `gcf/open-questions.md` (the board, `design check`, the audit, `context`, the index) reads the fields the same way:
+  - a field is a line at the record's field indent, so a block line such as `answer: x` is text: before, it made a D1 read as answered;
+  - a blank line inside a block no longer ends the record: before, the fields after it were lost;
+  - `gcf question answer` replaces an old answer written as a block whole: before, it replaced only the block's first line;
+  - an empty `answer:` is no answer: `design check` now holds the D1's units, as the board already showed it unanswered.
+
+### 0.7.7
+
+- `ai-factory gcf config [--json]` lists the human's settings of `gcf/config.yml` with what each means; `gcf config set <key> --value=<v>` sets one, checked by the rules a read applies, the comments kept, one `gcf(config)` commit. An empty number goes back to its default. `gcf board --json` carries them as `settings`.
+- `gcf board --json` questions also carry `assumed`, `until`, `sys`, `lens` and `sections`: a D2 shows what it assumed and when it comes back, and every record where it came from.
+
 ### 0.7.6
 
 - `ai-factory gcf permissions [--on <group>] [--off <group>] [--deny <rule>] [--undeny <rule>]` — what agent runs may not do: deny groups and the human's own rules in the `agent:` section of `gcf/config.yml`, one `gcf(permissions)` commit; with no change it lists them. On by default: `git-destroy`, `mass-delete`, `publish`, `human-moves`, `guards`; off: `secrets`, `outside`, `processes`. `agent.groups` keeps only the human's choices (`secrets: true`): a group it does not name keeps its default, so one a later version adds comes on. `git push` is in none. `gcf board --json` carries `agent` (`groups`, `deny_extra`, the resolved `deny`, `allow`).

package/commands/gcf.js

@@ -977,6 +977,37 @@ function registerBoard(gcf) {
         ].join('\n'),
       );
     });
+  const config = gcf
+    .command('config')
+    .description("The human's settings of gcf/config.yml: list them, or set one (commit)")
+    // A misspelt subcommand would read as a stray word and list the settings, as if set.
+    .allowExcessArguments(false)
+    .option('--json', 'machine output')
+    .action(async (o) => {
+      const { gcfRoot, readConfig, readRawConfig } = await lib('gcf-paths');
+      await readConfig(gcfRoot()); // a config the rules refuse says so here
+      const list = (await lib('config-set')).settingsOf(await readRawConfig(gcfRoot()));
+      out(o.json, list, (x) =>
+        x.map((s) => `${s.key}: ${s.value ?? '-'}  # ${s.label}`).join('\n'),
+      );
+    });
+  config
+    .command('set <key>')
+    .description('Set one key; an empty --value= takes a number back to its default')
+    // The value only through --value: `set plan_passes 7` must not read as a reset. A value
+    // may start with a hyphen (a command's flag); as `--value=<text>` it stays one value.
+    .allowExcessArguments(false)
+    .requiredOption('--value <value>', 'the new value; empty (--value=) for the default')
+    .option('--no-commit', 'skip the commit (tests only)')
+    .action(async (key, o) => {
+      const r = await (
+        await lib('config-set')
+      ).setConfig(process.cwd(), key, o.value, {
+        commit: o.commit,
+      });
+      const now = `${r.key}: ${r.value ?? 'default'}`;
+      console.log(r.unchanged ? `${now} (unchanged)` : `${now}${shortHash(r.hash)}`);
+    });
   const many = (v, prev = []) => [...prev, v];
   gcf
     .command('permissions')

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

package/lib/agent-permissions.js

@@ -75,7 +75,7 @@ export const DENY_GROUPS = [
   {
     id: 'human-moves',
     label:
-      "the human's GCF moves: verdict, decide, answer, unblock, phase, pillars, permissions, setup",
+      "the human's GCF moves: verdict, decide, answer, unblock, phase, pillars, settings, permissions, setup",
     on: true,
     rules: shell(
       'ai-factory gcf verdict*',
@@ -85,6 +85,7 @@ export const DENY_GROUPS = [
       'ai-factory gcf phase next*',
       'ai-factory gcf pillar*',
       'ai-factory gcf permissions*',
+      'ai-factory gcf config set*',
       'ai-factory gcf hooks-install*',
       'ai-factory gcf-harness init*',
       'ai-factory gcf-harness run*',

package/lib/audit-core.js

@@ -11,6 +11,7 @@ import { STORED } from './transitions.js';
 import { openDepends } from './work-ops.js';
 import { runHolder } from './main-lock.js';
 import { sessionActive } from './session-mark.js';
+import { fieldOf } from './question-fields.js';
 
 function git(args, cwd) {
   // A blame of a long file overflows the 1 MiB default, and an overflow reads as a git failure.
@@ -276,7 +277,7 @@ const questionsText = async (root) => {
   return existsSync(file) ? readFile(file, 'utf8') : '';
 };
 
-const D2_UNTIL_RE = /^\s+until:\s*(verdict\([a-z0-9-]+\)|retune\([a-z0-9-]+\)|manual\([^)]*\))/m;
+const D2_UNTIL_RE = /^(verdict\([a-z0-9-]+\)|retune\([a-z0-9-]+\)|manual\([^)]*\))/;
 
 /**
  * Until annotations across work items and systems docs, and the `until:` of each D2 record in
@@ -296,8 +297,8 @@ function untilRecords(items, systems, fired, questions) {
 
   for (const rec of questions.replace(/\r\n/g, '\n').split(/\n(?=- id:)/)) {
     const id = rec.match(/^- id:\s*(\S+)/)?.[1];
-    const trigger = rec.match(D2_UNTIL_RE)?.[1];
-    if (!id || !trigger || !/^\s+class:\s*D2\b/m.test(rec)) continue;
+    const trigger = fieldOf(rec, 'until')?.match(D2_UNTIL_RE)?.[1];
+    if (!id || !trigger || !/^D2\b/.test(fieldOf(rec, 'class') ?? '')) continue;
     until.push({
       file: 'gcf/open-questions.md',
       id,

package/lib/board.js

@@ -4,7 +4,7 @@ import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { buildLedger } from './ledger.js';
-import { readConfig } from './gcf-paths.js';
+import { readConfig, readRawConfig } from './gcf-paths.js';
 import { readLive } from './live.js';
 import { listInbox } from './inbox.js';
 import { phaseStatus } from './phase.js';
@@ -17,6 +17,7 @@ import { movesOf } from './transitions.js';
 import { listQuestions } from './questions.js';
 import { sessionActive } from './session-mark.js';
 import { agentOf } from './agent-permissions.js';
+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.
@@ -232,6 +233,8 @@ export async function board(projectDir) {
     run_mode: config.run_mode,
     // What the harness hands its agent runs (Harness-PRD §7): the deny rules and the context limits.
     agent: agentOf(config),
+    // The human's settings of config.yml, each with its value and default (`gcf config set`).
+    settings: settingsOf(await readRawConfig(root)),
     context: {
       handoff_pct: config.context_handoff_pct,
       window: config.context_window,

package/lib/config-set.js

@@ -0,0 +1,171 @@
+// `gcf config set` (GCF-PRD §12.4): the human's settings of gcf/config.yml, one key at a time,
+// so a board edits them through the core and never writes the file itself. A change is checked
+// by the same rules a read applies before it is written; the rest of the file keeps its keys
+// and comments. `phases:` and `agent:` have their own commands and are not set here.
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import YAML from 'yaml';
+import { commitMove } from './unit-ops.js';
+import { atomicWrite } from './safe-path.js';
+import { configOf, DEFAULT_CONFIG, gcfRoot, RUN_MODES } from './gcf-paths.js';
+
+/** @typedef {'number' | 'share' | 'mode' | 'command'} Kind */
+
+// Thrown inside the move to leave without a write or a commit.
+const NO_CHANGE = new Error('no change');
+
+/** @type {{ key: string, kind: Kind, label: string }[]} */
+export const SETTINGS = [
+  {
+    key: 'run_mode',
+    kind: 'mode',
+    label:
+      'how a run drives an item: worktree (several at once) or main (one at a time in the project folder)',
+  },
+  { key: 'dod.test', kind: 'command', label: "the project's test command for the DoD, or none" },
+  { key: 'dod.build', kind: 'command', label: "the project's build command for the DoD, or none" },
+  {
+    key: 'plan_passes',
+    kind: 'number',
+    label: 'improve passes a plan may take before the item blocks',
+  },
+  { key: 'dod_attempts', kind: 'number', label: 'DoD attempts before the item blocks' },
+  {
+    key: 'wip_built_limit',
+    kind: 'number',
+    label: 'items waiting for a verdict before new verdict work stops',
+  },
+  {
+    key: 'context_handoff_pct',
+    kind: 'share',
+    label:
+      'share of the context window at which a session hands its item to a fresh one (0: never)',
+  },
+  { key: 'context_window', kind: 'number', label: "context window in tokens (0: the model's)" },
+  {
+    key: 'auto_compact_pct',
+    kind: 'share',
+    label: 'share at which the agent compacts (0: its default; at least the handoff share + 15)',
+  },
+  { key: 'tune_limit', kind: 'number', label: 'tune verdicts an item may take' },
+  { key: 'unplayed_warn_after', kind: 'number', label: 'unplayed items before the audit warns' },
+  {
+    key: 'built_stale_after_commits',
+    kind: 'number',
+    label: 'commits after which a waiting or blocked item is stale',
+  },
+  {
+    key: 'question_stale_after_commits',
+    kind: 'number',
+    label: 'commits after which an open question is stale',
+  },
+  { key: 'context_budget', kind: 'number', label: "token budget of an item's readset" },
+  { key: 'pillars_budget', kind: 'number', label: 'token budget of PILLARS.md' },
+  {
+    key: 'envelope_default_spread',
+    kind: 'number',
+    label: 'default spread of a feel envelope around a GDD number (0.3: ±30%)',
+  },
+];
+
+const BY_KEY = new Map(SETTINGS.map((s) => [s.key, s]));
+
+/**
+ * Each setting with what the file sets (null: not set, the default holds) and its default:
+ * what a settings screen shows. `raw` is the parsed config.yml, before the defaults.
+ */
+export function settingsOf(raw) {
+  return SETTINGS.map((s) => {
+    const [head, sub] = s.key.split('.');
+    const parent = raw?.[head];
+    const value = sub
+      ? parent && typeof parent === 'object'
+        ? (parent[sub] ?? null)
+        : null
+      : (parent ?? null);
+    const def = sub ? null : head === 'run_mode' ? 'worktree' : (DEFAULT_CONFIG[head] ?? null);
+
+    return { ...s, value, default: def };
+  });
+}
+
+/** The value of `text` for a setting of `kind`; an empty number goes back to its default. */
+function valueOf(setting, text) {
+  const t = String(text ?? '').trim();
+  if (setting.kind === 'command') {
+    if (!t) throw new Error(`${setting.key}: name the command, or none`);
+
+    return t;
+  }
+
+  if (setting.kind === 'mode') {
+    if (!RUN_MODES.includes(t)) throw new Error(`run_mode must be ${RUN_MODES.join(' | ')}`);
+
+    return t;
+  }
+
+  if (!t) return null;
+  // Plain decimals only: Number() would also take 0x10, 1e3 and 0b1.
+  if (!/^\d+(\.\d+)?$/.test(t)) throw new Error(`${setting.key} must be a number, got ${t}`);
+  const n = Number(t);
+  if (!Number.isFinite(n)) throw new Error(`${setting.key} must be a number, got ${t}`);
+
+  return n;
+}
+
+/**
+ * Set one key of gcf/config.yml and commit gcf(config); a number set to nothing goes back to
+ * its default. The file is read and checked under the move's lock.
+ */
+export async function setConfig(projectDir, key, text, { commit = true } = {}) {
+  const setting = BY_KEY.get(key);
+  if (!setting) throw new Error(`no setting ${key}: ${SETTINGS.map((s) => s.key).join(' | ')}`);
+  const value = valueOf(setting, text);
+  const file = path.join(gcfRoot(projectDir), 'config.yml');
+  const keys = key.split('.');
+  let raw;
+  // A change that changes nothing (the same value, a reset of a key not set) commits nothing.
+  let unchanged = false;
+  const hash = await commitMove(projectDir, `gcf(config): ${key}`, {
+    files: [file],
+    mutate: async () => {
+      const text = existsSync(file) ? await readFile(file, 'utf8') : '';
+      const doc = YAML.parseDocument(text);
+      if (doc.errors.length) throw new Error(`gcf/config.yml: ${doc.errors[0].message}`);
+      if (!YAML.isMap(doc.contents)) doc.contents = doc.createNode({});
+      // A blank parent (`dod:` with nothing under it) is no map yet.
+      if (keys.length > 1) {
+        const parent = doc.get(keys[0], true);
+        if (
+          parent != null &&
+          !YAML.isMap(parent) &&
+          !(YAML.isScalar(parent) && parent.value == null)
+        )
+          throw new Error(`gcf/config.yml: ${keys[0]} must map its keys`);
+        if (!YAML.isMap(parent)) doc.set(keys[0], doc.createNode({}));
+      }
+
+      if (value === null) doc.deleteIn(keys);
+      else doc.setIn(keys, value);
+      raw = doc.toJS();
+      configOf(raw);
+      const out = doc.toString();
+      // The values, not the text: YAML's output may differ in form (a final newline, `{}`).
+      if (isDeepStrictEqual(YAML.parse(text) ?? {}, raw ?? {})) {
+        unchanged = true;
+        throw NO_CHANGE;
+      }
+
+      await atomicWrite(file, out);
+    },
+    commit,
+  }).catch((e) => {
+    if (e !== NO_CHANGE) throw e;
+
+    return null;
+  });
+
+  return { key, value, unchanged, settings: settingsOf(raw), hash };
+}

package/lib/context.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { listItems, listSystems, readConfig, tokensEst } from './gcf-paths.js';
+import { fieldOf } from './question-fields.js';
 
 /**
  * Readset assembly — the whole command is deterministic (GCF-PRD §9.1, §10.1):
@@ -94,9 +95,9 @@ async function d2Assumptions(root, systems) {
   const records = (await readFile(oqFile, 'utf8')).split(/\n(?=- id:)/);
 
   return records
-    .filter((rec) => /^\s*-?\s*id:/m.test(rec) && /class:\s*D2/.test(rec))
+    .filter((rec) => /^\s*-?\s*id:/m.test(rec) && /^D2\b/.test(fieldOf(rec, 'class') ?? ''))
     .filter((rec) => {
-      const sys = rec.match(/sys:\s*(.+)/)?.[1] ?? '';
+      const sys = fieldOf(rec, 'sys') ?? '';
 
       return systems.some((s) => sys.includes(s));
     })

package/lib/design-check.js

@@ -19,6 +19,7 @@ import {
 import { buildLedger } from './ledger.js';
 import { sourceBodies } from './anchors.js';
 import { collapseLines } from './verdict-fs.js';
+import { fieldOf } from './question-fields.js';
 
 // Units a number may carry. A project adds its own in the `units:` block of glossary.md.
 // Bare `px` is absent on purpose: its size depends on the screen density.
@@ -122,7 +123,7 @@ export const recordsIn = (text, key) =>
   readRecords(itemsIn(text, key)).records.map((r) => r.values);
 
 /** A D1 record nobody answered yet: only such a question holds its units. */
-const blocksUnits = (rec) => /^\s+class:\s*D1\b/m.test(rec) && !/^\s+answer:/m.test(rec);
+const blocksUnits = (rec) => /^D1\b/.test(fieldOf(rec, 'class') ?? '') && !fieldOf(rec, 'answer');
 
 /**
  * open-questions.md: every record id, every `blocks:` reference, the D1 ones per blocked id. A
@@ -136,7 +137,7 @@ export function questionBlocks(text) {
   const qids = new Set([...src.matchAll(/^\s*- id:\s*(\S+)/gm)].map((m) => m[1]));
   for (const rec of src.split(/\n(?=- id:)/)) {
     const qid = rec.match(/^- id:\s*(\S+)/)?.[1];
-    const ids = listOf(rec.match(/^\s+blocks:\s*(.+)$/m)?.[1] ?? '');
+    const ids = listOf(fieldOf(rec, 'blocks') ?? '');
     if (!qid || ids === 'TBD' || !ids.length) continue;
     refs.push({ qid, ids });
     if (!blocksUnits(rec)) continue;

package/lib/gcf-paths.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import YAML from 'yaml';
 import { parse } from './frontmatter.js';
 
-const DEFAULT_CONFIG = {
+export const DEFAULT_CONFIG = {
   schema: 1,
   built_stale_after_commits: 5,
   tune_limit: 3,
@@ -48,27 +48,24 @@ function runModeOf(v = 'worktree') {
 
 /** @returns {Promise<Record<string, any>>} */
 export async function readConfig(root) {
-  const config = await readNumbers(root);
-  for (const key of PCT_KEYS)
-    if (config[key] > 100)
-      throw new Error(`gcf/config.yml: ${key} is a share of the window, 0-100, got ${config[key]}`);
-  // A compaction before the handoff threshold shrinks the context the handoff waits for.
-  const { auto_compact_pct: compact, context_handoff_pct: handoff } = config;
-  if (compact && handoff && compact < handoff + 15)
-    throw new Error(
-      `gcf/config.yml: auto_compact_pct ${compact} must be at least context_handoff_pct + 15 ` +
-        `(${handoff + 15}), or the compaction comes before the handoff`,
-    );
-
-  return { ...config, run_mode: runModeOf(config.run_mode) };
+  return configOf(await readRawConfig(root));
 }
 
-/** @returns {Promise<Record<string, any>>} */
-async function readNumbers(root) {
+/** config.yml as the file has it, before the defaults: `{}` when there is none. */
+export async function readRawConfig(root) {
   const file = path.join(root, 'config.yml');
-  if (!existsSync(file)) return { ...DEFAULT_CONFIG };
-  const parsed = YAML.parse(await readFile(file, 'utf8')) ?? {};
-  if (typeof parsed !== 'object' || Array.isArray(parsed))
+
+  return existsSync(file) ? (YAML.parse(await readFile(file, 'utf8')) ?? {}) : {};
+}
+
+/**
+ * The config a parsed config.yml gives, checked: defaults for what it does not set, every limit
+ * a non-negative number, the shares 0-100, the run mode one of RUN_MODES. Throws on the first
+ * key that breaks a rule. `gcf config set` checks a change with it before it writes.
+ * @returns {Record<string, any>}
+ */
+export function configOf(parsed) {
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
     throw new Error('gcf/config.yml must be a key: value mapping');
   // A blank `key:` parses as null and means "not set", like an absent key.
   const config = {
@@ -85,7 +82,18 @@ async function readNumbers(root) {
     }
   }
 
-  return config;
+  for (const key of PCT_KEYS)
+    if (config[key] > 100)
+      throw new Error(`gcf/config.yml: ${key} is a share of the window, 0-100, got ${config[key]}`);
+  // A compaction before the handoff threshold shrinks the context the handoff waits for.
+  const { auto_compact_pct: compact, context_handoff_pct: handoff } = config;
+  if (compact && handoff && compact < handoff + 15)
+    throw new Error(
+      `gcf/config.yml: auto_compact_pct ${compact} must be at least context_handoff_pct + 15 ` +
+        `(${handoff + 15}), or the compaction comes before the handoff`,
+    );
+
+  return { ...config, run_mode: runModeOf(config.run_mode) };
 }
 
 /** Token estimate: ceil(chars/4). Stability over accuracy (GCF-PRD §9.1). */

package/lib/index-gen.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { listItems, listSystems, firstBullet } from './gcf-paths.js';
 import { parseLive } from './live.js';
 import { atomicWrite } from './safe-path.js';
+import { fieldOf } from './question-fields.js';
 import { readDesign, slotValues, loadDocProfile, isTbd, UNIT_TYPES } from './design.js';
 
 /**
@@ -46,8 +47,9 @@ export async function generate(root) {
 
   const txt = await readIfExists(root, 'open-questions.md');
   if (txt !== null) {
-    const d1 = count(txt, /^\s*class:\s*D1/gm);
-    const d2 = count(txt, /^\s*class:\s*D2/gm);
+    const classes = txt.split(/\n(?=- id:)/).map((rec) => fieldOf(rec, 'class') ?? '');
+    const d1 = classes.filter((c) => /^D1\b/.test(c)).length;
+    const d2 = classes.filter((c) => /^D2\b/.test(c)).length;
     row(['questions', 'open-questions.md', '-', '-', `${d1} D1, ${d2} D2`]);
   }
 

package/lib/question-fields.js

@@ -0,0 +1,70 @@
+// The fields of one record of gcf/open-questions.md (`- id:` and the indented lines under it).
+// A field is a line at the record's field indent; a YAML block (`|`, `>`) is the deeper lines
+// under its key, so a block line that reads like `answer: x` is text, not a field.
+
+/** The indent of a record's fields: the indent of its first field line. */
+export const indentOf = (record) => record.match(/^([ \t]+)\w+:/m)?.[1] ?? '  ';
+
+/** The index after the lines under field line `i`: deeper ones, and blank ones between them. */
+export function blockEnd(lines, i, indent) {
+  let end = i + 1;
+  for (let j = i + 1; j < lines.length; j++) {
+    if (!lines[j].trim()) continue;
+    if (!lines[j].startsWith(indent) || !/^[ \t]/.test(lines[j].slice(indent.length))) break;
+    end = j + 1;
+  }
+
+  return end;
+}
+
+// `|`, `>-`, `|2`, `> # note`: a block's sign with its chomping, indentation and comment.
+const BLOCK = /^([|>])[-+]?\d?[-+]?(\s+#.*)?$/;
+
+/**
+ * A `>` block's lines folded: the lines of one paragraph join with a space, each blank line is a
+ * line break, and a more indented line keeps its breaks, the one before a blank line too.
+ */
+function folded(lines) {
+  let text = '';
+  let prev = null;
+  let blanks = 0;
+  for (const l of lines) {
+    if (!l) {
+      blanks += 1;
+      continue;
+    }
+
+    const kind = /^[ \t]/.test(l) ? 'more' : 'text';
+    if (prev !== null) {
+      const both = prev === 'text' && kind === 'text';
+      if (blanks) text += '\n'.repeat(both ? blanks : blanks + 1);
+      else text += both ? ' ' : '\n';
+    }
+
+    text += l;
+    prev = kind;
+    blanks = 0;
+  }
+
+  return text;
+}
+
+/**
+ * The value of field `k` in a record, or null. A block reads as its lines, the common indent
+ * taken off: `|` keeps the line breaks, `>` folds them (`folded`).
+ */
+export function fieldOf(record, k) {
+  const lines = record.split(/\r?\n/);
+  const indent = indentOf(record);
+  const i = lines.findIndex((l) => l.startsWith(`${indent}${k}:`));
+  if (i < 0) return null;
+  const value = lines[i].slice(indent.length + k.length + 1).trim();
+  const block = value.match(BLOCK)?.[1];
+  if (!block) return value || null;
+  const body = lines.slice(i + 1, blockEnd(lines, i, indent));
+  const cut = Math.min(...body.filter((l) => l.trim()).map((l) => l.match(/^[ \t]*/)[0].length));
+  const dedented = body.map((l) => l.slice(cut).trimEnd());
+  const text = block === '|' ? dedented.join('\n') : folded(dedented);
+
+  return text.trim() || null;
+}

package/lib/questions.js

@@ -7,26 +7,47 @@ import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { atomicWrite } from './safe-path.js';
 import { commitMove } from './unit-ops.js';
+import { blockEnd, fieldOf, indentOf } from './question-fields.js';
 
-const FIELDS = ['class', 'question', 'proposed', 'blocks', 'answer'];
+// A D2 carries its assumption and the trigger that brings it back; `lens`, `sections` and `sys`
+// say where a record came from: an import names its lens and the GDD sections.
+const FIELDS = [
+  'class',
+  'question',
+  'proposed',
+  'blocks',
+  'answer',
+  'assumed',
+  'until',
+  'sys',
+  'lens',
+  'sections',
+];
 
 const fileOf = (root) => path.join(root, 'open-questions.md');
 
 /**
  * The records of a file's text, each `{id, text, start}`: a `- id:` line and the indented lines
- * under it. A blank or unindented line ends the record: a heading after the last record is not
- * part of it.
+ * under it. An unindented line ends the record, and so does a blank one unless an indented line
+ * follows it (a blank line inside a block): a heading after the last record is not part of it.
  */
 function recordsOf(text) {
   const records = [];
   let at = 0;
   /** @type {{id: string, text: string, start: number} | null} */
   let rec = null;
+  // Blank lines after a record's last line: its own when an indented line follows.
+  let blank = '';
   for (const line of text.split(/(?<=\n)/)) {
     const id = line.match(/^- id:\s*(\S+)/)?.[1];
     if (id) records.push((rec = { id, text: line, start: at }));
-    else if (rec && /^[ \t]+\S/.test(line)) rec.text += line;
-    else rec = null;
+    else if (rec && /^[ \t]+\S/.test(line)) rec.text += blank + line;
+    else if (rec && !line.trim()) {
+      blank += line;
+      at += line.length;
+      continue;
+    } else rec = null;
+    blank = '';
     at += line.length;
   }
 
@@ -43,23 +64,27 @@ export async function listQuestions(root) {
 
   return recordsOf(await readFile(file, 'utf8')).map(({ id, text }) => ({
     id,
-    ...Object.fromEntries(
-      FIELDS.map((k) => [
-        k,
-        text.match(new RegExp(`^[ \\t]+${k}:[ \\t]*(.*?)\\s*$`, 'm'))?.[1] || null,
-      ]),
-    ),
+    ...Object.fromEntries(FIELDS.map((k) => [k, fieldOf(text, k)])),
   }));
 }
 
 /** The record text with its `answer:` set: an old answer is replaced, a new one appended. */
 function withAnswer(record, answer) {
   const eol = record.includes('\r\n') ? '\r\n' : '\n';
-  const indent = record.match(/^([ \t]+)\w+:/m)?.[1] || '  ';
+  const indent = indentOf(record);
   const line = `${indent}answer: ${answer}`;
-  // A function, not a string: `$&` in the operator's answer is text, not a pattern.
-  if (/^[ \t]+answer:/m.test(record))
-    return record.replace(/^[ \t]+answer:.*?(?=\r?$)/m, () => line);
+  // Each line with its own line end, so the lines around the answer keep their bytes.
+  const parts = record.split(/(?<=\n)/);
+  const lines = parts.map((p) => p.replace(/\r?\n$/, ''));
+  const at = lines.findIndex((l) => l.startsWith(`${indent}answer:`));
+  // An old answer goes with the block under it, if it was one.
+  if (at >= 0) {
+    const end = blockEnd(lines, at, indent);
+    parts.splice(at, end - at, line + (parts[end - 1].match(/\r?\n$/)?.[0] ?? ''));
+
+    return parts.join('');
+  }
+
   const body = record.replace(/(\r?\n)+$/, '');
 
   return `${body}${eol}${line}${record.slice(body.length) || eol}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gcf-aif-ext",
-  "version": "0.7.6",
+  "version": "0.7.8",
   "description": "Game Context Framework for AI Factory",
   "type": "module",
   "license": "MIT",

package/templates/agents-block.md

@@ -29,6 +29,7 @@ gcf_forbidden:
 - do not answer a `TBD` of a design unit yourself: ask the human and offer your draft as the proposed answer
 - do not run `ai-factory gcf phase next`: the phase moves on the human's word only
 - do not change what agent runs may do: `ai-factory gcf permissions` and its deny groups belong to the human
+- do not change a setting of `gcf/config.yml`: `ai-factory gcf config set` belongs to the human
 - do not reuse an ended id: rework gets a new id with `reopens: <old id>`
 - do not commit past the gate with `--no-verify`: a refused commit names what to fix