kimaki 1.3.0 → 1.5.0

package/src/coordinator.ts

@@ -0,0 +1,168 @@
+// Coordinator notes: when a thread session finishes a run, its coordinator learns
+// about it, so the coordinator always knows what happened in its project.
+//
+//   thread run ends ─▶ `kimaki send --wait` prompt, wait not over, target busy? ─▶ no note: the wait prints the answer
+//                  ├─▶ run prompt sent by a coordinator (`sender`)?      ─▶ note + wake that coordinator
+//                  └─▶ else (user steered, routine), channel coordinator? ─▶ silent note (read at next prompt)
+//
+// Who sent the prompt is in its metadata (`sender`, prompt.ts), read from the
+// run's messages: no state of its own. The note is a synthetic inbox item, like
+// OpenCode's own subagent completion (core/src/session/subagent-completion.ts):
+// `resume` decides if it wakes the session.
+
+import { isCoordinatorChannel, oc, projectOf, readMarker, type Bot } from './bot.ts'
+import type { RunEnded } from './event-loop.ts'
+import { createLogger } from './logger.ts'
+import { IDLE_REPLY } from './plugin/coordinator.ts'
+import type { Sender } from './prompt.ts'
+import { finalAnswer, formatDuration, formatTokens, sessionUsage, type Message } from './session-events.ts'
+import { escapeAttribute } from './system-prompt.ts'
+
+const logger = createLogger('COORDINATOR')
+
+// A woken coordinator reads the whole answer; a silent note only says what happened.
+const WAKE_ANSWER_CHARS = 2_000
+const NOTE_ANSWER_CHARS = 400
+const USER_PROMPT_CHARS = 1_000
+const RUN_PAGE_MESSAGES = 30
+// A run longer than this only loses uploads from its first steps.
+const MAX_RUN_PAGES = 10
+
+// The messages of the last run, oldest first: pages back until its user prompt.
+async function lastRunMessages(bot: Bot, sessionId: string) {
+  const messages: Message[] = []
+  let cursor: string | undefined
+  for (let page = 0; page < MAX_RUN_PAGES; page++) {
+    const result = await oc(bot, 'message.list', (client) =>
+      client.message.list({ sessionID: sessionId, limit: RUN_PAGE_MESSAGES, ...(cursor ? { cursor } : { order: 'desc' as const }) }),
+    )
+    if (result instanceof Error) return result
+    messages.push(...result.data)
+    cursor = result.cursor.next ?? undefined
+    if (!cursor || result.data.some((message) => message.type === 'user')) break
+  }
+  return messages.reverse()
+}
+
+// Who wrote the run's prompt, from its metadata (prompt.ts): a sender
+// (`kimaki send`, routine, sleep wake) or a person in Discord.
+function runPrompt(messages: readonly Message[]): { sender: Sender | null; user: { username: string; text: string } | null } {
+  const prompt = messages.findLast((message) => message.type === 'user')
+  if (prompt?.type !== 'user') return { sender: null, user: null }
+  const sender: unknown = prompt.metadata?.['sender']
+  if (sender && typeof sender === 'object') {
+    const sessionId: unknown = Reflect.get(sender, 'sessionId')
+    const waitUntil: unknown = Reflect.get(sender, 'waitUntil')
+    return { sender: { ...(typeof sessionId === 'string' && { sessionId }), ...(typeof waitUntil === 'number' && { waitUntil }) }, user: null }
+  }
+  const discord: unknown = prompt.metadata?.['discord']
+  const username: unknown = discord && typeof discord === 'object' ? Reflect.get(discord, 'username') : null
+  return { sender: null, user: typeof username === 'string' ? { username, text: prompt.text } : null }
+}
+
+// The coordinator a session belongs to: the root of its conversation when that is
+// a coordinator channel. The sender may be a subagent of that coordinator.
+async function coordinatorOf(bot: Bot, sessionId: string): Promise<string | null> {
+  const { sessionThreads, roots } = bot.store.getState()
+  const conversation = sessionThreads[sessionId]
+  if (!conversation || !(await holdsCoordinator(bot, conversation))) return null
+  return roots[conversation] ?? null
+}
+
+function cut(text: string, max: number): string {
+  return text.length <= max ? text : `${text.slice(0, max)}…`
+}
+
+// A conversation that is a project channel in coordinator mode holds a coordinator.
+async function holdsCoordinator(bot: Bot, conversationId: string): Promise<boolean> {
+  if (!isCoordinatorChannel(bot, conversationId)) return false
+  const project = await projectOf(bot, conversationId)
+  return !(project instanceof Error) && project !== null
+}
+
+// The project channel of a session thread, from its view or from Discord.
+async function channelOfThread(bot: Bot, threadId: string): Promise<string | null> {
+  const view = bot.store.getState().threads[threadId]
+  if (view) return view.channelId
+  const channel = await bot.discord.channels.fetch(threadId).catch(() => null)
+  return channel?.isThread() ? channel.parentId : null
+}
+
+// The run's prompt came from `kimaki send --wait`, the run ended before the wait
+// ran out and the target still runs: it is waiting in that shell call, which
+// prints the answer. A target that is idle lost its wait (shell timeout,
+// interrupt), so it gets the note.
+async function isWaiting(bot: Bot, target: string): Promise<boolean> {
+  const active = await oc(bot, 'session.active', (client) => client.session.active())
+  // On a failed check the note goes out: a duplicate is better than a lost result.
+  if (active instanceof Error) {
+    logger.warn(`wait check of ${target}`, active)
+    return false
+  }
+  return target in active
+}
+
+async function noteRunEnded(bot: Bot, run: RunEnded): Promise<void> {
+  const channelId = await channelOfThread(bot, run.threadId)
+  // The coordinator's own runs, and threads outside any project channel.
+  if (!channelId || channelId === run.threadId) return
+  const [info, messages] = await Promise.all([
+    oc(bot, 'session.get', (client) => client.session.get({ sessionID: run.sessionId })),
+    lastRunMessages(bot, run.sessionId),
+  ])
+  if (info instanceof Error) return logger.warn(`note of ${run.sessionId}`, info)
+  if (messages instanceof Error) return logger.warn(`answer of ${run.sessionId}`, messages)
+  const marker = readMarker(info.metadata)
+  const { sender, user } = runPrompt(messages)
+  // TODO: also note sessions on other machines (remote `kimaki send`, OpenCode workspaces).
+  // Their bot cannot reach this OpenCode server: relay the note through a Discord envelope
+  // in the coordinator channel, like remote-send.ts does for prompts.
+  // Only a run a coordinator prompted wakes it. The user steering the thread, routines and
+  // other senders leave a silent note in the channel's coordinator.
+  const sentBy = sender?.sessionId ? await coordinatorOf(bot, sender.sessionId) : null
+  const wake = sentBy !== null
+  const target = sentBy ?? (isCoordinatorChannel(bot, channelId) ? bot.store.getState().roots[channelId] : undefined)
+  if (!target || target === run.sessionId) return
+  if (sender?.waitUntil !== undefined && Date.now() < sender.waitUntil && (await isWaiting(bot, target))) return
+  const answer = run.error ?? finalAnswer(messages) ?? 'Finished without a text answer.'
+  const state = run.error ? 'error' : 'completed'
+  const title = info.title || 'Untitled'
+  const routine = marker?.task ? ` routine="#${marker.task.id}"` : ''
+  // Context size and run length, so the coordinator knows when a follow-up would rewrite a big cache.
+  const usage = sessionUsage(messages)
+  const stats = usage ? ` context="${formatTokens(usage.contextTokens)} tokens"${usage.runMs === null ? '' : ` duration="${formatDuration(usage.runMs)}"`}` : ''
+  const text = [
+    `<session-finished sessionID="${run.sessionId}" threadID="${run.threadId}" state="${state}" title="${escapeAttribute(title)}"${routine}${stats} wake="${wake}">`,
+    // The user steered this thread directly: the coordinator must know what they asked.
+    ...(user ? [`<user-prompt username="${escapeAttribute(user.username)}">\n${cut(user.text, USER_PROMPT_CHARS)}\n</user-prompt>`] : []),
+    cut(answer, wake ? WAKE_ANSWER_CHARS : NOTE_ANSWER_CHARS),
+    `More: kimaki session read ${run.sessionId}`,
+    ...(wake ? [`The user sees nothing else about this. When it is work they asked for, a failure or a decision they must make, tell them the outcome in a few plain sentences, with the thread link <#${run.threadId}> once. Otherwise reply exactly ${IDLE_REPLY}.`] : []),
+    '</session-finished>',
+  ].join('\n')
+  const sent = await oc(bot, 'session.synthetic', (client) =>
+    client.session.synthetic({
+      sessionID: target,
+      text,
+      description: `${title} finished`,
+      metadata: { source: 'kimaki-session', sessionID: run.sessionId, threadID: run.threadId, title, state, wake },
+      resume: wake,
+    }),
+  )
+  if (sent instanceof Error) return logger.warn(`note of ${run.sessionId} to ${target}`, sent)
+  logger.log(`${wake ? 'woke' : 'noted'} coordinator ${target}: ${run.sessionId} ${state}`)
+}
+
+export function createCoordinatorNotes() {
+  const registered: { bot: Bot | null } = { bot: null }
+  return {
+    register(bot: Bot) {
+      registered.bot = bot
+    },
+    runEnded(run: RunEnded) {
+      const bot = registered.bot
+      // No channel in coordinator mode: no note to send, so no OpenCode reads.
+      if (bot && (bot.coordinatorDefault || Object.values(bot.store.getState().coordinator).includes(true))) void noteRunEnded(bot, run)
+    },
+  }
+}

package/src/db.test.ts

@@ -89,6 +89,7 @@ test('fresh install gets kimaki.db with the kimaki tables; subcommands never cre
       "bot_settings",
       "bot_tokens",
       "channel_agents",
+      "channel_coordinator",
       "channel_directories",
       "channel_mention_mode",
       "channel_models",

package/src/diagram.test.ts

@@ -0,0 +1,56 @@
+import { render } from 'pele'
+import { expect, test } from 'vitest'
+
+import { computeCustomProperties, renderDiagram, withColorClasses } from './diagram.ts'
+
+const NESTED = `flowchart LR
+  subgraph outer[Outer]
+    subgraph inner[Inner]
+      a[A]:::blue --> b[(B)]
+    end
+  end
+  b -->|label| c{C}
+  classDef blue fill:#0b1f38,stroke:#1d68c5`
+
+test('computes inherited custom properties, fallbacks and color-mix', () => {
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" style="--_a:var(--theme-a,#ffffff);--_b:var(--missing,#000000);width:10px"><g style="--_a:#ff0000"><rect fill="var(--_a)" stroke="color-mix(in srgb,var(--_a) 50%,var(--_b))"/></g><rect fill="var(--_a)" style="rx:var(--_r, 4px)"/></svg>`
+  expect(computeCustomProperties(svg, new Map([['--theme-a', '#00ff00']]))).toMatchInlineSnapshot(`"<svg xmlns="http://www.w3.org/2000/svg" style="width:10px"><g><rect fill="#ff0000" stroke="#800000"/></g><rect fill="#00ff00" rx="4px"/></svg>"`)
+})
+
+test('leaves no var() or color-mix() in pele output', () => {
+  const svg = computeCustomProperties(render(NESTED, { padding: 24 }).svg)
+  expect(svg).not.toContain('var(')
+  expect(svg).not.toContain('color-mix')
+  expect(svg).toContain('fill="#ffffff"')
+})
+
+test('renders a png and reports syntax errors with position', () => {
+  const png = renderDiagram(NESTED)
+  if (png instanceof Error) throw png
+  expect(png.subarray(1, 4).toString()).toBe('PNG')
+  const dark = renderDiagram(NESTED, { theme: 'dark' })
+  if (dark instanceof Error) throw dark
+  expect(dark.equals(png)).toBe(false)
+
+  const error = renderDiagram('flowchart LR\n  a --> \n  b[unclosed')
+  expect(error instanceof Error ? error.message : 'no error').toMatchInlineSnapshot(`
+    "Parse error on line 11:
+
+    ^
+    Expecting 'SQE', 'UNICODE_TEXT', 'TEXT', 'TAGSTART', got '$end'"
+  `)
+})
+
+test('adds built-in color classes the source does not define', () => {
+  expect(withColorClasses('flowchart LR\n  a:::blue --> b:::teal\n  classDef teal,red fill:#000')).toMatchInlineSnapshot(`
+    "flowchart LR
+      a:::blue --> b:::teal
+      classDef teal,red fill:#000
+      classDef blue fill:#edf5fb,stroke:#a0c3e2,color:#141413
+      classDef green fill:#eef6f0,stroke:#a7c8af,color:#141413
+      classDef purple fill:#f3effa,stroke:#bfb1de,color:#141413
+      classDef pink fill:#fbeef3,stroke:#e0abbf,color:#141413
+      classDef amber fill:#fbf5e8,stroke:#e2c893,color:#141413"
+  `)
+  expect(withColorClasses('sequenceDiagram\n  A->>B: hi')).toBe('sequenceDiagram\n  A->>B: hi')
+})

package/src/diagram.ts

@@ -0,0 +1,243 @@
+// `kimaki diagram`: renders Mermaid source to a PNG for Discord, which shows
+// SVG attachments as code, not as images. pele (https://pele.run) lays out
+// the diagram as SVG in pure JS; resvg rasterizes it with the bundled Geist fonts.
+// Loaded lazily by the CLI command, so the static imports cost nothing at startup.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Resvg } from '@resvg/resvg-js'
+import * as errore from 'errore'
+import { DomUtils, parseDocument } from 'htmlparser2'
+import { detectType, render } from 'pele'
+import postcss from 'postcss'
+import valueParser, { type Node as ValueNode } from 'postcss-value-parser'
+
+const FONTS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'assets', 'fonts')
+const SCALE = 2
+const PADDING = 24
+// Inherited by every shape without its own width, edges included.
+const STROKE_WIDTH = 1.5
+// Share of the hue in a color class border; the rest is its fill, for soft borders.
+const BORDER_HUE = 0.5
+// Discord shrinks long images until labels are unreadable; a square one reads best.
+// The compact candidate asks pele for the narrowest layout: wrapped labels and `LR`
+// turned into `TB` (https://pele.run/api#narrow-screens).
+const SQUARE_CANDIDATES = [{ autoDirection: false }, { maxWidth: 1, autoDirection: true, directionBreakpoint: Infinity }]
+
+type ColorName = 'blue' | 'green' | 'purple' | 'pink' | 'amber' | 'red' | 'teal'
+type Palette = { readonly [name in ColorName]: { fill: string; stroke: string } }
+
+// Category hues, built in as classDefs so diagrams only write `node:::blue`.
+// Light: the claude-style palette of the diagrams-and-charts skill. Dark: Vercel/Next.js docs.
+const LIGHT_COLORS: Palette = {
+  blue: { fill: '#edf5fb', stroke: '#5290c8' },
+  green: { fill: '#eef6f0', stroke: '#5f9a6d' },
+  purple: { fill: '#f3effa', stroke: '#8a72c2' },
+  pink: { fill: '#fbeef3', stroke: '#c4688a' },
+  amber: { fill: '#fbf5e8', stroke: '#c99a3e' },
+  red: { fill: '#fbeeee', stroke: '#c8524f' },
+  teal: { fill: '#ebf6f4', stroke: '#3f9a8f' },
+}
+
+const DARK_COLORS: Palette = {
+  blue: { fill: '#0b1f38', stroke: '#1d68c5' },
+  green: { fill: '#1a2c1e', stroke: '#49a45f' },
+  purple: { fill: '#251931', stroke: '#8955a7' },
+  pink: { fill: '#371523', stroke: '#c14c70' },
+  amber: { fill: '#4c3d20', stroke: '#f2b342' },
+  red: { fill: '#3c1618', stroke: '#e5484d' },
+  teal: { fill: '#0d2d2a', stroke: '#12a594' },
+}
+
+export type DiagramTheme = 'light' | 'dark'
+
+type Theme = { colors: Palette; vars: ReadonlyMap<string, string> }
+
+// pele's CSS variables (https://pele.run/theming).
+function theme({ colors, base }: { colors: Palette; base: Record<string, string> }): Theme {
+  const vars = new Map(Object.entries({
+    ...base,
+    '--pele-radius': '10px',
+    '--pele-font': 'Geist, sans-serif',
+    '--pele-font-mono': 'Geist Mono, monospace',
+    '--pele-series-1': colors.blue.stroke,
+    '--pele-series-2': colors.amber.stroke,
+    '--pele-series-3': colors.green.stroke,
+    '--pele-series-4': colors.pink.stroke,
+    '--pele-series-5': colors.purple.stroke,
+    '--pele-series-6': base['--pele-accent']!,
+    '--pele-series-7': colors.red.stroke,
+    '--pele-series-8': colors.teal.stroke,
+  }))
+  return { colors, vars }
+}
+
+const THEMES: { readonly [name in DiagramTheme]: Theme } = {
+  light: theme({
+    colors: LIGHT_COLORS,
+    base: {
+      '--pele-bg': '#faf9f5',
+      '--pele-fg': '#141413',
+      '--pele-muted': '#72736e',
+      '--pele-line': '#8c8b85',
+      '--pele-surface': '#ffffff',
+      '--pele-surface-alt': '#efeee5',
+      '--pele-border': '#d1cfc5',
+      '--pele-accent': '#d97757',
+      '--pele-critical': LIGHT_COLORS.pink.stroke,
+      '--pele-error': LIGHT_COLORS.red.stroke,
+    },
+  }),
+  dark: theme({
+    colors: DARK_COLORS,
+    base: {
+      '--pele-bg': '#0a0a0a',
+      '--pele-fg': '#ededed',
+      '--pele-muted': '#8f8f8f',
+      '--pele-line': '#878787',
+      '--pele-surface': '#171717',
+      '--pele-surface-alt': '#232323',
+      '--pele-border': '#3d3d3d',
+      '--pele-accent': '#4a8fe7',
+      '--pele-critical': DARK_COLORS.pink.stroke,
+      '--pele-error': DARK_COLORS.red.stroke,
+    },
+  }),
+}
+
+export class DiagramError extends errore.createTaggedError({
+  name: 'DiagramError',
+  message: '$reason',
+}) {}
+
+// resvg and librsvg do not support CSS custom properties, which pele uses for
+// every color. This does the browser's job on the parsed SVG: custom properties
+// inherit down the element tree, and every var() and color-mix() in attributes
+// and inline styles is computed to a plain value. resvg also ignores rx/ry in
+// style (pele writes rx:var(--_r)), so they move to attributes.
+// TODO: drop this once resvg resolves var(). https://github.com/linebender/resvg/issues/821
+export function computeCustomProperties(svg: string, vars: ReadonlyMap<string, string> = THEMES.light.vars): string {
+  const document = parseDocument(svg, { xmlMode: true })
+  for (const child of document.children) visit(child, vars)
+  return DomUtils.getOuterHTML(document, { xmlMode: true })
+}
+
+type DomNode = ReturnType<typeof parseDocument>['children'][number]
+
+function visit(node: DomNode, inherited: ReadonlyMap<string, string>) {
+  if (!DomUtils.isTag(node)) return
+  const vars = new Map(inherited)
+  const { style, ...attributes } = node.attribs
+  if (style) {
+    const declarations = postcss.parse(style).nodes.filter((child) => child.type === 'decl')
+    // Custom properties first: they apply to this element's own declarations too.
+    for (const decl of declarations) if (decl.prop.startsWith('--')) vars.set(decl.prop, computeValue(decl.value, vars))
+    for (const decl of declarations) if (decl.prop === 'rx' || decl.prop === 'ry') node.attribs[decl.prop] = computeValue(decl.value, vars)
+    const kept = declarations
+      .filter((decl) => !decl.prop.startsWith('--') && decl.prop !== 'rx' && decl.prop !== 'ry')
+      .map((decl) => `${decl.prop}:${computeValue(decl.value, vars)}`)
+    if (kept.length > 0) node.attribs.style = kept.join(';')
+    else delete node.attribs.style
+  }
+  for (const [name, value] of Object.entries(attributes)) node.attribs[name] = computeValue(value, vars)
+  for (const child of node.children) visit(child, vars)
+}
+
+function computeValue(value: string, vars: ReadonlyMap<string, string>): string {
+  if (!value.includes('var(') && !value.includes('color-mix(')) return value
+  const parsed = valueParser(value)
+  computeNodes(parsed.nodes, vars)
+  return parsed.toString()
+}
+
+// Replaces var() and color-mix() function nodes in place with word nodes.
+function computeNodes(nodes: ValueNode[], vars: ReadonlyMap<string, string>) {
+  for (const node of nodes) {
+    if (node.type !== 'function') continue
+    computeNodes(node.nodes, vars)
+    if (node.value === 'var') {
+      const [name, ...rest] = splitArgs(node.nodes)
+      const fallback = rest.length > 0 ? rest.join(',') : undefined
+      replaceWithWord(node, vars.get(name ?? '') ?? fallback ?? 'initial')
+    } else if (node.value === 'color-mix') {
+      const mixed = colorMix(splitArgs(node.nodes))
+      if (mixed) replaceWithWord(node, mixed)
+    }
+  }
+}
+
+function splitArgs(nodes: ValueNode[]): string[] {
+  const args: ValueNode[][] = [[]]
+  for (const node of nodes) {
+    if (node.type === 'div' && node.value === ',') args.push([])
+    else args.at(-1)!.push(node)
+  }
+  return args.map((arg) => valueParser.stringify(arg).trim())
+}
+
+function replaceWithWord(node: ValueNode, value: string) {
+  Object.assign(node, { type: 'word', value, nodes: undefined })
+}
+
+// color-mix(in srgb, <hex> [<pct>], <hex> [<pct>]): the only form pele emits.
+function colorMix([space, first, second]: string[]): string | undefined {
+  if (space !== 'in srgb' || !first || !second) return undefined
+  const [colorA, percentA] = first.split(/\s+/)
+  const [colorB, percentB] = second.split(/\s+/)
+  const weightA = percentA ? parseFloat(percentA) / 100 : percentB ? 1 - parseFloat(percentB) / 100 : 0.5
+  return mixHex({ a: colorA, b: colorB, weightA })
+}
+
+function mixHex({ a, b, weightA }: { a: string | undefined; b: string | undefined; weightA: number }): string | undefined {
+  const channelsA = hexChannels(a)
+  const channelsB = hexChannels(b)
+  if (!channelsA || !channelsB) return undefined
+  return `#${channelsA.map((channel, i) => Math.round(channel * weightA + channelsB[i]! * (1 - weightA)).toString(16).padStart(2, '0')).join('')}`
+}
+
+function hexChannels(color: string | undefined): number[] | undefined {
+  if (!color || !/^#[0-9a-f]{6}$/i.test(color)) return undefined
+  return [1, 3, 5].map((i) => parseInt(color.slice(i, i + 2), 16))
+}
+
+// Renders Mermaid source to PNG bytes. pele syntax errors already include the line and a pointer.
+// Diagram types whose grammar accepts classDef lines.
+const CLASS_DEF_TYPES = new Set(['flowchart', 'swimlane', 'state', 'class', 'er', 'requirement'])
+
+// Appends a classDef per color the source does not define itself.
+export function withColorClasses(source: string, theme: DiagramTheme = 'light'): string {
+  const type = detectType(source)
+  if (!type || !CLASS_DEF_TYPES.has(type)) return source
+  const { colors, vars } = THEMES[theme]
+  const defined = new Set(source.split('\n').flatMap((line) => line.trim().match(/^classDef\s+(\S+)/)?.[1]?.split(',') ?? []))
+  const lines = Object.entries(colors)
+    .filter(([name]) => !defined.has(name))
+    .map(([name, { fill, stroke }]) => `  classDef ${name} fill:${fill},stroke:${mixHex({ a: stroke, b: fill, weightA: BORDER_HUE })},color:${vars.get('--pele-fg')}`)
+  return [source.trimEnd(), ...lines].join('\n')
+}
+
+export function renderDiagram(source: string, { theme = 'light' }: { theme?: DiagramTheme } = {}): DiagramError | Buffer {
+  const { vars } = THEMES[theme]
+  const colored = withColorClasses(source, theme)
+  const renders = errore.try(
+    () => SQUARE_CANDIDATES.map((layout) => render(colored, { fontFamily: 'Geist', fontFamilyMono: 'Geist Mono', padding: PADDING, responsive: false, links: false, images: false, ...layout })),
+    (error) => new DiagramError({ reason: error instanceof Error ? error.message : String(error) }),
+  )
+  if (renders instanceof Error) return renders
+  const squareness = ({ width, height }: { width: number; height: number }) => Math.abs(Math.log(width / height))
+  const result = renders.reduce((best, candidate) => (squareness(candidate) < squareness(best) ? candidate : best))
+  const fontFiles = fs.readdirSync(FONTS_DIR).filter((file) => file.endsWith('.ttf')).map((file) => path.join(FONTS_DIR, file))
+  return errore.try(
+    () => {
+      const svg = result.svg.replace('<svg ', `<svg stroke-width="${STROKE_WIDTH}" `)
+      const resvg = new Resvg(computeCustomProperties(svg, vars), {
+        background: vars.get('--pele-bg'),
+        fitTo: { mode: 'zoom', value: SCALE },
+        font: { loadSystemFonts: false, fontFiles, defaultFontFamily: 'Geist', sansSerifFamily: 'Geist', monospaceFamily: 'Geist Mono' },
+      })
+      return resvg.render().asPng()
+    },
+    (error) => new DiagramError({ reason: `Rasterizing failed: ${error instanceof Error ? error.message : String(error)}`, cause: error }),
+  )
+}

package/src/duration.ts

@@ -1,18 +1,26 @@
-// Relative durations like `30m` or `2h` (`session wait --timeout`, `kimaki sleep --duration`).
+// Relative durations like `30m`, `2h` or `1 hour` (`session wait --timeout`, `kimaki sleep --duration`).
 // Dependency-light so the CLI can use it without loading bot modules.
 
 import { ConfigError } from './errors.ts'
 
-const DURATION = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)$/i
-const DURATION_MS = new Map(Object.entries({ ms: 1, s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 }))
+const DURATION = /^(\d+(?:\.\d+)?)\s*([a-z]+)$/i
+const UNITS: ReadonlyArray<[number, string[]]> = [
+  [1, ['ms', 'milli', 'millis']],
+  [1_000, ['s', 'second', 'seconds']],
+  [60_000, ['m', 'minute', 'minutes']],
+  [3_600_000, ['h', 'hour', 'hours']],
+  [86_400_000, ['d', 'day', 'days']],
+]
+const DURATION_MS = new Map(UNITS.flatMap(([ms, names]) => names.map((name) => [name, ms] as const)))
 
 // Milliseconds of a positive duration: a number plus ms, s, m, h, or d.
 // `label` names the input in errors, for example a flag like `--duration`.
 export function parseDuration(text: string, label = 'duration'): ConfigError | number {
   const trimmed = text.trim()
   const match = DURATION.exec(trimmed)
-  if (!match) return new ConfigError({ reason: `Invalid ${label} "${trimmed}". Use a number plus ms, s, m, h, or d (example: 2h)` })
-  const amount = Number(match[1]) * DURATION_MS.get(match[2]!.toLowerCase())!
+  const unit = match ? DURATION_MS.get(match[2]!.toLowerCase()) : undefined
+  if (!match || !unit) return new ConfigError({ reason: `Invalid ${label} "${trimmed}". Use a number plus ms, s, m, h, or d (example: 2h)` })
+  const amount = Number(match[1]) * unit
   if (!(amount > 0)) return new ConfigError({ reason: `${label.charAt(0).toUpperCase()}${label.slice(1)} must be greater than 0` })
   return amount
 }