antcolony

22.9 KB

1. // controller.hl — the controller step (ticket antcolony#1, mission 019; concept docs/scheduler-agent.md
2. // §1 "controller = one-shot LLM session that checks a report against what happened" and §2 "Report
3. // handling": validate → controller session → post or send back).
4. //
5. // runController: a SECOND one-shot Claude Code session after `work` got a schema-valid report, BEFORE
6. // anything is posted; same safety settings as the worker (permission mode, never bypass,
7. // `--permission-prompts none`, `--strict-mcp-config`, no token) + Edit/Write/NotebookEdit disallowed;
8. // in the same dev folder; stdin = templates/controller.md + the brief + the report + the worker's
9. // session as a compact transcript (from claude-result.json). `--json-schema`
10. // templates/verdict.schema.json → { ticket, session, verdict: pass|fail, findings[], summary }.
11. // Files: runs/<session>/controller-prompt.md, controller-result.json, controller-stderr.log,
12. // verdict.json; session.json gets `controller` (cost, usage, verdict).
13. // The CODE decides: a `pass` with a `false` / `no evidence` finding counts as `fail` ("overruled").
14. // postByVerdict: pass → `report --post`, the comment's machine line ends with `· controller pass` (mission 023:
15. // summary + findings stay in verdict.json); fail → a SHORT comment (what happened, ≤ 3 findings, the report's
16. // issues NOT filed), machine line `colony-verdict: <session> · fail · k of N`, ticket → `open`; the Nth fail on
17. // the same ticket (N = --max-fails / COLONY_MAX_FAILS, default 2; counted from the fail markers in
18. // the ticket's comments, one per session) → a creator question (inbox) instead, ticket → `on hold`.
19. // Idempotent: a session's fail comment is written once.
20. import { readFile, writeFile, exists } from 'hl:fs'
21. import { env } from 'hl:proc'
22. import { now, timestamp } from 'hl:time'
23. import { loadRegistry } from './registry.hl'
24. import { getJson, postJson, readToken, ticketPath, pageUrl, fileQuestion } from './tickets.hl'
25. import { postReport, parseRef, oneLine, refLabel, deployGate } from './report.hl'
26. import { runClaude, readClaude, usageLine, usageMeta, uuid, money, rateLimitOf, portEnv } from './claude.hl'
27. import { NL, readJson, isList, isObject, isString, nonEmpty, fenceFor } from './util.hl'
29. static VERDICT_KEYS = ['ticket' 'session' 'verdict' 'findings' 'summary' 'questions']
30. static REQUIRED_KEYS = ['ticket' 'session' 'verdict' 'findings' 'summary']
31. // antcolony#24: the check's ruling on each question of the report
32. static QUESTION_KEYS = ['index' 'ruling' 'reason' 'answer']
33. static RULINGS = ['ask' 'decided' 'trivial' 'internal' 'packed']
34. static FINDING_KEYS = ['claim' 'about' 'status' 'check']
35. static ABOUT = ['verified' 'done' 'other']
36. static STATUS = ['ok' 'false' 'no evidence' 'not checked']
37. static BAD = ['false' 'no evidence']
38. static TRANSCRIPT_MAX = 80000
40. static clip = (s, n) => {
41. if (s.length <= n) { return s }
42. return s.slice(0, n) + NL + '…[' + (s.length - n) + ' more characters]'
43. }
45. static fenced = (o, text) => {
46. let f = fenceFor(text)
47. o.push(f)
48. o.push(text)
49. o.push(f)
50. }
52. // the worker's session (claude-result.json with verbose output = the message list) as compact
53. // Markdown: its text, every tool call and every result, each clipped
54. static transcriptOf = (value) => {
55. if (!isList(value)) { return '_(the worker output is not a message list — no transcript; only the final result was kept)_' }
56. let o = []
57. let n = 0
58. for (m of value) {
59. if (isObject(m) && (m.type == 'assistant' || m.type == 'user') && m.message != null && isList(m.message.content)) {
60. for (c of m.message.content) {
61. if (isObject(c)) {
62. if (c.type == 'text' && nonEmpty(c.text)) {
63. n = n + 1
64. o.push('#### ' + n + ' · ' + m.type + ' text')
65. fenced(o, clip(c.text, 1500))
66. } else if (c.type == 'tool_use') {
67. n = n + 1
68. o.push('#### ' + n + ' · tool call `' + c.name + '`')
69. fenced(o, clip(JSON.stringify(c.input), 2000))
70. } else if (c.type == 'tool_result') {
71. n = n + 1
72. let t = isString(c.content) ? c.content : JSON.stringify(c.content)
73. o.push('#### ' + n + ' · tool result' + (c.is_error == true ? ' (ERROR)' : ''))
74. fenced(o, clip(t, 2000))
75. }
76. }
77. }
78. } else if (isObject(m) && m.type == 'result') {
79. n = n + 1
80. o.push('#### ' + n + ' · end: ' + m.subtype + ', ' + m.num_turns + ' turns' + (m.permission_denials != null && m.permission_denials.length > 0 ? ', ' + m.permission_denials.length + ' permission denial(s): ' + JSON.stringify(m.permission_denials) : ''))
81. }
82. }
83. if (n == 0) { return '_(no messages in the worker output)_' }
84. let t = o.join(NL)
85. // mission 025: a long session keeps its START and its END (the end is where the final checks are — the first live
86. // worker's session was 1.3 MB); before, only the first TRANSCRIPT_MAX characters were kept
87. if (t.length > TRANSCRIPT_MAX) {
88. let head = 30000
89. let tail = TRANSCRIPT_MAX - head
90. t = t.slice(0, head) + NL + NL + '…[' + (t.length - head - tail) + ' characters of the transcript left out here — the full session is in the run files (claude-result*.json)]' + NL + NL + t.slice(t.length - tail)
91. }
92. return t
93. }
95. static fill = (text, vars) => {
96. let s = text
97. for (k of vars.keys()) { s = s.replaceAll('{{' + k + '}}', vars[k]) }
98. return s
99. }
101. // the controller's whole input (stdin) → text
102. static promptOf = (c) => {
103. let o = []
104. o.push(fill(readFile('./templates/controller.md').trim(), { TICKET = c.ref SESSION = c.session FOLDER = c.folder RUNDIR = c.dir PORTS = c.ports }))
105. o.push('')
106. // mission 025: e.g. `salvage` — re-run nothing that writes
107. if (c.note != null && c.note != '') {
108. o.push('**' + c.note + '**')
109. o.push('')
110. }
111. o.push('## The worker report (report.json)')
112. o.push('')
113. fenced(o, readFile(c.dir + '/report.json'))
114. o.push('')
115. o.push("## The worker's session (compact transcript of claude-result.json)")
116. o.push('')
117. // a session that was parked and resumed (mission 020): the parts before each park first
118. let k = 1
119. while (exists(c.dir + '/claude-result.parked-' + k + '.json')) {
120. let pj = readJson(c.dir + '/claude-result.parked-' + k + '.json')
121. o.push('### Part ' + k + ' — until the session was parked')
122. o.push('')
123. o.push(pj.error != null ? '_(' + pj.error + ')_' : transcriptOf(pj.value))
124. o.push('')
125. o.push('### Part ' + (k + 1) + ' — resumed')
126. o.push('')
127. k = k + 1
128. }
129. // mission 025: a worker that ran out of steps / time, then the finalize step that only wrote the report
130. if (exists(c.dir + '/claude-result.before-finalize.json')) {
131. let bj = readJson(c.dir + '/claude-result.before-finalize.json')
132. o.push('### Part ' + k + ' — the worker, until it ran out of steps / time (claude-result.before-finalize.json)')
133. o.push('')
134. o.push(bj.error != null ? '_(' + bj.error + ')_' : transcriptOf(bj.value))
135. o.push('')
136. o.push('### Part ' + (k + 1) + ' — the finalize step: the same session resumed ONLY to write the report (it was told to change nothing)')
137. o.push('')
138. }
139. let rj = exists(c.dir + '/claude-result.json') ? readJson(c.dir + '/claude-result.json') : { error = 'no claude-result.json' }
140. o.push(rj.error != null ? '_(' + rj.error + ')_' : transcriptOf(rj.value))
141. o.push('')
142. o.push('## The brief the worker got (brief.md)')
143. o.push('')
144. fenced(o, readFile(c.dir + '/brief.md'))
145. o.push('')
146. o.push('(End of input. Check, then answer with the JSON verdict.)')
147. return o.join(NL)
148. }
150. // the verdict (the code is the authority, not the schema) → problems
151. static validateVerdict = (v, ref, session, nq) => {
152. let p = []
153. if (!isObject(v)) { return ['the verdict must be one JSON object'] }
154. for (k of v.keys()) { if (!VERDICT_KEYS.includes(k)) { p.push("(top): unknown field '" + k + "'") } }
155. for (k of REQUIRED_KEYS) { if (v[k] == null) { p.push("(top): field '" + k + "' is missing") } }
156. // antcolony#24: one ruling per question of the report (an old verdict.json without `questions` is fine when the report has none)
157. let qr = v.questions == null ? [] : v.questions
158. if (!isList(qr)) { p.push('questions: must be a list') } else {
159. let seen = []
160. let qi = 0
161. while (qi < qr.length) {
162. let q = qr[qi]
163. let at = 'questions[' + qi + ']'
164. if (!isObject(q)) { p.push(at + ': must be an object') } else {
165. for (k of q.keys()) { if (!QUESTION_KEYS.includes(k)) { p.push(at + ": unknown field '" + k + "'") } }
166. if (hlTypeName(q.index) != 'Number' || q.index < 0 || (nq != null && q.index >= nq)) { p.push(at + ": 'index' must be the number of a question of the report (0-based)") } else { seen.push(q.index) }
167. if (!RULINGS.includes(q.ruling)) { p.push(at + ": 'ruling' must be one of " + RULINGS.join(', ')) }
168. if (!nonEmpty(q.reason)) { p.push(at + ": 'reason' must be a non-empty string") }
169. if ((q.ruling == 'decided' || q.ruling == 'trivial' || q.ruling == 'internal') && !nonEmpty(q.answer)) { p.push(at + ": 'answer' (the decision, one line) is needed when the question is dropped") }
170. }
171. qi = qi + 1
172. }
173. if (nq != null) {
174. let n = 0
175. while (n < nq) { if (!seen.includes(n)) { p.push('questions: no ruling for question ' + n + ' of the report') } n = n + 1 }
176. }
177. }
178. if (v.ticket != null && v.ticket != ref) { p.push('ticket: "' + v.ticket + '" but the report is for ' + ref) }
179. if (v.session != null && v.session != session) { p.push('session: "' + v.session + '" but the report is session ' + session) }
180. if (v.verdict != null && v.verdict != 'pass' && v.verdict != 'fail') { p.push('verdict: must be pass or fail, not ' + JSON.stringify(v.verdict)) }
181. if (v.summary != null && !nonEmpty(v.summary)) { p.push('summary: must be a non-empty string') }
182. if (v.findings != null) {
183. if (!isList(v.findings)) { p.push('findings: must be a list') } else {
184. let i = 0
185. while (i < v.findings.length) {
186. let f = v.findings[i]
187. let at = 'findings[' + i + ']'
188. if (!isObject(f)) { p.push(at + ': must be an object') } else {
189. for (k of f.keys()) { if (!FINDING_KEYS.includes(k)) { p.push(at + ": unknown field '" + k + "'") } }
190. for (k of ['claim' 'check']) { if (!nonEmpty(f[k])) { p.push(at + ": '" + k + "' must be a non-empty string") } }
191. if (!ABOUT.includes(f.about)) { p.push(at + ": 'about' must be one of " + ABOUT.join(', ')) }
192. if (!STATUS.includes(f.status)) { p.push(at + ": 'status' must be one of " + STATUS.join(', ')) }
193. }
194. i = i + 1
195. }
196. }
197. }
198. return p
199. }
201. // how many questions the worker's report has (null when unreadable)
202. static questionCount = (dir) => {
203. let rj = readJson(dir + '/report.json')
204. if (rj.error != null || !isObject(rj.value) || !isList(rj.value.questions)) { return null }
205. return rj.value.questions.length
206. }
208. static packedOf = (v) => {
209. let o = []
210. if (v.questions != null) { for (q of v.questions) { if (q.ruling == 'packed') { o.push(q) } } }
211. return o
212. }
214. // antcolony#24: the report as it is posted — only the questions the check ruled `ask` become tickets; a dropped one
215. // (already decided / trivial / internal) becomes a `decided` line with the check's answer
216. static filterQuestions = (r, v) => {
217. if (v == null || v.questions == null || v.questions.length == 0) { return r }
218. let rulings = {}
219. for (q of v.questions) { rulings['' + q.index] = q }
220. let keep = []
221. let decided = []
222. if (r.decided != null) { for (d of r.decided) { decided.push(d) } }
223. let i = 0
224. while (i < r.questions.length) {
225. let q = rulings['' + i]
226. if (q == null || q.ruling == 'ask') { keep.push(r.questions[i]) }
227. else if (q.ruling != 'packed') { decided.push(oneLine(q.answer, 120)) }
228. i = i + 1
229. }
230. r.questions = keep
231. r.decided = decided
232. return r
233. }
235. // the effective verdict: a pass with a false / no-evidence finding is a fail → { verdict, overruled, bad }
236. static decide = (v) => {
237. let bad = []
238. for (f of v.findings) { if (BAD.includes(f.status)) { bad.push(f) } }
239. // antcolony#24: a packed question (more than one decision) sends the work back to be split
240. if (v.verdict == 'pass' && packedOf(v).length > 0) {
241. for (q of packedOf(v)) { bad.push({ claim = 'question ' + q.index + ' is packed: ' + q.reason about = 'other' status = 'false' check = q.reason }) }
242. return { verdict = 'fail' overruled = true bad = bad }
243. }
244. if (v.verdict == 'pass' && bad.length > 0) { return { verdict = 'fail' overruled = true bad = bad } }
245. return { verdict = v.verdict overruled = false bad = bad }
246. }
248. // runs the controller on a run folder. c = { dir, folder, ref, session, host, ports, bin, model,
249. // maxTurns, mode, timeout, budget }; meta = the session.json object (gets `controller`, written back).
250. // Calls done({ verdict (the JSON) | null, effective, overruled, reason, costUsd }) after the exit.
251. static runController = (c, meta, done) => {
252. let promptFile = c.dir + '/controller-prompt.md'
253. let outFile = c.dir + '/controller-result.json'
254. let errFile = c.dir + '/controller-stderr.log'
255. let verdictFile = c.dir + '/verdict.json'
256. writeFile(promptFile, promptOf(c), 384)
257. let cs = uuid()
258. let cm = { model = c.model maxTurns = c.maxTurns permissionMode = c.mode timeoutSeconds = c.timeout claude = c.bin claudeSession = cs started = timestamp(now()) outcome = 'running' }
259. meta.controller = cm
260. writeFile(c.dir + '/session.json', JSON.stringify(meta), 384)
261. let args = ['-p' '--output-format' 'json' '--json-schema' readFile('./templates/verdict.schema.json') '--model' c.model '--max-turns' c.maxTurns '--permission-mode' c.mode '--permission-prompts' 'none' '--strict-mcp-config' '--disallowedTools' 'Edit,Write,NotebookEdit' '--session-id' cs]
262. if (c.budget != null && c.budget != '') {
263. args.push('--max-budget-usd')
264. args.push(c.budget)
265. }
266. let p = runClaude({ label = 'controller' folder = c.folder inFile = promptFile outFile = outFile errFile = errFile bin = c.bin args = args timeout = c.timeout env = portEnv(c.ports) session = c.session ports = c.ports sandbox = c.sandbox }, (x) => {
267. cm.ended = timestamp(now())
268. cm.exit = x.ev.exit
269. // mission 026: what the controller left listening on its ports was stopped (lib/cleanup.sh) — logged here
270. if (x.cleanup.length > 0) { cm.cleanup = x.cleanup }
271. for (l of x.lines) { console.log(' controller ' + l) }
272. let rc = readClaude(outFile, x.ev.exit, x.timedOut, c.timeout, 'controller')
273. let reason = rc.reason
274. let rl = rateLimitOf(rc.value, rc.res)
275. let v = null
276. if (rc.cr != null) {
277. cm.permissionModeSeen = rc.cr.mode
278. if (rc.cr.mode != null && rc.cr.mode != c.mode) { console.log('controller: WARNING — asked for permission mode "' + c.mode + '", Claude reported "' + rc.cr.mode + '" (' + rc.cr.modes.join(', ') + ')') }
279. }
280. if (rc.res != null) {
281. let um = usageMeta(rc.res)
282. for (k of um.keys()) { cm[k] = um[k] }
283. console.log(usageLine('CONTROLLER USAGE', rc.res))
284. if (rc.res.structured_output == null) {
285. if (reason == null) { reason = 'no structured verdict (Claude: ' + rc.res.subtype + (rc.res.is_error ? ', error' : '') + ', ' + rc.res.num_turns + ' turns, exit ' + x.ev.exit + ')' }
286. } else {
287. v = rc.res.structured_output
288. writeFile(verdictFile, JSON.stringify(v), 384)
289. }
290. }
291. let eff = null
292. if (reason == null) {
293. let problems = validateVerdict(v, c.ref, c.session, questionCount(c.dir))
294. if (problems.length > 0) {
295. reason = 'the verdict was refused (' + problems.join('; ') + ')'
296. v = null
297. } else {
298. eff = decide(v)
299. }
300. }
301. if (reason != null) {
302. cm.outcome = 'no verdict: ' + reason
303. meta.controller = cm
304. writeFile(c.dir + '/session.json', JSON.stringify(meta), 384)
305. console.log('controller: NO VERDICT — ' + reason)
306. done({ verdict = null reason = reason costUsd = cm.costUsd limited = rl.limited resetMs = rl.resetMs limitText = rl.text })
307. return null
308. }
309. cm.verdict = v.verdict
310. cm.effective = eff.verdict
311. cm.overruled = eff.overruled
312. cm.outcome = 'verdict ' + eff.verdict
313. meta.controller = cm
314. writeFile(c.dir + '/session.json', JSON.stringify(meta), 384)
315. printVerdict(v, eff)
316. done({ verdict = v effective = eff.verdict overruled = eff.overruled reason = null costUsd = cm.costUsd limited = false })
317. return null
318. })
319. console.log('controller: started — ' + c.bin + ' -p --model ' + c.model + ' --max-turns ' + c.maxTurns + ' --permission-mode ' + c.mode + ' (Edit/Write off) in ' + c.folder + ' · pid ' + p.pid + ' · claude session ' + cs)
320. return p
321. }
323. static printVerdict = (v, eff) => {
324. console.log('VERDICT: ' + eff.verdict.toUpperCase() + (eff.overruled ? ' (the controller said pass, but ' + eff.bad.length + ' finding(s) are false / no evidence → fail)' : '') + ' — ' + v.findings.length + ' finding(s)')
325. for (f of v.findings) { console.log(' ' + f.status + ' — ' + f.about + ': ' + f.claim) }
326. }
328. // a verdict loaded from verdict.json (`check` on a run that has one) → the done() shape, or { reason }
329. static loadVerdict = (dir, ref, session) => {
330. let rj = readJson(dir + '/verdict.json')
331. if (rj.error != null) { return { verdict = null reason = rj.error } }
332. let problems = validateVerdict(rj.value, ref, session, questionCount(dir))
333. if (problems.length > 0) { return { verdict = null reason = 'verdict.json refused: ' + problems.join('; ') } }
334. let eff = decide(rj.value)
335. printVerdict(rj.value, eff)
336. return { verdict = rj.value effective = eff.verdict overruled = eff.overruled reason = null }
337. }
339. // ---- posting by the verdict ---------------------------------------------------------------------
340. // pass → the report comment's machine line ends with this (mission 023: the controller's summary + findings stay in
341. // runs/<session>/verdict.json — the creator reads the result, not the check)
342. static passNote = () => { return 'controller pass' }
344. // 1 → 'once', n → 'n times'
345. static times = (n) => { return n == 1 ? 'once' : n + ' times' }
347. // the fail markers in a ticket's comments → { sessions (distinct, in order), mine }
348. static failSessions = (events, session) => {
349. let out = []
350. let mine = false
351. for (e of events) {
352. if (e.kind == 'comment' && e.text != null) {
353. let i = e.text.indexOf('colony-verdict: ')
354. if (i >= 0) {
355. let rest = e.text.slice(i + 16)
356. let j = rest.indexOf(' · fail')
357. if (j > 0) {
358. let s = rest.slice(0, j)
359. if (s == session) { mine = true }
360. if (!out.includes(s)) { out.push(s) }
361. }
362. }
363. }
364. }
365. return { sessions = out mine = mine }
366. }
368. static maxFailsOf = (text) => {
369. let n = toNumber(text)
370. if (n == null || n < 1) { return 2 }
371. return n
372. }
374. // → { ok, outcome: 'posted' | 'ready to deploy' (mission 027) | 'half done' | 'sent back' | 'question' | 'nothing new' | 'post failed' | 'post refused', question }
375. // (mission 026: a passed report with `complete: false` → 'half done': short comment, ticket back to open)
376. static postByVerdict = (r, cv, meta, maxFails) => {
377. let reg = loadRegistry()
378. if (cv.effective == 'pass') {
379. let ok = postReport(filterQuestions(r, cv.verdict), reg, passNote())
380. // mission 027: a project with a live site → 'ready to deploy' (built; `./colony deployed` after the deploy)
381. return { ok = ok outcome = !ok ? 'post failed' : r.complete == false ? 'half done' : deployGate(r, reg) ? 'ready to deploy' : 'posted' }
382. }
383. return postFail(r, cv, meta, maxFails)
384. }
386. static postFail = (r, cv, meta, maxFails) => {
387. let v = cv.verdict
388. let tk = readToken()
389. if (tk.error != null) {
390. console.log('POST REFUSED — ' + tk.error)
391. return { ok = false outcome = 'post refused' }
392. }
393. let token = tk.token
394. let ref = parseRef(r.ticket)
395. let got = getJson(ticketPath(ref.project, ref.number))
396. if (got.status != 200) {
397. console.log('POST REFUSED — ticket ' + r.ticket + ' → ' + got.status)
398. return { ok = false outcome = 'post refused' }
399. }
400. let ticket = got.json.ticket
401. let url = pageUrl(ticket)
402. let fs = failSessions(got.json.events, r.session)
403. if (fs.mine) {
404. console.log(' HAVE the controller fail comment of session ' + r.session + ' on ' + r.ticket + ' — nothing written')
405. console.log('POSTED — nothing new (fail already filed)')
406. return { ok = true outcome = 'nothing new' }
407. }
408. let n = fs.sessions.length + 1
409. let all = []
410. for (s of fs.sessions) { all.push(s) }
411. all.push(r.session)
412. let question = null
413. if (n >= maxFails) {
414. // mission 023: a creator question like every other — subject "Question (<ref>): …", ≤ 5 short lines
415. let qs = []
416. qs.push('[' + refLabel(r.ticket) + '](' + url + ') failed its check ' + times(n) + ', so no worker starts on it any more (it is on hold).')
417. qs.push('')
418. qs.push('**What to do:** say in a comment there what you want, then set it back to open — or reject it.')
419. qs.push('')
420. qs.push('- Last check: ' + oneLine(v.summary, 150))
421. let q = fileQuestion(token, 'colony-verdict:' + r.session + ':question', 'Question (' + r.ticket + '): the work failed its check ' + times(n) + ' — how should it go on?', qs.join(NL), r.ticket)
422. if (q.error != null) {
423. console.log('POST FAILED — creator question: ' + q.error + ' — re-run to continue (idempotent)')
424. return { ok = false outcome = 'post failed' }
425. }
426. question = q.ticket
427. console.log((q.created ? ' FILED ' : ' HAVE ') + 'creator question ' + question.project + question.ref + ' ' + pageUrl(question))
428. }
429. // mission 023: the fail comment is short — what happened, what comes next, ≤ 3 findings; the checked report,
430. // all findings and the controller's summary stay in runs/<session>/ (verdict.json, report.json)
431. let o = []
432. if (question == null) { o.push((cv.overruled ? 'The result could not be confirmed' : 'The result did not hold up') + ' when it was checked — back to open for another try.') }
433. else { o.push('The result failed its check ' + times(n) + ' — on hold until you answer [' + question.project + ' ' + question.ref + '](' + pageUrl(question) + ').') }
434. let bad = []
435. for (f of v.findings) { if (f.status == 'false' || f.status == 'no evidence') { bad.push(f) } }
436. if (bad.length == 0) { bad = v.findings }
437. if (bad.length > 0) {
438. o.push('')
439. let k = 0
440. while (k < bad.length && k < 3) {
441. o.push('- ' + (bad[k].status == 'no evidence' ? 'Not shown: ' : bad[k].status == 'false' ? 'Not true: ' : '') + oneLine(bad[k].claim, 90))
442. k = k + 1
443. }
444. }
445. o.push('')
446. o.push('colony-verdict: ' + r.session + ' · fail · ' + n + ' of ' + maxFails + (cv.overruled ? ' · overruled' : ''))
447. let c = postJson(ticketPath(ref.project, ref.number) + '/comments', { text = o.join(NL) }, token)
448. if (c.status != 201) {
449. console.log('POST FAILED — comment on ' + r.ticket + ': ' + c.status + ' ' + c.text)
450. return { ok = false outcome = 'post failed' }
451. }
452. console.log(' POSTED the controller fail comment on ' + r.ticket + ' ' + url)
453. let st = c.json.ticket.state
454. let want = question == null ? 'open' : 'on hold'
455. if (st == want || st == 'confirmed' || st == 'rejected') {
456. console.log(' STATE left as "' + st + '"')
457. } else {
458. let text = question == null ? 'Back to open: the check failed (' + n + ' of ' + maxFails + ' tries).' : 'On hold: the check failed ' + times(n) + ' — waiting for your answer.'
459. let s = postJson(ticketPath(ref.project, ref.number) + '/state', { state = want text = text }, token)
460. if (s.status != 201) {
461. console.log('POST FAILED — state of ' + r.ticket + ': ' + s.status + ' ' + s.text)
462. return { ok = false outcome = 'post failed' }
463. }
464. console.log(' STATE ' + r.ticket + ': ' + st + ' → ' + want)
465. }
466. console.log('POSTED')
467. return { ok = true outcome = question == null ? 'sent back' : 'question' question = question fails = n }
468. }