@volter/supercode-teams 0.3.187 → 0.3.188

package/machine.mjs

@@ -84,7 +84,7 @@ import { WorkspaceContexts, fromContext } from '@volter/teams/context';
 import { TeamsClient } from '@volter/teams/http-client';
 import { supercodeHome } from '@volter/teams/home';
 import { readMailHistory, machineName } from './mail-history.mjs';
-import { randomBytes, createHash } from 'node:crypto';
+import { randomBytes, createHash, randomUUID } from 'node:crypto';
 import { WebSocket } from 'ws';
 import { TmuxTerminalHost, classifyAttentionSignal, composerHoldsDraft, composerReadyForInput } from '@volter/supercode-terminal';
 // The ConPTY host is read from the namespace, where a terminal package too old to have it gives undefined rather
@@ -137,6 +137,18 @@ export function claudeUsageLimitWait(screen) {
   return /usage limit to reset/i.test(status) && /rate-limit-options/i.test(status) && !/esc to interrupt/i.test(status);
 }
 
+/** Claude's /btw panel, from its native dialog receipt and live panel footer.
+ * Permission prompts, settings panels and an unknown layout do not qualify. */
+export function claudeSideQuestionPanel(screen, activity) {
+  if (activity?.harness !== 'claude-code' || activity.evidence?.source !== 'claude_registry'
+    || activity.evidence?.waiting_for !== 'dialog open') return false;
+  const rows = String(screen).replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').split('\n').map(line => line.trim()).filter(Boolean);
+  const footer = rows.slice(-3).join('\n');
+  return /^\/btw(?:\s|$)/mu.test(rows.slice(-40).join('\n'))
+    && /\b(?:esc|escape)(?:\s+to)?\s+close\b/iu.test(footer)
+    && composerHoldsDraft('claude-code', screen) === null;
+}
+
 /** The settle floor for a pane whose kind has no composer pattern: the screen
  *  must have stopped changing for this long before the pane counts as ready. */
 const INITIAL_INPUT_SETTLE_MS = 1_000;
@@ -551,6 +563,7 @@ export class TeamsMachine extends MachineCore {
     // Set by a service-run connector: how `machine.restart` ends this daemon so its service manager starts it again.
     this.restartHandler = null;
     this.launches = new Launches(this.p.launches);
+    this.boardOwnersPath = join(this.home, 'board-owners.json');
     // The release this daemon runs, in its machine record (`supercode teams machine status`): its Teams package and its
     // native. A daemon an upgrade did not restart runs the release it started with, whatever is installed, and a
     // client a release behind or ahead of it is refused, so status says which it is (2026-10-06: version skew between
@@ -717,6 +730,7 @@ export class TeamsMachine extends MachineCore {
       this.mailStore = new SqliteMailStore({ mailRoot: join(supercodeHome(this.env), 'mail'), machine: machineName(this.env), committed: this.env.SUPERCODE_MAIL_COMMITTED === '1', startupRecovery: this.env.SUPERCODE_MAIL_STARTUP_RECOVERY === '1', log: (line) => this.emit('records-log', line) });
       this.mailStore.acquire();
       await this.mailStore.start();
+      await this.#restoreBoardOwners();
       this.sessionIndex = new SessionIndexOwner({ database: this.mailStore.database, env: this.env, log: (line) => this.emit('records-log', line) });
       this.indexViews = new SessionIndexViews({ owner: this.sessionIndex,
         enrichLive: (query, rows) => projectLiveDescriptors(query, rows, { owner: this.sessionIndex, live: this.live, mail: this.mail }),
@@ -895,6 +909,30 @@ export class TeamsMachine extends MachineCore {
       const reading = await this.#serveRequest('harness.v1.sessions.activity_under', { pids: [session.rootPid] }, 4_000);
       const native = reading?.activities?.find(row => row.pid === session.rootPid)?.activity;
       if (native?.harness !== expected.harness || native.session_id !== expected.session) return { delivered: false, reason: 'the pane no longer runs the addressed native session; no input submitted' };
+      // A lifecycle wake belongs to the board's owned session, not the /btw
+      // composer. Dismiss only that identified panel; never answer a question,
+      // approve a permission, clear a draft or interrupt the underlying turn.
+      const boardWake = messageIds?.length && messageIds.every(id => {
+        const stored = this.mailStore.findIn(address, id);
+        const envelope = stored ? this.mailStore.body(stored) : null;
+        return envelope?.kind === 'notice' && parseAddress(envelope.from)?.harness === 'board';
+      });
+      if (boardWake && claudeSideQuestionPanel(await this.host.capture(session.id, { lines: 200, preserveEscapes: true }), native)) {
+        const owner = randomUUID();
+        if (await this.host.acquireInput?.(session.id, owner)) {
+          try {
+            await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
+            const latest = await this.#serveRequest('harness.v1.sessions.activity_under', { pids: [session.rootPid] }, 4_000);
+            const current = latest?.activities?.find(row => row.pid === session.rootPid)?.activity;
+            const screen = await this.host.capture(session.id, { lines: 200, preserveEscapes: true });
+            if (!this.stopping && current?.session_id === expected.session && claudeSideQuestionPanel(screen, current)) {
+              await this.host.sendInput(session.id, '\u001b', { submitMode: 'single', inputOwner: owner, deadlineMs: Date.now() + 5_000 });
+              this.log.append({ principal: null, cap: 'control', target: `pane:${pane}`, outcome: 'board-side-question-dismissed', detail: JSON.stringify({ address, message_ids: messageIds }) });
+              await new Promise(resolve => setTimeout(resolve, COMPOSER_RECHECK_MS));
+            }
+          } finally { await this.host.releaseInput?.(session.id, owner); }
+        }
+      }
       const result = await this.#paneTurn(session, pane, text, { messageIds, harness });
       if (result.refused) throw new Error(result.refused.reason);
       return result.waits ?? result;
@@ -1028,6 +1066,15 @@ export class TeamsMachine extends MachineCore {
           try { activities = (await this.#serveRequest('harness.v1.sessions.activity_under', { pids: live.map((pane) => pane.pid) }, 30_000))?.activities ?? []; }
           catch (error) { sessions_unread = String(error?.message ?? error).slice(0, 200); }
         }
+        const launches = new Map(this.launches.all().map(launch => [launch.pane, launch]));
+        for (const pane of live) {
+          const launch = launches.get(pane.pane), activity = activities.find(row => row.pid === pane.pid)?.activity;
+          // The daemon resolved the starter at launch; the native receipt and
+          // current process must name the same child. A pane title or argv is
+          // never a delegation receipt.
+          if (launch?.status === 'ready' && launch.native_session && launch.native_session === activity?.session_id && launch.kind === activity.harness)
+            pane.starter_session = launch.by ?? null;
+        }
         this.live?.panes(live.map((pane) => ({ pane: pane.pane, pid: pane.pid,
           activity: sessions_unread ? null : activities.find(row => row.pid === pane.pid)?.activity ?? null })), { current: sessions_unread == null });
         // the sessions under the panes unread: the panes are read again on the section's backoff until they are (MR4)
@@ -2075,7 +2122,7 @@ export class TeamsMachine extends MachineCore {
   /** The home and board a board name (an address's last part) names among the homes registered with this daemon, by the
    * one rule the board names itself with (@volter/teams/board-name). */
   #boardKept(name) {
-    for (const root of Object.keys(this.boardEvents?.state?.boards ?? {})) {
+    for (const root of new Set([...Object.keys(this.boardEvents?.state?.boards ?? {}), ...(this.boardOwners?.keys() ?? [])])) {
       if (boardName(boardLabel(root, 'default')) === name) return { root, board: 'default' };
       let named = [];
       try { named = readdirSync(join(root, 'kanban', 'boards')); } catch { /* no named boards */ }
@@ -2577,6 +2624,23 @@ export class TeamsMachine extends MachineCore {
     return Number((await run('ps', ['-o', 'ppid=', '-p', String(holder)])).trim()) === pid;
   }
 
+  /** A restart retains the homes a verified owner registered. A saved PID is
+   * only a candidate: the kernel must still show it holding that home's lock.
+   * Caller admission separately proves the live connection's process. */
+  async #restoreBoardOwners() {
+    this.boardOwners = new Map();
+    const saved = readJson(this.boardOwnersPath, { owners: {} });
+    for (const [root, pid] of Object.entries(saved?.owners ?? {})) {
+      if (isAbsolute(root) && Number.isSafeInteger(pid) && pid > 1 && await this.#holdsBoardLock(root, pid))
+        this.boardOwners.set(root, pid);
+    }
+    this.#saveBoardOwners();
+  }
+
+  #saveBoardOwners() {
+    writeJson(this.boardOwnersPath, { version: 1, owners: Object.fromEntries(this.boardOwners ?? []) });
+  }
+
   /** A filing's sender as this machine knows it, with no process and no request (mailbox.rs `sender_identity`'s rule): this filing door is local, so a sender from this machine's address is a session here
    * (`local`, the same user, D186), and one claiming another machine's address is unresolved: another machine's mail
    * reaches this one only through its link, so a return address is never an identity. */
@@ -2590,7 +2654,7 @@ export class TeamsMachine extends MachineCore {
   async #runFiling(request) {
     if (!this.mailSend) return { code: 1, text: 'this machine\'s daemon has not started its mail yet' };
     return this.mailSend.file({ address: request.from, name: request.from_name ?? '' }, request.to, request.body ?? '', {
-      subject: request.subject ?? null, key: request.id ?? null, wake: request.wake !== false,
+      subject: request.subject ?? null, key: request.id ?? null, wake: request.wake !== false, notice: request.notice === true,
       sender_identity: request.sender_identity && typeof request.sender_identity === 'object' ? request.sender_identity : null, typed: request.typed === true,
     });
   }
@@ -4501,7 +4565,7 @@ export class TeamsMachine extends MachineCore {
         for (const key of ['from', 'to', 'body']) if (typeof params[key] !== 'string' || !params[key]) throw Object.assign(new Error(`a filing names its ${key}`), { code: 400 });
         const sender_identity = await this.#observeSender(params.from, params.from_name ?? null, typeof params.context === 'string' && params.context ? params.context : null);
         const answer = await this.#runFiling({ from: params.from, from_name: params.from_name ?? '', to: params.to, body: params.body, id: params.id ?? null,
-          wake: params.wake !== false, subject: params.subject ?? null, sender_identity });
+          wake: params.wake !== false, subject: params.subject ?? null, notice: params.notice === true, sender_identity });
         act('mail.file', params.to, answer?.code === 0 ? 'ok' : 'failed');
         return answer;
       }
@@ -4814,21 +4878,26 @@ export class TeamsMachine extends MachineCore {
       case 'harness.v1.boards.register': case 'harness.v1.boards.list': case 'harness.v1.boards.unregister': {
         // A board home this machine keeps, published to its team by its connector (board-events.mjs).
         if (!operator) throw Object.assign(new Error('operators only'), { code: 403 });
-        if (!this.boardEvents) throw Object.assign(new Error('this daemon serves no team: a board is published by a connected machine (`supercode teams connect`)'), { code: 409 });
-        if (method === 'harness.v1.boards.list') return this.boardEvents.list();
+        if (method === 'harness.v1.boards.list') return this.boardEvents?.list() ?? [];
         if (method === 'harness.v1.boards.unregister') {
           if (typeof params.root !== 'string' || !params.root) throw Object.assign(new Error('name the board home (root)'), { code: 400 });
-          return this.boardEvents.unregister(params.root);
+          this.boardOwners?.delete(resolve(params.root));
+          try { this.boardOwners?.delete(realpathSync(params.root)); } catch { /* already removed */ }
+          this.#saveBoardOwners();
+          return this.boardEvents?.unregister(params.root) ?? { root: resolve(params.root), published: false };
         }
         if (typeof params.root !== 'string' || !params.root) throw Object.assign(new Error('name the board home (root)'), { code: 400 });
-        const registered = this.boardEvents.register(params.root);
+        const registered = this.boardEvents?.register(params.root) ?? { root: resolve(params.root), published: false };
         // The home's board owner acts as its boards: the caller it names for a board of that home is taken from it
         // (#callerOf). The owner is the process holding the home's board lock (board.lock, through its lock holder), as
         // the kernel says: the registering client names its pid (its claim), and only a pid that holds the lock is
         // taken. A registration from any other process publishes the home and grants nothing, and never replaces the
         // owner's.
         const pid = entry.principal === 'local' && !entry.appDoor ? Number(params.claim?.pid) : NaN;
-        if (Number.isInteger(pid) && await this.#holdsBoardLock(registered.root, pid)) (this.boardOwners ??= new Map()).set(registered.root, pid);
+        if (Number.isInteger(pid) && (!entry.socket || await peerIs(entry.socket, pid)) && await this.#holdsBoardLock(registered.root, pid)) {
+          (this.boardOwners ??= new Map()).set(registered.root, pid);
+          this.#saveBoardOwners();
+        }
         act('boards.register', registered.root);
         return registered;
       }

package/mail/send.mjs

@@ -732,13 +732,13 @@ export class MailSend {
    * `sender_identity` is the filer's observation (this daemon's), never the request's own. Answers `{ code, message_id,
    * new, to }`, or `{ code, text }`.
    */
-  file(from, to, body, { subject = null, key = null, wake = true, sender_identity = null, typed = false } = {}) {
+  file(from, to, body, { subject = null, key = null, wake = true, sender_identity = null, typed = false, notice = false } = {}) {
     const sender = parseAddress(from.address), receiver = parseAddress(to);
     if (!sender) return { code: EXIT_REFUSED, text: `\`${from.address}\` is not a session address; addresses look like sc:<machine>:<harness>:<session-id>` };
     if (!receiver) return { code: EXIT_REFUSED, text: `\`${to}\` is not a session address; addresses look like sc:<machine>:<harness>:<session-id>` };
     let id = messageIdFor(sender.address, key);
     if (typed) id = `i-${id.replace(/^m-/, '')}`;
-    const filed = makeEnvelope({ id, from: sender.address, from_name: from.name ?? '', sender_identity, kind: typed ? 'user' : 'peer', reply_via: { mode: typed ? 'none' : 'command' }, subject: subjectLine(subject), body });
+    const filed = makeEnvelope({ id, from: sender.address, from_name: from.name ?? '', sender_identity, kind: typed ? 'user' : notice ? 'notice' : 'peer', reply_via: { mode: typed || notice ? 'none' : 'command' }, subject: subjectLine(subject), body });
     try {
       if (this.store.findIn(receiver.address, id)) return { code: 0, message_id: id, new: false, to: receiver.address };
       // a typed line's record is read already: it reached the session as its composer turn, never as mail

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.187",
+  "version": "0.3.188",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",

package/session-index-owner.mjs

@@ -273,7 +273,8 @@ export class SessionIndexOwner extends EventEmitter {
     // Lifecycle parents cover replacement of the selected root, not every
     // sibling below that parent. Only selected physical directory bindings
     // extend file-source admission beyond its logical aliases.
-    const parents = new Set([dirname(source.root), ...[...source.aliases].map(dirname)]);
+    const parents = new Set([dirname(source.root), ...[...source.aliases].map(dirname),
+      ...(source.registryPath ? [dirname(source.registryPath)] : [])]);
     const selectedTargets = source.kind === 'stores' ? targets : targets.filter((target) => !parents.has(target));
     if (path != null && !pathUnder(source.root, path) && !pathUnder(path, source.root)
       && ![...selectedTargets, ...source.aliases].some((target) => pathUnder(path, target) || pathUnder(target, path))
@@ -349,6 +350,12 @@ export class SessionIndexOwner extends EventEmitter {
     });
     if (this.closed) return;
     for (const part of source.parts.values()) if (part.kind === 'file' && (folder === source.root || pathUnder(folder, part.path)) && !listing.parts.has(part.path)) this.#remove(source, part.path);
+    // A previous watcher may have admitted a sibling of an aliased registry.
+    // Only a completed full listing proves which transcript paths belong here;
+    // malformed files still selected retain their failure and retry evidence.
+    if (folder === source.root) for (const failure of this.store.failures([source.id])) {
+      if (failure.kind === 'file' && !listing.parts.has(failure.path)) this.store.clearFailure(source.id, failure.path, failure.kind);
+    }
     for (const path of listing.parts) { if (this.closed) return; await this.#file(source, path); }
     if (this.closed) return;
     this.store.clearFailure(source.id, folder, 'folder');