gcf-aif-ext 0.3.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gcf-aif-ext",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Game Context Framework for AI Factory",
   "type": "module",
   "license": "MIT",
@@ -24,8 +24,9 @@
     "node": ">=22.14"
   },
   "scripts": {
-    "test": "node --test",
-    "prepack": "node -e \"const p=require('./package.json'),e=require('./extension.json');if(p.version!==e.version)throw new Error('version mismatch: package.json '+p.version+' vs extension.json '+e.version)\""
+    "test": "node --test && npm run test:gate",
+    "prepack": "node -e \"const p=require('./package.json'),e=require('./extension.json');if(p.version!==e.version)throw new Error('version mismatch: package.json '+p.version+' vs extension.json '+e.version)\"",
+    "test:gate": "node -e \"process.env.GCF_TEST_GATE='1';require('node:child_process').execFileSync(process.execPath,['--test'],{stdio:'inherit'})\""
   },
   "files": [
     "extension.json",

package/profiles/pillars.md

@@ -28,5 +28,5 @@ custom_sections:
 - none: a pillar that needs more than its three keys is not a pillar yet
 
 enforcement:
-- `npx cnlp check`, over the file a `cnlp.config.json` corpus entry maps to this profile
+- `npx --yes cnlp-kit check`, over the file a `cnlp.config.json` corpus entry maps to this profile
 - `ai-factory gcf audit` checks the count and token budget

package/profiles/system.md

@@ -52,5 +52,5 @@ custom_sections:
 - none: a fact that fits no block above belongs to code or to a card, not here
 
 enforcement:
-- `npx cnlp check`, over the files a `cnlp.config.json` corpus entry maps to this profile
+- `npx --yes cnlp-kit check`, over the files a `cnlp.config.json` corpus entry maps to this profile
 - the gcf P2 linter adds its own forbidden-content patterns on top in the pre-commit hook

package/profiles/unit-constraint.md

@@ -27,6 +27,16 @@ sections:
   required: yes
   note: how the threshold is measured and on what - device, build, scene
 
+- key: tuning
+  form: bullet-list
+  required: no
+  note: work stage only - one verdict remark per tune, read before the rebuild
+
+- key: notes
+  form: bullet-list
+  required: no
+  note: work stage only - the operator's answers and delivered files, one per unblock
+
 - key: provenance
   form: record-list
   required: no

package/profiles/unit-entity.md

@@ -23,6 +23,16 @@ sections:
   record_keys: name, holds
   note: one record per field - what it holds, never its allowed values, which belong to a rule
 
+- key: tuning
+  form: bullet-list
+  required: no
+  note: work stage only - one verdict remark per tune, read before the rebuild
+
+- key: notes
+  form: bullet-list
+  required: no
+  note: work stage only - the operator's answers and delivered files, one per unblock
+
 - key: provenance
   form: record-list
   required: no

package/profiles/unit-mechanic.md

@@ -89,7 +89,12 @@ sections:
 - key: tuning
   form: bullet-list
   required: no
-  note: card stage only - one verdict remark per tune, read before the rebuild
+  note: work stage only - one verdict remark per tune, read before the rebuild
+
+- key: notes
+  form: bullet-list
+  required: no
+  note: work stage only - the operator's answers and delivered files, one per unblock
 
 - key: provenance
   form: record-list

package/profiles/unit-resource.md

@@ -69,7 +69,12 @@ sections:
 - key: tuning
   form: bullet-list
   required: no
-  note: card stage only - one verdict remark per tune, read before the rebuild
+  note: work stage only - one verdict remark per tune, read before the rebuild
+
+- key: notes
+  form: bullet-list
+  required: no
+  note: work stage only - the operator's answers and delivered files, one per unblock
 
 - key: provenance
   form: record-list

package/profiles/unit-rule.md

@@ -27,6 +27,16 @@ sections:
   required: yes
   note: what accepts the rule without a human playing - a test, an analyzer, a device run
 
+- key: tuning
+  form: bullet-list
+  required: no
+  note: work stage only - one verdict remark per tune, read before the rebuild
+
+- key: notes
+  form: bullet-list
+  required: no
+  note: work stage only - the operator's answers and delivered files, one per unblock
+
 - key: provenance
   form: record-list
   required: no

package/schemas/item.schema.json

@@ -0,0 +1,105 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/VirtualMaestro/GCF/schemas/item.schema.json",
+  "title": "GCF work item frontmatter (schema 3)",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema", "id", "type", "gate", "status", "created"],
+  "definitions": {
+    "slug": { "type": "string", "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$" },
+    "slugOrNull": {
+      "anyOf": [{ "type": "null" }, { "type": "string", "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$" }]
+    },
+    "textOrNull": {
+      "anyOf": [{ "type": "null" }, { "type": "string", "pattern": "\\S" }]
+    },
+    "slugList": {
+      "type": "array",
+      "items": { "type": "string", "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$" }
+    },
+    "summary": { "type": "string", "pattern": "\\S", "maxLength": 250 }
+  },
+  "properties": {
+    "schema": { "const": 3 },
+    "id": { "$ref": "#/definitions/slug" },
+    "type": {
+      "enum": [
+        "feature",
+        "mechanic",
+        "resource",
+        "rule",
+        "constraint",
+        "entity",
+        "tech",
+        "bug",
+        "spike",
+        "asset",
+        "content",
+        "perf",
+        "release"
+      ]
+    },
+    "gate": { "enum": ["verdict", "auto", "decision"] },
+    "title": { "type": "string", "pattern": "\\S" },
+    "status": {
+      "enum": ["ready", "awaiting-verdict", "awaiting-decision", "blocked", "parked", "unplayed"]
+    },
+    "parent": { "$ref": "#/definitions/slugOrNull" },
+    "children": { "$ref": "#/definitions/slugList" },
+    "system": { "$ref": "#/definitions/slugList" },
+    "depends": { "$ref": "#/definitions/slugList" },
+    "pillars": { "$ref": "#/definitions/slugList" },
+    "source": { "type": "string", "pattern": "^(GDD#[A-Za-z0-9_-]+|manual)$" },
+    "reopens": { "$ref": "#/definitions/slugOrNull" },
+    "milestone": { "$ref": "#/definitions/slugOrNull" },
+    "parallel": { "enum": ["ok", "serial"] },
+    "plan": { "$ref": "#/definitions/textOrNull" },
+    "tune_count": { "type": "integer", "minimum": 0 },
+    "severity": {
+      "anyOf": [{ "type": "null" }, { "enum": ["critical", "high", "medium", "low"] }]
+    },
+    "blocked": { "$ref": "#/definitions/textOrNull" },
+    "since": {
+      "anyOf": [{ "type": "null" }, { "type": "string", "pattern": "^[0-9a-f]{7,64}$" }]
+    },
+    "frozen": { "type": "string", "pattern": "^[0-9a-f]{40}$" },
+    "live": {
+      "anyOf": [
+        { "type": "null" },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["none"],
+          "properties": { "none": { "type": "string", "pattern": "\\S" } }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["changes"],
+          "properties": {
+            "changes": {
+              "type": "array",
+              "minItems": 1,
+              "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": ["id", "change"],
+                "properties": {
+                  "id": { "$ref": "#/definitions/slug" },
+                  "change": { "enum": ["added", "modified", "removed"] },
+                  "summary": { "$ref": "#/definitions/summary" },
+                  "refs": { "type": "string", "pattern": "\\S" }
+                },
+                "if": { "properties": { "change": { "enum": ["added", "modified"] } } },
+                "then": { "required": ["summary"] }
+              }
+            }
+          }
+        }
+      ]
+    },
+    "model": { "$ref": "#/definitions/textOrNull" },
+    "effort": { "$ref": "#/definitions/textOrNull" },
+    "created": { "type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}$" }
+  }
+}

package/skills/gcf-adopt/SKILL.md

@@ -18,7 +18,7 @@ preconditions:
 
 forbidden_behaviors:
 - do not write `behavior`, `feel` or `constraints` out of reading code: a line derivable from code stays in code (П2)
-- do not open cards or backlog lines for what is already implemented: adoption puts nobody into work
+- do not open work items or backlog lines for what is already implemented: adoption puts nobody into work
 - do not schedule a retro playtest for a mechanic that already ships
 - do not write a pillar or a subsystem name the human did not confirm: both are human authorship
 - do not read code files whole: names, paths and entry points are the whole input
@@ -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 cnlp check`, then `ai-factory gcf lint` over each new systems doc, then `ai-factory gcf index`
+10. run `npx --yes cnlp-kit check`, 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-audit/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gcf-audit
-description: Run the GCF consistency audit - stale until records, idle built cards, tune limits, P2 linter findings, plus a semantic contradiction pass. Use at session start or when the user says "аудит gcf".
+description: Run the GCF consistency audit - stale until records, items waiting on the human too long, tune limits, unplayed items, P2 linter findings, plus a semantic contradiction pass. Use at session start or when the user says "аудит gcf".
 ---
 
 mode: inspection
@@ -17,8 +17,8 @@ forbidden_behaviors:
 
 workflow:
 1. run `ai-factory gcf audit --json` and read the report
-2. state the first line verbatim: stale built cards 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
+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

package/skills/gcf-card/SKILL.md

@@ -1,19 +1,19 @@
 ---
 name: gcf-card
-description: Take a design unit into work - close its TBD with the human, then move a soft unit into its card or hand a hard unit to the AIF cycle. Also parks a fresh idea as a unit. Use when work starts on a feature or the user says "заведи карточку" / "берём в работу".
+description: Put work into gcf/work/ - take a design unit with every TBD answered, group units under a feature, or create a tech, bug, spike, asset, content, perf or release item. Also parks a fresh idea as a unit. Use when work starts or the user says "заведи карточку" / "берём в работу" / "заведи задачу".
 ---
 
 mode: authoring
 
 purpose:
-- take one unit of `gcf/design/` into work with every slot answered
-- a soft unit (mechanic, resource) becomes `gcf/cards/<id>.md` with the same body; a hard unit (rule, constraint, entity) stays in place and goes to the AIF cycle
+- every piece of work in the project is one work item `gcf/work/<id>.md` with a type and a gate: who closes it - the human after play (`verdict`), a check (`auto`), the human without a build (`decision`)
+- a design unit enters work with every slot answered and its section moved, not copied
 
 inputs:
-- an id from `gcf/backlog.md`, or a free-text idea
+- an id from `gcf/backlog.md`, several ids to group under a feature, a free-text idea, or a request for non-design work
 
 preconditions:
-- `gcf/` exists; `gcf/INDEX.md` lists the current subsystems
+- `gcf/` exists; `gcf/INDEX.md` lists the current subsystems and items
 
 forbidden_behaviors:
 - do not invent a new subsystem name when INDEX carries a synonym: reuse or ask
@@ -21,25 +21,32 @@ forbidden_behaviors:
 - do not take a unit an open D1 blocks: `ai-factory gcf design check` names the blocking question, and the human answers it first
 - do not write a digit in prose: a number is an envelope `a..b <unit>` in `feel` or a closing comparison
 - do not put `until:` in the frontmatter: it is a line annotation inside slots
-- do not move a section or edit the backlog by hand: `ai-factory gcf take`, `done` and `drop` own those moves
+- 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>`
 
 outputs:
 - each answered slot gets a provenance record `- slot: <block>` with `answer: manual`, or `answer: q-NNN` when it closes a question
-- a card body carries every block of its type plus `contract:` (paths and entry points) and `interactions:` (`<other id>: how the two cross`, or `- none: <why>`)
+- a design-unit item body carries every block of its type plus `contract:` (paths and entry points) and `interactions:` (`<other id>: how the two cross`, or `- none: <why>`)
+- every item carries a `live:` delta before it ends: what it adds, modifies or removes in `gcf/LIVE.md`, or `none: <why>`
 
 workflow:
-1. for a free-text 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. 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
-3. 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
-4. 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
-5. confirm the route: ask "can an autotest accept this without a human playing?"; yes = hard, no or mixed = soft; a mixed unit splits into a soft mechanic and a hard rule before work
-6. ask the human one question per `TBD` slot, each with your proposed answer, questions per message <= 2
-7. write each answer into the unit in place, with its `answer:` provenance record
-8. run `ai-factory gcf design check` until the unit reads `ready` and the check has no blocking finding for it, then commit the answered unit: a hard unit leaves `gcf/design/` at `done`, and its answers live in git only from this commit
-9. for a soft unit: run `ai-factory gcf take <id>` - it writes `gcf/cards/<id>.md` and removes the section and the backlog line in one step
-10. in the card, write `contract:` from the code tree and `interactions:` from the units and cards that write the same state, then run `ai-factory gcf design check` again
-11. for a hard unit: send it to the AIF cycle (`/aif-plan` with the unit id); after the tests are green, run `ai-factory gcf done <id>`, adding `--constraint "<line>"` for a prohibition every future reader of the subsystem must remember
-12. report the card path and the one question the playtest will answer, or the hard unit's plan
+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 - 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
+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
+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
+8. confirm the route: ask "can an autotest accept this without a human playing?"; yes = hard, no or mixed = soft; a mixed unit splits into a soft mechanic and a hard rule before work
+9. ask the human one question per `TBD` slot, each with your proposed answer, questions per message <= 2
+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. run `ai-factory gcf design check --json` until the unit's entry in `units` reads `ready: true`, then commit the answered unit
+14. 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
+15. in each design-unit 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
+16. write the item's `live:` delta (a feature's children keep `none: parent`; the feature writes the capability), run `ai-factory gcf design check`, and commit
+17. report the item paths, each item's gate, and for a verdict item the one question the playtest will answer
 
 invocation:
-- run when work starts on a unit, or when a fresh idea needs a home
+- run when work starts on a unit or a group of units, when non-design work needs an item, or when a fresh idea needs a home

package/skills/gcf-ingest/SKILL.md

@@ -17,7 +17,7 @@ preconditions:
 - the sequential pass below is the correctness reference; the parallel fan-out belongs to the harness
 
 forbidden_behaviors:
-- do not create card files: a unit stays in `gcf/design/` until `/gcf-card` takes it into work
+- do not create work items: a unit stays in `gcf/design/` until `/gcf-card` takes it into work
 - do not write a pillar into PILLARS.md: pillar candidates go to open-questions as D1
 - do not fill a slot from your own reasoning: a value without a verbatim quote is `TBD`, and your draft answer goes into the `proposed:` field of a question
 - do not read `gcf/source/` files whole after anchoring: read a section with `ai-factory gcf section <file> <anchor>`
@@ -42,7 +42,7 @@ workflow:
 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
 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 becomes a card later; a rule, a constraint or an entity is hard and leaves through tests
+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
 6. split a candidate that mixes a tunable feel with a testable rule into 2 units: a soft mechanic and a hard rule
 7. treat the GDD's own open-questions section, and any TBD or TODO, as D1 records with lens `gdd-open` and the anchor in `sections:`, and name the units each one gates in `blocks:`
 8. copy each quote verbatim from the section `ai-factory gcf section` prints; a unit with no quote at all becomes a D1 record with lens `provenance`, not a unit
@@ -55,7 +55,7 @@ workflow:
 15. record `depends:` between units from the interaction matrix: units that write the same state
 16. propose the glossary from the dictionary lens: one term per concept and its forbidden synonyms; keep the GDD's own words in unit text until the human confirms a term
 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 card or a collapsed system that cites a changed anchor, and run steps 3..16 over the text no quote covers any more
+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
 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

package/skills/gcf-init/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gcf-init
-description: Bootstrap the gcf/ documentary layer - skeleton, pillars interview, hooks reminder. Use when a game project adopts GCF or when the user says "set up gcf".
+description: Bootstrap the gcf/ documentary layer - skeleton, pillars interview, hooks reminder - and revise pillars later. Use when a game project adopts GCF, when the user says "set up gcf", or "поменяем столпы" / "revise pillars".
 ---
 
 mode: bootstrap
@@ -20,14 +20,17 @@ forbidden_behaviors:
 - pillar count <= 7, and do not pad the list to reach 7
 
 workflow:
-1. when `.ai-factory/DESCRIPTION.md` is absent, tell the human to run `/aif` first: `aif-plan` reads it, and a card cannot reach a plan without it
-2. run `ai-factory gcf init` and report which files it created, `gcf/design/` among them; it writes no `PILLARS.md`, so no example ever reads as the game's truth
+1. when `.ai-factory/DESCRIPTION.md` is absent, tell the human to run `/aif` first: `aif-plan` reads it, and a work item cannot reach a plan without it
+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 cnlp check` and fix form issues it reports
+6. run `npx --yes cnlp-kit check` and fix form issues it reports
 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
+10. to rename a pillar, run `ai-factory gcf pillar rename <from> <to>`: every unit and item citing it follows
+11. to drop a pillar, run `ai-factory gcf pillar retire <id> --reason "<why>"`; a unit it leaves at `pillars: TBD` goes back through the pillars steps of the gcf-card skill
 
 invocation:
-- run when the user asks to set up gcf in a project
+- run when the user asks to set up gcf in a project, or to revise its pillars

package/skills/gcf-triage/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: gcf-triage
+description: Triage gcf/inbox.md - playtest notes, CI failures, the agent's ideas and requests - into work items, tunes, ideas for the design, or noise, with the human approving each call. Use after a playtest session or when the user says "разбери инбокс".
+---
+
+mode: human gate
+
+purpose:
+- turn raw input into decided work: each inbox entry becomes a work item, a tune note, a design unit, a graveyard line, or nothing - and leaves the inbox
+
+inputs:
+- `gcf/inbox.md`, read through `ai-factory gcf inbox --json`
+
+preconditions:
+- `gcf/` exists and the inbox holds entries
+
+forbidden_behaviors:
+- do not create an item or erase an entry without the human's yes: the agent proposes, the human approves
+- do not turn a feel complaint into a bug: "jump feels floaty" is a tune of the item that owns the jump, a bug is behaviour that breaks a rule or a test
+- do not open a second item for something `gcf/graveyard.md` already buried: name the line and ask whether the reason still holds
+- do not edit `gcf/inbox.md` by hand: `ai-factory gcf item new --from` and `ai-factory gcf inbox drop` own its lines
+
+workflow:
+1. run `ai-factory gcf inbox --json`; read `gcf/LIVE.md` and `gcf/INDEX.md` to know what exists and what is in work
+2. classify each entry: bug, tune of a live or unplayed item, idea for the design, request (an asset file, a question), duplicate, or noise; search `gcf/graveyard.md` for each idea and bug
+3. 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
+4. present the calls to the human, calls per message <= 5, and apply only the approved ones
+5. 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:`
+6. 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. 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>`
+8. a duplicate or noise: run `ai-factory gcf inbox drop <in-id>`
+9. report what each entry became and how many entries remain
+
+invocation:
+- run after a playtest session, after a CI run that added entries, or when the user asks to triage

package/skills/gcf-verdict/SKILL.md

@@ -1,33 +1,36 @@
 ---
 name: gcf-verdict
-description: Record the human playtest verdict on a built card - keep, tune or kill - and run the collapse. Use after a playtest or when the user says "вердикт".
+description: Record the human's verdict on an item waiting for play or unplayed - keep, tune or kill - or the human's decision on a decision item, a bug or a feature. Use after a playtest session or when the user says "вердикт" / "решение".
 ---
 
 mode: human gate
 
 purpose:
-- record the human verdict and run the one operation that collapses a card into subsystem state
+- record what the human decided and run the one command that ends or returns the item
 
 inputs:
-- a card id and a verdict word: keep, tune or kill; or nothing, which means "print the playtest list"
+- an item id and a verdict word (keep, tune, kill) or a decision word (go, no, wontfix, known, close, continue, kill); or nothing, which means "print the playtest list"
 
 preconditions:
-- the card sits in status `built`; the human has played the build
+- a verdict: the item is `awaiting-verdict` or `unplayed`, and the human has played the build
+- a decision: the item is `awaiting-decision`, or a bug in `ready`, `blocked` or `parked`, or a feature paused after a child died
 
 forbidden_behaviors:
-- do not decide the verdict: the human with hands on the controls decides, this skill records
-- do not run `keep` when the human has not answered the card's miss_criterion question
-- do not edit systems docs by hand: `ai-factory gcf verdict` owns the collapse
+- 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
 
 workflow:
-1. with no arguments: run `ai-factory gcf playtest` and stop - that list is the session's playtest sheet
-2. read the card; ask the human the miss_criterion question and record the answer in one line
-3. for `tune` at tune_count 3: refuse and present the fork - kill, or redesign the envelope and reset the counter with a note
-4. for `keep`: compress the card first - the collapse copies lines verbatim, 1 line per behavior record, refusal and boundary; strip `contract:` down to paths and entry points
-5. for `keep`: cut `intent:` to the line the subsystem's purpose still lacks, or to `- none: <why>`
-6. run `ai-factory gcf verdict <id> <verdict> --note "<answer or reason>"`; a tune note lands in the card's `tuning:` block, where the rebuild reads it
-7. for `keep` on a card touching 2 or more subsystems: read each updated systems doc and report a contradiction between constraints as a D1 question instead of finishing silently
-8. report the verdict commit hash: `git revert <hash>` is the undo
+1. with no arguments: run `ai-factory gcf playtest` and stop - that list, awaiting-verdict and unplayed items, is the session's playtest sheet
+2. read the item; for a verdict ask the human the miss_criterion question and record the answer in one line
+3. for `tune` at the tune limit (`tune_limit` in `gcf/config.yml`, 3 by default): the command refuses; the way out is a kill, and a redesigned envelope becomes a new item with `reopens: <id>`
+4. for `keep` of a design-unit item still awaiting its verdict: compress it first - the collapse copies lines verbatim, 1 line per behavior record, refusal and boundary
+5. for that keep: strip `contract:` down to paths and entry points and cut `intent:` to the line the subsystem's purpose still lacks; leave an unplayed item as it is - its close froze the body
+6. run `ai-factory gcf verdict <id> <verdict> --note "<answer or reason>"`; a kill creates the removal item for code already in main unless the human says `--no-remove`
+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
 
 invocation:
-- run after a playtest, or with no arguments to print the playtest sheet
+- run after a playtest session, on a human decision, or with no arguments to print the playtest sheet

package/templates/agents-block.md

@@ -0,0 +1,28 @@
+## Game Context Framework (from gcf-aif-ext)
+
+gcf_context:
+- the game's design and its work live in `gcf/`, and the `ai-factory gcf` commands and the gcf skills change them
+- read `gcf/INDEX.md` before anything else under `gcf/`: it lists every subsystem, design unit and work item
+- `gcf/LIVE.md` says what the game does now, and `gcf/PILLARS.md` says what it must stay
+
+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
+- 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, otherwise with aif-plan and aif-implement
+- end the work on an item with its command: `ai-factory gcf submit <id>` for gate verdict or decision, `ai-factory gcf close <id>` for gate auto with every check green
+- work that cannot go on: run `ai-factory gcf block <id> --reason "<why or the question>"`
+- a design question only the human can answer becomes a D1 record in `gcf/open-questions.md`
+
+gcf_forbidden:
+- do not edit `status:`, `frozen:`, `gcf/LIVE.md`, `gcf/history.md`, `gcf/graveyard.md` or `gcf/INDEX.md` by hand: the commands own them
+- do not give a verdict or a decision: `verdict` and `decide` belong to the human, through the gcf-verdict skill
+- do not answer a `TBD` of a design unit yourself: ask the human and offer your draft as the proposed answer
+- 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
+
+gcf_skills:
+- gcf-vision starts a game that has no design yet, and gcf-ingest imports a GDD into `gcf/design/`
+- gcf-card puts work into `gcf/work/`, and gcf-triage sorts `gcf/inbox.md`
+- gcf-verdict records the human's verdict or decision, and gcf-audit reports the health of `gcf/`
+- gcf-debate stresses the design, gcf-adopt puts existing code on GCF, and gcf-init sets up `gcf/` and revises the pillars

package/templates/config.yml

@@ -6,3 +6,10 @@ wip_built_limit: 5
 context_budget: 30000
 pillars_budget: 1500
 envelope_default_spread: 0.3
+unplayed_warn_after: 5
+plan_passes: 5
+dod_attempts: 2
+# The project's own commands for the auto DoD (Methodology §6); the engine does not matter.
+dod:
+  test:
+  build:

package/templates/{card.md → item.md}

@@ -1,14 +1,21 @@
 ---
-schema: 2
+schema: 3
 id: example
 type: mechanic
-status: proposed
+gate: verdict
+status: ready
 system: [example-system]
 depends: []
 pillars: []
 source: manual
 tune_count: 0
-built_at: null
+since: null
+live:
+  changes:
+    - id: example
+      change: added
+      summary: A short dash forward between fights.
+      refs: gcf/systems/example-system.md
 created: "2026-01-01"
 ---