antcolony

23.0 KB

1. #!/usr/bin/env node
2. // tests/fake-claude.mjs — stands in for `claude -p` in tests/e2e.mjs (COLONY_CLAUDE=<this file>), so the
3. // `work` process is tested end to end without spending Claude quota. It behaves like Claude Code 2.1.280
4. // with `--output-format json` + `verbose` (a LIST of messages, the `result` entry last).
5. // It is the WORKER, or — when `--json-schema` is the verdict schema — the CONTROLLER (mission 019).
6. // FAKE_CLAUDE_MODE worker: good (default) | nostructured | badreport | hang | falseclaim | longresult
7. // (falseclaim: the report claims `missing.txt`, which is never written; mission 027 longresult:
8. // a `result` of 124 characters + a test step on `.scratch/` → refused → the fix step)
9. // FAKE_DECIDED worker: the report's `decided` (a JSON list; default [] — mission 027)
10. // FAKE_QUESTIONS worker: the report's `questions` (a JSON list; default [] — mission 022)
11. // FAKE_OPEN worker: the report's `open` (a JSON list; default [] — mission 023)
12. // FAKE_WEEK_FILE `/usage`: the weekly percent (default 41; "none" = the answer has no weekly limit — mission 023)
13. // FAKE_CLAUDE_LOG worker: file with argv, cwd, stdin (the brief), whether COLONY_TOKEN_FILE was visible
14. // FAKE_CONTROLLER_MODE controller: pass (default) | fail | noevidence (says pass, one finding "no evidence")
15. // | nostructured | hang
16. // FAKE_QUESTION_RULINGS controller: comma list of rulings per report question (ask|decided|trivial|internal|packed; default ask)
17. // FAKE_CONTROLLER_LOG controller: the same log for the controller call
18. // Mission 020 (the `run` loop):
19. // `-p /usage` the quota probe: answers like Claude 2.1.280's local /usage command (cost 0) with
20. // `usage_report.rate_limits.limits[kind session].percent` = the number in FAKE_USAGE_FILE
21. // (re-read on every call, so a test can change it while `run` runs) or FAKE_USAGE_PERCENT (5)
22. // FAKE_CLAUDE_MODE=ratelimit worker: ends like a session evicted by the usage limit (rate_limit_event
23. // `rejected` with resetsAt = now + FAKE_RATELIMIT_RESET s (default 3), error result
24. // "You've hit your limit …", no structured output); `--resume <id>` then answers like `good`
25. // FAKE_CLAUDE_SLEEP seconds every worker / controller call waits before answering (default 0)
26. // FAKE_CLAUDE_SLEEP_DIR `<folder name>=<seconds>`: the calls run in that folder wait this long instead (antcolony#28)
27. // FAKE_LOG_DIR one JSON file per call: kind (usage/worker/controller), argv, pid, start/end ms, the
28. // COLONY_PORTS* env, cwd — to prove parallel sessions and their port ranges
29. // Mission 025 (the finalize step): a `--resume` whose stdin carries `colony-finalize:` is the FINALIZE call — it
30. // answers by FAKE_FINALIZE_MODE (good | nostructured | badreport | hang; default = the worker's own mode, so an old
31. // test whose worker had no report gets none again), writes no file, logs kind `finalize` (FAKE_LOG_DIR) and its
32. // argv/stdin to FAKE_FINALIZE_LOG. `hang` now writes the worker's file before it hangs (work was done, then time ran out).
33. // Mission 026:
34. // FAKE_COMPLETE worker / finalize: the report's `complete` (default true; "false" = half done)
35. // FAKE_LEAVE_SERVER comma list of call kinds (worker, finalize, controller) that LEAVE servers running on their port
36. // range (detached, like a crashed test's dev servers): worker → COLONY_PORT_FROM (own session env),
37. // +2 (env COLONY_SESSION=s-foreign-e2e: "another colony session"), +3 (ignores SIGTERM);
38. // finalize → +5; controller → +4. Each started server is appended to FAKE_SERVER_LOG (JSON lines
39. // { kind, role, port, pid }) — the e2e checks what the scheduler stopped and kills the rest itself.
40. // prompt cache (simulated): a session remembers its tool list (`--disallowedTools`, '' when none) from its first call;
41. // a `--resume` with the SAME tool list reads the cached prefix (cache read 20000, write 44, cost
42. // 0.0123), a DIFFERENT one re-writes it (cache read 0, write 20000, cost 0.1107 = 9×) — the
43. // effect seen on the first real finalize (mission 025), modelled, not measured.
44. import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from 'node:fs';
45. import { join } from 'node:path';
46. import { spawn } from 'node:child_process';
47. import { connect } from 'node:net';
49. const argv = process.argv.slice(2);
50. const opt = (n) => { const i = argv.indexOf(n); return i >= 0 ? argv[i + 1] : null; };
51. const started = Date.now();
52. const callLog = (kind, extra = {}) => {
53. if (!process.env.FAKE_LOG_DIR) return;
54. mkdirSync(process.env.FAKE_LOG_DIR, { recursive: true });
55. const f = join(process.env.FAKE_LOG_DIR, `${started}-${process.pid}-${kind}.json`);
56. writeFileSync(f, JSON.stringify({ kind, argv, pid: process.pid, start: started, end: extra.end || null, cwd: process.cwd(),
57. ports: process.env.COLONY_PORTS || null, portFrom: process.env.COLONY_PORT_FROM || null, portTo: process.env.COLONY_PORT_TO || null,
58. tokenFileVisible: 'COLONY_TOKEN_FILE' in process.env, stopFileVisible: 'COLONY_STOP_FILE' in process.env, ...extra }));
59. };
60. if (argv[0] === '-p' && argv[1] === '/usage') {
61. // the quota probe: a local command in the real Claude Code (no model call, cost 0)
62. let pct = Number(process.env.FAKE_USAGE_PERCENT || 5);
63. if (process.env.FAKE_USAGE_FILE && existsSync(process.env.FAKE_USAGE_FILE)) pct = Number(readFileSync(process.env.FAKE_USAGE_FILE, 'utf8').trim());
64. // mission 023: the weekly percent (default 41) from FAKE_WEEK_FILE (re-read per call); "none" = no weekly limit in the answer
65. let week = '41';
66. if (process.env.FAKE_WEEK_FILE && existsSync(process.env.FAKE_WEEK_FILE)) week = readFileSync(process.env.FAKE_WEEK_FILE, 'utf8').trim();
67. const resets = new Date(Date.now() + 3 * 3600e3).toISOString().replace('Z', '000+00:00');
68. const text = `You are currently using your subscription to power your Claude Code usage\n\nCurrent session: ${pct}% used · resets soon` + (week === 'none' ? '' : `\nCurrent week (all models): ${week}% used · resets later`);
69. process.stdout.write(JSON.stringify([
70. { type: 'system', subtype: 'init', permissionMode: opt('--permission-mode'), session_id: 'usage-probe' },
71. { type: 'assistant', message: { model: '<synthetic>', content: [{ type: 'text', text }] }, usage_report: { session: { total_cost_usd: 0 },
72. rate_limits: { limits: [{ kind: 'session', group: 'session', percent: pct, resets_at: resets }, ...(week === 'none' ? [] : [{ kind: 'weekly_all', group: 'weekly', percent: Number(week), resets_at: resets }])] } } },
73. { type: 'result', subtype: 'success', is_error: false, num_turns: 0, total_cost_usd: 0, result: text, local_command: 'usage', session_id: 'usage-probe' },
74. ]));
75. callLog('usage', { percent: pct, week, end: Date.now() });
76. process.exit(0);
77. }
78. const stdin = readFileSync(0, 'utf8');
79. // Mission 029: the LIBRARIAN (its schema has "supersedes"): reads the JSON input of the prompt and answers by markers in
80. // the creator's text — `#not` (or the text "test") → not a decision; `#global` → project "all"; `#project:<name>`;
81. // `#topic:<word-with-dashes>`; `#excerpt:"…"` → that quote (verbatim); `#paraphrase` → a quote NOT in the text; a text saying
82. // `i never said "X"` supersedes every current entry whose quote contains X. FAKE_LIBRARIAN_MODE good (default) |
83. // nostructured | badproject (answers a project that is not allowed) | hang; FAKE_LIBRARIAN_LOG = file (argv + stdin) per call.
84. // Mission 034: FAKE_LIBRARIAN_MODE_FILE (re-read per call, beats FAKE_LIBRARIAN_MODE) so a test can switch the mode while
85. // `run` runs. `ratelimit` = the shape Claude Code 2.1.280 gave LIVE on 2026-09-25 (librarian/calls/0muha3gdyxbp-result.json):
86. // rate_limit_event rejected (resetsAt = now + FAKE_RATELIMIT_RESET s, default 3), a synthetic assistant message with
87. // error "rate_limit" + "You've hit your session limit · resets 8:50pm (Europe/Vienna)", a result with subtype "success",
88. // is_error true, api_error_status 429, 0 tokens, $0, no structured output. `ratelimit-noreset` = the same WITHOUT the
89. // rate_limit_event and WITHOUT api_error_status (no reset time known; only the synthetic message + the text say it).
90. if (/"supersedes"/.test(opt('--json-schema') || '')) {
91. let lmode = process.env.FAKE_LIBRARIAN_MODE || 'good';
92. if (process.env.FAKE_LIBRARIAN_MODE_FILE && existsSync(process.env.FAKE_LIBRARIAN_MODE_FILE)) lmode = readFileSync(process.env.FAKE_LIBRARIAN_MODE_FILE, 'utf8').trim() || lmode;
93. const at = stdin.indexOf('## Input (JSON)');
94. const line = stdin.slice(at).split('\n').find(l => l.startsWith('{'));
95. const input = JSON.parse(line);
96. const text = input.creatorText.quotes.join('\n');
97. const resetsAt = Math.floor(Date.now() / 1000) + Number(process.env.FAKE_RATELIMIT_RESET || 3);
98. if (process.env.FAKE_LIBRARIAN_LOG) appendFileSync(process.env.FAKE_LIBRARIAN_LOG, JSON.stringify({ argv, cwd: process.cwd(), text, input, mode: lmode, at: Date.now(), resetsAt: lmode === 'ratelimit' ? resetsAt : null, tokenFileVisible: 'COLONY_TOKEN_FILE' in process.env }) + '\n');
99. callLog('librarian', { mode: lmode, text });
100. if (lmode === 'hang') { setInterval(() => {}, 1000); }
101. else if (lmode === 'ratelimit' || lmode === 'ratelimit-noreset') {
102. const sid = 'fake-librarian-limited';
103. const zero = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 };
104. const msg = "You've hit your session limit · resets 8:50pm (Europe/Vienna)";
105. const out = [{ type: 'system', subtype: 'init', permissionMode: opt('--permission-mode'), session_id: sid, model: 'claude-sonnet-5' }];
106. if (lmode === 'ratelimit') out.push({ type: 'rate_limit_event', rate_limit_info: { status: 'rejected', resetsAt, rateLimitType: 'five_hour', overageStatus: 'rejected', isUsingOverage: false, unifiedWindows: { five_hour: { utilization: 1, resetsAt }, seven_day: { utilization: 0.2, resetsAt: resetsAt + 86400 } } }, session_id: sid });
107. out.push({ type: 'assistant', message: { model: '<synthetic>', role: 'assistant', stop_reason: 'stop_sequence', usage: zero, content: [{ type: 'text', text: msg }] }, session_id: sid, error: 'rate_limit', is_api_error_message: true });
108. const result = { type: 'result', subtype: 'success', is_error: true, num_turns: 1, duration_ms: 488, duration_api_ms: 0, session_id: sid, total_cost_usd: 0, usage: zero, modelUsage: {}, permission_denials: [], terminal_reason: 'api_error', result: msg };
109. if (lmode === 'ratelimit') result.api_error_status = 429;
110. out.push(result);
111. process.stdout.write(JSON.stringify(out));
112. process.exitCode = 1;
113. }
114. else {
115. const not = /#not\b/.test(text) || /^test$/i.test(text.trim());
116. let project = /#global\b/.test(text) ? 'all' : ((text.match(/#project:(\S+)/) || [])[1] || (input.ticket ? input.ticket.project : 'all'));
117. if (lmode === 'badproject') project = 'no-such-project';
118. const topic = ((text.match(/#topic:([a-z-]+)/) || [])[1] || 'general').replace(/-/g, ' ');
119. // #paraphrase: a quote that is NOT in the text (a model that rephrased) — the scheduler must store the whole text
120. const quote = /#paraphrase\b/.test(text) ? 'the creator wants it teal' : ((text.match(/#excerpt:"([^"]+)"/) || [])[1] || '');
121. const never = (text.match(/i never said "([^"]+)"/i) || [])[1];
122. const supersedes = never ? input.currentEntries.filter(e => e.quote.includes(never)).map(e => e.id) : [];
123. // #longmeans: a reading of 400 characters on two lines (the scheduler makes it one line and clips it to 300)
124. const means = /#longmeans\b/.test(text) ? 'long reading line one ' + 'x'.repeat(180) + '\nline two ' + 'y'.repeat(200) : 'fake reading of: ' + text.replace(/\s+/g, ' ').slice(0, 60);
125. const answer = { decision: !not, project, topic, quote, means: not ? '' : means, supersedes, why: not ? 'fake: marked #not' : 'fake: a decision' };
126. const result = { type: 'result', subtype: lmode === 'nostructured' ? 'error_max_turns' : 'success', is_error: lmode === 'nostructured', num_turns: 1, duration_ms: 321, session_id: 'fake-librarian',
127. total_cost_usd: 0.0031, usage: { input_tokens: 5, output_tokens: 6, cache_read_input_tokens: 7, cache_creation_input_tokens: 8 }, modelUsage: { ['fake-' + opt('--model')]: { costUSD: 0.0031 } }, permission_denials: [] };
128. if (lmode !== 'nostructured') result.structured_output = answer;
129. process.stdout.write(JSON.stringify([{ type: 'system', subtype: 'init', permissionMode: opt('--permission-mode'), session_id: 'fake-librarian' }, result]));
130. process.exitCode = lmode === 'nostructured' ? 1 : 0;
131. }
132. } else {
133. const controller = /"verdict"/.test(opt('--json-schema') || '');
134. const resuming = opt('--resume');
135. let mode = controller ? (process.env.FAKE_CONTROLLER_MODE || 'pass') : (process.env.FAKE_CLAUDE_MODE || 'good');
136. if (resuming && mode === 'ratelimit') mode = 'good';
137. const finalize = !controller && !!resuming && stdin.includes('colony-finalize:');
138. if (finalize && process.env.FAKE_FINALIZE_MODE) mode = process.env.FAKE_FINALIZE_MODE;
139. const logFile = finalize ? (process.env.FAKE_FINALIZE_LOG || process.env.FAKE_CLAUDE_LOG) : controller ? process.env.FAKE_CONTROLLER_LOG : process.env.FAKE_CLAUDE_LOG;
140. if (logFile) writeFileSync(logFile, JSON.stringify({ argv, cwd: process.cwd(), brief: stdin, tokenFileVisible: 'COLONY_TOKEN_FILE' in process.env }, null, 1));
141. const callSession = controller ? (stdin.match(/`session` = `([^`]+)`/) || [])[1] : (stdin.match(/"session": "([^"]+)"/) || [])[1];
142. const kind = controller ? 'controller' : finalize ? 'finalize' : 'worker';
143. callLog(kind, { mode, resume: resuming, session: callSession || null });
144. let usage = { input_tokens: 11, output_tokens: 22, cache_read_input_tokens: 33, cache_creation_input_tokens: 44 };
145. let cost = controller ? 0.0045 : 0.0123;
146. const pm = opt('--permission-mode');
147. const sid = opt('--session-id') || resuming;
148. const rateEvent = (status, resetsAt) => ({ type: 'rate_limit_event', rate_limit_info: { status, resetsAt, rateLimitType: 'five_hour', unifiedWindows: { five_hour: { utilization: status === 'rejected' ? 1 : 0.05, resetsAt } } } });
149. // mission 025: like Claude Code 2.1.280, a RESUMED session reports the cost of the WHOLE session so far (cumulative
150. // total_cost_usd / modelUsage) — the fake keeps each Claude session's total in FAKE_STATE_DIR (default: .fake-claude-sessions/ in the cwd)
151. const tools = opt('--disallowedTools') || '';
152. const sessionTotal = (sid, add) => {
153. if (controller || !sid) return add;
154. const dir = process.env.FAKE_STATE_DIR || join(process.cwd(), '.fake-claude-sessions');
155. mkdirSync(dir, { recursive: true });
156. const f = join(dir, sid + '.json');
157. const st = resuming && existsSync(f) ? JSON.parse(readFileSync(f, 'utf8')) : { total: 0, tools };
158. // mission 026: the simulated prompt cache — a resume with another tool list misses the cached prefix
159. if (resuming) {
160. const hit = (st.tools || '') === tools;
161. usage = { ...usage, cache_read_input_tokens: hit ? 20000 : 0, cache_creation_input_tokens: hit ? 44 : 20000 };
162. if (!hit) add = Math.round(add * 9 * 1e6) / 1e6;
163. }
164. const total = Math.round((st.total + add) * 1e6) / 1e6;
165. writeFileSync(f, JSON.stringify({ total, tools: st.tools === undefined ? tools : st.tools }));
166. return total;
167. };
168. const answer = (structured, messages = []) => {
169. const limited = mode === 'ratelimit';
170. const total = sessionTotal(sid, cost);
171. const failed = mode === 'nostructured' || limited;
172. const resetsAt = Math.floor(Date.now() / 1000) + Number(process.env.FAKE_RATELIMIT_RESET || 3);
173. const result = { type: 'result', subtype: failed && !limited ? 'error_max_turns' : 'success', is_error: failed,
174. num_turns: 2, duration_ms: 1234, session_id: sid, total_cost_usd: total, usage,
175. modelUsage: { ['fake-' + opt('--model')]: { costUSD: total } }, permission_denials: [] };
176. if (limited) { result.result = "You've hit your limit · resets 8:19pm (Europe/Vienna)"; result.api_error_status = 429; }
177. if (!failed) result.structured_output = structured;
178. process.stdout.write(JSON.stringify([
179. { type: 'system', subtype: 'init', permissionMode: pm, session_id: sid },
180. { type: 'system', subtype: 'status', permissionMode: pm },
181. rateEvent(limited ? 'rejected' : 'allowed', resetsAt),
182. ...messages,
183. result,
184. ]));
185. process.stderr.write('fake claude: ' + kind + ' mode ' + mode + (resuming ? ' (resume ' + resuming + ')' : '') + '\n');
186. process.exitCode = failed ? 1 : 0;
187. callLog(kind + '-end', { mode, resume: resuming, end: Date.now(), limited, session: callSession || null });
188. };
190. // mission 026: servers a session leaves behind (detached; they outlive this fake) — waits until each one listens
191. const serverCode = (stubborn) => `const s=require('http').createServer((q,r)=>r.end('fake'));s.listen(Number(process.env.FAKE_PORT),'127.0.0.1');${stubborn ? "process.on('SIGTERM',()=>{});" : ''}setInterval(()=>{},1000);`;
192. const listening = (port) => new Promise(res => { const c = connect(port, '127.0.0.1'); c.on('connect', () => { c.destroy(); res(true); }); c.on('error', () => res(false)); });
193. const leaveServers = async () => {
194. const kinds = (process.env.FAKE_LEAVE_SERVER || '').split(',');
195. if (!kinds.includes(kind)) return;
196. const from = Number(process.env.COLONY_PORT_FROM);
197. if (!from) return;
198. // a real session starts its servers seconds after it began; the scheduler counts only processes started more than
199. // 50 ms after the session (clock precision margin) — so the fake waits a little too
200. await new Promise(r => setTimeout(r, 300));
201. const plan = kind === 'worker' ? [['own', 0, {}, false], ['foreign', 2, { COLONY_SESSION: 's-foreign-e2e' }, false], ['stubborn', 3, {}, true]]
202. : kind === 'finalize' ? [['own', 5, {}, false]] : [['own', 4, {}, false]];
203. for (const [role, off, env, stubborn] of plan) {
204. const port = from + off;
205. const c = spawn(process.execPath, ['-e', serverCode(stubborn), 'fake-left-server-' + kind + '-' + role], { detached: true, stdio: 'ignore', env: { ...process.env, ...env, FAKE_PORT: String(port) } });
206. c.unref();
207. if (process.env.FAKE_SERVER_LOG) appendFileSync(process.env.FAKE_SERVER_LOG, JSON.stringify({ kind, role, port, pid: c.pid }) + '\n');
208. for (let i = 0; i < 50 && !(await listening(port)); i++) await new Promise(r => setTimeout(r, 100));
209. }
210. };
211. const main = async () => {
212. await leaveServers();
213. if (mode === 'hang') {
214. // mission 025: the work was done, then time ran out (not in a finalize call: that one changes nothing)
215. const session = (stdin.match(/"session": "([^"]+)"/) || [])[1];
216. if (!controller && !finalize && session) writeFileSync('fake-worker-was-here.txt', session + '\n');
217. setInterval(() => {}, 1000);
218. }
219. else if (!controller) {
220. const ticket = (stdin.match(/"ticket": "([^"]+)"/) || [])[1];
221. const session = (stdin.match(/"session": "([^"]+)"/) || [])[1];
222. // "the work": a file in the cwd (= the project's dev folder) — the finalize step (mission 025) writes nothing
223. if (!finalize) writeFileSync('fake-worker-was-here.txt', session + '\n');
224. const report = {
225. ticket, session,
226. result: finalize ? 'The fake worker wrote its file; its report came from the finalize step.' : 'The fake worker wrote its file.',
227. complete: process.env.FAKE_COMPLETE !== 'false',
228. test: ['open the dev folder — `fake-worker-was-here.txt` is there', 'it holds the session id'],
229. done: ['created `fake-worker-was-here.txt`'],
230. verified: [{ claim: 'the file exists', command: 'cat fake-worker-was-here.txt', output: session }],
231. open: process.env.FAKE_OPEN ? JSON.parse(process.env.FAKE_OPEN) : [], issues: [], questions: process.env.FAKE_QUESTIONS ? JSON.parse(process.env.FAKE_QUESTIONS) : [],
232. decided: process.env.FAKE_DECIDED ? JSON.parse(process.env.FAKE_DECIDED) : [], running: [], refused: [],
233. };
234. if (mode === 'longresult') {
235. report.result = 'The fake worker wrote its file and this sentence is deliberately far too long for the creator to read in one glance, really.';
236. report.test = ['open .scratch/dev/fake-worker-was-here.txt', 'it holds the session id'];
237. }
238. if (mode === 'badreport') delete report.verified[0].output;
239. if (mode === 'falseclaim') {
240. report.done = ['created `missing.txt` with the content `hello`'];
241. report.verified = [{ claim: '`missing.txt` exists and says hello', command: 'cat missing.txt', output: 'hello' }];
242. report.issues = [{ project: 'hybriel', subject: 'fake issue of a false report', repro: 'r', observed: 'o', expected: 'e', blocks: false }];
243. }
244. // a transcript like Claude's verbose output: one tool call + its result
245. answer(report, [
246. { type: 'assistant', message: { content: [{ type: 'text', text: 'fake worker: writing the file' }, { type: 'tool_use', id: 't1', name: 'Bash', input: { command: 'cat fake-worker-was-here.txt' } }] } },
247. { type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 't1', content: session }] } },
248. ]);
249. } else {
250. // the controller: really look at the files the report names (like a real controller would)
251. const ticket = (stdin.match(/`ticket` = `([^`]+)`/) || [])[1];
252. const session = (stdin.match(/`session` = `([^`]+)`/) || [])[1];
253. const fenceStart = stdin.indexOf('## The worker report (report.json)');
254. const reportText = stdin.slice(fenceStart).split('\n').find(l => l.startsWith('{'));
255. const report = JSON.parse(reportText);
256. const findings = report.verified.map(v => {
257. const file = (v.command.match(/^cat (\S+)$/) || [])[1];
258. const there = file && existsSync(file);
259. return { claim: v.claim, about: 'verified', status: there ? 'ok' : 'false', check: file ? `test -f ${file}: ${there ? 'exists' : 'no such file'}` : 'not a cat command' };
260. });
261. let verdict = findings.every(f => f.status === 'ok') ? 'pass' : 'fail';
262. if (mode === 'fail') { verdict = 'fail'; findings.push({ claim: 'fake controller says: fail', about: 'other', status: 'false', check: 'FAKE_CONTROLLER_MODE=fail' }); }
263. if (mode === 'noevidence') { verdict = 'pass'; findings.push({ claim: report.done[0], about: 'done', status: 'no evidence', check: 'nothing in the session shows it' }); }
264. // antcolony#24: a ruling per question of the report; FAKE_QUESTION_RULINGS = comma list (default: ask for all)
265. const rl = (process.env.FAKE_QUESTION_RULINGS || '').split(',');
266. const questions = (report.questions || []).map((_, index) => { const ruling = rl[index] || 'ask'; return ruling === 'ask' || ruling === 'packed' ? { index, ruling, reason: 'fake ruling' } : { index, ruling, reason: 'fake ruling', answer: 'Use the obvious choice.' }; });
267. answer({ ticket, session, verdict, findings, questions, summary: `fake controller (${mode}): ${verdict}, ${findings.length} finding(s)` },
268. [{ type: 'assistant', message: { content: [{ type: 'tool_use', id: 'c1', name: 'Bash', input: { command: 'test -f …' } }] } }]);
269. }
270. };
271. let pause = Number(process.env.FAKE_CLAUDE_SLEEP || 0);
272. const byDir = (process.env.FAKE_CLAUDE_SLEEP_DIR || '').split('=');
273. if (byDir.length === 2 && process.cwd().split('/').pop() === byDir[0]) pause = Number(byDir[1]);
274. if (pause > 0) setTimeout(main, pause * 1000); else main();
275. }