@volter/supercode-teams 0.3.124 → 0.3.126

package/bin/teams.mjs

@@ -31,6 +31,7 @@
 // CLI in ./workspace.mjs.
 import { appendFileSync, createWriteStream, readFileSync, writeFileSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { SupercodeHarnessClient } from '@volter/supercode-harness-sdk';
 import { noteStep, rotatedLogs, slowLogPath, timeCommand } from '@volter/supercode-harness-sdk/slow-log';
@@ -54,7 +55,7 @@ import { APP_DOOR_PATH, appDoorFile, appDoorLink, normalOrigin, readAppDoor, rea
 
 const MACHINE_VERBS = new Set(['machine', 'slow', 'describe', 'records', 'panes', 'input', 'suspend', 'resume', 'files', 'ports', 'port', 'browser', 'stream', 'jobs', 'workspace', 'title', 'attention', 'watch', 'rpc', 'launches', 'log', 'mail', 'board', 'health', 'app-door']);
 // Every flag a machine verb reads; any other is refused rather than silently ignored.
-const KNOWN_FLAGS = new Set(['home', 'since', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path', 'repo', 'branch', 'solo', 'card', 'create', 'presence-only', 'processes', 'panes', 'clear-draft', 'message-ids', 'harness', 'observe', 'attach-context', 'json', 'all', 'origin', 'port', 'remove-origin', 'open']);
+const KNOWN_FLAGS = new Set(['home', 'since', 'machine', 'context', 'floor', 'supercode', 'tmux-socket', 'verbose', 'lines', 'input', 'name', 'for', 'urgency', 'reason', 'interrupt', 'query', 'out', 'in', 'interval', 'no-enter', 'when-composer-empty', 'key', 'listen', 'list', 'from', 'to', 'path', 'to-path', 'repo', 'branch', 'solo', 'card', 'create', 'presence-only', 'processes', 'panes', 'clear-draft', 'message-ids', 'harness', 'observe', 'attach-context', 'json', 'all', 'origin', 'port', 'remove-origin', 'open', 'foreign']);
 
 const argv = process.argv.slice(2);
 const flags = {};
@@ -195,7 +196,15 @@ async function main() {
       }
       // `machine restart [--machine M] [--reason text]`: the daemon (this one, or M's through the server) restarts under its service.
       if (sub === 'restart') return withNode(async (rpc) => out(await rpc.call('machine.restart', { reason: flags.reason ? String(flags.reason) : null })));
-      die('machine start|status|restart');
+      // `machine boards [list]` and `machine boards unregister <root>`: the board homes this machine's connector follows
+      // and publishes, and one no longer followed (a proof's scratch home: t_f7b219b8)
+      if (sub === 'boards') {
+        const [action = 'list', root] = rest;
+        if (action === 'list') return withNode(async (rpc) => out(await rpc.call('harness.v1.boards.list', {})));
+        if (action === 'unregister' && root) return withNode(async (rpc) => out(await rpc.call('harness.v1.boards.unregister', { root: resolve(root) })));
+        die('machine boards [list] | machine boards unregister <root>');
+      }
+      die('machine start|status|restart|boards');
     }
     case 'slow': {
       // `slow [--since 1h|30m|<iso>]`: the slow log on this machine, grouped by what was slow (kind and name), the
@@ -238,7 +247,13 @@ async function main() {
         flags.processes ? 'panes.processes' : flags['presence-only'] ? 'panes.present' : 'panes.list',
         flags['presence-only'] && typeof flags.panes === 'string' ? { panes: flags.panes.split(',').filter(Boolean) } : {})));
       if (sub === 'capture') return withNode(async (rpc) => out((await rpc.call('panes.capture', { pane: rest[0], lines: Number(flags.lines ?? 200) })).text));
-      if (sub === 'close') return withNode(async (rpc) => out(await rpc.call('panes.close', { pane: rest[0] })));
+      // One pane, named: `--foreign` closes a pane another session started, and is said for that pane alone.
+      if (sub === 'close') {
+        // the flag parser takes `--foreign p_…` as the flag's value: that pane is the one named
+        const named = typeof flags.foreign === 'string' ? [flags.foreign, ...rest] : rest;
+        if (named.length !== 1) die('panes close <pane> [--foreign]: one pane per close');
+        return withNode(async (rpc) => out(await rpc.call('panes.close', { pane: named[0], foreign: flags.foreign !== undefined, ...(await acting()) })));
+      }
       // `window <pane> [machine]`: a terminal window on this machine's screen showing the pane, this machine's or, named,
       // another machine's (attached through Teams, in that machine's Teams context `--attach-context`); `--observe` shows it
       // read-only.

package/bin/workspace.mjs

@@ -1477,7 +1477,9 @@ function stampStderr() {
   const decoder = new StringDecoder('utf8');
   let atStart = true;
   process.stderr.write = (chunk, ...rest) => {
-    const text = typeof chunk === 'string' ? chunk : decoder.write(Buffer.from(chunk));
+    // a string written while a Buffer's split character is pending ends that character first (as U+FFFD, the bytes
+    // it had), so the bytes are never held back to land after the string
+    const text = typeof chunk === 'string' ? decoder.end() + chunk : decoder.write(Buffer.from(chunk));
     // an empty write (or a Buffer holding only part of a character) changes no line
     if (!text) return write(text, ...rest);
     const stamp = new Date().toISOString();
@@ -1497,7 +1499,10 @@ async function releaseSkills() {
   const release = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', '..');
   try {
     if (JSON.parse(readFileSync(join(release, 'package.json'), 'utf8')).name !== '@volter/supercode') return [];
-    const { installSkills } = await import(pathToFileURL(join(release, 'lib', 'skills.mjs')).href);
+    const { installSkills, notThisHomesOwner } = await import(pathToFileURL(join(release, 'lib', 'skills.mjs')).href);
+    // only as the home's owner (a `sudo -E` connect would leave root-owned skill folders in the user's harness homes)
+    const refused = notThisHomesOwner?.();
+    if (refused) return [`skills not installed (${refused}); run \`supercode skills install\` as the home's owner`];
     return installSkills();
   } catch { return []; }
 }

package/board-events.mjs

@@ -5,8 +5,8 @@
 // Each board home's cursor is kept beside the connector, so a restart resumes where it left off; a published event's id
 // is derived from its server, team, source and publication, so a follower that starts over republishes the same ids.
 import { spawn } from 'node:child_process';
-import { mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 import { createHash } from 'node:crypto';
 import { createInterface } from 'node:readline';
 import { TeamsClient, retryAfterMs, spentClause } from '@volter/teams/http-client';
@@ -91,6 +91,23 @@ export class BoardEvents {
     }
     return { root, registered: true, refused: this.refused };
   }
+  /**
+   * A home no longer followed: its follower ended for good and its record dropped, so no restart brings it back
+   * (t_f7b219b8: 16 scratch proof homes on aarons-mac-mini, each with its own follower, after every daemon start). By an
+   * operator (`supercode teams machine boards unregister <root>`), or here for a home whose folder is gone. Its cards
+   * already published stay on the team.
+   */
+  unregister(path, why = 'unregistered') {
+    let root = resolve(String(path));
+    try { root = realpathSync(root); } catch { /* gone: named as it was registered */ }
+    if (!this.state.boards[root]) return { root, unregistered: false };
+    delete this.state.boards[root]; delete this.state.sources[root]; this.save();
+    this.waits.delete(root);
+    const child = this.followers.get(root);
+    if (child) { child.gone = true; end(child); }
+    this.log(`board events of ${root}: no longer followed (${why})`);
+    return { root, unregistered: true };
+  }
   start() {
     this.started = true;
     for (const root of Object.keys(this.state.boards)) this.follow(root);
@@ -101,6 +118,9 @@ export class BoardEvents {
   follow(root) {
     if (this.followers.has(root) || this.stopped || this.refused) return;
     const board = this.state.boards[root];
+    if (!board) return; // unregistered while it waited
+    // a home whose folder is gone (a proof's scratch home, removed) has no board left to follow: dropped, not retried
+    if (!existsSync(root)) { this.unregister(root, 'its folder is gone'); return; }
     // In a process group of its own (end): the follower is the native binary, the orchestrator it runs and the one that
     // hands the line to, and ending the first alone left the others running, holding its output open.
     const child = spawn(this.binary, ['workflow', 'events', '--root', root, ...(board.cursor ? ['--after', board.cursor] : [])], { env: this.env, stdio: ['ignore', 'pipe', 'pipe'], detached: true });
@@ -148,7 +168,7 @@ export class BoardEvents {
     child.on('close', async (code) => {
       await frames;
       this.followers.delete(root);
-      if (this.stopped || this.refused) return;
+      if (this.stopped || this.refused || child.gone) return;
       if (child.again) { this.follow(root); return; } // registered again: on the orchestrator the home names now
       // its last lines, a stack among them when the store's own error ended it (orchestrator.mjs)
       if (code && !board.error) this.log(`board events of ${root}: workflow events ended (${code}): ${stderr.trim().split('\n').slice(-12).join('\n  ')}`);

package/codex-startup.mjs

@@ -42,7 +42,16 @@ export function codexStartupArguments(args = []) {
     }
     normalized.push(argument);
   }
-  return ['-c', 'check_for_update_on_startup=false', ...normalized];
+  // Codex 0.160's `resume` does not take this override from before the subcommand: a resumed TUI with it there still
+  // stopped on "Update available" once another Codex had cached a newer version, and `codex resume <id> -c …` did not
+  // (yuerans, 2026-10-06). It goes after the subcommand and its session id (readers of the process take the word after
+  // `resume` as the id: codex_peer.rs `resumed_session_in`), in front when there is no subcommand. `fork` is placed the
+  // same way by extension; only `resume` was measured.
+  const subcommand = normalized.findIndex((argument, index) => ['resume', 'fork'].includes(argument)
+    && !['-c', '--config'].includes(normalized[index - 1]) && !normalized.slice(0, index).includes('--'));
+  const id = subcommand >= 0 && normalized[subcommand + 1] !== undefined && normalized[subcommand + 1] !== '--' && !normalized[subcommand + 1].startsWith('-');
+  const at = subcommand < 0 ? 0 : subcommand + (id ? 2 : 1);
+  return [...normalized.slice(0, at), '-c', 'check_for_update_on_startup=false', ...normalized.slice(at)];
 }
 
 export function codexUpdatePrompt(screen) {

package/machine.mjs

@@ -2079,16 +2079,22 @@ export class TeamsMachine extends MachineCore {
   }
 
   #refuseForeign(pane, caller) {
-    if (typeof caller !== 'string' || !caller || /^sc:[^:]+:board:/.test(caller)) return;
+    const starter = this.#foreignStarter(pane, caller);
+    if (starter) throw Object.assign(new Error(`pane ${pane} ${starter}, not by ${caller}: a session acts only on the panes it started. Nothing was done; reach that session through its own doors (supercode message send)`), { code: 403 });
+  }
+
+  /** Who started `pane`, said, when `caller` is a session that did not start it; null when the caller may act on it (a
+   *  person, a board, its starter). */
+  #foreignStarter(pane, caller) {
+    if (typeof caller !== 'string' || !caller || /^sc:[^:]+:board:/.test(caller)) return null;
     const launch = this.launches.all().find((entry) => entry.pane === pane);
     const by = launch?.by ?? null;
-    if (by === caller) return;
+    if (by === caller) return null;
     // A pane that resumes a session is that session's as well: its first starter acts on it as before the resume
     // (t_09a795fd item 18). The starter is the oldest harness launch whose own transcript confirmed it started that
     // session, never a launch row's claim (any caller can launch a program with --session-id S).
-    if (launch?.resumes && this.#sessionOrigin(launch.resumes)?.by === caller) return;
-    const starter = by ? `was started by ${by}` : 'was not started by a session (a person or an earlier daemon started it)';
-    throw Object.assign(new Error(`pane ${pane} ${starter}, not by ${caller}: a session acts only on the panes it started. Nothing was done; reach that session through its own doors (supercode message send)`), { code: 403 });
+    if (launch?.resumes && this.#sessionOrigin(launch.resumes)?.by === caller) return null;
+    return by ? `was started by ${by}` : 'was not started by a session (a person or an earlier daemon started it)';
   }
 
   /** The launch that started native Claude session `session`: the oldest journal row of a Claude launch whose own
@@ -3307,7 +3313,7 @@ export class TeamsMachine extends MachineCore {
         }
         const contextKey = params.pane ?? `p_${randomBytes(9).toString('base64url')}`;
         // Who started the pane: the launching session's (or board's) address, null for a person. A session's later
-        // input on the pane is refused unless it is this one (#refuseForeign); close is not creator-restricted.
+        // input on the pane is refused unless it is this one (#refuseForeign); its close needs `foreign` (panes.close).
         // Who to tell when the pane ends (`open --new … --notify-when-ended`): a session's mail address, and this
         // machine's name as the address a notice from its pane comes from.
         if (params.notify !== undefined && !(params.notify && typeof params.notify.to === 'string' && /^sc:[^:\s]+:[^:\s]+:\S+$/.test(params.notify.to) && typeof params.notify.machine === 'string' && /^[a-z0-9][a-z0-9-]*$/.test(params.notify.machine))) throw Object.assign(new Error('launch notify is { to: <sc: address>, machine: <this machine\'s mail name> }'), { code: 400 });
@@ -3459,14 +3465,28 @@ export class TeamsMachine extends MachineCore {
       case 'harness.v1.panes.close':
       case 'panes.close': {
         need('control', `pane:${params.pane}`);
-        for (const pending of this.pendingStartups.values()) if (pending.pane === params.pane) pending.abort.abort();
+        // A session closes the panes it started and the one it runs in. Another's pane is closed only when the caller
+        // says so (`foreign`), one pane at a time, by name: a listing piped into close is refused pane by pane rather
+        // than ending every session on the machine (docs/adr/0004-pane-close-authority.md).
+        const starting = [...this.pendingStartups.values()].filter((pending) => pending.pane === params.pane);
+        // only a pane here (open, or still starting) is anyone's: one this machine lacks is answered as absent, before
+        // the caller is asked for
+        const here = starting.length > 0 || Boolean(await this.#paneByContext(params.pane));
+        const closeBy = here ? await this.#callerOf(entry, params) : null;
+        const starter = params.foreign === true || !here ? null : this.#foreignStarter(params.pane, closeBy);
+        // the pane the caller runs in: a Claude row names it as its tmux locator (`p_…:@window.%pane`), the others as the pane
+        if (starter && !this.live.sessions().some((live) => live.address === closeBy && String(live.pane ?? '').split(':')[0] === params.pane)) {
+          act('close', `pane:${params.pane}`, 'refused', `foreign: ${starter}`);
+          throw Object.assign(new Error(`pane ${params.pane} ${starter}, not by ${closeBy}. Nothing was closed. A session closes the panes it started; closing another's is deliberate: read what the pane holds, settle it with whoever started it, then close that one pane with --foreign`), { code: 403 });
+        }
+        for (const pending of starting) pending.abort.abort();
         const session = await this.#paneByContext(params.pane);
         if (!session) {
           act('close', `pane:${params.pane}`, 'ok', 'already absent');
           return { closed: params.pane, alreadyAbsent: true };
         }
         await this.host.closeSession(session.id);
-        act('close', `pane:${params.pane}`);
+        act('close', `pane:${params.pane}`, 'ok', params.foreign === true ? `foreign, by ${closeBy ?? 'a person'}` : null);
         this.#panesChanged();
         return { closed: params.pane };
       }
@@ -3990,11 +4010,15 @@ export class TeamsMachine extends MachineCore {
         if (entry.principal !== 'local' || entry.appDoor) throw Object.assign(new Error('a caller is resolved only for a process on this machine'), { code: 403 });
         return { caller: await this.#callerOf(entry, params) };
       }
-      case 'harness.v1.boards.register': case 'harness.v1.boards.list': {
+      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.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);
+        }
         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);
         // The home's board owner acts as its boards: the caller it names for a board of that home is taken from it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.124",
+  "version": "0.3.126",
   "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",
@@ -70,7 +70,7 @@
     "@volter/supercode-health": "^0.1.0",
     "@volter/supercode-terminal": "^0.2.54",
     "@volter/supercode-trace": "^0.1.0",
-    "@volter/teams": "0.2.34",
+    "@volter/teams": "0.2.35",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",

package/worker/index.mjs

@@ -145,7 +145,7 @@ export class TeamsServer extends DurableObject {
 
 /** What the Durable Object's runtime said of a failed call (its error's own flags), for the log and the answer. */
 const objectFailure = (error) => ({
-  name: String(error?.name ?? 'Error'),
+  name: String(error?.name ?? 'Error').slice(0, 100),
   message: String(error?.message ?? error).slice(0, 200),
   retryable: error?.retryable === true,
   overloaded: error?.overloaded === true,
@@ -173,12 +173,16 @@ export default {
   },
 };
 
+/** The error names an unauthenticated caller is told; any other (a library's or the runtime's own) is said as
+ *  `Error`, and is in the log line only (#1246 review). */
+const PUBLIC_NAMES = new Set(['Error', 'TypeError', 'RangeError', 'ReferenceError', 'SyntaxError', 'AbortError', 'TimeoutError', 'DOMException']);
+
 /** Failures before the HTTP handler (object initialization, migrations, storage, a reset) as our API contract, not a
  *  platform HTML page. The answer goes to callers not yet authenticated, so it names only the error's kind and the
  *  runtime's flags; its message (storage or SQL text, internal paths) is in the log line its request id leads to. */
 function unavailable(failure, retried) {
   const requestId = crypto.randomUUID();
   console.error(JSON.stringify({ event: 'teams_unavailable', request_id: requestId, failure, ...(retried ? { first: retried } : {}) }));
-  const cause = `${failure.name}${failure.reset ? ', object reset' : ''}${failure.overloaded ? ', overloaded' : ''}${retried ? ', after one retry' : ''}`;
-  return Response.json({ version: 1, error: { code: 'unavailable', message: `Teams server is temporarily unavailable (${cause})`, request_id: requestId, retryable: true, cause: { name: failure.name, retryable: failure.retryable, overloaded: failure.overloaded, remote: failure.remote, reset: failure.reset } } }, { status: 503, headers: { 'Retry-After': failure.overloaded ? '15' : '5', 'X-Request-ID': requestId } });
+  const cause = `${PUBLIC_NAMES.has(failure.name) ? failure.name : 'Error'}${failure.reset ? ', object reset' : ''}${failure.overloaded ? ', overloaded' : ''}${retried ? ', after one retry' : ''}`;
+  return Response.json({ version: 1, error: { code: 'unavailable', message: `Teams server is temporarily unavailable (${cause})`, request_id: requestId, retryable: true, cause: { name: PUBLIC_NAMES.has(failure.name) ? failure.name : 'Error', retryable: failure.retryable, overloaded: failure.overloaded, remote: failure.remote, reset: failure.reset } } }, { status: 503, headers: { 'Retry-After': failure.overloaded ? '15' : '5', 'X-Request-ID': requestId } });
 }