gcf-aif-ext 0.15.0 → 0.16.1

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,14 @@ 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.16.1
54
+
55
+ Update together with gcf-harness-aif-ext 0.16.1 and gcf-board 0.12.1; run `ai-factory gcf init` after it (the AGENTS.md block learns the new proposals and `item mode`).
56
+
57
+ - An item's own run mode (Board-PRD decision 28): `ai-factory gcf item mode <id> --run main|worktree|default` sets `run_mode:` in its file over the project's `run_mode` (`default` takes it off); refused while a run drives the item; commit `gcf(item): <id> runs in <mode>`. `gcf board --json` carries `items[].run_mode` and the domain move `mode`.
58
+ - `gcf integrate` merges nothing while a harness main run works in the checkout (`.gcf-session/runs/.main-run.lock`): "a main run works in the main checkout (pid N): integrate after it ends". The branches wait; the harness merges them when that run ends.
59
+ - The project chat's agent proposes more moves (`propose: true` in `gcf board --json`): `block`, `drop`, `depends`, `inbox-add`, `inbox-tag`, `inbox-drop` beside `item-new`. The board shows each as a card the operator makes with one click (Board-PRD decision 27); the gcf-chat skill calls the `propose_<move>` tool instead of running the command.
60
+
53
61
  ### 0.15.0
54
62
 
55
63
  Update together with gcf-harness-aif-ext 0.15.0 and gcf-board 0.11.0; no `gcf init` needed.
package/commands/gcf.js CHANGED
@@ -792,6 +792,19 @@ function registerAgent(item) {
792
792
  `${id} runs on model ${shown(r.model)}, effort ${shown(r.effort)}${shortHash(r.hash)}`,
793
793
  );
794
794
  });
795
+ item
796
+ .command('mode <id>')
797
+ .description(
798
+ "Set where an item's runs go: main or worktree over the project's run_mode (commit)",
799
+ )
800
+ .requiredOption('--run <mode>', "main, worktree, or default: the project's run_mode")
801
+ .option('--no-commit', 'skip the commit (tests only)')
802
+ .action(async (id, o) => {
803
+ const r = await (
804
+ await lib('work-ops')
805
+ ).setRunMode(process.cwd(), id, { run: o.run, commit: o.commit });
806
+ console.log(`${id} runs in ${r.run_mode ?? "the project's run_mode"}${shortHash(r.hash)}`);
807
+ });
795
808
  }
796
809
 
797
810
  function registerAttach(item) {
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.15.0",
4
+ "version": "0.16.1",
5
5
  "description": "Game Context Framework for AI Factory",
6
6
  "skills": [
7
7
  "skills/gcf-init",
package/lib/board.js CHANGED
@@ -216,6 +216,7 @@ const SCALARS = [
216
216
  'since',
217
217
  'model',
218
218
  'effort',
219
+ 'run_mode',
219
220
  ];
220
221
 
221
222
  /**
package/lib/domain.js CHANGED
@@ -7,6 +7,7 @@ import { DEFAULT_GATE, GATES, ITEM_TYPES, SEVERITIES, UNIT_ITEM_TYPES } from './
7
7
  import { SOURCES } from './inbox.js';
8
8
  import { NOTE_MAX } from './work-ops.js';
9
9
  import { SESSION_TTL_MS } from './session-mark.js';
10
+ import { RUN_MODES } from './gcf-paths.js';
10
11
 
11
12
  // The status a run starts from; the order of its column is the run order.
12
13
  export const RUNS_FROM = 'ready';
@@ -77,8 +78,15 @@ const text = (key, label, extra = {}) => ({ key, label, kind: 'text', ...extra }
77
78
  const PICKS = "default: the project's, else the agent picks";
78
79
  const MODEL = text('model', 'Model of its run', { presets: 'model', help: PICKS });
79
80
  const EFFORT = text('effort', 'Effort of its run', { presets: 'effort', help: PICKS });
81
+ // Where an item's runs go (Methodology §7): the operator's choice over the project's run_mode;
82
+ // the framework does not judge which a project's work needs.
83
+ const RUN_MODE_HELP = {
84
+ worktree: 'its own copy, several runs at once; its branch merges after a green verify',
85
+ main: 'the project folder, one run at a time; the agent records its move there',
86
+ };
80
87
 
81
- // An item's moves (§4.1), offered by `items[].moves`.
88
+ // An item's moves (§4.1), offered by `items[].moves`. A project chat agent may propose one with
89
+ // `propose` (AD-12, AD-53): the board shows it as a card, the operator's click makes it.
82
90
  const ITEM_SPECS = {
83
91
  submit: {
84
92
  label: 'submit',
@@ -141,6 +149,7 @@ const ITEM_SPECS = {
141
149
  help: 'Stop it until the operator answers',
142
150
  args: ['gcf', 'block', '{id}'],
143
151
  fields: [REASON],
152
+ propose: true,
144
153
  },
145
154
  unblock: {
146
155
  label: 'unblock',
@@ -157,6 +166,7 @@ const ITEM_SPECS = {
157
166
  danger: true,
158
167
  rare: true,
159
168
  drag: 'graveyard',
169
+ propose: true,
160
170
  },
161
171
  depends: {
162
172
  label: 'depends',
@@ -167,6 +177,7 @@ const ITEM_SPECS = {
167
177
  { key: 'remove', label: 'Remove: ids it no longer waits for', kind: 'ids' },
168
178
  ],
169
179
  rare: true,
180
+ propose: true,
170
181
  },
171
182
  agent: {
172
183
  label: 'model / effort',
@@ -175,6 +186,26 @@ const ITEM_SPECS = {
175
186
  fields: [MODEL, EFFORT],
176
187
  rare: true,
177
188
  },
189
+ mode: {
190
+ label: 'run mode',
191
+ help: 'Where its runs go: the project folder or a worktree of their own; the next run takes it',
192
+ args: ['gcf', 'item', 'mode', '{id}'],
193
+ fields: [
194
+ {
195
+ // The item's field it sets, so the drawer's change starts from its value.
196
+ key: 'run_mode',
197
+ flag: 'run',
198
+ label: 'Its runs go',
199
+ kind: 'choice',
200
+ required: true,
201
+ options: [
202
+ { value: 'default', label: "default: the project's run_mode" },
203
+ ...RUN_MODES.map((m) => ({ value: m, label: m, help: RUN_MODE_HELP[m] })),
204
+ ],
205
+ },
206
+ ],
207
+ rare: true,
208
+ },
178
209
  attach: {
179
210
  label: 'attach',
180
211
  help: 'Give the item a file (a chat image, a reference): committed in its attachments',
@@ -288,6 +319,7 @@ const BLOCK_SPECS = {
288
319
  },
289
320
  { key: 'tags', label: 'Tags', kind: 'tags' },
290
321
  ],
322
+ propose: true,
291
323
  },
292
324
  'inbox-drop': {
293
325
  label: 'erase',
@@ -295,6 +327,7 @@ const BLOCK_SPECS = {
295
327
  args: ['gcf', 'inbox', 'drop', '{id}', '--commit'],
296
328
  fields: [],
297
329
  danger: true,
330
+ propose: true,
298
331
  },
299
332
  'inbox-tag': {
300
333
  label: 'tag',
@@ -304,6 +337,7 @@ const BLOCK_SPECS = {
304
337
  { key: 'add', label: 'Add tags', kind: 'tags' },
305
338
  { key: 'remove', label: 'Remove tags', kind: 'tags' },
306
339
  ],
340
+ propose: true,
307
341
  },
308
342
  'question-answer': {
309
343
  label: 'answer',
@@ -339,6 +373,7 @@ const FIELDS = [
339
373
  // `edit`: the move that changes it, from the drawer.
340
374
  { key: 'model', label: 'model', kind: 'text', card: true, edit: 'agent' },
341
375
  { key: 'effort', label: 'effort', kind: 'text', edit: 'agent' },
376
+ { key: 'run_mode', label: 'run mode', kind: 'text', edit: 'mode' },
342
377
  { key: 'tune_count', label: 'tune', kind: 'text', help: 'Tune verdicts so far', card: true },
343
378
  {
344
379
  key: 'waits_for',
package/lib/history.js CHANGED
@@ -22,6 +22,7 @@ export const OLD_SUBJECTS = [
22
22
  [/^gcf\(decide\): ([a-z]+) (\S+)$/, (m) => ({ move: `decide:${m[1]}`, ids: [m[2]] })],
23
23
  [/^gcf\(priority\): (\S+(?:, \S+)*)$/, (m) => ({ move: 'prioritize', ids: m[1].split(', ') })],
24
24
  [/^gcf\(item\): (\S+) model \S+, effort \S+$/, (m) => ({ move: 'agent', ids: [m[1]] })],
25
+ [/^gcf\(item\): (\S+) runs in \S+$/, (m) => ({ move: 'mode', ids: [m[1]] })],
25
26
  [/^gcf\(item\): (\S+)$/, (m) => ({ move: 'item-new', ids: [m[1]] })],
26
27
  [/^gcf\(integrate\): (\S+)(?: plan)?$/, (m) => ({ move: 'integrate', ids: [m[1]] })],
27
28
  // A submit or close may say why it went without a green verify or with tasks unticked.
package/lib/integrate.js CHANGED
@@ -8,7 +8,7 @@ import { spawnSync } from 'node:child_process';
8
8
  import path from 'node:path';
9
9
  import { buildLedger } from './ledger.js';
10
10
  import { parse } from './frontmatter.js';
11
- import { withMainLock, runHolder } from './main-lock.js';
11
+ import { withMainLock, runHolder, lockedItem, MAIN_RUN } from './main-lock.js';
12
12
  import { verifyItem, deltaProblems } from './verify.js';
13
13
  import { submitItem, closeItem, blockItem } from './work-ops.js';
14
14
  import { isValidId } from './id.js';
@@ -358,15 +358,27 @@ function commitMetrics(projectDir) {
358
358
  );
359
359
  }
360
360
 
361
+ // The harness waits on these words (gcf-harness run): keep them.
362
+ const MAIN_BUSY = 'a main run works in the main checkout';
363
+
361
364
  /**
362
365
  * Merge verified branches into main and record each item's move: gate auto closes, the others
363
366
  * submit; a move the item refuses blocks it with the reason. `ids` empty: every verified branch.
364
- * One item's failure is reported and the others still go.
367
+ * One item's failure is reported and the others still go. Refused while a main run works in the
368
+ * checkout: a merge there would land under its agent; the branches wait for it to end.
365
369
  */
366
370
  export async function integrate(projectDir, ids = []) {
367
371
  const branch = git(projectDir, ['rev-parse', '--abbrev-ref', 'HEAD']).out;
368
372
  if (branch === 'HEAD' || branch.startsWith('work/'))
369
373
  throw new Error(`integrate runs in the main checkout on its branch, not on ${branch}`);
374
+ // The session of the item that run works now merges as before (gcf-run's step 1): it works the
375
+ // checkout itself. A worktree session of the same harness inherits its owner, not that item.
376
+ const main = runHolder(projectDir, MAIN_RUN);
377
+ const own =
378
+ process.env.GCF_RUN_OWNER === `run:${main}` &&
379
+ Boolean(process.env.GCF_RUN_ITEM) &&
380
+ process.env.GCF_RUN_ITEM === lockedItem(projectDir, MAIN_RUN);
381
+ if (main && !own) throw new Error(`${MAIN_BUSY} (pid ${main}): integrate after it ends`);
370
382
 
371
383
  return withMainLock(projectDir, async () => {
372
384
  // The run logs go in at every integrate, a main-mode run's first one too: nothing else
package/lib/main-lock.js CHANGED
@@ -25,6 +25,23 @@ export const alive = (pid) => {
25
25
  }
26
26
  };
27
27
 
28
+ /**
29
+ * The harness's lock of the main checkout (`.gcf-session/runs/.main-run.lock`): a main-mode run
30
+ * works there, one at a time. `runHolder(dir, MAIN_RUN)` is its live run.
31
+ */
32
+ export const MAIN_RUN = '.main-run';
33
+
34
+ /** The item a run lock names on its second line (the main run's: the item it works now), or null. */
35
+ export function lockedItem(projectDir, id) {
36
+ try {
37
+ const file = path.join(path.resolve(projectDir), '.gcf-session', 'runs', `${id}.lock`);
38
+
39
+ return readFileSync(file, 'utf8').split('\n')[1]?.trim() || null;
40
+ } catch {
41
+ return null;
42
+ }
43
+ }
44
+
28
45
  /**
29
46
  * The pid of a live harness run that drives item `id` (`.gcf-session/runs/<id>.lock`), or null.
30
47
  * A move on that item from anywhere else would race the run's own record of it.
@@ -34,6 +34,8 @@ const FROM = {
34
34
  attach: STORED,
35
35
  // The model and effort of its next run change no status either.
36
36
  agent: STORED,
37
+ // Nor does where its runs go, main or a worktree.
38
+ mode: STORED,
37
39
  };
38
40
 
39
41
  /** Every move an item may be offered, in the board's order. */
@@ -66,6 +66,7 @@ const FIELDS = [
66
66
  'live',
67
67
  'model',
68
68
  'effort',
69
+ 'run_mode',
69
70
  'version',
70
71
  'channel',
71
72
  'created',
@@ -164,6 +165,8 @@ const RULES = {
164
165
  live: (v) => liveProblem(v) ?? true,
165
166
  model: (v) => nullable(isText)(v) || 'model must be text or null',
166
167
  effort: (v) => nullable(isText)(v) || 'effort must be text or null',
168
+ run_mode: (v) =>
169
+ nullable((x) => ['main', 'worktree'].includes(x))(v) || 'run_mode must be main | worktree',
167
170
  version: (v) =>
168
171
  nullable((x) => typeof x === 'string' && /^\S+$/.test(x))(v) ||
169
172
  'version must be one word of text (quote a number: "1.0")',
package/lib/work-ops.js CHANGED
@@ -10,7 +10,7 @@ import { createHash } from 'node:crypto';
10
10
  import path from 'node:path';
11
11
  import { parse, serialize } from './frontmatter.js';
12
12
  import { buildLedger } from './ledger.js';
13
- import { readConfig, RUN_WORD } from './gcf-paths.js';
13
+ import { readConfig, RUN_MODES, RUN_WORD } from './gcf-paths.js';
14
14
  import { atomicWrite, resolveInside } from './safe-path.js';
15
15
  import { allowedFrom, decisionFits, FEATURE_ONLY, fromOf } from './transitions.js';
16
16
  import { ITEM_TYPES, DEFAULT_GATE, GATES, SEVERITIES, UNIT_ITEM_TYPES } from './validate-item.js';
@@ -1107,6 +1107,42 @@ async function setAgentUnlocked(projectDir, id, { model, effort, commit = true }
1107
1107
  return { ...result, hash };
1108
1108
  }
1109
1109
 
1110
+ /**
1111
+ * Set where item `id`'s runs go (Methodology §7): `main` or `worktree` over the project's
1112
+ * `run_mode`, `default` taking the field off. One commit `gcf(item)`; the next run takes it.
1113
+ * Which one a project's work needs is the operator's to know: the framework does not judge it.
1114
+ * @param {string} projectDir
1115
+ * @param {string} id
1116
+ * @param {{run?: string, commit?: boolean}} [opts]
1117
+ */
1118
+ async function setRunModeUnlocked(projectDir, id, { run, commit = true } = {}) {
1119
+ if (run !== AGENT_DEFAULT && !RUN_MODES.includes(run ?? ''))
1120
+ throw new Error(`--run is ${[...RUN_MODES, AGENT_DEFAULT].join(' | ')}`);
1121
+ const ledger = await buildLedger(projectDir);
1122
+ const item = ledger.item(id);
1123
+ if (!item) throw new Error(`${id} is not a work item`);
1124
+ refuseRunning(projectDir, id);
1125
+ const data = { ...item.data };
1126
+ if (run === AGENT_DEFAULT) delete data.run_mode;
1127
+ else data.run_mode = run;
1128
+ const result = { id, run_mode: data.run_mode ?? null };
1129
+ if (data.run_mode === item.data.run_mode) return { ...result, hash: null };
1130
+ const hash = await commitMove(
1131
+ projectDir,
1132
+ `gcf(item): ${id} runs in ${data.run_mode ?? AGENT_DEFAULT}`,
1133
+ {
1134
+ files: [item.file],
1135
+ inputs: [item.file],
1136
+ mutate: () => atomicWrite(item.file, serialize(data, item.body)),
1137
+ commit,
1138
+ key: 'mode',
1139
+ items: [id],
1140
+ },
1141
+ );
1142
+
1143
+ return { ...result, hash };
1144
+ }
1145
+
1110
1146
  // An attachment is a picture or a file the operator gave the item (a chat image, a reference).
1111
1147
  const ATTACH_MAX = 10 * 1024 * 1024;
1112
1148
 
@@ -1281,6 +1317,9 @@ export const setDepends = (projectDir, id, opts = {}) =>
1281
1317
  /** @type {typeof setAgentUnlocked} */
1282
1318
  export const setAgent = (projectDir, id, opts = {}) =>
1283
1319
  locked(projectDir, opts.commit ?? true, () => setAgentUnlocked(projectDir, id, opts));
1320
+ /** @type {typeof setRunModeUnlocked} */
1321
+ export const setRunMode = (projectDir, id, opts = {}) =>
1322
+ locked(projectDir, opts.commit ?? true, () => setRunModeUnlocked(projectDir, id, opts));
1284
1323
  /** @type {typeof newItemUnlocked} */
1285
1324
  export const newItem = (projectDir, spec) =>
1286
1325
  locked(projectDir, spec.commit ?? false, () => newItemUnlocked(projectDir, spec));
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "gcf-aif-ext",
3
- "version": "0.15.0",
3
+ "version": "0.16.1",
4
4
  "description": "Game Context Framework for AI Factory",
5
5
  "type": "module",
6
6
  "license": "MIT",
@@ -100,6 +100,7 @@
100
100
  },
101
101
  "model": { "$ref": "#/definitions/textOrNull" },
102
102
  "effort": { "$ref": "#/definitions/textOrNull" },
103
+ "run_mode": { "enum": ["main", "worktree", null] },
103
104
  "version": {
104
105
  "anyOf": [{ "type": "null" }, { "type": "string", "pattern": "^\\S+$" }]
105
106
  },
@@ -8,7 +8,8 @@ mode: human gate
8
8
  purpose:
9
9
  - answer the human's questions about the game, its design, its work items and its runs from what `gcf/` and the run files say
10
10
  - turn a bug, an idea or a task the talk finds into a proposed work item the human accepts with one click
11
- - make a move the human asks for through its `ai-factory gcf` command, which the chat shows the human as a card first
11
+ - propose a move on an item or an inbox entry (block, drop, depends, inbox add, tag, erase) as a card the human makes with one click
12
+ - make another move the human asks for through its `ai-factory gcf` command, which the chat shows the human as a card first
12
13
 
13
14
  inputs:
14
15
  - the human's messages, one turn each
@@ -22,6 +23,7 @@ forbidden_behaviors:
22
23
  - do not make the human's moves: `verdict`, `decide`, `question answer`, `unblock`, `phase next`, `pillar`, `permissions`, `config set`, `hooks-install`; the rules refuse them to any agent
23
24
  - do not run `ai-factory gcf-harness run|stop|chat|init` or `ai-factory extension`: the rules refuse them; name the board's button instead
24
25
  - do not make a new item with `ai-factory gcf item new`: propose it with the `propose_item_new` tool of the `gcf` MCP server, and the human's click makes it
26
+ - do not run the command of a move that has a `propose_` tool of the `gcf` MCP server (`propose_block`, `propose_drop`, `propose_depends`, `propose_inbox_add`, `propose_inbox_tag`, `propose_inbox_drop`): call the tool
25
27
  - do not write code or edit files to fix what the talk finds: a fix is a work item, and its run builds it
26
28
  - do not answer from memory what a file says: read the file, then answer
27
29
  - do not ask again for a move the human refused: say what it would have done and leave it
@@ -32,9 +34,10 @@ workflow:
32
34
  2. a thread bound to an item: read the item's file, its plan, its run's log and run chat first, the paths the context file names, before the first answer
33
35
  3. answer the question from the files you read, with the paths that say it; for the runs' numbers run `ai-factory gcf-harness metrics` when the project has the harness
34
36
  4. a bug, an idea or a task that is new work: call `propose_item_new` with its id, type, title, subsystems and a note of what its run should know; note length <= 4000 characters
35
- 5. a raw thought that is not work yet: propose to put it in the inbox with `ai-factory gcf inbox add`
36
- 6. a move the human asks for: run its `ai-factory gcf` command; the human approves it on the card, or refuses it
37
- 7. say in one line what changed, or that nothing did
37
+ 5. a raw thought that is not work yet: propose it for the inbox with `propose_inbox_add`, source `agent`
38
+ 6. a move the human asks for, or one the talk shows is due, that has a `propose_<move>` tool: call it with the `id` of the item or inbox entry it acts on, and say why in one line
39
+ 7. another move the human asks for: run its `ai-factory gcf` command; the human approves it on the card, or refuses it
40
+ 8. say in one line what changed, or that nothing did
38
41
 
39
42
  invocation:
40
43
  - run at the start of a project chat thread the board opens, and when the user types `/gcf-chat`
@@ -25,6 +25,7 @@ gcf_work:
25
25
  - a release item carries `version:` and `channel:` (`item new <id> --type release --release <v> --channel <c>`): its end writes the `release:` block of `gcf/LIVE.md`
26
26
  - `item new` and `take` refuse a type the current phase does not take: run `ai-factory gcf phase` and bring the refusal to the human
27
27
  - an item the human wants run on a given model or effort gets `item new <id> --model <m> --effort <e>`: the harness run passes both to the agent; an existing item changes with `ai-factory gcf item agent <id> --model <m> --effort <e>` (`default` takes one off), never a hand edit; its next run takes them; an item without its own runs on the project's `agent.model` and `agent.effort` of `gcf/config.yml`, a setting of the human
28
+ - where an item's runs go, the project folder or a worktree, is the human's choice: `ai-factory gcf item mode <id> --run main|worktree|default` over the project's `run_mode`, never a hand edit; set it only when the human asks
28
29
  - before starting a run, `ai-factory gcf-harness gate --each <ids...> --json` says what the run gate refuses each item alone for now (it exits 0; a batch is still gated as a whole by `gate <ids...>`, exit 1); a session stops after `session_timeout_min` of `gcf/config.yml`, its item stays ready
29
30
  - ready items run in `priority:` order, lower first: rank a set of items with `ai-factory gcf prioritize <id> <id> …`, and put an id in `depends` only when the item uses that one's data or code: `ai-factory gcf depends <id> --add <ids>` or `--remove <ids>`, never a hand edit
30
31
  - what happened to an item before (who submitted, blocked, tuned or reranked it, and when) is `ai-factory gcf item history <id>`: its moves from git, an ended item's too
@@ -35,7 +36,7 @@ gcf_work:
35
36
  - 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`
36
37
  - a pillar changes only on the human's word: `ai-factory gcf pillar rename <from> <to>`, or `ai-factory gcf pillar retire <id> --reason "<why>"`
37
38
  - a new item's `--note "<text>"` (or `--note-file -` for several lines) says what its run should know, up to 4000 characters
38
- - in the project chat (the gcf-chat skill) a new item is proposed with the `propose_item_new` tool of the `gcf` MCP server, not made with `item new`: the human's click makes it
39
+ - in the project chat (the gcf-chat skill) a new item is proposed with the `propose_item_new` tool of the `gcf` MCP server, not made with `item new`: the human's click makes it; so are a block, a drop, a dependency change and the inbox's add, tag and erase, with their `propose_` tools and the `id` they act on
39
40
  - a chat thread bound to an item reads the item's file, its plan, its run's log and run chat first (the paths its context names), answers the question, and only then proposes a move
40
41
 
41
42
  gcf_forbidden: