shraga 0.1.99 → 0.1.101

package/src/client/lib/prompt-directives.ts

@@ -54,7 +54,7 @@ export function writeRuntimeDirective(text: string, sel: RuntimeSelection): stri
     }
   }
   // An engine the chosen model already implies is not written: `[model:cursor/composer-2.5]` and
-  // `[engine:agentx,model:cursor/composer-2.5]` mean the same thing to the parser, and emitting the
+  // `[engine:ext-agent,model:cursor/composer-2.5]` mean the same thing to the parser, and emitting the
   // longer one would stamp a pin the user never chose onto every schedule that carries a model-only
   // directive (11 of the 15 live ones) the moment the picker is touched.
   const impliedEngine = sel.model ? resolveModelAlias(sel.model)?.engine : undefined;

package/src/server/background-jobs.ts

@@ -6,10 +6,10 @@
 // polling is not the fix; something has to WAKE the session when the process exits.
 //
 // Shape:
-//   • The registry is owned by the SERVER (module singleton), not by the turn. agentx builds a fresh
+//   • The registry is owned by the SERVER (module singleton), not by the turn. An add-on engine builds a fresh
 //     `Agent` per turn, so a registry created there would die with the turn — the very failure above.
 //     Hosts hand each turn a thin per-session VIEW (`sessionJobRegistry`) over this one store; the
-//     view is duck-compatible with agentx's `ShellJobRegistry`, so `Shell({background:true})` and the
+//     view is duck-compatible with the add-on engine's `ShellJobRegistry`, so `Shell({background:true})` and the
 //     ShellOutput/ShellStatus/ShellKill tools light up with no folklore `nohup`.
 //   • On exit we report through wake.ts — the same "close then report" path polls.ts already uses in
 //     production, so a job outcome lands wherever the session speaks (Slack thread / web UI).
@@ -193,10 +193,10 @@ function pidAgeSeconds(pid: number): number | null {
 /**
  * Env for a job's shell: the server's own, minus anything that looks like a credential.
  *
- * agentx's foreground `Bash` redacts these by default (RealShellOptions.redactEnv). Backgrounding a
+ * An add-on engine's foreground `Bash` redacts these by default (RealShellOptions.redactEnv). Backgrounding a
  * command must not be a way around that — otherwise `Bash({background:true})` becomes a strictly
  * weaker sandbox than `Bash({})`, and `echo $ANTHROPIC_API_KEY` lands in a job log we then feed back
- * into the model. Mirrors agentx's SECRET_ENV_RE; a job that genuinely needs a credential gets it
+ * into the model. Mirrors the add-on engine's SECRET_ENV_RE; a job that genuinely needs a credential gets it
  * explicitly via `JobOwner.env`.
  */
 const SECRET_ENV_RE = /(API_KEY|_TOKEN|_SECRET|_PASSWORD|_PRIVATE_KEY|^AWS_|^GITHUB_TOKEN$|^OPENAI_|^ANTHROPIC_|^GOOGLE_|^GEMINI_|^GROQ_|^NPM_TOKEN$|^SLACK_)/i;
@@ -519,7 +519,7 @@ function pruneOld(): void {
 // ── The per-turn view handed to the agent engine ───────────────────────────────
 
 /**
- * A session-scoped facade over the process-wide store, duck-compatible with agentx's
+ * A session-scoped facade over the process-wide store, duck-compatible with the add-on engine's
  * `ShellJobRegistry` — pass it as `makeRealShellTool({ registry })` and to `makeShellJobTools`.
  *
  * Cheap to build per turn (it holds no state); the jobs it starts belong to the server, so they

package/src/server/boot.ts

@@ -1022,84 +1022,146 @@ function abortUpgrade(socket: import('node:stream').Duplex, code: number, messag
   catch { socket.destroy(); }
 }
 
-function proxySidecarWebSocket(req: import('node:http').IncomingMessage, socket: import('node:stream').Duplex, head: Buffer, port: number) {
+/** Claude Code speaks the kitty keyboard protocol, where `CSI <code>;<mods> u` IS a modified keypress —
+ *  `CSI 107;9u` is cmd+k, which clears its screen and, arriving twice, runs `/clear` and destroys the
+ *  conversation. Our terminal is xterm.js 5.5, which has no kitty support and can never emit that byte,
+ *  so anything shaped like it on this socket is spurious, not a keystroke the user made. Drop it and say
+ *  where it came from — repeated unexplained `/clear`s cost real sessions. Remove once a client that
+ *  genuinely speaks the protocol attaches here. */
+const CSI_U_KEY = /\x1b\[\d+;\d+u/;
+function isSpuriousKittyKey(data: import('ws').RawData, isBinary: boolean): string | null {
+  if (isBinary) return null;
+  try {
+    const msg = JSON.parse(data.toString());
+    if (msg?.type !== 'input' || typeof msg.data !== 'string') return null;
+    const input = Buffer.from(msg.data, 'base64').toString();
+    return CSI_U_KEY.test(input) ? input : null;
+  } catch { return null; }
+}
+
+function proxySidecarWebSocket(req: import('node:http').IncomingMessage, socket: import('node:stream').Duplex, head: Buffer, port: number, authed: Promise<import('./auth.ts').AuthUser | null>) {
   const targetUrl = `ws://127.0.0.1:${port}${req.url}`;
   sidecarWss.handleUpgrade(req, socket as any, head, (clientWs) => {
-    // The caller paused the socket for the async auth gap; ws has now attached its own 'data' listener
-    // (handleUpgrade → setSocket runs before this callback), so it's safe — and necessary — to resume:
-    // an EXPLICITLY paused socket does not re-enter flowing mode just because a listener was added, so
-    // without this every buffered byte and every subsequent keystroke would sit unread forever.
+    // Belt-and-braces: nothing pauses this socket any more (the auth gap moved past the handshake, see
+    // AUTH GATE below), but an explicitly paused socket does not re-enter flowing mode just because a
+    // listener was added — so if anything upstream ever pauses again, resuming here is what keeps every
+    // buffered byte and every subsequent keystroke from sitting unread forever.
     socket.resume();
-    const targetWs = new WebSocket(targetUrl);
-    let opened = false;
 
-    // Bound IMMEDIATELY, not inside targetWs 'open': the BROWSER's socket is OPEN the moment
-    // handleUpgrade returns, so it reports "connected" and starts sending while we're still dialing the
-    // sidecar. Registering the listener on open discarded everything typed in that window — silently.
-    // Queue instead, and flush in order once upstream is up.
-    const pending: Array<{ data: import('ws').RawData; isBinary: boolean }> = [];
+    // AUTH GATE — deliberately AFTER the handshake, not before it. The upgrade must complete in the
+    // SAME tick as the 'upgrade' event: on Bun (reproduced on 1.4.0) a `handleUpgrade` deferred past a
+    // macrotask — exactly what awaiting a token verification costs on a cold key cache — lands in ws's
+    // `completeUpgrade` abort path, and ws's own `abortHandshake` then throws
+    // (`undefined is not an object (evaluating 'message')`). The browser sees a bare close, caddy logs
+    // `502 EOF`, and every terminal pane stays blank. Isolated repro: a microtask-deferred handleUpgrade
+    // succeeds, a `setTimeout(…, 0)`-deferred one throws — which is why this only bit when auth actually
+    // hit the network. Security is unchanged: NOTHING is dialed or forwarded until the token verifies,
+    // and a failed check closes the socket with 1008 before a single byte reaches the sidecar.
+    let targetWs: WebSocket;
+    let opened = false;
+    // Anything typed between the 101 and the auth verdict. Bounded like `pending` below; on rejection it
+    // is dropped with the socket.
+    const preAuth: Array<{ data: import('ws').RawData; isBinary: boolean }> = [];
+    let gateOpen = false;
     clientWs.on('message', (data, isBinary) => {
-      // App-level liveness probe (Layer 2): the client can't read protocol pongs from JS, so it sends
-      // `{type:'ping'}` and expects `{type:'pong'}`. We RELAY it — we must not answer it here. A
-      // proxy-local reply only proves THIS hop is alive: if the proxy→sidecar leg is half-open, or the
-      // sidecar has already dropped this client from its subscriber set, the browser still gets pongs,
-      // keeps `readyState === OPEN`, shows a green "connected" dot, and every keystroke disappears.
-      // The probe is only worth anything end-to-end, so the sidecar owns the reply (it answers in its
-      // own ws message handler); a sidecar that doesn't reply fails the probe, which is the honest
-      // outcome — the client then reconnects rather than trusting a dead pipe.
-      if (targetWs.readyState === WebSocket.OPEN) targetWs.send(data, { binary: isBinary });
-      else if (!opened && pending.length < 256) pending.push({ data, isBinary }); // bounded: never buffer unboundedly
-    });
-
-    targetWs.on('open', () => {
-      opened = true;
-      for (const m of pending) {
-        if (targetWs.readyState === WebSocket.OPEN) targetWs.send(m.data, { binary: m.isBinary });
+      if (gateOpen || preAuth.length >= 256) return; // bounded: never buffer unboundedly
+      // Same kitty-key filter the bridged handler applies. These frames are flushed straight into
+      // `pending`, so without it a spurious `CSI …u` sent during the auth window would reach the shell
+      // by the one path that skips the guard.
+      if (isSpuriousKittyKey(data, isBinary)) {
+        console.warn('[ws-proxy] BLOCKED kitty key input (pre-auth)', JSON.stringify({ url: req.url?.split('?')[0], ua: req.headers['user-agent'] }));
+        return;
       }
-      pending.length = 0;
-      targetWs.on('message', (data, isBinary) => {
-        if (clientWs.readyState === WebSocket.OPEN) clientWs.send(data, { binary: isBinary });
-      });
+      preAuth.push({ data, isBinary });
     });
-
-    // Keepalive: a proxied sidecar socket carries no app-level heartbeat, so an idle WS gets silently dropped
-    // by an intermediary (Cloudflare tunnel idles WS at ~100s) leaving the BROWSER half-open — readyState
-    // stays OPEN, no onclose fires, the "connected" dot stays green and keystrokes vanish into a dead pipe.
-    // Ping the client (browsers auto-pong at the protocol level) to keep intermediaries from idling us out,
-    // and terminate a peer that misses a pong so the client gets a real close → its reconnect kicks in.
-    // Tolerate ONE missed pong before terminating (~2 intervals of grace): a backgrounded mobile tab is
-    // JS/network-frozen and can't auto-pong for a cycle, so a 1-strike policy force-closed it every 30s and
-    // churned reconnects. Two strikes lets a brief freeze ride through; a truly dead pipe still gets cut.
-    let missedPongs = 0;
-    clientWs.on('pong', () => { missedPongs = 0; });
-    const pingInterval = setInterval(() => {
+    void authed.then((user) => {
       if (clientWs.readyState !== WebSocket.OPEN) return;
-      if (missedPongs >= 2) { console.warn('[ws-proxy] client missed pongs — terminating (likely backgrounded/frozen client)'); clientWs.terminate(); return; }
-      missedPongs++;
-      clientWs.ping();
-    }, WS_PING_INTERVAL);
-
-    targetWs.on('close', () => { clearInterval(pingInterval); clientWs.close(); });
-    targetWs.on('error', (e) => {
-      // Pre-open failure = the sidecar daemon is unreachable (e.g. it idle-exited, or is not up yet
-      // after a restart). This is TRANSIENT: the daemon (and its shells) survive a server/proxy blip, and
-      // we revive it right below — so flag `fatal:false`. The client must keep the pane alive and re-attach
-      // (a mobile client that backgrounded for minutes recovers its still-running sidecar on resume), NOT show a
-      // permanent "session unavailable". Only the daemon's own `session not found` (post-open) is fatal.
-      if (!opened) {
-        if (clientWs.readyState === WebSocket.OPEN) {
-          try { clientWs.send(JSON.stringify({ type: 'error', message: 'sidecar daemon unavailable', fatal: false })); } catch { /* socket gone */ }
-        }
-      } else {
-        console.warn('[ws-proxy] target error:', e.message);
+      if (!user) {
+        console.warn(`[ws-proxy] rejected unauthenticated upgrade for ${req.url?.split('?')[0]}`);
+        clientWs.close(1008, 'unauthorized');
+        return;
       }
-      clientWs.close();
+      gateOpen = true;
+      startBridge();
     });
-    clientWs.on('close', () => { clearInterval(pingInterval); if (targetWs.readyState === WebSocket.OPEN) targetWs.close(); });
-    clientWs.on('error', (e) => { console.error(`[ws-proxy] client error:`, e.message); targetWs.close(); });
+
+    function startBridge() {
+      targetWs = new WebSocket(targetUrl);
+
+      // Bound IMMEDIATELY, not inside targetWs 'open': the BROWSER's socket is OPEN the moment
+      // handleUpgrade returns, so it reports "connected" and starts sending while we're still dialing the
+      // sidecar. Registering the listener on open discarded everything typed in that window — silently.
+      // Queue instead, and flush in order once upstream is up.
+      const pending: Array<{ data: import('ws').RawData; isBinary: boolean }> = preAuth.splice(0);
+      clientWs.on('message', (data, isBinary) => {
+        // App-level liveness probe (Layer 2): the client can't read protocol pongs from JS, so it sends
+        // `{type:'ping'}` and expects `{type:'pong'}`. We RELAY it — we must not answer it here. A
+        // proxy-local reply only proves THIS hop is alive: if the proxy→sidecar leg is half-open, or the
+        // sidecar has already dropped this client from its subscriber set, the browser still gets pongs,
+        // keeps `readyState === OPEN`, shows a green "connected" dot, and every keystroke disappears.
+        // The probe is only worth anything end-to-end, so the sidecar owns the reply (para-pty answers in
+        // its ws message handler); a sidecar that doesn't reply fails the probe, which is the honest
+        // outcome — the client then reconnects rather than trusting a dead pipe.
+        const spurious = isSpuriousKittyKey(data, isBinary);
+        if (spurious) {
+          console.warn('[ws-proxy] BLOCKED kitty key input', JSON.stringify({
+            url: req.url?.split('?')[0], seq: spurious, ua: req.headers['user-agent'], ref: req.headers.referer,
+          }));
+          return;
+        }
+        if (targetWs.readyState === WebSocket.OPEN) targetWs.send(data, { binary: isBinary });
+        else if (!opened && pending.length < 256) pending.push({ data, isBinary }); // bounded: never buffer unboundedly
+      });
+
+      targetWs.on('open', () => {
+        opened = true;
+        for (const m of pending) {
+          if (targetWs.readyState === WebSocket.OPEN) targetWs.send(m.data, { binary: m.isBinary });
+        }
+        pending.length = 0;
+        targetWs.on('message', (data, isBinary) => {
+          if (clientWs.readyState === WebSocket.OPEN) clientWs.send(data, { binary: isBinary });
+        });
+      });
+
+      // Keepalive: a proxied sidecar socket carries no app-level heartbeat, so an idle WS gets silently dropped
+      // by an intermediary (Cloudflare tunnel idles WS at ~100s) leaving the BROWSER half-open — readyState
+      // stays OPEN, no onclose fires, the "connected" dot stays green and keystrokes vanish into a dead pipe.
+      // Ping the client (browsers auto-pong at the protocol level) to keep intermediaries from idling us out,
+      // and terminate a peer that misses a pong so the client gets a real close → its reconnect kicks in.
+      // Tolerate ONE missed pong before terminating (~2 intervals of grace): a backgrounded mobile tab is
+      // JS/network-frozen and can't auto-pong for a cycle, so a 1-strike policy force-closed it every 30s and
+      // churned reconnects. Two strikes lets a brief freeze ride through; a truly dead pipe still gets cut.
+      let missedPongs = 0;
+      clientWs.on('pong', () => { missedPongs = 0; });
+      const pingInterval = setInterval(() => {
+        if (clientWs.readyState !== WebSocket.OPEN) return;
+        if (missedPongs >= 2) { console.warn('[ws-proxy] client missed pongs — terminating (likely backgrounded/frozen client)'); clientWs.terminate(); return; }
+        missedPongs++;
+        clientWs.ping();
+      }, WS_PING_INTERVAL);
+
+      targetWs.on('close', () => { clearInterval(pingInterval); clientWs.close(); });
+      targetWs.on('error', (e) => {
+        // Pre-open failure = the sidecar daemon is unreachable (e.g. it idle-exited, or is not up yet
+        // after a restart). This is TRANSIENT: the daemon (and its shells) survive a server/proxy blip, and
+        // we revive it right below — so flag `fatal:false`. The client must keep the pane alive and re-attach
+        // (a mobile client that backgrounded for minutes recovers its still-running sidecar on resume), NOT show a
+        // permanent "session unavailable". Only the daemon's own `session not found` (post-open) is fatal.
+        if (!opened) {
+          if (clientWs.readyState === WebSocket.OPEN) {
+            try { clientWs.send(JSON.stringify({ type: 'error', message: 'sidecar daemon unavailable', fatal: false })); } catch { /* socket gone */ }
+          }
+        } else {
+          console.warn('[ws-proxy] target error:', e.message);
+        }
+        clientWs.close();
+      });
+      clientWs.on('close', () => { clearInterval(pingInterval); if (targetWs.readyState === WebSocket.OPEN) targetWs.close(); });
+      clientWs.on('error', (e) => { console.error(`[ws-proxy] client error:`, e.message); targetWs.close(); });
+    }
   });
 }
-
 server.on('upgrade', (req, socket, head) => {
   if (req.url === '/ws') {
     wss.handleUpgrade(req, socket as any, head, (ws) => {
@@ -1125,7 +1187,6 @@ server.on('upgrade', (req, socket, head) => {
       // is reading it while we verify; pausing makes that explicit and guarantees bytes the client sends
       // between the handshake and our decision are buffered, not dropped. proxySidecarWebSocket resumes
       // it once ws owns the socket.
-      socket.pause();
       // Fail CLOSED on anything: a rejected/thrown/slow auth must destroy the socket, never leave it
       // dangling. Without the catch a throw in authenticateWsUpgrade (token store unavailable, malformed
       // header) produced an unhandled rejection AND an open, unauthenticated, un-proxied socket; without
@@ -1139,17 +1200,15 @@ server.on('upgrade', (req, socket, head) => {
       // upgrade even when auth resolved in milliseconds.
       let authTimer: ReturnType<typeof setTimeout> | undefined;
       const timedOut = new Promise<null>((resolve) => { authTimer = setTimeout(() => resolve(null), WS_AUTH_TIMEOUT_MS); authTimer.unref?.(); });
-      void Promise.race([authed, timedOut])
-        .then((user) => {
-          if (authTimer) clearTimeout(authTimer);
-          if (socket.destroyed) return;
-          if (!user) {
-            console.warn(`[ws-proxy] rejected unauthenticated upgrade for ${req.url?.split('?')[0]}`);
-            abortUpgrade(socket, 401, 'Unauthorized: missing or invalid token');
-            return;
-          }
-          proxySidecarWebSocket(req, socket, head, port);
-        });
+      const verdict = Promise.race([authed, timedOut]).then((user) => { if (authTimer) clearTimeout(authTimer); return user; });
+      // The handshake is NOT deferred behind that verification: on Bun (reproduced on 1.4.0) a
+      // `handleUpgrade` deferred past a macrotask lands in ws's `completeUpgrade` abort path, and ws's
+      // own `abortHandshake` then throws (`undefined is not an object (evaluating 'message')`). The
+      // browser sees a bare close, caddy logs `502 EOF`, and every terminal pane stays blank — and an
+      // UNAUTHENTICATED upgrade hangs instead of being refused. Complete the upgrade now, hand the
+      // in-flight verification down, and let it decide whether to bridge or close (see the AUTH GATE
+      // note in proxySidecarWebSocket).
+      proxySidecarWebSocket(req, socket, head, port, verdict);
     } else {
       // No sidecar registered for this path — a client error, not an auth failure.
       abortUpgrade(socket, 400, 'Unknown upgrade path');

package/src/server/directives.ts

@@ -38,7 +38,7 @@ const DIRECTIVE_KEYS = ['model', 'turns', 'thinking', 'think', 'effort', 'engine
 const isQualifiedModel = (v: string) => /^[a-z0-9._-]+\/[a-z0-9./_-]+$/.test(v);
 
 /** Resolves a model token the alias table doesn't know against the REGISTERED engines' own model
- *  lists, and reports which engine owns it. Without this, `[composer-2.5]` (an agentx model) was
+ *  lists, and reports which engine owns it. Without this, `[composer-2.5]` (an add-on engine's model) was
  *  warned about and dropped, so the turn silently ran on the previous engine/model. Injected by
  *  `initEngines()` — directives.ts stays pure and dependency-free for CE and for tests. */
 export type ModelResolver = (token: string) => { model: string; engine?: string } | null;

package/src/server/engine/index.ts

@@ -70,7 +70,7 @@ export function resolveAndGetEngine(directives?: { engine?: string }, agentConfi
   const name = resolveEngine(directives, agentConfig);
   // An optional engine may be unregistered on a given boot (add-on not loaded, missing API key or
   // failed init). Rerouting to claude-code here silently switched PROVIDER AND BILLING under the
-  // caller — a cursor/agentx run billed Anthropic while the UI still showed the cursor chips. Fail
+  // caller — an add-on engine's run billed Anthropic while the UI still showed the cursor chips. Fail
   // loudly instead; the degradation is surfaced to whoever asked (user, schedule) as a turn error.
   if (!hasEngine(name)) throw new EngineUnavailableError(name, getAvailableEngines());
   return getEngine(name);

package/src/server/listen-retry.ts

@@ -4,7 +4,7 @@
  * `kickstart -k` starts the replacement while the old process drains (up to 90s), so the new one
  * meets EADDRINUSE. Exiting immediately hands the problem to the service manager — which respawns
  * on a ~10s throttle, meets the same still-draining owner, and exits again. MEASURED 2026-09-06 on
- * the feedox box: one watchdog kick produced ~20 start/exit cycles over five minutes, every one of
+ * a production box: one watchdog kick produced ~20 start/exit cycles over five minutes, every one of
  * them `port already in use`, and every scheduled run in that window died with it. The manager was
  * doing exactly what it was asked to; the retry it was standing in for just belonged here, where
  * the wait is one process holding still instead of N processes racing.

package/src/server/paths.ts

@@ -68,7 +68,7 @@ export const APP_ROOT = resolveAppRoot();
  * (shipped assets) explicitly.
  *
  * Aliased to APP_ROOT, not PACKAGE_ROOT, deliberately: every remaining external consumer of this
- * export (shraga-ee `engine/cursor.ts`, `engine/agentx.ts`) uses it as the agent's project root —
+ * export (shraga-ee's optional engines, e.g. `engine/cursor.ts`) uses it as the agent's project root —
  * i.e. they meant APP_ROOT and were hitting the same npm-layout bug. Pointing the alias here fixes
  * them without an EE change. Nothing in this package reads shipped assets through it.
  */

package/src/server/port-reclaim.ts

@@ -7,7 +7,7 @@ import { execFileSync } from 'node:child_process';
  * when the server's launchd/systemd parent dies first: the server reparents to pid 1, nothing will
  * ever signal it, and it holds the port FOREVER. The replacement then dies on every respawn while
  * the orphan keeps serving the OLD code, so `kickstart -k` looks successful and changes nothing
- * (observed on feedox 2026-08-28: a deploy "restarted" the service four times, and the process
+ * (observed on a production deployment 2026-08-28: a deploy "restarted" the service four times, and the process
  * answering :3032 was three hours and one version old).
  *
  * Reclaiming is deliberately narrow — an over-broad "kill whatever holds my port" is how a deploy
@@ -22,7 +22,7 @@ export function reclaimStalePort(port: number, opts: { entrypoint?: string; cwd?
 
   // Any state, not just LISTEN: an orphan that closed its listener inside a drain it never finished
   // still OWNS the socket, and looking only for LISTEN made it invisible while it blocked every
-  // replacement (feedox 2026-09-06: ppid-1 orphan, listener closed, port held for six minutes and
+  // replacement (a production deployment 2026-09-06: ppid-1 orphan, listener closed, port held for six minutes and
   // counting). `isStaleSelf` is what keeps this narrow — a bystander is never a candidate.
   const holders = [...new Set([...listeners(port), ...portUsers(port)])]
     .filter((pid) => pid !== process.pid && isStaleSelf(pid, entrypoint, cwd));

package/src/server/scheduler/builtins.ts

@@ -112,7 +112,7 @@ export function backfillScope(schedules: Schedule[]): void {
     }
     // Undo the `engine: 'claude-code'` pin reconcile stamped onto the failure notifier. It shipped on
     // a premise the box's own logs disprove — nothing was ever misrouted; the deployment was simply
-    // globally on claude-code then and on agentx now — and it made the alarm the second casualty of
+    // globally on claude-code then and on an add-on engine now — and it made the alarm the second casualty of
     // the real failure mode (an org cap on the pinned provider). Narrow on purpose: exactly the
     // state that clause produced (this id, that engine, no model), so it cannot eat a real choice.
     if (s.id === FAILURE_NOTIFIER_SCHEDULE_ID && task.engine === 'claude-code' && !task.model) {

package/src/server/self-upgrade/supervisor.sh

@@ -139,7 +139,7 @@ wait_for_version() { # version timeout
 # One dropped probe is not a crash-loop. This runs on a busy box where a single request can lose a
 # 10s race (MCP mounts, a GC pause, the drain window of the restart we just did), and a zero-
 # tolerance soak turns that blip into an automatic rollback of a perfectly good version — observed
-# reverting 0.1.48 on feedox while the process stayed up throughout. Require CONSECUTIVE misses, so
+# reverting 0.1.48 on a production deployment while the process stayed up throughout. Require CONSECUTIVE misses, so
 # a real crash (which never answers again) still fails fast.
 SOAK_MISS_LIMIT="${SOAK_MISS_LIMIT:-3}"
 soak() { # version seconds