@maolon/pi-watcher 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project uses
 [Semantic Versioning](https://semver.org/). Before 1.0, minor versions may break.
 
+## [Unreleased]
+
+## [0.1.4] - 2026-10-08
+
+### Added
+- `/watcher cancel [reason]` closes every active or paused watch of the current session, no watchId needed. Each close withdraws pending attentions and supersedes open episodes like a per-watch `close`; other sessions are untouched.
+
+## [0.1.3] - 2026-10-08
+
+### Changed
+- Attention toasts follow the outcome: a succeeded `task.terminal` notice shows at `info`; failures, cancellations, unknown exits, deadlines, semantic candidates and failed relay wakes stay at `warning`.
+- Git flow: `dev` integration branch, release and hotfix PRs into `main` publish to npm.
+
 ## [0.1.2] - 2026-10-08
 
 ### Changed

package/README.md

@@ -146,7 +146,8 @@ degraded; they never mark the task as failed. The command text is stored as evid
 | `register` | Full spec: `run`, `group` (up to 16 members) and `obligation` targets |
 
 `/watcher` shows the panel; `/watcher ack <episodeId> <received|investigating|defer|resolved|dismiss> [until]`
-handles an episode locally; `/watcher jev` manages the optional semantic review (see below).
+handles an episode locally; `/watcher cancel [reason]` closes every active or paused watch of the current session
+(no watchId needed); `/watcher jev` manages the optional semantic review (see below).
 
 ### Exit markers for `exec_command`
 

package/dist/engine/engine.d.ts

@@ -42,6 +42,8 @@ export interface AttentionNotice {
     relayError?: string;
     /** Deadline until which the envelope is still valid (ms epoch) */
     validUntil: number;
+    /** Observed task state for terminal-fact notices (display layer picks the toast level from it) */
+    taskState?: string;
 }
 /** Accepted-judgment-complete notification (display-layer notice; judge review must be visible) */
 export interface JudgmentNotice {

package/dist/engine/engine.js

@@ -236,7 +236,7 @@ export class WatchEngine {
             }, now);
             if (episodeId) {
                 produced.episodes.push(episodeId);
-                await this.publishEpisodeAttention(watchId, row, episodeId, kind, `${snapshot.taskState}${snapshot.exitCode !== undefined && snapshot.exitCode !== null ? ` exitCode=${snapshot.exitCode}` : ''}: ${snapshot.summary ?? 'no summary'}`, now);
+                await this.publishEpisodeAttention(watchId, row, episodeId, kind, `${snapshot.taskState}${snapshot.exitCode !== undefined && snapshot.exitCode !== null ? ` exitCode=${snapshot.exitCode}` : ''}: ${snapshot.summary ?? 'no summary'}`, now, undefined, snapshot.taskState);
             }
             const resultId = `result-${watchId}-${row.generation}-${snapshot.lastSourceSeq ?? 0}`;
             const card = buildResultCard({
@@ -720,7 +720,7 @@ export class WatchEngine {
         return { inspectionId, watchId, ingested: 0, produced, health: missing.length > 0 ? 'degraded' : 'healthy', lifecycleAfter: 'active' };
     }
     /** Unified attention publishing for hard facts / semantic candidates: truth lands in the outbox first, then publishes via relay managed delivery (I6). */
-    async publishEpisodeAttention(watchId, row, episodeId, reasonCode, summary, now, probability) {
+    async publishEpisodeAttention(watchId, row, episodeId, reasonCode, summary, now, probability, taskState) {
         const envelopeId = newId('att');
         const envelope = {
             schemaVersion: 1,
@@ -785,7 +785,8 @@ export class WatchEngine {
                 summary,
                 transport,
                 relayError,
-                validUntil: validUntilMs
+                validUntil: validUntilMs,
+                taskState
             });
         }
         catch { /* display-layer failure does not affect the engine */ }

package/dist/engine/service.d.ts

@@ -42,6 +42,13 @@ export declare class WatchService {
         inspectionId: Id;
     }>;
     control(requestId: Id, watchId: Id, expectedControlRevision: number, action: 'pause' | 'close' | 'resume', reason: string, actor: ActorContext): Promise<Json>;
+    /**
+     * Local owner cancel (for the /watcher command only): close every active or paused watch of this owner
+     * session. Each close goes through control() with the watch's current controlRevision, so the scope
+     * advance, attention withdraw and episode supersede are identical to a per-watch close. A close that
+     * fails is reported per watch, never folded into success.
+     */
+    closeAllForOwner(reason: string, actor: ActorContext): Promise<Json>;
     /**
      * Layered withdrawal report (design 6.5): sourceFence for the scope advance and one entry
      * per affected route. "withdrawn" is claimed only when every route reports prevented

package/dist/engine/service.js

@@ -280,6 +280,35 @@ export class WatchService {
         }
         return { ...result, ...this.relayCutReport(result) };
     }
+    /**
+     * Local owner cancel (for the /watcher command only): close every active or paused watch of this owner
+     * session. Each close goes through control() with the watch's current controlRevision, so the scope
+     * advance, attention withdraw and episode supersede are identical to a per-watch close. A close that
+     * fails is reported per watch, never folded into success.
+     */
+    async closeAllForOwner(reason, actor) {
+        const rows = [];
+        let cursor;
+        for (;;) {
+            const page = this.store.transaction(tx => tx.listWatches(actor.owner.sessionId, cursor, 200, ['active', 'paused']));
+            rows.push(...page);
+            if (page.length < 200)
+                break;
+            cursor = page[page.length - 1].watchId;
+        }
+        const closed = [];
+        const failed = [];
+        for (const row of rows) {
+            try {
+                const r = await this.control(newId('cancel'), row.watchId, row.controlRevision, 'close', reason, actor);
+                closed.push({ watchId: row.watchId, previousLifecycle: row.lifecycle, withdrawn: Array.isArray(r.withdrawEventIds) ? r.withdrawEventIds.length : 0 });
+            }
+            catch (e) {
+                failed.push({ watchId: row.watchId, code: e.code ?? 'ERROR', message: e instanceof Error ? e.message : String(e) });
+            }
+        }
+        return { closed, failed, reason };
+    }
     /**
      * Layered withdrawal report (design 6.5): sourceFence for the scope advance and one entry
      * per affected route. "withdrawn" is claimed only when every route reports prevented

package/dist/pi-extension.d.ts

@@ -15,6 +15,7 @@
  *   source/profile/owner capability are injected from the trusted context; the model cannot specify sessionId
  * - ack requires relay delivery (deliveryRef); when relay is not negotiated it returns NO_DELIVERY and never fabricates a receipt
  */
+import { type AttentionNotice } from './engine/engine.js';
 import { type PiClassifierRegistry } from './jev/pi-registry.js';
 /** Minimal structural types: avoid a hard dependency on the pi runtime (the loader is Pi itself). */
 export interface PiToolCallContext {
@@ -120,4 +121,15 @@ export interface RelayBindResult {
         message?: string;
     };
 }
+/**
+ * Session backend: local runtime, no IPC (per-session root, decision 2026-09-21).
+ * This session is the only process on its own root, so the single-writer invariant holds naturally; no primary/attached,
+ * no failover; version skew (an old primary serving an old action surface) is structurally impossible.
+ */
+/**
+ * Toast level for an attention notice. A clean success is informational; anything that needs a
+ * closer look (failure, cancellation, unknown exit, deadline, semantic candidate) or a broken
+ * relay wake leg stays a warning.
+ */
+export declare function attentionNotifyLevel(notice: Pick<AttentionNotice, 'reasonCode' | 'transport' | 'taskState'>): 'info' | 'warning';
 export default function watcherExtension(pi: PiExtensionAPI, options?: WatcherExtensionOptions): void;

package/dist/pi-extension.js

@@ -78,6 +78,16 @@ const sessionDirOf = (sid) => sid.replace(/[^A-Za-z0-9._-]+/g, '_').slice(0, 64)
  * This session is the only process on its own root, so the single-writer invariant holds naturally; no primary/attached,
  * no failover; version skew (an old primary serving an old action surface) is structurally impossible.
  */
+/**
+ * Toast level for an attention notice. A clean success is informational; anything that needs a
+ * closer look (failure, cancellation, unknown exit, deadline, semantic candidate) or a broken
+ * relay wake leg stays a warning.
+ */
+export function attentionNotifyLevel(notice) {
+    if (notice.transport === 'relay-failed')
+        return 'warning';
+    return notice.reasonCode === 'task.terminal' && notice.taskState === 'succeeded' ? 'info' : 'warning';
+}
 class SessionBackend {
     rt;
     refreshWidget;
@@ -100,7 +110,7 @@ class SessionBackend {
         const text = `pi-watcher attention [${notice.reasonCode}] watch ${notice.watchId}: ${notice.summary}` + tail;
         if (!notice.ownerSession || notice.ownerSession === this.sessionId) {
             try {
-                this.notifyUser(text);
+                this.notifyUser(text, attentionNotifyLevel(notice));
             }
             catch { /* display failure does not block */ }
         }
@@ -120,6 +130,9 @@ class SessionBackend {
     async localAck(req, actor) {
         return JSON.stringify(await toServiceResultAsync(req.requestId, () => this.rt.service.ackEpisode(req.requestId, req.episodeId, req.action, req.note, req.until, actor)));
     }
+    async localCancelAll(reason, actor) {
+        return JSON.stringify(await toServiceResultAsync(undefined, () => this.rt.service.closeAllForOwner(reason, actor)));
+    }
     requestWidgetRefresh() {
         this.refreshWidget();
     }
@@ -226,7 +239,7 @@ export default function watcherExtension(pi, options = {}) {
                     catch { /* display failure does not block the engine */ }
                 }
             });
-            const be = new SessionBackend(rt, refreshWidget, text => { ctx.ui?.notify?.(text, 'warning'); }, primarySid);
+            const be = new SessionBackend(rt, refreshWidget, (text, level) => { ctx.ui?.notify?.(text, level); }, primarySid);
             attentionSink = n => be.handleAttention(n);
             if (sessionClosed) {
                 be.close();
@@ -543,7 +556,7 @@ export default function watcherExtension(pi, options = {}) {
         ].join('\n');
     };
     pi.registerCommand('watcher', {
-        description: 'pi-watcher panel: watches, health, open issues, and why no attention was sent. /watcher ack <episodeId> <received|investigating|defer|resolved|dismiss> [until ISO] — local owner response. /watcher jev [status] | /watcher jev consent <on|off> — optional Jev semantic review',
+        description: 'pi-watcher panel: watches, health, open issues, and why no attention was sent. /watcher ack <episodeId> <received|investigating|defer|resolved|dismiss> [until ISO] — local owner response. /watcher cancel [reason...] — close every active/paused watch of this session. /watcher jev [status] | /watcher jev consent <on|off> — optional Jev semantic review',
         handler: async (args, ctx) => {
             await ensureBackend(ctx);
             const be = backend;
@@ -587,6 +600,24 @@ export default function watcherExtension(pi, options = {}) {
                 ctx.ui?.notify?.(result, parsed.ok === false ? 'error' : 'info');
                 return;
             }
+            if (argv[0] === 'cancel') {
+                // Local owner cancel (non-model path): close every active/paused watch of this session, no watchId needed
+                const reason = argv.slice(1).join(' ') || 'local owner cancel';
+                const result = await be.localCancelAll(reason, actorOf(ctx));
+                be.requestWidgetRefresh();
+                const parsed = JSON.parse(result);
+                if (parsed.ok === false) {
+                    ctx.ui?.notify?.(result, 'error');
+                    return;
+                }
+                const closed = parsed.value?.closed?.length ?? 0;
+                const failed = parsed.value?.failed?.length ?? 0;
+                const head = closed === 0 && failed === 0
+                    ? 'pi-watcher: no active or paused watch in this session'
+                    : `pi-watcher: closed ${closed} watch(es) in this session` + (failed > 0 ? `, ${failed} failed` : '');
+                ctx.ui?.notify?.(failed > 0 ? `${head}\n${result}` : head, failed > 0 ? 'warning' : 'info');
+                return;
+            }
             const panel = await be.panel(actorOf(ctx));
             const text = JSON.stringify(panel, null, 2);
             ctx.ui?.notify?.(text.length > 4000 ? `${text.slice(0, 4000)}…` : text, 'info');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maolon/pi-watcher",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Watch long-running Pi tasks without babysitting: deterministic task monitoring, optional semantic review, and relay-delivered wakes only when something needs the host.",
   "keywords": [
     "pi-package",