antcolony

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