adyusuf

1import type { EngineInterface, Hook, Register } from 'claude-code'
2
3import type { AgentRow, Promotion, Settings, Stage } from '../types'
4import {
5  agentsBody, agentsSummary, FOLDED_AT_START, promotionBody, promotionSummary, section, settingsBody, settingsSummary,
6} from './boxes'
7import type { SectionId } from './boxes'
8import {
9  countOf, DISCOVER_PY, IS_FILE_PY, overrideNote, parseDiscovery, plannedStages, refSet, scriptDir, waivedLines, waivedRange,
10} from './choose'
11
12/** One pane, three bordered boxes in it (Settings, Agents, Promotion), each folded by its header. */
13const BOXES = 'adyusuf-boxes'
14const TITLE = 'adyusuf'
15
16// The pane's values live in `$.state`, declared in ../types; a value never written reads as undefined, so each read names its initial one.
17const settings = { plugin: 'adyusuf', key: 'settings' } as const
18const settingsError = { plugin: 'adyusuf', key: 'settingsError' } as const
19const settingsProblems = { plugin: 'adyusuf', key: 'settingsProblems' } as const
20const promotion = { plugin: 'adyusuf', key: 'promotion' } as const
21const folded = { plugin: 'adyusuf', key: 'folded' } as const
22
23const PLUGIN = 'adyusuf'
24const MARKETPLACE = 'adyusuf-marketplace'
25const PLUGIN_ID = `${PLUGIN}@${MARKETPLACE}`
26
27type Run = (argv: readonly string[]) => Promise<{ exitCode: number; stdout: string; stderr: string }>
28
29/** The configuration script of the INSTALLED adyusuf plugin ('' when it has none yet); the choice is choose.ts's scriptDir. */
30async function scriptPath(run: Run): Promise<string> {
31  const found = await run(['python3', '-c', DISCOVER_PY, MARKETPLACE, PLUGIN])
32  const { record, listing } = parseDiscovery(found.stdout)
33  const dir = scriptDir(record, PLUGIN_ID, listing)
34  if (!dir) return ''
35  const script = `${dir}/scripts/adyusuf_config.py`
36  const has = await run(['python3', '-c', IS_FILE_PY, script])
37  return has.exitCode === 0 ? script : ''
38}
39
40/** This session's id ('' when the engine will not say): the boxes change THIS session's layer only, never the saved defaults. */
41async function sessionId($: EngineInterface): Promise<string> {
42  try {
43    return (await $.session.id()) || ''
44  } catch {
45    return ''
46  }
47}
48
49async function refreshSettings($: EngineInterface) {
50  const run: Run = argv => $.process.run(argv)
51  const script = await scriptPath(run)
52  if (!script) {
53    await $.state.set(settingsError, 'The adyusuf plugin with /adyusuf:config is not installed yet: /plugin update adyusuf')
54    return
55  }
56  const id = await sessionId($)
57  const scope = id ? ['--session', id] : []
58  const shown = await run(['python3', script, 'show', '--json', ...scope])
59  const agents = await run(['python3', script, 'agents', '--json', '--all', ...scope])
60  const schema = await run(['python3', script, 'schema'])
61  if (shown.exitCode !== 0 || agents.exitCode !== 0 || schema.exitCode !== 0) {
62    await $.state.set(settingsError, (shown.stderr || agents.stderr || schema.stderr || 'adyusuf_config.py failed').slice(0, 300))
63    return
64  }
65  try {
66    const data = JSON.parse(shown.stdout) as { values: Settings['values']; sources: Settings['sources']; problems?: string[] }
67    const next: Settings = {
68      schema: JSON.parse(schema.stdout),
69      values: data.values,
70      sources: data.sources,
71      agents: JSON.parse(agents.stdout) as AgentRow[],
72    }
73    await $.state.set(settings, next)
74    await $.state.set(settingsError, '')
75    await $.state.set(settingsProblems, data.problems ?? [])
76  } catch (error) {
77    await $.state.set(settingsError, `Unreadable answer from adyusuf_config.py: ${String(error).slice(0, 200)}`)
78  }
79}
80
81async function refreshPromotion($: EngineInterface) {
82  const git = (args: string[]) => $.process.run(['git', ...args])
83  const refs = await git(['for-each-ref', '--format=%(refname:short)', 'refs/heads', 'refs/remotes/origin'])
84  if (refs.exitCode !== 0) {
85    await $.state.set(promotion, ({ stages: [], error: 'Not inside a git repository' }) as Promotion)
86    return
87  }
88  const stages: Stage[] = []
89  for (const stage of plannedStages(refSet(refs.stdout))) {
90    const tip = await git(['rev-parse', '--short', `origin/${stage.branch}`])
91    const ahead = stage.local ? await git(['rev-list', '--count', `origin/${stage.branch}..${stage.branch}`]) : null
92    const range = waivedRange(stage)
93    const log = range ? await git(['log', '--format=@@%h%n%B', range]) : null
94    stages.push({
95      branch: stage.branch,
96      origin: tip.stdout.trim(),
97      unpushed: ahead ? countOf(ahead.stdout) : 0,
98      waived: log && log.exitCode === 0 ? waivedLines(log.stdout) : [],
99    })
100  }
101  await $.state.set(promotion, ({ stages }) as Promotion)
102}
103
104
105async function setSetting($: EngineInterface, key: string, value: string) {
106  const run: Run = argv => $.process.run(argv)
107  const script = await scriptPath(run)
108  if (!script) {
109    await $.ui.toast('The adyusuf plugin is not installed yet: /plugin install adyusuf@adyusuf-marketplace')
110    return
111  }
112  const id = await sessionId($)
113  if (!id) {
114    await $.ui.toast('Could not tell which session this is, so nothing was changed (the saved defaults stay as they are)')
115    return
116  }
117  const done = await run(['python3', script, 'set', '--session', id, key, value])
118  if (done.exitCode !== 0) await $.ui.toast(done.stderr.trim().slice(0, 200) || 'The change was refused')
119  await refreshSettings($)
120  const { value: now = null } = await $.state.get(settings)
121  if (done.exitCode === 0 && now) {
122    const note = overrideNote(key, value, now.values[key], now.sources[key])
123    if (note) await $.ui.toast(note)
124  }
125}
126
127/** A failing read must never stop the session from starting; the Settings box says what failed instead of waiting forever. */
128async function safely($: EngineInterface, work: Promise<void>) {
129  try {
130    await work
131  } catch (error) {
132    await $.state.set(settingsError, `Could not read: ${String(error).slice(0, 200)}`)
133  }
134}
135
136/** Folds or unfolds one box of the pane; called from a press, never while drawing. */
137async function flip($: EngineInterface, id: SectionId) {
138  const { value: now = FOLDED_AT_START } = await $.state.get(folded)
139  await $.state.set(folded, { ...now, [id]: !now[id] })
140}
141
142// Clicks run one after another: two settings changed quickly must not race each other's read-modify-write.
143let queue: Promise<void> = Promise.resolve()
144function click($: EngineInterface, key: string, value: string) {
145  queue = queue.then(() => setSetting($, key, value)).catch(() => undefined)
146}
147
148const onStart: Hook<'session.start'> = async ($, e, next) => {
149  await $.command.register({ name: 'adyusuf:panels', description: 'Open the adyusuf settings, agents and promotion boxes' })
150  void $.ui.open({ id: BOXES, title: TITLE })
151  await safely($, refreshSettings($))
152  await safely($, refreshPromotion($))
153  return next(e)
154}
155
156const onPanels: Hook<'command.run'> = async $ => {
157  await $.ui.open({ id: BOXES, title: TITLE })
158  await safely($, refreshSettings($))
159  await safely($, refreshPromotion($))
160  return { text: 'adyusuf boxes opened.' }
161}
162
163// The boxes follow the work: a turn may have merged, pushed or changed a setting through /adyusuf:config.
164const onTurnComplete: Hook<'turn.complete'> = async ($, e, next) => {
165  await safely($, refreshSettings($))
166  await safely($, refreshPromotion($))
167  return next(e)
168}
169
170const onRender: Hook<'ui.render'> = async ($, e) => {
171  const ui = { ...$.ui.resolve(e), h }
172  const { Box } = ui
173  const { value: data = null } = await $.state.get(settings)
174  const { value: problem = '' } = await $.state.get(settingsError)
175  const { value: problems = [] } = await $.state.get(settingsProblems)
176  const { value: stages = null } = await $.state.get(promotion)
177  const { value: fold = FOLDED_AT_START } = await $.state.get(folded)
178  const press = (key: string, value: string) => click($, key, value)
179  const toggle = (id: SectionId) => () => void flip($, id)
180  return (
181    <Box flexDirection="column">
182      {section(ui, 'settings', 'Settings', settingsSummary(data), fold.settings === true, toggle('settings'),
183        settingsBody(ui, data, problem, problems, press))}
184      {section(ui, 'agents', 'Agents', agentsSummary(data), fold.agents === true, toggle('agents'),
185        agentsBody(ui, data, press))}
186      {section(ui, 'promotion', 'Promotion', promotionSummary(stages), fold.promotion === true, toggle('promotion'),
187        promotionBody(ui, stages))}
188    </Box>
189  )
190}
191
192export const register: Register = on => {
193  on('session.start', onStart)
194  on('command.run', { command: 'adyusuf:panels' }, onPanels)
195  on('turn.complete', onTurnComplete)
196  on('ui.render', { component: 'Pane', requestId: BOXES }, onRender)
197}
198

1// What the boxes of the adyusuf pane show, kept apart from the engine so it can be tested without one: no import from
2// 'claude-code', no JSX. The element factory `h` and the elements themselves (Box, Text, Button) are handed in as
3// `ui`: each surface has its own elements, and a test hands in a recording factory instead of the engine's. A choice among
4// several values is a radio list (one Button per option, `(•)` on the chosen one), not a dropdown (user decision 24/10/2026).
5import { enabledFor, settingGroups } from './choose'
6
7export type Factory = (type: unknown, props: Record<string, unknown> | null, ...children: unknown[]) => unknown
8export type Ui = { h: Factory; Box: unknown; Text: unknown; Button: unknown }
9export type Press = (key: string, value: string) => void
10
11type Spec = { key: string; type: 'bool' | 'enum'; label: string; group: string; options?: string[] }
12type AgentRow = { role: string; defined: string; runs_on: string; active: boolean; in_mode: boolean; enabled: string; model: string }
13type SettingsData = { schema: Spec[]; values: Record<string, boolean | string>; sources: Record<string, string>; agents: AgentRow[] }
14type Stage = { branch: string; origin: string; unpushed: number; waived: string[] }
15type PromotionData = { stages: Stage[]; error?: string }
16
17export const SECTIONS = ['settings', 'agents', 'promotion'] as const
18export type SectionId = (typeof SECTIONS)[number]
19
20/** Sections that start folded, so the pane opens as a short card and not as one long list. */
21export const FOLDED_AT_START: Record<string, boolean> = { agents: true, promotion: true }
22
23const AGENT_MODELS = ['default', 'opus', 'sonnet', 'haiku', 'fable']
24
25type Option = { value: string; label: string }
26
27/** A radio list: the label, then one pressable line per option, the chosen one marked `(•)`. `wrap` lays the options in a row. */
28export function radio(ui: Ui, key: string, label: string, options: Option[], value: string, press: Press, wrap = false) {
29  const { h } = ui
30  return h(
31    ui.Box,
32    { flexDirection: 'column' },
33    h(ui.Text, {}, label),
34    h(ui.Box, wrap ? { flexDirection: 'row', flexWrap: 'wrap', columnGap: 2, paddingLeft: 2 } : { flexDirection: 'column', paddingLeft: 2 },
35      options.map(option =>
36        h(ui.Button, { key: `${key}=${option.value}`, plain: true, onPress: () => press(key, option.value) },
37          `${option.value === value ? '(•)' : '( )'} ${option.label}`))),
38  )
39}
40
41/** One bordered box with a header that folds it; the summary stays visible while it is folded. */
42export function section(ui: Ui, id: SectionId, title: string, summary: string, folded: boolean, toggle: () => void, body: unknown) {
43  const { h } = ui
44  return h(
45    ui.Box,
46    { flexDirection: 'column', borderStyle: 'round', paddingX: 1, marginBottom: 1 },
47    h(ui.Button, { key: `fold-${id}`, plain: true, onPress: toggle },
48      folded ? '▸ ' : '▾ ',
49      h(ui.Text, { bold: true }, title),
50      summary ? h(ui.Text, { dimColor: true }, `  ${summary}`) : ''),
51    folded ? null : body,
52  )
53}
54
55export function settingsSummary(data: SettingsData | null): string {
56  if (!data) return ''
57  const changed = Object.values(data.sources).filter(source => source === 'session').length
58  return changed > 0 ? `${changed} changed in this session` : 'this session only'
59}
60
61export function agentsSummary(data: SettingsData | null): string {
62  if (!data) return ''
63  const mode = String(data.values.mode)
64  return mode === 'A' ? 'mode A: no agents' : `mode ${mode}: ${data.agents.filter(agent => agent.active).length} of ${data.agents.length} active`
65}
66
67export function promotionSummary(data: PromotionData | null): string {
68  if (!data || data.error) return ''
69  return data.stages.map(stage => `${stage.branch} ${stage.origin}`).join(' · ')
70}
71
72export function settingsBody(ui: Ui, data: SettingsData | null, problem: string, problems: string[], press: Press) {
73  const { h } = ui
74  if (!data) return h(ui.Text, { dimColor: true }, problem || 'Reading the configuration…')
75  const { groups, shown } = settingGroups(data.schema)
76  return h(
77    ui.Box,
78    { flexDirection: 'column' },
79    problem !== '' ? h(ui.Text, { color: 'red' }, problem) : null,
80    problems.map(line => h(ui.Text, { color: 'yellow' }, `! ${line}`)),
81    groups.map(group =>
82      h(ui.Box, { flexDirection: 'column', marginBottom: 1 },
83        h(ui.Text, { bold: true, dimColor: true }, group),
84        shown.filter(spec => spec.group === group).map(spec => {
85          const value = data.values[spec.key]
86          const from = data.sources[spec.key]
87          const tag = from && from !== 'default' ? ` (${from})` : ''
88          if (spec.type === 'bool') {
89            return h(ui.Button, { key: spec.key, onPress: () => void press(spec.key, value === true ? 'no' : 'yes') },
90              value === true ? '[x] ' : '[ ] ', spec.label, tag)
91          }
92          return radio(ui, spec.key, `${spec.label}${tag}:`, (spec.options ?? []).map(option => ({ value: option, label: option })), String(value), press)
93        })),
94    ),
95    h(ui.Text, { dimColor: true }, 'Changes apply to this session only; a new session starts from your saved defaults (/adyusuf:config saves them).'),
96  )
97}
98
99export function agentsBody(ui: Ui, data: SettingsData | null, press: Press) {
100  const { h } = ui
101  if (!data) return h(ui.Text, { dimColor: true }, 'Reading the configuration…')
102  const mode = String(data.values.mode)
103  const model = String(data.values.mode_model)
104  return h(
105    ui.Box,
106    { flexDirection: 'column' },
107    h(ui.Text, { dimColor: true }, `Opus agents run on ${model === 'keep' ? 'their defined model' : model} unless one is set below`),
108    h(ui.Box, { flexDirection: 'column', marginTop: 1 },
109      data.agents.map(agent =>
110        h(ui.Box, { flexDirection: 'column', marginBottom: 1 },
111          h(ui.Button, {
112            key: `on-${agent.role}`,
113            onPress: () => {
114              if (mode === 'A') return
115              press(`agents.${agent.role}.enabled`, enabledFor(!agent.active, agent.in_mode))
116            },
117          }, `${agent.active ? '[x] ' : '[ ] '}${agent.role}${!agent.in_mode && agent.active ? ' (added)' : ''}${agent.in_mode && !agent.active && mode !== 'A' ? ' (off)' : ''}`),
118          agent.active
119            ? radio(ui, `agents.${agent.role}.model`, `  model (defined ${agent.defined}):`,
120              AGENT_MODELS.map(option => ({ value: option, label: option === 'default' ? `default (${agent.runs_on})` : option })),
121              agent.model, press, true)
122            : null)),
123    ),
124    h(ui.Text, { dimColor: true }, "A box ticked beyond the mode's set adds that agent; cleared, it removes one."),
125  )
126}
127
128export function promotionBody(ui: Ui, data: PromotionData | null) {
129  const { h } = ui
130  if (!data) return h(ui.Text, { dimColor: true }, 'Reading the branches…')
131  if (data.error) return h(ui.Text, { dimColor: true }, data.error)
132  return h(
133    ui.Box,
134    { flexDirection: 'column' },
135    data.stages.map(stage =>
136      h(ui.Box, { flexDirection: 'column', marginBottom: 1 },
137        h(ui.Text, { bold: true }, `${stage.branch.padEnd(5)} origin ${stage.origin}${stage.unpushed > 0 ? `  ${stage.unpushed} not pushed` : '  pushed'}`),
138        stage.waived.length === 0
139          ? h(ui.Text, { dimColor: true }, 'no waived gate on the way in')
140          : stage.waived.map(line => h(ui.Text, { color: 'yellow' }, `waived ${line}`)))),
141    data.stages.length === 0 ? h(ui.Text, { dimColor: true }, 'No dev, test or prod branch here.') : null,
142  )
143}
144

1// Pure decisions of the boxes, kept apart from the drawing so they can be tested without an engine.
2
3/**
4 * The folder the plugin manager says `id` is installed in, from the text of installed_plugins.json ('' when it
5 * names none). Not the newest folder in the cache: a replaced version is marked and then becomes the newest.
6 */
7export function installPathOf(text: string, id: string): string {
8  try {
9    const entry = (JSON.parse(text) as { plugins?: Record<string, unknown> }).plugins?.[id]
10    const entries = Array.isArray(entry) ? entry : entry ? [entry] : []
11    for (const one of entries) {
12      const path = (one as { installPath?: unknown }).installPath
13      if (typeof path === 'string' && path !== '') return path.replace(/\/$/, '')
14    }
15  } catch {
16    // an unreadable record names nothing
17  }
18  return ''
19}
20
21/** Whether the value the script now reports is the one that was asked for (yes/no settings are booleans). */
22export function isWanted(value: unknown, wanted: string): boolean {
23  if (typeof value === 'boolean') return value === (wanted === 'yes')
24  return String(value) === wanted
25}
26
27/** What to write into `agents.<role>.enabled` so that the agent ends up `want` (on/off), given the mode's own set. */
28export function enabledFor(want: boolean, inMode: boolean): 'auto' | 'on' | 'off' {
29  if (want === inMode) return 'auto'
30  return want ? 'on' : 'off'
31}
32
33/** `<short sha> <gates> (neden: ...)` for every `Gate-Waived:` line of a `git log --format=@@%h%n%B` output. */
34export function waivedLines(log: string): string[] {
35  const out: string[] = []
36  let sha = ''
37  for (const line of log.split('\n')) {
38    if (line.startsWith('@@')) sha = line.slice(2)
39    else if (line.startsWith('Gate-Waived:')) out.push(`${sha} ${line.slice('Gate-Waived:'.length).trim()}`)
40  }
41  return out
42}
43
44/** The message for a click that changed nothing because a higher layer wins ('' when the click took effect). */
45export function overrideNote(key: string, wanted: string, value: unknown, source: string | undefined): string {
46  if (isWanted(value, wanted)) return ''
47  const from = source && source !== 'default' ? `the ${source} layer` : 'another layer'
48  return `${key} stays ${String(value)}: ${from} sets it, and it wins over the user's file`
49}
50
51/**
52 * The newest installed copy of the plugin that is not marked as replaced, from the lines `live <dir>` / `orphaned <dir>`
53 * that parseDiscovery builds, newest first ('' when there is none). Only used when the plugin manager's
54 * record names no folder.
55 */
56export function newestLiveDir(output: string): string {
57  for (const line of output.split('\n')) {
58    const [state, ...rest] = line.trim().split(/\s+/)
59    if (state === 'live' && rest.length > 0) return rest.join(' ').replace(/\/$/, '')
60  }
61  return ''
62}
63
64/**
65 * Python run as `python3 -c <this> <marketplace> <plugin>`: prints the plugin manager's record and the plugin's cache
66 * folders (newest first, each `live` or `orphaned`) as one JSON object. The panel needs no shell for this: the engine's
67 * process runner could not find `sh` on Windows (24/10/2026), and `python3` is needed for the configuration script anyway.
68 */
69export const DISCOVER_PY = [
70  'import json, os, sys',
71  "base = os.path.join(os.path.expanduser('~'), '.claude', 'plugins')",
72  'try:',
73  "    record = open(os.path.join(base, 'installed_plugins.json'), encoding='utf-8').read()",
74  'except OSError:',
75  "    record = ''",
76  "root = os.path.join(base, 'cache', sys.argv[1], sys.argv[2])",
77  'dirs = [os.path.join(root, d) for d in os.listdir(root)] if os.path.isdir(root) else []',
78  'dirs = sorted((d for d in dirs if os.path.isdir(d)), key=os.path.getmtime, reverse=True)',
79  "rows = [['orphaned' if os.path.exists(os.path.join(d, '.orphaned_at')) else 'live', d.replace(os.sep, '/')] for d in dirs]",
80  "sys.stdout.write(json.dumps({'record': record, 'cache': rows}))",
81].join('\n')
82
83/** Python run as `python3 -c <this> <path>`: exit 0 when `path` is a file, 1 when it is not. */
84export const IS_FILE_PY = 'import os, sys; sys.exit(0 if os.path.isfile(sys.argv[1]) else 1)'
85
86/**
87 * What DISCOVER_PY printed, as the record text and the `live <dir>` / `orphaned <dir>` lines newestLiveDir reads
88 * (both empty when the output is not what the script prints).
89 */
90export function parseDiscovery(output: string): { record: string; listing: string } {
91  try {
92    const data = JSON.parse(output) as { record?: unknown; cache?: unknown }
93    const rows = Array.isArray(data.cache) ? data.cache : []
94    const lines = rows
95      .filter((row): row is [string, string] => Array.isArray(row) && typeof row[0] === 'string' && typeof row[1] === 'string')
96      .map(([state, dir]) => `${state} ${dir}`)
97    return { record: typeof data.record === 'string' ? data.record : '', listing: lines.join('\n') }
98  } catch {
99    return { record: '', listing: '' }
100  }
101}
102
103/** The folder that holds the configuration script: the recorded one, else the newest live one in the cache. */
104export function scriptDir(recordText: string, id: string, cacheListing: string): string {
105  return installPathOf(recordText, id) || newestLiveDir(cacheListing)
106}
107
108/** The sections of the Settings box: the groups in schema order, and the settings that are shown (agents have their own box). */
109export function settingGroups<T extends { key: string; group: string }>(schema: T[]): { groups: string[]; shown: T[] } {
110  const shown = schema.filter(spec => !spec.key.startsWith('agents.'))
111  const groups: string[] = []
112  for (const spec of shown) if (!groups.includes(spec.group)) groups.push(spec.group)
113  return { groups, shown }
114}
115
116export type PlannedStage = { branch: string; previous: string; local: boolean }
117
118/** The promotion stages to read, in order: a stage exists when `origin/<branch>` does; `previous` is the stage before it. */
119export function plannedStages(have: Set<string>, order: readonly string[] = ['dev', 'test', 'prod']): PlannedStage[] {
120  const out: PlannedStage[] = []
121  order.forEach((branch, index) => {
122    if (!have.has(`origin/${branch}`)) return
123    const previous = index > 0 && have.has(`origin/${order[index - 1]}`) ? order[index - 1] : ''
124    out.push({ branch, previous, local: have.has(branch) })
125  })
126  return out
127}
128
129/** The git range of commits that reached `branch`'s origin from its previous stage's origin ('' for the first stage). */
130export function waivedRange(stage: PlannedStage): string {
131  return stage.previous ? `origin/${stage.branch}..origin/${stage.previous}` : ''
132}
133
134/** The number in git's `--count` output (0 when it is not one). */
135export function countOf(text: string): number {
136  return Number(text.trim()) || 0
137}
138
139/** The refs git printed, one per line, as a set. */
140export function refSet(text: string): Set<string> {
141  return new Set(text.split('\n').map(line => line.trim()).filter(Boolean))
142}
143

1export type Spec = { key: string; type: 'bool' | 'enum'; label: string; group: string; options?: string[] }
2export type AgentRow = {
3  role: string
4  defined: string
5  runs_on: string
6  active: boolean
7  in_mode: boolean
8  /** agents.<role>.enabled: auto, on or off */
9  enabled: string
10  /** agents.<role>.model: default or a model name */
11  model: string
12}
13export type Settings = {
14  schema: Spec[]
15  values: Record<string, boolean | string>
16  sources: Record<string, string>
17  agents: AgentRow[]
18}
19export type Stage = { branch: string; origin: string; unpushed: number; waived: string[] }
20export type Promotion = { stages: Stage[]; error?: string }
21
22declare module 'claude-code' {
23  interface PluginState {
24    'adyusuf': {
25      /** The effective configuration, read through the plugin's own script; null until the first read. */
26      settings: Settings | null
27      /** Why the settings could not be read (script missing, bad JSON); empty when they could. */
28      settingsError: string
29      /** Problems the script reports about the configuration files (an unreadable or invalid layer); empty when none. */
30      settingsProblems: string[]
31      promotion: Promotion | null
32      /** Which of the pane's boxes are folded, by id (settings, agents, promotion); the pane starts with agents and promotion folded. */
33      folded: Record<string, boolean>
34    }
35  }
36}
37