@volter/supercode-teams 0.3.200 → 0.3.202

package/bin/teams-cli.mjs

@@ -108,8 +108,11 @@ const home = flags.home ? String(flags.home) : migrationRead
   ? process.env.SUPERCODE_TEAMS_HOME ?? join(supercodeHome(), 'teams') : teamsHome();
 const p = paths(home);
 const out = (value) => process.stdout.write((typeof value === 'string' ? value : JSON.stringify(value, null, 2)) + '\n');
-const die = (message, code = 2) => { process.stderr.write(`supercode teams: ${message}\n`); process.exit(code); };
-if (!workspaceVerb) for (const flag of Object.keys(flags)) if (!KNOWN_FLAGS.has(flag)) die(`unknown flag: --${flag}`);
+// A refusal ends the command through main()'s promise, never by process.exit() at the point of refusal: by then a
+// machine verb has usually opened a machine (a fetch, a socket), and on Windows exiting while that handle is still
+// closing aborts Node inside libuv (`!(handle->flags & UV_HANDLE_CLOSING)`, src\win\async.c) and loses the exit code.
+const die = (message, code = 2) => { throw Object.assign(new Error(message), { exitCode: code }); };
+if (!workspaceVerb) for (const flag of Object.keys(flags)) if (!KNOWN_FLAGS.has(flag)) { process.stderr.write(`supercode teams: unknown flag: --${flag}\n`); process.exit(2); }
 
 /** Named keys (tmux's names) as the bytes a terminal sends for them: `panes.input` delivers
  *  them (`keys`) as a keystream, which every terminal host turns back into keys. */
@@ -611,4 +614,10 @@ async function main() {
   }
 }
 
-if (!workspaceVerb) main().catch((error) => die(error.message ?? String(error), error.code === 'machine_offline' ? 5 : 1));
+if (!workspaceVerb) main().catch(async (error) => {
+  process.stderr.write(`supercode teams: ${error.message ?? String(error)}\n`);
+  process.exitCode = error.exitCode ?? (error.code === 'machine_offline' ? 5 : 1);
+  // Windows: let the loop drain so closing handles finish, then force the exit if something still holds it open.
+  if (process.platform === 'win32') { setTimeout(() => process.exit(process.exitCode), 2_000).unref(); return; }
+  await new Promise((resolve) => process.stdout.write('', resolve)); process.exit();
+});

package/live-sessions.mjs

@@ -769,6 +769,9 @@ export class LiveSessions extends EventEmitter {
     }
     const left = () => Math.max(250, deadline - Date.now());
     for (const { pid: at, command } of await ancestryOf(Number(pid), left())) {
+      // a process with no entry has its registry file read now: the folder's watch can miss a new file's event, and a
+      // session that started after this daemon was then no one for its first sends (R71)
+      if (!this.claude.has(at)) for (const dir of this.claudeDirs.keys()) { this.#readClaude(dir, `${at}.json`); if (this.claude.has(at)) break; }
       const claude = this.claude.get(at);
       if (claude && alive(claude.pid)) return this.#address('claude-code', claude.sessionId);
       const hosted = await this.#runtimeOfPid(at, deadline);

package/machine.mjs

@@ -74,6 +74,9 @@ function inProcessPair() {
 import { boardLabel, boardName } from '@volter/teams/board-name';
 import { fileURLToPath } from 'node:url';
 import { boardGuardArguments } from '@volter/teams/board-process-guard';
+// The harnesses whose board launch carries the native process policy here: Claude's exec-form hook runs on every
+// platform; Codex's shell-form hook is POSIX-quoted, so Windows does not offer it.
+const BOARD_GUARDED_HARNESSES = process.platform === 'win32' ? ['claude-code'] : ['claude-code', 'codex'];
 import { homedir, hostname, userInfo, tmpdir } from 'node:os';
 import { mkdtempSync } from 'node:fs';
 import { serveHttpListener } from './http-listener.mjs';
@@ -1069,7 +1072,7 @@ export class TeamsMachine extends MachineCore {
         return { panes, activities, sessions_unread };
       },
       // what a board launch needs of this machine: its board process guard and its keyed launch door (this daemon has it)
-      capabilities: async () => ({ guard: process.platform === 'win32' ? [] : ['claude-code', 'codex'], launches: true }),
+      capabilities: async () => ({ guard: BOARD_GUARDED_HARNESSES, launches: true }),
       // the mail headers, from the header index (no process)
       mail: async (mailboxes) => {
         const answer = this.mail.headers({ recent: RECENT_PER_MAILBOX, mailboxes });
@@ -2399,7 +2402,7 @@ export class TeamsMachine extends MachineCore {
   // Native session hooks carry the launcher's identity across Codex's shared
   // app-server process boundary. Process ancestry alone cannot recover it.
   #nativeQuestionCommand(params, pane, by, nativeInput) {
-    if (params.env?.SUPERCODE_BOARD_PROCESS_GUARD === '1' && process.platform === 'win32') throw new Error('board process guard is unavailable on Windows; no unguarded session was launched');
+    if (params.env?.SUPERCODE_BOARD_PROCESS_GUARD === '1' && !BOARD_GUARDED_HARNESSES.includes(params.kind)) throw new Error(`board process guard is unavailable for ${params.kind} on this machine; no unguarded session was launched`);
     let args = boardGuardArguments(params.kind,params.arguments ?? [],{cwd:params.cwd,enabled:params.env?.SUPERCODE_BOARD_PROCESS_GUARD === '1'});
     const name = String(params.program ?? '').split(/[\\/]/).pop();
     // Windows has no Unix endpoint for a pane's own native server, so a fresh Codex there starts with no session to
@@ -3369,7 +3372,7 @@ export class TeamsMachine extends MachineCore {
       node: { pid: process.pid, version: MACHINE_VERSION, protocol: NODE_PROTOCOL, floor: this.floor },
       egress: this.env.SUPERCODE_TEAMS_EGRESS ?? 'unrestricted',
       execution: executionCapabilities(this.env),
-      boardProcessPolicy: process.platform === 'win32' ? null : { version: 1, harnesses: ['claude-code','codex'], boundary: 'native-PreToolUse' },
+      boardProcessPolicy: { version: 1, harnesses: BOARD_GUARDED_HARNESSES, boundary: 'native-PreToolUse' },
       runSpec: this.env.SUPERCODE_TEAMS_RUN_SPEC_SHA256 ?? null,
       restart: Boolean(this.restartHandler),
       at: Date.now(),

package/mail/send.mjs

@@ -690,7 +690,10 @@ export class MailSend {
     else text = `sent to ${reached.length ? reached.join(', ') : 'no one woken yet'}.${copied.length ? ` CC (filed, not woken): ${copied.join(', ')}.` : ''}${heldText} Message id ${shortId(sent.id)}.${thread} Don't poll; carry on.`;
     if (failed.length) text += ` Not delivered to: ${failed.join('; ')}.`;
     const code = reached.length || copied.length || held.length || waiting ? 0 : EXIT_FAILED;
-    return { ...outcome(code, text, code === 0 ? { delivered: true, message_ids: [sent.id], receipt: 'agent-mailbox', ...(waiting ? { waiting } : {}), ...(held.length && !reached.length && !copied.length ? { unanswered: true } : {}) } : null), waiting };
+    // Filing, CC and a held wake are durable mail, but only native reaches confirm handoff. Keep this fact beside
+    // the wording so callers never have to infer it from the translated display text or a changed sentence.
+    const handoffConfirmed = reached.length > 0 && failed.length === 0 && held.length === 0;
+    return { ...outcome(code, text, code === 0 ? { delivered: true, handoff_confirmed: handoffConfirmed, message_ids: [sent.id], receipt: 'agent-mailbox', ...(waiting ? { waiting } : {}), ...(held.length && !reached.length && !copied.length ? { unanswered: true } : {}) } : null), waiting };
   }
 
   /** `sent` filed unread in `address`'s mailbox on this machine's mail, without waking it (mail_agent.rs `file_unread`):
@@ -829,7 +832,7 @@ export class MailSend {
     try { plan = await this.agents.plan(sent, receiver, channel); } catch (error) { return refused('delivery_failed', error.message); }
     if (plan) {
       const done = await this.#deliverPlanned({ address: sender, name: sent.from_name }, sent, plan, { queue: false, notify_when_idle: params.notify_when_idle === true });
-      return { delivered_to_bus: done.code === 0, message_id: sent.id, reply_to: sender, thread: plan.thread?.id ?? null, target: { harness, session_id: sessionId }, delivery: { door: 'agent', how: done.text } };
+      return { delivered_to_bus: done.code === 0, message_id: sent.id, reply_to: sender, thread: plan.thread?.id ?? null, target: { harness, session_id: sessionId }, delivery: { door: 'agent', how: done.text, handoff_confirmed: done.receipt?.handoff_confirmed === true } };
     }
     if (!door || door.kind === 'other_machine') return refused('not_live', `no running \`${harness}\` session \`${sessionId}\` is reachable; its transcript is persisted only`);
     let how;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.3.200",
+  "version": "0.3.202",
   "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",
@@ -84,10 +84,10 @@
     "@volter/supercode-frontend": "^0.2.2",
     "@volter/supercode-harness-sdk": "^0.3.58",
     "@volter/supercode-health": "^0.1.0",
-    "@volter/supercode-interchange": "0.1.10",
+    "@volter/supercode-interchange": "0.1.11",
     "@volter/supercode-terminal": "^0.2.54",
     "@volter/supercode-trace": "^0.1.0",
-    "@volter/teams": "0.2.46",
+    "@volter/teams": "0.2.47",
     "@xterm/addon-serialize": "^0.14.0",
     "@xterm/headless": "^6.0.0",
     "protobufjs": "8.8.0",