gcf-aif-ext 0.34.0 → 0.36.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -50,6 +50,26 @@ Updating preserves `gcf/`, `cnlp.config.json` and the pre-commit hook. Run `ai-f
50
50
 
51
51
  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.
52
52
 
53
+ ### 0.36.0
54
+
55
+ Update together with gcf-harness-aif-ext 0.35.0 and gcf-board 0.36.0 ([Plan-Review-Rework-Plan](https://github.com/VirtualMaestro/GCF/blob/main/docs/Plan-Review-Rework-Plan.md), Board-PRD decision 67). Then run `ai-factory gcf init`: the `AGENTS.md` block changed.
56
+
57
+ - **A plan review finds, the plan's author judges.** The reviewer only finds; the session that wrote the plan checks each finding against the code, gives it a verdict (`accepted`, `rejected`, `downgraded`) and fixes the plan. `gcf plan pass <id> --findings <file.json> --by …` writes the findings with their verdicts to the plan's `## Findings` (`- [c<C>.]p<K>.<N> <blocking|polish> <verdict> <d#/t#>: <summary>[; <reason>]`) and counts the pass line itself; `--blocking N --polish M` stays for an older harness and is refused in a cycle that already has findings. A blocking finding with no `scenario` is recorded as polish. The review converges when the last pass has no blocking finding with any verdict, so a rejected or downgraded one is followed by a check.
58
+ - **Full review, then checks.** `gcf review row <id> --kind plan --pass <k> [--diff] --json` keeps the plan as that reviewer saw it in `.gcf-session/plans/<id>.md` and answers `mode` (`full`, or `check` of the fixes) and `cycle`, with `--diff` the `diff.file` of the plan's changes since the earlier pass; it asks only the next pass and refuses a stalled plan. `gcf plan check --json` carries `findings`, and prints a `format:` line for a plan over about 150 lines or 20 tasks.
59
+ - **A model and effort per run phase.** `plan_model`, `plan_effort`, `implement_model`, `implement_effort` on a card (`gcf item agent <id> --phase plan|implement --model <m> --effort <e>`) and `agent.plan.model|effort`, `agent.implement.model|effort` in `gcf/config.yml` (`gcf config set agent.plan.effort high`, keys of three levels); `gcf board --json` carries them and `agent.phase_defaults` (GCF's own: `plan.effort: high`).
60
+ - **Review defaults:** `review.plan` is `codex:astra:high`, `claude:fable:medium`, `claude:fable:medium`; lists already in `gcf/config.yml` stay as they are.
61
+
62
+ ### 0.35.0
63
+
64
+ Update together with gcf-board 0.35.0 (`gcf board --json` is `schema: 7`; each refuses the other's old schema) and gcf-harness-aif-ext 0.34.0 ([Lessons-Review-Plan](https://github.com/VirtualMaestro/GCF/blob/main/docs/Lessons-Review-Plan.md), Board-PRD decision 66). Then run `ai-factory gcf init`: the `AGENTS.md` block changed (groups of entries, the project's rules, lesson reports, the base-improving tech note).
65
+
66
+ - **A group of inbox entries of one cause is one move and one commit.** `item new --from in-a,in-b` and `item amend --from in-a,in-b` put a bullet of each, its id first, in the note (`item new` takes the first entry's title unless `--title`; past 4000 characters it refuses: shorten or split the group, unless `--note`/`--note-file` gives the note, which then takes the bullets' place; their pictures are named after their entry's id); `inbox drop in-a in-b` and `inbox later in-a in-b` check every entry before they write any, and one refused leaves all as they are. `inbox drop --reason done|duplicate|noise|reported|amended [--of <id|hash>]` puts the reason in the commit's subject and a `GCF-Reason:` trailer; an erase of entries never committed still commits, so its trailers stand. `--proposal <thread>/<id>` on `item new`, `item amend`, `inbox drop`, `inbox later`, `rules add` and `lessons report` names the board's proposal in a `GCF-Proposal:` trailer; the domain flags those moves `proposal_trailer`, and a board recovers a proposal made only by that commit.
67
+ - **The project's own rules.** `gcf rules [--json]` reads `AGENTS.md` and `CLAUDE.md` (`{files: [{file, text, base, bytes, block, imports_agents, dirty}], own_rules}`, `own_rules` the lines under `## Project rules` of `AGENTS.md`). `rules add --text <line> [--from <in-ids>] [--base <hash>] (--dry-run [--json] | --commit)` puts one line, up to 300 characters, under `## Project rules`, outside GCF's block, of `AGENTS.md` and of a `CLAUDE.md` that does not import it; refused: a repeat, several lines, a marker, a leading `@` or `#`, an `@path` anywhere, a code fence; `--base` refuses files changed since the dry run that gave it; `gcf init` keeps the line. `rules save --file AGENTS.md|CLAUDE.md --base <hash> --text-file - (--dry-run | --commit)` saves a whole file in its own line endings, refused for a stale base, a changed GCF block or a marker pair too many or too few. A file with edits not committed (a `gcf init` refresh) goes into the commit whole; `--dry-run` shows its diff from HEAD.
68
+ - **Lesson reports.** `lessons report --from <in-ids> --to framework|template (--dry-run [--json] | --commit)` writes a file a lesson to `<GCF_BOARD_HOME or ~/.gcf>/lessons/<to>/<project>-<in-id>.md` (the project, the card, the kind, when it was recorded, the lesson's text with its `where` as the last line, the core, harness and board versions — the board's from `GCF_BOARD_VERSION` — and the date; a file already there, of a lesson still in the inbox, is a leftover of an attempt stopped before its commit and is written over) and erases the entries (`reported`) in one commit; an entry not of the category `lesson` is refused.
69
+ - `rules add`, `rules save` and `lessons report` are the human's moves: a run and a thread are refused, the deny group `human-moves` holds them; a chat agent proposes `rules add` and `lessons report` (`propose_rules_add`, `propose_lessons_report`).
70
+ - **The instructions mark.** `rules diff --from <hash> --to <hash> [--names] [--json]` (hex only) gives what the commits `from..to` changed in `AGENTS.md`, `CLAUDE.md`, `.claude/` and `.ai-factory/` without its plans and archive (`INSTRUCTION_PATHS`): no merges, first parent, no move of the operator's. `gcf changes --json` marks such a file `instructions: true`.
71
+ - The domain: the thread start `lessons-review` (skill gcf-triage; its agent may not edit or name in a shell command the instruction files, YOLO or not; `entries: lesson`, `next`), the moves `rules-add`, `lessons-report`, `rules-save`, `inbox-drop` and `inbox-later` on `{ids}` with the erase's `reason` and `of`, `from` as an `ids` field (`inbox: true`), and `sections.lessons {review, rule, report}`. gcf-triage teaches the review by groups; gcf-chat the new proposals.
72
+
53
73
  ### 0.34.0
54
74
 
55
75
  Update together with gcf-board 0.34.0 and gcf-harness-aif-ext 0.33.0 ([Until-Records-Plan](https://github.com/VirtualMaestro/GCF/blob/main/docs/Until-Records-Plan.md)). Then run `ai-factory gcf init`: the `AGENTS.md` block changed (a session starts with `ai-factory gcf audit` and states its first line; a fired D2 goes to the human, who answers on the record itself). If the audit then reports inbox entries from before the categories, run `ai-factory gcf inbox migrate` once.
@@ -94,7 +114,7 @@ Update together with gcf-board 0.32.0 (`gcf board --json` is `schema: 6`; each r
94
114
 
95
115
  ### 0.23.0
96
116
 
97
- - `gcf item amend <id>` fixes a live card's text from every stored status but `unplayed`, the status unchanged: `--text` (`--text-file`) replaces the blocks it names, a key alone takes one out; `--add` adds to `notes:`; `--title`; `--from <in-id>` takes an inbox entry in the same commit, its pictures one by one. `provenance:` and `tuning:` cannot be named; a unit's block must be in its profile. `--dry-run --json` writes nothing and gives `{base, title, text, changes}`; `--base <hash>` refuses a card changed since (`gcf-refusal: {"code":"stale"}`). The operator's: a run and a thread are refused, the deny group `human-moves` holds it, and a chat agent proposes it (`propose_amend`). Refused during this card's run or session (`{"code":"running"}`). Findings on the new text come from the pre-commit gate, with its rollback. The domain's `preview` and `hint` tell a board.
117
+ - `gcf item amend <id>` fixes a live card's text from every stored status but `unplayed`, the status unchanged: `--text` (`--text-file`) replaces the blocks it names, a key alone takes one out; `--add` adds to `notes:`; `--title`; `--from <in-ids>` takes inbox entries, comma-separated, in the same commit, its pictures one by one. `provenance:` and `tuning:` cannot be named; a unit's block must be in its profile. `--dry-run --json` writes nothing and gives `{base, title, text, changes}`; `--base <hash>` refuses a card changed since (`gcf-refusal: {"code":"stale"}`). The operator's: a run and a thread are refused, the deny group `human-moves` holds it, and a chat agent proposes it (`propose_amend`). Refused during this card's run or session (`{"code":"running"}`). Findings on the new text come from the pre-commit gate, with its rollback. The domain's `preview` and `hint` tell a board.
98
118
  - A resumed worktree takes main's card over what a stopped run wrote into its copy, saved or not; other files' conflicts read as before. A `work/<id>` branch whose folder was deleted syncs with main too.
99
119
  - `item new --from <in> --note <text>`: the note goes over the entry's text, not beside it, so a board's form does not double it. The entry's links follow its pictures.
100
120
  - The domain's `inbox-add` has the `item` field: an agent's proposal may name its card.
@@ -200,7 +220,7 @@ Autonomy (docs/Autonomy-Plan.md): the agent works by itself, the operator plays
200
220
 
201
221
  Update together with gcf-board 0.15.0 (`gcf board --json` is `schema: 4`; each refuses the other's old schema) and the gcf-harness-aif-ext released with it. Then run `ai-factory gcf init` (the AGENTS.md block learns the categories and `item new --title`) and, once, `ai-factory gcf inbox migrate`.
202
222
 
203
- - **The inbox by categories** (Board-PRD decision 32). An entry's frontmatter is `category`, `detail`, `origin`, `later`, `item`, `at`; `source` and `tags` are gone. The category is one of a fixed vocabulary, the core's base and the domain's layer merged (`ai-factory gcf inbox categories [--json]` prints it with who may file each); the project's layer is reserved. `inbox add [--category <c>] [--detail <word>] [--origin you|agent|automation] [--item <id>]`: the operator's entry with no category is a `note`, an agent must name one; the origin defaults to who makes the move (an agent's run or session is `agent` and may claim no other). `inbox category <in-id> [--category] [--detail]` replaces `inbox tag`: the operator moves an entry to any category but `decision`, `assumption` and `unsorted`, an agent only to one it may file; the origin never changes. `inbox later <in-id> [--off]` puts an entry away to Later and back; `decision`, `failure` and `assumption` never go there. The domain's moves are `inbox-add`, `inbox-category`, `inbox-later`, `inbox-back`, `inbox-drop`; an agent may propose the first three and `inbox-drop`.
223
+ - **The inbox by categories** (Board-PRD decision 32). An entry's frontmatter is `category`, `detail`, `origin`, `later`, `item`, `at`; `source` and `tags` are gone. The category is one of a fixed vocabulary, the core's base and the domain's layer merged (`ai-factory gcf inbox categories [--json]` prints it with who may file each); the project's layer is reserved. `inbox add [--category <c>] [--detail <word>] [--origin you|agent|automation] [--item <id>]`: the operator's entry with no category is a `note`, an agent must name one; the origin defaults to who makes the move (an agent's run or session is `agent` and may claim no other). `inbox category <in-id> [--category] [--detail]` replaces `inbox tag`: the operator moves an entry to any category but `decision`, `assumption` and `unsorted`, an agent only to one it may file; the origin never changes. `inbox later <in-ids...> [--off]` puts entries away to Later and back, one commit; `decision`, `failure` and `assumption` never go there. The domain's moves are `inbox-add`, `inbox-category`, `inbox-later`, `inbox-back`, `inbox-drop`; an agent may propose the first three and `inbox-drop`.
204
224
  - `inbox migrate [--json]` writes the entries from before the categories in the new format, in one commit `gcf(inbox): N entries to categories`, and lists what did not fit: `playtest` stays, `ci` → `failure`, `agent` → `unsorted`, `operator` → `note`, a lesson → `lesson` with its kind as the detail and its `item`, the tag `later` → the flag, the first other tag → the detail, the rest dropped. A second run changes nothing. Until it runs, the core reads an old entry the way the migration would write it, and the audit names it (`inbox.unmigrated`), as it names an unknown category and every `unsorted` entry.
205
225
  - Lessons are entries of the category `lesson`, their kind the detail. `gcf board --json`: `inbox[]` is `{id, category, detail, origin, later, item, at, title, text, attachments?}`; `inbox_repeats` lists each lesson kind met in 3 items or more, Later left out; each question carries `category` (`decision` for D1, `assumption` for D2); `domain.sections.inbox` carries `groups` and `categories`; an item's `lessons` counts only the category `lesson`.
206
226
  - **Ids from titles** (Board-PRD decision 34). `item new [id] --title <text>`: without an id the core makes it from the title (Cyrillic transliterated, about four words and 32 characters, `-2`, `-3`… when the id was ever used, `<type>-<n>` when nothing is left) and prints `<id> gcf/work/<id>.md` first; `--from` gives the title too. `item new` always holds the main lock. `--dry-run` prints the id and writes nothing. `--parent` takes one live feature. `design save --kind unit --system <s> --type <t> --title <text>` with no name makes a new unit's id the same way and prints it first (domain move `design-new-unit`). A pillar has an optional `name`; a new pillar's id comes from it; a changed name renames the id after the save, in a second commit `gcf(pillar): rename <a> → <b>`.
@@ -298,7 +318,7 @@ Update together with gcf-harness-aif-ext 0.12.0 and gcf-board 0.6.0 (docs/Sessio
298
318
  - `gcf verify` kills a `dod.test` or `dod.build` command that runs longer than `dod_timeout_min` minutes (60 by default, 0 for no limit), with every process it started, and fails the DoD: `dod.test timed out after 60 min (dod_timeout_min), killed: <command>`. Before, a hung engine held the check, and a run with it, for hours.
299
319
  - `gcf prioritize` takes an item made with `gcf item new` and never committed, and commits it with its rank. Before, it refused the item as an uncommitted file. An item with uncommitted edits is still refused.
300
320
  - `gcf playtest session` lists the items awaiting a decision in a section of their own: before, they were missing from the sheet.
301
- - `plan_passes` defaults to 3 (was 5). A plan converges when an improve pass finds nothing blocking (Methodology §5.2.1); a project that sets `plan_passes` keeps its value.
321
+ - `plan_passes` defaults to 3 (was 5). A plan converges when its last review pass finds nothing blocking (Methodology §5.2.1); a project that sets `plan_passes` keeps its value.
302
322
 
303
323
  ### 0.7.9
304
324
 
@@ -436,8 +456,9 @@ Removal leaves `gcf/` and `cnlp.config.json` in place. It also leaves the pre-co
436
456
 
437
457
  **A deterministic core** behind `ai-factory gcf …`:
438
458
 
439
- - work items — `take <ids...> [--feature <id>]`, `item new [id] --title <text> --type <type>`, `submit`, `close`, `verdict <id> keep|tune|kill`, `decide <id> go|no|wontfix|known|close|continue|kill`, `block`, `unblock`, `drop`, `done`, `where`, `item amend <id> [--text <blocks>] [--add <lines>] [--title <text>] [--from <in-id>] [--dry-run --json]`
459
+ - work items — `take <ids...> [--feature <id>]`, `item new [id] --title <text> --type <type>`, `submit`, `close`, `verdict <id> keep|tune|kill`, `decide <id> go|no|wontfix|known|close|continue|kill`, `block`, `unblock`, `drop`, `done`, `where`, `item amend <id> [--text <blocks>] [--add <lines>] [--title <text>] [--from <in-ids>] [--proposal <key>] [--dry-run --json]`, `inbox drop <in-ids...> [--reason done|duplicate|noise|reported|amended] [--of <id|hash>]`, `inbox later <in-ids...> [--off]`
440
460
  - inbox and snapshot — `inbox [add <text> [--category <c>] [--detail <word>] | add --text-file <path|-> | category <in-id> | later <in-id> [--off] | categories | drop <in-id> | migrate]`, `live`, `live check`
461
+ - lessons and rules (Lessons-Review-Plan d5, d6; the human's moves, refused to a run and a board thread, proposed by a chat agent) — `lessons report --from <in-ids> --to framework|template (--dry-run [--json] | --commit)`: a file a lesson in `<GCF_BOARD_HOME or ~/.gcf>/lessons/<to>/<project>-<in-id>.md`, the entries erased (`reported`) in one commit; `rules [--json]` reads `AGENTS.md` and `CLAUDE.md` (`{files: [{file, text, base, bytes, block, imports_agents, dirty}], own_rules}`); `rules add --text <line> [--from <in-ids>] [--base <hash>] (--dry-run | --commit)` puts one line under `## Project rules`, outside GCF's block, of `AGENTS.md` and of a `CLAUDE.md` that does not import it (refused: a repeat, several lines, a marker, a leading `@` or `#`, a code fence); `rules save --file AGENTS.md|CLAUDE.md --base <hash> --text-file - (--dry-run | --commit)` saves the whole file in its own line endings, refused for a stale base or a changed GCF block. A file with edits not committed goes into the commit whole; `--dry-run` shows its diff from HEAD. `--proposal <thread>/<id>` on `rules add` and `lessons report`; `rules diff --from <hash> --to <hash> [--names] [--json]` (a read, hex hashes only; `--names`: paths alone, no patch) gives what the commits `from..to` changed in the agent's instructions — `AGENTS.md`, `CLAUDE.md`, `.claude/`, `.ai-factory/` without `plans/` and `archive/` (`INSTRUCTION_PATHS`) — no merges, first parent only, so a worktree's `gcf(sync)` of main is not its own, nor a move of the operator's (`GCF-By: operator`) (`{from, to, paths, uncommitted, commits: [{sha, subject, diff}]}`; the harness names them in `run_end.instructions`)
441
462
  - runs and play — `context`, `plan check <id>`, `verify <id>`, `playtest`, `playtest session`, `playtest status`, `playtest devices`, `play-notes`, `item show`, `audit`
442
463
  - project phase and board — `phase`, `phase next [--reason]`, `board [--json]` (everything a board shows, in one read)
443
464
  - branches — `worktree <id>`, `verify <id> --mark`, `integrate [<id>...]`: a run in its own worktree, the `GCF-Verified` trailer, the merge into main and the move; every committed move holds `.gcf-session/main.lock`
@@ -454,7 +475,7 @@ Every move of an item makes one commit `gcf(<move>): <id>` with every file it to
454
475
  **CNLP profiles and a work item schema** for the documents the agent reads — one profile per unit type, shared by a unit and its item — plus injections into `aif-plan`, `aif-review` and `aif-commit`.
455
476
 
456
477
 
457
- Review passes (Hold-Plan, Operator-Tasks-Plan t2): `review.plan` and `review.code` of `gcf/config.yml` are lists of rows `{agent: claude|codex, model, effort}` (`gcf config set review.plan --value "claude:opus:high, codex:astra:medium"`, `none`: no review; defaults Codex astra·medium and fable·medium ×2 for the plan, Codex sol·high and opus·high for the code); row k makes pass k, the next only while the last found something blocking. A row that cannot make its pass gives way to a model of its size (Fallback-Fidelity-Plan d2): Codex medium to fable·medium then opus·high, Codex high and fable·medium to opus·high, any other to none; `gcf board --json` carries the rules as `review_fallback`. `gcf review row <id> --kind plan|code --pass k [--diff] --json` names the row and its `fallback` (and writes the code's diff for the reviewer to `.gcf-session/review/<id>.diff`: from where the card's work started to the disk, new files in, `gcf/` and `no_diff` out). `gcf plan pass <id> --blocking N --polish M [--by agent:model:effort [--for agent:model:effort]] [--kind code]` records each pass (`, for` the row, when someone else made it: `self` or a stand-in) in the plan's `## Passes` (the code's `## Reviews`) and answers continue, converged or stalled; `gcf review stall <id> --kind plan|code` blocks a review that does not converge (`stall.plan|code`; a card's old `stall` is the plan's), and the human answers with `gcf review more <id> --passes N` or `gcf review accept <id>`. `plan_passes` and `plan_review:` are gone: `gcf audit` names the one `config set review.plan` command that moves them, and that set drops them.
478
+ Review passes (Hold-Plan, Operator-Tasks-Plan t2): `review.plan` and `review.code` of `gcf/config.yml` are lists of rows `{agent: claude|codex, model, effort}` (`gcf config set review.plan --value "claude:opus:high, codex:astra:medium"`, `none`: no review; defaults Codex astra·high and fable·medium ×2 for the plan (the first pass is a full review, the next ones check the author's fixes: `gcf plan pass --findings`), Codex sol·high and opus·high for the code); row k makes pass k, the next only while the last found something blocking, of any verdict (accepted, rejected or downgraded). A row that cannot make its pass gives way to a model of its size (Fallback-Fidelity-Plan d2): Codex medium to fable·medium then opus·high, Codex high and fable·medium to opus·high, any other to none; `gcf board --json` carries the rules as `review_fallback`. `gcf review row <id> --kind plan|code --pass k [--diff] --json` names the row and its `fallback` (and writes the code's diff for the reviewer to `.gcf-session/review/<id>.diff`: from where the card's work started to the disk, new files in, `gcf/` and `no_diff` out). `gcf plan pass <id> --blocking N --polish M [--by agent:model:effort [--for agent:model:effort]] [--kind code]` records each pass (`, for` the row, when someone else made it: `self` or a stand-in) in the plan's `## Passes` (the code's `## Reviews`) and answers continue, converged or stalled; `gcf review stall <id> --kind plan|code` blocks a review that does not converge (`stall.plan|code`; a card's old `stall` is the plan's), and the human answers with `gcf review more <id> --passes N` or `gcf review accept <id>`. `plan_passes` and `plan_review:` are gone: `gcf audit` names the one `config set review.plan` command that moves them, and that set drops them.
458
479
 
459
480
  ## Docs
460
481
 
package/commands/gcf.js CHANGED
@@ -1368,11 +1368,18 @@ function registerItemShow(item) {
1368
1368
  if (!card) throw new Error(`${id} is not on the board`);
1369
1369
  const { handoffLines, handoffOf } = await lib('handoff');
1370
1370
  const handoff = await handoffOf(process.cwd(), id, { ledger });
1371
- const r = { id, title: card.data.title ?? null, status: card.data.status, handoff };
1371
+ // The plan review's findings with the author's verdicts (Plan-Review-Rework-Plan d2).
1372
+ const findings = (await lib('plan-check')).itemFindings(process.cwd(), { ...card.data, id });
1373
+ const r = { id, title: card.data.title ?? null, status: card.data.status, handoff, findings };
1372
1374
  out(o.json, r, (x) =>
1373
1375
  [
1374
1376
  `${x.id} (${x.status})${x.title ? ` ${x.title}` : ''}`,
1375
1377
  ...(x.handoff ? handoffLines(x.id, x.handoff) : ['it waits for nothing: no handoff']),
1378
+ ...x.findings.map(
1379
+ (f) =>
1380
+ `finding ${f.tag} ${f.severity} ${f.verdict} ${f.where}: ${f.summary}` +
1381
+ (f.reason ? `; ${f.reason}` : ''),
1382
+ ),
1376
1383
  ].join('\n'),
1377
1384
  );
1378
1385
  });
@@ -1406,7 +1413,11 @@ function registerItemNew(item) {
1406
1413
  .option('--depends <list>', 'ids it waits for, comma-separated')
1407
1414
  .option('--severity <level>', 'a bug: critical | high | medium | low')
1408
1415
  .option('--blocked <why>', 'start blocked, e.g. "file needed" for an asset')
1409
- .option('--from <in-id>', 'the inbox entry it comes from: erased')
1416
+ .option(
1417
+ '--from <in-ids>',
1418
+ 'inbox entries it comes from, comma-separated: erased; several, a bullet each in its ' +
1419
+ 'note, which --note replaces',
1420
+ )
1410
1421
  .option('--reopens <id>', 'the ended id this item reworks')
1411
1422
  .option('--milestone <name>', 'the milestone of game.md it belongs to')
1412
1423
  .option('--release <version>', 'a release: the version it ships')
@@ -1472,13 +1483,14 @@ function registerAmend(item) {
1472
1483
  .option('--add <lines>', 'lines to add to notes:, up to 4000 characters')
1473
1484
  .option('--title <text>', 'the new title')
1474
1485
  .option(
1475
- '--from <in-id>',
1476
- 'the inbox entry it takes: erased; its words go to notes: unless --add',
1486
+ '--from <in-ids>',
1487
+ 'the inbox entries it takes, comma-separated: erased; their words go to notes: unless --add',
1477
1488
  )
1478
1489
  .option('--base <hash>', "the preview's base: refused when the card changed since")
1479
1490
  .option('--dry-run', 'show what would change; write nothing; a run may hold the card')
1480
1491
  .option('--json', 'with --dry-run: {base, title, text, changes: [{block, old, new}]}')
1481
1492
  .option('--no-commit', 'skip the commit (tests only)')
1493
+ .option('--proposal <key>', "the board's proposal it makes, <thread>/<id>: its commit names it")
1482
1494
  .action(async (id, o) => {
1483
1495
  if (o.text !== undefined && o.textFile !== undefined)
1484
1496
  throw new Error('give the text once: --text=<blocks> or --text-file <path|->');
@@ -1494,6 +1506,7 @@ function registerAmend(item) {
1494
1506
  base: o.base,
1495
1507
  dryRun: o.dryRun === true,
1496
1508
  commit: o.commit,
1509
+ proposal: o.proposal,
1497
1510
  });
1498
1511
  if (o.json) console.log(JSON.stringify(r, null, 2));
1499
1512
  else if (o.dryRun)
@@ -1524,6 +1537,23 @@ function registerHistory(item) {
1524
1537
  });
1525
1538
  }
1526
1539
 
1540
+ /** `gcf item agent <id>`: the item's model and effort, or its phase's. */
1541
+ async function itemAgent(id, o) {
1542
+ const r = await (
1543
+ await lib('work-ops')
1544
+ ).setAgent(process.cwd(), id, {
1545
+ model: o.model,
1546
+ effort: o.effort,
1547
+ phase: o.phase,
1548
+ commit: o.commit,
1549
+ });
1550
+ const shown = (v) => v ?? 'default';
1551
+ const phase = r.phase ? ` in its ${r.phase} phase` : '';
1552
+ console.log(
1553
+ `${id} runs${phase} on model ${shown(r.model)}, effort ${shown(r.effort)}` + shortHash(r.hash),
1554
+ );
1555
+ }
1556
+
1527
1557
  function registerAgent(item) {
1528
1558
  item
1529
1559
  .command('agent <id>')
@@ -1536,16 +1566,12 @@ function registerAgent(item) {
1536
1566
  '--effort <level>',
1537
1567
  "e.g. high; default takes the field off: the project's, else the agent's",
1538
1568
  )
1569
+ .option(
1570
+ '--phase <phase>',
1571
+ "plan | implement: the phase's own, over the item's in that phase (plan_model, plan_effort)",
1572
+ )
1539
1573
  .option('--no-commit', 'skip the commit (tests only)')
1540
- .action(async (id, o) => {
1541
- const r = await (
1542
- await lib('work-ops')
1543
- ).setAgent(process.cwd(), id, { model: o.model, effort: o.effort, commit: o.commit });
1544
- const shown = (v) => v ?? 'default';
1545
- console.log(
1546
- `${id} runs on model ${shown(r.model)}, effort ${shown(r.effort)}${shortHash(r.hash)}`,
1547
- );
1548
- });
1574
+ .action(itemAgent);
1549
1575
  item
1550
1576
  .command('mode <id>')
1551
1577
  .description(
@@ -1785,10 +1811,11 @@ function registerDecide(gcf) {
1785
1811
  * @param {boolean | undefined} commit
1786
1812
  * @param {string} message
1787
1813
  * @param {() => P | Promise<P>} make
1788
- * @param {string} key the domain's move key, for the commit's trailer
1814
+ * @param {string | {key: string, proposal?: string, reason?: string, empty?: boolean}} move the
1815
+ * domain's move key, or it with the rest of the commit's trailers
1789
1816
  * @returns {Promise<{hash: string | null, plan: P}>}
1790
1817
  */
1791
- async function inboxMove(commit, message, make, key) {
1818
+ async function inboxMove(commit, message, make, move) {
1792
1819
  if (!commit) {
1793
1820
  const plan = await make();
1794
1821
  await plan.apply();
@@ -1811,7 +1838,7 @@ async function inboxMove(commit, message, make, key) {
1811
1838
  await plan.apply();
1812
1839
  },
1813
1840
  commit: true,
1814
- key,
1841
+ ...(typeof move === 'string' ? { key: move } : move),
1815
1842
  });
1816
1843
 
1817
1844
  return { hash, plan };
@@ -1857,23 +1884,25 @@ function registerInboxSort(inbox) {
1857
1884
  console.log(`${id} is ${category}${detail ? `:${detail}` : ''}${shortHash(hash)}`);
1858
1885
  });
1859
1886
  inbox
1860
- .command('later <in-id>')
1861
- .description('Put an entry away to Later, or take it back with --off')
1862
- .option('--off', 'take it back from Later')
1887
+ .command('later <in-ids...>')
1888
+ .description('Put entries away to Later, or take them back with --off: one commit')
1889
+ .option('--off', 'take them back from Later')
1863
1890
  .option('--commit', 'commit it (gcf(inbox)): for a caller with no console, e.g. a board')
1864
- .action(async (id, o) => {
1891
+ .option('--proposal <key>', "the board's proposal it makes, <thread>/<id>: its commit names it")
1892
+ .action(async (ids, o) => {
1865
1893
  await refuseOnWork('put an entry away');
1866
- const { planLater } = await lib('inbox');
1894
+ const { planLater, planGroup } = await lib('inbox');
1867
1895
  const { gcfRoot } = await lib('gcf-paths');
1868
1896
  const vocab = await vocabulary();
1869
1897
  const [key, what] = o.off ? ['inbox-back', 'back'] : ['inbox-later', 'later'];
1898
+ const named = [...new Set(ids)].join(', ');
1870
1899
  const { hash } = await inboxMove(
1871
1900
  o.commit,
1872
- `gcf(inbox): ${what} ${id}`,
1873
- () => planLater(gcfRoot(), id, !o.off, vocab),
1874
- key,
1901
+ `gcf(inbox): ${what} ${named}`,
1902
+ () => planGroup(ids, (id) => planLater(gcfRoot(), id, !o.off, vocab)),
1903
+ { key, proposal: o.proposal },
1875
1904
  );
1876
- console.log(`${id} ${o.off ? 'back from Later' : 'in Later'}${shortHash(hash)}`);
1905
+ console.log(`${named} ${o.off ? 'back from Later' : 'in Later'}${shortHash(hash)}`);
1877
1906
  });
1878
1907
  registerInboxCategories(inbox);
1879
1908
  }
@@ -1949,35 +1978,61 @@ function readTextFile(file) {
1949
1978
 
1950
1979
  function registerInboxDrop(inbox) {
1951
1980
  inbox
1952
- .command('drop <in-id>')
1953
- .description('Erase an entry: triaged as noise, a duplicate, or turned into an item')
1981
+ .command('drop <in-ids...>')
1982
+ .description(
1983
+ 'Erase entries: triaged as noise, a duplicate, done, or turned into an item; one commit',
1984
+ )
1985
+ .option('--reason <why>', 'why, in its commit: done | duplicate | noise | reported | amended')
1986
+ .option(
1987
+ '--of <id>',
1988
+ 'with --reason: the item, entry or commit hash it is a duplicate of, or did',
1989
+ )
1954
1990
  .option('--commit', 'commit it (gcf(inbox)): for a caller with no console, e.g. a board')
1955
- .action(async (id, o) => {
1991
+ .option('--proposal <key>', "the board's proposal it makes, <thread>/<id>: its commit names it")
1992
+ .action(async (ids, o) => {
1956
1993
  await refuseOnWork('erase an entry');
1957
- const { planDrop } = await lib('inbox');
1994
+ const reason = await dropReason(o);
1995
+ const { planDrop, planGroup } = await lib('inbox');
1958
1996
  const { gcfRoot } = await lib('gcf-paths');
1959
- const { inHead } = await lib('git');
1960
- const committed = inHead(
1961
- process.cwd(),
1962
- (await planDrop(gcfRoot(), id)).files[0], // the entry's own file
1963
- );
1964
- // An entry never committed leaves nothing to commit: it is only erased, from the index too.
1997
+ const named = [...new Set(ids)].join(', ');
1998
+ // An entry never committed leaves nothing of its own to commit: the commit still goes, empty
1999
+ // when nothing else rides along, so its trailers say why (Lessons-Review-Plan d7).
1965
2000
  const { hash, plan } = await inboxMove(
1966
- o.commit && committed,
1967
- `gcf(inbox): drop ${id}`,
1968
- () => planDrop(gcfRoot(), id),
1969
- 'inbox-drop',
2001
+ o.commit,
2002
+ `gcf(inbox): drop ${named}${reason ? ` (${reason})` : ''}`,
2003
+ () => planGroup(ids, (id) => planDrop(gcfRoot(), id)),
2004
+ { key: 'inbox-drop', reason, proposal: o.proposal, empty: true },
1970
2005
  );
1971
- if (!committed)
1972
- spawnSync('git', ['rm', '--cached', '-q', '--ignore-unmatch', '--', ...plan.files], {
2006
+ // Out of the index too: one staged and never committed would stay staged without its file.
2007
+ const { inHead } = await lib('git');
2008
+ const fresh = plan.files.filter((f) => !inHead(process.cwd(), f));
2009
+ if (fresh.length)
2010
+ spawnSync('git', ['rm', '--cached', '-q', '--ignore-unmatch', '--', ...fresh], {
1973
2011
  windowsHide: true,
1974
2012
  cwd: process.cwd(),
1975
2013
  stdio: 'ignore',
1976
2014
  });
1977
- console.log(`erased ${id}${shortHash(hash)}`);
2015
+ console.log(`erased ${named}${shortHash(hash)}`);
1978
2016
  });
1979
2017
  }
1980
2018
 
2019
+ /** The reason of `inbox drop`, `--of` with it: one of DROP_REASONS, an id or a hash, one line. */
2020
+ async function dropReason(o) {
2021
+ if (o.reason === undefined) {
2022
+ if (o.of !== undefined) throw new Error('--of goes with --reason');
2023
+
2024
+ return undefined;
2025
+ }
2026
+
2027
+ const reasons = Object.keys((await lib('inbox')).DROP_REASONS);
2028
+ if (!reasons.includes(o.reason))
2029
+ throw new Error(`--reason is ${reasons.join(' | ')}, not ${o.reason}`);
2030
+ if (o.of !== undefined && !/^[a-z0-9]+(-[a-z0-9]+)*$/.test(o.of))
2031
+ throw new Error(`--of is an item id, an entry id or a commit hash, not ${o.of}`);
2032
+
2033
+ return o.of === undefined ? o.reason : `${o.reason} of ${o.of}`;
2034
+ }
2035
+
1981
2036
  function registerInbox(gcf) {
1982
2037
  const inbox = gcf
1983
2038
  .command('inbox')
@@ -2083,6 +2138,158 @@ function registerLessons(gcf) {
2083
2138
  );
2084
2139
  console.log(`recorded ${plan.entries.length} lessons for ${id}${shortHash(hash)}`);
2085
2140
  });
2141
+ registerLessonsReport(lessons);
2142
+ }
2143
+
2144
+ /**
2145
+ * A move with a preview: `--dry-run` writes nothing, `--commit` records it; one is needed. Both:
2146
+ * the dry run wins, as a board previews the move by its own args and `--dry-run`.
2147
+ */
2148
+ function previewOrCommit(o) {
2149
+ if (!o.dryRun && !o.commit) throw new Error('give --dry-run or --commit');
2150
+ }
2151
+
2152
+ function registerLessonsReport(lessons) {
2153
+ lessons
2154
+ .command('report')
2155
+ .description(
2156
+ 'Report lessons about GCF or the template: a file each in ~/.gcf/lessons/<to>/, ' +
2157
+ 'the entries erased (reported) in one commit',
2158
+ )
2159
+ .requiredOption('--from <in-ids>', 'the lessons, comma-separated')
2160
+ .requiredOption('--to <where>', 'framework | template')
2161
+ .option('--dry-run', 'show the files it would write; write nothing')
2162
+ .option('--json', 'machine output: {to, from, files}')
2163
+ .option('--commit', 'write the files and commit the erase (gcf(inbox))')
2164
+ .option('--proposal <key>', "the board's proposal it makes, <thread>/<id>: its commit names it")
2165
+ .action(async (o) => {
2166
+ previewOrCommit(o);
2167
+ if (!o.dryRun) await operatorOnly('lessons report');
2168
+ const r = await (
2169
+ await lib('lessons')
2170
+ ).reportLessons(process.cwd(), {
2171
+ from: o.from,
2172
+ to: o.to,
2173
+ dryRun: o.dryRun === true,
2174
+ proposal: o.proposal,
2175
+ });
2176
+ out(o.json, r, (x) =>
2177
+ o.dryRun
2178
+ ? x.files.map((f) => `${f.path}\n\n${f.text}`).join('\n')
2179
+ : `reported ${x.from.join(', ')} to ${x.files.join(', ')}${shortHash(x.hash)}`,
2180
+ );
2181
+ });
2182
+ }
2183
+
2184
+ // `rules` has a `--json` of its own: a subcommand's, after its word, goes to the group's options.
2185
+ const jsonIn = (o, cmd) => Boolean(o.json || cmd?.optsWithGlobals?.().json);
2186
+
2187
+ function registerRules(gcf) {
2188
+ const rules = () => lib('rules');
2189
+ const group = gcf
2190
+ .command('rules')
2191
+ .description(
2192
+ "The project's rules for its agents: AGENTS.md and a CLAUDE.md, GCF's block and " +
2193
+ '## Project rules',
2194
+ )
2195
+ .option(
2196
+ '--json',
2197
+ '{files: [{file, text, base, bytes, block, imports_agents, dirty}], own_rules}',
2198
+ )
2199
+ .action(async (o) => {
2200
+ const r = (await rules()).readRules(process.cwd());
2201
+ out(o.json, r, (x) =>
2202
+ [
2203
+ ...x.files.map(
2204
+ (f) =>
2205
+ `${f.file}: ${f.bytes} bytes${f.block ? '' : ', no GCF block'}` +
2206
+ `${f.imports_agents ? ', imports AGENTS.md' : ''}${f.dirty ? ', uncommitted' : ''}`,
2207
+ ),
2208
+ ...x.own_rules.map((l) => `- ${l}`),
2209
+ ].join('\n'),
2210
+ );
2211
+ });
2212
+ group
2213
+ .command('add')
2214
+ .description("A line under ## Project rules of each file an agent reads (the human's)")
2215
+ .requiredOption('--text <line>', 'the rule: one line, up to 300 characters')
2216
+ .option('--from <in-ids>', 'inbox entries it settles, comma-separated: erased in its commit')
2217
+ .option('--base <hash>', 'the base its dry run gave: refused when the files changed since')
2218
+ .option('--dry-run', "show each file's diff from HEAD; write nothing")
2219
+ .option('--json', 'machine output')
2220
+ .option('--commit', 'write it and commit (gcf(rules)), with any edits the files had')
2221
+ .option('--proposal <key>', "the board's proposal it makes, <thread>/<id>: its commit names it")
2222
+ .action(async (o, cmd) => {
2223
+ previewOrCommit(o);
2224
+ if (!o.dryRun) await operatorOnly('rules add');
2225
+ const r = await (
2226
+ await rules()
2227
+ ).addRule(process.cwd(), {
2228
+ text: o.text,
2229
+ from: o.from,
2230
+ base: o.base,
2231
+ dryRun: o.dryRun === true,
2232
+ proposal: o.proposal,
2233
+ });
2234
+ out(jsonIn(o, cmd), r, (x) =>
2235
+ o.dryRun
2236
+ ? x.files.map((f) => f.diff).join('\n')
2237
+ : `added the rule to ${x.files.join(', ')}${shortHash(x.hash)}`,
2238
+ );
2239
+ });
2240
+ registerRulesSave(group, rules);
2241
+ registerRulesDiff(group, rules);
2242
+ }
2243
+
2244
+ function registerRulesDiff(group, rules) {
2245
+ group
2246
+ .command('diff')
2247
+ .description(
2248
+ "What commits from..to changed in the agent's instructions (AGENTS.md, CLAUDE.md, " +
2249
+ '.claude/, .ai-factory/ but plans and archive): no merges, first parent only',
2250
+ )
2251
+ .requiredOption('--from <sha>', 'the commit before, hex')
2252
+ .requiredOption('--to <sha>', 'the commit after, hex')
2253
+ .option('--json', '{from, to, paths, uncommitted, commits: [{sha, subject, diff}]}')
2254
+ .option('--names', 'the paths alone: no commits, no patch')
2255
+ .action(async (o, cmd) => {
2256
+ const range = { from: o.from, to: o.to, names: o.names === true };
2257
+ const r = (await rules()).rulesDiff(process.cwd(), range);
2258
+ out(
2259
+ jsonIn(o, cmd),
2260
+ r,
2261
+ (x) =>
2262
+ [
2263
+ ...(x.commits?.map((c) => `commit ${c.sha} ${c.subject}\n\n${c.diff}`) ?? x.paths),
2264
+ ...(x.uncommitted.length ? [`not committed: ${x.uncommitted.join(', ')}`] : []),
2265
+ ].join('\n') || 'no change to the instructions',
2266
+ );
2267
+ });
2268
+ }
2269
+
2270
+ function registerRulesSave(group, rules) {
2271
+ group
2272
+ .command('save')
2273
+ .description("Save the human's text of AGENTS.md or CLAUDE.md; GCF's block stays as it is")
2274
+ .requiredOption('--file <name>', 'AGENTS.md | CLAUDE.md')
2275
+ .requiredOption('--base <hash>', 'the base gcf rules gave: refused when the file changed since')
2276
+ .requiredOption('--text-file <path>', 'the whole new text, - for stdin')
2277
+ .option('--dry-run', 'show the diff from HEAD; write nothing')
2278
+ .option('--json', 'machine output')
2279
+ .option('--commit', 'save and commit (gcf(rules))')
2280
+ .action(async (o, cmd) => {
2281
+ previewOrCommit(o);
2282
+ if (!o.dryRun) await operatorOnly('rules save');
2283
+ const r = await (
2284
+ await rules()
2285
+ ).saveRules(process.cwd(), {
2286
+ file: o.file,
2287
+ base: o.base,
2288
+ text: readTextFile(o.textFile),
2289
+ dryRun: o.dryRun === true,
2290
+ });
2291
+ out(jsonIn(o, cmd), r, (x) => (o.dryRun ? x.diff : `saved ${x.file}${shortHash(x.hash)}`));
2292
+ });
2086
2293
  }
2087
2294
 
2088
2295
  function registerLive(gcf) {
@@ -2150,18 +2357,24 @@ function registerPlan(gcf) {
2150
2357
  }
2151
2358
 
2152
2359
  /**
2153
- * The improve passes of a plan and their stop (Hold-Plan d12, d16): a pass is recorded in the
2360
+ * The review passes of a plan and their stop (Hold-Plan d12, d16): a pass is recorded in the
2154
2361
  * plan, the verdict decides; a stall blocks the card for the operator's more or accept.
2155
2362
  */
2156
2363
  function registerPlanPasses(plan) {
2157
2364
  plan
2158
2365
  .command('pass <id>')
2159
2366
  .description(
2160
- "Record an improve pass in the plan's ## Passes: its blocking and polish findings; " +
2161
- 'answer the verdict: continue, converged or stalled',
2367
+ "Record a review pass in the plan's ## Passes: its findings with the author's verdicts " +
2368
+ '(## Findings, the counts from them), or its counts; answer the verdict: continue, ' +
2369
+ 'converged or stalled',
2370
+ )
2371
+ .option(
2372
+ '--findings <file>',
2373
+ "JSON: the reviewer's findings, each with the author's verdict (accepted | rejected | " +
2374
+ 'downgraded) and reason; a blocking one without a scenario is polish',
2162
2375
  )
2163
- .requiredOption('--blocking <n>', 'findings that block the plan')
2164
- .requiredOption('--polish <n>', 'findings that only polish it')
2376
+ .option('--blocking <n>', 'without --findings: findings that block the plan')
2377
+ .option('--polish <n>', 'without --findings: findings that only polish it')
2165
2378
  .option('--by <reviewer>', 'who made the pass: agent:model:effort (gcf review row), or self')
2166
2379
  .option(
2167
2380
  '--for <row>',
@@ -2174,8 +2387,9 @@ function registerPlanPasses(plan) {
2174
2387
  const r = await (
2175
2388
  await lib('plan-check')
2176
2389
  ).recordPass(process.cwd(), id, {
2177
- blocking: Number(o.blocking),
2178
- polish: Number(o.polish),
2390
+ blocking: o.blocking === undefined ? undefined : Number(o.blocking),
2391
+ polish: o.polish === undefined ? undefined : Number(o.polish),
2392
+ findings: o.findings,
2179
2393
  by: o.by,
2180
2394
  for: o.for,
2181
2395
  kind: o.kind,
@@ -2195,11 +2409,16 @@ function registerReview(gcf) {
2195
2409
  .command('row <id>')
2196
2410
  .description(
2197
2411
  'Who makes pass k of the plan or code review (review.plan|code of gcf/config.yml; past ' +
2198
- 'the rows, the last); --diff writes the code diff the reviewer reads',
2412
+ 'the rows, the last); --diff writes the diff the reviewer reads. A plan pass keeps ' +
2413
+ 'the plan it sees in .gcf-session/plans/ and says its mode: full, or check of the fixes',
2199
2414
  )
2200
2415
  .requiredOption('--kind <kind>', 'plan or code')
2201
2416
  .requiredOption('--pass <k>', 'the pass number, 1 or more')
2202
- .option('--diff', 'code: write .gcf-session/review/<id>.diff and name it')
2417
+ .option(
2418
+ '--diff',
2419
+ 'code: write .gcf-session/review/<id>.diff; plan, a check: .gcf-session/review/' +
2420
+ "<id>.plan.diff, from the earlier pass's plan; and name it",
2421
+ )
2203
2422
  .option('--json', 'machine output')
2204
2423
  .action(async (id, o) => {
2205
2424
  await touchSession(id);
@@ -2208,7 +2427,7 @@ function registerReview(gcf) {
2208
2427
  ).reviewRow(process.cwd(), id, { kind: o.kind, pass: Number(o.pass), diff: o.diff });
2209
2428
  out(o.json, r, (x) =>
2210
2429
  [
2211
- `pass ${x.pass}: ${x.by ?? 'no review'}`,
2430
+ `pass ${x.pass}: ${x.by ?? 'no review'}${x.mode ? ` (${x.mode})` : ''}`,
2212
2431
  ...(x.fallback.length
2213
2432
  ? [`fallback: ${x.fallback.map((f) => `${f.agent}:${f.model}:${f.effort}`).join(', ')}`]
2214
2433
  : []),
@@ -2356,11 +2575,14 @@ function registerSettings(gcf) {
2356
2575
  .allowExcessArguments(false)
2357
2576
  .option('--json', 'machine output')
2358
2577
  .action(async (o) => {
2359
- const { gcfRoot, readConfig } = await lib('gcf-paths');
2578
+ const { gcfRoot, readConfig, readRawConfig } = await lib('gcf-paths');
2360
2579
  await readConfig(gcfRoot()); // a config the rules refuse says so here
2361
- const list = await (await lib('config-set')).projectSettings(process.cwd());
2580
+ const settings = await lib('config-set');
2581
+ const list = await settings.projectSettings(process.cwd());
2582
+ // A phase's own model and effort, set by `config set`, have no settings row yet (d10).
2583
+ const phases = settings.phaseValues(await readRawConfig(gcfRoot()));
2362
2584
  out(o.json, list, (x) =>
2363
- x
2585
+ [...x, ...phases]
2364
2586
  .map((s) =>
2365
2587
  Array.isArray(s.value)
2366
2588
  ? `${s.key}: # ${s.label}\n${s.value.map((v) => ` ${v}`).join('\n')}`
@@ -2646,6 +2868,7 @@ export function register(program) {
2646
2868
  registerDecide(gcf);
2647
2869
  registerInbox(gcf);
2648
2870
  registerLessons(gcf);
2871
+ registerRules(gcf);
2649
2872
  registerLive(gcf);
2650
2873
  registerPlan(gcf);
2651
2874
  registerReview(gcf);
package/extension.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "$schema": "https://raw.githubusercontent.com/lee-to/ai-factory/2.x/schemas/extension.schema.json",
3
3
  "name": "gcf-aif-ext",
4
- "version": "0.34.0",
4
+ "version": "0.36.0",
5
5
  "description": "Game Context Framework for AI Factory",
6
6
  "skills": [
7
7
  "skills/gcf-init",