@prjct.app/pi-signals 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 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.
+
 ## 0.1.1 (2026-10-07)
 
 - Bind the standalone npm CLI to the Pi host's public SDK peers, which Pi intentionally omits from extension installs. Record the host location on session start and use the same bootstrap for scheduled runs.

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
+        }));
       }
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prjct.app/pi-signals",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "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",

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>;
@@ -20,8 +22,8 @@ export function installSignals(pi: ExtensionAPI, dependencies: SignalsDependenci
   };
   pi.registerTool({
     name: 'signal_report', label: 'Record failure signal',
-    description: 'Record a local issue in the global .prjct database for an installed extension or Pi: latency regression, crash, or concrete response-quality regression. Supply a stable defect signature, exact session evidence, reproduction steps, expected and actual behavior. No GitHub or model request occurs during capture.',
-    promptGuidelines: ['When you detect a latency regression, crash, or concrete response-quality regression in Pi or an installed extension, record minimal evidence with signal_report, then continue the original task. Use signal_inspect for targets. Detection is a signal, not proof of causality; the active agent and later triage decide.'],
+    // No promptGuidelines: a system-prompt rule asked every session to watch Pi, whatever the task.
+    description: 'Record a local issue in the global .prjct database for an installed extension or Pi: latency regression, crash, or concrete response-quality regression. Supply a stable defect signature, exact session evidence, reproduction steps, expected and actual behavior. Find targets with signal_inspect first; a detection is a signal, not proof of causality. No GitHub or model request occurs during capture; afterwards, continue the original task.',
     parameters: ReportSchema,
     async execute(_id, input, _signal, _update, ctx) {
       const target = catalog(ctx).find(target => target.id === input.target);
@@ -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/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,
+    }));
+  }
 }