gcf-aif-ext 0.2.0

package/node_modules/yaml/dist/visit.js

@@ -0,0 +1,236 @@
+'use strict';
+
+var identity = require('./nodes/identity.js');
+
+const BREAK = Symbol('break visit');
+const SKIP = Symbol('skip children');
+const REMOVE = Symbol('remove node');
+/**
+ * Apply a visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this node, continue with next
+ *     sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current node, then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
+function visit(node, visitor) {
+    const visitor_ = initVisitor(visitor);
+    if (identity.isDocument(node)) {
+        const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));
+        if (cd === REMOVE)
+            node.contents = null;
+    }
+    else
+        visit_(null, node, visitor_, Object.freeze([]));
+}
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
+visit.BREAK = BREAK;
+/** Do not visit the children of the current node */
+visit.SKIP = SKIP;
+/** Remove the current node */
+visit.REMOVE = REMOVE;
+function visit_(key, node, visitor, path) {
+    const ctrl = callVisitor(key, node, visitor, path);
+    if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
+        replaceNode(key, path, ctrl);
+        return visit_(key, ctrl, visitor, path);
+    }
+    if (typeof ctrl !== 'symbol') {
+        if (identity.isCollection(node)) {
+            path = Object.freeze(path.concat(node));
+            for (let i = 0; i < node.items.length; ++i) {
+                const ci = visit_(i, node.items[i], visitor, path);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK)
+                    return BREAK;
+                else if (ci === REMOVE) {
+                    node.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        else if (identity.isPair(node)) {
+            path = Object.freeze(path.concat(node));
+            const ck = visit_('key', node.key, visitor, path);
+            if (ck === BREAK)
+                return BREAK;
+            else if (ck === REMOVE)
+                node.key = null;
+            const cv = visit_('value', node.value, visitor, path);
+            if (cv === BREAK)
+                return BREAK;
+            else if (cv === REMOVE)
+                node.value = null;
+        }
+    }
+    return ctrl;
+}
+/**
+ * Apply an async visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `Promise`: Must resolve to one of the following values
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this node, continue with next
+ *     sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current node, then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
+async function visitAsync(node, visitor) {
+    const visitor_ = initVisitor(visitor);
+    if (identity.isDocument(node)) {
+        const cd = await visitAsync_(null, node.contents, visitor_, Object.freeze([node]));
+        if (cd === REMOVE)
+            node.contents = null;
+    }
+    else
+        await visitAsync_(null, node, visitor_, Object.freeze([]));
+}
+// Without the `as symbol` casts, TS declares these in the `visit`
+// namespace using `var`, but then complains about that because
+// `unique symbol` must be `const`.
+/** Terminate visit traversal completely */
+visitAsync.BREAK = BREAK;
+/** Do not visit the children of the current node */
+visitAsync.SKIP = SKIP;
+/** Remove the current node */
+visitAsync.REMOVE = REMOVE;
+async function visitAsync_(key, node, visitor, path) {
+    const ctrl = await callVisitor(key, node, visitor, path);
+    if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
+        replaceNode(key, path, ctrl);
+        return visitAsync_(key, ctrl, visitor, path);
+    }
+    if (typeof ctrl !== 'symbol') {
+        if (identity.isCollection(node)) {
+            path = Object.freeze(path.concat(node));
+            for (let i = 0; i < node.items.length; ++i) {
+                const ci = await visitAsync_(i, node.items[i], visitor, path);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === BREAK)
+                    return BREAK;
+                else if (ci === REMOVE) {
+                    node.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        else if (identity.isPair(node)) {
+            path = Object.freeze(path.concat(node));
+            const ck = await visitAsync_('key', node.key, visitor, path);
+            if (ck === BREAK)
+                return BREAK;
+            else if (ck === REMOVE)
+                node.key = null;
+            const cv = await visitAsync_('value', node.value, visitor, path);
+            if (cv === BREAK)
+                return BREAK;
+            else if (cv === REMOVE)
+                node.value = null;
+        }
+    }
+    return ctrl;
+}
+function initVisitor(visitor) {
+    if (typeof visitor === 'object' &&
+        (visitor.Collection || visitor.Node || visitor.Value)) {
+        return Object.assign({
+            Alias: visitor.Node,
+            Map: visitor.Node,
+            Scalar: visitor.Node,
+            Seq: visitor.Node
+        }, visitor.Value && {
+            Map: visitor.Value,
+            Scalar: visitor.Value,
+            Seq: visitor.Value
+        }, visitor.Collection && {
+            Map: visitor.Collection,
+            Seq: visitor.Collection
+        }, visitor);
+    }
+    return visitor;
+}
+function callVisitor(key, node, visitor, path) {
+    if (typeof visitor === 'function')
+        return visitor(key, node, path);
+    if (identity.isMap(node))
+        return visitor.Map?.(key, node, path);
+    if (identity.isSeq(node))
+        return visitor.Seq?.(key, node, path);
+    if (identity.isPair(node))
+        return visitor.Pair?.(key, node, path);
+    if (identity.isScalar(node))
+        return visitor.Scalar?.(key, node, path);
+    if (identity.isAlias(node))
+        return visitor.Alias?.(key, node, path);
+    return undefined;
+}
+function replaceNode(key, path, node) {
+    const parent = path[path.length - 1];
+    if (identity.isCollection(parent)) {
+        parent.items[key] = node;
+    }
+    else if (identity.isPair(parent)) {
+        if (key === 'key')
+            parent.key = node;
+        else
+            parent.value = node;
+    }
+    else if (identity.isDocument(parent)) {
+        parent.contents = node;
+    }
+    else {
+        const pt = identity.isAlias(parent) ? 'alias' : 'scalar';
+        throw new Error(`Cannot replace node with ${pt} parent`);
+    }
+}
+
+exports.visit = visit;
+exports.visitAsync = visitAsync;

package/node_modules/yaml/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "yaml",
+  "version": "2.9.1",
+  "license": "ISC",
+  "author": "Eemeli Aro <eemeli@gmail.com>",
+  "funding": "https://github.com/sponsors/eemeli",
+  "repository": "github:eemeli/yaml",
+  "description": "JavaScript parser and stringifier for YAML",
+  "keywords": [
+    "YAML",
+    "parser",
+    "stringifier"
+  ],
+  "homepage": "https://eemeli.org/yaml/",
+  "files": [
+    "browser/",
+    "dist/",
+    "util.js"
+  ],
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "bin": "./bin.mjs",
+  "browser": {
+    "./dist/index.js": "./browser/index.js",
+    "./dist/util.js": "./browser/dist/util.js",
+    "./util.js": "./browser/dist/util.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "node": "./dist/index.js",
+      "default": "./browser/index.js"
+    },
+    "./package.json": "./package.json",
+    "./util": {
+      "types": "./dist/util.d.ts",
+      "node": "./dist/util.js",
+      "default": "./browser/dist/util.js"
+    }
+  },
+  "scripts": {
+    "build": "npm run build:node && npm run build:browser",
+    "build:browser": "rollup -c config/rollup.browser-config.mjs",
+    "build:node": "rollup -c config/rollup.node-config.mjs",
+    "clean": "git clean -fdxe node_modules",
+    "lint": "eslint config/ src/",
+    "prettier": "prettier --write .",
+    "prestart": "rollup --sourcemap -c config/rollup.node-config.mjs",
+    "start": "node --enable-source-maps -i -e 'YAML=require(\"./dist/index.js\");const{parse,parseDocument,parseAllDocuments}=YAML'",
+    "test": "jest --config config/jest.config.js",
+    "test:all": "npm test && npm run test:types && npm run test:dist && npm run test:dist:types",
+    "test:browsers": "cd playground && npm test",
+    "test:dist": "npm run build:node && jest --config config/jest.config.js",
+    "test:dist:types": "tsc --allowJs --moduleResolution node --noEmit --target es5 dist/index.js",
+    "test:types": "tsc --noEmit && tsc --noEmit -p tests/tsconfig.json",
+    "docs:install": "cd docs-slate && bundle install",
+    "predocs:deploy": "node docs/prepare-docs.mjs",
+    "docs:deploy": "cd docs-slate && ./deploy.sh",
+    "predocs": "node docs/prepare-docs.mjs",
+    "docs": "cd docs-slate && bundle exec middleman server",
+    "preversion": "npm test && npm run build",
+    "prepublishOnly": "npm run clean && npm test && npm run build"
+  },
+  "browserslist": "defaults, not ie 11",
+  "prettier": {
+    "arrowParens": "avoid",
+    "semi": false,
+    "singleQuote": true,
+    "trailingComma": "none"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.12.10",
+    "@babel/plugin-transform-typescript": "^7.12.17",
+    "@babel/preset-env": "^7.12.11",
+    "@eslint/js": "^9.9.1",
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-typescript": "^12.1.1",
+    "@types/jest": "^29.2.4",
+    "@types/node": "^20.11.20",
+    "babel-jest": "^29.0.1",
+    "eslint": "^9.9.1",
+    "eslint-config-prettier": "^10.1.8",
+    "fast-check": "^2.12.0",
+    "jest": "^29.0.1",
+    "jest-resolve": "^29.7.0",
+    "jest-ts-webcompat-resolver": "^1.0.0",
+    "prettier": "^3.0.2",
+    "rollup": "^4.12.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.4.0"
+  },
+  "engines": {
+    "node": ">= 14.6"
+  }
+}

package/node_modules/yaml/util.js

@@ -0,0 +1,2 @@
+// Re-exporter for Node.js < 12.16.0
+module.exports = require('./dist/util.js')

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "gcf-aif-ext",
+  "version": "0.2.0",
+  "description": "Game Context Framework for AI Factory",
+  "type": "module",
+  "license": "MIT",
+  "author": "Oleg (VirtualMaestro)",
+  "aiFactoryCompatibility": ">=2.0.0 <3.0.0",
+  "keywords": [
+    "ai-factory",
+    "gcf",
+    "gamedev",
+    "extension"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VirtualMaestro/GCF.git"
+  },
+  "homepage": "https://github.com/VirtualMaestro/GCF#readme",
+  "bugs": {
+    "url": "https://github.com/VirtualMaestro/GCF/issues"
+  },
+  "engines": {
+    "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)\""
+  },
+  "files": [
+    "extension.json",
+    "injections",
+    "lib",
+    "skills",
+    "commands",
+    "templates",
+    "schemas",
+    "profiles",
+    "hooks",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "cnlp-kit": "^3.1.3",
+    "yaml": "^2.5.1"
+  },
+  "bundleDependencies": [
+    "cnlp-kit",
+    "yaml"
+  ],
+  "devDependencies": {
+    "ajv": "^8.20.0"
+  }
+}

package/profiles/card.md

@@ -0,0 +1,65 @@
+---
+name: card
+description: The CNL-P profile of a GCF feature card — the six slots a card body carries, in order.
+---
+
+format: cnlp-format.md
+
+mood: declarative
+
+headings:
+- none: the body is flat and the document is named by its frontmatter or its fixed path
+
+frontmatter_fields:
+- schema
+- id
+- slug
+- status
+- route
+- system
+- depends
+- source
+- tune_count
+- built_at
+- created
+
+lexicon_exempt:
+- none: every field of a card body is read at planning time and must stay unambiguous
+
+sections:
+- key: behavior
+  form: bullet-list
+  required: yes
+  note: player input -> state change -> feedback, one observable statement per line
+
+- key: contract
+  form: bullet-list
+  required: yes
+  note: entities, components and data flows the feature adds; paths and entry points, never member lists or values
+
+- key: feel
+  form: bullet-list
+  required: yes
+  note: a comparison line (like X, not like Y) plus envelope lines; envelopes are the only legal numbers in gcf documents
+
+- key: interactions
+  form: bullet-list
+  required: yes
+  note: existing mechanics this feature crosses; a soft line may end with an "[until: ...]" annotation
+
+- key: constraints
+  form: bullet-list
+  required: yes
+  note: negative constraints, one prohibition per line, checkable by an analyzer or a reviewer
+
+- key: miss_criterion
+  form: scalar
+  required: yes
+  note: the one question the game in hand answers; the human answers it at the verdict
+
+custom_sections:
+- none: a card block that is not listed above is prose looking for a home
+
+enforcement:
+- `npx cnlp check`, over the files a `cnlp.config.json` corpus entry maps to this profile
+- frontmatter is validated separately by `schemas/card.schema.json` in the gcf pre-commit hook

package/profiles/pillars.md

@@ -0,0 +1,31 @@
+---
+name: pillars
+description: The CNL-P profile of gcf/PILLARS.md — the pillars and negative invariants read in every readset.
+---
+
+format: cnlp-format.md
+
+mood: declarative
+
+headings:
+- none: the body is flat and the document is named by its frontmatter or its fixed path
+
+frontmatter_fields:
+- none: the file is a singleton at a fixed path and carries no machine fields
+
+lexicon_exempt:
+- none: nothing is exempt in the most-read document of the project
+
+sections:
+- key: pillars
+  form: record-list
+  required: yes
+  record_keys: statement, invariant, review_question
+  note: pillar count <= 7 and the token budget are enforced by the gcf audit core, not the checker
+
+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
+- `ai-factory gcf audit` checks the count and token budget

package/profiles/system.md

@@ -0,0 +1,56 @@
+---
+name: system
+description: The CNL-P profile of a GCF subsystem state document — overwritten in place at every verdict.
+---
+
+format: cnlp-format.md
+
+mood: declarative
+
+headings:
+- none: the body is flat and the document is named by its frontmatter or its fixed path
+
+frontmatter_fields:
+- system
+- updated_by
+
+lexicon_exempt:
+- none: the whole document is a readset member on every task touching the subsystem
+
+sections:
+- key: purpose
+  form: bullet-list
+  required: yes
+  note: what this subsystem is and why it exists, 2..5 lines of intent
+
+- key: code
+  form: bullet-list
+  required: yes
+  note: paths and entry points only; member lists, signatures and balance values live in code
+
+- key: behavior
+  form: bullet-list
+  required: yes
+  note: validated observable behaviors, one line each, appended by collapse
+
+- key: feel
+  form: bullet-list
+  required: no
+  note: envelopes still in force, kept as constraints for future retunes
+
+- key: constraints
+  form: bullet-list
+  required: yes
+  note: negative constraints and invariants accumulated from cards and hard implementations
+
+- key: open
+  form: bullet-list
+  required: no
+  note: lines carrying a live "[until: ...]" annotation, moved here by collapse
+
+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
+- the gcf P2 linter adds its own forbidden-content patterns on top in the pre-commit hook

package/schemas/card.schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/VirtualMaestro/GCF/schemas/card.schema.json",
+  "title": "GCF card frontmatter",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema", "id", "slug", "status", "route", "system", "depends", "source", "tune_count", "created"],
+  "properties": {
+    "schema": { "const": 1 },
+    "id": { "type": "string", "pattern": "^card-\\d{3}$" },
+    "slug": { "type": "string", "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$" },
+    "status": { "enum": ["proposed", "built", "tuning"] },
+    "route": { "enum": ["soft", "hard"] },
+    "system": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "type": "string", "pattern": "^[a-z0-9]+(-[a-z0-9]+)*$" }
+    },
+    "depends": {
+      "type": "array",
+      "items": { "type": "string", "pattern": "^card-\\d{3}$" }
+    },
+    "source": { "type": "string", "pattern": "^(GDD#[A-Za-z0-9_-]+|manual|inferred)$" },
+    "tune_count": { "type": "integer", "minimum": 0 },
+    "built_at": {
+      "anyOf": [{ "type": "null" }, { "type": "string", "pattern": "^[0-9a-f]{7,40}$" }]
+    },
+    "created": { "type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}$" }
+  }
+}

package/skills/gcf-adopt/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: gcf-adopt
+description: Put a project that already has code on GCF rails - subsystem dictionary, entry points, pillars, no retro-documentation. Use when a working game adopts GCF or the user says "заехать на существующий проект".
+---
+
+mode: adoption
+
+purpose:
+- give an existing codebase the 3 things GCF runs on and code cannot hold: a subsystem name dictionary, entry-point paths, pillars
+- keep the empty blocks empty: behavior, feel and constraints arrive at the first verdict that touches the subsystem
+
+inputs:
+- none: the skill reads the working directory and asks the human for the names and the intent
+
+preconditions:
+- the project is a git repository with AI Factory initialized
+- the game already has code: a project with none starts at `/gcf-vision` instead
+
+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 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
+
+workflow:
+1. run `ai-factory gcf init` and report what it created; when `backlog.md` and `PILLARS.md` still hold the template examples, clear those example lines so INDEX does not count them
+2. scan the code tree by names only - directories, `*.asmdef`, feature classes, entry points - and propose a subsystem list with a path per entry
+3. ask the human to edit and confirm the names; a name they reject or doubt becomes a D1 record in `gcf/open-questions.md`, not a file
+4. write `gcf/systems/<name>.md` per confirmed subsystem from the package template, frontmatter `system: <name>` and `updated_by: adopt`
+5. fill `code:` with <= 2 bullets, the directory and the entry point: more bullets means 2 subsystems, and the П2 linter rejects 3 bullets naming CamelCase identifiers
+6. fill `purpose:` with one line of intent the human confirmed: the INDEX row of a subsystem is its first `purpose` bullet
+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 3..5, 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`
+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`, new work starts at `/gcf-card`
+
+invocation:
+- run once, when a project that already has code adopts GCF

package/skills/gcf-audit/SKILL.md

@@ -0,0 +1,27 @@
+---
+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".
+---
+
+mode: inspection
+
+purpose:
+- report what rotted: the deterministic core finds the mechanical violations, this skill adds the semantic pass
+
+inputs:
+- none: the audit reads the whole gcf/ tree
+
+forbidden_behaviors:
+- do not fix findings silently: report, and change files only on an explicit go-ahead
+- do not read `gcf/source/` during the semantic pass: audit covers the living layer only
+
+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
+4. 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
+5. list the pragmas: each `gcf:allow` is a standing exception, and a growing list is the linter rotting
+6. propose the next actions, ranked, proposed actions <= 3: playtest, answer a D1, or collapse a stale record
+
+invocation:
+- run at session start, after a long break, or on demand