gcf-aif-ext 0.32.0 → 0.34.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/lib/play.js CHANGED
@@ -17,7 +17,7 @@ import { configDoc } from './config-doc.js';
17
17
  import { readConfig } from './gcf-paths.js';
18
18
  import { isValidId } from './id.js';
19
19
  import { buildLedger } from './ledger.js';
20
- import { alive, claimMainRun, MAIN_RUN, runHolder, withMainLock } from './main-lock.js';
20
+ import { alive, claimMainRun, locked, MAIN_RUN, runHolder, withMainLock } from './main-lock.js';
21
21
  import { atomicWrite, renameRetrying } from './safe-path.js';
22
22
  import { commitMove } from './commit-move.js';
23
23
  import { commandEnv } from './shell-env.js';
@@ -1848,25 +1848,26 @@ export async function setupPlay(projectDir, opts) {
1848
1848
  const o = { ...rest, words };
1849
1849
  needSetup(dir, o);
1850
1850
  const file = path.join(dir, 'gcf', 'config.yml');
1851
- const was = existsSync(file) ? readFileSync(file, 'utf8') : '';
1852
- const doc = playDoc(was, o);
1853
- // The same setup again (an agent proposed what is there): nothing to write, nothing to commit.
1854
- const same =
1855
- JSON.stringify(configDoc(was).toJS()?.play ?? null) === JSON.stringify(doc.toJS().play);
1856
- const hash = same
1857
- ? null
1858
- : await commitMove(dir, 'gcf(config): play', {
1859
- files: [file],
1860
- commit,
1861
- key: 'config',
1862
- mutate: async () => {
1863
- // Read again under the lock: a move meanwhile may have changed the file.
1864
- const now = existsSync(file) ? readFileSync(file, 'utf8') : '';
1865
- const next = playDoc(now, o);
1866
- playOf(next.toJS());
1867
- await atomicWrite(file, next.toString());
1868
- },
1869
- });
1851
+ // Under the lock from the first read: a move that waited behind a main run reads again.
1852
+ const hash = await locked(dir, commit, async () => {
1853
+ const was = existsSync(file) ? readFileSync(file, 'utf8') : '';
1854
+ const doc = playDoc(was, o);
1855
+ // The same setup again (an agent proposed what is there): nothing to write, nothing to commit.
1856
+ const same =
1857
+ JSON.stringify(configDoc(was).toJS()?.play ?? null) === JSON.stringify(doc.toJS().play);
1858
+
1859
+ return same
1860
+ ? null
1861
+ : commitMove(dir, 'gcf(config): play', {
1862
+ files: [file],
1863
+ commit,
1864
+ key: 'config',
1865
+ mutate: async () => {
1866
+ playOf(doc.toJS());
1867
+ await atomicWrite(file, doc.toString());
1868
+ },
1869
+ });
1870
+ });
1870
1871
 
1871
1872
  return { hash, play: playOf(await readConfig(path.join(dir, 'gcf'))) };
1872
1873
  }
@@ -9,7 +9,7 @@ import { existsSync, readdirSync, readFileSync, rmSync, statSync, utimesSync } f
9
9
  import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
10
10
  import { spawnSync } from 'node:child_process';
11
11
  import path from 'node:path';
12
- import { alive, withMainLock } from './main-lock.js';
12
+ import { alive, withMainLock, yieldToWaiting } from './main-lock.js';
13
13
  import { enterFolder } from './shelf.js';
14
14
 
15
15
  // A run's default timeout: an agent can implement for long without a gcf command. The harness
@@ -87,6 +87,7 @@ export async function claimSession(projectDir, id, owner = ownerOf(), opts = {})
87
87
  const file = markOf(projectDir, id);
88
88
  await excludeSession(projectDir);
89
89
  await mkdir(path.dirname(file), { recursive: true });
90
+ await yieldToWaiting(projectDir);
90
91
 
91
92
  // Under the main lock: two sessions claiming at once must not both pass the check.
92
93
  return withMainLock(projectDir, async () => {
@@ -4,8 +4,10 @@ import { readFile } from 'node:fs/promises';
4
4
  import { existsSync } from 'node:fs';
5
5
  import path from 'node:path';
6
6
  import { parseBlocks, itemsOf } from 'cnlp-kit';
7
- import { parse } from './frontmatter.js';
8
- import { scalarIn } from './design.js';
7
+ import { parse, serialize } from './frontmatter.js';
8
+ import { blockOrder, scalarIn } from './design.js';
9
+ import { atomicWrite } from './safe-path.js';
10
+ import { PLACEHOLDER_RE } from './d2-states.js';
9
11
 
10
12
  const NONE_LINE = '- none: no item of this subsystem has collapsed yet';
11
13
 
@@ -81,9 +83,9 @@ export function putBlock(lines, specs, spec, { rendered, raw = false }) {
81
83
 
82
84
  /**
83
85
  * Append `addLines` to the `key:` bullet block of a body, skipping lines already there. A
84
- * `- none: …` placeholder gives way: CNL-P reads it as the whole content or not at all. The
85
- * block stands where `order` (the profile's block keys, see blockOrder) puts it: M1 refuses
86
- * any other place.
86
+ * `- none: …` placeholder, or a GCF marker line, gives way: CNL-P reads it as the whole content
87
+ * or not at all. The block stands where `order` (the profile's block keys, see blockOrder) puts
88
+ * it: M1 refuses any other place.
87
89
  */
88
90
  export function upsertBlock(rawBody, key, addLines, order) {
89
91
  // A CRLF checkout: `\r` before each `\n` would stop the block match at its first line and
@@ -91,8 +93,11 @@ export function upsertBlock(rawBody, key, addLines, order) {
91
93
  const body = lf(rawBody);
92
94
  const existing = blockLines(body, key);
93
95
  const fresh = addLines.filter((l) => !existing.includes(l));
94
- if (!fresh.length) return body;
95
- const kept = existing.filter((l) => !/^- none\b/.test(l));
96
+ // GCF's own manual() markers (d2-states.js) stand in for content too; a human's manual() stays.
97
+ // An old merge left one beside the very lines merged again: content arriving takes it out.
98
+ const marked = addLines.length > 0 && existing.some((l) => PLACEHOLDER_RE.test(l));
99
+ if (!fresh.length && !marked) return body;
100
+ const kept = existing.filter((l) => !/^- none\b/.test(l) && !PLACEHOLDER_RE.test(l));
96
101
  // A key the profile does not know goes last, after every block it does.
97
102
  const specs = (order.includes(key) ? order : [...order, key]).map((k) => ({ key: k }));
98
103
  const lead = /** @type {RegExpMatchArray} */ (body.match(/^\n*/))[0];
@@ -178,17 +183,59 @@ export function removeLines(rawBody, key, dropLines) {
178
183
 
179
184
  const lf = (text) => String(text).replace(/\r\n/g, '\n');
180
185
 
181
- /** Purpose lines a new systems doc starts with: design/<sys>.md's `purpose:`, or a marker. */
182
- async function purposeLines(root, system) {
186
+ const markerOf = (system) => `[until: manual(purpose of ${system})]`;
187
+
188
+ const designOf = async (root, system) => {
183
189
  const file = path.join(root, 'design', `${system}.md`);
184
- const text = existsSync(file) ? lf(await readFile(file, 'utf8')) : '';
185
- const pre = text.split(/^## /m)[0];
190
+
191
+ return existsSync(file) ? lf(await readFile(file, 'utf8')) : '';
192
+ };
193
+
194
+ /** The purpose lines of a design text (design/<sys>.md, or a bundle's system part); none: TBD. */
195
+ function purposeIn(text) {
196
+ const pre = lf(text).split(/^## /m)[0];
186
197
  const bullets = blockLines(pre, 'purpose').filter((l) => !/^- (TBD|none\b)/.test(l));
187
198
  if (bullets.length) return bullets;
188
199
  const scalar = scalarIn(pre, 'purpose');
189
- if (scalar && scalar !== 'TBD') return [`- ${scalar}`];
190
200
 
191
- return [`- the purpose of ${system} is not written yet [until: manual(purpose of ${system})]`];
201
+ return scalar && scalar !== 'TBD' ? [`- ${scalar}`] : [];
202
+ }
203
+
204
+ /** Purpose lines a new systems doc starts with: design/<sys>.md's `purpose:`, or a marker. */
205
+ async function purposeLines(root, system) {
206
+ const lines = purposeIn(await designOf(root, system));
207
+
208
+ return lines.length
209
+ ? lines
210
+ : [`- the purpose of ${system} is not written yet ${markerOf(system)}`];
211
+ }
212
+
213
+ /**
214
+ * systems/<system>.md when it holds GCF's purpose marker and `design` (design/<system>.md's
215
+ * text, or what a move is about to write there) has a purpose; else null. Only then does a move
216
+ * stage the doc: a doc it leaves alone would refuse the move for edits of its own.
217
+ * @param {string} root
218
+ * @param {string} system
219
+ * @param {string} [design]
220
+ */
221
+ export async function purposeTarget(root, system, design) {
222
+ const file = path.join(root, 'systems', `${system}.md`);
223
+ if (!existsSync(file) || !purposeIn(design ?? (await designOf(root, system))).length) return null;
224
+ const { body } = parse(lf(await readFile(file, 'utf8')));
225
+
226
+ return blockLines(body, 'purpose').some((l) => l.includes(markerOf(system))) ? file : null;
227
+ }
228
+
229
+ /** The purpose marker of systems/<system>.md replaced by design/'s purpose; never starts a doc. */
230
+ export async function fillPurpose(root, system) {
231
+ const design = await designOf(root, system);
232
+ const file = await purposeTarget(root, system, design);
233
+ if (!file) return null;
234
+ const { data, body } = parse(lf(await readFile(file, 'utf8')));
235
+ const order = await blockOrder('system');
236
+ await atomicWrite(file, serialize(data, upsertBlock(body, 'purpose', purposeIn(design), order)));
237
+
238
+ return file;
192
239
  }
193
240
 
194
241
  /**
package/lib/work-ops.js CHANGED
@@ -1019,7 +1019,7 @@ async function keepPack(projectDir, name) {
1019
1019
  }
1020
1020
 
1021
1021
  /** Refuse a milestone keep that would carry changes of gcf/ or the plans but the pack's own. */
1022
- function refuseLoose(projectDir, name, own) {
1022
+ function refuseLoose(projectDir, name, own, order) {
1023
1023
  const loose = changedIn(projectDir).filter((c) => !own.has(c.file));
1024
1024
  if (loose.length) {
1025
1025
  // The board's Commit clears only gcf/'s edits: a loose plan gets the words alone.
@@ -1028,6 +1028,7 @@ function refuseLoose(projectDir, name, own) {
1028
1028
  loose.every((c) => all.includes(c.file)) ? all : [],
1029
1029
  `commit or stash these first, keep --milestone ${name} would carry them: ` +
1030
1030
  loose.map((c) => c.file).join(', '),
1031
+ { message: `gcf(verdict): keep ${name}`, items: order },
1031
1032
  );
1032
1033
  }
1033
1034
  }
@@ -1086,7 +1087,7 @@ async function keepMilestoneUnlocked(projectDir, name, opts = {}) {
1086
1087
  const pack = await keepPack(projectDir, name);
1087
1088
  const order = keepOrder(pack);
1088
1089
  const own = new Set(pack.map((i) => path.relative(projectDir, i.file).replaceAll('\\', '/')));
1089
- refuseLoose(projectDir, name, own);
1090
+ refuseLoose(projectDir, name, own, order);
1090
1091
  refuseKeepBusy(projectDir, name, commit);
1091
1092
 
1092
1093
  const saved = pack.map((i) => [i.file, readFileSync(i.file)]);
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "gcf-aif-ext",
3
- "version": "0.32.0",
3
+ "version": "0.34.0",
4
4
  "description": "Game Context Framework for AI Factory",
5
5
  "type": "module",
6
6
  "license": "MIT",
@@ -19,11 +19,16 @@ workflow:
19
19
  1. run `ai-factory gcf audit --json` and read the report
20
20
  2. state the first line verbatim: items waiting too long block dependent work, so they lead
21
21
  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
22
- 4. for a stale until record of `gcf/open-questions.md`: the D2 assumption its `id` names expired - ask the human to confirm it, then cite `answer: <id>` and remove the record, or to replace the value
23
- 5. read the `design` summary: blocking findings first (run `ai-factory gcf design check` for the list), then the count of ready units
24
- 6. semantic pass, only when the mechanical report is clean or the human asks: read the systems docs of ONE subsystem the human names and report pairs of lines that contradict each other as D1 questions
25
- 7. list the pragmas: each `gcf:allow` is a standing exception, and a growing list is the linter rotting
26
- 8. propose the next actions, ranked, proposed actions <= 3: playtest, answer a D1, take a ready unit, or collapse a stale record
22
+ 4. for a stale until record of `gcf/open-questions.md`: the D2 assumption its `id` names fired - propose the answer in chat, to confirm the value or replace it; a fired D2 is not re-filed as a D1
23
+ 5. the human answers it: the board's Overrule, or `ai-factory gcf question answer <id> --text="<answer>"`; do not answer it yourself
24
+ 6. only after the record carries the human's `answer:`: write it into each slot that cites `assumed: <id>`, cite `answer: <id>` there, then remove the record
25
+ 7. an unplayed item keeps its `assumed: <id>`, as its body is frozen: the answered record stays while an unplayed item cites it, and leaves after that item's verdict
26
+ 8. a stale until annotation in `gcf/systems/` or `gcf/work/` becomes a D1; on the human's go-ahead file it with `ai-factory gcf question add --class D1 --question "<the line> - still true?" --proposed "<its value>" --sys <s>`
27
+ 9. list the `manual(...)` until records, the `placeholder` ones aside: GCF closes its own placeholders
28
+ 10. read the `design` summary: blocking findings first (run `ai-factory gcf design check` for the list), then the count of ready units
29
+ 11. 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
30
+ 12. list the pragmas: each `gcf:allow` is a standing exception, and a growing list is the linter rotting
31
+ 13. propose the next actions, ranked, proposed actions <= 3: playtest, answer a D1, take a ready unit, or collapse a stale record
27
32
 
28
33
  invocation:
29
34
  - run at session start, after a long break, or on demand
@@ -29,7 +29,8 @@ forbidden_behaviors:
29
29
  - do not reuse an id: an ended id stays ended; rework gets a new id with `reopens: <old id>`
30
30
  - do not put an id in `depends` for order alone: `depends` names an item whose data or code this one uses, and order goes in `priority`
31
31
  - do not remove an answered D1 record while a unit in its `blocks:` lacks the answer, or names a receiver you cannot tell: it stays
32
- - do not remove a D2 record cited as `assumed: q-NNN`: it stays in `gcf/open-questions.md` until its `until:` fires; when the human confirms the value earlier, rewrite each citation to `answer: q-NNN` first
32
+ - do not remove a D2 record without the human's `answer:`, nor before each citation `assumed: q-NNN` outside an unplayed item reads `answer: q-NNN`
33
+ - do not touch an unplayed item's `assumed: q-NNN`: its body is frozen; the answered record stays while an unplayed item cites it, and leaves after that item's verdict
33
34
 
34
35
  outputs:
35
36
  - each answered slot gets a provenance record `- slot: <block>` with `answer: manual`, or `answer: q-NNN` when it closes a question
@@ -53,15 +54,16 @@ workflow:
53
54
  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
54
55
  12. write each answer into the unit in place, with its `answer:` provenance record
55
56
  13. a record of `gcf/open-questions.md` with the human's `answer:` that names this unit in `blocks:` goes into the slot of every unit it blocks, each with `answer: q-NNN`; it leaves the file after the last of them has it
56
- 14. run `ai-factory gcf design check --json` until the unit's entry in `units` reads `ready: true`, then commit the answered unit
57
- 15. run `ai-factory gcf take <id>`, or `take <id> <id> --feature <feature-id>` to group units; a unit without its milestone takes `--milestone <name>` from `gcf/game.md`; it writes `gcf/work/<id>.md`
58
- 16. in each mechanic or resource item write `contract:` from the code tree and `interactions:` from the units and items that write the same state
59
- 17. 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
60
- 18. when the work is several items (a feature's children, or a batch), cut them along subsystem boundaries: each a thin slice that builds and tests alone
61
- 19. two items of one subsystem that change different files get `parallel: ok`, and their `contract:` or `intent:` names those files
62
- 20. set each item's dependencies with `ai-factory gcf depends <id> --add <ids>`: it commits the item's edits too, and a feature's child never depends on its feature
63
- 21. rank the items with `ai-factory gcf prioritize <id> <id> …`: dependencies first, then by value
64
- 22. report the item paths, each item's gate, and for a verdict item the one question the playtest will answer
57
+ 14. a D2 record with the human's `answer:` overrules its `assumed:`: write it into each slot that cites `assumed: q-NNN`, cite `answer: q-NNN` there, then remove the record, the unplayed items aside
58
+ 15. run `ai-factory gcf design check --json` until the unit's entry in `units` reads `ready: true`, then commit the answered unit
59
+ 16. run `ai-factory gcf take <id>`, or `take <id> <id> --feature <feature-id>` to group units; a unit without its milestone takes `--milestone <name>` from `gcf/game.md`; it writes `gcf/work/<id>.md`
60
+ 17. in each mechanic or resource item write `contract:` from the code tree and `interactions:` from the units and items that write the same state
61
+ 18. 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
62
+ 19. when the work is several items (a feature's children, or a batch), cut them along subsystem boundaries: each a thin slice that builds and tests alone
63
+ 20. two items of one subsystem that change different files get `parallel: ok`, and their `contract:` or `intent:` names those files
64
+ 21. set each item's dependencies with `ai-factory gcf depends <id> --add <ids>`: it commits the item's edits too, and a feature's child never depends on its feature
65
+ 22. rank the items with `ai-factory gcf prioritize <id> <id> …`: dependencies first, then by value
66
+ 23. report the item paths, each item's gate, and for a verdict item the one question the playtest will answer
65
67
 
66
68
  invocation:
67
69
  - 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
@@ -34,11 +34,13 @@ workflow:
34
34
  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
35
35
  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
36
36
  6. run `ai-factory gcf verdict <id> <verdict> --note "<answer>"`, with `--played-on <build>` per build of `play.builds` the human played on; a kill makes a removal item for code in main unless `--no-remove`
37
- 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
38
- 8. for a feature whose child died, the human picks: `close` without the child, `continue` with a replacement, or `kill` with its live children
39
- 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
40
- 10. report the commit hash, `git revert <hash>` undoes that one move - not the code, nor a later move or edit on the same files - and the id of any removal item the command made
41
- 11. a whole milestone: compress its awaiting-verdict units as in steps 4-5, then run `ai-factory gcf verdict <milestone> keep --milestone`
37
+ 7. after each verdict - step 6, or the milestone keep of step 13 - run `ai-factory gcf audit --json`
38
+ 8. each stale `until` entry the verdict fired - `verdict(<id>)` of the item or of each id the milestone keep prints after `→`, or `retune(<its subsystem>)` after a tune - ask the human now, while present, as steps 4-8 of the gcf-audit skill do
39
+ 9. 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
40
+ 10. for a feature whose child died, the human picks: `close` without the child, `continue` with a replacement, or `kill` with its live children
41
+ 11. 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
42
+ 12. report the commit hash, `git revert <hash>` undoes that one move - not the code, nor a later move or edit on the same files - and the id of any removal item the command made
43
+ 13. a whole milestone: compress its awaiting-verdict units as in steps 4-5, then run `ai-factory gcf verdict <milestone> keep --milestone`
42
44
 
43
45
  invocation:
44
46
  - run after a playtest session, on a human decision, or with no arguments to print the playtest sheet
@@ -3,6 +3,8 @@ gcf_context:
3
3
  - read `gcf/INDEX.md` before anything else under `gcf/`: it lists every subsystem, design unit and work item
4
4
  - `gcf/LIVE.md` says what the game does now, and `gcf/PILLARS.md` says what it must stay
5
5
  - `ai-factory gcf board --json` gives the whole state in one read: the phase, the items by status with plan progress, the inbox and the open questions
6
+ - start a session with `ai-factory gcf audit` and state its first line before anything else
7
+ - a stale `until` record that line names goes to the human through the gcf-audit skill: the human confirms or replaces the value
6
8
 
7
9
  gcf_work:
8
10
  - 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
@@ -46,6 +48,10 @@ gcf_work:
46
48
  - work that cannot go on: run `ai-factory gcf block <id> --reason "<why or the question>"`
47
49
  - in a worktree on branch `work/<id>` change no `gcf/` file but the item's `live:` and new inbox entries, commit all, then run `ai-factory gcf verify <id> --mark`: `ai-factory gcf integrate` in the main checkout merges it and records the move
48
50
  - a design question only the human can answer becomes a D1 record in `gcf/open-questions.md`
51
+ - a fired assumption is never an inbox entry
52
+ - a fired D2 is not re-filed as a D1: the human answers its own record; a plan that needs its value blocks with `--reason "needs the human's answer to <q-NNN> (its until fired)"`
53
+ - an assumption with no record, a fired inline `until` annotation or a belief your work shows false, is a D1 question
54
+ - file it with `ai-factory gcf question add --class D1 --question "<question>" --proposed "<your answer>"`, and `--blocks <id>` for the item it holds
49
55
  - name each thing by the term `GLOSSARY.md` defines for it
50
56
  - a word added to an `avoid:` of `GLOSSARY.md` leaves `gcf/design/`, `gcf/systems/`, `gcf/PILLARS.md` and every item but an unplayed one in the same commit
51
57
  - `ai-factory gcf design check` names each hit of an avoided word in design and items as M4, `npx --yes cnlp-kit check` the rest
@@ -102,6 +108,8 @@ gcf_work:
102
108
  - an answer that moves into a unit's slot goes there in English
103
109
  - do not translate keys, statuses, ids, commands, `TBD`, `answer: q-NNN`, `## Handoff`, a `quote:` (it is verbatim from the GDD) or the fixed start of a block reason (`needs permission:`, `planning does not converge`, `waits for`)
104
110
  - a D1 record that carries the human's `answer:` goes into the slot of each unit it blocks, with `answer: q-NNN`, and then leaves `gcf/open-questions.md`
111
+ - a D2 record's `answer:` from the human overrules its `assumed:`: write it into each slot that cites `assumed: q-NNN`, cite `answer: q-NNN` there, then remove the record
112
+ - an unplayed item's body is frozen: its `assumed: q-NNN` stays, and the answered record stays while an unplayed item cites it; it leaves after that item's verdict
105
113
  - a pillar changes only on the human's word; its short `name:` is what the human knows it by, and its id comes from the name
106
114
  - a new name saved with `design save` renames the id in every file that cites it
107
115
  - `ai-factory gcf pillar retire <id> --reason "<why>"` takes a pillar out
@@ -121,6 +129,7 @@ gcf_work:
121
129
  - in the project chat propose a new item by its title, never an id
122
130
  - in the project chat propose a verdict only after the human said in the talk that they played the item and how it felt, its note in the human's words; leave the `remove` of a kill, a no or a wontfix to the rule unless the human says otherwise
123
131
  - a move refused for hand edits under `gcf/` ends its error with `gcf-refusal: {"code":"dirty","paths":[…]}`: `ai-factory gcf edits diff --path <path>` shows them; `gcf edits commit` and `gcf edits discard` are the human's moves, never the agent's
132
+ - while a main run works a card, your move is still refused for that run's `gcf/` edits and does not wait; the human's move waits behind the run: propose the move to the human, or make it again after the card's commit
124
133
  - `item amend` refused for a live run ends with `gcf-refusal: {"code":"running"}`, and refused for a card changed since its preview with `gcf-refusal: {"code":"stale"}`
125
134
  - a move the commit gate refuses ends its error with `gcf-refusal: {"code":"gate","problems":[…]}`: git holds no commit of it; fix what it names, then make the move again
126
135
  - `ai-factory gcf changes [--worktree <id>]` lists what is uncommitted in the checkout or an item's worktree, `gcf changes diff --path <path>` shows one text file's diff