@volter/supercode-teams 0.3.125 → 0.3.126

package/bin/teams.mjs

@@ -55,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 = {};
@@ -247,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/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 };
       }

package/package.json

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