gcf-aif-ext 0.7.13 → 0.7.14

package/README.md

@@ -50,6 +50,13 @@ 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.14
+
+- `gcf anchor --json` gives each section its `body`, the text `/gcf-run-ingest` hands its workflow. The delta counts from the last *finished* import: `anchor` holds the map it started from in `gcf/source/<file>.import.json` until `gcf anchor <file> --done`, so an import that died after anchoring reports the same delta again (`resumed`) instead of an empty one. `/gcf-ingest` ends with `--done`.
+- Instructions, from an audit of the agents' rules (2026-10-16): the commit injection makes no move on a `work/<id>` branch (verify `--mark`, the integrator moves it); the plan injection allows `gcf/INDEX.md` and `gcf/config.yml` besides the readset and names its graveyard and D2 lines; the review injection checks a feature child's capability against its parent's `live:`.
+- Skills: `/gcf-card` puts `--severity` and `--release --channel` on `item new` and writes a bug's `repro:`, and removes an answered D1 only after every unit it blocks has it; `/gcf-triage` leaves a tune note in the inbox until `/gcf-verdict … tune --note` records it; a re-check after a red verify counts against `dod_attempts`; `cnlp-kit check` is named for what it covers. The item template keeps the architecture rule in `constraints:`; the systems profile keeps an `until:` line in its own block.
+- Run `ai-factory extension update gcf-aif-ext`: the injections and skills come with it. Update `gcf-harness-aif-ext` to 0.9.6 with it: an older `/gcf-run-ingest` never runs `anchor --done`, so every later import would come back `resumed` with the delta of the first one.
+
 ### 0.7.13
 
 - `gcf close` and `gcf submit` need a green `gcf verify <id>` of the code as it is now (Methodology §6). A green verify records the hash of the project's code (everything but `gcf/`, `.ai-factory/` and `.gcf-session/`, committed or not) in `.gcf-session/runs/<id>.verified`; committing that code keeps the record valid, any later edit asks for a new verify. Without one the move refuses: `<id>: no green gcf verify on record — run ai-factory gcf verify <id> until it is green; only the human may move it without one (--unverified "<why>")`; a changed code names the files that changed. `--unverified "<why>"` is the operator's way past it, and the reason goes into the move's commit (`gcf(close): <id> (unverified: <why>)`). A feature's close and the integrator's moves (they rest on the `GCF-Verified` trailer) need no record.

package/commands/gcf.js

@@ -459,31 +459,25 @@ function registerAnchor(gcf) {
       'Import a GDD into gcf/source/ with stable section anchors; on re-import prints the delta',
     )
     .option('--json', 'machine output')
+    .option('--done', 'the import is written: the next anchor counts its delta from this one')
     .action(async (file, opts) => {
-      const anchors = await lib('anchors');
-      const { splitSections, importSource, loadAnchorMap, classifyDelta } = anchors;
-      const base = path.basename(file);
-      const oldMap = await loadAnchorMap(process.cwd(), base);
-      const { readFile } = await import('node:fs/promises');
-      const sections = splitSections(await readFile(file, 'utf8'));
-      const delta = oldMap?.anchors ? classifyDelta(oldMap.anchors, sections) : null;
-      await importSource(process.cwd(), file);
-      // A renamed heading moves its anchor: provenance and source: follow it.
-      const rewritten = delta ? await anchors.rewriteAnchors(process.cwd(), delta.renamed) : [];
-      const rebaselined = Boolean(oldMap?.rebaselined);
-      const result = {
-        file: `gcf/source/${base}`,
-        sections: sections.map((s) => ({ anchor: s.anchor, heading: s.heading, lines: s.lines })),
-        delta,
-        rebaselined,
-        rewritten,
-      };
-      out(opts.json, result, (r) =>
+      const { anchorImport, finishImport } = await lib('anchors');
+      if (opts.done) {
+        const done = await finishImport(process.cwd(), file);
+        console.log(done ? `import of ${path.basename(file)} finished` : 'no import to finish');
+
+        return;
+      }
+
+      out(opts.json, await anchorImport(process.cwd(), file), (r) =>
         [
           ...r.sections.map(
             (s) => `${s.anchor}  L${s.lines[0]}-${s.lines[1]}  ${s.heading ?? '(preamble)'}`,
           ),
           anchorDeltaLine(r),
+          ...(r.resumed
+            ? ['resumed: an earlier import of this file did not finish, the delta counts from it']
+            : []),
           ...r.rewritten.map((f) => `renamed anchors rewritten in gcf/${f}`),
         ].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.7.13",
+  "version": "0.7.14",
   "description": "Game Context Framework for AI Factory",
   "skills": [
     "skills/gcf-init",

package/injections/commit-status.md

@@ -1,6 +1,7 @@
 ## GCF: work item status after commit (from gcf-aif-ext)
 
 gcf_commit:
+- on a `work/<id>` branch (a harness worktree) make none of the moves below: the session marks the branch with `ai-factory gcf verify <item-id> --mark` once its work is done, a stop goes into `.gcf-session/outcome.json`, and `ai-factory gcf integrate` on main records the move
 - when `gcf/` exists and the commit implements a work item, commit the implementation first, then move the item with its own command in a follow-up commit
 - gate `verdict` or `decision`: run `ai-factory gcf submit <item-id>` — it waits for the operator, `since:` records where the wait began
 - gate `auto`, every check green: write the item's `live:` delta, then run `ai-factory gcf close <item-id>` — never edit `status:` by hand

package/injections/plan-context.md

@@ -2,7 +2,8 @@
 
 gcf_gate:
 - when `gcf/` exists and the task names a work item, run `ai-factory gcf context <item-id>` first
-- the returned file list is the readset: read those files and nothing else under `gcf/`; `gcf/LIVE.md` in it says what the game already does
+- the returned file list is the readset: read those files, `gcf/INDEX.md` and `gcf/config.yml`, and nothing else under `gcf/`; `gcf/LIVE.md` in it says what the game already does
+- its `graveyard_hits` and `d2` lines are context too: what was buried before, and the assumptions in force with their `until:`
 - `over_budget: true` in the result: stop and record a D1 question instead of planning
 - an id in `depends:` that lives in `gcf/design/`, or as an item in any status but unplayed, parked or awaiting-verdict, is not played: do not plan on top of it, stop
 - a dependency awaiting its verdict is planned on: the close of this item then waits for that verdict (`ai-factory gcf block <id> --reason "waits for <dep>"`)

package/injections/review-pillars.md

@@ -6,3 +6,4 @@ gcf_review:
 - check the diff against each pillar's review question: a contradiction is a finding, not a note
 - numeric feel values in code outside the item's envelope: report the value and the envelope bounds
 - a capability the diff adds, changes or removes that the item's `live:` delta does not name: a finding
+- a feature child with `live: none: parent` carries no delta of its own: check the capability against its parent feature's `live:`, and one the parent does not name is a finding on the parent

package/lib/anchors.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { readFile, writeFile, mkdir, readdir } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, readdir, rm } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 
@@ -230,3 +230,60 @@ export async function rewriteAnchors(projectDir, renamed) {
 
   return changed;
 }
+
+/** `<base>.import.json`: the anchor map an import that has not finished started from. */
+const heldFile = (projectDir, base) =>
+  path.join(path.resolve(projectDir), 'gcf', 'source', `${base}.import.json`);
+
+/**
+ * `gcf anchor`: copy a GDD into gcf/source/, write its anchor map, and report its sections
+ * with their bodies and the delta. The delta counts from the map the last FINISHED import left:
+ * the map an import starts from is held until `finishImport`, so an import that died after
+ * anchoring reports the same delta again instead of an empty one (`resumed`).
+ */
+export async function anchorImport(projectDir, file) {
+  const base = path.basename(file);
+  const held = heldFile(projectDir, base);
+  const resumed = existsSync(held);
+  const current = await loadAnchorMap(projectDir, base);
+  const start = resumed
+    ? JSON.parse(await readFile(held, 'utf8'))
+    : (current ?? { anchors: null, rebaselined: false });
+  // Read first: a wrong path must leave no held map behind to fake an unfinished import.
+  const sections = splitSections(await readFile(file, 'utf8'));
+  if (!resumed) {
+    await mkdir(path.dirname(held), { recursive: true });
+    await writeFile(held, `${JSON.stringify(start, null, 2)}\n`, 'utf8');
+  }
+
+  const delta = start.anchors ? classifyDelta(start.anchors, sections) : null;
+  await importSource(projectDir, file);
+  // A renamed heading moves its anchor: provenance and source: follow it, from the anchors
+  // they cite now - those of the last anchoring - and from the held start's too, for a file a
+  // rewrite that died left behind; a rename already applied finds nothing to change.
+  const moved = current?.anchors ? classifyDelta(current.anchors, sections).renamed : [];
+  const renamed = [...moved, ...(delta?.renamed ?? [])];
+
+  return {
+    file: `gcf/source/${base}`,
+    sections: sections.map(({ anchor, heading, lines, body }) => ({
+      anchor,
+      heading,
+      lines,
+      body,
+    })),
+    delta,
+    rebaselined: Boolean(start.rebaselined),
+    resumed,
+    rewritten: await rewriteAnchors(projectDir, renamed),
+  };
+}
+
+/** `gcf anchor <file> --done`: the import is written; the next delta counts from it. */
+export async function finishImport(projectDir, file) {
+  const held = heldFile(projectDir, path.basename(file));
+  if (!existsSync(held)) return false;
+  await rm(held);
+
+  return true;
+}

package/package.json

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

package/profiles/pillars.md

@@ -25,7 +25,7 @@ sections:
   note: pillar count <= 7 and the token budget are enforced by the gcf audit core; id is the slug a design unit cites in pillars:
 
 custom_sections:
-- none: a pillar that needs more than its three keys is not a pillar yet
+- none: a pillar that needs more than its statement, invariant, review question and id is not a pillar yet
 
 enforcement:
 - `npx --yes cnlp-kit check`, over the file a `cnlp.config.json` corpus entry maps to this profile

package/profiles/system.md

@@ -46,7 +46,7 @@ sections:
 - key: open
   form: bullet-list
   required: no
-  note: lines carrying a live "[until: ...]" annotation, moved here by collapse
+  note: open entries that fit no block above; a line with a live "[until: ...]" stays in its own block (an envelope in feel, a limit in constraints) - the annotation alone moves nothing here
 
 custom_sections:
 - none: a fact that fits no block above belongs to code or to a work item, not here

package/skills/gcf-adopt/SKILL.md

@@ -33,7 +33,7 @@ workflow:
 7. fill `behavior:` and `constraints:` with 1 placeholder each, annotated `[until: manual(first verdict touching <name>)]`: the profile requires both blocks, and a `manual(...)` trigger is not an audit finding
 8. write a constraint the human states out loud into `constraints:`, and do not interview subsystem by subsystem for more: unanswered questions on adoption day are the staleness this framework exists to remove
 9. draft `PILLARS.md` by the interview in the `gcf-init` skill, steps 4..6, and do not restate that interview here
-10. run `npx --yes cnlp-kit check`, then `ai-factory gcf lint` over each new systems doc, then `ai-factory gcf index`
+10. run `npx --yes cnlp-kit check` (it covers the systems docs and PILLARS of `cnlp.config.json`, not design units), then `ai-factory gcf lint` over each new systems doc, then `ai-factory gcf index`
 11. ask the human to run `ai-factory gcf hooks-install`; when it refuses over a foreign pre-commit, hand them the chain line it prints
 12. state the next step: an old design document goes through `/gcf-ingest` into `gcf/design/`, new work starts at `/gcf-card`
 

package/skills/gcf-card/SKILL.md

@@ -24,6 +24,7 @@ forbidden_behaviors:
 - do not move a section, edit the backlog or write `status:` by hand: `ai-factory gcf take`, `item new`, `done`, `drop` and the item moves own those
 - do not reuse an id: an ended id stays ended; rework gets a new id with `reopens: <old id>`
 - do not put an id in `depends` for order alone: `depends` names an item whose data or code this one uses, and order goes in `priority`
+- do not remove an answered D1 record while a unit in its `blocks:` lacks the answer, or names a receiver you cannot tell: it stays
 - do not remove a D2 record cited as `assumed: q-NNN`: it stays in `gcf/open-questions.md` until its `until:` fires; when the human confirms the value earlier, rewrite each citation to `answer: q-NNN` first
 
 outputs:
@@ -34,8 +35,8 @@ outputs:
 workflow:
 1. for a free-text design idea: ask "into work now, or park it?"; write a unit in the matching `gcf/design/<system>.md` with `source: manual` and `TBD` slots, append `- <id>` to `gcf/backlog.md`, and on "park" stop here
 2. for non-design work: pick the type - tech, bug, spike, asset, content, perf, release - among those `ai-factory gcf phase` says the phase takes, and propose the gate its type gives; the human may flip it (`--gate auto` is "no playtest")
-3. a bug needs `--severity` and a `repro:` the human confirms; a release needs `--release <version> --channel <name>` from the human
-4. run `ai-factory gcf item new <id> --type <type> [--gate <gate>] [--parent <feature>] [--title "<line>"]`, add `--from <in-id>` when it comes from the inbox, `--blocked "file needed"` for a final asset; then write `intent:` and `live:` and stop
+3. a bug needs `--severity <level>` and a `repro:` the human confirms; a release needs `--release <version> --channel <name>` from the human; those flags go on the `item new` of step 4
+4. run `ai-factory gcf item new <id> --type <type> [--gate <gate>] [--parent <feature>] [--title "<line>"]`, `--from <in-id>` from the inbox, `--blocked "file needed"` for an asset; write `intent:`, a bug's `repro:` and `live:`; stop
 5. for a design unit: run `ai-factory gcf where <id>`; the id must be a single unit of `gcf/design/`; read its section from the file the command names
 6. for a unit with `flags: impl?` ask the human first whether the mechanic already ships; on "yes" run `ai-factory gcf drop <id> --reason "already ships"` and stop
 7. for a unit with `flags: src-changed` re-read each changed anchor with `ai-factory gcf section`, rebuild the slots whose quote moved, and remove the flag
@@ -44,7 +45,7 @@ workflow:
 10. for `pillars: TBD` propose the ids from `gcf/PILLARS.md` whose statement the unit serves and whose invariant it keeps
 11. when no pillar fits, ask whether the unit is out of scope or a pillar is missing, and write a D1 question for the answer
 12. write each answer into the unit in place, with its `answer:` provenance record
-13. a record of `gcf/open-questions.md` that carries the human's `answer:` and names this unit in `blocks:` goes into its slot with `answer: q-NNN`; the record then leaves the file
+13. a record of `gcf/open-questions.md` with the human's `answer:` that names this unit in `blocks:` goes into the slot of every unit it blocks, each with `answer: q-NNN`; it leaves the file after the last of them has it
 14. run `ai-factory gcf design check --json` until the unit's entry in `units` reads `ready: true`, then commit the answered unit
 15. run `ai-factory gcf take <id>` for one unit, or `ai-factory gcf take <id> <id> --feature <feature-id>` to group several under a feature; it writes `gcf/work/<id>.md` and removes the sections and backlog lines in one step
 16. in each mechanic or resource item write `contract:` from the code tree and `interactions:` from the units and items that write the same state; a soft unit whose human wants no playtest gets `gate: auto` - it will close as unplayed

package/skills/gcf-ingest/SKILL.md

@@ -23,13 +23,14 @@ forbidden_behaviors:
 - do not read `gcf/source/` files whole after anchoring: read a section with `ai-factory gcf section <file> <anchor>`
 - do not turn a count, a hard limit or a performance threshold into an envelope: only a tunable value gets a range
 - do not write a digit in prose: a number is an envelope `a..b <unit>` in `feel` or a rate, or a closing comparison `<subject> <op> <value> [unit]`
+- a quote keeps its digits verbatim, and an id, a path or a backticked value is no prose; a number spelled out in words is no fix
 - do not overwrite a slot whose provenance record reads `answer:`: the human wrote it, and a conflict with the GDD is a D1 question
 - do not reuse an id the ledger reports as done, collapsed or killed: `ai-factory gcf where <id>` says, and a revival is the human's D1
 
 outputs:
 - a unit: a `## <id>` section in `gcf/design/<system>.md`, the id a lowercase hyphen slug from the unit's name, frozen once written
 - the unit header: `type`, `title`, `route: soft|hard (<why>)`, `system: [<file system>, ...]`, `milestone`, `pillars`, `depends`, `source`, and `flags` only when one applies
-- the unit body: the blocks of `templates/design.md` for its type - mechanic, resource, rule, constraint or entity - with `TBD` for every unknown
+- the unit body: the header of `templates/design.md`, and the blocks `profiles/unit-<type>.md` lists for its type - mechanic, resource, rule, constraint or entity - with `TBD` for every unknown; `contract:` and `interactions:` come only in work
 - a `provenance:` block per unit: one record per slot, `slot` plus `src: GDD#<anchor>` and `quote: "<verbatim>"`, or `assumed: q-NNN` for a D2 decision
 - `gcf/design/<system>.md` opens with `# <system>` and a `purpose:` block, `TBD` when the GDD names no purpose
 - `gcf/backlog.md`: one `- <id>` line per new unit, appended at the end
@@ -39,7 +40,7 @@ outputs:
 
 workflow:
 1. when `gcf/systems/` is empty and the repository already holds game code, tell the human `impl?` marks are blind without `/gcf-adopt`, and offer to run it first
-2. run `ai-factory gcf anchor <file>`: it prints each anchor with its line range; on a re-import read the printed delta and jump to step 17
+2. run `ai-factory gcf anchor <file>`: it prints each anchor and its lines; on a re-import read the delta and jump to step 17; on `resumed` skip a new section (added, or any on a first import) a unit already cites
 3. extract per aspect, one pass each, with a quote and an anchor per value: pillar candidates; subsystems (nouns); player verbs (mechanic); economy resources (resource)
 4. extract the hard aspects the same way: invariants (rule); platform and performance thresholds (constraint); data nouns (entity)
 5. type each unit: a mechanic or a resource is soft and waits for a verdict once in work; a rule, a constraint or an entity is hard and leaves through tests
@@ -57,7 +58,7 @@ workflow:
 17. on a re-import run `ai-factory gcf design check`: a unit whose quote is no longer verbatim gets `flags: src-changed`, a unit whose anchor the GDD removed gets `flags: orphan`; `gcf anchor` already rewrote renamed anchors
 18. on a re-import, raise a D1 for a work item or a collapsed system that cites a changed anchor, and run steps 3..16 over the text no quote covers any more
 19. mark a unit whose nouns match the `purpose` or the `code` paths of an existing systems doc with `flags: impl?`: the mechanic may already ship, and the human drops it with `ai-factory gcf drop`
-20. append the new ids to `gcf/backlog.md`, run `ai-factory gcf design check`, and fix every blocking finding before you report
+20. append the new ids to `gcf/backlog.md`, run `ai-factory gcf design check`, fix every blocking finding, then run `ai-factory gcf anchor <file> --done`: until then a rerun gets the same delta
 21. report the package, ordered: D1 questions (the main product), pillar candidates, glossary conflicts, the design summary per subsystem, D2 assumptions; say when `impl?` was blind
 22. state the next step: answer the D1s, confirm pillars and glossary, then take the first unit with `/gcf-card <id>`
 

package/skills/gcf-init/SKILL.md

@@ -24,8 +24,8 @@ workflow:
 2. run `ai-factory gcf init` and report which files it created, `gcf/design/` and the agent instructions in `AGENTS.md` among them; it writes no `PILLARS.md`
 3. when the human is about to import a GDD, leave `PILLARS.md` absent: the import proposes pillar candidates, and the interview runs after it
 4. otherwise ask the human for the game's core promise, then for 2..7 pillars: each needs an id (a lowercase hyphen slug the design units cite), a statement, a negative invariant and a review question
-5. write `gcf/PILLARS.md` with the confirmed pillars in the record-list form of `.ai-factory/extensions/gcf-aif-ext/templates/PILLARS.md`
-6. run `npx --yes cnlp-kit check` and fix form issues it reports
+5. write `gcf/PILLARS.md` with the confirmed pillars, word for word, in the record-list form of `.ai-factory/extensions/gcf-aif-ext/templates/PILLARS.md`: the human decides each pillar, you only write it down
+6. run `npx --yes cnlp-kit check` and fix form issues it reports; it checks only the systems docs and PILLARS of `cnlp.config.json`: units go through `ai-factory gcf design check`, the tree through `ai-factory gcf audit`
 7. ask the human to run `ai-factory gcf hooks-install`: the commit gate is theirs to arm
 8. state the next step: import a GDD with `/gcf-ingest`, or start the design with `/gcf-vision` when there is none
 9. to add one pillar later, ask only for its id, statement, invariant and review question; append it as one record to `gcf/PILLARS.md`, keep the others, keep the count <= 7, then run step 6

package/skills/gcf-triage/SKILL.md

@@ -27,7 +27,7 @@ workflow:
 4. for each entry propose one call with its fields: a bug gets type `bug`, severity and a repro; a tune names the item and the note; an idea names the subsystem; a duplicate names the item it repeats
 5. present the calls to the human, calls per message <= 5, and apply only the approved ones
 6. a bug or other work: run `ai-factory gcf item new <id> --type <type> [--severity <level>] --from <in-id>`, then write its `intent:` and `repro:`
-7. a tune of an item waiting for its verdict: keep the note for the verdict session and run `ai-factory gcf inbox drop <in-id>`; the note goes in through `/gcf-verdict … tune --note`
+7. a tune of an item waiting for its verdict or unplayed: leave the entry in the inbox, the note's only copy, until `/gcf-verdict <id> tune --note` records it and drops it; a tune of a kept mechanic is new work with `--reopens <id>`
 8. an idea for the design: write a unit with `TBD` slots in `gcf/design/<system>.md` and its backlog line, then run `ai-factory gcf inbox drop <in-id>`
 9. a duplicate or noise: run `ai-factory gcf inbox drop <in-id>`
 10. report what each entry became and how many entries remain

package/skills/gcf-verdict/SKILL.md

@@ -19,6 +19,7 @@ forbidden_behaviors:
 - do not decide the verdict or the decision: the human decides, this skill records
 - do not run `keep` when the human has not answered the item's miss_criterion question
 - do not edit systems docs, `LIVE.md`, history or graveyard by hand: the commands own them
+- a tune note triage left in the inbox for the item goes into `--note`; after the verdict run `ai-factory gcf inbox drop <in-id>`, not before
 
 workflow:
 1. with no arguments: run `ai-factory gcf playtest session` and stop - its build line and checklist of awaiting-verdict and unplayed items are the session's playtest sheet
@@ -30,7 +31,7 @@ workflow:
 7. for a decision run `ai-factory gcf decide <id> <choice> --reason "<why>"`; `known` parks a bug and lists it in `gcf/LIVE.md` known issues
 8. for a feature whose child died, the human picks: `close` without the child, `continue` with a replacement, or `kill` with its live children
 9. for `keep` on an item touching 2 or more subsystems: read each updated systems doc and report a contradiction between constraints as a D1 question instead of finishing silently
-10. report the commit hash, `git revert <hash>` is the undo, and the id of any removal item the command made
+10. report the commit hash, `git revert <hash>` undoes that one move - not the code, nor a later move or edit on the same files - and the id of any removal item the command made
 
 invocation:
 - run after a playtest session, on a human decision, or with no arguments to print the playtest sheet

package/skills/gcf-vision/SKILL.md

@@ -31,7 +31,7 @@ workflow:
 3. ask about scope: platform, session length, solo or multiplayer, art constraints, team size, and the milestones - what the first version must prove
 4. ask what the game is NOT: negative answers seed the pillars and the scope_out list, and cost the least
 5. write `gcf/game.md` from the answers, and read it back to the human for corrections
-6. name the subsystems and the units with the human: each player verb a mechanic, each currency a resource, each invariant a rule; write each unit with the blocks of `templates/design.md` for its type
+6. name the subsystems and the units with the human: each player verb a mechanic, each currency a resource, each invariant a rule; write each unit with the header of `templates/design.md` and the blocks `profiles/unit-<type>.md` lists for its type
 7. write `gcf/backlog.md` in the human's ranking, then run `ai-factory gcf design check` and fix every blocking finding
 8. state the next step: `/gcf-init` for the pillars interview, `/gcf-debate` to stress the design, then `/gcf-card <id>` for the first unit
 

package/templates/agents-block.md

@@ -8,9 +8,9 @@ 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 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
+- drive a ready item with the gcf-run skill when the project has gcf-harness-aif-ext and the agent is Claude Code (a batch at once: `ai-factory gcf-harness run <ids...>`), otherwise with aif-plan and aif-implement
 - a question about how the runs go (the share that reached their move, cost, plan checks, DoD attempts, guard firings) is answered by `ai-factory gcf-harness metrics`
-- 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
+- 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, at most `dod_attempts` of `gcf/config.yml` red runs; still red: block the item with the diagnosis
 - `submit` and `close` refuse code that changed since its last green `gcf verify`: run it again after any fix; `--unverified "<why>"` is the human's call, never the agent's
 - then end the work on the item with its command: `ai-factory gcf submit <id>` for gate verdict or decision, `ai-factory gcf close <id>` for gate auto
 - work that cannot go on: run `ai-factory gcf block <id> --reason "<why or the question>"`

package/templates/item.md

@@ -45,13 +45,13 @@ feel:
   envelope: 0.4..0.8 s
 
 contract:
-- new components and systems live under Assets/Scripts/Example/
-- data flows from input to simulation, never backwards
+- new components and systems live under Assets/Scripts/Example/, entry point ExampleFeature.cs
 
 interactions:
 - none: this example crosses no existing mechanic
 
 constraints:
+- data flows from input to simulation, never backwards
 - do not add a new input binding
 - no per-frame allocations