@volter/supercode-teams 0.3.183 → 0.3.185

package/README.md

@@ -225,7 +225,10 @@ required for archived Codex metadata.
 
 Sources are keyed by harness, physical root and profile/registry selection.
 Watches precede listings, include root parents and absent-root ancestors, and
-share physical directories. Hourly reconciliation repairs missed events.
+share physical coverage. On macOS/Windows recursive streams cover session trees
+and symlink-target parents; Linux retains directory watches over inotify.
+Hourly reconciliation repairs missed events. [The scale decision](../../docs/adr/0022-session-tree-watches.md)
+names the native-watch failure paths and measured platform scope.
 Metadata changes and verified file offsets commit together with cursor-addressed
 row changes; unchanged warm files contribute no transcript reads. A refused
 source retains its prior rows and reports the path, error and retry deadline.

package/app-door.mjs

@@ -214,12 +214,32 @@ export function serveAppDoor({ home, open, log = () => {} }) {
     start();
   };
 
-  let watcher = null;
-  try { watcher = watch(home, (_, name) => { if (name === 'app-door.json') reload(); }); } catch { /* a home that cannot be watched is read at start */ }
+  let watcher = null, watchRetry = null, closed = false;
+  const watchLost = (error) => {
+    if (closed) return;
+    watcher?.close(); watcher = null;
+    log({ outcome: 'failed', origin: null, detail: `app door settings watch: ${error.message}` });
+    clearTimeout(watchRetry);
+    watchRetry = setTimeout(watchSettings, LISTEN_RETRY_MS);
+    watchRetry.unref?.();
+  };
+  const watchSettings = () => {
+    if (closed) return;
+    watchRetry = null;
+    // Re-read even when watch installation fails, so revocation and turning
+    // the door off still take effect while native watching is unavailable.
+    reload();
+    try {
+      watcher = watch(home, (_, name) => { if (name == null || name === 'app-door.json') reload(); });
+      watcher.on('error', watchLost);
+      reload(); // cover a settings write between the first read and watch
+    } catch (error) { watchLost(error); }
+  };
+  watchSettings();
   start();
   if (!setting.enabled) report();
   return {
     state: () => ({ enabled: setting.enabled, port: setting.port, origins: setting.origins, listening, failure }),
-    close() { watcher?.close(); stop(); wss.close(); },
+    close() { closed = true; clearTimeout(watchRetry); watcher?.close(); stop(); wss.close(); },
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.183",
+  "version": "0.3.185",
   "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

@@ -270,8 +270,13 @@ export class SessionIndexOwner extends EventEmitter {
     if (!source) return;
     const path = name == null ? null : join(directory, name);
     if (path?.endsWith('-shm')) return;
+    // 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 selectedTargets = source.kind === 'stores' ? targets : targets.filter((target) => !parents.has(target));
     if (path != null && !pathUnder(source.root, path) && !pathUnder(path, source.root)
-      && !(source.kind === 'stores' ? targets : [...source.aliases]).some((target) => pathUnder(path, target) || pathUnder(target, path))
+      && ![...selectedTargets, ...source.aliases].some((target) => pathUnder(path, target) || pathUnder(target, path))
       && !(source.registryPath && (pathUnder(source.registryPath, path) || pathUnder(path, source.registryPath)))
       && ![source.namesPath, source.historyPath].includes(path)) return;
     if (path == null || pathUnder(path, source.root) || path === source.registryPath
@@ -306,8 +311,10 @@ export class SessionIndexOwner extends EventEmitter {
     finally { this.running = null; if (!this.closed && this.pending.size) this.#schedule(this.pending.keys().next().value, null); }
   }
 
-  async #watch(source, path) {
-    const directory = await this.watches.want(source.id, path);
+  async #watch(source, path, tree = false) {
+    const directory = await this.watches.want(source.id, path, {
+      tree, physicalParent: tree && !pathUnder(source.root, path),
+    });
     source.wanted.add(path);
     if (!this.closed) {
       this.store.clearFailure(source.id, path, 'watch');
@@ -320,7 +327,7 @@ export class SessionIndexOwner extends EventEmitter {
     this.metrics.reconciliations = (this.metrics.reconciliations ?? 0) + 1;
     for (const root of new Set([source.root, ...source.aliases])) {
       await this.#watch(source, dirname(root));
-      await this.#watch(source, root);
+      await this.#watch(source, root, source.kind === 'files');
     }
     for (const failure of this.store.failures([source.id])) if (failure.kind === 'registry-selection') {
       try {
@@ -338,14 +345,14 @@ export class SessionIndexOwner extends EventEmitter {
     }
     if (source.harness === 'codex') await this.#codexLedgers(source);
     const listing = await listSessionParts(source.harness, source.root, {
-      folder, metrics: this.metrics, beforeDirectory: (path) => this.#watch(source, path),
+      folder, metrics: this.metrics, beforeDirectory: (path) => this.#watch(source, path, true),
     });
     if (this.closed) return;
-    for (const part of source.parts.values()) if (part.kind === 'file' && pathUnder(folder, part.path) && !listing.parts.has(part.path)) this.#remove(source, part.path);
+    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);
     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');
-    for (const directory of source.directories) if (pathUnder(folder, directory)) source.directories.delete(directory);
+    for (const directory of source.directories) if (folder === source.root || pathUnder(folder, directory)) source.directories.delete(directory);
     for (const directory of listing.directories) source.directories.add(directory);
     const wanted = new Set([...source.aliases, ...[...source.aliases].map(dirname), source.root, dirname(source.root), ...source.directories,
       ...(source.registryPath ? [source.registryPath, dirname(source.registryPath)] : []),
@@ -539,7 +546,12 @@ export class SessionIndexOwner extends EventEmitter {
     const part = await sessionPartFor(source.harness, source.root, path);
     if (part != null) return this.#file(source, part);
     if (path === source.root || !pathUnder(source.root, path)) return this.#reconcile(source);
-    if ((await sourceStat(path))?.isDirectory() || source.directories.has(path)) return this.#reconcile(source, path);
+    // Directory topology belongs to the whole selection: canonical transcript
+    // paths can sit outside a logical symlink's subtree. A removed alias no
+    // longer has stat metadata and is absent from the physical directory set,
+    // but must still retire those rows and their watch bindings.
+    const info = await sourceStat(path);
+    if (!info || info.isDirectory() || source.directories.has(path)) return this.#reconcile(source);
   }
 
   #retryTimer() {

package/session-index-watches.mjs

@@ -1,8 +1,11 @@
 import { watch } from 'node:fs';
-import { dirname } from 'node:path';
-import { normalizedSourcePath, sourceStat } from '@volter/supercode-interchange';
+import { basename, dirname, resolve } from 'node:path';
+import { normalizedSourcePath, pathUnder, sourceStat } from '@volter/supercode-interchange';
 
-/** One directory watch per physical directory, shared by all selected homes.
+const NATIVE_RECURSIVE = ['darwin', 'win32'].includes(process.platform);
+
+/** Native recursive trees on macOS/Windows, shared by physical coverage.
+ * Linux retains directory watches over its shared inotify descriptor.
  * Missing paths keep an ancestor watch. Reconciliation installs closer
  * watches before listing newly created directories. */
 export class SessionIndexWatches {
@@ -11,7 +14,7 @@ export class SessionIndexWatches {
     this.directories = new Map(); this.closed = false;
   }
 
-  async want(source, path) {
+  async want(source, path, { tree = false, physicalParent = false } = {}) {
     if (this.closed) return;
     let at = path;
     for (;;) {
@@ -21,27 +24,42 @@ export class SessionIndexWatches {
       if (parent === at) throw new Error(`no existing directory can watch ${path}`);
       at = parent;
     }
-    const directory = await normalizedSourcePath(at);
+    const target = await normalizedSourcePath(at);
+    let recursive = NATIVE_RECURSIVE && tree && at === path;
+    let directory = recursive && physicalParent ? dirname(target) : target;
+    // Descendants (including a symlink's physical tree) share an existing
+    // native stream. Shallow lifecycle/registry watches need no new stream
+    // when a selected tree already covers them.
+    for (const [root, value] of this.directories) if (value.recursive && pathUnder(root, target)) {
+      directory = root; recursive = true; break;
+    }
     const info = await sourceStat(directory);
     if (this.closed) return;
     if (!info?.isDirectory()) throw new Error(`directory changed while binding a watch for ${path}`);
     let held = this.directories.get(directory);
-    const renew = !held || held.dev !== info.dev || held.ino !== info.ino;
+    const renew = !held || held.dev !== info.dev || held.ino !== info.ino || recursive && !held.recursive;
     if (renew) {
       // A pathname can now name another filesystem object. Preserve every
       // source binding while replacing the watch attached to the old object.
       const old = held;
-      const value = { sources: old?.sources ?? new Map(), watcher: null, dev: info.dev, ino: info.ino };
+      const value = { sources: old?.sources ?? new Map(), watcher: null, dev: info.dev, ino: info.ino, recursive: recursive || old?.recursive || false };
       // Register before returning to the caller's first listing. A nameless
       // event and a watcher error both request a reconciliation, never removals.
-      value.watcher = watch(directory, { persistent: false, encoding: 'buffer' }, (event, filename) => {
+      value.watcher = watch(directory, { persistent: false, encoding: 'buffer', recursive: value.recursive }, (event, filename) => {
         if (this.closed || this.directories.get(directory) !== value) return;
         let name = null;
         if (filename != null) {
           try { name = new TextDecoder('utf-8', { fatal: true }).decode(filename); }
           catch { /* an undecodable path requires a whole directory read */ }
         }
-        for (const [id, targets] of value.sources) this.changed(id, { directory, name, event, targets: [...targets] });
+        const changed = name == null ? null : resolve(directory, name);
+        // Recursive filenames name a path below the tree. Keep the owner's
+        // directory/basename contract, and reconcile an undecodable event.
+        const known = changed != null && pathUnder(directory, changed);
+        for (const [id, targets] of value.sources) this.changed(id, {
+          directory: known ? dirname(changed) : directory,
+          name: known ? basename(changed) : null, event, targets: [...targets],
+        });
       });
       value.watcher.on('error', (error) => {
         this.#refuse(directory, value, error);
@@ -74,7 +92,7 @@ export class SessionIndexWatches {
     // Parent first closes the replacement/creation gap around root's stat.
     const parent = dirname(root);
     if (parent !== root) await this.want(source, parent);
-    await this.want(source, root);
+    await this.want(source, root, { tree: true });
   }
 
   /** Successful reconciliation supplies the complete wanted directory set.

package/terminal-mail.mjs

@@ -264,6 +264,23 @@ export class TerminalMailbox {
       batch.error = 'codex-update-prompt: delivery retained; restart Codex with check_for_update_on_startup=false';
       this.save(); this.log({ delivered: false, queued: true, reason: batch.error, message_ids: batch.message_ids }); return;
     }
+    if (batch.kind === 'codex' && batch.phase === 'pasted' && batch.enters >= 3 && Date.now() - batch.last_enter >= 5000) {
+      // Every Enter is spent and the transcript, read above from the paste's own offset, holds no such message. A
+      // composer that reads empty with no turn running holds neither the paste nor a turn that could still take it
+      // (Codex writes a message entered during a turn when that turn takes it or ends): this paste will never be
+      // confirmed, and left active it holds every later message behind it for good. It is refused, never pasted
+      // again, and the queue moves on. Read twice, then the transcript once more; a draft, a running turn or an
+      // unreadable screen leaves the batch waiting on its transcript.
+      let lost = true;
+      for (let check = 0; lost && check < 2; check++) {
+        const screen = await this.host.capture(this.session.id, { lines: 200, preserveEscapes: true });
+        lost = composerText(batch.kind, screen) === '' && !/\besc to (?:interrupt|cancel)\b/iu.test(screen);
+        if (lost && check === 0) await pause(200);
+      }
+      if (lost && !confirmed(batch)) {
+        await this.recordRefusal(batch, 'native transcript unconfirmed after Enter retries; composer empty'); return;
+      }
+    }
     if (batch.kind === 'claude-code' && batch.phase === 'prepared' && batch.expiresAt && Date.now() >= batch.expiresAt) {
       await this.recordRefusal(batch, 'delivery deadline elapsed; no input pasted'); return;
     }