@volter/supercode-teams 0.3.102 → 0.3.104

package/machine.mjs

@@ -1752,6 +1752,23 @@ export class TeamsMachine extends MachineCore {
     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');
     const 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
+    // type into: its rollout appears only with its first turn. Its first input is therefore Codex's own argv prompt,
+    // as it is on the other platforms, and the receipt is the rollout that records it under CODEX_HOME. A batch
+    // command line cannot carry a line break, so multi-line input keeps the pane and is typed as before.
+    if (process.platform === 'win32' && params.kind === 'codex' && /^codex(?:\.cmd|\.exe)?$/i.test(name)) {
+      const initialInput = params.initialInput && !/[\r\n\0]/.test(params.initialInput) && !args.includes('--') &&
+        !args.some((arg) => arg === '--remote' || arg.startsWith('--remote=')) ? params.initialInput : null;
+      if (!initialInput) return launchCommand(params.program, args);
+      const codexHome = params.env?.CODEX_HOME || this.env.CODEX_HOME || join(homedir(), '.codex');
+      // A resume appends to the rollout it names (`resume <id>`; `--last` names none). A fork writes a new
+      // rollout, so its receipt is found as a fresh session's is.
+      const verb = args.indexOf('resume');
+      const named = verb >= 0 ? args.slice(verb + 1).find((arg) => /^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(arg)) : null;
+      nativeInput({ kind: params.kind, text: initialInput, startedAt: Date.now(), codexSessions: join(codexHome, 'sessions'),
+        cwd: params.cwd || null, continuing: verb >= 0, resumeId: named ?? null });
+      return launchCommand(params.program, [...args, '--', initialInput]);
+    }
     if (process.platform === 'win32' || !((params.kind === 'codex' && name === 'codex') ||
       (params.kind === 'claude-code' && name === 'claude'))) return launchCommand(params.program, args);
     this.nativeQuestionHooksSupported ??= spawnSync(this.supercodeBin, ['message', 'native-question-hook', '--help'], { env: this.env, timeout: 2000, stdio: 'ignore' }).status === 0;

package/native-codex-pane.mjs

@@ -2,7 +2,7 @@
 // Supercode hosts neither the agent nor its run loop; it can attach to native
 // question requests while the stock TUI remains the session's UI.
 import { spawn } from 'node:child_process';
-import { readFileSync, writeFileSync, renameSync, mkdtempSync, existsSync, rmSync } from 'node:fs';
+import { readFileSync, writeFileSync, renameSync, mkdtempSync, existsSync, rmSync, appendFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
@@ -42,7 +42,23 @@ for (let index = 0; index < seed.arguments.length; index += 1) {
   }
 }
 if(writableRoots.length)config.push('-c',`sandbox_workspace_write.writable_roots=${JSON.stringify(writableRoots)}`);
-const server = spawn(seed.program, [...config, 'app-server', '--listen', endpoint], { stdio: ['ignore', 'ignore', 'inherit'] });
+// The app-server's stderr is never the pane's: the pane is the TUI's screen, and a record the server writes there lands
+// on the TUI's composer row, which the mail wake then reads as a person's draft and never types over (yuerans,
+// 2026-10-06: `ERROR codex_models_manager::manager: failed to refresh available models` held every wake of the box
+// maintainer off for three hours). It is kept beside the pane's binding instead, at most LOG_BYTES of it.
+const LOG_BYTES = 8 * 1024 * 1024;
+const serverLog = `${path.replace(/\.json$/, '')}.app-server.log`;
+let logged = 0;
+const server = spawn(seed.program, [...config, 'app-server', '--listen', endpoint], { stdio: ['ignore', 'ignore', 'pipe'] });
+server.stderr.on('data', (chunk) => {
+  if (logged >= LOG_BYTES) return;
+  const kept = chunk.subarray(0, LOG_BYTES - logged);
+  logged += kept.length;
+  try {
+    appendFileSync(serverLog, kept, { mode: 0o600 });
+    if (logged >= LOG_BYTES) appendFileSync(serverLog, `\nsupercode: the app-server's stderr past ${LOG_BYTES} bytes is not kept\n`);
+  } catch { /* its log is best kept; the pane never gets it */ }
+});
 let tui;
 let ended = false;
 let serverError;
@@ -67,7 +83,10 @@ try {
   tui = spawn(seed.program, args, { stdio: 'inherit' });
   process.exitCode = await new Promise((resolve, reject) => { tui.once('exit', (code) => resolve(code ?? 1)); tui.once('error', reject); });
 } catch (error) {
-  process.stderr.write(`supercode: ${error.message}\n`);
+  // a server that failed says why in its log, which the pane shows only now, as the pane's own failure
+  let why = '';
+  try { why = readFileSync(serverLog, 'utf8').slice(-2000).trim(); } catch { /* it wrote nothing */ }
+  process.stderr.write(`supercode: ${error.message}\n${why ? `its app-server's stderr (${serverLog}):\n${why}\n` : ''}`);
   process.exitCode = 1;
 } finally {
   clearInterval(guard);

package/native-initial-input.mjs

@@ -1,12 +1,55 @@
 // Native CLIs accept an initial prompt before their TUI starts. Their own
 // transcript, not a collapsed paste badge or an empty editor, confirms receipt.
-import { open, readFile } from 'node:fs/promises';
+import { open, readdir, readFile, stat } from 'node:fs/promises';
+import { join, win32 } from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
 import { codexQuestions } from './native-questions.mjs';
 
 const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-export async function confirmNativeInitialInput({ binding, kind, text, startedAt }, { signal, deadlineMs, live }) {
+/** Rollouts one daemon's launches have already taken as their receipt, with when: a launch that began before a
+ *  claim does not answer from that transcript, while a later launch (a resume of the same session) still can, since
+ *  its receipt must be newer than it anyway. This orders launches; it does not prove ownership — two panes in one
+ *  directory sent the same words within a second can still read each other's rollout, as the first to read wins. */
+const claimedRollouts = new Map();
+
+/** Rollouts Codex wrote since a launch, under `<CODEX_HOME>/sessions/YYYY/MM/DD` (Codex names the day in local
+ *  time). A fresh session's rollout is new: the day it started and the day after, so a launch just before midnight
+ *  still finds it (a fork writes a new one too). A resumed one appends to a rollout of any day, so the whole tree is read.
+ *  Where a pane has no native server to ask (Windows), this is how its first turn's transcript is found. */
+async function codexRolloutsSince(root, startedAt, continuing, resumeId) {
+  const dirs = continuing ? [root] : [...new Set([startedAt, startedAt + 86_400_000].map((t) => {
+    const d = new Date(t);
+    return join(root, String(d.getFullYear()), String(d.getMonth() + 1).padStart(2, '0'), String(d.getDate()).padStart(2, '0'));
+  }))];
+  const found = [];
+  for (const dir of dirs) {
+    let names;
+    try { names = await readdir(dir, { recursive: continuing }); } catch { continue; }
+    for (const name of names.filter((n) => /(?:^|[\\/])rollout-[^\\/]*\.jsonl$/.test(n))) {
+      const path = join(dir, name);
+      if ((claimedRollouts.get(path) ?? -Infinity) >= startedAt) continue;
+      if (resumeId && !path.endsWith(`-${resumeId}.jsonl`)) continue;
+      try { if ((await stat(path)).mtimeMs >= startedAt - 1000) found.push({ path, offset: 0 }); } catch { /* Gone since the listing. */ }
+    }
+  }
+  return found;
+}
+
+/** Whether a rollout's `session_meta` is this launch's session. A fresh one was begun after the launch, in the
+ *  launch's directory; another Codex sent the same words elsewhere is not this pane's receipt. A continued one keeps
+ *  the directory it was first made in, so it is named by its id instead (`resumeId`, in the scan). */
+function codexRolloutIsLaunch(meta, { cwd, startedAt, continuing }) {
+  if (!meta) return false;
+  if (continuing) return true;
+  // A Git Bash path (`/c/Users/…`) names the same directory as Codex's `C:\Users\…`.
+  const resolved = (path) => win32.resolve(path.replace(/^\/([a-z])(?=\/|$)/i, '$1:'))
+    .replace(/[\\/]+$/, '').toLowerCase();
+  if (cwd && (typeof meta.cwd !== 'string' || resolved(meta.cwd) !== resolved(cwd))) return false;
+  return Date.parse(meta.timestamp) >= startedAt - 1000;
+}
+
+export async function confirmNativeInitialInput({ binding, kind, text, startedAt, codexSessions, cwd, continuing = false, resumeId = null }, { signal, deadlineMs, live }) {
   const readers = new Map();
   const expired = () => signal.aborted || Date.now() >= deadlineMs;
   try {
@@ -14,7 +57,9 @@ export async function confirmNativeInitialInput({ binding, kind, text, startedAt
       if (!await live()) return { delivered: false, reason: 'pane-gone' };
       let paths = [];
       try {
-        if (kind === 'claude-code') {
+        if (codexSessions) {
+          paths = await codexRolloutsSince(codexSessions, startedAt, continuing, resumeId);
+        } else if (kind === 'claude-code') {
           paths = [JSON.parse(await readFile(binding.replace(/\.json$/, '.session.json'), 'utf8'))];
         } else {
           const seed = JSON.parse(await readFile(binding, 'utf8'));
@@ -45,6 +90,8 @@ export async function confirmNativeInitialInput({ binding, kind, text, startedAt
             const line = reader.buffered.slice(0, newline); reader.buffered = reader.buffered.slice(newline + 1);
             let record;
             try { record = JSON.parse(line); } catch { continue; }
+            if (codexSessions && record.type === 'session_meta' && !reader.meta) reader.meta = record.payload ?? {};
+            if (codexSessions && !codexRolloutIsLaunch(reader.meta, { cwd, startedAt, continuing })) continue;
             let content;
             if (kind === 'claude-code' && record.type === 'user' && !record.isMeta) content = record.message?.content;
             if (kind === 'codex' && record.type === 'response_item' && record.payload?.type === 'message' &&
@@ -55,6 +102,7 @@ export async function confirmNativeInitialInput({ binding, kind, text, startedAt
             // so a session can be told apart as one an agent launched (Claude Code's sessionId; Codex's rollout id).
             if (value === text) {
               const native = kind === 'claude-code' ? record.sessionId : /([0-9a-f]{8}-[0-9a-f-]{27})\.jsonl$/.exec(entry.path)?.[1];
+              if (codexSessions) claimedRollouts.set(entry.path, Date.now());
               return { delivered: true, receipt: 'native-user-message', ...(typeof native === 'string' && native ? { native_session: native } : {}) };
             }
           }

package/package.json

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