tablero-despacho

1import type { EngineInterface, Register } from 'claude-code'
2
3import type { TableroBoard } from '../types'
4import { loadConfig } from './orca-config'
5import type { Host } from './orca-config'
6import {
7  FIELDS,
8  GITHUB_REMOTE,
9  bandText,
10  checksText,
11  explainGhFailure,
12  parsePrs,
13  parseWorktrees,
14  prompts,
15  relativeTime,
16  reviewText,
17} from './tablero'
18
19const PANE = 'tablero'
20const EVERY_MS = 3 * 60 * 1000
21const board = { plugin: 'tablero-despacho', key: 'board' } as const
22
23const empty: TableroBoard = { status: 'unknown', message: '', prs: [], at: 0, hasDespacho: false }
24
25// The engine's `$` cannot cross an import: the config module gets these closures instead.
26const hostOf = ($: EngineInterface): Host => ({
27  home: async () => (await $.env.get('USERPROFILE')) ?? (await $.env.get('HOME')),
28  exists: path => $.fs.exists(path),
29  read: path => $.fs.read(path),
30  git: argv => $.process.run(argv, { timeoutMs: 10_000 }),
31  now: () => $.clock.now(),
32})
33
34const refresh = async ($: EngineInterface): Promise<void> => {
35  let hasDespacho = false
36  const put = (next: Omit<TableroBoard, 'at' | 'hasDespacho'>) =>
37    $.clock.now().then(at => $.state.set(board, { ...next, at, hasDespacho }))
38
39  // Nothing runs outside a git repository with a GitHub remote.
40  const repo = await $.session.repo()
41  if (repo === null || repo.remote === null || !GITHUB_REMOTE.test(repo.remote)) {
42    await put({ status: 'norepo', message: '', prs: [] })
43    return
44  }
45  // The dispatch buttons exist only when the project config declares `despacho`.
46  const script = (await loadConfig(hostOf($))).despacho?.script
47  hasDespacho = typeof script === 'string' && script.trim() !== ''
48  try {
49    const gh = await $.process.run(
50      ['gh', 'pr', 'list', '--state', 'open', '--limit', '50', '--json', FIELDS],
51      { timeoutMs: 20_000 },
52    )
53    if (gh.exitCode !== 0) {
54      const failure = explainGhFailure(gh.stderr)
55      await put(
56        failure.kind === 'norepo'
57          ? { status: 'norepo', message: '', prs: [] }
58          : { status: 'error', message: failure.message, prs: [] },
59      )
60      return
61    }
62    const git = await $.process.run(['git', 'worktree', 'list', '--porcelain']).catch(() => undefined)
63    const worktrees = parseWorktrees(git?.exitCode === 0 ? git.stdout : '')
64    await put({ status: 'ok', message: '', prs: parsePrs(gh.stdout, worktrees) })
65  } catch {
66    await put({
67      status: 'error',
68      message: 'No pude correr gh: ¿está instalado y en el PATH?',
69      prs: [],
70    })
71  }
72}
73
74export const register: Register = on => {
75  on('session.start', async ($, e, next) => {
76    await $.command.register({
77      name: 'tablero',
78      description: 'Abre el tablero de PRs, checks, reviews y worktrees',
79    })
80    // Off the start-up path: the first read must not hold the session back.
81    $.clock.after(0, () => void refresh($))
82    $.clock.every(EVERY_MS, () => void refresh($))
83
84    return next(e)
85  })
86
87  on('command.run', { command: 'tablero' }, async $ => {
88    await $.ui.open({ id: PANE, title: 'Tablero de despacho' })
89    await refresh($)
90
91    return { text: 'Tablero de despacho abierto.' }
92  })
93
94  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
95    const { value = empty } = await $.state.get(board)
96    if (e.props.hasSurvey || value.status !== 'ok' || value.prs.length === 0) {
97      return next(e)
98    }
99    const { Box, Button, Text } = $.ui.resolve(e)
100
101    return (
102      <Box>
103        <Text dimColor>{bandText(value.prs)} </Text>
104        <Button
105          key="open"
106          label="Tablero"
107          onPress={async () => {
108            await $.ui.open({ id: PANE, title: 'Tablero de despacho' })
109            await refresh($)
110          }}
111        />
112      </Box>
113    )
114  })
115
116  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
117    const { Box, Button, Text } = $.ui.resolve(e)
118    const { value = empty } = await $.state.get(board)
119    const now = await $.clock.now()
120    const send = (text: string) => $.prompt.submit({ text, asUser: true })
121
122    const body =
123      value.status === 'norepo' ? (
124        <Text dimColor>Este directorio no es un repo de git con remoto en GitHub.</Text>
125      ) : value.status === 'error' ? (
126        <Text color="red">{value.message}</Text>
127      ) : value.status !== 'ok' ? (
128        <Text dimColor>Cargando…</Text>
129      ) : value.prs.length === 0 ? (
130        <Text dimColor>No hay PRs abiertos.</Text>
131      ) : (
132        <Box flexDirection="column" gap={1}>
133          {value.prs.map(pr => (
134            <Box key={`pr:${pr.number}`} flexDirection="column">
135              <Text bold>
136                #{pr.number} {pr.title}
137                {pr.isDraft ? ' (borrador)' : ''}
138              </Text>
139              <Text dimColor>
140                {pr.branch} · {pr.author} · {relativeTime(pr.updatedAt, now)}
141              </Text>
142              <Text
143                color={pr.checks.state === 'fail' ? 'red' : pr.checks.state === 'ok' ? 'green' : undefined}
144              >
145                checks {checksText(pr.checks)} · {reviewText(pr.review)}
146                {pr.worktree === undefined ? '' : ` · worktree ${pr.worktree}`}
147              </Text>
148              <Box gap={2}>
149                {value.hasDespacho ? (
150                  <Button
151                    key={`review:${pr.number}`}
152                    label="Revisar con agy"
153                    onPress={() => send(prompts.review(pr.number))}
154                  />
155                ) : null}
156                <Button
157                  key={`status:${pr.number}`}
158                  label="Ver estado"
159                  onPress={() => send(prompts.status(pr.number))}
160                />
161                <Button
162                  key={`gentle:${pr.number}`}
163                  label="Consultar a Gentle Shell"
164                  onPress={() => send(prompts.gentle(pr.number))}
165                />
166                <Button
167                  key={`merge:${pr.number}`}
168                  label="Mergear"
169                  onPress={() => send(prompts.merge(pr.number))}
170                />
171              </Box>
172            </Box>
173          ))}
174        </Box>
175      )
176
177    return (
178      <Box flexDirection="column" gap={1}>
179        <Box gap={2}>
180          <Text dimColor>
181            {value.at === 0 ? 'Sin datos todavía' : `Actualizado ${relativeTime(value.at, now)}`}
182          </Text>
183          <Button key="refresh" label="Actualizar" onPress={() => refresh($)} />
184        </Box>
185        {body}
186      </Box>
187    )
188  })
189}
190

1// Config resolution shared by the orca-stack mods. A plugin can only import files of its own folder,
2// so this file is copied verbatim into each mod that needs it (hooks/orca-config.ts); the repo's
3// tests fail if a copy drifts from this one (edit shared/orca-config.ts, then run `npm run sync-shared`).
4//
5// Three layers, later ones override earlier ones:
6//   1. ~/.orca-stack/config.json        (personal)
7//   2. <repo>/.orca-stack.json          (committed project rules)
8//   3. <repo>/.orca-stack.local.json    (gitignored, local/sensitive)
9// <repo> is the main checkout, even when the session runs inside a git worktree.
10
11export type BlockRule = { agente: string; hasta: string; motivo?: string }
12
13export type StackConfig = {
14  humano?: string
15  mensajes?: { destinatarios?: string[] }
16  despacho?: { script?: string; revisar?: string }
17  riesgo?: string[] // path globs whose change needs a second review before merging (pi, or two other model families when pi wrote it)
18  agentes?: {
19    usa?: string[]
20    preguntarAntes?: string[]
21    modelos?: Record<string, unknown>
22    pi?: { perfil?: string; claudeConfigDir?: string } // perfil: gentle-pi profile name, or "preguntar" (the default)
23  }
24  guardia?: {
25    bloquear?: BlockRule[]
26    modeloClaude?: string
27  }
28}
29
30// Model families. Two agents whose models share a family share blind spots: one does not review the other, and
31// they do not count as two independent reviews. The family comes from the model in `agentes.modelos` (the one the
32// launcher passes with --model): its name, without the provider prefix, against `patterns`, in order. An agent
33// with no model takes `defaults`; pi is `fixed`, because its launcher never passes a model. A model that matches
34// no pattern has no family: nothing is proved about it.
35// The literal between the markers is JSON: src/despacho.mjs keeps the same one, and test/units.test.mjs compares them.
36// BEGIN FAMILIES
37export const FAMILIES = {
38  "agents": ["claude", "agy", "codex", "codex-cc", "pi"],
39  "fixed": { "pi": "claude" },
40  "defaults": { "claude": "claude", "codex": "gpt", "agy": "gemini" },
41  "patterns": [
42    ["claude", "^(claude|opus|sonnet|haiku|fable)"],
43    ["gpt", "^(gpt|codex|o\\d)"],
44    ["gemini", "^gemini"],
45    ["glm", "^glm"]
46  ]
47} as const
48// END FAMILIES
49
50const isPlain = (value: unknown): value is Record<string, unknown> =>
51  value !== null && typeof value === 'object' && !Array.isArray(value)
52
53export const familyOfModel = (model: string): string | undefined => {
54  const name = model.trim().toLowerCase().split('/').pop() ?? ''
55
56  return FAMILIES.patterns.find(([, pattern]) => new RegExp(pattern).test(name))?.[0]
57}
58
59// agentes.modelos.<agent>: "model", { modelo, esfuerzo } or { implementar: {...}, revisar: {...} } (as src/despacho.mjs).
60export const modelFor = (config: StackConfig, agent: string, mode: 'ticket' | 'review'): string | undefined => {
61  let entry = config.agentes?.modelos?.[agent]
62  if (isPlain(entry) && (entry['implementar'] !== undefined || entry['revisar'] !== undefined)) {
63    entry = entry[mode === 'review' ? 'revisar' : 'implementar']
64  }
65  const model = typeof entry === 'string' ? entry : isPlain(entry) ? entry['modelo'] : undefined
66
67  return typeof model === 'string' && model.trim() !== '' ? model.trim() : undefined
68}
69
70// The family `agent` runs on to implement ('ticket') or to review; `model` is the configured one, for messages.
71export const familyOf = (
72  config: StackConfig,
73  agent: string,
74  mode: 'ticket' | 'review',
75): { family: string | undefined; model: string | undefined } => {
76  const fixed = (FAMILIES.fixed as Record<string, string>)[agent]
77  if (fixed !== undefined) {
78    return { family: fixed, model: undefined }
79  }
80  const model = modelFor(config, agent, mode)
81
82  return { family: model === undefined ? (FAMILIES.defaults as Record<string, string>)[agent] : familyOfModel(model), model }
83}
84
85// "2026-10-29" -> local midnight of that day; an agent is blocked while now < that instant.
86export const parseUntil = (date: string): number | undefined => {
87  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date.trim())
88  if (match === null) {
89    return undefined
90  }
91  const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])]
92  const at = new Date(year, month - 1, day)
93  // Round trip: 2026-02-30 would silently become 2026-03-02.
94  if (at.getFullYear() !== year || at.getMonth() !== month - 1 || at.getDate() !== day) {
95    return undefined
96  }
97
98  return at.getTime()
99}
100
101// Why `agent` cannot be dispatched now, or undefined. A rule with a bad date stops it too: a block must not
102// vanish because of a typo.
103export const blockOf = (config: StackConfig, agent: string, now: number): string | undefined => {
104  for (const rule of config.guardia?.bloquear ?? []) {
105    if (typeof rule?.agente !== 'string' || rule.agente.toLowerCase() !== agent.toLowerCase()) {
106      continue
107    }
108    const until = typeof rule.hasta === 'string' ? parseUntil(rule.hasta) : undefined
109    if (until === undefined) {
110      return `La regla guardia.bloquear de ${agent} tiene una fecha "hasta" que no es AAAA-MM-DD (${String(rule.hasta)}): corregila antes de despacharlo.`
111    }
112    if (now < until) {
113      return typeof rule.motivo === 'string' && rule.motivo.trim() !== '' ? rule.motivo : `${agent} está bloqueado hasta el ${rule.hasta}.`
114    }
115  }
116
117  return undefined
118}
119
120// Plain objects merge key by key; anything else (arrays included) is replaced by the later layer.
121const mergePlain = (...layers: unknown[]): Record<string, unknown> => {
122  const out: Record<string, unknown> = {}
123  for (const layer of layers) {
124    if (!isPlain(layer)) {
125      continue
126    }
127    for (const [key, value] of Object.entries(layer)) {
128      const before = out[key]
129      out[key] = isPlain(value) && isPlain(before) ? mergePlain(before, value) : value
130    }
131  }
132
133  return out
134}
135
136// One exception: `guardia.bloquear` adds up across the layers, so a block in one layer cannot be dropped by another.
137export const mergeConfig = (...layers: unknown[]): StackConfig => {
138  const out = mergePlain(...layers) as StackConfig
139  const rules = layers.flatMap(layer => {
140    const guardia = isPlain(layer) ? layer['guardia'] : undefined
141    const list = isPlain(guardia) ? guardia['bloquear'] : undefined
142
143    return Array.isArray(list) ? (list as BlockRule[]) : []
144  })
145  if (rules.length > 0) {
146    out.guardia = { ...out.guardia, bloquear: rules }
147  }
148
149  return out
150}
151
152export const parseJson = (text: string): unknown => {
153  try {
154    return JSON.parse(text.replace(/^/, ''))
155  } catch {
156    return undefined
157  }
158}
159
160const slashed = (path: string): string => {
161  let out = path.split('\\').join('/')
162  while (out.length > 1 && out.endsWith('/')) {
163    out = out.slice(0, -1)
164  }
165
166  return out
167}
168
169// Output of `git rev-parse --path-format=absolute --git-common-dir --show-toplevel`:
170// the main checkout is the parent of the common `.git` dir; a bare repo falls back to the toplevel.
171export const repoRootFrom = (stdout: string): string | undefined => {
172  const [common, top] = stdout.split(/\r?\n/).map(line => line.trim())
173  if (common !== undefined && common !== '') {
174    const dir = slashed(common)
175    if (dir.endsWith('/.git')) {
176      return dir.slice(0, -'/.git'.length)
177    }
178  }
179
180  return top === undefined || top === '' ? undefined : slashed(top)
181}
182
183// The engine's `$` cannot cross an import, so the host passes the few operations this module needs
184// as closures: { home: async () => (await $.env.get('USERPROFILE')) ?? (await $.env.get('HOME')), exists: p => $.fs.exists(p), read: p => $.fs.read(p),
185// git: argv => $.process.run(argv, { timeoutMs: 10_000 }), now: () => $.clock.now() }.
186export type Host = {
187  home: () => Promise<string | undefined>
188  exists: (path: string) => Promise<boolean>
189  read: (path: string) => Promise<string>
190  git: (argv: string[]) => Promise<{ exitCode: number; stdout: string }>
191  now: () => Promise<number>
192}
193
194export const homeOf = async (host: Host): Promise<string | undefined> => {
195  let home: string | undefined
196  try {
197    home = await host.home()
198  } catch {
199    home = undefined
200  }
201
202  return home === undefined || home === '' ? undefined : slashed(home)
203}
204
205const readLayer = async (host: Host, path: string): Promise<unknown> => {
206  try {
207    if (!(await host.exists(path))) {
208      return undefined
209    }
210
211    return parseJson(await host.read(path))
212  } catch {
213    return undefined
214  }
215}
216
217export const repoRoot = async (host: Host): Promise<string | undefined> => {
218  try {
219    const git = await host.git(['git', 'rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel'])
220
221    return git.exitCode === 0 ? repoRootFrom(git.stdout) : undefined
222  } catch {
223    return undefined
224  }
225}
226
227// Whether the repo opted into orca-stack, with `.orca-stack.json` or `.orca-stack.local.json`: mods that inject text
228// into the session, or that gate on it, only do so in such a project.
229export const hasProjectConfig = async (host: Host): Promise<boolean> => {
230  const root = await repoRoot(host)
231  if (root === undefined) {
232    return false
233  }
234  for (const name of ['.orca-stack.json', '.orca-stack.local.json']) {
235    try {
236      if (await host.exists(`${root}/${name}`)) {
237        return true
238      }
239    } catch {
240      // An unreadable layer counts as missing.
241    }
242  }
243
244  return false
245}
246
247const loadFor = async (host: Host, home: string | undefined, root: string | undefined): Promise<StackConfig> =>
248  mergeConfig(
249    home === undefined ? undefined : await readLayer(host, `${home}/.orca-stack/config.json`),
250    root === undefined ? undefined : await readLayer(host, `${root}/.orca-stack.json`),
251    root === undefined ? undefined : await readLayer(host, `${root}/.orca-stack.local.json`),
252  )
253
254// Never throws: a missing or broken layer is skipped.
255export const loadConfig = async (host: Host): Promise<StackConfig> =>
256  loadFor(host, await homeOf(host), await repoRoot(host))
257
258// loadConfig with a short memory, for hooks that run on every tool call. The memory is keyed by the
259// resolved home and repo root, so switching to another checkout never serves the previous one's rules.
260let remembered: { key: string; at: number; config: StackConfig } | undefined
261
262export const currentConfig = async (host: Host, maxAgeMs = 30_000): Promise<StackConfig> => {
263  const home = await homeOf(host)
264  const root = await repoRoot(host)
265  const key = `${home ?? ''}|${root ?? ''}`
266  const now = await host.now()
267  if (remembered !== undefined && remembered.key === key && now - remembered.at < maxAgeMs) {
268    return remembered.config
269  }
270  const config = await loadFor(host, home, root)
271  remembered = { key, at: now, config }
272
273  return config
274}
275
276export const forgetConfig = (): void => {
277  remembered = undefined
278}
279

1// Pure helpers for the dispatch board: parse gh/git output and word it in Spanish.
2
3import type { TableroChecks, TableroPr } from '../types'
4
5export const FIELDS =
6  'number,title,headRefName,author,isDraft,reviewDecision,statusCheckRollup,updatedAt'
7
8export const GITHUB_REMOTE = /github\.com[:/]/i
9
10type Check = {
11  status?: string
12  conclusion?: string
13  state?: string
14}
15
16const FAILED = new Set(['FAILURE', 'TIMED_OUT', 'CANCELLED', 'ACTION_REQUIRED', 'STARTUP_FAILURE', 'ERROR'])
17const PENDING = new Set(['PENDING', 'EXPECTED', 'QUEUED', 'IN_PROGRESS', 'WAITING', 'REQUESTED'])
18
19export const summarizeChecks = (rollup: readonly Check[]): TableroChecks => {
20  let failed = 0
21  let pending = 0
22  for (const check of rollup) {
23    const verdict = (check.conclusion || check.state || check.status || '').toUpperCase()
24    if (FAILED.has(verdict)) {
25      failed += 1
26    } else if (PENDING.has(verdict) || (check.status !== undefined && check.status !== 'COMPLETED')) {
27      pending += 1
28    }
29  }
30  const total = rollup.length
31  if (total === 0) {
32    return { state: 'none', done: 0, total: 0 }
33  }
34  if (failed > 0) {
35    return { state: 'fail', done: failed, total }
36  }
37  if (pending > 0) {
38    return { state: 'pending', done: total - pending, total }
39  }
40
41  return { state: 'ok', done: total, total }
42}
43
44export const checksText = (checks: TableroChecks): string =>
45  ({
46    none: 'sin checks',
47    ok: `✓ ${checks.done}/${checks.total}`,
48    fail: `✗ ${checks.done} rojo${checks.done === 1 ? '' : 's'} de ${checks.total}`,
49    pending: `… ${checks.done}/${checks.total}`,
50  })[checks.state]
51
52export const reviewText = (review: TableroPr['review']): string =>
53  ({
54    approved: 'review aprobada',
55    changes: 'cambios pedidos',
56    required: 'review pendiente',
57    none: 'sin review',
58  })[review]
59
60const reviewOf = (decision: string | undefined): TableroPr['review'] =>
61  decision === 'APPROVED'
62    ? 'approved'
63    : decision === 'CHANGES_REQUESTED'
64      ? 'changes'
65      : decision === 'REVIEW_REQUIRED'
66        ? 'required'
67        : 'none'
68
69type RawPr = {
70  number: number
71  title: string
72  headRefName: string
73  author?: { login?: string }
74  isDraft?: boolean
75  reviewDecision?: string
76  statusCheckRollup?: Check[] | null
77  updatedAt?: string
78}
79
80// branch -> folder name of the worktree that has it checked out
81export const parseWorktrees = (porcelain: string): Map<string, string> => {
82  const byBranch = new Map<string, string>()
83  let path = ''
84  for (const line of porcelain.split(/\r?\n/)) {
85    if (line.startsWith('worktree ')) {
86      path = line.slice('worktree '.length).trim()
87    } else if (line.startsWith('branch refs/heads/')) {
88      byBranch.set(line.slice('branch refs/heads/'.length).trim(), path.split(/[\\/]/).pop() ?? path)
89    }
90  }
91
92  return byBranch
93}
94
95export const parsePrs = (json: string, worktrees: Map<string, string>): TableroPr[] => {
96  const raw = JSON.parse(json) as RawPr[]
97
98  return raw.map(pr => ({
99    number: pr.number,
100    title: pr.title,
101    branch: pr.headRefName,
102    author: pr.author?.login ?? '?',
103    isDraft: pr.isDraft === true,
104    review: reviewOf(pr.reviewDecision),
105    checks: summarizeChecks(pr.statusCheckRollup ?? []),
106    updatedAt: Date.parse(pr.updatedAt ?? '') || 0,
107    worktree: worktrees.get(pr.headRefName),
108  }))
109}
110
111export const relativeTime = (at: number, now: number): string => {
112  const minutes = Math.max(0, Math.round((now - at) / 60_000))
113  if (minutes < 1) {
114    return 'recién'
115  }
116  if (minutes < 60) {
117    return `hace ${minutes} min`
118  }
119  if (minutes < 60 * 24) {
120    return `hace ${Math.round(minutes / 60)} h`
121  }
122
123  return `hace ${Math.round(minutes / (60 * 24))} d`
124}
125
126export const bandText = (prs: readonly TableroPr[]): string => {
127  const ready = prs.filter(pr => pr.review === 'approved').length
128  const red = prs.filter(pr => pr.checks.state === 'fail').length
129  const parts = [`${prs.length} abierto${prs.length === 1 ? '' : 's'}`]
130  if (ready > 0) {
131    parts.push(`${ready} con review lista`)
132  }
133  if (red > 0) {
134    parts.push(`${red} con checks rojos`)
135  }
136
137  return `PRs: ${parts.join(' · ')}`
138}
139
140export type GhFailure = { kind: 'norepo' } | { kind: 'error'; message: string }
141
142// Short Spanish message for a failed gh call.
143export const explainGhFailure = (stderr: string): GhFailure => {
144  if (/not a git repository|no git remotes|none of the git remotes|could not determine base repo/i.test(stderr)) {
145    return { kind: 'norepo' }
146  }
147  if (/gh auth login|not logged in|authentication|GH_TOKEN|HTTP 401/i.test(stderr)) {
148    return { kind: 'error', message: 'gh no está autenticado: corré gh auth login.' }
149  }
150  const first = stderr.trim().split(/\r?\n/)[0] ?? ''
151
152  return { kind: 'error', message: `No pude leer los PRs${first === '' ? '.' : `: ${first.slice(0, 120)}`}` }
153}
154
155export const prompts = {
156  review: (n: number): string => `Lanzá el review del PR #${n} con agy`,
157  status: (n: number): string => `Fijate el PR #${n} y decime cómo está`,
158  merge: (n: number): string => `Si no hay bloqueos, mergeá el PR #${n}`,
159  gentle: (n: number): string => `Consultá a Gentle Shell sobre el PR #${n}`,
160}
161

1export type TableroChecks = {
2  state: 'ok' | 'fail' | 'pending' | 'none'
3  done: number
4  total: number
5}
6
7export type TableroPr = {
8  number: number
9  title: string
10  branch: string
11  author: string
12  isDraft: boolean
13  review: 'approved' | 'changes' | 'required' | 'none'
14  checks: TableroChecks
15  updatedAt: number
16  worktree?: string
17}
18
19export type TableroBoard = {
20  status: 'unknown' | 'loading' | 'ok' | 'norepo' | 'error'
21  message: string
22  prs: TableroPr[]
23  at: number
24  hasDespacho: boolean
25}
26
27declare module 'claude-code' {
28  interface PluginState {
29    'tablero-despacho': { board: TableroBoard }
30  }
31}
32