cockpit

1// Every function that takes `$` lives in this file: the engine follows `$`
2// only into functions declared beside the hooks. Pure helpers are in ./lib;
3// ./shared is the repo's shared/, copied in by scripts/sync-shared.sh.
4import { atom, read, update } from 'claude-code'
5import type { EngineInterface, Register } from 'claude-code'
6
7import type { ChangedFile, CodexChoice, GateRun, Incoming, Proposal, ReaderDoc } from '../types'
8import {
9  CODEX_CONTEXT_TEXT,
10  CONTEXT_TEXT,
11  KIND_TITLES,
12  PROPOSE_SPEC,
13  REPORT_SPEC,
14  REPORT_TRIES,
15  SAVE_PROMPT,
16  SAVE_SUGGEST_PERCENT,
17  answerMessage,
18  applyNumstat,
19  capProposals,
20  choiceLabel,
21  clip,
22  cockpitHeadline,
23  compactInstructions,
24  configChoice,
25  declineMessage,
26  diffArgv,
27  effortLabel,
28  failureMessage,
29  fileLabel,
30  filePathFor,
31  gateLook,
32  gateOutputOf,
33  gateSummary,
34  handoffKey,
35  handoffOf,
36  handoffSummary,
37  isDiffOk,
38  isGateCommand,
39  isHandoff,
40  isOpenProposal,
41  isUnfinished,
42  launchError,
43  needsYou,
44  openingPrompt,
45  parseCodexEvent,
46  parseModels,
47  parsePorcelain,
48  parseProposal,
49  parseReport,
50  planTitle,
51  proposalArgv,
52  proposalLook,
53  settleChoice,
54  settleCleared,
55  settleInterrupted,
56  splitDiff,
57  splitLines,
58  staleHandoffKeys,
59  stepPosition,
60  withSummaryAsk,
61} from './lib'
62import { AMBER, RED, toneColor } from './shared/colors'
63import { drawFooter, mergeFooter } from './shared/footer'
64import { STEP_ICONS } from './shared/glyphs'
65import { rtl } from './shared/rtl'
66import { bounded, cleanText, oneLine, pageBlocks, splitMarkdown, splitPlain, summarize } from './shared/text'
67import { formatAge } from './shared/time'
68
69const task = atom({ plugin: 'cockpit', key: 'task' } as const, '')
70const note = atom({ plugin: 'cockpit', key: 'note' } as const, '')
71const steps = atom({ plugin: 'cockpit', key: 'steps' } as const, [])
72const files = atom({ plugin: 'cockpit', key: 'files' } as const, [])
73const isFileListOpen = atom({ plugin: 'cockpit', key: 'isFileListOpen' } as const, false)
74const isGitRepo = atom({ plugin: 'cockpit', key: 'isGitRepo' } as const, false)
75const lastEditAt = atom({ plugin: 'cockpit', key: 'lastEditAt' } as const, 0)
76const gate = atom({ plugin: 'cockpit', key: 'gate' } as const, null)
77const gateOutput = atom({ plugin: 'cockpit', key: 'gateOutput' } as const, '')
78const reader = atom({ plugin: 'cockpit', key: 'reader' } as const, null)
79const isWorking = atom({ plugin: 'cockpit', key: 'isWorking' } as const, false)
80const incoming = atom({ plugin: 'cockpit', key: 'incoming' } as const, null)
81const hasSuggestedSave = atom({ plugin: 'cockpit', key: 'hasSuggestedSave' } as const, false)
82const proposals = atom({ plugin: 'cockpit', key: 'proposals' } as const, [])
83const models = atom({ plugin: 'cockpit', key: 'models' } as const, [])
84const proposalChoice = atom({ plugin: 'cockpit', key: 'proposalChoice' } as const, { model: 'gpt-5.5', effort: 'medium' })
85
86const PANE = 'cockpit'
87const OPEN = { id: PANE, title: 'Cockpit' }
88/** The person asked for it: bring the pane to the front (the surface may refuse the keys). */
89const SHOW = { ...OPEN, focus: true as const }
90const MAX_FILES = 15
91/** Even opened, the list stops here: one drawn tree holds at most 100000 characters. */
92const MAX_FILES_OPEN = 300
93// Each mod has a reader of its own; the id never shows (the tab shows the title).
94const READER = 'cockpit-reader'
95const SENT_NOTE = 'בסוף הפרומפט נוספה ל-Codex בקשה לפתוח את התשובה בתקציר של 2–3 שורות.'
96// The CLI inside the ChatGPT app tracks the account's models; the npm one can lag behind them.
97const BUNDLED_CODEX = '/Applications/ChatGPT.app/Contents/Resources/codex-cli/CodexCLI.app/Contents/MacOS/codex'
98/** Closed proposals kept below the open ones. */
99const CLOSED_PROPOSALS = 3
100
101let cwd = ''
102let codexBinary = 'codex'
103let isPumping = false
104/** The repo's top folder: git's paths are relative to it, so its commands run there. */
105let repoRoot = ''
106/** The project a handoff belongs to: the repo's top folder, else the session's folder. */
107let projectRoot = ''
108
109// ── work state ───────────────────────────────────────────────────────────
110
111/** Uncommitted changes from git, which also catches files a Bash command wrote. */
112async function refreshFiles($: EngineInterface) {
113  const top = await $.process.run(['git', 'rev-parse', '--show-toplevel'])
114  if (top.exitCode !== 0 || !top.stdout.trim()) {
115    await update($, isGitRepo, () => false)
116    return
117  }
118  repoRoot = top.stdout.trim()
119  await update($, isGitRepo, () => true)
120  const status = await $.process.run(['git', 'status', '--porcelain=v1', '-z', '-uall'])
121  if (status.exitCode !== 0) return
122  let numstat = await $.process.run(['git', 'diff', '--numstat', '-z', 'HEAD'])
123  if (numstat.exitCode !== 0) numstat = await $.process.run(['git', 'diff', '--numstat', '-z'])
124  const list = applyNumstat(parsePorcelain(status.stdout), numstat.exitCode === 0 ? numstat.stdout : '')
125  await update($, files, () => list)
126  // Edits Claude's Edit and Write tools never saw (a Bash command, Codex) still make a passed
127  // gate stale: the newest change on disk counts. A commit edits nothing, so it does not.
128  let newest = 0
129  for (const file of list.slice(0, MAX_FILES_OPEN)) {
130    try {
131      newest = Math.max(newest, (await $.fs.stat(`${repoRoot}/${file.path}`)).mtimeMs)
132    } catch {
133      // A deleted file has no time on disk.
134    }
135  }
136  if (newest > (await read($, lastEditAt))) await update($, lastEditAt, () => newest)
137}
138
139async function clearWork($: EngineInterface) {
140  await update($, task, () => '')
141  await update($, note, () => '')
142  await update($, steps, () => [])
143}
144
145/** The person cleared the task: nothing of it is handed to the next session. */
146async function clearTask($: EngineInterface) {
147  await clearWork($)
148  try {
149    const stored = await $.store.get(handoffKey(projectRoot))
150    if (isHandoff(stored) && stored.sessionId === (await $.session.id())) {
151      await $.store.set(handoffKey(projectRoot), { ...stored, isTaken: true })
152    }
153  } catch {
154    // A handoff is a convenience: a store that fails costs nothing else.
155  }
156}
157
158// ── handoff ──────────────────────────────────────────────────────────────
159
160async function findProjectRoot($: EngineInterface): Promise<string> {
161  try {
162    const top = await $.process.run(['git', 'rev-parse', '--show-toplevel'])
163    if (top.exitCode === 0 && top.stdout.trim()) return top.stdout.trim()
164  } catch {
165    // No git: the session's folder is the project.
166  }
167  return cwd
168}
169
170/** The work as it stands, kept for the next session in this project; only while there is any. */
171async function saveHandoff($: EngineInterface, sessionId?: string) {
172  if (!projectRoot) return
173  const work = {
174    task: await read($, task),
175    note: await read($, note),
176    steps: await read($, steps),
177    files: await read($, files),
178    gate: await read($, gate),
179    lastEditAt: await read($, lastEditAt),
180  }
181  if (!work.task.trim() && work.steps.length === 0) return
182  try {
183    const id = sessionId ?? (await $.session.id())
184    await $.store.set(handoffKey(projectRoot), handoffOf(work, id, projectRoot, await $.clock.now()))
185  } catch {
186    // A handoff is a convenience: a full store costs nothing else.
187  }
188}
189
190/** Offers the previous session's unfinished work here; old ones go, and a reload changes nothing. */
191async function loadIncoming($: EngineInterface) {
192  try {
193    const entries: [string, unknown][] = []
194    for (const key of await $.store.keys()) {
195      if (key.startsWith(handoffKey(''))) entries.push([key, await $.store.get(key)])
196    }
197    for (const key of staleHandoffKeys(entries, await $.clock.now())) await $.store.delete(key)
198    const stored = await $.store.get(handoffKey(projectRoot))
199    // A session with work of its own is offered no other: a reload must not put another
200    // session's snapshot over the task under way here.
201    const hasOwnWork = (await read($, task)).trim() !== '' || (await read($, steps)).length > 0
202    const offered =
203      !hasOwnWork && isHandoff(stored) && stored.sessionId !== (await $.session.id()) && !stored.isTaken && isUnfinished(stored)
204        ? stored
205        : null
206    await update($, incoming, (previous): Incoming | null => {
207      if (!offered) return null
208      const isSame = previous && previous.at === offered.at && previous.sessionId === offered.sessionId
209      return isSame ? previous : { ...offered, isQuiet: false }
210    })
211  } catch {
212    await update($, incoming, () => null)
213  }
214}
215
216/** Continue or ignore the previous session's work: either way it is not offered again. */
217async function takeHandoff($: EngineInterface, choice: 'continue' | 'ignore') {
218  const offered = await read($, incoming)
219  if (!offered) return
220  await update($, incoming, () => null)
221  try {
222    const stored = await $.store.get(handoffKey(offered.root))
223    if (isHandoff(stored) && stored.at === offered.at) await $.store.set(handoffKey(offered.root), { ...stored, isTaken: true })
224  } catch {
225    // Taken in this session's view all the same.
226  }
227  if (choice === 'continue') {
228    await fillPrompt($, openingPrompt(offered, await $.clock.now()), 'Handoff · פרומפט הפתיחה', offered.at)
229  }
230}
231
232/** Puts text in the prompt box for the person to read and send; after a draft, below it. */
233async function fillPrompt($: EngineInterface, text: string, title: string, at: number) {
234  let isFilled = false
235  try {
236    const draft = (await $.prompt.read()).text
237    const filled = await $.prompt.fill(draft.trim() ? { text: `\n\n${text}`, mode: 'append' } : { text, mode: 'replace' })
238    isFilled = filled.isFilled
239  } catch {
240    isFilled = false
241  }
242  if (!isFilled) {
243    const note = 'תיבת ה-prompt לא קיבלה את הטקסט — אפשר להעתיק אותו מכאן'
244    await openReader($, { title, kind: 'markdown', text, note, noteTone: 'warn', at })
245  }
246}
247
248/** The person saw the failed gate: it stops waiting for them, until the next run. */
249async function dismissGate($: EngineInterface) {
250  await update($, gate, run => (run ? { ...run, isDismissed: true } : run))
251}
252
253// ── the reader ───────────────────────────────────────────────────────────
254
255/** Puts a text in the reader and opens it there, under the text's own title. */
256async function openReader($: EngineInterface, doc: ReaderDoc) {
257  const title = oneLine(doc.title) || 'קריאה'
258  await update($, reader, () => ({ ...doc, title, page: 0 }))
259  await $.ui.open({ id: READER, title, focus: true })
260}
261
262async function turnPage($: EngineInterface, by: number) {
263  await update($, reader, doc => (doc ? { ...doc, page: Math.max(0, (doc.page ?? 0) + by) } : doc))
264}
265
266/** The last gate run's whole output; one Bash kept on disk is read from there. */
267async function openGate($: EngineInterface) {
268  const run = await read($, gate)
269  if (!run) return
270  let text = await read($, gateOutput)
271  let note: string | undefined
272  if (run.outputPath) {
273    try {
274      text = cleanText(String(await $.fs.read(run.outputPath)))
275    } catch {
276      note = `הפלט המלא לא נקרא (${run.outputPath}) — מוצג מה שנשמר`
277    }
278  }
279  const title = run.isOk ? 'פלט השער · עבר' : 'פלט השער · נכשל'
280  await openReader($, { title, kind: 'output', text, note, noteTone: 'warn', at: run.at })
281}
282
283/** A changed file's diff, fetched fresh each time it is opened. */
284async function openDiff($: EngineInterface, file: ChangedFile) {
285  const at = await $.clock.now()
286  const title = `diff · ${file.path.split('/').pop() || file.path}`
287  const fail = (note: string, text = '', noteTone?: 'failed') => openReader($, { title, kind: 'output', text, note, noteTone, at, file })
288  const where = repoRoot ? { cwd: repoRoot } : undefined
289  try {
290    const head = await $.process.run(['git', 'rev-parse', '--verify', '-q', 'HEAD'], where)
291    const argv = diffArgv(file, head.exitCode === 0)
292    if (!argv) return await fail('אין diff — התיקייה לא ב-git')
293    const ran = await $.process.run(argv, where)
294    if (!isDiffOk(argv, ran.exitCode)) {
295      return await fail(`✗ git diff נכשל (exit ${ran.exitCode}) — לחץ רענן כדי לנסות שוב`, ran.stderr || ran.stdout, 'failed')
296    }
297    const note = ran.isStdoutTruncated ? 'ה-diff ארוך מ-4MB — מוצג רק החלק הראשון' : undefined
298    await openReader($, { title, kind: 'diff', text: ran.stdout, note, noteTone: 'warn', at, file })
299  } catch (caught) {
300    const reason = caught instanceof Error ? caught.message : String(caught)
301    await fail(`✗ git לא רץ: ${reason} — לחץ רענן כדי לנסות שוב`, '', 'failed')
302  }
303}
304
305function relative(path: string): string {
306  return cwd && path.startsWith(`${cwd}/`) ? path.slice(cwd.length + 1) : path
307}
308
309// ── proposals to Codex ───────────────────────────────────────────────────
310
311async function resolveCodexBinary($: EngineInterface) {
312  try {
313    await $.fs.stat(BUNDLED_CODEX)
314    codexBinary = BUNDLED_CODEX
315  } catch {
316    codexBinary = 'codex'
317  }
318}
319
320/** The models on offer, and the choice a proposal starts with: the last one approved, else config.toml's. */
321async function loadModels($: EngineInterface) {
322  const home = await $.env.get('HOME')
323  if (!home) return
324  let offered: ReturnType<typeof parseModels> = []
325  try {
326    offered = parseModels(await $.fs.read(`${home}/.codex/models_cache.json`))
327  } catch {
328    offered = []
329  }
330  let fromConfig: Partial<CodexChoice> = {}
331  try {
332    fromConfig = configChoice(await $.fs.read(`${home}/.codex/config.toml`))
333  } catch {
334    fromConfig = {}
335  }
336  let stored: Partial<CodexChoice> = {}
337  try {
338    stored = ((await $.store.get('proposalChoice')) as Partial<CodexChoice> | undefined) ?? {}
339  } catch {
340    stored = {}
341  }
342  await update($, models, () => offered)
343  await update($, proposalChoice, () => settleChoice(offered, { ...fromConfig, ...stored }))
344}
345
346type CodexOutcome = { answer: string; error?: string }
347
348/** One read-only Codex run, streamed, with the model and effort it was given. */
349async function runCodexTurn($: EngineInterface, prompt: string, choice: CodexChoice): Promise<CodexOutcome> {
350  let answer = ''
351  let error: string | undefined
352  let isDone = false
353  let pending = ''
354  let stderr = ''
355  const handle = (line: string) => {
356    const event = parseCodexEvent(line)
357    if (event?.kind === 'message') answer = event.text
358    if (event?.kind === 'error') error = event.message
359    if (event?.kind === 'done') isDone = true
360  }
361  try {
362    const stream = $.process.spawn({ argv: proposalArgv(codexBinary, withSummaryAsk(prompt), choice), cwd: cwd || undefined })
363    for await (const chunk of stream) {
364      if (chunk.stream === 'stderr') {
365        stderr = (stderr + chunk.text).slice(-2000)
366        continue
367      }
368      const { lines, rest } = splitLines(pending, chunk.text)
369      pending = rest
370      for (const line of lines) handle(line)
371    }
372    // A last event written without a newline still counts.
373    if (pending.trim()) handle(pending)
374  } catch (caught) {
375    error = launchError(caught instanceof Error ? caught.message : String(caught))
376  }
377  if (!isDone && !error) error = clip(stderr.trim() || 'Codex נעצר בלי תשובה', 600)
378  return { answer, error }
379}
380
381/** Moves a proposal out of `from` only; reports whether this caller made the move. */
382async function moveProposal($: EngineInterface, id: number, from: Proposal['status'], change: Partial<Proposal>) {
383  let isMoved = false
384  await update($, proposals, list => {
385    isMoved = false
386    return list.map(p => {
387      if (p.id !== id || p.status !== from) return p
388      isMoved = true
389      return { ...p, ...change }
390    })
391  })
392  return isMoved
393}
394
395async function setProposal($: EngineInterface, id: number, change: Partial<Proposal>) {
396  await update($, proposals, list => list.map(p => (p.id === id ? { ...p, ...change } : p)))
397}
398
399/** The model or effort for one waiting proposal; it settles to what the model offers. */
400async function pickChoice($: EngineInterface, id: number, change: Partial<CodexChoice>) {
401  const offered = await read($, models)
402  const fallback = await read($, proposalChoice)
403  await update($, proposals, list =>
404    list.map(p => (p.id === id && p.status === 'pending' ? { ...p, choice: settleChoice(offered, { ...(p.choice ?? fallback), ...change }) } : p)),
405  )
406}
407
408/** Approving freezes the proposal's choice; that choice is where the next proposal starts. */
409async function approveProposal($: EngineInterface, id: number) {
410  const offered = await read($, models)
411  const fallback = await read($, proposalChoice)
412  // Read and frozen in one update, so a pick landing beside the press is not lost.
413  let choice = undefined as CodexChoice | undefined
414  await update($, proposals, list => {
415    choice = undefined
416    return list.map(p => {
417      if (p.id !== id || p.status !== 'pending') return p
418      choice = settleChoice(offered, p.choice ?? fallback)
419      return { ...p, status: 'approved' as const, choice }
420    })
421  })
422  if (!choice) return
423  await update($, proposalChoice, () => choice)
424  try {
425    await $.store.set('proposalChoice', choice)
426  } catch {
427    // The choice holds for this session all the same.
428  }
429}
430
431async function declineProposal($: EngineInterface, id: number) {
432  await moveProposal($, id, 'pending', { status: 'declined' })
433}
434
435/**
436 * Hands text to Claude as a turn of its own. A hook may drop it without throwing;
437 * either way the refusal is kept on the proposal and shown.
438 */
439async function deliver($: EngineInterface, id: number, text: string) {
440  let reason: string | undefined
441  try {
442    const sent = await $.prompt.submit({ text })
443    if (sent.drop !== undefined) reason = sent.drop || 'a hook dropped the prompt'
444  } catch (caught) {
445    reason = caught instanceof Error ? caught.message : String(caught)
446  }
447  if (reason === undefined) return
448  await setProposal($, id, { deliveryError: reason })
449  $.ui.toast(`התשובה של Codex לא הועברה ל-Claude (#${id}) — המלאה בפאנל Cockpit`)
450}
451
452async function runProposal($: EngineInterface, proposal: Proposal) {
453  if (!(await moveProposal($, proposal.id, 'approved', { status: 'running' }))) return
454  try {
455    const choice = proposal.choice ?? (await read($, proposalChoice))
456    const outcome = await runCodexTurn($, proposal.prompt, choice)
457    // A /clear while it ran: the conversation it answers is gone, so it stays in the pane.
458    const isCleared = (await read($, proposals)).find(p => p.id === proposal.id)?.isCleared === true
459    if (outcome.error) {
460      await setProposal($, proposal.id, { status: 'failed', answer: outcome.answer || outcome.error })
461      if (!isCleared) await deliver($, proposal.id, failureMessage(proposal.id, outcome.error, outcome.answer))
462    } else {
463      await setProposal($, proposal.id, { status: 'done', answer: outcome.answer })
464      $.ui.toast(`Codex ענה על הצעה #${proposal.id}`)
465      if (!isCleared) await deliver($, proposal.id, answerMessage(proposal.id, proposal.kind, outcome.answer))
466    }
467  } catch (caught) {
468    await setProposal($, proposal.id, {
469      status: 'failed',
470      answer: caught instanceof Error ? caught.message : String(caught),
471    })
472  }
473}
474
475/**
476 * Tells Claude the person declined. Marked told only once the row is stored; a
477 * hook's refusal is final, a call that threw is tried again a few times. Either
478 * way the card says when Claude was not told.
479 */
480async function reportDecline($: EngineInterface, p: Proposal) {
481  let refusal: string | undefined
482  let isFinal = false
483  try {
484    const appended = await $.session.append({ message: { type: 'user', content: [{ type: 'text', text: declineMessage(p.id) }] } })
485    if (appended.deny === undefined) {
486      await setProposal($, p.id, { isReported: true })
487      return
488    }
489    refusal = appended.deny || 'a hook refused the message'
490    isFinal = true
491  } catch (caught) {
492    refusal = caught instanceof Error ? caught.message : String(caught)
493  }
494  const tries = (p.reportTries ?? 0) + 1
495  if (isFinal || tries >= REPORT_TRIES) {
496    await setProposal($, p.id, { isReported: true, reportTries: tries, deliveryError: refusal })
497  } else {
498    await setProposal($, p.id, { reportTries: tries })
499  }
500}
501
502/**
503 * The session's runner: a clock started at `session.start` calls it, so a Codex
504 * run outlives the press that approved it. One run at a time.
505 */
506async function pump($: EngineInterface) {
507  if (isPumping) return
508  isPumping = true
509  try {
510    for (const p of await read($, proposals)) {
511      if (p.status === 'declined' && !p.isReported) await reportDecline($, p)
512    }
513    const approved = (await read($, proposals)).find(p => p.status === 'approved')
514    if (approved) await runProposal($, approved)
515  } finally {
516    isPumping = false
517  }
518}
519
520// ── hooks ────────────────────────────────────────────────────────────────
521
522export const register: Register = on => {
523  on('session.start', async ($, e, next) => {
524    cwd = e.cwd
525    // State outlives a reload: an older gate run gets the fields it lacks; a reader of another shape goes.
526    await update($, gate, (current): GateRun | null => {
527      const old = current as Partial<GateRun> | null
528      if (!old || typeof old.command !== 'string') return null
529      return {
530        ...(old as GateRun),
531        summary: Array.isArray(old.summary) ? old.summary : [],
532        isWhole: old.isWhole === true,
533        isDismissed: old.isDismissed === true,
534      }
535    })
536    await update($, isWorking, working => working === true)
537    await update($, hasSuggestedSave, shown => shown === true)
538    projectRoot = await findProjectRoot($)
539    await loadIncoming($)
540    await update($, reader, doc =>
541      doc && typeof doc.text === 'string' && typeof doc.title === 'string' && typeof doc.kind === 'string' ? doc : null,
542    )
543    await $.command.register({ name: 'cockpit', description: 'Open the Cockpit pane: task, steps, files, gate' })
544    await $.tool.register(REPORT_SPEC)
545    await $.tool.register(PROPOSE_SPEC)
546    await resolveCodexBinary($)
547    await loadModels($)
548    // A run a reload cut off ends: nothing runs it again, so it fails and Claude is told.
549    let interrupted: number[] = []
550    await update($, proposals, current => {
551      const settled = settleInterrupted(Array.isArray(current) ? current : [])
552      interrupted = settled.interrupted
553      return settled.proposals
554    })
555    for (const id of interrupted) {
556      await deliver($, id, failureMessage(id, 'the run was cut off when the Cockpit mod reloaded', ''))
557    }
558    void refreshFiles($)
559    // Files change outside Claude's turns too (the person's editor, another session): look
560    // again every half minute, and draw again, since the ages shown move with the clock.
561    $.clock.every(30_000, async () => {
562      await refreshFiles($)
563      $.ui.invalidate('ui.render')
564    })
565    $.clock.every(1000, () => {
566      void pump($)
567    })
568    void $.ui.open(OPEN)
569    return next(e)
570  })
571
572  on('command.run', { command: 'cockpit' }, async $ => {
573    await $.ui.open(SHOW)
574    return { text: 'Cockpit פתוח.' }
575  })
576
577  // A sub-agent's run raises no turn.start; its turn.complete carries an agentId.
578  on('turn.start', async ($, e, next) => {
579    await update($, isWorking, () => true)
580    return next(e)
581  })
582
583  on('turn.complete', async ($, e, next) => {
584    if (!e.agentId) {
585      await update($, isWorking, () => false)
586      await saveHandoff($)
587      void refreshFiles($)
588    }
589    return next(e)
590  })
591
592  // A session ends (exit, resume, /clear): its work is kept for the next one. After a
593  // /clear no session.start comes, so the work is offered here at once and the pane cleared.
594  // The whole chain shares a short bound: state and store writes only.
595  on('session.end', async ($, e, next) => {
596    await saveHandoff($, e.sessionId)
597    if (e.reason === 'clear') {
598      try {
599        const stored = await $.store.get(handoffKey(projectRoot))
600        if (isHandoff(stored) && !stored.isTaken && isUnfinished(stored)) {
601          await update($, incoming, () => ({ ...stored, isQuiet: false }))
602        }
603      } catch {
604        // Nothing to offer.
605      }
606      await clearWork($)
607      await update($, hasSuggestedSave, () => false)
608      await update($, proposals, current => settleCleared(Array.isArray(current) ? current : []))
609    }
610    return next(e)
611  })
612
613  // A compaction keeps the task and the plan word for word, and saves them first.
614  on('session.compact', async ($, e, next) => {
615    if (e.agentId) return next(e)
616    await saveHandoff($)
617    const extra = compactInstructions({ task: await read($, task), note: await read($, note), steps: await read($, steps) })
618    if (!extra) return next(e)
619    return next({ ...e, instructions: e.instructions ? `${e.instructions}\n\n${extra}` : extra })
620  })
621
622  // The person wrote something of their own: the handoff stops waiting for them.
623  on('prompt.submit', async ($, e, next) => {
624    if (e.origin.kind === 'composer' || e.origin.kind === 'bridge') {
625      const offered = await read($, incoming)
626      if (offered && !offered.isQuiet) await update($, incoming, () => ({ ...offered, isQuiet: true }))
627    }
628    return next(e)
629  })
630
631  // Once per conversation, as the context fills: suggest saving what this session learned.
632  // It counts only once shown: the box refuses while it holds text or a turn runs.
633  on('session.measure', async ($, e, next) => {
634    const percent = e.context.percent
635    if (percent !== undefined && percent >= SAVE_SUGGEST_PERCENT && !(await read($, hasSuggestedSave))) {
636      try {
637        if ((await $.prompt.suggest({ text: SAVE_PROMPT })).isShown) await update($, hasSuggestedSave, () => true)
638      } catch {
639        // Tried again at the next measure.
640      }
641    }
642    return next(e)
643  })
644
645  on('prompt.context', async ($, e, next) => {
646    const result = await next(e)
647    return {
648      ...result,
649      blocks: [...result.blocks, { name: 'cockpit', text: CONTEXT_TEXT }, { name: 'codex', text: CODEX_CONTEXT_TEXT }],
650    }
651  })
652
653  // Proposing only queues a card; the person's press in the Cockpit pane is the approval.
654  on('tool.check', { tool: 'mcp__cockpit__propose' }, () => ({ decision: 'allow' as const }))
655
656  on('tool.call', { tool: 'mcp__cockpit__propose' }, async ($, e) => {
657    const parsed = parseProposal(e as unknown as Record<string, unknown>)
658    if (typeof parsed === 'string') return { deny: parsed }
659    let id = 0
660    // The default as it stands now is this proposal's own: a later approval does not move it.
661    const choice = await read($, proposalChoice)
662    await update($, proposals, current => {
663      id = current.reduce((max, p) => Math.max(max, p.id), 0) + 1
664      return capProposals([...current, { id, ...parsed, status: 'pending' as const, choice }])
665    })
666    $.ui.toast(`Claude מבקש לשלוח ל-Codex: ${KIND_TITLES[parsed.kind]}. האישור בפאנל Cockpit`)
667    return {
668      result:
669        `Proposal #${id} is waiting for the user's approval in the Cockpit pane. Do not wait or poll: ` +
670        "continue or end your turn. Codex's answer, or the user's decline, will reach you as a message.",
671    }
672  })
673
674  // The report tool only updates this plugin's own pane, so it never needs a prompt.
675  on('tool.check', { tool: 'mcp__cockpit__report' }, () => ({ decision: 'allow' as const }))
676
677  on('tool.call', { tool: 'mcp__cockpit__report' }, async ($, e) => {
678    const report = parseReport(e as unknown as Record<string, unknown>)
679    if (report.task !== undefined) await update($, task, () => report.task ?? '')
680    if (report.note !== undefined) await update($, note, () => report.note ?? '')
681    if (report.steps !== undefined) await update($, steps, () => report.steps ?? [])
682    // A task of its own here: the previous session's is no longer offered.
683    if (report.task?.trim()) await update($, incoming, () => null)
684    await saveHandoff($)
685    return { result: 'Cockpit updated.' }
686  })
687
688  on('tool.call', { tool: ['Edit', 'Write', 'NotebookEdit'] }, async ($, e, next) => {
689    const ran = await next(e)
690    if (ran.deny !== undefined || ran.isError) return ran
691    const editedAt = await $.clock.now()
692    await update($, lastEditAt, () => editedAt)
693    if (!(await read($, isGitRepo))) {
694      const input = e as unknown as { file_path?: string; notebook_path?: string }
695      const path = relative(input.notebook_path ?? input.file_path ?? '')
696      const edited: ChangedFile = { path, status: 'ed', added: 0, removed: 0 }
697      await update($, files, list => [...list.filter(f => f.path !== path), edited])
698    }
699    return ran
700  })
701
702  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
703    const ran = await next(e)
704    // Typed `unknown` where the engine's own declarations leave Bash's input loose.
705    const command = String(e.command ?? '')
706    if (ran.deny !== undefined || !isGateCommand(command)) return ran
707    const output = ran.result as { backgroundTaskId?: string; interrupted?: boolean } | undefined
708    if (output?.backgroundTaskId) return ran
709    const isOk = ran.isError !== true && output?.interrupted !== true
710    const kept = gateOutputOf(ran)
711    const summary = gateSummary(kept.text, isOk)
712    const isWhole = !kept.path && summary.join('\n') === kept.text.trim()
713    await update($, gateOutput, () => kept.text)
714    const ranAt = await $.clock.now()
715    await update($, gate, () => ({
716      command,
717      isOk,
718      at: ranAt,
719      summary,
720      isWhole,
721      isDismissed: false,
722      ...(kept.path ? { outputPath: kept.path } : {}),
723    }))
724    await saveHandoff($)
725    return ran
726  })
727
728  on('tool.call', { tool: 'ExitPlanMode' }, async ($, e, next) => {
729    const ran = await next(e)
730    const plan = (ran.result as { plan?: string | null } | undefined)?.plan
731    const title = ran.deny === undefined && plan ? planTitle(plan) : undefined
732    if (title && !(await read($, task))) await update($, task, () => title)
733    return ran
734  })
735
736  // The layout reads right to left: rows are `row-reverse`, columns hug the right
737  // edge, and Hebrew runs are isolated as RTL (`rtl`).
738
739  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
740    const table = $.ui.resolve(e)
741    const { Box, Text, Button, Markdown } = table
742    // Each surface's table may carry an element it then drops; decide by surface.
743    const Select = e.surface !== 'mobile' && 'Select' in table ? table.Select : undefined
744    const now = await $.clock.now()
745    const columns = e.props.bodyColumns
746    // A framed card gives up its border and padding.
747    const cardColumns = Math.max(10, columns - 4)
748
749    const heading = (text: string) => <Text bold>{rtl(text)}</Text>
750
751    const currentTask = await read($, task)
752    const currentNote = await read($, note)
753    const stepList = await read($, steps)
754    const fileList = await read($, files)
755    const showAllFiles = await read($, isFileListOpen)
756    const inGit = await read($, isGitRepo)
757    const editedAt = await read($, lastEditAt)
758    const lastGate = await read($, gate)
759    const working = await read($, isWorking)
760    const offered = await read($, incoming)
761    const proposalList = await read($, proposals)
762    const offeredModels = await read($, models)
763    const defaultChoice = await read($, proposalChoice)
764    const waitState = { isWorking: working, steps: stepList, gate: lastGate, incoming: offered, proposals: proposalList }
765    const hero = cockpitHeadline(waitState)
766    // A waiting proposal is always framed; the gate and the handoff are framed by what waits beside it.
767    const waiting = needsYou({ ...waitState, proposals: [] })
768    const position = stepPosition(stepList)
769    const doneCount = stepList.filter(s => s.status === 'done').length
770    const look = gateLook(lastGate, editedAt, now)
771    const taskSummary = summarize(currentTask, { columns })
772    const noteSummary = summarize(currentNote, { columns })
773    const openProposals = proposalList.filter(isOpenProposal)
774    const closedProposals = proposalList.filter(p => !isOpenProposal(p)).slice(-CLOSED_PROPOSALS)
775
776    /** A press that opens `text` whole in the reader; none when the summary already is all of it. */
777    const readAll = (key: string, title: string, text: string, isWhole: boolean, note?: string) =>
778      isWhole ? null : (
779        <Button key={key} label="קרא הכל" plain onPress={() => openReader($, { title, kind: 'markdown', text, note, at: now })} />
780      )
781
782    // One proposal's card: framed while it waits for the person, who picks the model and approves.
783    const proposalCard = (p: Proposal) => {
784      const status = proposalLook(p.status, { hasDeliveryError: Boolean(p.deliveryError), isCleared: p.isCleared })
785      const isPending = p.status === 'pending'
786      const width = isPending ? cardColumns : columns
787      const choice = p.choice ?? defaultChoice
788      const pickedModel = offeredModels.find(m => m.slug === choice.model)
789      const prompt = summarize(p.prompt, { columns: width })
790      return (
791        <Box
792          flexDirection="column"
793          alignItems="flex-end"
794          key={`proposal-${p.id}`}
795          {...(isPending ? { borderStyle: 'round', borderColor: AMBER, paddingX: 1, width: '100%' } : {})}
796        >
797          <Box flexDirection="row-reverse" gap={1} flexWrap="wrap">
798            <Text bold>{rtl(`#${p.id} ${KIND_TITLES[p.kind]}`)}</Text>
799            <Text color={toneColor(status.tone)} dimColor={status.tone === 'muted'}>
800              {rtl(status.text)}
801            </Text>
802            {!isPending && p.choice && p.status !== 'declined' && p.status !== 'cleared' ? (
803              <Text dimColor>{rtl(`· ${choiceLabel(offeredModels, p.choice)}`)}</Text>
804            ) : null}
805          </Box>
806          {p.why ? <Text wrap="wrap">{rtl(bounded(p.why, 1000))}</Text> : null}
807          {isPending ? (
808            <Box flexDirection="column" alignItems="flex-end">
809              <Text dimColor>{rtl('הפרומפט שיישלח:')}</Text>
810              <Markdown text={prompt.text} dimColor />
811              {readAll(`read-prompt-${p.id}`, `#${p.id} · הפרומפט ל-Codex`, p.prompt, prompt.isWhole, SENT_NOTE)}
812              {Select && offeredModels.length > 0 ? (
813                <Box flexDirection="row-reverse" gap={2} flexWrap="wrap">
814                  <Select
815                    key={`proposal-model-${p.id}`}
816                    label="מודל"
817                    value={choice.model}
818                    options={offeredModels.map(m => ({ value: m.slug, label: m.name }))}
819                    onSelect={value => pickChoice($, p.id, { model: value })}
820                  />
821                  <Select
822                    key={`proposal-effort-${p.id}`}
823                    label="חשיבה"
824                    value={choice.effort}
825                    options={(pickedModel?.efforts ?? [choice.effort]).map(effort => ({
826                      value: effort,
827                      label: effortLabel(effort),
828                    }))}
829                    onSelect={value => pickChoice($, p.id, { effort: value })}
830                  />
831                </Box>
832              ) : (
833                <Text dimColor>{rtl(choiceLabel(offeredModels, choice))}</Text>
834              )}
835              <Box flexDirection="row-reverse" gap={1} flexWrap="wrap">
836                <Button key={`pane-approve-${p.id}`} label="אשר ושלח ל-Codex" variant="primary" onPress={() => approveProposal($, p.id)} />
837                <Button key={`pane-decline-${p.id}`} label="סרב" variant="secondary" onPress={() => declineProposal($, p.id)} />
838              </Box>
839            </Box>
840          ) : (
841            <Button
842              key={`read-prompt-${p.id}`}
843              label="הפרומפט שנשלח"
844              plain
845              onPress={() => openReader($, { title: `#${p.id} · הפרומפט ל-Codex`, kind: 'markdown', text: p.prompt, note: SENT_NOTE, at: now })}
846            />
847          )}
848          {p.answer && (p.status === 'done' || p.status === 'failed') ? (
849            <Box flexDirection="column" alignItems="flex-end">
850              <Markdown text={summarize(p.answer, { columns }).text} dimColor />
851              {readAll(`read-answer-${p.id}`, `#${p.id} · התשובה של Codex`, p.answer, summarize(p.answer, { columns }).isWhole)}
852            </Box>
853          ) : null}
854          {p.deliveryError ? (
855            <Text color={RED} wrap="wrap">
856              {rtl(
857                p.status === 'declined'
858                  ? `${bounded(p.deliveryError, 500)} — Claude לא יודע שסירבת`
859                  : `${bounded(p.deliveryError, 500)} — התשובה מוצגת כאן; אפשר להעתיק אותה ל-Claude`,
860              )}
861            </Text>
862          ) : null}
863        </Box>
864      )
865    }
866
867    // The gate's lines; framed while a failure waits for the person, with a way to mark it handled.
868    const isGateFramed = waiting === 'gate'
869    const gateBody = (
870      <Box
871        flexDirection="column"
872        alignItems="flex-end"
873        {...(isGateFramed ? { borderStyle: 'round', borderColor: AMBER, paddingX: 1, width: '100%' } : {})}
874      >
875        <Text color={toneColor(look.tone)} dimColor={look.tone === 'muted'}>
876          {rtl(look.text)}
877        </Text>
878        {lastGate ? (
879          <Text dimColor wrap="truncate-end">
880            {oneLine(lastGate.command, isGateFramed ? cardColumns : columns)}
881          </Text>
882        ) : null}
883        {(lastGate?.summary ?? []).map(line => (
884          <Text dimColor wrap="truncate-end">
885            {line}
886          </Text>
887        ))}
888        {lastGate ? (
889          <Box flexDirection="row-reverse" gap={1} flexWrap="wrap">
890            {!lastGate.isWhole ? <Button key="read-gate" label="קרא הכל" plain onPress={() => openGate($)} /> : null}
891            {isGateFramed ? (
892              <Button key="gate-dismiss" label="סמן כטופל" variant="secondary" onPress={() => dismissGate($)} />
893            ) : null}
894          </Box>
895        ) : null}
896      </Box>
897    )
898
899    return (
900      <Box flexDirection="column" alignItems="flex-end" gap={1}>
901        {/* The Hero: what is going on, in one line. */}
902        <Text
903          color={hero.tone === 'plain' ? undefined : toneColor(hero.tone)}
904          dimColor={hero.tone === 'muted'}
905          bold={hero.tone !== 'muted'}
906          wrap="truncate-end"
907        >
908          {rtl(`${hero.glyph} ${hero.text}`)}
909        </Text>
910
911        {/* Proposals to Codex still open: waiting for the person, queued or running. */}
912        {openProposals.length > 0 ? (
913          <Box flexDirection="column" alignItems="flex-end" gap={1} width="100%">
914            {heading('הצעות ל-Codex')}
915            {openProposals.map(proposalCard)}
916          </Box>
917        ) : null}
918
919        {/* A previous session's unfinished work: framed while it waits for the person. */}
920        {offered ? (
921          <Box
922            flexDirection="column"
923            alignItems="flex-end"
924            {...(waiting === 'handoff' ? { borderStyle: 'round', borderColor: AMBER, paddingX: 1, width: '100%' } : {})}
925          >
926            <Text bold color={offered.isQuiet ? undefined : AMBER} dimColor={offered.isQuiet}>
927              {rtl(`Handoff מהסשן הקודם · ${formatAge(offered.at, now)}`)}
928            </Text>
929            <Text wrap="wrap" dimColor={offered.isQuiet}>
930              {rtl(handoffSummary(offered))}
931            </Text>
932            <Box flexDirection="row-reverse" gap={1} flexWrap="wrap">
933              <Button key="handoff-continue" label="המשך מכאן" variant="secondary" onPress={() => takeHandoff($, 'continue')} />
934              <Button
935                key="handoff-read"
936                label="קרא הכל"
937                plain
938                onPress={() =>
939                  openReader($, { title: 'Handoff · פרומפט הפתיחה', kind: 'markdown', text: openingPrompt(offered, now), at: offered.at })
940                }
941              />
942              <Button key="handoff-ignore" label="התעלם" plain onPress={() => takeHandoff($, 'ignore')} />
943            </Box>
944          </Box>
945        ) : null}
946
947        <Box flexDirection="column" alignItems="flex-end">
948          <Box flexDirection="row-reverse" gap={1} alignItems="center" flexWrap="wrap">
949            {heading('המשימה')}
950            {currentTask || stepList.length > 0 ? (
951              <Button key="clear" label="נקה משימה" variant="secondary" onPress={() => clearTask($)} />
952            ) : null}
953            <Button key="save-knowledge" label="שמור ידע" plain onPress={() => fillPrompt($, SAVE_PROMPT, 'שמור ידע', now)} />
954          </Box>
955          <Text dimColor={!currentTask} wrap="wrap">
956            {rtl(taskSummary.text || 'אין משימה פעילה — Claude יעדכן כאן כשמשימה מתחילה')}
957          </Text>
958          {readAll('read-task', 'המשימה', currentTask, taskSummary.isWhole)}
959          {currentNote ? (
960            <Text color={AMBER} wrap="wrap">
961              {rtl(noteSummary.text)}
962            </Text>
963          ) : null}
964          {currentNote ? readAll('read-note', 'הערה', currentNote, noteSummary.isWhole) : null}
965        </Box>
966
967        {position ? (
968          <Box flexDirection="column" alignItems="flex-end">
969            <Box flexDirection="row-reverse" gap={1}>
970              {heading('שלבים')}
971              <Text dimColor>
972                ({doneCount}/{stepList.length})
973              </Text>
974            </Box>
975            {stepList.map(step => (
976              <Text
977                dimColor={step.status === 'done'}
978                bold={step.status === 'doing' || step.status === 'blocked'}
979                color={step.status === 'blocked' ? AMBER : undefined}
980                wrap="wrap"
981              >
982                {rtl(`${STEP_ICONS[step.status]} ${bounded(step.text, 500)}`)}
983              </Text>
984            ))}
985          </Box>
986        ) : null}
987
988        <Box flexDirection="column" alignItems="flex-end">
989          <Box flexDirection="row-reverse" gap={1} alignItems="center">
990            {heading('קבצים ששונו')}
991            <Text dimColor>
992              ({fileList.length}
993              {inGit ? ' · git' : ''})
994            </Text>
995            <Button key="refresh" label="רענן" plain onPress={() => refreshFiles($)} />
996          </Box>
997          {fileList.length === 0 ? (
998            <Text dimColor>{rtl(inGit ? 'אין שינויים' : 'אין שינויים — מחוץ ל-git מוצגים רק קבצים ש-Claude ערך')}</Text>
999          ) : null}
1000          {fileList.slice(0, showAllFiles ? MAX_FILES_OPEN : MAX_FILES).map((file, i) => {
1001            const label = fileLabel(file.status)
1002            // Line counts are neither ok nor failed: they are drawn dim.
1003            const counts = file.added || file.removed ? `+${file.added} −${file.removed}` : ''
1004            const path = filePathFor(file.path, columns, label.length + counts.length + 4)
1005            return (
1006              <Box flexDirection="row-reverse" gap={1} flexWrap="wrap">
1007                <Text dimColor>{rtl(label)}</Text>
1008                {inGit ? (
1009                  <Button key={`file-${i}`} label={path} plain onPress={() => openDiff($, file)} />
1010                ) : (
1011                  <Text>{path}</Text>
1012                )}
1013                {counts ? <Text dimColor>{counts}</Text> : null}
1014              </Box>
1015            )
1016          })}
1017          {fileList.length > MAX_FILES ? (
1018            <Button
1019              key="files-more"
1020              label={showAllFiles ? 'הצג פחות' : `ועוד ${fileList.length - MAX_FILES}…`}
1021              plain
1022              onPress={() => update($, isFileListOpen, open => !open)}
1023            />
1024          ) : null}
1025          {showAllFiles && fileList.length > MAX_FILES_OPEN ? (
1026            <Text dimColor>{rtl(`מוצגים ${MAX_FILES_OPEN} קבצים; את השאר רואים ב-git status`)}</Text>
1027          ) : null}
1028        </Box>
1029
1030        <Box flexDirection="column" alignItems="flex-end" width="100%">
1031          {heading('שער')}
1032          {gateBody}
1033        </Box>
1034
1035        {/* The last few closed proposals, below the work; with none at all, what will show here. */}
1036        {closedProposals.length > 0 ? (
1037          <Box flexDirection="column" alignItems="flex-end" gap={1}>
1038            {heading('הצעות קודמות ל-Codex')}
1039            {closedProposals.map(proposalCard)}
1040          </Box>
1041        ) : openProposals.length === 0 ? (
1042          <Box flexDirection="column" alignItems="flex-end">
1043            {heading('הצעות ל-Codex')}
1044            <Text dimColor>{rtl('כאן יופיעו הצעות של Claude לשלוח ל-Codex, לאישורך')}</Text>
1045          </Box>
1046        ) : null}
1047      </Box>
1048    )
1049  })
1050
1051  // The reader: the whole of one text a "read all" opened, split into blocks the
1052  // elements take; a diff is drawn as one, a command's output as plain code.
1053  on('ui.render', { component: 'Pane', requestId: 'cockpit-reader' }, async ($, e) => {
1054    const { Box, Text, Button, Markdown, Code } = $.ui.resolve(e)
1055    const doc = await read($, reader)
1056    if (!doc) {
1057      return (
1058        <Box flexDirection="column" alignItems="flex-end">
1059          <Text dimColor wrap="wrap">
1060            {rtl('כאן יופיע הטקסט המלא כשתלחץ "קרא הכל" בפאנל Cockpit.')}
1061          </Text>
1062        </Box>
1063      )
1064    }
1065    const now = await $.clock.now()
1066    const blocks = doc.kind === 'diff' ? splitDiff(doc.text) : doc.kind === 'output' ? splitPlain(doc.text) : splitMarkdown(doc.text)
1067    const pages = pageBlocks(blocks)
1068    const index = Math.min(doc.page ?? 0, Math.max(0, pages.length - 1))
1069    const file = doc.file
1070    // Above the page and again below it; keys differ, since a key is drawn once.
1071    const pager = (where: 'top' | 'end') =>
1072      pages.length > 1 ? (
1073        <Box flexDirection="row-reverse" gap={1} alignItems="center">
1074          <Text dimColor>{rtl(`עמוד ${index + 1} מתוך ${pages.length}`)}</Text>
1075          {index > 0 ? <Button key={`reader-prev-${where}`} label="הקודם" plain onPress={() => turnPage($, -1)} /> : null}
1076          {index < pages.length - 1 ? (
1077            <Button key={`reader-next-${where}`} label="הבא" plain onPress={() => turnPage($, 1)} />
1078          ) : null}
1079        </Box>
1080      ) : null
1081    return (
1082      <Box flexDirection="column" alignItems="flex-end" gap={1}>
1083        <Box flexDirection="row-reverse" gap={1} alignItems="center">
1084          <Text bold>{rtl(doc.title)}</Text>
1085          <Text dimColor>{rtl(formatAge(doc.at, now))}</Text>
1086          {file ? <Button key="reader-refresh" label="רענן" plain onPress={() => openDiff($, file)} /> : null}
1087        </Box>
1088        {file ? (
1089          <Text dimColor wrap="truncate-start">
1090            {file.path}
1091          </Text>
1092        ) : null}
1093        {doc.note ? (
1094          <Text
1095            color={doc.noteTone === 'failed' ? RED : doc.noteTone === 'warn' ? AMBER : undefined}
1096            dimColor={!doc.noteTone}
1097            wrap="wrap"
1098          >
1099            {rtl(doc.note)}
1100          </Text>
1101        ) : null}
1102        {blocks.length === 0 && !doc.note ? (
1103          <Text dimColor>{rtl(doc.kind === 'diff' ? 'אין שורות להציג — קובץ בינארי, או שהתוכן לא השתנה' : 'אין מה להציג')}</Text>
1104        ) : null}
1105        {pager('top')}
1106        <Box flexDirection="column" width="100%" gap={1}>
1107          {(pages[index] ?? []).map((block, i) =>
1108            doc.kind === 'markdown' ? (
1109              <Markdown key={`block-${i}`} text={block} />
1110            ) : (
1111              <Code key={`block-${i}`} source={block} format={doc.kind === 'diff' ? 'diff' : 'source'} />
1112            ),
1113          )}
1114        </Box>
1115        {pager('end')}
1116      </Box>
1117    )
1118  })
1119
1120  // No band above the prompt: the line under it, beside the status line, holds a
1121  // button per mod (shared/footer.ts merges what the mods beneath drew there). What
1122  // waits for the person in the pane (a proposal, a failed gate, a blocked step) marks the button.
1123  on('ui.render', { component: 'SessionMode' }, async ($, e, next) => {
1124    const { Box, Button } = $.ui.resolve(e)
1125    const isWaiting =
1126      needsYou({
1127        isWorking: await read($, isWorking),
1128        steps: await read($, steps),
1129        gate: await read($, gate),
1130        incoming: await read($, incoming),
1131        proposals: await read($, proposals),
1132      }) !== undefined
1133    // Dim at rest; marked at full strength while something waits (this line drops `variant`).
1134    const button = (
1135      <Button
1136        key="open-cockpit"
1137        label={isWaiting ? '◆ Cockpit' : 'Cockpit'}
1138        plain
1139        dimColor={!isWaiting}
1140        onPress={() => $.ui.open(SHOW)}
1141      />
1142    )
1143    return drawFooter(Box, mergeFooter([button], await next(e)))
1144  })
1145}
1146

1// Pure helpers: no `$`, so the tests import them directly.
2import type {
3  ChangedFile,
4  CodexChoice,
5  CodexModel,
6  GateRun,
7  Handoff,
8  Incoming,
9  Proposal,
10  ProposalKind,
11  Step,
12  StepStatus,
13} from '../types'
14import type { Tone } from './shared/colors'
15import { FAILED, IDLE, NEEDS_YOU, OK, RUNNING, STEP_ICONS, WARN } from './shared/glyphs'
16import { TEXT_MAX, bounded, cleanText, cutLine, middleTruncate, oneLine } from './shared/text'
17import { formatAge } from './shared/time'
18
19/** Commands that count as a project gate (typecheck, lint, build, tests). */
20const GATE = new RegExp(
21  [
22    String.raw`\b(npm|pnpm|yarn|bun)\s+(run\s+)?(lint|build|test|typecheck|check)\b`,
23    String.raw`\bnpx\s+(tsc|eslint|vitest|jest|playwright)\b`,
24    String.raw`(^|[\s;&|])tsc(\s|$)`,
25    String.raw`\b(pytest|vitest|jest|eslint)\b`,
26    String.raw`\bcompileall\b`,
27    String.raw`\bclaude\s+plugin\s+(validate|test)\b`,
28    String.raw`\bgate\.sh\b`,
29  ].join('|'),
30)
31
32export function isGateCommand(command: string): boolean {
33  const first = command.trimStart().split(/\s+/)[0] ?? ''
34  if (['git', 'grep', 'rg', 'cat', 'echo', 'ls', 'head', 'tail'].includes(first)) return false
35  return GATE.test(command)
36}
37
38/**
39 * `git status --porcelain=v1 -z` → files, without line counts yet. NUL-separated,
40 * so a path with spaces, quotes or Hebrew comes through as written; a rename's
41 * original path follows it as an entry of its own.
42 */
43export function parsePorcelain(text: string): ChangedFile[] {
44  const files: ChangedFile[] = []
45  const entries = text.split('\0')
46  for (let i = 0; i < entries.length; i++) {
47    const entry = entries[i] ?? ''
48    if (entry.length < 4) continue
49    const status = entry.slice(0, 2)
50    files.push({ path: entry.slice(3), status, added: 0, removed: 0 })
51    if (status.includes('R') || status.includes('C')) i++
52  }
53  return files
54}
55
56/** Folds `git diff --numstat -z` counts into the porcelain list (a rename: counts, then old and new path). */
57export function applyNumstat(files: ChangedFile[], text: string): ChangedFile[] {
58  const counts = new Map<string, [number, number]>()
59  const entries = text.split('\0')
60  for (let i = 0; i < entries.length; i++) {
61    const [added, removed, ...rest] = (entries[i] ?? '').split('\t')
62    if (added === undefined || removed === undefined || rest.length === 0) continue
63    let path = rest.join('\t')
64    if (path === '') {
65      // A rename: the old path, then the new one, each its own entry.
66      path = entries[i + 2] ?? ''
67      i += 2
68    }
69    counts.set(path, [Number(added) || 0, Number(removed) || 0])
70  }
71  return files.map(file => {
72    const count = counts.get(file.path)
73    return count ? { ...file, added: count[0], removed: count[1] } : file
74  })
75}
76
77/** The plan's first `# ` heading, as a fallback task title. */
78export function planTitle(plan: string): string | undefined {
79  const match = /^#\s+(.+)$/m.exec(plan)
80  return match?.[1]?.trim()
81}
82
83export const REPORT_TOOL = 'mcp__cockpit__report'
84
85export const STEP_STATUSES: StepStatus[] = ['todo', 'doing', 'done', 'blocked']
86
87export const REPORT_SPEC = {
88  name: 'report',
89  description:
90    'Update the Cockpit pane the user supervises from: the current task, its plan steps and their status. ' +
91    'Call it when you start a task of two or more steps, whenever a step starts, finishes or gets blocked, ' +
92    'and with the full list each time (it replaces the previous one). Write task, steps and note in Hebrew. ' +
93    'Never mark a step done that you did not finish and verify. Task, steps and note also carry over: the ' +
94    "next session in this project is offered them as a handoff if the work is left unfinished.",
95  inputSchema: {
96    type: 'object',
97    properties: {
98      task: { type: 'string', description: 'One line: what is being done now' },
99      steps: {
100        type: 'array',
101        description: 'The whole plan, in order',
102        items: {
103          type: 'object',
104          properties: {
105            text: { type: 'string' },
106            status: { type: 'string', enum: STEP_STATUSES },
107          },
108          required: ['text', 'status'],
109        },
110      },
111      note: { type: 'string', description: 'Optional: what the user should know or decide now' },
112    },
113  },
114}
115
116export const CONTEXT_TEXT =
117  'The user supervises this session from a Cockpit pane instead of an editor. For any task with two or more ' +
118  `steps, keep the pane current with the ${REPORT_TOOL} tool: task and full step list when you start, ` +
119  'and again whenever a step changes status. Hebrew text. It costs nothing to call and needs no permission. ' +
120  'What it holds when a session ends is offered to the next session in the project as a handoff.'
121
122/** The report tool's input, cleaned: unknown fields dropped, bad statuses read as `todo`. */
123export function parseReport(input: Record<string, unknown>): { task?: string; note?: string; steps?: Step[] } {
124  const out: { task?: string; note?: string; steps?: Step[] } = {}
125  if (typeof input.task === 'string') out.task = input.task
126  if (typeof input.note === 'string') out.note = input.note
127  if (Array.isArray(input.steps)) {
128    out.steps = input.steps
129      .filter((s): s is { text: string; status?: unknown } => typeof s?.text === 'string')
130      .map(s => ({
131        text: s.text,
132        status: STEP_STATUSES.includes(s.status as StepStatus) ? (s.status as StepStatus) : 'todo',
133      }))
134  }
135  return out
136}
137
138const FILE_LABELS: Record<string, string> = {
139  '??': 'חדש',
140  A: 'נוסף',
141  M: 'שונה',
142  D: 'נמחק',
143  R: 'הועבר',
144  ed: 'נערך',
145}
146
147export function fileLabel(status: string): string {
148  const exact = FILE_LABELS[status]
149  if (exact) return exact
150  const code = status.trim()[0] ?? ''
151  return FILE_LABELS[code] ?? status.trim()
152}
153
154// ── the reader: gate output and diffs ────────────────────────────────────
155
156/** A Bash call's output as the reader shows it: its record's streams, or the error the model read. */
157export function gateOutputOf(ran: { isError?: true; result?: unknown; text?: string }): { text: string; path?: string } {
158  const record = ran.result as { stdout?: unknown; stderr?: unknown; persistedOutputPath?: unknown } | undefined
159  const isEmpty = !record || typeof record !== 'object' || (!record.stdout && !record.stderr)
160  // A record whose streams were blanked (a headless session stores Bash so) falls back to what the model read.
161  if (!ran.isError && !(isEmpty && ran.text) && record && typeof record === 'object' && typeof record.stdout === 'string') {
162    const stderr = typeof record.stderr === 'string' && record.stderr.trim() ? `\n--- stderr ---\n${record.stderr}` : ''
163    const path = typeof record.persistedOutputPath === 'string' ? record.persistedOutputPath : undefined
164    return { text: cleanText(record.stdout + stderr), ...(path ? { path } : {}) }
165  }
166  const text = ran.text ?? (typeof ran.result === 'string' ? ran.result : '')
167  return { text: cleanText(text) }
168}
169
170const FAILURE_LINE = /exit:\s*[1-9]|\bfail|\berror|✗/i
171const CLEAN_LINE = /\b0 fail/i
172
173/** Up to three lines that tell a gate run: on failure the ones that failed, else the last ones. */
174export function gateSummary(output: string, isOk: boolean): string[] {
175  const lines = output.split('\n').filter(line => line.trim() !== '')
176  const failed = isOk ? [] : lines.filter(line => FAILURE_LINE.test(line) && !CLEAN_LINE.test(line))
177  return (failed.length > 0 ? failed.slice(0, 3) : lines.slice(-3)).map(line => oneLine(line, 200))
178}
179
180/** The `git diff` for one changed file, run from the repo's root; undefined outside git. */
181export function diffArgv(file: ChangedFile, hasHead: boolean): string[] | undefined {
182  if (file.status === 'ed') return undefined
183  const base = ['git', '--literal-pathspecs', 'diff', '--no-color', '--no-ext-diff']
184  // An untracked file, or any file before the first commit, is all new.
185  if (file.status === '??' || !hasHead) return [...base, '--no-index', '--', '/dev/null', file.path]
186  return [...base, 'HEAD', '--', file.path]
187}
188
189/** `git diff --no-index` exits 1 when the files differ, which is the answer asked for. */
190export function isDiffOk(argv: readonly string[], exitCode: number): boolean {
191  return exitCode === 0 || (exitCode === 1 && argv.includes('--no-index'))
192}
193
194const HUNK = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/
195/** Room kept in a block for a hunk header written anew. */
196const HEADER_ROOM = 120
197
198function hunkHeader(oldStart: number, oldCount: number, newStart: number, newCount: number, section: string): string {
199  // A side with no lines names the line before it, as git writes it.
200  const from = oldCount === 0 ? oldStart - 1 : oldStart
201  const to = newCount === 0 ? newStart - 1 : newStart
202  return `@@ -${from},${oldCount} +${to},${newCount} @@${oneLine(section, 60) ? ` ${oneLine(section, 60)}` : ''}`
203}
204
205/** A hunk too long for one block, as hunks of its own, each numbered where it starts. */
206function splitHunk(lines: string[], max: number): string[] {
207  const match = HUNK.exec(lines[0] ?? '')
208  if (!match) return [lines.join('\n')]
209  const section = match[5]?.trim() ?? ''
210  let oldNo = Number(match[1]) + (match[2] === '0' ? 1 : 0)
211  let newNo = Number(match[3]) + (match[4] === '0' ? 1 : 0)
212  const pieces: string[] = []
213  let body: string[] = []
214  let size = 0
215  let start = { old: oldNo, new: newNo }
216  let count = { old: 0, new: 0 }
217  const flush = () => {
218    if (body.length > 0) pieces.push([hunkHeader(start.old, count.old, start.new, count.new, section), ...body].join('\n'))
219    body = []
220    size = 0
221    start = { old: oldNo, new: newNo }
222    count = { old: 0, new: 0 }
223  }
224  for (const line of lines.slice(1)) {
225    const mark = line[0] ?? ' '
226    const isOld = mark === ' ' || mark === '-'
227    const isNew = mark === ' ' || mark === '+'
228    if (line.length + 1 > max - HEADER_ROOM) {
229      // One line wider than a block: each piece its own hunk, all on that line's numbers.
230      flush()
231      for (const piece of cutLine(line.slice(1), max - HEADER_ROOM - 1)) {
232        pieces.push([hunkHeader(oldNo, isOld ? 1 : 0, newNo, isNew ? 1 : 0, section), mark + piece].join('\n'))
233      }
234    } else {
235      if (size + line.length + 1 > max - HEADER_ROOM) flush()
236      body.push(line)
237      size += line.length + 1
238      if (isOld) count.old++
239      if (isNew) count.new++
240    }
241    if (isOld) oldNo++
242    if (isNew) newNo++
243    if (line.length + 1 > max - HEADER_ROOM) start = { old: oldNo, new: newNo }
244  }
245  flush()
246  return pieces
247}
248
249/**
250 * One file's unified diff as blocks a `Code format: 'diff'` takes: the file
251 * headers dropped, whole hunks packed into each block, a hunk too long split
252 * with its line numbers written anew. No hunks (a binary file) → none.
253 */
254export function splitDiff(diff: string, max = TEXT_MAX): string[] {
255  const hunks: string[][] = []
256  for (const line of cleanText(diff).split('\n')) {
257    if (line.startsWith('@@')) hunks.push([line])
258    else if (hunks.length > 0 && /^[ +\-\\]/.test(line)) hunks.at(-1)?.push(line)
259  }
260  const blocks: string[] = []
261  let current = ''
262  for (const hunk of hunks) {
263    const text = hunk.join('\n')
264    const pieces = text.length <= max ? [text] : splitHunk(hunk, max)
265    for (const piece of pieces) {
266      if (current && current.length + 1 + piece.length > max) {
267        blocks.push(current)
268        current = ''
269      }
270      current = current ? `${current}\n${piece}` : piece
271    }
272  }
273  if (current) blocks.push(current)
274  return blocks
275}
276
277// ── what the pane says ───────────────────────────────────────────────────
278
279/** Where the work is: the step under way, else the first unfinished one, else the last; of how many. */
280export function stepPosition(steps: readonly Step[]): { at: number; of: number } | undefined {
281  if (steps.length === 0) return undefined
282  const doing = steps.findIndex(s => s.status === 'doing')
283  const open = steps.findIndex(s => s.status !== 'done')
284  return { at: (doing >= 0 ? doing : open >= 0 ? open : steps.length - 1) + 1, of: steps.length }
285}
286
287type WaitState = {
288  isWorking: boolean
289  steps: readonly Step[]
290  gate: GateRun | null
291  incoming?: Incoming | null
292  proposals?: readonly Pick<Proposal, 'id' | 'status'>[]
293}
294
295/**
296 * What waits for the person, if anything: a proposal to Codex they have not
297 * answered, else a failed gate they have not marked handled, else a blocked step,
298 * else a previous session's handoff they have not answered. Only the proposal
299 * shows while Claude works: Claude makes it mid-turn and cannot answer it; the
300 * rest Claude is likely fixing.
301 * The Hero, the frames and the ◆ on the Cockpit button all ask this.
302 */
303export function needsYou(state: WaitState): 'proposal' | 'gate' | 'blocked' | 'handoff' | undefined {
304  if (state.proposals?.some(p => p.status === 'pending')) return 'proposal'
305  if (state.isWorking) return undefined
306  if (state.gate && !state.gate.isOk && !state.gate.isDismissed) return 'gate'
307  if (state.steps.some(s => s.status === 'blocked')) return 'blocked'
308  if (state.incoming && !state.incoming.isQuiet) return 'handoff'
309  return undefined
310}
311
312/** The Hero's tone: as the shared ones, and `plain` for work under way (not ok, not a warning). */
313export type HeroTone = Tone | 'plain'
314
315/** The Hero: one line at the top of the pane, as a glyph, a tone and a few words. */
316export function cockpitHeadline(state: WaitState): { tone: HeroTone; glyph: string; text: string } {
317  const waiting = needsYou(state)
318  const position = stepPosition(state.steps)
319  if (waiting === 'proposal') {
320    const pending = (state.proposals ?? []).filter(p => p.status === 'pending')
321    const more = pending.length > 1 ? ` (+${pending.length - 1})` : ''
322    return { tone: 'needs-you', glyph: NEEDS_YOU, text: `מחכה לך — הצעה ל-Codex #${pending[0]?.id}${more}` }
323  }
324  if (waiting === 'gate') return { tone: 'needs-you', glyph: NEEDS_YOU, text: 'מחכה לך — השער נכשל' }
325  if (waiting === 'blocked') {
326    const blocked = state.steps.findIndex(s => s.status === 'blocked') + 1
327    return { tone: 'needs-you', glyph: NEEDS_YOU, text: `מחכה לך — שלב ${blocked} חסום` }
328  }
329  if (waiting === 'handoff') return { tone: 'needs-you', glyph: NEEDS_YOU, text: 'מחכה לך — Handoff מהסשן הקודם' }
330  if (state.isWorking) {
331    return {
332      tone: 'plain',
333      glyph: RUNNING,
334      text: position ? `Claude עובד — שלב ${position.at} מתוך ${position.of}` : 'Claude עובד',
335    }
336  }
337  const done = state.steps.filter(s => s.status === 'done').length
338  return { tone: 'muted', glyph: IDLE, text: position ? `שקט — ${done} מתוך ${position.of} הושלמו` : 'שקט' }
339}
340
341/** The gate's line: failed, stale (files changed after it ran), passed, or never run. */
342export function gateLook(gate: GateRun | null, lastEditAt: number, nowMs: number): { tone: Tone; text: string } {
343  if (!gate) return { tone: 'muted', text: 'לא הורץ שער בסשן הזה' }
344  const age = formatAge(gate.at, nowMs)
345  if (!gate.isOk) return { tone: 'failed', text: `${FAILED} השער נכשל · ${age}` }
346  if (lastEditAt > gate.at) return { tone: 'needs-you', text: `${WARN} ישן · קבצים שונו אחרי הריצה · ${age}` }
347  return { tone: 'ok', text: `${OK} עבר · ${age}` }
348}
349
350/**
351 * A changed file's path within what its row leaves: the folders are cut, the file's
352 * name kept whole when it fits; a name longer than the room is cut in its middle.
353 * Never under 12 characters: a row narrower than that wraps instead.
354 */
355export function filePathFor(path: string, columns: number, reserved: number): string {
356  const room = Math.max(12, columns - reserved)
357  const line = oneLine(path, 1000)
358  if (line.length <= room) return line
359  const slash = line.lastIndexOf('/')
360  const name = slash >= 0 ? line.slice(slash + 1) : line
361  if (slash < 0 || name.length + 2 > room) return middleTruncate(name, room)
362  // "head…/name": as much of the folders' start as fits before the name.
363  const head = line.slice(0, room - name.length - 2)
364  return `${head}…/${name}`
365}
366
367
368// ── handoff and saved knowledge ──────────────────────────────────────────
369
370/** How long a project's last handoff is kept. */
371export const HANDOFF_DAYS = 30
372const HANDOFF_PREFIX = 'handoff:'
373const HANDOFF_FILES = 30
374const HANDOFF_STEPS = 40
375
376export function handoffKey(root: string): string {
377  return `${HANDOFF_PREFIX}${root}`
378}
379
380type WorkState = {
381  task: string
382  note: string
383  steps: readonly Step[]
384  files: readonly ChangedFile[]
385  gate: GateRun | null
386  lastEditAt: number
387}
388
389/** The work as it stands, bounded for the store and for one prompt. */
390export function handoffOf(work: WorkState, sessionId: string, root: string, at: number): Handoff {
391  return {
392    sessionId,
393    root,
394    at,
395    task: bounded(work.task, 2000),
396    note: bounded(work.note, 1000),
397    steps: work.steps.slice(0, HANDOFF_STEPS).map(s => ({ text: bounded(s.text, 300), status: s.status })),
398    omittedSteps: Math.max(0, work.steps.length - HANDOFF_STEPS),
399    openOmittedSteps: work.steps.slice(HANDOFF_STEPS).filter(s => s.status !== 'done').length,
400    files: work.files.slice(0, HANDOFF_FILES).map(f => ({ path: oneLine(f.path, 300), status: f.status })),
401    fileCount: work.files.length,
402    gate: work.gate
403      ? {
404          command: oneLine(work.gate.command, 300),
405          isOk: work.gate.isOk,
406          isStale: work.gate.isOk && work.lastEditAt > work.gate.at,
407          at: work.gate.at,
408          summary: work.gate.summary.slice(0, 3).map(line => oneLine(line, 300)),
409        }
410      : null,
411  }
412}
413
414/** Work left to do: a step not done, a task with no steps, or a gate that failed or went stale. */
415export function isUnfinished(h: Handoff): boolean {
416  if (h.steps.some(s => s.status !== 'done') || (h.openOmittedSteps ?? 0) > 0) return true
417  if (h.steps.length === 0 && h.task.trim() !== '') return true
418  return Boolean(h.gate && (!h.gate.isOk || h.gate.isStale))
419}
420
421/** The card's one line: the task and where it stopped. */
422export function handoffSummary(h: Handoff): string {
423  const position = stepPosition(h.steps)
424  const task = oneLine(h.task, 120) || 'בלי משימה רשומה'
425  return position ? `${task} · שלב ${position.at} מתוך ${position.of}` : task
426}
427
428/**
429 * The opening prompt for the next session, in Hebrew since it is sent as the
430 * person's own message: the work as it was left, then: check it still holds.
431 */
432export function openingPrompt(h: Handoff, nowMs: number): string {
433  const parts: string[] = [`המשך מהסשן הקודם בפרויקט הזה (המצב נשמר ${formatAge(h.at, nowMs)}).`]
434  parts.push(`## המשימה\n${h.task || 'לא נרשמה משימה.'}`)
435  if (h.steps.length > 0) {
436    const omitted = h.omittedSteps ? `\nועוד ${h.omittedSteps} שלבים, ${h.openOmittedSteps ?? 0} מהם פתוחים` : ''
437    parts.push(`## שלבים\n${h.steps.map(s => `${STEP_ICONS[s.status]} ${s.text}`).join('\n')}${omitted}`)
438  }
439  if (h.note) parts.push(`## הערה פתוחה\n${h.note}`)
440  if (h.gate) {
441    const state = !h.gate.isOk ? 'נכשל' : h.gate.isStale ? 'עבר, אבל קבצים שונו אחריו' : 'עבר'
442    const lines = [`\`${h.gate.command}\` — ${state} · ${formatAge(h.gate.at, nowMs)}`, ...h.gate.summary]
443    parts.push(`## שער אחרון\n${lines.join('\n')}`)
444  }
445  if (h.files.length > 0) {
446    const more = h.fileCount > h.files.length ? `\nועוד ${h.fileCount - h.files.length}` : ''
447    parts.push(`## קבצים ששונו אז\n${h.files.map(f => `- ${f.path} (${fileLabel(f.status)})`).join('\n')}${more}`)
448  }
449  parts.push(
450    'לפני שממשיכים: קרא את AGENTS.md ואת מסמך-האמת שהוא מפנה אליו, הרץ `git status` ו-`git log -5`, ובדוק שהמצב ' +
451      'עדיין תואם — הוא נשמר בסוף הסשן הקודם ואולי השתנה מאז. אחר כך עדכן את ה-Cockpit (report) והמשך מהשלב הפתוח.',
452  )
453  return parts.join('\n\n')
454}
455
456/**
457 * For the summary of a compaction: the Cockpit's task, every step and the note, word
458 * for word (cleaned of control characters only). None without a task.
459 */
460export function compactInstructions(work: { task: string; note: string; steps: readonly Step[] }): string | undefined {
461  if (!work.task.trim() && work.steps.length === 0) return undefined
462  const lines = ['Keep the current Cockpit task and plan verbatim in the summary:', `Task: ${cleanText(work.task).trim() || '(none)'}`]
463  for (const step of work.steps) lines.push(`- [${step.status}] ${cleanText(step.text).trim()}`)
464  if (work.note.trim()) lines.push(`Note: ${cleanText(work.note).trim()}`)
465  return lines.join('\n')
466}
467
468/** Saved handoffs older than `days`, or of another shape: the keys to delete. */
469export function staleHandoffKeys(entries: readonly [string, unknown][], nowMs: number, days = HANDOFF_DAYS): string[] {
470  const cutoff = nowMs - days * 24 * 60 * 60 * 1000
471  return entries
472    .filter(([key]) => key.startsWith(HANDOFF_PREFIX))
473    .filter(([, value]) => !isHandoff(value) || value.at < cutoff)
474    .map(([key]) => key)
475}
476
477export function isHandoff(value: unknown): value is Handoff {
478  if (value === null || typeof value !== 'object') return false
479  const h = value as Partial<Handoff>
480  return (
481    typeof h.sessionId === 'string' &&
482    typeof h.root === 'string' &&
483    typeof h.at === 'number' &&
484    typeof h.task === 'string' &&
485    typeof h.note === 'string' &&
486    Array.isArray(h.steps) &&
487    Array.isArray(h.files) &&
488    typeof h.fileCount === 'number'
489  )
490}
491
492/**
493 * The "save knowledge" prompt, in Hebrew as the person's own message: find what
494 * this session decided and learned, sort it by the person's rules, propose, wait.
495 */
496export const SAVE_PROMPT =
497  'שמור ידע מהסשן הזה: מצא החלטות, לקחים ומלכודות שעלו כאן ועוד לא כתובים בקבצי הפרויקט. מיין לפי הכללים: ' +
498  'כלל קבוע, מלכודת או ניווט → AGENTS.md (בלי תיאור של מצב נוכחי); החלטה מתוארכת או סטטוס → מסמך-האמת ' +
499  'ש-AGENTS.md מפנה אליו; שינוי מבנה → מפת-הקוד (/codemap). הצג לי את העריכות המוצעות, קובץ אחר קובץ, וחכה ' +
500  'לאישור לפני שאתה כותב.'
501
502/** From this share of the context window on, the pane suggests saving knowledge once. */
503export const SAVE_SUGGEST_PERCENT = 75
504
505// ── proposals to Codex ───────────────────────────────────────────────────
506
507export const PROPOSE_TOOL = 'mcp__cockpit__propose'
508
509export const CODEX_CONTEXT_TEXT =
510  `Codex (OpenAI, the user's ChatGPT subscription) is available as a read-only second opinion through ${PROPOSE_TOOL}. ` +
511  'Propose it when an independent look is worth it: a plan before the user approves it (plan-review), finished ' +
512  'work after the gate passed and before you call it done (result-review), or a research question (question). ' +
513  'The user approves or declines in the Cockpit pane, and picks the model there; never wait or poll for it.'
514
515export const PROPOSAL_KINDS: ProposalKind[] = ['plan-review', 'result-review', 'question']
516
517export const KIND_TITLES: Record<ProposalKind, string> = {
518  'plan-review': 'בדיקת תוכנית',
519  'result-review': 'בדיקת תוצאה',
520  question: 'שאלה / מחקר',
521}
522
523export const PROPOSE_SPEC = {
524  name: 'propose',
525  description:
526    "Propose sending a prompt to Codex (OpenAI's coding agent, on the user's ChatGPT subscription) for an " +
527    'independent, read-only second opinion. The user sees your reason and the full prompt in the Cockpit pane, ' +
528    'picks the model and approves or declines. Returns at once: do not wait or poll. If approved, Codex runs ' +
529    "read-only in the project folder and its answer reaches you later as a new message; if declined, you are told. " +
530    'Codex does not see this conversation: make the prompt self-contained (goal, absolute paths of the plan or ' +
531    'files to read, what to check, what form the answer should take). Write `why` in Hebrew for the user; the ' +
532    'prompt in English.',
533  inputSchema: {
534    type: 'object',
535    properties: {
536      kind: {
537        type: 'string',
538        enum: PROPOSAL_KINDS,
539        description: 'plan-review: check a plan; result-review: check finished work; question: research or a question',
540      },
541      why: { type: 'string', description: 'One Hebrew sentence for the user: why ask Codex now' },
542      prompt: { type: 'string', description: 'The self-contained prompt Codex will receive' },
543    },
544    required: ['kind', 'why', 'prompt'],
545  },
546}
547
548export function parseProposal(input: Record<string, unknown>): { kind: ProposalKind; why: string; prompt: string } | string {
549  const kind = PROPOSAL_KINDS.includes(input.kind as ProposalKind) ? (input.kind as ProposalKind) : undefined
550  if (!kind) return `kind must be one of ${PROPOSAL_KINDS.join(', ')}`
551  if (typeof input.prompt !== 'string' || input.prompt.trim() === '') return 'prompt is required'
552  const why = typeof input.why === 'string' ? input.why : ''
553  return { kind, why, prompt: input.prompt }
554}
555
556/**
557 * argv for one proposal's Codex run: a new thread, always read-only. The user's
558 * config.toml is not loaded, so none of its plugins, MCP servers or hooks run here
559 * (sign-in still comes from CODEX_HOME); model and effort are passed instead.
560 *
561 * ~/.codex/AGENTS.md, ~/.codex/agents and ~/.codex/skills still load: a run may
562 * spawn a sub-agent with its own model, which keeps this run's sandbox (checked
563 * 17/10 with `worker`, whose own file says workspace-write).
564 */
565export function proposalArgv(binary: string, prompt: string, choice: CodexChoice): string[] {
566  return [
567    binary,
568    'exec',
569    '--json',
570    '--skip-git-repo-check',
571    '--ignore-user-config',
572    '-m',
573    choice.model,
574    '-c',
575    `model_reasoning_effort="${choice.effort}"`,
576    '-c',
577    'sandbox_mode="read-only"',
578    '-s',
579    'read-only',
580    '--',
581    prompt,
582  ]
583}
584
585export type CodexEvent = { kind: 'message'; text: string } | { kind: 'done' } | { kind: 'error'; message: string }
586
587/** An error message that is itself a JSON envelope reads as its inner message. */
588function innerMessage(message: unknown): string {
589  const text = typeof message === 'string' ? message : JSON.stringify(message)
590  try {
591    const parsed = JSON.parse(text) as { error?: { message?: string }; message?: string }
592    return parsed.error?.message ?? parsed.message ?? text
593  } catch {
594    return text
595  }
596}
597
598/** One line of `codex exec --json` as a proposal needs it; undefined for the rest. */
599export function parseCodexEvent(line: string): CodexEvent | undefined {
600  let event: { type?: string; item?: Record<string, unknown>; message?: unknown; error?: { message?: unknown } }
601  try {
602    event = JSON.parse(line)
603  } catch {
604    return undefined
605  }
606  switch (event.type) {
607    case 'item.completed':
608      return event.item?.type === 'agent_message' ? { kind: 'message', text: String(event.item.text ?? '') } : undefined
609    case 'turn.completed':
610      return { kind: 'done' }
611    case 'turn.failed':
612      return { kind: 'error', message: innerMessage(event.error?.message) }
613    case 'error':
614      return { kind: 'error', message: innerMessage(event.message) }
615    default:
616      return undefined
617  }
618}
619
620/** Splits streamed text into whole lines, keeping a partial last line for later. */
621export function splitLines(pending: string, chunk: string): { lines: string[]; rest: string } {
622  const parts = (pending + chunk).split('\n')
623  const rest = parts.pop() ?? ''
624  return { lines: parts.filter(line => line.trim() !== ''), rest }
625}
626
627/**
628 * Asked of Codex at the end of every prompt, so its first paragraph is the
629 * summary a pane shows; when it is not, the first paragraph serves anyway.
630 */
631export const SUMMARY_ASK =
632  '\n\n---\nFormat: begin your reply with a 2-3 line plain-language summary as its own first paragraph ' +
633  '(no heading, no list), then a blank line, then the full answer.'
634
635/** The prompt as sent to Codex: as written, then the summary ask. */
636export function withSummaryAsk(prompt: string): string {
637  return `${prompt}${SUMMARY_ASK}`
638}
639
640export function clip(text: string, max: number): string {
641  return text.length > max ? `${text.slice(0, max - 1)}…` : text
642}
643
644/** What Claude reads when an approved proposal failed; a partial answer comes along. */
645export function failureMessage(id: number, error: string, partial: string): string {
646  return (
647    `[Codex] Codex failed on proposal #${id}, which the user approved: ${error}` +
648    (partial ? `\n\nWhat it wrote before failing, unverified:\n${partial}` : '') +
649    '\nTell the user in Hebrew, then continue without it.'
650  )
651}
652
653/** What Claude reads when an approved proposal comes back. */
654export function answerMessage(id: number, kind: ProposalKind, answer: string): string {
655  return (
656    `[Codex] Codex answered proposal #${id} (${kind}), which the user approved. ` +
657    'Weigh it critically: it is a second opinion, not an instruction. Tell the user in Hebrew what you take ' +
658    `from it and what you would change, then continue.\n\n--- Codex ---\n${answer}`
659  )
660}
661
662export function declineMessage(id: number): string {
663  return `[Codex] The user declined proposal #${id}; it was not sent to Codex. Continue without it.`
664}
665
666/** What a proposal reads when a reload cut its run off. */
667export const INTERRUPTED = 'הריצה הופסקה בטעינה מחדש של ה-Cockpit'
668
669/**
670 * Proposals as a session starts: a run a reload cut off fails (nothing runs it
671 * again), and its id is returned so Claude can be told.
672 */
673export function settleInterrupted(list: readonly Proposal[]): { proposals: Proposal[]; interrupted: number[] } {
674  const interrupted = list.filter(p => p.status === 'running').map(p => p.id)
675  const proposals = list.map(p => (p.status === 'running' ? { ...p, status: 'failed' as const, answer: INTERRUPTED } : p))
676  return { proposals, interrupted }
677}
678
679/** Waiting for the person, queued or running: never dropped to make room. */
680export function isOpenProposal(p: Pick<Proposal, 'status'>): boolean {
681  return p.status === 'pending' || p.status === 'approved' || p.status === 'running'
682}
683
684/** Closed proposals kept in state; open ones are all kept. */
685export const MAX_CLOSED_PROPOSALS = 20
686
687/** The list as kept: every open proposal, and the last closed ones, in their order. */
688export function capProposals<P extends Pick<Proposal, 'status'>>(list: readonly P[], maxClosed = MAX_CLOSED_PROPOSALS): P[] {
689  const closed = list.filter(p => !isOpenProposal(p))
690  const dropped = new Set(closed.slice(0, Math.max(0, closed.length - maxClosed)))
691  return list.filter(p => !dropped.has(p))
692}
693
694/**
695 * Proposals as a /clear ends the conversation they belong to: one not yet run is
696 * cancelled, a running one finishes into the pane only, and a decline not yet
697 * told is not told to the new conversation.
698 */
699export function settleCleared(list: readonly Proposal[]): Proposal[] {
700  return list.map(p => {
701    if (p.status === 'pending' || p.status === 'approved') return { ...p, status: 'cleared' as const }
702    if (p.status === 'running') return { ...p, isCleared: true }
703    if (p.status === 'declined' && !p.isReported) return { ...p, isReported: true }
704    return p
705  })
706}
707
708/** Tries at telling Claude about a decline before the card says it was not told. */
709export const REPORT_TRIES = 3
710
711/** The models the account may pick, from Codex's own models cache. */
712export function parseModels(json: string): CodexModel[] {
713  let parsed: unknown
714  try {
715    parsed = JSON.parse(json)
716  } catch {
717    return []
718  }
719  const list = Array.isArray(parsed) ? parsed : (parsed as { models?: unknown })?.models
720  if (!Array.isArray(list)) return []
721  return list
722    .filter((m): m is Record<string, unknown> => typeof m?.slug === 'string' && m.visibility === 'list')
723    .map(m => {
724      const levels = Array.isArray(m.supported_reasoning_levels) ? m.supported_reasoning_levels : []
725      // The cache is Codex's file, not ours: what shows is cleaned and bounded.
726      const efforts = levels
727        .map(level => (level as { effort?: unknown })?.effort)
728        .filter((effort): effort is string => typeof effort === 'string')
729        .map(effort => oneLine(effort, 40))
730        .filter(effort => effort !== '')
731      const preferred = typeof m.default_reasoning_level === 'string' ? oneLine(m.default_reasoning_level, 40) : ''
732      return {
733        slug: m.slug as string,
734        name: oneLine(typeof m.display_name === 'string' ? m.display_name : (m.slug as string), 60),
735        efforts,
736        defaultEffort: preferred || (efforts[0] ?? 'medium'),
737      }
738    })
739}
740
741/** `model` and `model_reasoning_effort` from config.toml's top level, if set. */
742export function configChoice(toml: string): Partial<CodexChoice> {
743  const top = toml.split(/^\[/m)[0] ?? ''
744  const model = /^model\s*=\s*"([^"]+)"/m.exec(top)?.[1]
745  const effort = /^model_reasoning_effort\s*=\s*"([^"]+)"/m.exec(top)?.[1]
746  return { ...(model ? { model } : {}), ...(effort ? { effort } : {}) }
747}
748
749/** A choice that fits the models offered: an unknown model or effort falls back. */
750export function settleChoice(models: readonly CodexModel[], wanted: Partial<CodexChoice>): CodexChoice {
751  const model = models.find(m => m.slug === wanted.model) ?? models[0]
752  if (!model) return { model: wanted.model ?? 'gpt-5.5', effort: wanted.effort ?? 'medium' }
753  const effort = wanted.effort && model.efforts.includes(wanted.effort) ? wanted.effort : model.defaultEffort
754  return { model: model.slug, effort }
755}
756
757export const EFFORT_LABELS: Record<string, string> = {
758  none: 'ללא',
759  minimal: 'מינימלית',
760  low: 'נמוכה',
761  medium: 'בינונית',
762  high: 'גבוהה',
763  xhigh: 'גבוהה מאוד',
764  max: 'מקסימלית',
765  ultra: 'אולטרה',
766}
767
768/** A choice on one line, by the model's display name: "GPT-6-Sol · חשיבה גבוהה". */
769export function choiceLabel(models: readonly CodexModel[], choice: CodexChoice): string {
770  const name = models.find(m => m.slug === choice.model)?.name ?? choice.model
771  return `${oneLine(name, 40)} · חשיבה ${effortLabel(choice.effort)}`
772}
773
774/** An effort as it reads in Hebrew; one we do not know shows as written, bounded. */
775export function effortLabel(effort: string): string {
776  return EFFORT_LABELS[effort] ?? oneLine(effort, 40)
777}
778
779/**
780 * How a proposal's status reads on its card; an answer that never reached Claude
781 * is not a success, whatever the run did.
782 */
783export function proposalLook(
784  status: Proposal['status'],
785  flags: { hasDeliveryError?: boolean; isCleared?: boolean } = {},
786): { tone: Tone; text: string } {
787  if (flags.hasDeliveryError && status === 'declined') return { tone: 'failed', text: `סירבת — ${FAILED} לא הועבר ל-Claude` }
788  if (flags.hasDeliveryError && (status === 'done' || status === 'failed')) {
789    return { tone: 'failed', text: `${FAILED} לא הועבר ל-Claude` }
790  }
791  // After a /clear the answer belongs to no conversation: it shows here only.
792  if (flags.isCleared && status === 'done') return { tone: 'muted', text: `${OK} Codex ענה — לא נשלח, השיחה נוקתה ב-/clear` }
793  if (flags.isCleared && status === 'failed') return { tone: 'failed', text: `${FAILED} נכשלה — לא נשלח, השיחה נוקתה ב-/clear` }
794  switch (status) {
795    case 'pending':
796      return { tone: 'needs-you', text: `${NEEDS_YOU} מחכה לך` }
797    case 'approved':
798      return { tone: 'muted', text: 'בתור' }
799    case 'running':
800      return { tone: 'codex', text: `${RUNNING} Codex בודק` }
801    case 'done':
802      return { tone: 'ok', text: `${OK} Codex ענה — התשובה עברה ל-Claude` }
803    case 'declined':
804      return { tone: 'muted', text: 'סירבת' }
805    case 'failed':
806      return { tone: 'failed', text: `${FAILED} נכשלה` }
807    case 'cleared':
808      return { tone: 'muted', text: 'בוטלה — השיחה נוקתה ב-/clear' }
809  }
810}
811
812/** A Codex that would not start: what happened, and where to look. */
813export function launchError(message: string): string {
814  return `Codex לא הופעל: ${message} — בדוק שאפליקציית ChatGPT מותקנת`
815}
816

1// Colour carries meaning only (ROADMAP, design language): ok, needs-you/warn/stale, failed, Codex.
2export const RED = '#D9534F'
3export const AMBER = '#D9A030'
4export const GREEN = '#3FA672'
5export const ACCENT = '#4F8EF7'
6
7/** What a line means, and so its colour; `muted` draws dim, with no colour. */
8export type Tone = 'ok' | 'needs-you' | 'failed' | 'codex' | 'muted'
9
10export function toneColor(tone: Tone): string | undefined {
11  return { ok: GREEN, 'needs-you': AMBER, failed: RED, codex: ACCENT, muted: undefined }[tone]
12}
13

1import type { BoxProps, ElementConstructor, RenderElement, RenderNode } from 'claude-code'
2
3// The line under the prompt, beside the status line (the engine's `SessionMode`),
4// is one drawing the mods share: what the engine draws there, then one button per
5// mod that opens its pane. The engine asks the top mod, whose `next(e)` returns
6// what the mods beneath drew; each mod adds its button to theirs and draws the
7// whole line, so it reads the same in any load order.
8
9/** The buttons' order, by key; a key not listed goes last. */
10const BUTTON_ORDER = ['open-cockpit']
11
12function keyOf(node: RenderNode): string | undefined {
13  if (typeof node === 'string' || !('props' in node)) return undefined
14  const key = (node.props as Record<string, unknown> | undefined)?.key
15  return typeof key === 'string' ? key : undefined
16}
17
18function rank(node: RenderNode): number {
19  const index = BUTTON_ORDER.indexOf(keyOf(node) ?? '')
20  return index === -1 ? BUTTON_ORDER.length : index
21}
22
23/** The line's parts: what the engine (or another plugin) drew there, and the mods' buttons. */
24export type FooterParts = { line: RenderNode[]; buttons: RenderNode[] }
25
26/** This mod's buttons joined with the line the mods beneath drew. */
27export function mergeFooter(mine: RenderNode[], below: RenderElement): FooterParts {
28  const line: RenderNode[] = []
29  const buttons = [...mine]
30  if (below.type === 'Box' && keyOf(below) === 'footer') {
31    for (const child of below.children ?? []) {
32      if (keyOf(child) === 'footer-buttons' && typeof child !== 'string' && child.type === 'Box') {
33        buttons.push(...(child.children ?? []))
34      } else {
35        line.push(child)
36      }
37    }
38  } else {
39    // The engine's own drawing (its mode labels), or another plugin's: kept whole.
40    line.push(below)
41  }
42  return { line, buttons: buttons.sort((a, b) => rank(a) - rank(b)) }
43}
44
45/** The line as one row: what was there, then the buttons, right to left among themselves. */
46export function drawFooter(Box: ElementConstructor<BoxProps>, parts: FooterParts): RenderElement {
47  const buttons = Box({ key: 'footer-buttons', flexDirection: 'row-reverse', gap: 1, alignItems: 'center', children: parts.buttons })
48  return Box({ key: 'footer', flexDirection: 'row', gap: 2, alignItems: 'center', children: [...parts.line, buttons] })
49}
50

1export const STEP_ICONS: Record<'done' | 'doing' | 'todo' | 'blocked', string> = {
2  done: '✓',
3  doing: '▶',
4  todo: '◻',
5  blocked: '⛔',
6}
7
8/** States in the design language: warning or stale, at the limit, failed. */
9export const WARN = '⚠'
10export const LIMIT = '⛔'
11export const FAILED = '✗'
12
13/** States in a headline: working, waiting for the person, at rest, done. */
14export const RUNNING = '●'
15export const NEEDS_YOU = '◆'
16export const IDLE = '○'
17export const OK = '✓'
18

1/** Isolates a run as right-to-left, so its punctuation and numbers sit where a Hebrew reader expects. */
2export function rtl(text: string): string {
3  return `⁧${text}⁩`
4}
5

1// Long text in a pane: a summary of a few rows, and the whole of it split into
2// blocks a Text, Markdown or Code element accepts (at most 10000 characters,
3// tab and newline the only control characters), and the blocks into pages (a
4// tree past 100000 characters of text is refused whole).
5
6export const TEXT_MAX = 10000
7
8const ANSI = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-_]/g
9const CONTROL = /[\x00-\x08\x0b-\x1f\x7f-\x9f]/g
10
11/** Text an element accepts: no ANSI escapes, LF line ends, no control characters but tab and newline. */
12export function cleanText(text: string): string {
13  return text.replace(ANSI, '').replace(/\r\n?/g, '\n').replace(CONTROL, '')
14}
15
16/** One line of at most `max` characters, for a pane title or a label. */
17export function oneLine(text: string, max = 60): string {
18  const line = cleanText(text).replace(/\s+/g, ' ').trim()
19  return line.length > max ? `${cutAt(line, max - 1)}…` : line
20}
21
22/** Text cleaned and held to `max` characters, for one element of a pane. */
23export function bounded(text: string, max = 2000): string {
24  const clean = cleanText(text)
25  return clean.length > max ? `${cutAt(clean, max - 1)}…` : clean
26}
27
28export type Summary = { text: string; isWhole: boolean }
29
30const SKIPPED = /^\s*(#{1,6}\s|(?:-{3,}|\*{3,}|_{3,})\s*$|(?:`{3,}|~{3,})\S*\s*$)/
31
32/**
33 * The text's first paragraph, in at most `rows` rows of `columns` (headings,
34 * rules and fence lines before it skipped); `isWhole` when that is all of it.
35 */
36export function summarize(text: string, options: { rows?: number; columns?: number } = {}): Summary {
37  const rows = options.rows ?? 3
38  const width = Math.min(1000, Math.max(10, (options.columns ?? 80) - 2))
39  const whole = cleanText(text).trim()
40  if (!whole) return { text: '', isWhole: true }
41  const lines = whole.split('\n')
42  let start = 0
43  while (start < lines.length && (lines[start]?.trim() === '' || SKIPPED.test(lines[start] ?? ''))) start++
44  const paragraph: string[] = []
45  for (const line of lines.slice(start)) {
46    if (line.trim() === '') break
47    if (!SKIPPED.test(line)) paragraph.push(line.trimEnd())
48  }
49  const picked: string[] = []
50  let left = rows
51  for (const line of paragraph) {
52    if (left <= 0) break
53    const cost = Math.max(1, Math.ceil(line.length / width))
54    if (cost <= left) {
55      picked.push(line)
56      left -= cost
57    } else {
58      picked.push(`${cutAt(line, left * width - 1)}…`)
59      left = 0
60    }
61  }
62  const summary = picked.join('\n')
63  return { text: summary, isWhole: summary === whole }
64}
65
66/** Cuts at `at` code units, never between the halves of a surrogate pair. */
67function cutAt(text: string, at: number): string {
68  if (at <= 0) return ''
69  if (at >= text.length) return text
70  const code = text.charCodeAt(at - 1)
71  return text.slice(0, code >= 0xd800 && code <= 0xdbff ? at - 1 : at)
72}
73
74/** A line longer than `limit` as pieces of at most `limit`. */
75export function cutLine(line: string, limit: number): string[] {
76  const pieces: string[] = []
77  let rest = line
78  while (rest.length > limit) {
79    const piece = cutAt(rest, limit)
80    pieces.push(piece)
81    rest = rest.slice(piece.length)
82  }
83  pieces.push(rest)
84  return pieces
85}
86
87/** Room kept in each block for a fence closed at its end and reopened at the next one's start. */
88const FENCE_ROOM = 200
89const FENCE_OPEN = /^\s*(`{3,}|~{3,})(.*)$/
90
91/**
92 * Markdown as blocks of at most `max` characters: split between paragraphs where
93 * it can, between lines where it must; a code fence cut in two is closed at the
94 * end of one block and reopened at the start of the next.
95 */
96export function splitMarkdown(text: string, max = TEXT_MAX): string[] {
97  const whole = cleanText(text)
98  if (whole.length <= max) return whole.trim() ? [whole] : []
99  const blocks: string[] = []
100  let lines: string[] = []
101  let size = 0
102  let fence: { mark: string; open: string } | null = null
103  let lastBreak = -1
104  const measure = () => {
105    size = lines.reduce((sum, line, i) => sum + line.length + (i > 0 ? 1 : 0), 0)
106  }
107  const fits = (line: string) => size + (lines.length > 0 ? 1 : 0) + line.length + (fence ? fence.mark.length + 1 : 0) <= max
108  for (const raw of whole.split('\n')) {
109    for (const line of cutLine(raw, max - 2 * FENCE_ROOM)) {
110      while (!fits(line) && lines.length > 0) {
111        if (lastBreak > 0) {
112          // Between paragraphs, outside any fence: the rest moves on whole.
113          blocks.push(lines.slice(0, lastBreak).join('\n'))
114          lines = lines.slice(lastBreak + 1)
115        } else {
116          blocks.push(lines.join('\n') + (fence ? `\n${fence.mark}` : ''))
117          lines = fence ? [fence.open] : []
118        }
119        lastBreak = -1
120        measure()
121      }
122      if (!fence && line.trim() === '') lastBreak = lines.length
123      const opening: RegExpExecArray | null | undefined = fence ? undefined : FENCE_OPEN.exec(line)
124      if (opening) {
125        const mark: string = opening[1] ?? '```'
126        fence = { mark, open: `${mark}${oneLine(opening[2] ?? '', FENCE_ROOM / 2 - mark.length)}` }
127      } else if (fence && line.trim().startsWith(fence.mark) && /^(`+|~+)$/.test(line.trim())) {
128        fence = null
129      }
130      size += (lines.length > 0 ? 1 : 0) + line.length
131      lines.push(line)
132    }
133  }
134  if (lines.some(line => line.trim() !== '')) blocks.push(lines.join('\n'))
135  return blocks.filter(block => block.trim() !== '')
136}
137
138/** Plain text (a command's output) as blocks of at most `max` characters, split between lines. */
139export function splitPlain(text: string, max = TEXT_MAX): string[] {
140  const whole = cleanText(text)
141  if (whole.length <= max) return whole ? [whole] : []
142  const blocks: string[] = []
143  let lines: string[] = []
144  let size = 0
145  for (const raw of whole.split('\n')) {
146    for (const line of cutLine(raw, max)) {
147      const cost = (lines.length > 0 ? 1 : 0) + line.length
148      if (size + cost > max && lines.length > 0) {
149        blocks.push(lines.join('\n'))
150        lines = []
151        size = 0
152      }
153      size += (lines.length > 0 ? 1 : 0) + line.length
154      lines.push(line)
155    }
156  }
157  if (lines.length > 0) blocks.push(lines.join('\n'))
158  return blocks.filter(block => block.length > 0)
159}
160
161/** How much text one drawn tree may hold: the engine refuses a tree past 100000 characters. */
162export const PAGE_MAX = 90000
163
164/** Blocks as pages, each within `budget` characters, so one page is one tree the engine draws. */
165export function pageBlocks(blocks: readonly string[], budget = PAGE_MAX): string[][] {
166  const pages: string[][] = []
167  let page: string[] = []
168  let size = 0
169  for (const block of blocks) {
170    if (page.length > 0 && size + block.length > budget) {
171      pages.push(page)
172      page = []
173      size = 0
174    }
175    page.push(block)
176    size += block.length
177  }
178  if (page.length > 0) pages.push(page)
179  return pages
180}
181
182/**
183 * One line of at most `max` characters with its middle cut out ("cock…pit"), for a
184 * name whose start and end both say something, such as a folder.
185 */
186export function middleTruncate(text: string, max: number): string {
187  const line = cleanText(text).replace(/\s+/g, ' ').trim()
188  if (line.length <= max) return line
189  if (max <= 0) return ''
190  if (max === 1) return '…'
191  const head = cutAt(line, Math.ceil((max - 1) / 2))
192  const tailLength = Math.floor((max - 1) / 2)
193  let tail = tailLength > 0 ? line.slice(line.length - tailLength) : ''
194  // Never begin on the second half of a surrogate pair.
195  const first = tail.charCodeAt(0)
196  if (first >= 0xdc00 && first <= 0xdfff) tail = tail.slice(1)
197  return `${head}…${tail}`
198}
199

1/** "בעוד 2:05 שע'" / "בעוד 3 ימים" — relative, so no time zone is needed. */
2export function formatResetIn(resetsAt: string | undefined, nowMs: number): string {
3  if (!resetsAt) return ''
4  const left = Date.parse(resetsAt) - nowMs
5  if (Number.isNaN(left)) return ''
6  if (left <= 0) return 'התאפס'
7  const minutes = Math.ceil(left / 60_000)
8  if (minutes < 60) return `איפוס בעוד ${minutes} דק'`
9  const hours = Math.floor(minutes / 60)
10  if (hours < 24) return `איפוס בעוד ${hours}:${String(minutes % 60).padStart(2, '0')} שע'`
11  const days = Math.floor(hours / 24)
12  return `איפוס בעוד ${days} ${days === 1 ? 'יום' : 'ימים'} ו-${hours % 24} שע'`
13}
14
15export function formatAge(atMs: number, nowMs: number): string {
16  const minutes = Math.floor((nowMs - atMs) / 60_000)
17  if (minutes < 1) return 'עכשיו'
18  if (minutes < 60) return `לפני ${minutes} דק'`
19  const hours = Math.floor(minutes / 60)
20  if (hours < 24) return `לפני ${hours} שע'`
21  return `לפני ${Math.floor(hours / 24)} ימים`
22}
23

1export type StepStatus = 'todo' | 'doing' | 'done' | 'blocked'
2
3export type Step = { text: string; status: StepStatus }
4
5/** `status` is git's two-letter porcelain code, or `ed` for a file edited outside git. */
6export type ChangedFile = { path: string; status: string; added: number; removed: number }
7
8/** A gate run: `summary` is the up-to-three lines the pane shows; the whole output is `gateOutput`. */
9export type GateRun = {
10  command: string
11  isOk: boolean
12  at: number
13  summary: string[]
14  /** The summary is all the output said, so the pane offers no "read all". */
15  isWhole: boolean
16  /** Where Bash kept an output too large to hand back inline. */
17  outputPath?: string
18  /** The person marked this failure handled: it stops waiting for them. A new run starts unmarked. */
19  isDismissed: boolean
20}
21
22/** How the reader draws a text: Markdown, a unified diff, or a command's plain output. */
23export type ReaderKind = 'markdown' | 'diff' | 'output'
24
25/** What the reader pane shows: the whole text a "read all" opened; `file` when it is a file's diff. */
26export type ReaderDoc = {
27  title: string
28  kind: ReaderKind
29  text: string
30  note?: string
31  /** A note that says something failed draws red; one that warns, amber. */
32  noteTone?: 'warn' | 'failed'
33  at: number
34  file?: ChangedFile
35  /** Which page is shown, from 0: a page holds as much as one drawn tree may. */
36  page?: number
37}
38
39/** The last gate run as a handoff carries it: stale when files changed after it. */
40export type HandoffGate = { command: string; isOk: boolean; isStale: boolean; at: number; summary: string[] }
41
42/**
43 * Where a session left its work, kept in the store per project (`handoff:<root>`) so
44 * the next session there can pick it up. `isTaken` once continued or ignored.
45 */
46export type Handoff = {
47  sessionId: string
48  root: string
49  at: number
50  task: string
51  note: string
52  steps: Step[]
53  /** Steps past the ones kept, and how many of them were not done. */
54  omittedSteps?: number
55  openOmittedSteps?: number
56  files: { path: string; status: string }[]
57  fileCount: number
58  gate: HandoffGate | null
59  isTaken?: boolean
60}
61
62/** A previous session's handoff shown in the pane; quiet once the person wrote something else. */
63export type Incoming = Handoff & { isQuiet: boolean }
64
65/** A model Codex offers this account, as its models cache lists it. */
66export type CodexModel = { slug: string; name: string; efforts: string[]; defaultEffort: string }
67
68/** Which model and reasoning effort a Codex run uses. */
69export type CodexChoice = { model: string; effort: string }
70
71export type ProposalKind = 'plan-review' | 'result-review' | 'question'
72
73/** `cleared`: a /clear ended the conversation before it ran. */
74export type ProposalStatus = 'pending' | 'approved' | 'running' | 'done' | 'declined' | 'failed' | 'cleared'
75
76/** A prompt Claude wants to send to Codex, waiting for the person's approval. */
77export type Proposal = {
78  id: number
79  kind: ProposalKind
80  why: string
81  prompt: string
82  status: ProposalStatus
83  /** The model and effort picked for this proposal; frozen once approved. */
84  choice?: CodexChoice
85  answer?: string
86  /** A decline the runner has already told Claude about, or given up telling. */
87  isReported?: boolean
88  /** Failed tries at telling Claude about a decline. */
89  reportTries?: number
90  /** Why handing the answer (or the decline) to Claude failed, when it did. */
91  deliveryError?: string
92  /** A /clear came while it ran: its answer stays in the pane, not in the new conversation. */
93  isCleared?: boolean
94}
95
96declare module 'claude-code' {
97  interface PluginState {
98    cockpit: {
99      task: string
100      note: string
101      steps: Step[]
102      files: ChangedFile[]
103      isFileListOpen: boolean
104      isGitRepo: boolean
105      lastEditAt: number
106      gate: GateRun | null
107      /** Claude is in a turn of the main loop (`turn.start` to `turn.complete`). */
108      isWorking: boolean
109      /** A previous session's unfinished work, offered until continued or ignored. */
110      incoming: Incoming | null
111      /** "Save knowledge" was shown as a suggestion in this conversation; /clear starts it over. */
112      hasSuggestedSave: boolean
113      /** Claude's proposals to Codex: open ones, then the last few closed. */
114      proposals: Proposal[]
115      /** The models Codex offers this account. */
116      models: CodexModel[]
117      /** The model and effort a new proposal starts with: the last one approved. */
118      proposalChoice: CodexChoice
119      /** The last gate run's whole output; only the reader reads it. */
120      gateOutput: string
121      reader: ReaderDoc | null
122    }
123  }
124}
125