pi-note 0.39.4 → 0.40.1

package/mcp/core.ts

@@ -14,6 +14,7 @@ import { stripVTControlCharacters } from 'node:util';
 import { defaultAgentGuidance, defaultFooterField, defaultHandoffPrompt, defaultNewSessionPrompt, effectiveFooterFields, parseAgentGuidance, parseFooterConfig, parseHandoffPrompt, parseNewSessionPrompt, readConfigDocument, readFooterDocument, saveFooterConfig } from '../footer-config.ts';
 import { proposalTitleOptions, proposalDescriptionOptions, proposalText } from '../proposal.ts';
 import type { FieldAutomation, FieldResult } from './field-events.ts';
+import { discoverFieldWatchers, parseFieldWatchers, validateWatcherExecutable, type FieldWatcherConfig } from '../field-watchers.ts';
 import { taskTitle } from '../task-title.ts';
 
 const URI = 'pinote://ui';
@@ -35,7 +36,7 @@ const ProposalInput = z.union([
   ExistingProposal,
 ]);
 const Proposal = z.union([NewProposal.extend({ id: z.string().uuid() }), ExistingProposal.extend({ id: z.string().uuid() })]);
-const Context = z.object({ conversationId: z.string().min(1).max(256), contextId: z.string().min(1).max(256).optional(), state: z.object({
+const Context = z.object({ conversationId: z.string().min(1).max(256), contextId: z.string().min(1).max(256).optional(), fieldReceipts: z.array(z.string().uuid()).max(4096).optional(), state: z.object({
   proposal: Proposal.nullable().optional(),
   launch: z.object({ task_id: TaskId, updated_at: z.string().min(1).max(128) }).strict().optional(),
   selectedId: z.number().int().positive().safe().nullable().optional(), screen: z.enum(['tasks', 'settings', 'field']).optional(),
@@ -104,7 +105,7 @@ function settings() {
   if (!['always', 'github-remote', 'never'].includes(policy)) throw new Error('Invalid taskOfferPolicy in pi-note.json');
   const guidanceOverridden = Object.hasOwn(root, 'agentGuidance');
   const guidance = guidanceOverridden ? parseAgentGuidance(root.agentGuidance) : defaultAgentGuidance;
-  return { ...document, handoffPrompt, newSessionPrompt, policy, guidance, guidanceOverridden };
+  return { ...document, handoffPrompt, newSessionPrompt, policy, guidance, guidanceOverridden, watchers: discoverFieldWatchers(root) };
 }
 function agentGuidance(): string {
   const { value: root } = readConfigDocument();
@@ -117,7 +118,7 @@ async function selection(state: State, signal: AbortSignal) {
   if (proposal && 'task_id' in proposal && (!proposedTask || !['active', 'in_progress'].includes(proposedTask.state))) proposal = null;
   return { task, proposal, proposedTask };
 }
-async function snapshot(state: State, signal: AbortSignal, automation?: FieldAutomation, contextId?: string) {
+async function snapshot(state: State, signal: AbortSignal, automation?: FieldAutomation, contextId?: string, receipts: readonly string[] = []) {
   const launchTask: Task | null = state.launch ? JSON.parse(await note(['agent', 'get', String(state.launch.task_id)], signal)) : null;
   const tasks: Task[] = state.launch
     ? launchTask && ['active', 'in_progress'].includes(launchTask.state) ? [launchTask] : []
@@ -129,7 +130,7 @@ async function snapshot(state: State, signal: AbortSignal, automation?: FieldAut
   if (state.screen === 'field' && !fields(config.config, task?.agent_notes).some((f) => f.name === state.field)) state.screen = 'settings';
   state = Context.parse({ conversationId: 'canonical', state }).state;
   const fieldStatuses = task ? automation?.statuses(task) ?? [] : [];
-  const fieldNotifications = task && contextId ? automation?.notices(task, contextId) ?? [] : [];
+  const fieldNotifications = task && contextId ? automation?.notices(task, contextId, receipts) ?? [] : [];
   const revision = createHash('sha256').update(JSON.stringify({ state, tasks, task, proposedTask, raw: config.raw, fieldStatuses, fieldNotifications })).digest('hex');
   return { state, tasks, task, proposedTask, suggestion, config, revision, fieldStatuses, fieldNotifications };
 }
@@ -159,6 +160,7 @@ function footerFeatures(meta: Record<string, unknown> | undefined) {
     footerNativeActions: z.object({ footerNativeActions: z.literal(true) }).safeParse(meta?.['native-ui/features']).success,
     footerStyles: z.object({ footerStyles: z.literal(true) }).safeParse(meta?.['native-ui/features']).success,
     fieldEvents: z.object({ fieldEvents: z.literal(true) }).safeParse(meta?.['native-ui/features']).success,
+    fieldWatchers: z.object({ fieldWatchers: z.literal(true) }).safeParse(meta?.['native-ui/features']).success,
     footerDoubleActions: z.object({ footerDoubleActions: z.literal(true) }).safeParse(meta?.['native-ui/features']).success,
   };
 }
@@ -170,7 +172,7 @@ function fullPreview(task: { text: string; agent_notes?: Record<string, string>
   const document = task.text + notes;
   return document.length <= 20_000 ? document : 'Full preview exceeds the 20000-character display limit. Nothing has been truncated here: read the complete task and handoff notes through the Pinote CLI or service (get_task).';
 }
-function view(data: Snapshot, scoped = false, secondary = false, features: { footerNativeActions?: boolean; footerStyles?: boolean; footerDoubleActions?: boolean; fieldEvents?: boolean } = {}) {
+function view(data: Snapshot, scoped = false, secondary = false, features: { footerNativeActions?: boolean; footerStyles?: boolean; footerDoubleActions?: boolean; fieldEvents?: boolean; fieldWatchers?: boolean } = {}) {
   const { tasks, task, suggestion, config, revision } = data;
   const state = Context.parse({ conversationId: 'outgoing-state', state: { ...data.state, selectedId: task?.id ?? null } }).state;
   const controls: Control[] = [];
@@ -202,6 +204,16 @@ function view(data: Snapshot, scoped = false, secondary = false, features: { foo
     for (const [key, label, description] of [['titleWidth', 'Task title width', '3–1000 terminal cells.'], ['fieldWidth', 'Default field width', '3–1000 terminal cells; inherited by fields without a width override.'], ['maxFields', 'Maximum visible fields', '0–64 fields; 0 hides all task fields.']] as const) controls.push({ id: key, label, description, kind: 'number', value: config.config[key], confirm: 'Save this global footer setting?' });
     controls.push({ id: 'add-field', label: 'Add field', icon: icons.add, kind: 'text', value: '', description: 'Unique nonblank field name, at most 64 characters; Bar is reserved. Changes display definitions, not task values.', confirm: 'Add this global footer field?' });
     fields(config.config, task?.agent_notes).forEach((field) => action(`field:${field.name}`, field.name, { description: `${field.label || '(no label)'} · ${field.format}` }));
+    controls.push({ id: 'add-watcher', label: 'Add watcher file', icon: icons.add, kind: 'text', value: '',
+      description: 'Absolute executable path on the service machine. Added disabled; enable separately after reviewing trusted code.',
+      confirm: 'Add this trusted watcher file to shared fieldWatchers (disabled)?' });
+    for (const watcher of config.watchers) {
+      controls.push({ id: `watcher:${watcher.id}`, label: watcher.name, kind: 'toggle', value: watcher.enabled,
+        description: `${watcher.bundled ? 'Bundled' : 'Custom'} · ${watcher.path}`,
+        confirm: `Change this shared watcher?\n${watcher.path}\nEnabling executes trusted code with the service user’s permissions and credentials. Its alerts automatically trigger the owning Pi worker to investigate and fix the current task. Disabling stops checks and hides its results.` });
+      if (!watcher.bundled) action(`remove-watcher:${watcher.id}`, `Remove ${watcher.name}`, { icon: icons.cross,
+        description: watcher.path, confirm: `Remove this watcher from shared settings? The file and task values are retained.\n${watcher.path}` });
+    }
   } else if (state.screen === 'field') {
     const field = fields(config.config, task?.agent_notes).find((f) => f.name === state.field);
     if (!field) throw new Error('Field no longer exists; open Settings again');
@@ -222,6 +234,8 @@ function view(data: Snapshot, scoped = false, secondary = false, features: { foo
     const matches = tasks.filter((t) => state.launch
       ? t.id === state.launch.task_id && t.updated_at === state.launch.updated_at
       : terms.every((term) => `${t.text} ${t.tag ?? ''} #${t.id}`.toLowerCase().includes(term)));
+    // IDs are assigned by SQLite AUTOINCREMENT at creation and retained on edits/restores.
+    matches.sort((a, b) => b.id - a.id);
     for (const candidate of matches.slice(0, 200)) action(`select:${candidate.id}`, taskTitle(candidate.text), { description: `#${candidate.id} · ${candidate.tag || 'No tag'} · ${humanStatus(candidate.state)}${candidate.id === task?.id ? ' · CURRENT' : ''} · Select and start this task for this conversation` });
     if (matches.length > 200) body += '\nShowing the first 200 matches; use Filter tasks to narrow the list.';
   }
@@ -274,7 +288,7 @@ function view(data: Snapshot, scoped = false, secondary = false, features: { foo
     return false;
   });
   if (scoped) for (const control of editable) control.revision = actionRevision(data, control);
-  const result = { version: 1, title, body: body.slice(0, 20_000), revision, state: boundedState(state), retainOnNew: true, controls: editable, footer, ...(features.fieldEvents ? { fieldNotifications: data.fieldNotifications } : {}) };
+  const result = { version: 1, title, body: body.slice(0, 20_000), revision, state: boundedState(state), retainOnNew: true, controls: editable, footer, ...(features.fieldEvents ? { fieldNotifications: data.fieldNotifications.map((notice) => ({ ...notice, ...(features.fieldWatchers ? { triggerWorker: true } : {}) })) } : {}) };
   // JSON escaping and expanded footer formats can exceed the host budget even
   // with bounded row counts. Preserve navigation/filter controls ahead of rows.
   let shortened = false;
@@ -337,14 +351,14 @@ server.setRequestHandler(ReadResourceRequestSchema, (request, extra) => serial(a
   }
   if (request.params.uri !== URI) throw new Error('Unknown resource');
   const caller = context(request.params._meta);
-  const data = await snapshot(caller.state, extra.signal, options.fieldAutomation, caller.contextId ?? caller.conversationId);
+  const data = await snapshot(caller.state, extra.signal, options.fieldAutomation, caller.contextId ?? caller.conversationId, caller.fieldReceipts);
   return { contents: [{ uri: URI, mimeType: MIME, text: JSON.stringify(view(data, scopedActions(request.params._meta), secondaryActions(request.params._meta), footerFeatures(request.params._meta))) }] };
 }));
 server.setRequestHandler(Action, (request, extra) => serial(async () => {
   const caller = context(request.params._meta);
   const state = caller.state;
   const owner = caller.contextId ?? caller.conversationId;
-  const before = await snapshot(state, extra.signal, options.fieldAutomation, owner);
+  const before = await snapshot(state, extra.signal, options.fieldAutomation, owner, caller.fieldReceipts);
   const scoped = scopedActions(request.params._meta);
   const { action, value } = request.params;
   const control = view(before, scoped, secondaryActions(request.params._meta), footerFeatures(request.params._meta)).controls.find((item) => item.id === action);
@@ -389,7 +403,25 @@ server.setRequestHandler(Action, (request, extra) => serial(async () => {
     const cfg = structuredClone(before.config.config);
     let handoff = before.config.handoffPrompt, newSession = before.config.newSessionPrompt, policy = before.config.policy;
     let guidance: string | null | undefined;
-    if (action === 'agentGuidance') guidance = parseAgentGuidance(value);
+    let watchers: FieldWatcherConfig[] | undefined;
+    if (action === 'add-watcher' || action.startsWith('watcher:') || action.startsWith('remove-watcher:')) {
+      watchers = before.config.watchers.map(({ path, enabled }) => ({ path, enabled }));
+      if (action === 'add-watcher') {
+        const entry = parseFieldWatchers({ fieldWatchers: [{ path: z.string().parse(value), enabled: false }] })[0];
+        validateWatcherExecutable(entry.path);
+        watchers.push(entry);
+      } else {
+        const watcher = before.config.watchers.find((item) => item.id === action.split(':')[1]);
+        if (!watcher) staleAction();
+        if (action.startsWith('remove-watcher:')) watchers = watchers.filter((item) => item.path !== watcher.path);
+        else {
+          const enabled = z.boolean().parse(value);
+          if (enabled) validateWatcherExecutable(watcher.path);
+          watchers.find((item) => item.path === watcher.path)!.enabled = enabled;
+        }
+      }
+      watchers = parseFieldWatchers({ fieldWatchers: watchers });
+    } else if (action === 'agentGuidance') guidance = parseAgentGuidance(value);
     else if (action === 'reset-agent-guidance') guidance = null;
     else if (action === 'handoffPrompt') handoff = z.string().parse(value);
     else if (action === 'newSessionPrompt') newSession = z.string().parse(value);
@@ -408,10 +440,10 @@ server.setRequestHandler(Action, (request, extra) => serial(async () => {
       }
     }
     extra.signal.throwIfAborted();
-    saveFooterConfig(cfg, before.config.raw, handoff, newSession, policy, guidance);
+    saveFooterConfig(cfg, before.config.raw, handoff, newSession, policy, guidance, watchers);
   }
   if (next.selectedId && (action.startsWith('select:') || action === 'proposal:accept' || action === 'add')) options.fieldAutomation?.claim(next.selectedId, owner, true);
-  const result = { view: view(await snapshot(next, extra.signal, options.fieldAutomation, owner), scoped, secondaryActions(request.params._meta), footerFeatures(request.params._meta)), ...(draft ? { draft } : {}), ...(preview ? { preview } : {}) };
+  const result = { view: view(await snapshot(next, extra.signal, options.fieldAutomation, owner, caller.fieldReceipts), scoped, secondaryActions(request.params._meta), footerFeatures(request.params._meta)), ...(draft ? { draft } : {}), ...(preview ? { preview } : {}) };
   await notifyChanged();
   return result;
 }));

package/mcp/field-events.ts

@@ -7,6 +7,7 @@ import { homedir } from 'node:os';
 import type { DatabaseSync } from 'node:sqlite';
 import { z } from 'zod';
 import { readConfigDocument } from '../footer-config.ts';
+import { discoverFieldWatchers, type FieldWatcher } from '../field-watchers.ts';
 
 const exec = promisify(execFile);
 const integer = z.number().int().nonnegative().safe();
@@ -23,20 +24,12 @@ export const FieldResult = z.object({
 }).strict();
 export type FieldResult = z.infer<typeof FieldResult>;
 type FieldEvent = z.infer<typeof Event>;
-type Job = { event: FieldEvent; result?: FieldResult; due: number | null; attempts: number; checkedAt?: string; stale?: boolean };
-export type FieldStatus = { field: string; value: string; result: FieldResult; checkedAt?: string; stale: boolean };
+type Job = { watcherId: string; event: FieldEvent; result?: FieldResult; due: number | null; attempts: number; checkedAt?: string; stale?: boolean };
+export type FieldStatus = { watcherId: string; field: string; value: string; result: FieldResult; checkedAt?: string; stale: boolean };
 export type FieldNotice = { id: string; taskId: number; field: string; message: string };
 type Task = { id: number; state: string; updated_at: string; agent_notes: Record<string, string> };
 type Row = { job: string };
 
-export function configuredFieldHandler(): string | undefined {
-  const { value: config } = readConfigDocument();
-  const handler = config.fieldHandler;
-  if (handler === undefined || handler === null) return undefined;
-  if (typeof handler !== 'string' || !isAbsolute(handler) || /[\u0000-\u001f\u007f]/u.test(handler)) throw new Error('fieldHandler must be an absolute executable file path');
-  return handler;
-}
-
 /** One bounded invocation, no shell. Kill the process group on cancellation/overflow. */
 export function runFieldHandler(handler: string, input: unknown, signal: AbortSignal, timeoutMs = 30_000): Promise<FieldResult> {
   signal.throwIfAborted();
@@ -71,20 +64,26 @@ export class FieldAutomation {
   private lifetime = new AbortController();
   private timer?: ReturnType<typeof setTimeout>;
   private work?: Promise<void>;
-  private handler: string;
+  private watchers: () => FieldWatcher[];
+  private enabled: FieldWatcher[] = [];
+  private signature = '';
+  private generation = 0;
+  private invocation?: AbortController;
+  private ticking = false;
   private noteCommand: string;
   private changed: () => void;
   private log: () => void;
-  private constructor(db: DatabaseSync, handler: string, noteCommand: string, changed: () => void, log: () => void) {
-    this.db = db; this.handler = handler; this.noteCommand = noteCommand; this.changed = changed; this.log = log;
+  private constructor(db: DatabaseSync, watchers: () => FieldWatcher[], noteCommand: string, changed: () => void, log: () => void) {
+    this.db = db; this.watchers = watchers; this.noteCommand = noteCommand; this.changed = changed; this.log = log;
     db.exec(`PRAGMA busy_timeout=5000;
-      CREATE TABLE IF NOT EXISTS scheduler (id INTEGER PRIMARY KEY CHECK(id=1), cursor INTEGER NOT NULL DEFAULT 0, handler TEXT NOT NULL, owner TEXT, lease_until INTEGER NOT NULL DEFAULT 0);
-      CREATE TABLE IF NOT EXISTS jobs (task_id INTEGER NOT NULL, field TEXT NOT NULL, job TEXT NOT NULL, PRIMARY KEY(task_id, field));
+      CREATE TABLE IF NOT EXISTS fw_scheduler (id INTEGER PRIMARY KEY CHECK(id=1), owner TEXT, lease_until INTEGER NOT NULL DEFAULT 0);
+      CREATE TABLE IF NOT EXISTS fw_watchers (id TEXT PRIMARY KEY, path TEXT NOT NULL, cursor INTEGER NOT NULL DEFAULT 0);
+      CREATE TABLE IF NOT EXISTS fw_jobs (watcher_id TEXT NOT NULL, task_id INTEGER NOT NULL, field TEXT NOT NULL, job TEXT NOT NULL, PRIMARY KEY(watcher_id,task_id,field));
       CREATE TABLE IF NOT EXISTS owners (task_id INTEGER PRIMARY KEY, context_id TEXT NOT NULL);
-      CREATE TABLE IF NOT EXISTS notices (task_id INTEGER NOT NULL, field TEXT NOT NULL, id TEXT NOT NULL, message TEXT NOT NULL, PRIMARY KEY(task_id, field));`);
-    db.prepare('INSERT OR IGNORE INTO scheduler(id, handler) VALUES (1, ?)').run(handler);
+      CREATE TABLE IF NOT EXISTS fw_notices (watcher_id TEXT NOT NULL, task_id INTEGER NOT NULL, field TEXT NOT NULL, id TEXT NOT NULL, message TEXT NOT NULL, PRIMARY KEY(watcher_id,task_id,field));
+      INSERT OR IGNORE INTO fw_scheduler(id) VALUES (1);`);
   }
-  static async open(options: { handler: string; path?: string; noteCommand?: string; changed?: () => void; log?: () => void }): Promise<FieldAutomation> {
+  static async open(options: { watchers?: () => FieldWatcher[]; path?: string; noteCommand?: string; changed?: () => void; log?: () => void } = {}): Promise<FieldAutomation> {
     const dataHome = process.env.XDG_DATA_HOME;
     const database = join(dataHome && isAbsolute(dataHome) ? dataHome : join(homedir(), '.local/share'), 'pinote/notes.db');
     const namespace = createHash('sha256').update(database).digest('hex').slice(0, 16);
@@ -97,7 +96,7 @@ export class FieldAutomation {
     if (!stat.isFile() || stat.uid !== process.getuid?.() || (stat.mode & 0o077)) throw new Error('Unsafe field automation database');
     const { DatabaseSync } = await import('node:sqlite');
     const db = new DatabaseSync(path);
-    try { return new FieldAutomation(db, options.handler, options.noteCommand ?? process.env.PINOTE_NOTE_COMMAND ?? 'note', options.changed ?? (() => {}), options.log ?? (() => {})); }
+    try { return new FieldAutomation(db, options.watchers ?? (() => discoverFieldWatchers(readConfigDocument().value)), options.noteCommand ?? process.env.PINOTE_NOTE_COMMAND ?? 'note', options.changed ?? (() => {}), options.log ?? (() => {})); }
     catch (error) { db.close(); throw error; }
   }
   private async note(args: string[]): Promise<unknown> {
@@ -105,7 +104,7 @@ export class FieldAutomation {
     return JSON.parse(stdout);
   }
   private leased(): boolean {
-    return Boolean(this.db.prepare('SELECT 1 FROM scheduler WHERE id=1 AND owner=? AND lease_until>?').get(this.owner, Date.now()));
+    return Boolean(this.db.prepare('SELECT 1 FROM fw_scheduler WHERE id=1 AND owner=? AND lease_until>?').get(this.owner, Date.now()));
   }
   private transaction(work: () => void): void {
     this.db.exec('BEGIN IMMEDIATE');
@@ -114,13 +113,33 @@ export class FieldAutomation {
       work(); this.db.exec('COMMIT');
     } catch (error) { this.db.exec('ROLLBACK'); throw error; }
   }
+  private reconcile(): void {
+    const enabled = this.watchers().filter((watcher) => watcher.enabled);
+    if (enabled.length > 32 || new Set(enabled.map((w) => w.id)).size !== enabled.length) throw new Error('Invalid enabled watchers');
+    const signature = JSON.stringify(enabled.map((w) => [w.id, w.path]));
+    if (signature === this.signature) return;
+    this.generation++; this.invocation?.abort();
+    this.db.exec('BEGIN IMMEDIATE');
+    try {
+      for (const row of this.db.prepare('SELECT id,path FROM fw_watchers').all()) {
+        if (!enabled.some((w) => w.id === row.id && w.path === row.path)) {
+          this.db.prepare('DELETE FROM fw_jobs WHERE watcher_id=?').run(row.id);
+          this.db.prepare('DELETE FROM fw_notices WHERE watcher_id=?').run(row.id);
+          this.db.prepare('DELETE FROM fw_watchers WHERE id=?').run(row.id);
+        }
+      }
+      for (const watcher of enabled) this.db.prepare('INSERT OR IGNORE INTO fw_watchers(id,path) VALUES (?,?)').run(watcher.id, watcher.path);
+      this.db.exec('COMMIT');
+    } catch (error) { this.db.exec('ROLLBACK'); throw error; }
+    this.enabled = enabled; this.signature = signature; this.changed();
+  }
   private save(job: Job): void {
-    this.db.prepare('INSERT INTO jobs(task_id,field,job) VALUES (?,?,?) ON CONFLICT(task_id,field) DO UPDATE SET job=excluded.job')
-      .run(job.event.taskId, job.event.field, JSON.stringify(job));
+    this.db.prepare('INSERT INTO fw_jobs(watcher_id,task_id,field,job) VALUES (?,?,?,?) ON CONFLICT(watcher_id,task_id,field) DO UPDATE SET job=excluded.job')
+      .run(job.watcherId, job.event.taskId, job.event.field, JSON.stringify(job));
   }
-  private clear(taskId: number, name: string): void {
-    this.db.prepare('DELETE FROM jobs WHERE task_id=? AND field=?').run(taskId, name);
-    this.db.prepare('DELETE FROM notices WHERE task_id=? AND field=?').run(taskId, name);
+  private clear(watcherId: string, taskId: number, name: string): void {
+    this.db.prepare('DELETE FROM fw_jobs WHERE watcher_id=? AND task_id=? AND field=?').run(watcherId, taskId, name);
+    this.db.prepare('DELETE FROM fw_notices WHERE watcher_id=? AND task_id=? AND field=?').run(watcherId, taskId, name);
   }
   /** Explicit selection/write owns alerts; background reads can only claim unowned tasks. */
   claim(taskId: number, contextId: string, replace = false): void {
@@ -129,19 +148,21 @@ export class FieldAutomation {
       : 'INSERT OR IGNORE INTO owners(task_id,context_id) VALUES (?,?)').run(taskId, contextId);
   }
   statuses(task: Task): FieldStatus[] {
-    return (this.db.prepare('SELECT job FROM jobs WHERE task_id=?').all(task.id) as Row[]).flatMap(({ job: raw }) => {
+    this.reconcile();
+    return this.enabled.flatMap((watcher) => (this.db.prepare('SELECT job FROM fw_jobs WHERE watcher_id=? AND task_id=?').all(watcher.id, task.id) as Row[]).flatMap(({ job: raw }) => {
       const job = JSON.parse(raw) as Job;
-      if (job.event.value === null || job.event.value !== task.agent_notes[job.event.field] || !job.result) return [];
-      return [{ field: job.event.field, value: job.event.value, result: job.result, checkedAt: job.checkedAt, stale: job.stale ?? false }];
-    });
+      if (job.event.value === null || job.event.value !== task.agent_notes[job.event.field] || !job.result || Object.keys(job.result).length === 0) return [];
+      return [{ watcherId: watcher.id, field: job.event.field, value: job.event.value, result: job.result, checkedAt: job.checkedAt, stale: job.stale ?? false }];
+    }));
   }
-  notices(task: Task, contextId: string): FieldNotice[] {
+  notices(task: Task, contextId: string, receipts: readonly string[] = []): FieldNotice[] {
     this.claim(task.id, contextId);
     const owner = this.db.prepare('SELECT context_id FROM owners WHERE task_id=?').get(task.id);
     if (owner?.context_id !== contextId) return [];
-    const fields = new Set(this.statuses(task).filter((s) => !s.stale && s.result.notification).map((s) => s.field));
-    return (this.db.prepare('SELECT id, field, message FROM notices WHERE task_id=?').all(task.id) as { id: string; field: string; message: string }[])
-      .filter((n) => fields.has(n.field)).map((n) => ({ ...n, taskId: task.id }));
+    const received = new Set(receipts);
+    const fields = new Set(this.statuses(task).filter((s) => !s.stale && s.result.notification).map((s) => `${s.watcherId}:${s.field}`));
+    return (this.db.prepare('SELECT watcher_id, id, field, message FROM fw_notices WHERE task_id=?').all(task.id) as { watcher_id: string; id: string; field: string; message: string }[])
+      .filter((n) => !received.has(n.id) && fields.has(`${n.watcher_id}:${n.field}`)).slice(0, 64).map(({ id, field, message }) => ({ id, field, message, taskId: task.id }));
   }
   start(): void {
     const schedule = () => {
@@ -154,80 +175,103 @@ export class FieldAutomation {
     };
     schedule();
   }
-  async tick(): Promise<void> {
+  tick(): Promise<void> {
+    if (this.ticking) return this.work ?? Promise.resolve();
+    this.ticking = true;
+    const work = this.performTick().finally(() => { this.ticking = false; if (this.work === work) this.work = undefined; });
+    this.work = work;
+    return work;
+  }
+  private async performTick(): Promise<void> {
     this.lifetime.signal.throwIfAborted();
-    const acquired = this.db.prepare('UPDATE scheduler SET owner=?, lease_until=? WHERE id=1 AND (lease_until<=? OR owner=?)')
+    const acquired = this.db.prepare('UPDATE fw_scheduler SET owner=?, lease_until=? WHERE id=1 AND (lease_until<=? OR owner=?)')
       .run(this.owner, Date.now() + 90_000, Date.now(), this.owner).changes;
     if (!acquired) return;
     try {
-      let state = this.db.prepare('SELECT cursor, handler FROM scheduler WHERE id=1').get() as { cursor: number; handler: string };
-      if (state.handler !== this.handler) {
-        this.transaction(() => {
-          this.db.exec('DELETE FROM jobs; DELETE FROM notices;');
-          this.db.prepare('UPDATE scheduler SET cursor=0, handler=? WHERE id=1').run(this.handler);
-        });
-        state = { cursor: 0, handler: this.handler }; this.changed();
+      this.reconcile();
+      const generation = this.generation;
+      const valid = () => {
+        this.reconcile();
+        if (!this.leased() || generation !== this.generation || this.lifetime.signal.aborted) return false;
+        // Many watchers can make intake longer than one lease; each bounded operation renews it.
+        this.db.prepare('UPDATE fw_scheduler SET lease_until=? WHERE id=1 AND owner=?').run(Date.now() + 90_000, this.owner);
+        return true;
       }
-      const batch = Batch.parse(await this.note(['field-events', '--after', String(state.cursor), '--limit', '25']));
-      if (!this.leased()) return;
-      if (batch.cursor < state.cursor || batch.events.some((e) => e.id <= state.cursor || e.id > batch.cursor)) throw new Error('Invalid field event cursor');
-      if (batch.cursor !== state.cursor) {
-        this.transaction(() => {
-          for (const event of batch.events) {
-            // New input invalidates both old display and pending alerts immediately.
-            this.clear(event.taskId, event.field);
-            this.save({ event, due: Date.now(), attempts: 0 });
-          }
-          this.db.prepare('UPDATE scheduler SET cursor=? WHERE id=1').run(batch.cursor);
-        });
-        this.changed();
-        return; // Drain durable history before executing; coalesce superseded values.
+      let drained = false;
+      for (const watcher of this.enabled) {
+        const state = this.db.prepare('SELECT cursor FROM fw_watchers WHERE id=?').get(watcher.id) as { cursor: number };
+        const batch = Batch.parse(await this.note(['field-events', '--after', String(state.cursor), '--limit', '25']));
+        if (!valid()) return;
+        if (batch.cursor < state.cursor || batch.events.some((e) => e.id <= state.cursor || e.id > batch.cursor)) throw new Error('Invalid field event cursor');
+        if (batch.cursor !== state.cursor) {
+          this.transaction(() => {
+            for (const event of batch.events) {
+              this.clear(watcher.id, event.taskId, event.field);
+              this.save({ watcherId: watcher.id, event, due: Date.now(), attempts: 0 });
+            }
+            this.db.prepare('UPDATE fw_watchers SET cursor=? WHERE id=?').run(batch.cursor, watcher.id);
+          });
+          drained = true;
+        }
       }
-      const jobs = (this.db.prepare('SELECT job FROM jobs').all() as Row[]).map(({ job }) => JSON.parse(job) as Job);
+      if (drained) { this.changed(); return; }
+      const jobs = (this.db.prepare('SELECT job FROM fw_jobs').all() as Row[]).map(({ job }) => JSON.parse(job) as Job);
       const job = jobs.filter((j) => j.due !== null && j.due <= Date.now()).sort((a, b) => a.due! - b.due!)[0];
       if (!job) return;
       const event = job.event;
+      const watcher = this.enabled.find((w) => w.id === job.watcherId);
+      if (!watcher) return;
       const task = await this.note(['agent', 'get', String(event.taskId)]) as Task;
-      if (!this.leased()) return;
+      if (!valid()) return;
       const currentValue = task && ['active', 'in_progress'].includes(task.state) ? task.agent_notes[event.field] ?? null : null;
-      if (event.value !== currentValue) { this.transaction(() => this.clear(event.taskId, event.field)); this.changed(); return; }
+      if (event.value !== currentValue) { this.transaction(() => this.clear(job.watcherId, event.taskId, event.field)); this.changed(); return; }
       let result: FieldResult, retryAfterSeconds = 0;
+      const invocation = new AbortController();
+      this.invocation = invocation;
+      const abort = () => invocation.abort();
+      this.lifetime.signal.addEventListener('abort', abort, { once: true });
+      const poll = setInterval(() => { try { this.reconcile(); } catch { invocation.abort(); } }, 100);
       try {
-        result = await runFieldHandler(this.handler, {
+        result = await runFieldHandler(watcher.path, {
           version: 1, eventId: `${event.id}:${event.field}`, taskId: event.taskId, field: event.field,
           event: job.checkedAt ? 'check' : event.event, value: event.value, previousValue: event.previousValue,
           ...(job.result ? { previousResult: job.result } : {}),
-        }, this.lifetime.signal);
+        }, invocation.signal);
         if (result.state === 'error') {
           retryAfterSeconds = result.recheckAfterSeconds ?? 0;
           throw new Error('Handler reported unavailable data');
         }
       } catch {
-        if (!this.leased() || this.lifetime.signal.aborted) return;
+        if (!valid() || invocation.signal.aborted) return;
         job.attempts++; job.stale = true;
         job.result ??= { state: 'error', summary: 'Field handler unavailable', display: { color: 'muted' } };
         job.due = Date.now() + Math.max(retryAfterSeconds, Math.min(3600, 30 * 2 ** Math.min(job.attempts - 1, 7))) * 1000;
         this.transaction(() => this.save(job)); this.changed(); this.log(); return;
       }
+      finally {
+        clearInterval(poll); this.lifetime.signal.removeEventListener('abort', abort);
+        if (this.invocation === invocation) this.invocation = undefined;
+      }
+      if (!valid() || invocation.signal.aborted) return;
       const latest = await this.note(['agent', 'get', String(event.taskId)]) as Task;
-      if (!this.leased()) return;
+      if (!valid()) return;
       if (latest?.updated_at !== task?.updated_at) return; // Includes remove/re-add (ABA); next tick drains new events.
       this.transaction(() => {
-        if (event.value === null) this.clear(event.taskId, event.field);
+        if (event.value === null) this.clear(job.watcherId, event.taskId, event.field);
         else {
           const notification = result.notification;
-          if (!notification) this.db.prepare('DELETE FROM notices WHERE task_id=? AND field=?').run(event.taskId, event.field);
+          if (!notification) this.db.prepare('DELETE FROM fw_notices WHERE watcher_id=? AND task_id=? AND field=?').run(job.watcherId, event.taskId, event.field);
           else if (JSON.stringify(notification) !== JSON.stringify(job.result?.notification)) {
-            this.db.prepare('INSERT INTO notices(task_id,field,id,message) VALUES (?,?,?,?) ON CONFLICT(task_id,field) DO UPDATE SET id=excluded.id,message=excluded.message')
-              .run(event.taskId, event.field, randomUUID(), notification.message);
+            this.db.prepare('INSERT INTO fw_notices(watcher_id,task_id,field,id,message) VALUES (?,?,?,?,?) ON CONFLICT(watcher_id,task_id,field) DO UPDATE SET id=excluded.id,message=excluded.message')
+              .run(job.watcherId, event.taskId, event.field, randomUUID(), notification.message);
           }
-          this.save({ event, result, due: result.recheckAfterSeconds ? Date.now() + result.recheckAfterSeconds * 1000 : null,
+          this.save({ watcherId: job.watcherId, event, result, due: result.recheckAfterSeconds ? Date.now() + result.recheckAfterSeconds * 1000 : null,
             attempts: 0, checkedAt: new Date().toISOString(), stale: false });
         }
       });
       this.changed();
     } finally {
-      this.db.prepare('UPDATE scheduler SET lease_until=0 WHERE id=1 AND owner=?').run(this.owner);
+      this.db.prepare('UPDATE fw_scheduler SET lease_until=0 WHERE id=1 AND owner=?').run(this.owner);
     }
   }
   async close(): Promise<void> {

package/mcp/http.ts

@@ -9,7 +9,7 @@ import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { createPinoteServer } from './core.ts';
 import { completionEvents } from './events.ts';
 import { pinoteToken } from '../token.ts';
-import { configuredFieldHandler, FieldAutomation } from './field-events.ts';
+import { FieldAutomation } from './field-events.ts';
 
 export interface PinoteHttpOptions {
   token?: string;
@@ -61,11 +61,10 @@ export async function startPinoteHttpServer(options: PinoteHttpOptions = {}) {
   if (configuredHosts?.some((value) => !/^(?:\[[0-9a-fA-F:]+\]|[a-zA-Z0-9.-]+)(?::[0-9]+)?$/.test(value))) throw new Error('Invalid allowed HTTP authority');
   let allowedHosts = new Set(configuredHosts);
   const fieldListeners = new Set<() => void>();
-  const handler = configuredFieldHandler();
-  const fieldAutomation = handler ? await FieldAutomation.open({ handler,
+  const fieldAutomation = await FieldAutomation.open({
     changed: () => { for (const listener of fieldListeners) listener(); },
     log: () => log('field automation check failed; will retry'),
-  }) : undefined;
+  });
   const reject = (res: ServerResponse, status: number) => { res.writeHead(status, { 'Content-Type': 'text/plain' }); res.end(`${status}\n`); };
   const single = (req: IncomingMessage, name: string) => {
     const values = req.rawHeaders.filter((_, i) => i % 2 === 0 && req.rawHeaders[i].toLowerCase() === name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-note",
-  "version": "0.39.4",
+  "version": "0.40.1",
   "description": "Persistent pinote tasks, Markdown handoffs, and task status for Pi",
   "license": "MIT",
   "type": "module",
@@ -32,6 +32,8 @@
     "LOCAL.md",
     "deploy",
     "examples",
+    "watchers",
+    "field-watchers.ts",
     "footer-status.ts",
     "footer-links.ts",
     "footer-config.ts",

package/remote/menu.ts

@@ -2,11 +2,12 @@ import { DynamicBorder, getSelectListTheme, keyText, type ExtensionContext } fro
 import { Input, Key, matchesKey, SelectList, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component, type Container, type TUI } from '@earendil-works/pi-tui';
 import { clean, editorText, type NativeView } from './protocol.ts';
 
-export interface MenuState { search: string; selected?: string; input?: Input }
+export interface MenuState { search: string; selected?: string; input?: Input; pendingSearch?: Promise<void> }
 export interface MenuChoice { id: string }
 export interface MenuOptions {
   search?: 'none' | 'local' | 'tasks';
   searchLabel?: string;
+  tab?: 'settings' | 'tasks';
   onSearch?: (query: string) => Promise<void>;
   notice?: string;
 }
@@ -55,21 +56,28 @@ export function remoteMenu(ctx: ExtensionContext, view: NativeView, state: MenuS
     const fresh = () => !tasks || state.search === String(view.state.search ?? '');
     const schedule = () => {
       clearTimeout(timer);
-      if (fresh() || !options.onSearch || searching || disposed) return;
+      if (fresh() || !options.onSearch || state.pendingSearch || disposed) return;
       timer = setTimeout(() => {
         if (disposed || signal.aborted) return;
         searching = true;
-        void options.onSearch!(state.search).catch(() => { error = 'Search unavailable · Ctrl+R refresh'; }).finally(() => {
+        const query = state.search;
+        const pending = options.onSearch!(query).catch(() => { error = 'Search unavailable · Ctrl+R refresh'; });
+        state.pendingSearch = pending;
+        void pending.then(() => {
+          if (state.pendingSearch === pending) state.pendingSearch = undefined;
           searching = false;
-          if (!disposed) tui.requestRender();
+          if (!disposed) { if (!error && state.search !== query) schedule(); tui.requestRender(); }
         });
       }, 250);
     };
+    // A notification can replace this component before its search action settles.
+    // Share the in-flight read so replacements never queue stale duplicate searches.
+    if (state.pendingSearch) void state.pendingSearch.then(() => { if (!disposed) { schedule(); tui.requestRender(); } });
     schedule();
     const activate = (preview = false) => {
       if (signal.aborted || !usable || !layout || !fresh() || searching || geometry !== `${tui.terminal.columns}:${tui.terminal.rows}:${inlineHeight(tui, tui.terminal.columns, component)}`) return;
       const item = list?.getSelectedItem();
-      if (item) done({ id: preview && tasks ? `__preview:${item.value.slice('select:'.length)}` : item.value });
+      if (item && (!preview || item.value.startsWith('select:'))) done({ id: preview ? `__preview:${item.value.slice('select:'.length)}` : item.value });
     };
     const component: Component & { dispose(): void; focused: boolean; capturesViewportInput: boolean } = {
       capturesViewportInput: true,
@@ -82,7 +90,7 @@ export function remoteMenu(ctx: ExtensionContext, view: NativeView, state: MenuS
         if (!usable) { layout = ''; return [truncateToWidth('Enlarge terminal · Esc back', width)]; }
         const compact = height < 18;
         const border = new DynamicBorder((s) => theme.fg('border', s)).render(width);
-        const hints = wrapTextWithAnsi(`${keyText('tui.select.up')}/${keyText('tui.select.down')} move · ${keyText('tui.select.confirm')} ${tasks ? 'select · F1 preview' : 'open'} · ${keyText('tui.select.cancel')} back · Ctrl+R refresh`, width);
+        const hints = wrapTextWithAnsi(`${keyText('tui.select.up')}/${keyText('tui.select.down')} move · ${keyText('tui.select.confirm')} ${tasks ? 'open · F1 preview task' : 'open'}${options.tab ? ` · ${keyText('tui.input.tab')} ${options.tab}` : ''} · ${keyText('tui.select.cancel')} back · Ctrl+R refresh`, width);
         const summary = (view.body ?? '').split('\n').flatMap((s) => wrapTextWithAnsi(clean(s), width - 2));
         const summaryLimit = compact ? 1 : 3;
         const header = [...border, theme.fg('accent', heading(view.title, width)),
@@ -98,12 +106,14 @@ export function remoteMenu(ctx: ExtensionContext, view: NativeView, state: MenuS
         if (layout !== signature) {
           layout = signature;
           list = new SelectList(filtered, capacity, {
-            ...getSelectListTheme(), noMatch: () => theme.fg('muted', tasks ? state.search ? '  No tasks match this search.' : '  No active tasks. Esc back to create one.' : '  No matching items.'),
+            ...getSelectListTheme(), noMatch: () => theme.fg('muted', tasks ? state.search ? '  No tasks match this search.' : '  No active tasks.' : '  No matching items.'),
           }, { minPrimaryColumnWidth: 12, maxPrimaryColumnWidth: Math.min(40, Math.floor(width * 0.6)) });
-          list.setSelectedIndex(Math.max(0, filtered.findIndex((item) => item.value === state.selected)));
+          const selected = filtered.some((item) => item.value === state.selected) ? state.selected
+            : tasks && state.search.trim() ? filtered.find((item) => item.value.startsWith('select:'))?.value : undefined;
+          list.setSelectedIndex(Math.max(0, filtered.findIndex((item) => item.value === selected)));
           list.onSelectionChange = (item) => { state.selected = item.value; };
           list.onSelect = () => activate(); list.onCancel = cancel;
-          if (list.getSelectedItem()) state.selected = list.getSelectedItem()!.value;
+          if (fresh() && list.getSelectedItem()) state.selected = list.getSelectedItem()!.value;
         }
         const selectedIndex = filtered.findIndex((item) => item.value === list?.getSelectedItem()?.value);
         const selected = filtered[selectedIndex];
@@ -122,7 +132,8 @@ export function remoteMenu(ctx: ExtensionContext, view: NativeView, state: MenuS
       handleInput(data) {
         if (keys.matches(data, 'tui.select.cancel') || matchesKey(data, Key.ctrl('c'))) cancel();
         else if (usable && geometry === `${tui.terminal.columns}:${tui.terminal.rows}:${inlineHeight(tui, tui.terminal.columns, component)}`) {
-          if (matchesKey(data, Key.ctrl('r'))) done({ id: '__refresh' });
+          if (options.tab && keys.matches(data, 'tui.input.tab')) done({ id: `__${options.tab}` });
+          else if (matchesKey(data, Key.ctrl('r'))) done({ id: '__refresh' });
           else if (tasks && matchesKey(data, Key.f1)) activate(true);
           else if (keys.matches(data, 'tui.select.confirm')) activate();
           else if (keys.matches(data, 'tui.select.pageUp') || keys.matches(data, 'tui.select.pageDown')) {