@prjct.app/pi-signals 0.1.2 → 0.2.1

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.2.1 (2026-10-13)
+
+- The `seen` list in `evidenceTool` is now a cell holding an immutable array. Each `execute` builds a new array with the additions appended instead of pushing in place; `contains` reads from the cell.
+
+## 0.2.0 (2026-10-09)
+
+- `/signals` opens the shared docked panel, like the other prjct extensions. It lists what needs a fix first, then queued, running, flaky and resolved issues, each with component, status and sightings. An issue's detail shows the triage decision, recent observations and runs. The Daily triage row shows schedule, recent days, repositories and the repair setting. `r` queues an issue for triage again. Outside the TUI the same list prints as text instead of JSON.
+
 ## 0.1.2 (2026-10-09)
 
 - No system-prompt rule. signal_report no longer asks every session to watch Pi and extensions; its description says what it records and when to inspect targets first.

package/README.md

@@ -24,7 +24,7 @@ Pi's private npm bin directory may not be on your shell PATH. In that case use `
 
 - `signal_report`: select minimal evidence, a stable signature identifying the component and failure mechanism, and one of the three signal categories. The same signature groups repeated sightings; repeated submission of the same session evidence is deduplicated.
 - `signal_inspect`: list `targets`, `issues`, or `observations`. Supply `issueId` for persisted issue observations. Pages have explicit continuation offsets; history is never trimmed.
-- `/signals`: show recent local issues and the configured daily time.
+- `/signals`: the docked panel (shared with the other prjct extensions). What needs a fix comes first, then queued, running, flaky and resolved issues, each with its component, status and sightings. Enter shows the triage decision, recent observations and runs; the **Daily triage** row shows the schedule, recent days, repositories and repair setting. `r` queues an issue for triage again. Outside the TUI the same list prints as text.
 - `pi-signals status`, `show <id>` and `retry <id>`: inspect or explicitly requeue a signal.
 - `pi-signals once`: run queued triage/repair now. `once --scheduled` respects the daily clock and completed-day record.
 - `pi-signals schedule install`: install a macOS LaunchAgent using the absolute installed npm CLI path. An hourly OS wake checks the configured timezone; the worker runs once after the configured hour and catches up after sleep/login. There is no resident polling process inside Pi. Other platforms can schedule `once --scheduled` hourly with their OS scheduler.

package/dist/cli.mjs

@@ -92,7 +92,13 @@ var init_store = __esm({
         return this.db.prepare("SELECT id FROM issues ORDER BY updated DESC,id LIMIT 21 OFFSET ?").all(offset).map((row) => this.get(String(row.id)));
       }
       observations(id, offset = 0, limit = 21) {
-        return this.db.prepare("SELECT * FROM observations WHERE issueId=? ORDER BY created,id LIMIT ? OFFSET ?").all(id, limit, offset).map((row) => ({ ...row, payload: JSON.parse(String(row.payload)) }));
+        return this.db.prepare("SELECT * FROM observations WHERE issueId=? ORDER BY created,id LIMIT ? OFFSET ?").all(id, limit, offset).map((row) => ({
+          id: String(row.id),
+          issueId: String(row.issueId),
+          version: String(row.version),
+          created: Number(row.created),
+          payload: JSON.parse(String(row.payload))
+        }));
       }
       capture(value, now = Date.now()) {
         return this.transaction(() => {
@@ -154,8 +160,22 @@ var init_store = __esm({
         this.assertOwner(owner);
         this.db.exec("UPDATE issues SET status='new',lastError='Previous worker interrupted; evidence retained' WHERE status IN ('triaging','repairing'); UPDATE runs SET state='interrupted' WHERE state='running'");
       }
+      /** The latest daily triage days, newest first. */
+      days(limit = 7) {
+        return this.db.prepare("SELECT day,started,finished FROM schedule ORDER BY day DESC LIMIT ?").all(limit).map((row) => ({ day: String(row.day), started: Number(row.started), ...row.finished == null ? {} : { finished: Number(row.finished) } }));
+      }
       runs(id) {
-        return this.db.prepare("SELECT * FROM runs WHERE issueId=? ORDER BY started").all(id).map((row) => ({ ...row, id: String(row.id), state: String(row.state), result: row.result ? JSON.parse(String(row.result)) : void 0 }));
+        return this.db.prepare("SELECT * FROM runs WHERE issueId=? ORDER BY started").all(id).map((row) => ({
+          id: String(row.id),
+          issueId: String(row.issueId),
+          revision: Number(row.revision),
+          phase: String(row.phase),
+          owner: String(row.owner),
+          state: String(row.state),
+          started: Number(row.started),
+          ...row.finished == null ? {} : { finished: Number(row.finished) },
+          result: row.result ? JSON.parse(String(row.result)) : void 0
+        }));
       }
     };
   }
@@ -814,7 +834,7 @@ var init_schema = __esm({
 // src/evidence.ts
 import { Type as Type2 } from "typebox";
 function evidenceTool(source) {
-  const seen = [];
+  const seen = { items: [] };
   const tool = {
     name: "signal_evidence",
     label: "Read original signal evidence",
@@ -824,14 +844,16 @@ function evidenceTool(source) {
       const input = raw, offset = input.offset ?? 0, limit = input.limit ?? 1;
       const rows = typeof source === "function" ? source(offset, limit + 1) : source.slice(offset, offset + limit + 1);
       const items = await protectOutboundData(rows.slice(0, limit));
+      const additions = [];
       for (const item of items) {
         const payload = item.payload;
-        seen.push(payload?.body ?? JSON.stringify(item));
+        additions.push(payload?.body ?? JSON.stringify(item));
       }
+      if (additions.length) seen.items = [...seen.items, ...additions];
       return { content: [{ type: "text", text: JSON.stringify({ items, nextOffset: rows.length > limit ? offset + limit : null }) }], details: {} };
     }
   };
-  return { tool, contains: (quote2) => seen.some((text2) => text2.includes(quote2)) };
+  return { tool, contains: (quote2) => seen.items.some((text2) => text2.includes(quote2)) };
 }
 var init_evidence = __esm({
   "src/evidence.ts"() {
@@ -933,10 +955,10 @@ ${JSON.stringify({ issue })}`,
     const source = resolve(path, file), destination = resolve(baselinePath, file);
     if (!source.startsWith(path + sep2) || !destination.startsWith(baselinePath + sep2)) return blocked("Regression file escaped the worktree.");
     for (const root of [path, baselinePath]) {
-      let current = root;
+      const cursor = { current: root };
       for (const part of file.split("/")) {
-        current = join6(current, part);
-        const stat = await lstat(current).catch(() => void 0);
+        cursor.current = join6(cursor.current, part);
+        const stat = await lstat(cursor.current).catch(() => void 0);
         if (stat?.isSymbolicLink()) return blocked("Regression paths must not contain symlinks.");
       }
     }
@@ -953,7 +975,7 @@ ${JSON.stringify({ issue })}`,
   if (await protectOutboundData(diff) !== diff) return blocked("The candidate diff contains data caught by outbound protection; publication is blocked.");
   await must(path, ["git", "commit", "-m", `fix: ${issue.title}`], signal);
   const head = await must(path, ["git", "rev-parse", "HEAD"], signal);
-  for (let sample = 0; sample < 3; sample++) {
+  for (const _sample of [0, 1, 2]) {
     const before = await command(baselinePath, fix.regressionCommand, signal);
     checks.push(before);
     if (before.code === 0 || !before.output.includes(fix.failurePattern)) return blocked("The unchanged baseline did not consistently reproduce the claimed failure.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prjct.app/pi-signals",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Local failure signals, daily agent-owned triage and verified repair candidates for Pi.",
   "type": "module",
   "license": "MIT",
@@ -32,7 +32,8 @@
     "bin"
   ],
   "dependencies": {
-    "@prjct.app/pi-secrets": "^0.2.6"
+    "@prjct.app/pi-secrets": "^0.2.6",
+    "@prjct.app/pi-tui-kit": "^0.3.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=1.0.4",
@@ -50,7 +51,7 @@
   },
   "scripts": {
     "check": "tsc --noEmit",
-    "test": "node --import ./tests/isolate.mjs --import tsx --test --test-concurrency=2 tests/*.test.ts",
+    "test": "export PI_CODING_AGENT_DIR=\"$(mktemp -d)\" PRJCT_HOME=\"$(mktemp -d)\" && node --import ./tests/isolate.mjs --import tsx --test --test-concurrency=2 tests/*.test.ts",
     "check:package": "npm pack --dry-run --ignore-scripts",
     "build": "node scripts/build.mjs",
     "prepack": "npm run build",

package/src/evidence.ts

@@ -5,7 +5,8 @@ import { protectOutboundData } from '@prjct.app/pi-secrets/privacy';
 export type EvidenceSource = readonly unknown[] | ((offset: number, limit: number) => unknown[]);
 /** Keep full observations in storage; the deciding agent chooses which pages to read. */
 export function evidenceTool(source: EvidenceSource) {
-  const seen: string[] = [];
+  // The one cell that changes: it holds the current list, which is always replaced, never edited.
+  const seen: { items: readonly string[] } = { items: [] };
   const tool: ToolDefinition = {
     name: 'signal_evidence', label: 'Read original signal evidence',
     description: 'Read original issue observations by page. Nothing is discarded; follow nextOffset to inspect all sightings. Select a smaller limit for large reports.',
@@ -14,12 +15,14 @@ export function evidenceTool(source: EvidenceSource) {
       const input = raw as { offset?: number; limit?: number }, offset = input.offset ?? 0, limit = input.limit ?? 1;
       const rows = typeof source === 'function' ? source(offset, limit + 1) : source.slice(offset, offset + limit + 1);
       const items = await protectOutboundData(rows.slice(0, limit));
+      const additions: string[] = [];
       for (const item of items) {
         const payload = (item as { payload?: { body?: string } }).payload;
-        seen.push(payload?.body ?? JSON.stringify(item));
+        additions.push(payload?.body ?? JSON.stringify(item));
       }
+      if (additions.length) seen.items = [...seen.items, ...additions];
       return { content: [{ type: 'text', text: JSON.stringify({ items, nextOffset: rows.length > limit ? offset + limit : null }) }], details: {} };
     },
   };
-  return { tool, contains: (quote: string) => seen.some(text => text.includes(quote)) };
+  return { tool, contains: (quote: string) => seen.items.some(text => text.includes(quote)) };
 }

package/src/index.ts

@@ -5,6 +5,8 @@ import { hideLocalPaths, prepareReport } from './report.ts';
 import { InspectSchema, OBSERVATION, ReportSchema } from './schema.ts';
 import { SignalStore } from './store.ts';
 import { rememberHost } from './host.ts';
+import { brand, openPanel, panelText } from '@prjct.app/pi-tui-kit';
+import { signalPanelSpec, type SignalPanelOps } from './panel.ts';
 
 const defaults = { config, targets, protect: protectOutboundData, databasePath };
 export type SignalsDependencies = Partial<typeof defaults>;
@@ -48,13 +50,36 @@ export function installSignals(pi: ExtensionAPI, dependencies: SignalsDependenci
       finally { store.close(); }
     },
   });
+  const withStore = <T>(read: (store: SignalStore) => T): T => {
+    const store = new SignalStore(deps.databasePath());
+    try { return read(store); } finally { store.close(); }
+  };
+  /** One snapshot per panel draw; a change clears it. Every issue, not one page. */
+  const panelOps = (): SignalPanelOps => {
+    const cache: { issues?: ReturnType<SignalStore['list']> } = {};
+    const all = (store: SignalStore) => {
+      const pages = (offset: number): ReturnType<SignalStore['list']> => {
+        const rows = store.list(offset);
+        return rows.length > 20 ? [...rows.slice(0, 20), ...pages(offset + 20)] : rows;
+      };
+      return pages(0);
+    };
+    return {
+      config: () => deps.config(),
+      issues: () => (cache.issues ??= withStore(all)),
+      observations: id => withStore(store => store.observations(id, 0, 50)),
+      runs: id => withStore(store => store.runs(id)),
+      days: () => withStore(store => store.days()),
+      retry: id => { cache.issues = undefined; return withStore(store => store.retry(id)); },
+    };
+  };
   pi.registerCommand('signals', {
-    description: 'Show local issues and daily triage configuration',
+    description: brand('signals: local issues in Pi and extensions, what to fix, and the daily triage'),
     async handler(_args, ctx) {
       try {
-        const settings = deps.config(), store = new SignalStore(deps.databasePath());
-        try { ctx.ui.notify(JSON.stringify({ enabled: settings.enabled, daily: `${settings.hour}:${String(settings.minute).padStart(2, '0')} ${settings.timezone}`, issues: page(store.list(), 0) }), 'info'); }
-        finally { store.close(); }
+        const spec = signalPanelSpec(panelOps());
+        if (ctx.mode === 'tui' && ctx.hasUI && typeof ctx.ui.custom === 'function') await openPanel(ctx, spec);
+        else ctx.ui.notify(panelText(spec), 'info');
       } catch { ctx.ui.notify('Cannot read signals configuration or database.', 'error'); }
     },
   });

package/src/panel.ts

@@ -0,0 +1,129 @@
+import { SYMBOL, ago, type PanelAction, type PanelDetail, type PanelItem, type PanelSpec, type Tone } from '@prjct.app/pi-tui-kit';
+import type { Config } from './config.ts';
+import type { LocalIssue, Status } from './store.ts';
+
+/** What the panel reads and the one change it can make. Each call opens and closes the store. */
+export type SignalPanelOps = {
+  readonly config: () => Config;
+  readonly issues: () => readonly LocalIssue[];
+  readonly observations: (id: string) => readonly { created: number; version: string; payload: { title: string; body: string } }[];
+  readonly runs: (id: string) => readonly { phase: string; state: string; started: number; finished?: number; result?: unknown }[];
+  readonly days: () => readonly { day: string; started: number; finished?: number }[];
+  /** Queue an issue for triage again; false when a worker holds it. */
+  readonly retry: (id: string) => boolean;
+  readonly now?: () => number;
+};
+
+const TRIAGE = '__triage__';
+const STATUS: Readonly<Record<Status, { word: string; short: string; symbol: string; tone: Tone; rank: number }>> = {
+  attention: { word: 'needs a fix', short: 'fix', symbol: SYMBOL.attention, tone: 'warning', rank: 0 },
+  blocked: { word: 'repair blocked', short: 'blocked', symbol: SYMBOL.error, tone: 'error', rank: 1 },
+  needs_evidence: { word: 'needs evidence', short: 'evidence', symbol: SYMBOL.attention, tone: 'warning', rank: 2 },
+  new: { word: 'waiting for triage', short: 'queued', symbol: SYMBOL.idle, tone: 'accent', rank: 3 },
+  triaging: { word: 'triaging', short: 'triaging', symbol: SYMBOL.active, tone: 'accent', rank: 4 },
+  repairing: { word: 'repairing', short: 'repairing', symbol: SYMBOL.active, tone: 'accent', rank: 5 },
+  flaky: { word: 'flaky', short: 'flaky', symbol: SYMBOL.idle, tone: 'muted', rank: 6 },
+  verified: { word: 'fix verified', short: 'verified', symbol: SYMBOL.ok, tone: 'success', rank: 7 },
+  resolved: { word: 'resolved', short: 'resolved', symbol: SYMBOL.ok, tone: 'success', rank: 8 },
+};
+/** What still needs someone: a fix, a repair that failed, or more evidence. */
+const TO_FIX: readonly Status[] = ['attention', 'blocked', 'needs_evidence'];
+const RETRYABLE: readonly Status[] = ['attention', 'blocked', 'needs_evidence', 'flaky', 'verified', 'resolved'];
+
+const at = (config: Config): string => `${String(config.hour).padStart(2, '0')}:${String(config.minute).padStart(2, '0')} ${config.timezone}`;
+const firstLine = (text: string): string => text.split('\n').map(line => line.trim()).find(Boolean) ?? '';
+const short = (value: unknown): string => {
+  if (value === undefined || value === null) return '';
+  const record = value as { status?: unknown; explanation?: unknown; verdict?: unknown };
+  return [record.status ?? record.verdict, record.explanation].filter(part => typeof part === 'string' && part).join(' · ').slice(0, 200);
+};
+
+export function signalPanelSpec(ops: SignalPanelOps, initial?: string): PanelSpec {
+  const now = (): number => ops.now?.() ?? Date.now();
+  const sorted = (): readonly LocalIssue[] => [...ops.issues()]
+    .sort((a, b) => STATUS[a.status].rank - STATUS[b.status].rank || b.updated - a.updated);
+  const issueOf = (item: PanelItem | undefined): LocalIssue | undefined =>
+    item && item.id !== TRIAGE ? ops.issues().find(issue => issue.id === item.id) : undefined;
+
+  const triageDetail = (): PanelDetail => {
+    const config = ops.config();
+    const repositories = Object.entries(config.repositories);
+    return {
+      title: 'Daily triage',
+      subtitle: config.enabled ? `runs every day at ${at(config)}` : 'off: signals are disabled in the global configuration',
+      subtitleTone: config.enabled ? 'muted' : 'warning',
+      fields: [
+        { label: 'Signals', value: config.enabled ? 'on' : 'off', tone: config.enabled ? 'success' : 'warning' },
+        { label: 'Repair', value: config.repair ? 'on: verified fixes are prepared in a worktree' : 'off: triage only' },
+        { label: 'Watching', value: config.packages.length ? config.packages.join(', ') : 'Pi and installed extensions' },
+        { label: 'Repositories', value: repositories.length ? repositories.map(([name, repo]) => `${name} (${repo.base})`).join(', ') : 'none configured' },
+      ],
+      sections: [
+        { title: 'Recent days', lines: ops.days().map(day => `${day.day}  ${day.finished ? `finished ${ago(day.finished, now())}` : `started ${ago(day.started, now())}, not finished`}`) },
+        ...(ops.issues().length ? [] : [{ title: 'No issues yet', lines: [
+          'When Pi or an installed extension shows a latency regression, a crash or a concrete response-quality regression, the agent can record it with signal_report.',
+          'Recorded issues appear here and are triaged daily.',
+        ] }]),
+      ],
+    };
+  };
+
+  const issueDetail = (issue: LocalIssue): PanelDetail => {
+    const status = STATUS[issue.status];
+    const observations = [...ops.observations(issue.id)].sort((a, b) => b.created - a.created).slice(0, 5);
+    const runs = [...ops.runs(issue.id)].sort((a, b) => b.started - a.started).slice(0, 5);
+    return {
+      title: issue.title,
+      subtitle: `${issue.component} · ${issue.category}`,
+      fields: [
+        { label: 'Status', value: status.word, tone: status.tone },
+        { label: 'Seen', value: `${issue.sightings} ${issue.sightings === 1 ? 'time' : 'times'}` },
+        { label: 'First seen', value: ago(issue.created, now()) },
+        { label: 'Updated', value: ago(issue.updated, now()) },
+        ...(issue.model ? [{ label: 'Model', value: `${issue.model.provider}/${issue.model.id}` }] : []),
+        ...(issue.lastError ? [{ label: 'Last error', value: issue.lastError, tone: 'error' as const }] : []),
+      ],
+      sections: [
+        ...(issue.decision ? [{ title: `Triage: ${issue.decision.verdict}`, lines: [issue.decision.reason, ...issue.decision.evidence.map(line => `· ${line}`)] }] : []),
+        { title: 'Observations', lines: observations.map(item => `${ago(item.created, now())} · ${item.version} · ${firstLine(item.payload.title) || firstLine(item.payload.body)}`) },
+        { title: 'Runs', lines: runs.map(run => `${run.phase} ${run.state} · ${ago(run.started, now())}${short(run.result) ? ` · ${short(run.result)}` : ''}`) },
+      ],
+    };
+  };
+
+  const actions: PanelAction[] = [{
+    key: 'r', label: 'Queue for triage again',
+    when: item => { const issue = issueOf(item); return !!issue && RETRYABLE.includes(issue.status); },
+    run: (item, panel) => {
+      const issue = issueOf(item)!;
+      const queued = ops.retry(issue.id);
+      panel.notice(queued ? `${issue.title}: queued for the next triage.` : `${issue.title}: a worker is on it; try again later.`, queued ? 'success' : 'warning');
+      panel.refresh();
+    },
+  }];
+
+  return {
+    title: 'Signals',
+    summary: () => {
+      const issues = ops.issues(), config = ops.config();
+      const toFix = issues.filter(issue => TO_FIX.includes(issue.status)).length;
+      return [`${issues.length} ${issues.length === 1 ? 'issue' : 'issues'}`, `${toFix} to fix`,
+        config.enabled ? `triage ${at(config)}` : 'triage off'].join(' · ');
+    },
+    items: () => {
+      const config = ops.config();
+      // The list column is narrow: the label carries what it is, the meta one short fact.
+      const triage: PanelItem = { id: TRIAGE, label: 'Daily triage', symbol: config.enabled ? SYMBOL.active : SYMBOL.idle,
+        tone: config.enabled ? 'success' : 'warning', meta: config.enabled ? at(config).split(' ')[0] : 'off', search: config.timezone };
+      return [triage, ...sorted().map(issue => {
+        const status = STATUS[issue.status];
+        return { id: issue.id, label: `${issue.component} · ${issue.title}`, symbol: status.symbol, tone: status.tone,
+          meta: `${status.short} · ${issue.sightings}×`, search: `${issue.category} ${issue.status} ${status.word}` };
+      })];
+    },
+    detail: item => { const issue = issueOf(item); return issue ? issueDetail(issue) : triageDetail(); },
+    actions,
+    empty: 'No issues yet.',
+    initial: initial ?? sorted()[0]?.id ?? TRIAGE,
+  };
+}

package/src/repair.ts

@@ -43,10 +43,10 @@ export async function repair(issue: LocalIssue, repo: Repository, path: string,
     if (!source.startsWith(path + sep) || !destination.startsWith(baselinePath + sep)) return blocked('Regression file escaped the worktree.');
     // Refuse symlinks throughout either path; do not copy arbitrary external files.
     for (const root of [path, baselinePath]) {
-      let current = root;
+      const cursor = { current: root };
       for (const part of file.split('/')) {
-        current = join(current, part);
-        const stat = await lstat(current).catch(() => undefined);
+        cursor.current = join(cursor.current, part);
+        const stat = await lstat(cursor.current).catch(() => undefined);
         if (stat?.isSymbolicLink()) return blocked('Regression paths must not contain symlinks.');
       }
     }
@@ -62,7 +62,7 @@ export async function repair(issue: LocalIssue, repo: Repository, path: string,
   if (await protectOutboundData(diff) !== diff) return blocked('The candidate diff contains data caught by outbound protection; publication is blocked.');
   await must(path, ['git', 'commit', '-m', `fix: ${issue.title}`], signal);
   const head = await must(path, ['git', 'rev-parse', 'HEAD'], signal);
-  for (let sample = 0; sample < 3; sample++) {
+  for (const _sample of [0, 1, 2]) {
     const before = await command(baselinePath, fix.regressionCommand, signal); checks.push(before);
     if (before.code === 0 || !before.output.includes(fix.failurePattern)) return blocked('The unchanged baseline did not consistently reproduce the claimed failure.');
     const after = await command(path, fix.regressionCommand, signal); checks.push(after);

package/src/store.ts

@@ -34,7 +34,8 @@ export class SignalStore {
   list(offset = 0) { return this.db.prepare('SELECT id FROM issues ORDER BY updated DESC,id LIMIT 21 OFFSET ?').all(offset).map(row => this.get(String(row.id))!); }
   observations(id: string, offset = 0, limit = 21) {
     return this.db.prepare('SELECT * FROM observations WHERE issueId=? ORDER BY created,id LIMIT ? OFFSET ?').all(id, limit, offset)
-      .map(row => ({ ...row, payload: JSON.parse(String(row.payload)) }));
+      .map(row => ({ id: String(row.id), issueId: String(row.issueId), version: String(row.version), created: Number(row.created),
+        payload: JSON.parse(String(row.payload)) as { title: string; body: string } }));
   }
   capture(value: Capture, now = Date.now()) {
     return this.transaction(() => {
@@ -91,5 +92,16 @@ export class SignalStore {
     // An interrupted run never counts as fixed.
     this.db.exec("UPDATE issues SET status='new',lastError='Previous worker interrupted; evidence retained' WHERE status IN ('triaging','repairing'); UPDATE runs SET state='interrupted' WHERE state='running'");
   }
-  runs(id: string) { return this.db.prepare('SELECT * FROM runs WHERE issueId=? ORDER BY started').all(id).map(row => ({ ...row, id: String(row.id), state: String(row.state), result: row.result ? JSON.parse(String(row.result)) : undefined })); }
+  /** The latest daily triage days, newest first. */
+  days(limit = 7) {
+    return this.db.prepare('SELECT day,started,finished FROM schedule ORDER BY day DESC LIMIT ?').all(limit)
+      .map(row => ({ day: String(row.day), started: Number(row.started), ...(row.finished == null ? {} : { finished: Number(row.finished) }) }));
+  }
+  runs(id: string) {
+    return this.db.prepare('SELECT * FROM runs WHERE issueId=? ORDER BY started').all(id).map(row => ({
+      id: String(row.id), issueId: String(row.issueId), revision: Number(row.revision), phase: String(row.phase), owner: String(row.owner),
+      state: String(row.state), started: Number(row.started), ...(row.finished == null ? {} : { finished: Number(row.finished) }),
+      result: row.result ? JSON.parse(String(row.result)) as unknown : undefined,
+    }));
+  }
 }