opencode-extended-sidebar 0.2.90

package/src/pware.oc.core/pware.oc.core.sqlite.ts

@@ -0,0 +1,175 @@
+/**
+ * Thin readonly SQLite handle: prefers bun:sqlite, falls back to node:sqlite.
+ * Never writes. Returns null when neither backend / DB is available.
+ */
+import { createRequire } from "node:module"
+import fs from "node:fs"
+import { dbg, profile, pushScreenLine } from "./pware.oc.core.debug.js"
+
+export type SqlRow = Record<string, unknown>
+
+export type SqlDb = {
+  all: <T extends SqlRow = SqlRow>(sql: string, ...params: unknown[]) => T[]
+  get: <T extends SqlRow = SqlRow>(sql: string, ...params: unknown[]) => T | null
+  close: () => void
+}
+
+const require = createRequire(import.meta.url)
+
+/**
+ * Lock wait before a query fails with SQLITE_BUSY. Fail-fast: a transient WAL
+ * checkpoint lock should surface as an error row (and a `sql.busy` debug line)
+ * instead of blocking the whole TUI for seconds.
+ */
+const BUSY_TIMEOUT_MS = 100
+
+/** One-line query label for the profile log; computed lazily (profiling off = free). */
+function sqlLabel(sql: string): string {
+  return sql.replace(/\s+/g, " ").trim().slice(0, 80)
+}
+
+/** True when a thrown error is a SQLite lock/busy failure (SQLITE_BUSY). */
+export function isBusyError(e: unknown): boolean {
+  return e instanceof Error ? /locked|busy/i.test(e.message) : false
+}
+
+/**
+ * Run a query, logging a `sql.busy` debug line when the DB is locked. The
+ * error still propagates so `withDbRead` can retry once and then soft-fail.
+ */
+function guardQuery<T>(sql: string, fn: () => T): T {
+  try {
+    return fn()
+  } catch (e) {
+    if (isBusyError(e)) dbg("sql.busy", "db locked", { q: sqlLabel(sql) })
+    throw e
+  }
+}
+
+function wrapBun(db: {
+  query: (sql: string) => { all: (...p: unknown[]) => SqlRow[]; get: (...p: unknown[]) => SqlRow | null }
+  exec: (sql: string) => void
+  close: () => void
+}): SqlDb {
+  try {
+    db.exec("PRAGMA query_only = ON")
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`)
+  } catch {
+    // older / restricted
+  }
+  return {
+    all: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
+      profile("sql", () => guardQuery(sql, () => db.query(sql).all(...params) as T[]), () => ({ q: sqlLabel(sql) })),
+    get: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
+      profile("sql", () => guardQuery(sql, () => (db.query(sql).get(...params) as T | null) ?? null), () => ({ q: sqlLabel(sql) })),
+    close: () => {
+      try {
+        db.close()
+      } catch {
+        // ignore
+      }
+    },
+  }
+}
+
+function wrapNodeSync(db: {
+  prepare: (sql: string) => {
+    all: (...p: unknown[]) => SqlRow[]
+    get: (...p: unknown[]) => SqlRow | undefined
+  }
+  exec: (sql: string) => void
+  close: () => void
+}): SqlDb {
+  try {
+    db.exec("PRAGMA query_only = ON")
+    db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`)
+  } catch {
+    // ignore
+  }
+  return {
+    all: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
+      profile("sql", () => guardQuery(sql, () => db.prepare(sql).all(...params) as T[]), () => ({ q: sqlLabel(sql) })),
+    get: <T extends SqlRow>(sql: string, ...params: unknown[]) =>
+      profile("sql", () => guardQuery(sql, () => (db.prepare(sql).get(...params) as T | undefined) ?? null), () => ({ q: sqlLabel(sql) })),
+    close: () => {
+      try {
+        db.close()
+      } catch {
+        // ignore
+      }
+    },
+  }
+}
+
+let hold: { path: string; db: SqlDb } | null = null
+
+function openFresh(dbPath: string): SqlDb | null {
+  if (!dbPath || !fs.existsSync(dbPath)) return null
+  try {
+    if (typeof process.versions.bun === "string") {
+      const { Database } = require("bun:sqlite") as {
+        Database: new (
+          path: string,
+          opts?: { readonly?: boolean; create?: boolean },
+        ) => Parameters<typeof wrapBun>[0]
+      }
+      return wrapBun(new Database(dbPath, { readonly: true, create: false }))
+    }
+  } catch {
+    // try node next
+  }
+  try {
+    const mod = require("node:sqlite") as {
+      DatabaseSync: new (
+        path: string,
+        opts?: { readOnly?: boolean },
+      ) => Parameters<typeof wrapNodeSync>[0]
+    }
+    if (!mod?.DatabaseSync) return null
+    return wrapNodeSync(new mod.DatabaseSync(dbPath, { readOnly: true }))
+  } catch {
+    return null
+  }
+}
+
+/** De-duplicated, non-empty string ids for `IN (...)` queries. */
+export function uniqueIds(ids: readonly string[]): string[] {
+  return [...new Set(ids.filter((id) => typeof id === "string" && id.length > 0))]
+}
+
+/** Drop the cached handle so the next open is a real reopen. */
+export function resetReadonlyDb(): void {
+  if (!hold) return
+  try {
+    hold.db.close()
+  } catch {
+    // ignore
+  }
+  hold = null
+}
+
+/** Retry a read after dropping a stale handle. */
+export function withDbRead<T>(run: () => T, fallback: (err: unknown) => T): T {
+  try {
+    return run()
+  } catch (e) {
+    resetReadonlyDb()
+    try {
+      return run()
+    } catch {
+      return fallback(e)
+    }
+  }
+}
+
+/** Open opencode.db readonly. Reuses one handle per path. Never throws — returns null on failure. */
+export function openReadonlyDb(dbPath: string): SqlDb | null {
+  if (!dbPath) return null
+  if (hold?.path === dbPath) return hold.db
+  resetReadonlyDb()
+  const db = openFresh(dbPath)
+  if (!db) return null
+  hold = { path: dbPath, db }
+  pushScreenLine("db open")
+  return db
+}

package/src/pware.oc.core/pware.oc.core.status.ts

@@ -0,0 +1,214 @@
+/**
+ * Canonical lifecycle / tool / work status. OpenCode and OMO use different
+ * synonyms; every mapper in the panel goes through this file. The raw status
+ * strings live in `constants/pware.oc.core.constants.status.js`.
+ */
+import {
+  STATUS_ABANDONED,
+  STATUS_ARCHIVED,
+  STATUS_COMPLETED,
+  STATUS_ERROR,
+  STATUS_IDLE,
+  STATUS_PAUSED,
+  STATUS_PENDING,
+  STATUS_RUNNING,
+  STATUS_UNKNOWN,
+  type CanonicalStatus,
+  type ToolStatus,
+} from "./constants/pware.oc.core.constants.status.js"
+import { formatTokenRate } from "./pware.oc.core.pulse.js"
+import { clipMiddleWidth } from "./pware.oc.core.width.js"
+
+export type { CanonicalStatus, ToolStatus }
+
+/** The transient one-line status a tab shows while it waits for its data. */
+export type TabTone = "loading" | "error" | "muted"
+
+/** Null when the tab's data is ready — the row does not exist then. */
+export type TabStatus = { label: string; tone: TabTone } | null
+
+/** The transient DB state right after a session is selected but its row is not visible yet. */
+export const TAB_STATUS_SESSION_NOT_IN_DB = "session not in db yet"
+
+/** A tab status resolved to a render line: static glyph + label + tone. Null = no row. */
+export type TabStatusLine = {
+  label: string
+  tone: TabTone
+  /** Static prefix glyph for error/muted; null for loading — the row animates the spinner. */
+  glyph: "×" | "•" | null
+} | null
+
+export function normalizeStatus(raw: string | null | undefined): CanonicalStatus {
+  const s = (raw || "").toLowerCase()
+  if (s === "running" || s === "in_progress" || s === "active") return STATUS_RUNNING
+  if (s === "completed" || s === "done" || s === "success") return STATUS_COMPLETED
+  if (s === "error" || s === "failed") return STATUS_ERROR
+  if (s === "pending" || s === "queued") return STATUS_PENDING
+  if (s === "paused") return STATUS_PAUSED
+  if (s === "abandoned") return STATUS_ABANDONED
+  if (s === "archived") return STATUS_ARCHIVED
+  if (s === "idle") return STATUS_IDLE
+  return STATUS_UNKNOWN
+}
+
+export function toToolStatus(raw: string | null | undefined): ToolStatus {
+  const c = normalizeStatus(raw)
+  if (c === STATUS_RUNNING) return STATUS_RUNNING
+  if (c === STATUS_COMPLETED) return STATUS_COMPLETED
+  if (c === STATUS_ERROR) return STATUS_ERROR
+  return STATUS_PENDING
+}
+
+/** Short work status for the panel — no full paths, no checklist text. */
+export function toWorkLabel(raw: string | null | undefined): string {
+  const c = normalizeStatus(raw)
+  if (c === STATUS_COMPLETED) return "done"
+  if (c === STATUS_UNKNOWN) return (raw || "").toLowerCase() || "unknown"
+  return c
+}
+
+/**
+ * One-cell glyph for a work row's status: ✓ done, × error, ⧗ pending/queued,
+ * ║ paused, ⊘ abandoned, ○ unknown. Null while running — the pulse spinner owns
+ * the running cell. Core owns this mapping; the ui layer re-exports it.
+ */
+export function workStatusGlyph(status: string): string | null {
+  const s = toWorkLabel(status)
+  if (s === "done") return "✓"
+  if (s === STATUS_ERROR) return "×"
+  if (s === STATUS_RUNNING) return null
+  // A single-cell geometric hourglass, not the emoji — one cell, monochrome.
+  if (s === STATUS_PENDING) return "⧗"
+  if (s === STATUS_PAUSED) return "║"
+  if (s === STATUS_ABANDONED) return "⊘"
+  return "○"
+}
+
+export function sessionStatusLabel(status: string): string {
+  return status
+}
+
+/**
+ * The one shared decision behind every tab's status row. Priority order:
+ * a session switch in flight, then the transient "row not visible yet" state,
+ * then any real DB error, then Perf's own states, then a cold (not yet loaded)
+ * tab. Null when the tab's data is ready.
+ */
+export function tabStatus(opts: {
+  tab: string
+  currentId: string | null
+  dbError: string | null
+  dbPresent: boolean
+  switching: string | null
+  perfError: string | null
+  perfTurns: number
+  cold: boolean
+}): TabStatus {
+  if (opts.switching && opts.currentId !== opts.switching && !opts.dbError) {
+    return { label: `switching · ${clipMiddleWidth(opts.switching, 10)}`, tone: "loading" }
+  }
+  if (opts.dbError === TAB_STATUS_SESSION_NOT_IN_DB) {
+    return { label: "waiting for session", tone: "loading" }
+  }
+  if (opts.dbError) {
+    return { label: opts.dbError, tone: "error" }
+  }
+  if (!opts.dbPresent) {
+    return { label: "waiting for session", tone: "loading" }
+  }
+  if (opts.tab === "perf") {
+    if (opts.perfError) return { label: opts.perfError, tone: "error" }
+    if (opts.cold) return { label: "loading · stats", tone: "loading" }
+    if (opts.perfTurns === 0) return { label: "no turns yet", tone: "muted" }
+    return null
+  }
+  if (opts.cold) {
+    return {
+      label: opts.tab === "mywork" ? "loading · my work" : "loading · sessions",
+      tone: "loading",
+    }
+  }
+  return null
+}
+
+/**
+ * Resolve a tab status to its render line. The null contract lives here so it
+ * is unit-testable: a ready tab (`null`) returns `null`, and the glyph maps
+ * tone → `×` error, `•` muted, `null` loading (the row animates the spinner).
+ */
+export function tabStatusLine(status: TabStatus): TabStatusLine {
+  if (!status) return null
+  if (status.tone === "error") return { label: status.label, tone: "error", glyph: "×" }
+  if (status.tone === "muted") return { label: status.label, tone: "muted", glyph: "•" }
+  return { label: status.label, tone: "loading", glyph: null }
+}
+
+/** Tone of the global status bar: loading/error/muted, or "ready" when a tab is done. */
+export type StatusBarTone = TabTone | "ready"
+
+/**
+ * Global status-bar line. A ready tab (`null`) still yields a line — with an
+ * empty label the bar is a bare `OES` (the realtime category tabs on the same
+ * row already lead with their own `•`), never `OES •` + a tab bullet.
+ */
+export type StatusBarLine = { label: string; tone: StatusBarTone }
+
+export function statusBarLine(status: TabStatus): StatusBarLine {
+  const line = tabStatusLine(status)
+  if (!line) return { label: "", tone: "ready" }
+  return { label: line.label, tone: line.tone }
+}
+
+/**
+ * The OES bar split into the pieces the row draws separately, because the
+ * inline trend renders faded while the reading next to it stays full strength.
+ * Empty `bar` / `rate` mean the row is a single run of text. `rateIdle` marks
+ * a reading of zero, which the row fades to match the trend behind it.
+ */
+export type OesBarParts = { head: string; bar: string; rate: string; rateIdle: boolean }
+
+/**
+ * What the OES bar says. A busy label always wins — while the bar is reporting
+ * a load, a switch or an error, the live token reading is noise and is dropped.
+ * On a quiet bar the trend and the rate follow a bare `OES`; with neither, the
+ * row is `OES` plus whatever glyph the tone asked for. Pass `rate` as the raw
+ * per-second number; idleness follows the number the row actually prints, so a
+ * trickle that rounds down to `0 tok/s` fades like a dead stop.
+ */
+export function oesBarParts(
+  label: string,
+  glyph: string,
+  rateBar = "",
+  rate?: number | null,
+): OesBarParts {
+  if (label) return { head: `OES ${glyph} ${label}`, bar: "", rate: "", rateIdle: false }
+  if (rateBar || rate !== undefined) {
+    const shown = typeof rate === "number" && Number.isFinite(rate) ? Math.round(rate) : 0
+    return {
+      head: "OES  ",
+      bar: rateBar,
+      rate: rate === undefined ? "" : ` ${formatTokenRate(rate)}`,
+      rateIdle: shown <= 0,
+    }
+  }
+  return { head: glyph ? `OES ${glyph}` : "OES", bar: "", rate: "", rateIdle: false }
+}
+
+/** Paused and abandoned are deliberate stops — they must not keep pulsing. */
+export function workIsTerminal(status: string): boolean {
+  const s = toWorkLabel(status)
+  return s === "done" || s === STATUS_ERROR || s === STATUS_PAUSED || s === STATUS_ABANDONED
+}
+
+export function isRunningLifecycle(raw: string | null | undefined): boolean {
+  return normalizeStatus(raw) === STATUS_RUNNING
+}
+
+export function taskRank(status: string): number {
+  const c = normalizeStatus(status)
+  if (c === STATUS_RUNNING) return 0
+  if (c === STATUS_PENDING) return 1
+  if (c === STATUS_ERROR || (status || "").toLowerCase() === "cancelled") return 2
+  if (c === STATUS_COMPLETED) return 3
+  return 4
+}

package/src/pware.oc.core/pware.oc.core.timing.ts

@@ -0,0 +1,63 @@
+/**
+ * pware.oc.core.timing
+ *
+ * Panel clock budgets — every interval and granularity in one place. The tick
+ * drives the animation heartbeat; `now` and the scan debounce decide how often
+ * rows and the DB re-read actually re-run. See docs/tick-system.md.
+ */
+
+/** UI heartbeat — spinner/arrow animation phase. */
+export const TICK_MS = 50
+
+/**
+ * Fast glyph cadence — spinners and direction flows step this often on a
+ * separate signal (`glyphFrame`), so the animation is smooth while rows and
+ * ages still run on the coarse `TICK_MS` / `NOW_MS` clocks.
+ */
+export const GLYPH_TICK_MS = 80
+
+/**
+ * Coarse `now` granularity — ages, marks and row arrays recompute at most this
+ * often, while glyphs still animate at `TICK_MS`. Displayed ages use 1s
+ * granularity anyway (`formatCoarseSec`).
+ */
+export const NOW_MS = 1_000
+
+/** FPS read cadence in ticks (TICK_MS × 6 = 300ms). */
+export const FPS_READ_EVERY_TICKS = 6
+
+/** Blink half-period in ticks (TICK_MS × 2 = 100ms). */
+export const BLINK_TICKS = 2
+
+/** Monitor: SQLite poll interval. */
+export const MONITOR_POLL_MS = 1_500
+
+/** Monitor: fs-watch → emit debounce. */
+export const MONITOR_WATCH_DEBOUNCE_MS = 120
+
+/**
+ * My-work attention scan cadence while the tab is quiet — the periodic floor.
+ * DB-change-driven rescans (see MYWORK_BADGE_COOLDOWN_MS) refresh it sooner.
+ */
+export const MYWORK_BADGE_MS = 5_000
+
+/**
+ * Minimum gap between My-work badge rescans when a new DB snapshot just landed
+ * — a question appears within ~1s instead of waiting for the 5s floor.
+ */
+export const MYWORK_BADGE_COOLDOWN_MS = 1_000
+
+/** Host event → scan debounce (trailing). */
+export const EVENT_SCAN_DEBOUNCE_MS = 100
+
+/** Sliding window over which the live token rate is measured. */
+export const TOKEN_RATE_WINDOW_MS = 5_000
+
+/** How long the shared realtime timeline stays in RAM (3 minutes). */
+export const REALTIME_WINDOW_MS = 3 * 60 * 1000
+
+/** Window over which token/cache rates and CPU% are derived (≈ "rate right now"). */
+export const REALTIME_RATE_WINDOW_MS = 1_000
+
+/** Session-switch status row safety: hide the indicator even if no snapshot lands. */
+export const SWITCH_TIMEOUT_MS = 3_000

package/src/pware.oc.core/pware.oc.core.width.ts

@@ -0,0 +1,215 @@
+/**
+ * Display-width helpers — columns, not code units.
+ *
+ * OpenTUI lays text out by wcwidth columns (a wide char is 2 columns, a
+ * combining mark is 0), but `String.length` counts UTF-16 code units. Every
+ * row-budget calculation in this plugin used `.length`, so a row with a wide
+ * character (emoji, CJK) measured "fits" while actually overflowing and
+ * wrapping to a second line. This module is the single place that turns text
+ * into columns and clips it grapheme-safely, so budgets are real columns.
+ */
+
+/** Inclusive [start, end] code-point ranges of width-0 characters. */
+const ZERO: readonly (readonly [number, number])[] = [
+  [0x0300, 0x036f], [0x0483, 0x0489], [0x0591, 0x05bd], [0x05bf, 0x05bf],
+  [0x05c1, 0x05c2], [0x05c4, 0x05c5], [0x05c7, 0x05c7], [0x0610, 0x061a],
+  [0x064b, 0x065f], [0x0670, 0x0670], [0x06d6, 0x06dc], [0x06df, 0x06e4],
+  [0x06e7, 0x06e8], [0x06ea, 0x06ed], [0x0711, 0x0711], [0x0730, 0x074a],
+  [0x07a6, 0x07b0], [0x07eb, 0x07f3], [0x0816, 0x0819], [0x081b, 0x0823],
+  [0x0825, 0x0827], [0x0829, 0x082d], [0x0859, 0x085b], [0x08d3, 0x0902],
+  [0x093a, 0x093a], [0x093c, 0x093c], [0x0941, 0x0948], [0x094d, 0x094d],
+  [0x0951, 0x0957], [0x0962, 0x0963], [0x0981, 0x0981], [0x09bc, 0x09bc],
+  [0x09c1, 0x09c4], [0x09cd, 0x09cd], [0x09e2, 0x09e3], [0x0a01, 0x0a02],
+  [0x0a3c, 0x0a3c], [0x0a41, 0x0a42], [0x0a47, 0x0a48], [0x0a4b, 0x0a4d],
+  [0x0a51, 0x0a51], [0x0a70, 0x0a71], [0x0a75, 0x0a75], [0x0a81, 0x0a82],
+  [0x0abc, 0x0abc], [0x0ac1, 0x0ac5], [0x0ac7, 0x0ac8], [0x0acd, 0x0acd],
+  [0x0ae2, 0x0ae3], [0x0afa, 0x0aff], [0x0b01, 0x0b01], [0x0b3c, 0x0b3c],
+  [0x0b3f, 0x0b3f], [0x0b41, 0x0b44], [0x0b4d, 0x0b4d], [0x0b56, 0x0b56],
+  [0x0b62, 0x0b63], [0x0b82, 0x0b82], [0x0bc0, 0x0bc0], [0x0bcd, 0x0bcd],
+  [0x0c00, 0x0c00], [0x0c04, 0x0c04], [0x0c3e, 0x0c40], [0x0c46, 0x0c48],
+  [0x0c4a, 0x0c4d], [0x0c55, 0x0c56], [0x0c62, 0x0c63], [0x0c81, 0x0c81],
+  [0x0cbc, 0x0cbc], [0x0cbf, 0x0cbf], [0x0cc6, 0x0cc6], [0x0ccc, 0x0ccd],
+  [0x0ce2, 0x0ce3], [0x0d00, 0x0d01], [0x0d3b, 0x0d3c], [0x0d41, 0x0d44],
+  [0x0d4d, 0x0d4d], [0x0d62, 0x0d63], [0x0dca, 0x0dca], [0x0dd2, 0x0dd4],
+  [0x0dd6, 0x0dd6], [0x0e31, 0x0e31], [0x0e34, 0x0e3a], [0x0e47, 0x0e4e],
+  [0x0eb1, 0x0eb1], [0x0eb4, 0x0ebc], [0x0ec8, 0x0ecd], [0x0f18, 0x0f19],
+  [0x0f35, 0x0f35], [0x0f37, 0x0f37], [0x0f39, 0x0f39], [0x0f71, 0x0f7e],
+  [0x0f80, 0x0f84], [0x0f86, 0x0f87], [0x0f8d, 0x0f97], [0x0f99, 0x0fbc],
+  [0x0fc6, 0x0fc6], [0x102d, 0x1030], [0x1032, 0x1037], [0x1039, 0x103a],
+  [0x103d, 0x103e], [0x1058, 0x1059], [0x105e, 0x1060], [0x1071, 0x1074],
+  [0x1082, 0x1082], [0x1085, 0x1086], [0x108d, 0x108d], [0x109d, 0x109d],
+  [0x135d, 0x135f], [0x1712, 0x1714], [0x1732, 0x1734], [0x1752, 0x1753],
+  [0x1772, 0x1773], [0x17b4, 0x17b5], [0x17b7, 0x17bd], [0x17c6, 0x17c6],
+  [0x17c9, 0x17d3], [0x17dd, 0x17dd], [0x180b, 0x180e], [0x1885, 0x1886],
+  [0x18a9, 0x18a9], [0x1920, 0x1922], [0x1927, 0x1928], [0x1932, 0x1932],
+  [0x1939, 0x193b], [0x1a17, 0x1a18], [0x1a1b, 0x1a1b], [0x1a56, 0x1a56],
+  [0x1a58, 0x1a5e], [0x1a60, 0x1a60], [0x1a62, 0x1a62], [0x1a65, 0x1a6c],
+  [0x1a73, 0x1a7c], [0x1a7f, 0x1a7f], [0x1ab0, 0x1ac0], [0x1b00, 0x1b03],
+  [0x1b34, 0x1b34], [0x1b36, 0x1b3a], [0x1b3c, 0x1b3c], [0x1b42, 0x1b42],
+  [0x1b6b, 0x1b73], [0x1b80, 0x1b81], [0x1ba2, 0x1ba5], [0x1ba8, 0x1ba9],
+  [0x1bab, 0x1bad], [0x1be6, 0x1be6], [0x1be8, 0x1be9], [0x1bed, 0x1bed],
+  [0x1bef, 0x1bf1], [0x1c2c, 0x1c33], [0x1c36, 0x1c37], [0x1cd0, 0x1cd2],
+  [0x1cd4, 0x1ce0], [0x1ce2, 0x1ce8], [0x1ced, 0x1ced], [0x1cf4, 0x1cf4],
+  [0x1cf8, 0x1cf9], [0x1dc0, 0x1df9], [0x1dfb, 0x1dff], [0x200b, 0x200f],
+  [0x202a, 0x202e], [0x2060, 0x2064], [0x2066, 0x206f], [0x20d0, 0x20f0],
+  [0x2cef, 0x2cf1], [0x2d7f, 0x2d7f], [0x2de0, 0x2dff], [0x302a, 0x302d],
+  [0x3099, 0x309a], [0xa66f, 0xa672], [0xa674, 0xa67d], [0xa69e, 0xa69f],
+  [0xa6f0, 0xa6f1], [0xa802, 0xa802], [0xa806, 0xa806], [0xa80b, 0xa80b],
+  [0xa825, 0xa826], [0xa8c4, 0xa8c5], [0xa8e0, 0xa8f1], [0xa926, 0xa92d],
+  [0xa947, 0xa951], [0xa980, 0xa982], [0xa9b3, 0xa9b3], [0xa9b6, 0xa9b9],
+  [0xa9bc, 0xa9bd], [0xa9e5, 0xa9e5], [0xaa29, 0xaa2e], [0xaa31, 0xaa32],
+  [0xaa35, 0xaa36], [0xaa43, 0xaa43], [0xaa4c, 0xaa4c], [0xaa7c, 0xaa7c],
+  [0xaab0, 0xaab0], [0xaab2, 0xaab4], [0xaab7, 0xaab8], [0xaabe, 0xaabf],
+  [0xaac1, 0xaac1], [0xaaec, 0xaaed], [0xaaf6, 0xaaf6], [0xabe5, 0xabe5],
+  [0xabe8, 0xabe8], [0xabed, 0xabed], [0xfb1e, 0xfb1e], [0xfe00, 0xfe0f],
+  [0xfe20, 0xfe2f], [0x101fd, 0x101fd], [0x102e0, 0x102e0], [0x10376, 0x1037a],
+  [0x10a01, 0x10a03], [0x10a05, 0x10a06], [0x10a0c, 0x10a0f], [0x10a38, 0x10a3a],
+  [0x10a3f, 0x10a3f], [0x10ae5, 0x10ae6], [0x11001, 0x11001], [0x11038, 0x11046],
+  [0x1107f, 0x11081], [0x110b3, 0x110b6], [0x110b9, 0x110ba], [0x11100, 0x11102],
+  [0x11127, 0x1112b], [0x1112d, 0x11134], [0x11173, 0x11173], [0x11180, 0x11181],
+  [0x111b6, 0x111be], [0x111ca, 0x111cc], [0x1122f, 0x11231], [0x11234, 0x11234],
+  [0x11236, 0x11237], [0x1123e, 0x1123e], [0x112df, 0x112df], [0x112e3, 0x112ea],
+  [0x11300, 0x11301], [0x1133c, 0x1133c], [0x11340, 0x11340], [0x11366, 0x1136c],
+  [0x11370, 0x11374], [0x11438, 0x1143f], [0x11442, 0x11444], [0x11446, 0x11446],
+  [0x114b3, 0x114b8], [0x114ba, 0x114ba], [0x114bf, 0x114c0], [0x114c2, 0x114c3],
+  [0x115b2, 0x115b5], [0x115bc, 0x115bd], [0x115bf, 0x115c0], [0x115dc, 0x115dd],
+  [0x11633, 0x1163a], [0x1163d, 0x1163d], [0x1163f, 0x11640], [0x116ab, 0x116ab],
+  [0x116ad, 0x116ad], [0x116b0, 0x116b5], [0x116b7, 0x116b7], [0x1171d, 0x1171f],
+  [0x11722, 0x11725], [0x11727, 0x1172b], [0x11c30, 0x11c36], [0x11c38, 0x11c3d],
+  [0x11c3f, 0x11c3f], [0x11c92, 0x11ca7], [0x11caa, 0x11cb0], [0x11cb2, 0x11cb3],
+  [0x11cb5, 0x11cb6], [0x11d31, 0x11d36], [0x11d3a, 0x11d3a], [0x11d3c, 0x11d3d],
+  [0x11d3f, 0x11d45], [0x11d47, 0x11d47], [0x16af0, 0x16af4], [0x16b30, 0x16b36],
+  [0x16f8f, 0x16f92], [0x1bc9d, 0x1bc9e], [0x1bca0, 0x1bca3], [0x1d165, 0x1d169],
+  [0x1d16d, 0x1d182], [0x1d185, 0x1d18b], [0x1d1aa, 0x1d1ad], [0x1d242, 0x1d244],
+  [0x1da00, 0x1da36], [0x1da3b, 0x1da6c], [0x1da75, 0x1da75], [0x1da84, 0x1da84],
+  [0x1da9b, 0x1da9f], [0x1daa1, 0x1daaf], [0x1e000, 0x1e006], [0x1e008, 0x1e018],
+  [0x1e01b, 0x1e021], [0x1e023, 0x1e024], [0x1e026, 0x1e02a], [0x1e8d0, 0x1e8d6],
+  [0x1e944, 0x1e94a], [0xe0100, 0xe01ef],
+]
+
+/** Inclusive [start, end] code-point ranges of width-2 (wide) characters. */
+const WIDE: readonly (readonly [number, number])[] = [
+  [0x1100, 0x115f], [0x231a, 0x231b], [0x2329, 0x232a], [0x23e9, 0x23ec],
+  [0x23f0, 0x23f0], [0x23f3, 0x23f3], [0x25fd, 0x25fe], [0x2614, 0x2615],
+  [0x2648, 0x2653], [0x267f, 0x267f], [0x2693, 0x2693], [0x26a1, 0x26a1],
+  [0x26aa, 0x26ab], [0x26bd, 0x26be], [0x26c4, 0x26c5], [0x26ce, 0x26ce],
+  [0x26d4, 0x26d4], [0x26ea, 0x26ea], [0x26f2, 0x26f3], [0x26f5, 0x26f5],
+  [0x26fa, 0x26fa], [0x26fd, 0x26fd], [0x2705, 0x2705], [0x270a, 0x270b],
+  [0x2728, 0x2728], [0x274c, 0x274c], [0x274e, 0x274e], [0x2753, 0x2755],
+  [0x2757, 0x2757], [0x2795, 0x2797], [0x27b0, 0x27b0], [0x27bf, 0x27bf],
+  [0x2b1b, 0x2b1c], [0x2b50, 0x2b50], [0x2b55, 0x2b55], [0x2e80, 0x2e99],
+  [0x2e9b, 0x2ef3], [0x2f00, 0x2fd5], [0x2ff0, 0x2ffb], [0x3000, 0x303e],
+  [0x3041, 0x3096], [0x3099, 0x30ff], [0x3105, 0x312f], [0x3131, 0x318e],
+  [0x3190, 0x31e3], [0x31f0, 0x321e], [0x3220, 0x3247], [0x3250, 0x4dbf],
+  [0x4e00, 0xa48c], [0xa490, 0xa4c6], [0xa960, 0xa97c], [0xac00, 0xd7a3],
+  [0xf900, 0xfaff], [0xfe10, 0xfe19], [0xfe30, 0xfe52], [0xfe54, 0xfe66],
+  [0xfe68, 0xfe6b], [0xff00, 0xff60], [0xffe0, 0xffe6], [0x16fe0, 0x16fe4],
+  [0x17000, 0x187f7], [0x18800, 0x18cd5], [0x18d00, 0x18d08], [0x1b000, 0x1b11e],
+  [0x1b150, 0x1b152], [0x1b164, 0x1b167], [0x1b170, 0x1b2fb], [0x1f004, 0x1f004],
+  [0x1f0cf, 0x1f0cf], [0x1f18e, 0x1f18e], [0x1f191, 0x1f19a], [0x1f200, 0x1f202],
+  [0x1f210, 0x1f23b], [0x1f240, 0x1f248], [0x1f250, 0x1f251], [0x1f260, 0x1f265],
+  [0x1f300, 0x1f320], [0x1f32d, 0x1f335], [0x1f337, 0x1f37c], [0x1f37e, 0x1f393],
+  [0x1f3a0, 0x1f3ca], [0x1f3cf, 0x1f3d3], [0x1f3e0, 0x1f3f0], [0x1f3f4, 0x1f3f4],
+  [0x1f3f8, 0x1f43e], [0x1f440, 0x1f440], [0x1f442, 0x1f4fc], [0x1f4ff, 0x1f53d],
+  [0x1f54b, 0x1f54e], [0x1f550, 0x1f567], [0x1f57a, 0x1f57a], [0x1f595, 0x1f596],
+  [0x1f5a4, 0x1f5a4], [0x1f5fb, 0x1f64f], [0x1f680, 0x1f6c5], [0x1f6cc, 0x1f6cc],
+  [0x1f6d0, 0x1f6d2], [0x1f6d5, 0x1f6d7], [0x1f6eb, 0x1f6ec], [0x1f6f4, 0x1f6fc],
+  [0x1f7e0, 0x1f7eb], [0x1f90c, 0x1f93a], [0x1f93c, 0x1f945], [0x1f947, 0x1f978],
+  [0x1f97a, 0x1f9cb], [0x1f9cd, 0x1f9ff], [0x1fa70, 0x1fa74], [0x1fa78, 0x1fa7a],
+  [0x1fa80, 0x1fa86], [0x1fa90, 0x1faa8], [0x1fab0, 0x1fab6], [0x1fac0, 0x1fac2],
+  [0x1fad0, 0x1fad6], [0x20000, 0x2fffd], [0x30000, 0x3fffd],
+]
+
+function inRanges(cp: number, table: readonly (readonly [number, number])[]): boolean {
+  let lo = 0
+  let hi = table.length - 1
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1
+    const [a, b] = table[mid]!
+    if (cp < a) hi = mid - 1
+    else if (cp > b) lo = mid + 1
+    else return true
+  }
+  return false
+}
+
+/** wcwidth of one code point: 0 combining/control, 2 wide, else 1. */
+export function codepointWidth(cp: number): number {
+  if (cp === 0) return 0
+  if (cp < 32 || (cp >= 0x7f && cp < 0xa0)) return 0
+  if (inRanges(cp, ZERO)) return 0
+  if (inRanges(cp, WIDE)) return 2
+  return 1
+}
+
+/** Display width in columns (wcwidth) of a string. */
+export function strWidth(s: string): number {
+  let w = 0
+  for (const ch of s) w += codepointWidth(ch.codePointAt(0)!)
+  return w
+}
+
+/** Split into grapheme clusters; falls back to code points when Segmenter is absent. */
+function graphemes(s: string): string[] {
+  const Seg = (Intl as unknown as {
+    Segmenter?: new (l?: string, o?: { granularity: string }) => { segment: (t: string) => Iterable<{ segment: string }> }
+  }).Segmenter
+  if (typeof Seg === "function") {
+    return Array.from(new Seg(undefined, { granularity: "grapheme" }).segment(s), (x) => x.segment)
+  }
+  return Array.from(s)
+}
+
+/** Longest prefix of `s` whose column width is at most `cols`. */
+export function takeCols(s: string, cols: number): string {
+  if (cols <= 0) return ""
+  let width = 0
+  let out = ""
+  for (const g of graphemes(s)) {
+    const gw = strWidth(g)
+    if (width + gw > cols) break
+    width += gw
+    out += g
+  }
+  return out
+}
+
+/** Longest suffix of `s` whose column width is at most `cols`. */
+export function takeLastCols(s: string, cols: number): string {
+  if (cols <= 0) return ""
+  const gs = graphemes(s)
+  let width = 0
+  const picked: string[] = []
+  for (let i = gs.length - 1; i >= 0; i--) {
+    const g = gs[i]!
+    const gw = strWidth(g)
+    if (width + gw > cols) break
+    width += gw
+    picked.unshift(g)
+  }
+  return picked.join("")
+}
+
+const ELLIPSIS = "…"
+
+/** Clip to at most `max` columns with a trailing ellipsis; collapses whitespace. */
+export function clipWidth(s: string, max: number): string {
+  const t = s.replace(/\s+/g, " ").trim()
+  if (max <= 0) return ""
+  if (strWidth(t) <= max) return t
+  if (max === 1) return ELLIPSIS
+  return `${takeCols(t, max - strWidth(ELLIPSIS))}${ELLIPSIS}`
+}
+
+/** Clip to at most `max` columns with a middle ellipsis; collapses whitespace. */
+export function clipMiddleWidth(s: string, max: number): string {
+  const t = s.replace(/\s+/g, " ").trim()
+  if (max <= 0) return ""
+  if (strWidth(t) <= max) return t
+  if (max <= 2) return takeCols(t, max)
+  // Suffix-bias the middle split, but never wider than the post-ellipsis budget.
+  const budget = max - strWidth(ELLIPSIS)
+  const tail = Math.min(budget, Math.max(3, Math.floor(budget / 2)))
+  const head = budget - tail
+  return `${takeCols(t, head)}${ELLIPSIS}${takeLastCols(t, tail)}`
+}

package/src/pware.oc.omo/constants/index.ts

@@ -0,0 +1,15 @@
+/**
+ * pware.oc.omo.constants
+ *
+ * Single source of truth for the OMO string literals: plan pending statuses,
+ * boulder statuses, run-continuation background-task states, review-lifecycle
+ * statuses, and review lane verdicts.
+ */
+export * from "./pware.oc.omo.constants.planStatus.js"
+export * from "./pware.oc.omo.constants.boulderStatus.js"
+export * from "./pware.oc.omo.constants.backgroundTask.js"
+export * from "./pware.oc.omo.constants.reviewStatus.js"
+export * from "./pware.oc.omo.constants.verdict.js"
+export * from "./pware.oc.omo.constants.docKind.js"
+export * from "./pware.oc.omo.constants.startWork.js"
+export * from "./pware.oc.omo.constants.eventName.js"