gcf-aif-ext 0.5.2 → 0.6.0

package/README.md

@@ -50,6 +50,23 @@ 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.6.0
+
+- `gcf board --json` carries `schema: 1`, the version of its format (Methodology §11 lists every field); a board refuses a version it does not know. New fields: per item `file`, `plan_file`, `log`, `depends`, `milestone`, `tune_count`, `since`, `model`, `effort` and `moves` (what the item takes now by Methodology §4.1, empty while a run drives it); at the top `history` and `graveyard`.
+- `item new --model <m> --effort <e>`: the run of the item uses them (gcf-harness-aif-ext 0.7). One word each.
+- `playtest session --json` and `live check --json` answer JSON: the flag went to the parent command, which printed text.
+- `--commit` on `item new`, `inbox add` and `inbox drop` records the move alone (`gcf(item): <id>`, `gcf(inbox): …`) for a caller with no console, a board. Without it nothing is committed, as before. Inbox lines added earlier without a commit go into the same commit: the inbox is raw input.
+- `inbox add --text=<text>`: 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.
+
+### 0.5.3
+
+- `gcf init` restamps an unplayed item frozen by 0.4.0 (the hash of its body alone), so its `live:` is guarded too — only while that `live:` is still the one its close committed. Commit the restamped items it names.
+- While a harness run drives an item (`.gcf-session/runs/<id>.lock` held by a live process), the core refuses any move on it, `/gcf-run` on main included, and `gcf integrate` leaves its branch unmerged; the audit and the board read it as `running`. A lock left by a run that died is taken over. `gcf board --json` reports WIP as `{count, limit, over}`.
+- The audit reads the `until:` of every D2 record in `open-questions.md`: a fired one is a stale until record, and the assumption goes back to the human.
+- `gcf design check` reads the text of an HTML comment in a unit or an item for forbidden words (M4) and numbers (M5); a `gcf:allow` pragma and a tool's marked region are skipped.
+- An unplayed tune or kill keeps a systems-doc line the doc held before the item's close.
+- `gcf playtest session` groups the checklist by subsystem and warns when the build is not of main: the remote's default branch when the clone knows it, else any branch but a detached HEAD or a `work/` one.
+
 ### 0.5.2
 
 - Bundles `cnlp-kit` 3.9, so `gcf design check` and the commit gate accept a bullet written in Cyrillic alone.

package/commands/gcf.js

@@ -166,6 +166,9 @@ function registerInit(gcf, program) {
       const block = await readFile(path.join(EXT_ROOT, 'templates', 'agents-block.md'), 'utf8');
       const agents = await (await lib('agents-block')).writeAgentsBlock(process.cwd(), block);
       if (agents.length) console.log(`agent instructions written: ${agents.join(', ')}`);
+      const restamped = await (await lib('work-ops')).restampFrozen(process.cwd());
+      if (restamped.length)
+        console.log(`frozen: restamped to guard live: too, commit them: ${restamped.join(', ')}`);
       console.log(
         'gcf/ ready. Write PILLARS.md through /gcf-init, then import a GDD with /gcf-ingest ' +
           'or start the design with /gcf-vision.',
@@ -253,17 +256,30 @@ function buildText(b) {
   return b.skipped ? 'no build step (dod.build: none)' : 'built with dod.build';
 }
 
-/** The session sheet: the build, then per item what to check and how to get there. */
-function sessionText(s) {
+/** The sheet's head: what was built, and why it may not be what main holds. */
+function sessionHead(s) {
   const build = buildText(s.build);
-  const lines = [
+
+  return [
     s.commit ? `build: ${s.branch} @ ${s.commit} — ${build}` : 'build: no commit to build yet',
-    // shortcut: the main branch is named main; read the remote default when a project differs.
-    ...(s.branch !== 'main' ? ['warning: not on main — the session plays main'] : []),
+    // Main by the remote's default when known, else any branch but detached or a worktree's.
+    ...(s.branch === 'HEAD' || s.branch?.startsWith('work/') || (s.main && s.branch !== s.main)
+      ? [`warning: ${s.branch} is not ${s.main ?? 'main'} — the session plays main`]
+      : []),
     ...(s.dirty ? ['warning: uncommitted changes — the build is not the commit'] : []),
   ];
+}
+
+/** The session sheet: the build, then per item what to check and how to get there. */
+function sessionText(s) {
+  const lines = sessionHead(s);
   if (!s.items.length) return [...lines, 'nothing waits for a playtest'].join('\n');
+  let group = null;
+  // Items come sorted by their first subsystem: one header each, so play goes system by system.
   for (const c of s.items) {
+    const system = c.system[0] ?? '(no subsystem)';
+    if (system !== group) lines.push('', `## ${system}`);
+    group = system;
     lines.push(
       '',
       `[ ] ${c.id} (${c.status}) [${c.system.join(',')}] ${c.title ?? c.intent ?? ''}`,
@@ -305,7 +321,8 @@ function registerPlaytest(gcf) {
       const r = await (
         await lib('playtest-list')
       ).playtestSession(process.cwd(), { build: Boolean(o.build) });
-      out(o.json, r, sessionText);
+      // Commander gives a flag both levels define to the parent: `playtest session --json`.
+      out(o.json || playtest.opts().json, r, sessionText);
       if (r.build && !r.build.ok) process.exitCode = 1;
     });
 }
@@ -627,6 +644,9 @@ function registerItem(gcf) {
     .option('--milestone <name>', 'the milestone of game.md it belongs to')
     .option('--release <version>', 'a release: the version it ships')
     .option('--channel <name>', 'a release: where it ships, e.g. steam')
+    .option('--model <name>', 'the model its run uses, e.g. opus')
+    .option('--effort <level>', 'the effort its run uses, e.g. high')
+    .option('--commit', 'commit it (gcf(item)): for a caller with no console, e.g. a board')
     .action(async (id, o) => {
       const { newItem } = await lib('work-ops');
       const r = await newItem(process.cwd(), {
@@ -644,8 +664,11 @@ function registerItem(gcf) {
         milestone: o.milestone,
         version: o.release,
         channel: o.channel,
+        model: o.model,
+        effort: o.effort,
+        commit: o.commit === true,
       });
-      console.log(r.item);
+      console.log(`${r.item}${shortHash(r.hash)}`);
     });
 }
 
@@ -720,6 +743,36 @@ function registerDecide(gcf) {
     });
 }
 
+/**
+ * An inbox edit; with `commit`, committed alone under the main lock — a board has no console to
+ * commit from. Returns the commit hash, or null.
+ * @param {boolean | undefined} commit
+ * @param {string} message
+ * @param {(root: string) => Promise<unknown>} edit
+ */
+async function inboxMove(commit, message, edit) {
+  const { gcfRoot } = await lib('gcf-paths');
+  const root = gcfRoot();
+  if (!commit) {
+    await edit(root);
+
+    return null;
+  }
+
+  const { commitMove } = await lib('unit-ops');
+  const inbox = path.join(root, 'inbox.md');
+
+  // Raw input (merge=union): lines added before without a commit ride along with this one.
+  return commitMove(process.cwd(), message, {
+    files: [inbox],
+    inputs: [inbox],
+    mutate: async () => {
+      await edit(root);
+    },
+    commit: true,
+  });
+}
+
 function registerInbox(gcf) {
   const inbox = gcf
     .command('inbox')
@@ -733,21 +786,34 @@ function registerInbox(gcf) {
       );
     });
   inbox
-    .command('add <text>')
+    .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);
+    // 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('--commit', 'commit it (gcf(inbox)): for a caller with no console, e.g. a board')
+    .action(async (arg, o) => {
+      const text = o.text ?? arg;
+      if (!text || (o.text !== undefined && arg !== undefined))
+        throw new Error('give the entry once: as the argument, or as --text=<text>');
+      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;
+      });
+      console.log(`${id}${shortHash(hash)}`);
     });
   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}`);
+    .option('--commit', 'commit it (gcf(inbox)): for a caller with no console, e.g. a board')
+    .action(async (id, o) => {
+      const { dropInbox } = await lib('inbox');
+      const hash = await inboxMove(o.commit, `gcf(inbox): drop ${id}`, (root) =>
+        dropInbox(root, id),
+      );
+      console.log(`erased ${id}${shortHash(hash)}`);
     });
 }
 
@@ -778,7 +844,7 @@ function registerLive(gcf) {
     .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'));
+      out(o.json || live.opts().json, r.issues, (l) => (l.length ? l.join('\n') : 'clean'));
       if (r.issues.length) process.exitCode = 1;
     });
 }
@@ -840,7 +906,7 @@ function registerBoard(gcf) {
           ...Object.entries(x.columns).map(
             ([s, ids]) => `${s}: ${ids.map((id) => tag(byId.get(id))).join(', ') || '-'}`,
           ),
-          `wip: ${x.wip.verdict}/${x.wip.limit}`,
+          `wip: ${x.wip.count}/${x.wip.limit}`,
           `inbox: ${x.inbox.length}, open questions: ${x.questions.length}`,
         ].join('\n'),
       );

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

package/lib/audit-core.js

@@ -9,6 +9,7 @@ import { designCheck, recordsIn } from './design-check.js';
 import { buildLedger } from './ledger.js';
 import { STORED } from './transitions.js';
 import { openDepends } from './work-ops.js';
+import { runHolder } from './main-lock.js';
 
 function git(args, cwd) {
   // A blame of a long file overflows the 1 MiB default, and an overflow reads as a git failure.
@@ -32,7 +33,7 @@ const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  * @property {string[]} legacy_cards
  * @property {{tokens: number, budget: number, over: boolean, count: number, too_many: boolean}
  *   | null} pillars
- * @property {Array<{file: string, trigger: string, status: string}>} until
+ * @property {Array<{file: string, id?: string, trigger: string, status: string}>} until
  * @property {Record<string, object[]>} linter
  * @property {object[]} pragmas
  * @property {boolean} index_drift
@@ -40,7 +41,8 @@ const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  * @property {Array<{id: string, commits: number | null, limit: number}>} stale_questions
  * @property {number} [schema]
  * @property {Array<{id: string, type: string, gate: string, status: string, system: string[],
- *   depends: string[], parent: string | null, tune_count: number}>} [items]
+ *   depends: string[], parent: string | null, tune_count: number, parallel: string,
+ *   running: boolean}>} [items]
  * @property {{blocking: number, units: number, ready: number}} [design]
  */
 
@@ -70,7 +72,12 @@ export async function audit(projectDir) {
     },
     legacy_cards: legacyCards(root),
     pillars: await pillarsOf(root, config),
-    until: untilRecords(items, systems, projectDir, ledger),
+    until: untilRecords(
+      items,
+      systems,
+      verdictMatchers(projectDir, ledger, items),
+      await questionsText(root),
+    ),
     linter: {},
     pragmas: [],
     index_drift: await drifted(root),
@@ -89,6 +96,7 @@ export async function audit(projectDir) {
     parent: c.data.parent ?? null,
     tune_count: c.data.tune_count ?? 0,
     parallel: c.data.parallel ?? 'serial',
+    running: runHolder(projectDir, c.data.id) !== null,
   }));
   const design = await designCheck(projectDir);
   checkItems(report, items, config, { projectDir, ledger });
@@ -159,7 +167,7 @@ function staleEntry(c, config, projectDir) {
 }
 
 /** WIP counts what waits for the playtest; unplayed items have their own warning (§4). */
-function wipOf(items, config) {
+export function wipOf(items, config) {
   const count = items.filter((c) => c.data.status === 'awaiting-verdict').length;
 
   return { count, limit: config.wip_built_limit, over: count > config.wip_built_limit };
@@ -257,9 +265,20 @@ function untilStatus(trigger, fired) {
   return 'manual';
 }
 
-/** Until annotations across work items and systems docs. */
-function untilRecords(items, systems, projectDir, ledger) {
-  const fired = verdictMatchers(projectDir, ledger, items);
+/** open-questions.md, or '' without one. */
+const questionsText = async (root) => {
+  const file = path.join(root, 'open-questions.md');
+
+  return existsSync(file) ? readFile(file, 'utf8') : '';
+};
+
+const D2_UNTIL_RE = /^\s+until:\s*(verdict\([a-z0-9-]+\)|retune\([a-z0-9-]+\)|manual\([^)]*\))/m;
+
+/**
+ * Until annotations across work items and systems docs, and the `until:` of each D2 record in
+ * open-questions.md (`questions` its text): a fired one is an assumption to ask the human again.
+ */
+function untilRecords(items, systems, fired, questions) {
   const docs = [
     ...items.map((c) => ({ rel: `work/${c.name}`, body: c.body })),
     ...systems.map((s) => ({ rel: `systems/${s.name}`, body: s.body })),
@@ -271,6 +290,18 @@ function untilRecords(items, systems, projectDir, ledger) {
     }
   }
 
+  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;
+    until.push({
+      file: 'gcf/open-questions.md',
+      id,
+      trigger,
+      status: untilStatus(trigger, fired),
+    });
+  }
+
   return until;
 }
 

package/lib/board.js

@@ -10,29 +10,82 @@ import { listInbox } from './inbox.js';
 import { phaseStatus } from './phase.js';
 import { verifiedBranches, worktreeOf } from './integrate.js';
 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';
+
+// 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'];
 
 /**
- * Plan progress `{tasks, done}` from its checkboxes, null without a plan file (§3.3); a plan:
- * outside the project or not a file reads as `{error}`, the rest of the board still shows.
+ * Plan progress `{tasks, done}` from its checkboxes and the plan's project path, both null
+ * without a plan file (§3.3); a plan: outside the project or not a file reads as `{error}`, the
+ * rest of the board still shows.
  */
 async function progress(projectDir, item) {
+  const plan = item.data.plan ?? `.ai-factory/plans/${item.data.id}.md`;
   try {
-    const plan = item.data.plan ?? `.ai-factory/plans/${item.data.id}.md`;
     const file = resolveInside(projectDir, plan);
-    if (!existsSync(file)) return null;
+    if (!existsSync(file)) return { plan: null, plan_file: null };
     const text = await readFile(file, 'utf8');
 
     return {
-      tasks: (text.match(/^\s*- \[[ xX]\] /gm) ?? []).length,
-      done: (text.match(/^\s*- \[[xX]\] /gm) ?? []).length,
+      plan: {
+        tasks: (text.match(/^\s*- \[[ xX]\] /gm) ?? []).length,
+        done: (text.match(/^\s*- \[[xX]\] /gm) ?? []).length,
+      },
+      plan_file: plan,
     };
   } catch (e) {
-    return { error: e.message };
+    return { plan: { error: e.message }, plan_file: null };
   }
 }
 
+/** The lines `- <a> | <b> | …` of a gcf record file, split on the pipes. */
+async function records(root, name) {
+  const file = path.join(root, name);
+  if (!existsSync(file)) return [];
+
+  return (await readFile(file, 'utf8')).split(/\r?\n/).flatMap((l) => {
+    const m = l.match(/^- (\S+)\s*\|(.*)$/);
+
+    return m ? [[m[1], ...m[2].split('|').map((f) => f.trim())]] : [];
+  });
+}
+
+/** history.md: `- <id> | <event> | <date>` (§9). */
+const historyOf = async (root) =>
+  (await records(root, 'history.md')).map(([id, event, date]) => ({
+    id,
+    event: event || null,
+    date: date || null,
+  }));
+
+/**
+ * graveyard.md: `- <id> | <type> | <reason> | tags: <tags>`; a 0.3 line has no type, and its
+ * second field is a type only when it names one (§9).
+ */
+const graveyardOf = async (root) =>
+  (await records(root, 'graveyard.md')).map(([id, ...fields]) => {
+    const tags = fields.at(-1)?.startsWith('tags:') ? fields.pop() : null;
+    const typed = fields.length > 1 && ITEM_TYPES.includes(fields[0]);
+
+    return {
+      id,
+      type: typed ? fields[0] : null,
+      reason: (typed ? fields.slice(1) : fields).join(' | ') || null,
+      tags: (tags ?? '')
+        .slice('tags:'.length)
+        .split(',')
+        .map((t) => t.trim())
+        .filter(Boolean),
+    };
+  });
+
 /** Verified branches; none outside a repository. */
 function verifiedOf(projectDir) {
   try {
@@ -66,48 +119,77 @@ async function phaseOf(projectDir) {
   }
 }
 
+/** The release block with every field: one a malformed block lacks is null (live check says so). */
+const releaseOf = (r) =>
+  r && {
+    version: r.version,
+    ...Object.fromEntries(['channel', 'date', 'phase'].map((k) => [k, r[k] ?? null])),
+  };
+
+/** The run log of an item, project-relative, or null before its first run. */
+function logOf(projectDir, id) {
+  const log = `.gcf-session/runs/${id}.log`;
+
+  return existsSync(path.join(projectDir, log)) ? log : null;
+}
+
+// Fields of the item file a board shows as they are: null or [] when the file has none.
+const SCALARS = ['title', 'parent', 'milestone', 'tune_count', 'since', 'model', 'effort'];
+const LISTS = ['children', 'system', 'depends'];
+
+/** One item of the board. */
+async function itemOf(projectDir, c, verified) {
+  const id = String(c.data.id);
+  // A trailer counts only while the item waits on main for its integrate.
+  const ready = c.data.status === 'ready' && verified.has(id);
+  // `running` and `verify` are not stored (§4): a live harness run, or a worktree of a ready
+  // item, is a run; a trailer is a passed DoD.
+  const running =
+    runHolder(projectDir, id) !== null ||
+    (c.data.status === 'ready' && !ready && existsSync(worktreeOf(projectDir, id)));
+
+  return {
+    id,
+    type: c.data.type,
+    gate: c.data.gate,
+    status: c.data.status,
+    ...Object.fromEntries(SCALARS.map((k) => [k, c.data[k] ?? null])),
+    ...Object.fromEntries(LISTS.map((k) => [k, c.data[k] ?? []])),
+    ...(c.data.severity ? { severity: c.data.severity } : {}),
+    ...(c.data.blocked ? { blocked: c.data.blocked } : {}),
+    running,
+    verified: ready,
+    // What a board may offer (§4.1): nothing while a run drives the item.
+    moves: running ? [] : movesOf(c.data),
+    file: `gcf/work/${c.name}`,
+    log: logOf(projectDir, id),
+    ...(await progress(projectDir, c)),
+  };
+}
+
 export async function board(projectDir) {
   const root = path.join(path.resolve(projectDir), 'gcf');
   const ledger = await buildLedger(projectDir);
   const verified = verifiedOf(projectDir);
   const items = [];
-  for (const c of ledger.items) {
-    const id = String(c.data.id);
-    // A trailer counts only while the item waits on main for its integrate.
-    const ready = c.data.status === 'ready' && verified.has(id);
-    items.push({
-      id,
-      type: c.data.type,
-      gate: c.data.gate,
-      status: c.data.status,
-      title: c.data.title ?? null,
-      parent: c.data.parent ?? null,
-      children: c.data.children ?? [],
-      system: c.data.system ?? [],
-      ...(c.data.severity ? { severity: c.data.severity } : {}),
-      ...(c.data.blocked ? { blocked: c.data.blocked } : {}),
-      // `running` and `verify` are not stored (§4): a worktree is a run, a trailer a passed DoD.
-      running: existsSync(worktreeOf(projectDir, id)) && !ready,
-      verified: ready,
-      plan: await progress(projectDir, c),
-    });
-  }
+  for (const c of ledger.items) items.push(await itemOf(projectDir, c, verified));
 
   const config = await readConfig(root);
   const live = await readLive(root);
 
   return {
+    schema: BOARD_SCHEMA,
     phase: await phaseOf(projectDir),
-    release: live.release,
+    // 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)]),
     ),
     items,
-    wip: {
-      verdict: items.filter((i) => i.status === 'awaiting-verdict').length,
-      limit: config.wip_built_limit,
-    },
+    wip: wipOf(ledger.items, config),
     inbox: await listInbox(root),
     questions: await questions(root),
+    history: await historyOf(root),
+    graveyard: await graveyardOf(root),
   };
 }

package/lib/design-check.js

@@ -270,6 +270,23 @@ async function bodyProblems(body, type, stage = 'card') {
   return { profile, issues };
 }
 
+/**
+ * Text an HTML comment holds in a body: cnlp-kit gives it no block, but an agent reads the raw
+ * file, so M4 and M5 read it too.
+ */
+function commentValues(body) {
+  const { lines, prose, regions } = parseBlocks(body);
+  // A tool's region and its markers belong to the tool; a pragma is an instruction, not prose.
+  const owned = (n) => regions.some((r) => n >= r.line && n <= r.end);
+  const markup = /^\s*<!--\s*(?:gcf:allow\b|[\w-]+:(?:start|end)\s*-->)/;
+
+  return prose.flatMap((l, i) =>
+    l.trim() && !lines[i].trim() && !owned(i + 1) && !markup.test(l)
+      ? [{ block: 'comment', value: l.trim(), line: i + 1 }]
+      : [],
+  );
+}
+
 /** M4 and M5 over the values of a unit. */
 function valueIssues(values, ctx) {
   const out = [];
@@ -372,7 +389,8 @@ async function checkUnit(u, ctx, ledger) {
   const { profile, issues: shape } = await bodyProblems(u.body, u.header.type, 'design');
   for (const i of shape) add('M1', atBody(i.line), i.message);
   const values = slotValues(u.body, profile);
-  for (const [c, line, m] of valueIssues(values, ctx)) add(c, atBody(line), m);
+  for (const [c, line, m] of valueIssues([...values, ...commentValues(u.body)], ctx))
+    add(c, atBody(line), m);
   for (const [c, line, m, sev] of provenanceIssues(u, values, ctx)) add(c, atBody(line), m, sev);
 
   return { issues, values };
@@ -462,7 +480,8 @@ async function checkItem(item, ctx, ledger) {
   // An unplayed body is frozen (§5.4): a later glossary word or unit, or a gone question, cannot
   // be fixed there, only reported until a tune or a kill takes the item back.
   const frozen = item.data.status === 'unplayed' ? 'report' : 'block';
-  for (const [c, line, m] of valueIssues(values, ctx)) add(c, line, m, frozen);
+  for (const [c, line, m] of valueIssues([...values, ...commentValues(item.body)], ctx))
+    add(c, line, m, frozen);
   for (const r of provenanceOf(item.body)) {
     const problem = recordProblem(r, ctx);
     // An item's quotes go stale when the GDD moves on: that is a D1 for the human, not a gate.

package/lib/integrate.js

@@ -8,7 +8,7 @@ import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { buildLedger } from './ledger.js';
 import { parse } from './frontmatter.js';
-import { withMainLock } from './main-lock.js';
+import { withMainLock, runHolder } from './main-lock.js';
 import { verifyItem, deltaProblems } from './verify.js';
 import { submitItem, closeItem, blockItem } from './work-ops.js';
 import { isValidId } from './id.js';
@@ -238,16 +238,19 @@ async function integrateMerged(projectDir, id, item) {
   if (!item || item.data.status !== 'ready' || movedSinceMerge(projectDir, id))
     return { id, skipped: `${branchOf(id)} is in main already`, ...cleanUp(projectDir, id) };
 
-  return { id, ...(await recordMove(projectDir, item)), ...cleanUp(projectDir, id) };
+  return { ...(await recordMove(projectDir, item)), id, ...cleanUp(projectDir, id) };
 }
 
 async function integrateOne(projectDir, id) {
+  // Its run records the move itself once it ends: merging now would land code with no move.
+  const run = runHolder(projectDir, id);
+  if (run) return { id, skipped: `${id} is driven by a harness run (pid ${run})` };
   const item = (await buildLedger(projectDir)).item(id);
   const ancestor = ['merge-base', '--is-ancestor', branchOf(id), 'HEAD'];
   if (git(projectDir, ancestor, { check: false }).ok) return integrateMerged(projectDir, id, item);
   if (!item || item.data.status !== 'ready')
     return { id, skipped: `${id} is ${item ? item.data.status : 'not a work item'} on main` };
-  if (item.data.type === 'spike') return { id, ...(await integrateSpike(projectDir, item)) };
+  if (item.data.type === 'spike') return { ...(await integrateSpike(projectDir, item)), id };
   const foreign = foreignGcfEdits(projectDir, id);
   if (foreign.length)
     return {
@@ -260,7 +263,7 @@ async function integrateOne(projectDir, id) {
   if (failed) return { id, ...failed };
   const moved = await recordMove(projectDir, (await buildLedger(projectDir)).item(id));
 
-  return { id, ...moved, ...cleanUp(projectDir, id) };
+  return { ...moved, id, ...cleanUp(projectDir, id) };
 }
 
 /**

package/lib/live.js

@@ -66,7 +66,7 @@ export function parseLive(text) {
   /** A record line of capabilities or known-issues; false when the line is not one. */
   const recordLine = (line) => {
     const start = line.match(/^- id:\s*(\S+)\s*$/);
-    if (start && section) {
+    if (start && section && section !== 'release') {
       rec = { id: start[1], summary: '' };
       out[section].push(rec);
 
@@ -106,7 +106,11 @@ const recordText = (r) =>
 
 const byId = (a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
 
-/** LIVE.md text: records sorted by id, so two branches touching different ids merge cleanly. */
+/**
+ * LIVE.md text: records sorted by id, so two branches touching different ids merge cleanly.
+ * @param {{phase?: string | null, release?: LiveRelease | null, capabilities: LiveRecord[],
+ *   knownIssues: LiveRecord[]}} live
+ */
 export function serializeLive({ phase = null, release = null, capabilities, knownIssues }) {
   const block = (key, list) =>
     `${key}:\n${list.length ? [...list].sort(byId).map(recordText).join('\n') : NONE[key]}\n`;

package/lib/main-lock.js

@@ -3,7 +3,8 @@
 // each other instead of committing over each other. Re-entrant along one call chain: `integrate`
 // holds it across the merge and the move it records.
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { link, mkdir, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises';
+import { link, mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 
@@ -24,6 +25,21 @@ const alive = (pid) => {
   }
 };
 
+/**
+ * The pid of a live harness run that drives item `id` (`.gcf-session/runs/<id>.lock`), or null.
+ * A move on that item from anywhere else would race the run's own record of it.
+ */
+export function runHolder(projectDir, id) {
+  try {
+    const file = path.join(path.resolve(projectDir), '.gcf-session', 'runs', `${id}.lock`);
+    const pid = Number(readFileSync(file, 'utf8').split('\n')[0]);
+
+    return Number.isInteger(pid) && pid > 0 && pid !== process.pid && alive(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
 /** The lock's text when its holder is gone, else null. The file appears whole: see `take`. */
 async function staleText(file) {
   try {
@@ -59,20 +75,34 @@ async function take(file, token) {
 }
 
 /**
- * Move a dead holder's lock aside. shortcut: two takers that judged the same dead lock may race
- * here — the rename lets one of them win, a fresh lock renamed by the loser is put back.
+ * Remove a dead holder's lock. Only the taker holding `<lock>.break` may: two takers that judged
+ * the same dead lock cannot both clear it, and the second finds the winner's live lock in place.
+ * Nothing else replaces the lock meanwhile — `take` fails on an existing file.
  */
 async function clearStale(file, text) {
-  const aside = `${file}.stale-${randomUUID()}`;
-  try {
-    await rename(file, aside);
-  } catch {
+  const breaker = `${file}.break`;
+  const token = randomUUID();
+  if (!(await take(breaker, token))) {
+    // A breaker is held for a read and an unlink; an old one belongs to a taker that died there.
+    const old = await stat(breaker).then(
+      (s) => Date.now() - s.mtimeMs > 10000,
+      () => false,
+    );
+    if (old) await unlink(breaker).catch(() => {});
+    await sleep(100);
+
     return;
   }
 
-  if ((await readFile(aside, 'utf8').catch(() => text)) !== text)
-    await link(aside, file).catch(() => {});
-  await unlink(aside).catch(() => {});
+  try {
+    if ((await readFile(file, 'utf8').catch(() => null)) === text) await unlink(file);
+  } catch {
+    // released meanwhile
+  } finally {
+    // A breaker taken over as old meanwhile belongs to its new holder.
+    if ((await readFile(breaker, 'utf8').catch(() => '')).includes(token))
+      await unlink(breaker).catch(() => {});
+  }
 }
 
 /**

package/lib/playtest-list.js

@@ -64,10 +64,16 @@ export async function playtestSession(
   const dirty = git(projectDir, ['status', '--porcelain', '--', '.', ':(exclude)gcf/.metrics']);
   const session = {
     branch: git(projectDir, ['rev-parse', '--abbrev-ref', 'HEAD']),
+    // The remote's default branch when the clone knows it: main by any name. Null otherwise.
+    main:
+      git(projectDir, ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'])?.replace(
+        /^origin\//,
+        '',
+      ) ?? null,
     commit: git(projectDir, ['rev-parse', '--short', 'HEAD']),
     // No commit (no repository, or none yet): the build is unknown, not clean.
     dirty: dirty === null ? null : Boolean(dirty),
-    build: null,
+    build: /** @type {ReturnType<typeof runDod> | null} */ (null),
     items,
   };
   if (build) session.build = runDod(projectDir, await readConfig(root), 'build', stdio);

package/lib/transitions.js

@@ -37,6 +37,31 @@ export function allowedFrom(move, status) {
 /** Statuses `move` starts from, for error messages. */
 export const fromOf = (move) => FROM[move] ?? [];
 
+export const FEATURE_ONLY = ['close', 'continue', 'kill'];
+const BUG_ONLY = ['wontfix', 'known'];
+
+/** Whether a decision fits an item's type: a feature has its own, wontfix and known a bug's. */
+export const decisionFits = (choice, type) =>
+  FEATURE_ONLY.includes(choice) === (type === 'feature') &&
+  (!BUG_ONLY.includes(choice) || type === 'bug');
+
+/** Whether a move fits the item beyond its status: its gate for submit and close, its type. */
+function fits(move, { type, gate }) {
+  const [cmd, arg] = move.split(':');
+  if (cmd === 'submit') return gate !== 'auto';
+  if (cmd === 'close') return gate === 'auto';
+
+  return cmd !== 'decide' || decisionFits(arg, type);
+}
+
+/**
+ * The moves an item may take now (§4.1), named as `allowedFrom` names them: `verdict:keep`,
+ * `decide:go`, `unblock`… A board offers these and nothing else; each command still checks the
+ * rest itself (dependencies, a live: delta, the tune limit).
+ */
+export const movesOf = (data) =>
+  Object.keys(FROM).filter((m) => allowedFrom(m, data.status) && fits(m, data));
+
 /** A status an item FILE may carry. */
 export function isStorable(status) {
   return STORED.includes(status);

package/lib/verdict-fs.js

@@ -3,6 +3,7 @@
 // work-ops.js; these are the deterministic pieces they share.
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { parseBlocks, itemsOf, readRecords } from 'cnlp-kit';
 import { serialize } from './frontmatter.js';
@@ -82,22 +83,60 @@ export async function mergeIntoSystem(root, system, item) {
   await atomicWrite(doc.file, serialize({ ...doc.data, updated_by: item.data.id }, body));
 }
 
+/**
+ * The lines a systems doc held before the item's unplayed close: the merge skipped them, so they
+ * are some earlier item's or unit's, not this one's. None when that commit is not found.
+ */
+function linesBeforeClose(root, system, id) {
+  const cwd = path.dirname(root);
+  const close = unplayedCloseCommit(cwd, id);
+  if (!close) return [];
+  const text = fileAt(cwd, `${close}^`, path.join(root, 'systems', `${system}.md`));
+
+  return text === null ? [] : text.replace(/\r\n/g, '\n').split('\n');
+}
+
+/** The last commit that closed item `id` unplayed, or null. */
+export function unplayedCloseCommit(projectDir, id) {
+  const log = spawnSync(
+    'git',
+    ['log', '-1', '--format=%H', '--fixed-strings', `--grep=gcf(close): ${id} → unplayed`],
+    { cwd: projectDir, encoding: 'utf8' },
+  );
+
+  return (log.status === 0 && log.stdout.trim()) || null;
+}
+
+/** A file's text at a revision, or null when the revision does not hold it. */
+export function fileAt(projectDir, rev, file) {
+  const rel = path.relative(projectDir, file).replace(/\\/g, '/');
+  const show = spawnSync('git', ['show', `${rev}:${rel}`], {
+    cwd: projectDir,
+    encoding: 'utf8',
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (show.error) throw show.error;
+
+  return show.status === 0 ? show.stdout : null;
+}
+
 /**
  * Take an unplayed item's lines back out of a systems doc (tune, kill or drop of an unplayed
- * item). `keep` are lines other unplayed items still owe the doc. shortcut: a line shared word
- * for word with an already kept item leaves too — that body is gone; upgrade to per-line origin
- * marks if that ever bites.
+ * item). `keep` are lines other unplayed items still owe the doc; a line the doc held before the
+ * close stays too. shortcut: a line an item kept after this close brought word for word was
+ * skipped by its merge and leaves here; upgrade to per-line origin marks if that ever bites.
  */
 export async function unmergeFromSystem(root, system, item, keep = []) {
   const file = path.join(root, 'systems', `${system}.md`);
   if (!existsSync(file)) return;
   const doc = await openSystemDoc(root, system);
+  const before = linesBeforeClose(root, system, item.data.id);
   let body = doc.body;
   for (const [section, lines] of Object.entries(collapseLines(item.body))) {
     body = removeLines(
       body,
       section,
-      lines.filter((l) => !keep.includes(l)),
+      lines.filter((l) => !keep.includes(l) && !before.includes(l)),
     );
   }
 

package/lib/work-ops.js

@@ -8,12 +8,11 @@ import { existsSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import path from 'node:path';
-import { serialize } from './frontmatter.js';
+import { parse, serialize } from './frontmatter.js';
 import { buildLedger } from './ledger.js';
 import { readConfig } from './gcf-paths.js';
-import { atomicWrite, withFileRollback } from './safe-path.js';
-import { writeIndex } from './index-gen.js';
-import { allowedFrom, fromOf } from './transitions.js';
+import { atomicWrite } from './safe-path.js';
+import { allowedFrom, decisionFits, FEATURE_ONLY, fromOf } from './transitions.js';
 import { ITEM_TYPES, DEFAULT_GATE, GATES, SEVERITIES, UNIT_ITEM_TYPES } from './validate-item.js';
 import { isValidId } from './id.js';
 import { commitMove, addConstraints } from './unit-ops.js';
@@ -25,6 +24,8 @@ import {
   systemFiles,
   buryLine,
   recordLine,
+  unplayedCloseCommit,
+  fileAt,
 } from './verdict-fs.js';
 import {
   readLiveStrict,
@@ -36,6 +37,7 @@ import {
 } from './live.js';
 import { dropInbox } from './inbox.js';
 import { refuseByPhase } from './phase.js';
+import { runHolder } from './main-lock.js';
 
 /**
  * Options of a committed move; each move reads the ones it needs.
@@ -108,15 +110,44 @@ export const frozenHash = (item) =>
     .update(`\nlive: ${JSON.stringify(item.data.live ?? null)}`)
     .digest('hex');
 
+/** The 0.4.0 `frozen:`: the sha1 of the body alone, without the `live:` delta. */
+const legacyFrozen = (item) =>
+  createHash('sha1').update(String(item.body).replace(/\r\n/g, '\n').trim()).digest('hex');
+
 /**
- * Whether an unplayed item still matches its `frozen:`. An item closed by 0.4.0 holds the sha1
- * of its body alone: it still guards the body. shortcut: such an item's live: stays unguarded
- * until it is closed again; drop the legacy form once no 0.4.0 unplayed item is left.
+ * Whether an unplayed item still matches its `frozen:`. An item closed by 0.4.0 holds the
+ * legacy form, which guards the body only, until `gcf init` restamps it (restampFrozen).
  */
 export const matchesFrozen = (item) =>
-  item.data.frozen === frozenHash(item) ||
-  item.data.frozen ===
-    createHash('sha1').update(String(item.body).replace(/\r\n/g, '\n').trim()).digest('hex');
+  item.data.frozen === frozenHash(item) || item.data.frozen === legacyFrozen(item);
+
+/** Whether the item's `live:` is the one its unplayed close committed. */
+function liveAsClosed(projectDir, item) {
+  const close = unplayedCloseCommit(projectDir, item.data.id);
+  const text = close && fileAt(projectDir, close, item.file);
+  if (!text) return false;
+  const live = (data) => JSON.stringify(data.live ?? null);
+
+  return live(parse(text).data) === live(item.data);
+}
+
+/**
+ * Give every unplayed item still frozen in the 0.4.0 form the full hash, so its `live:` is
+ * guarded too — only while that `live:` is still the one its close committed: a later edit is
+ * the drift the guard exists for, and must not be stamped in. Returns the ids.
+ */
+export async function restampFrozen(projectDir) {
+  const ledger = await buildLedger(projectDir);
+  const legacy = ledger.items.filter(
+    (i) =>
+      i.data.status === 'unplayed' &&
+      i.data.frozen === legacyFrozen(i) &&
+      liveAsClosed(projectDir, i),
+  );
+  for (const i of legacy) await writeItem(i, { ...i.data, frozen: frozenHash(i) });
+
+  return legacy.map((i) => String(i.data.id));
+}
 
 /** Children of a feature that are not finished: live in any status but unplayed and parked. */
 function unfinishedChildren(ledger, feature) {
@@ -136,6 +167,12 @@ async function begin(projectDir, id, move) {
   const ledger = await buildLedger(projectDir);
   const item = itemOf(ledger, id);
   need(move, item);
+  const run = runHolder(projectDir, id);
+  if (run)
+    throw new Error(
+      `${id} is driven by a harness run (pid ${run}): wait until that run ends; if no harness ` +
+        `run is going, delete .gcf-session/runs/${id}.lock`,
+    );
   const files = [item.file];
   const steps = [];
   const liveOps = [];
@@ -608,10 +645,9 @@ const DECIDE = {
   },
   kill: killFeature,
 };
-const FEATURE_ONLY = ['close', 'continue', 'kill'];
-
 /** Refuse a decision that does not fit the item's type. */
 function fitDecision(choice, item) {
+  if (decisionFits(choice, item.data.type)) return;
   const feature = item.data.type === 'feature';
   if (FEATURE_ONLY.includes(choice) !== feature)
     throw new Error(
@@ -619,8 +655,7 @@ function fitDecision(choice, item) {
         ? `${item.data.id} is a feature: decide close | continue | kill`
         : `decide ${choice} is for a feature; ${item.data.id} is a ${item.data.type}`,
     );
-  if (['wontfix', 'known'].includes(choice) && item.data.type !== 'bug')
-    throw new Error(`decide ${choice} is for a bug; ${item.data.id} is a ${item.data.type}`);
+  throw new Error(`decide ${choice} is for a bug; ${item.data.id} is a ${item.data.type}`);
 }
 
 /** The operator's decisions (Methodology §4.1): spikes, decision items, bugs and features.
@@ -689,6 +724,9 @@ export async function dropItem(projectDir, id, opts = {}) {
   return { id, hash: await finish(m, 'drop', id, commit), removal };
 }
 
+// A leading hyphen would read as a flag of the agent's command line.
+export const RUN_WORD = /^[A-Za-z0-9][\w.-]*$/;
+
 /** The version and channel of a new item: well-formed, and only on a release. */
 function checkRelease(spec) {
   const { type, version, channel } = spec;
@@ -702,6 +740,20 @@ function checkRelease(spec) {
     throw new Error('--release and --channel belong to a release item');
 }
 
+const RUN_KEYS = ['model', 'effort'];
+
+/** The model and effort a new item gives: the run passes them to the agent's command line. */
+function runFields(spec) {
+  for (const k of RUN_KEYS)
+    if (spec[k] !== undefined && !RUN_WORD.test(spec[k]))
+      throw new Error(
+        `--${k} is one word that starts with a letter or a digit ` +
+          '(then letters, digits, dots, hyphens, underscores), e.g. opus',
+      );
+
+  return Object.fromEntries(RUN_KEYS.filter((k) => spec[k]).map((k) => [k, spec[k]]));
+}
+
 /** Refuse a spec `item new` cannot honour; returns the gate the item gets. */
 function checkNew(ledger, spec) {
   const { id, type, gate, severity } = spec;
@@ -752,6 +804,7 @@ function optionalFields(spec, gate, since) {
     ...(spec.milestone ? { milestone: spec.milestone } : {}),
     ...(spec.version ? { version: spec.version } : {}),
     ...(spec.channel ? { channel: spec.channel } : {}),
+    ...runFields(spec),
     ...(live ? { live } : {}),
   };
 }
@@ -800,14 +853,18 @@ export async function newItem(projectDir, spec) {
     writes.push([p.file, serialize({ ...p.data, children }, p.body)]);
   }
 
-  await withFileRollback(
-    [...writes.map((w) => w[0]), path.join(root, 'inbox.md'), path.join(root, 'INDEX.md')],
-    async () => {
+  // `commit` is for a caller with no console to commit from, a board: a run starts from HEAD.
+  // The inbox is raw input (merge=union): lines added without a commit ride along with it.
+  const inbox = spec.from ? [path.join(root, 'inbox.md')] : [];
+  const hash = await commitMove(projectDir, `gcf(item): ${spec.id}`, {
+    files: [...writes.map((w) => w[0]), ...inbox],
+    inputs: inbox,
+    mutate: async () => {
       for (const [f, text] of writes) await atomicWrite(f, text);
       if (spec.from) await dropInbox(root, spec.from);
-      await writeIndex(root);
     },
-  );
+    commit: spec.commit ?? false,
+  });
 
-  return { item: `gcf/work/${spec.id}.md` };
+  return { item: `gcf/work/${spec.id}.md`, hash };
 }

package/package.json

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

package/skills/gcf-audit/SKILL.md

@@ -19,10 +19,11 @@ workflow:
 1. run `ai-factory gcf audit --json` and read the report
 2. state the first line verbatim: items waiting too long block dependent work, so they lead
 3. for each stale until record: name the file, the trigger that fired and the line to re-check; for each entry of `stale_questions`: name the question id and ask the human for the answer
-4. read the `design` summary: blocking findings first (run `ai-factory gcf design check` for the list), then the count of ready units
-5. semantic pass, only when the mechanical report is clean or the human asks: read the systems docs of ONE subsystem the human names and report pairs of lines that contradict each other as D1 questions
-6. list the pragmas: each `gcf:allow` is a standing exception, and a growing list is the linter rotting
-7. propose the next actions, ranked, proposed actions <= 3: playtest, answer a D1, take a ready unit, or collapse a stale record
+4. for a stale until record of `gcf/open-questions.md`: the D2 assumption its `id` names expired - ask the human to confirm it, then cite `answer: <id>` and remove the record, or to replace the value
+5. read the `design` summary: blocking findings first (run `ai-factory gcf design check` for the list), then the count of ready units
+6. semantic pass, only when the mechanical report is clean or the human asks: read the systems docs of ONE subsystem the human names and report pairs of lines that contradict each other as D1 questions
+7. list the pragmas: each `gcf:allow` is a standing exception, and a growing list is the linter rotting
+8. propose the next actions, ranked, proposed actions <= 3: playtest, answer a D1, take a ready unit, or collapse a stale record
 
 invocation:
 - run at session start, after a long break, or on demand

package/skills/gcf-init/SKILL.md

@@ -15,7 +15,7 @@ preconditions:
 - the project is a git repository with AI Factory initialized
 
 forbidden_behaviors:
-- do not overwrite an existing gcf/ tree: re-running repairs missing files only
+- do not overwrite an existing gcf/ tree: re-running repairs missing files, refreshes the AGENTS.md block and restamps a 0.4.0 `frozen:`
 - do not write pillars the human did not confirm: pillar authorship is human
 - pillar count <= 7, and do not pad the list to reach 7
 

package/templates/agents-block.md

@@ -6,7 +6,7 @@ gcf_context:
 
 gcf_work:
 - every piece of work is one work item `gcf/work/<id>.md`: find the item before writing code for a feature, a bug or a tech task, or create it with the gcf-card skill
-- a raw idea, a playtest note or a CI finding that is not work yet goes to `ai-factory gcf inbox add "<text>"`, and the gcf-triage skill sorts it later
+- a raw idea, a playtest note or a CI finding that is not work yet goes to `ai-factory gcf inbox add "<text>"`, and the gcf-triage skill sorts it later; a text that starts with a hyphen goes as `inbox add --text="<text>"`
 - before planning an item, run `ai-factory gcf context <id>` and read only the files it lists under `gcf/`
 - drive a ready item with the gcf-run skill when the project has gcf-harness-aif-ext (a batch at once: `ai-factory gcf-harness run <ids...>`), otherwise with aif-plan and aif-implement
 - after the code, write the item's `live:` delta and run `ai-factory gcf verify <id>`: fix what it reports and run it again until every check is green
@@ -18,6 +18,7 @@ gcf_work:
 - the human plays from `ai-factory gcf playtest session`; each free note from that play goes to `ai-factory gcf inbox add --source playtest "<note>"`
 - a release item carries `version:` and `channel:` (`item new <id> --type release --release <v> --channel <c>`): its end writes the `release:` block of `gcf/LIVE.md`
 - `item new` and `take` refuse a type the current phase does not take: run `ai-factory gcf phase` and bring the refusal to the human
+- an item the human wants run on a given model or effort gets `item new <id> --model <m> --effort <e>`: the harness run passes both to the agent
 - a pillar changes only on the human's word: `ai-factory gcf pillar rename <from> <to>`, or `ai-factory gcf pillar retire <id> --reason "<why>"`
 
 gcf_forbidden: