@maolon/pi-watcher 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -6,6 +6,11 @@ All notable changes to this project are documented here. The format follows
 
 ## [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

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/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.js

@@ -130,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();
     }
@@ -553,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;
@@ -597,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.3",
+  "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",