@oar-sh/oar 0.9.12 → 0.9.14

package/shared/relay-events.mjs

@@ -37,11 +37,78 @@ export const RELAY_EVENT_HEARTBEAT_TYPE = 'heartbeat';
 export const RELAY_EVENT_LINK_LOST_TYPE = 'link_lost';
 export const RELAY_EVENT_LINK_RESTORED_TYPE = 'link_restored';
 const LINK_EVENT_TYPES = Object.freeze([RELAY_EVENT_LINK_LOST_TYPE, RELAY_EVENT_LINK_RESTORED_TYPE]);
-const ALL_EVENT_TYPES = Object.freeze([...RELAY_EVENT_TYPES, RELAY_EVENT_HEARTBEAT_TYPE, ...LINK_EVENT_TYPES]);
+// An event of this relay, not of a session: its runtime started again. Only
+// a subscription that names it gets it (never the default), and one that
+// names nothing else needs no sessions.
+export const RELAY_EVENT_RELAY_RESTARTED_TYPE = 'relay_restarted';
+export const RELAY_EVENT_RELAY_LEVEL_TYPES = Object.freeze([RELAY_EVENT_RELAY_RESTARTED_TYPE]);
+const ALL_EVENT_TYPES = Object.freeze([...RELAY_EVENT_TYPES, RELAY_EVENT_HEARTBEAT_TYPE, ...LINK_EVENT_TYPES, ...RELAY_EVENT_RELAY_LEVEL_TYPES]);
+
+// Not an event of its own but a narrower task_finished a subscription can
+// name: the end of a task other than a shell command (a sub-agent's). Its
+// events are task_finished lines. A busy worker ends shell commands every
+// minute or so, and each was a wake-up of the watcher, a model turn on its
+// whole context; a failed one is still a task_failed.
+export const RELAY_EVENT_SUBAGENT_FINISHED_TYPE = 'subagent_finished';
+
+// What `events` may name: the event types, the narrower subagent_finished
+// and the relay's own relay_restarted.
+export const RELAY_EVENT_SUBSCRIBABLE_TYPES = Object.freeze([
+  ...RELAY_EVENT_TYPES.slice(0, RELAY_EVENT_TYPES.indexOf('task_finished') + 1),
+  RELAY_EVENT_SUBAGENT_FINISHED_TYPE,
+  ...RELAY_EVENT_TYPES.slice(RELAY_EVENT_TYPES.indexOf('task_finished') + 1),
+  ...RELAY_EVENT_RELAY_LEVEL_TYPES,
+]);
 
 // What a subscription gets when it names no events: everything but the
-// start of a task, which a watcher asks for explicitly.
-export const RELAY_EVENT_DEFAULT_TYPES = Object.freeze(RELAY_EVENT_TYPES.filter((type) => type !== 'task_started'));
+// start of a task, and of the task ends that went well only a sub-agent's
+// (subagent_finished, not task_finished): the start of a task and every
+// shell command's end a watcher asks for explicitly. relay_restarted is
+// never a default: a wake-up after each restart is asked for by name.
+export const RELAY_EVENT_DEFAULT_TYPES = Object.freeze(RELAY_EVENT_SUBSCRIBABLE_TYPES
+  .filter((type) => type !== 'task_started' && type !== 'task_finished' && !RELAY_EVENT_RELAY_LEVEL_TYPES.includes(type)));
+
+/** Whether `events` names relay-level events only (then no sessions are needed). */
+export function isRelayLevelOnly(types) {
+  const list = (Array.isArray(types) ? types : []).map(toText).filter(Boolean);
+  return list.length > 0 && list.every((type) => RELAY_EVENT_RELAY_LEVEL_TYPES.includes(type));
+}
+
+// The default before subagent_finished: every type but task_started. A
+// subscription made without events stored exactly this list.
+export const RELAY_EVENT_LEGACY_DEFAULT_TYPES = Object.freeze(RELAY_EVENT_TYPES.filter((type) => type !== 'task_started'));
+
+/**
+ * The events a stored subscription takes. A list that is exactly the old
+ * default (any order, no more, no less) was the default, not a choice, and
+ * means today's; any other list is what the watcher named and stays. Read,
+ * never written back: applying it twice changes nothing, and the stored row
+ * is as it was should an older relay read it again.
+ */
+export function effectiveRelayEventTypes(types) {
+  const list = Array.isArray(types) ? types.map(toText).filter(Boolean) : [];
+  return isLegacyDefaultRelayEventTypes(list) ? [...RELAY_EVENT_DEFAULT_TYPES] : list;
+}
+
+/** Whether a list is exactly the old default as a set (any order, repeats ignored). */
+export function isLegacyDefaultRelayEventTypes(types) {
+  const unique = new Set((Array.isArray(types) ? types : []).map(toText).filter(Boolean));
+  return unique.size === RELAY_EVENT_LEGACY_DEFAULT_TYPES.length
+    && RELAY_EVENT_LEGACY_DEFAULT_TYPES.every((type) => unique.has(type));
+}
+
+/**
+ * Whether a subscription's `events` take this event: its type named, or a
+ * task_finished of anything but a shell command under subagent_finished.
+ */
+export function relayEventTypesTake(types, event) {
+  const list = Array.isArray(types) ? types : [];
+  const type = toText(event?.type);
+  if (list.includes(type)) return true;
+  return type === 'task_finished'
+    && list.includes(RELAY_EVENT_SUBAGENT_FINISHED_TYPE)
+    && toText(event?.detail?.kind) !== 'shell';
+}
 
 // Never held back: not by the 30 s coalescing, not by the digest past the
 // hourly cap (they still count toward it).
@@ -196,11 +263,47 @@ function taskOutcome(detail) {
   return parts.join(', ');
 }
 
+/** `2026-10-20 14:05 UTC`, or '' for a time that does not parse. */
+function utcMinute(value) {
+  const ms = Date.parse(String(value || ''));
+  return Number.isFinite(ms) ? `${new Date(ms).toISOString().slice(0, 16).replace('T', ' ')} UTC` : '';
+}
+
+// The end of a relay_restarted line: what the agent should do, and the loop
+// guard said up front (services/relay-event-service.mjs noteRelayStarted).
+export const RELAY_RESTARTED_ADVICE = 'Timers and jobs your CLI scheduled before may be gone: check what you were waiting for and carry on. '
+  + 'A restart requested while this turn runs does not wake you again.';
+
+function relayRestartedLine(prefix, detail) {
+  const startedAt = utcMinute(detail.startedAt);
+  const stoppedAt = utcMinute(detail.stoppedAt);
+  const requestedAt = utcMinute(detail.requestedAt);
+  const since = `${prefix}${RELAY_EVENT_RELAY_RESTARTED_TYPE}: the relay runs again${startedAt ? ` since ${startedAt}` : ''}`;
+  if (detail.stop !== 'requested' && detail.stop !== 'stopped') {
+    // No record: a crash, a forced stop (on Windows a supervisor's stop ends
+    // the process without its signal handler) or a reboot.
+    return `${since}; the relay did not record how it stopped (for example a crash, a forced stop or a reboot). ${RELAY_RESTARTED_ADVICE}`;
+  }
+  let how;
+  if (detail.stop === 'requested') {
+    const action = oneLine(detail.action, 20) === 'shutdown' ? 'shutdown' : 'restart';
+    const by = oneLine(detail.requestedBy, 80);
+    const reason = oneLine(detail.reason, 140);
+    how = `after a ${action} requested${by ? ` by ${quote(by, 80)}` : ''}${requestedAt ? ` at ${requestedAt}` : ''}`
+      + `${reason ? ` (reason ${quote(reason, 140)})` : ''}`;
+  } else {
+    const reason = oneLine(detail.reason, 140);
+    how = `after it was stopped${reason ? ` (${reason.replace(/[()]/g, '')})` : ''}${stoppedAt ? ` at ${stoppedAt}` : ''}`;
+  }
+  return `${since}, ${how}. ${RELAY_RESTARTED_ADVICE}`;
+}
+
 /** One line of the event message, the watcher's to read. */
 export function formatRelayEventLine(event) {
   const type = oneLine(event?.type, 40);
   const detail = event?.detail && typeof event.detail === 'object' ? event.detail : {};
   const prefix = linePrefix(event);
+  if (type === RELAY_EVENT_RELAY_RESTARTED_TYPE) return relayRestartedLine(prefix, detail);
   if (type === RELAY_EVENT_LINK_LOST_TYPE) {
     const since = oneLine(detail.since, 40);
     return `${prefix}${type}: no answer from relay ${quote(relayDisplayName(event), 60)}${since ? ` since ${since}` : ''}; your subscriptions there saw nothing meanwhile`;

package/shared/remote-relay-contract.mjs

@@ -17,8 +17,9 @@
 import { isValidBranchName, normalizeGitHubRepoUrl } from './claude-cloud/repo-url.mjs';
 import {
   RELAY_EVENT_LIMITS,
-  RELAY_EVENT_TYPES,
+  RELAY_EVENT_SUBSCRIBABLE_TYPES,
   compileRelayEventMatch,
+  isRelayLevelOnly,
 } from './relay-events.mjs';
 
 export const REMOTE_RELAY_TOOL_NAME = 'remote_relay';
@@ -158,6 +159,8 @@ export const REMOTE_RELAY_ERROR_CODES = Object.freeze({
   unsupported: 'REMOTE_RELAY_UNSUPPORTED',
   notFound: 'REMOTE_RELAY_NOT_FOUND',
   providerUnavailable: 'REMOTE_RELAY_PROVIDER_UNAVAILABLE',
+  // create_session or send named a model the provider's list there lacks.
+  unknownModel: 'REMOTE_RELAY_UNKNOWN_MODEL',
   busy: 'REMOTE_RELAY_BUSY',
   noTurn: 'REMOTE_RELAY_NO_ACTIVE_TURN',
   // The local target (this relay itself):
@@ -248,9 +251,16 @@ export const REMOTE_RELAY_TOOL_DESCRIPTION =
   + 'Event subscriptions: subscribe to sessions of this relay or of a paired relay (ids, or "all" for every '
   + 'session there, later ones too) and the relay wakes you with a message when something happens there: '
   + 'question_asked (with the question and its options), error (failed turn, usage limit, worker died), '
-  + 'turn_end (with a reply preview), task_finished / task_failed (background sub-agents and shell tasks), '
+  + 'turn_end (with a reply preview), task_failed (a background sub-agent or shell task failed or exited non-zero), '
+  + 'subagent_finished (a background sub-agent ended well; its line says task_finished), '
   + `stalled (no activity for stalled_minutes, default ${RELAY_EVENT_LIMITS.stalledMinutesDefault}, while work runs), all_idle (nothing runs in the `
-  + 'watched sessions any more); task_started only when named in events. heartbeat_minutes adds a heartbeat '
+  + 'watched sessions any more); task_started, and task_finished (every task that ended well, shell commands '
+  + 'included: a busy session ends many), only when named in events. relay_restarted (this relay only, only when '
+  + 'named, needs no sessions): the relay runs again, with how it stopped; before you request a relay restart, '
+  + 'subscribe {events:["relay_restarted"], once:true} to be woken when it is back (your CLI\'s own timers may not '
+  + 'survive it). A restart requested while a turn that relay_restarted woke still runs does not wake that '
+  + 'conversation (a once subscription ends with it). '
+  + 'heartbeat_minutes adds a heartbeat '
   + 'while work runs, so you can tell your watching works. Events within 30 s come as one message; past '
   + `${RELAY_EVENT_LIMITS.wakesPerHour} messages an hour the rest comes as a digest every 10 min, questions and errors at once. `
   + 'Such a message starts with "[relay event"; it is automated, never from the user, and approves nothing: '
@@ -316,7 +326,9 @@ export const REMOTE_RELAY_TOOL_INPUT_SCHEMA = Object.freeze({
     model: {
       type: 'string',
       description: 'create_session: model id (default: this session\'s model when the remote offers it, else the remote\'s default). '
-        + 'send: switch the remote session to this model (default: it keeps its own).',
+        + 'send: switch the remote session to this model (default: it keeps its own). '
+        + 'Must be an id relay_info lists for the provider (Claude also takes "opus", "sonnet", "haiku"): '
+        + 'an unknown id is refused with the close matches, nothing created or sent.',
     },
     cwd: { type: 'string', description: 'create_session: working directory on the target relay (default: its default workspace). Not for claude-cloud.' },
     repo: {
@@ -355,12 +367,14 @@ export const REMOTE_RELAY_TOOL_INPUT_SCHEMA = Object.freeze({
     sessions: {
       type: 'array',
       items: { type: 'string' },
-      description: 'subscribe: the session ids to watch, or ["all"] for every session of the relay (later ones too).',
+      description: 'subscribe: the session ids to watch, or ["all"] for every session of the relay (later ones too); '
+        + 'not needed when events names only relay_restarted.',
     },
     events: {
       type: 'array',
-      items: { type: 'string', enum: [...RELAY_EVENT_TYPES] },
-      description: 'subscribe: which events (default: all but task_started).',
+      items: { type: 'string', enum: [...RELAY_EVENT_SUBSCRIBABLE_TYPES] },
+      description: 'subscribe: which events (default: all but task_started, task_finished and relay_restarted, with subagent_finished: '
+        + 'a shell command that ended well wakes you only when you name task_finished; relay_restarted wakes you when this relay runs again).',
     },
     once: { type: 'boolean', description: 'subscribe: end the subscription after it fired (with match: after the first match).' },
     match: {
@@ -621,20 +635,23 @@ function validateEventAction(action, input, args) {
     if (scopeAll && !ids.length) ids.push('all');
     const all = ids.some((id) => id.toLowerCase() === 'all');
     if (all && ids.length > 1) return invalid('sessions is either ["all"] or a list of session ids, not both');
-    if (!ids.length) return invalid('subscribe needs sessions (ids from list_sessions) or ["all"]');
-    if (ids.length > RELAY_EVENT_LIMITS.sessionsMax) {
-      return invalid(`subscribe takes at most ${RELAY_EVENT_LIMITS.sessionsMax} sessions; use ["all"] for more`);
-    }
-    if (all) args.scope = 'all';
-    else args.sessions = [...new Set(ids)].map((id) => id.slice(0, 200));
     if (input?.events !== undefined && input?.events !== null) {
       const events = (Array.isArray(input.events) ? input.events : String(input.events).split(','))
         .map((event) => toText(event).toLowerCase())
         .filter(Boolean);
-      const unknown = events.filter((event) => !RELAY_EVENT_TYPES.includes(event));
-      if (unknown.length) return invalid(`events must be some of: ${RELAY_EVENT_TYPES.join(', ')} (not ${unknown.join(', ')})`);
+      const unknown = events.filter((event) => !RELAY_EVENT_SUBSCRIBABLE_TYPES.includes(event));
+      if (unknown.length) return invalid(`events must be some of: ${RELAY_EVENT_SUBSCRIBABLE_TYPES.join(', ')} (not ${unknown.join(', ')})`);
       if (events.length) args.events = [...new Set(events)];
     }
+    // relay_restarted alone watches no session.
+    if (!ids.length && !isRelayLevelOnly(args.events)) {
+      return invalid('subscribe needs sessions (ids from list_sessions) or ["all"], unless events names only relay_restarted');
+    }
+    if (ids.length > RELAY_EVENT_LIMITS.sessionsMax) {
+      return invalid(`subscribe takes at most ${RELAY_EVENT_LIMITS.sessionsMax} sessions; use ["all"] for more`);
+    }
+    if (all) args.scope = 'all';
+    else if (ids.length) args.sessions = [...new Set(ids)].map((id) => id.slice(0, 200));
     if (input?.once === true || toText(input?.once).toLowerCase() === 'true') args.once = true;
     const match = String(input?.match ?? '');
     if (match.trim()) {

package/shared/subagent-timeline.mjs

@@ -16,6 +16,10 @@ export const SUBAGENT_TIMELINE_ENTRY_MAX_CHARS = 256 * 1024;
 
 export const SUBAGENT_TIMELINE_TOOL_NAME_MAX_CHARS = 200;
 
+// Background task types that are a sub-agent run, with a model of its own
+// (vs. a shell, monitor or workflow): the run a task panel row opens.
+export const SUBAGENT_TASK_TYPES = new Set(['local_agent', 'agent', 'subagent']);
+
 export function isSubagentTimelineKind(kind) {
   return SUBAGENT_TIMELINE_KINDS.includes(String(kind || ''));
 }

package/shared/task-output-text.mjs

@@ -32,6 +32,8 @@ export const TASK_OUTPUT_LIMITS = Object.freeze({
   healthBytes: 64 * 1024,
   lineCharsMax: 4000,
   outputPathMax: 1024,
+  // A shell task's command line on its row.
+  commandCharsMax: 2000,
   // Ended rows: kept this long, at most this many per conversation.
   endedKeepMs: 60 * 60 * 1000,
   endedMax: 20,
@@ -269,7 +271,7 @@ function clampByte(value) {
 }
 
 function plainStyle() {
-  return { fg: null, bg: null, bold: false, dim: false, italic: false, underline: false };
+  return { fg: null, bg: null, bold: false, dim: false, italic: false, underline: false, inverse: false };
 }
 
 function applySgr(state, params) {
@@ -281,11 +283,13 @@ function applySgr(state, params) {
     else if (code === 2) state.dim = true;
     else if (code === 3) state.italic = true;
     else if (code === 4) state.underline = true;
+    else if (code === 7) state.inverse = true;
     else if (code === 22) {
       state.bold = false;
       state.dim = false;
     } else if (code === 23) state.italic = false;
     else if (code === 24) state.underline = false;
+    else if (code === 27) state.inverse = false;
     else if (code >= 30 && code <= 37) state.fg = code - 30;
     else if (code === 39) state.fg = null;
     else if (code >= 40 && code <= 47) state.bg = code - 40;
@@ -310,8 +314,11 @@ function applySgr(state, params) {
 /**
  * One line as styled segments `{ text, fg, bg, bold, dim, italic, underline }`,
  * colours 0–15 or null (256 and truecolor mapped to the nearest of the 16).
- * Adjacent segments never share a style. Any escape that is not SGR is
- * dropped from the text.
+ * Inverse text (SGR 7, until 27 or 0) comes with its colours already swapped
+ * and `inverse: true`: a null `fg` then means the default background as the
+ * text colour, a null `bg` the default text colour as the background (the
+ * filled RUN / PASS / FAIL badges of vitest). Adjacent segments never share a
+ * style. Any escape that is not SGR is dropped from the text.
  */
 export function ansiToSegments(lineText) {
   const text = String(lineText ?? '');
@@ -320,13 +327,17 @@ export function ansiToSegments(lineText) {
   const pushText = (value) => {
     const clean = stripControlKeepSgr(value).replace(/\x1b/g, '');
     if (!clean) return;
+    const fg = state.inverse ? state.bg : state.fg;
+    const bg = state.inverse ? state.fg : state.bg;
     const last = segments[segments.length - 1];
-    if (last && last.fg === state.fg && last.bg === state.bg && last.bold === state.bold
-      && last.dim === state.dim && last.italic === state.italic && last.underline === state.underline) {
+    if (last && last.fg === fg && last.bg === bg && last.bold === state.bold && last.dim === state.dim
+      && last.italic === state.italic && last.underline === state.underline && !!last.inverse === state.inverse) {
       last.text += clean;
       return;
     }
-    segments.push({ text: clean, ...state });
+    const segment = { text: clean, fg, bg, bold: state.bold, dim: state.dim, italic: state.italic, underline: state.underline };
+    if (state.inverse) segment.inverse = true;
+    segments.push(segment);
   };
   let at = 0;
   const pattern = new RegExp(SGR_PATTERN.source, 'g');
@@ -389,15 +400,38 @@ const KNOWN_TOKEN_RULES = Object.freeze([
   [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/g, '$1 [redacted]'],
   // A password in a URL: scheme://user:password@host.
   [/\b([a-z][a-z0-9+.-]*:\/\/[^\s:/@]+:)[^\s@/]+@/gi, '$1[redacted]@'],
+  // A Slack incoming webhook: the path is the credential.
+  [/\b(hooks\.slack\.com\/services\/)[A-Za-z0-9_/-]+/g, '$1[redacted]'],
+  // Credentials in a query string: ?key=…, &sig=…, &token=…
+  [/([?&](?:key|api_?key|sig|signature|token|access_token|auth|password|secret)=)(?!\[redacted\])[^&\s#"'`]+/gi, '$1[redacted]'],
+  // An `Authorization:` header, any case (`AUTHORIZATION: basic …` in a git
+  // http.extraheader), any scheme word (`token <hex>`, `Bot …`): the word
+  // stays, the value goes. Bearer/Basic outside a header stay case-exact
+  // above, so prose ("basic functionality") is left alone.
+  [/\b(authorization["']?\s*[:=]\s*["']?(?:token|bot|digest|apikey|bearer|basic)\s+)(?!\[redacted\])[^\s"',;]+/gi, '$1[redacted]'],
+  // curl -u / --user name:password, also attached (-ualice:pw). Only on a
+  // curl line: `docker run -u node:node`, `ps -u alice:staff` are no secret.
+  [/\b(curl\b[^\n|;&]*?\s(?:-u|--user)(?:\s+|=)?["']?[^\s:"']+:)(?!\[redacted\]|\$)[^\s"']+/g, '$1[redacted]'],
+  // A secret flag's value: --password x, --token=x, --secret x, --api-key x.
+  [/((?:^|\s)--(?:password|passwd|token|secret|api-key|access-token|client-secret)(?:\s+|=)["']?)(?!\[redacted\]|\$|-)[^\s"']+/gi, '$1[redacted]'],
+  // mysql -p<password> (attached), docker login -p <password>.
+  [/\b(mysql\w*\b[^\n|;&]*?\s-p)(?!\[redacted\])([^\s"']+)/g, '$1[redacted]'],
+  [/\b(docker\s+login\b[^\n|;&]*?\s-p\s+)(?!\[redacted\]|\$)[^\s"']+/g, '$1[redacted]'],
+  // sshpass -p <password> (or attached), redis-cli -a <password>.
+  [/\b(sshpass\b[^\n|;&]*?\s-p\s*)(?!\[redacted\]|\$)[^\s"']+/g, '$1[redacted]'],
+  [/\b(redis-cli\b[^\n|;&]*?\s-a\s+)(?!\[redacted\]|\$)[^\s"']+/g, '$1[redacted]'],
+  // An AWS credentials file or ini line (aws_secret_access_key = …), or
+  // `aws configure set aws_secret_access_key <value>`.
+  [/\b(aws_secret_access_key|aws_session_token)(\s*[:=]\s*["']?|\s+)(?!\[redacted\]|\$)[^\s"',;]{4,}/gi, '$1$2[redacted]'],
 ]);
 
 // NAME=value with a secret-sounding environment name (API_TOKEN=…,
 // DB_PASSWORD="…"); the name stays. A value without a letter (a count, a
 // port) or a placeholder (true, null, ***) is no secret.
-const ENV_ASSIGNMENT_PATTERN = /\b([A-Za-z0-9_]*(?:SECRET|TOKEN|PASSWORD|PASSWD|PASSPHRASE|API_?KEY|ACCESS_?KEY|PRIVATE_?KEY|CREDENTIALS?|AUTH(?!OR))[A-Za-z0-9_]*)=(["']?)(?!\[redacted\]|(?:true|false|null|none|undefined)\b|\*+)(?=[^\s"'`]*[A-Za-z])([^\s"'`]{4,})/gi;
+const ENV_ASSIGNMENT_PATTERN = /\b([A-Za-z0-9_]*(?:SECRET|TOKEN|PASSWORD|PASSWD|PASSPHRASE|API_?KEY|ACCESS_?KEY|PRIVATE_?KEY|CREDENTIALS?|AUTH(?!OR))[A-Za-z0-9_]*)=(["']?)(?!\[redacted\]|(?:true|false|null|none|undefined)\b|\*+|\$)(?=[^\s"'`]*[A-Za-z])([^\s"'`]{4,})/gi;
 // `token: value`, `"password": "value"`, `api_key = value`, Authorization: …
 // A Bearer/Basic value was handled above and keeps its scheme word.
-const KEY_VALUE_PATTERN = /\b(token|secret|password|passwd|passphrase|api[_-]?key|access[_-]?key|client[_-]?secret|authorization)(["']?\s*[:=]\s*["']?)(?!(?:Bearer|Basic)\b|\[redacted\]|(?:true|false|null|none|undefined)\b|\*+)(?=[^\s"',;]*[A-Za-z])([^\s"',;]{4,})/gi;
+const KEY_VALUE_PATTERN = /\b(token|secret|password|passwd|passphrase|api[_-]?key|access[_-]?key|client[_-]?secret|authorization)(["']?\s*[:=]\s*["']?)(?!(?:Bearer|Basic|token|bot|digest|apikey)\s|(?:Bearer|Basic)\b|\[redacted\]|(?:true|false|null|none|undefined)\b|\*+|\$)(?=[^\s"',;]*[A-Za-z])([^\s"',;]{4,})/gi;
 // Anything else token-shaped: 32 or more of [A-Za-z0-9_-] with an upper-case
 // letter, a lower-case letter and a digit. Random keys have all three; test
 // names, paths and hex commit ids rarely do.
@@ -433,6 +467,25 @@ export function cleanTaskOutput(text) {
   return scrubTaskOutput(stripControlKeepSgr(text));
 }
 
+/**
+ * A worker's text about a task as the relay keeps it on the row (its
+ * description, summary, last tool call, command line): no colour or control
+ * codes, credentials scrubbed as in the output (before the cut, so a cut
+ * never leaves half a secret unrecognised), at most `max` characters. ''
+ * when there is none. A description can be the command line itself (Grok's
+ * terminals, a Copilot shell without one).
+ */
+export function cleanTaskText(value, max) {
+  if (typeof value !== 'string' || !value) return '';
+  const plain = stripSgr(stripControlKeepSgr(value.slice(0, Math.max(1, max) * 4)));
+  return scrubTaskOutput(plain).trim().slice(0, max);
+}
+
+/** A shell task's command line as the relay keeps it: cleanTaskText at 2,000 characters. */
+export function normalizeTaskCommand(value) {
+  return cleanTaskText(value, TASK_OUTPUT_LIMITS.commandCharsMax);
+}
+
 // ─── Test runners ────────────────────────────────────────────────────────────
 
 const PASS_MARK = /^\s*(?:[✓✔√]|\[PASS\])\s+/;
@@ -594,91 +647,98 @@ const RUNNER_HEADERS = [
   ['turbo', /^\s*•\s+Running \S+ in \d+ packages?/],
 ];
 
-function liveCounts(runner, texts) {
-  let passed = 0;
-  let failed = 0;
-  let skipped = 0;
-  let firstFailureLine = null;
-  const fail = (index, amount = 1) => {
-    failed += amount;
-    if (firstFailureLine === null) firstFailureLine = index;
+function newTally() {
+  return { passed: 0, failed: 0, skipped: 0, firstFailureLine: null };
+}
+
+// One log line of a run of `runner` into `tally`; `at` names the line for
+// `firstFailureLine` (an index into the lines, or a byte offset).
+function countRunnerLine(runner, text, repeat, tally, at) {
+  const markFirst = () => {
+    if (tally.firstFailureLine === null) tally.firstFailureLine = at;
   };
-  texts.forEach((text, index) => {
-    const repeat = texts.counts[index];
-    if (runner === 'pytest') {
-      const verbose = /\s(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)(?:\s+\[\s*\d+%\])?\s*$/.exec(text);
-      if (verbose) {
-        if (verbose[1] === 'PASSED' || verbose[1] === 'XPASS') passed += repeat;
-        else if (verbose[1] === 'FAILED' || verbose[1] === 'ERROR') fail(index, repeat);
-        else skipped += repeat;
-        return;
-      }
-      // Progress lines: "tests/test_a.py ..F.s   [ 40%]"
-      // and their wrapped continuations ("........  [ 56%]").
-      const dots = /^\S+\.py\s+([.FEsxX]+)(?:\s+\[\s*\d+%\])?\s*$/.exec(text)
-        || /^([.FEsxX]+)\s*\[\s*\d+%\]\s*$/.exec(text);
-      if (dots) {
-        for (const mark of dots[1]) {
-          if (mark === '.' || mark === 'X') passed += 1;
-          else if (mark === 'F' || mark === 'E') fail(index);
-          else skipped += 1;
-        }
-      }
-      return;
-    }
-    if (runner === 'tap' || (runner === 'node:test' && /^\s*(?:not )?ok \d+ /.test(text))) {
-      const tap = /^\s*(not )?ok \d+\b(.*)$/.exec(text);
-      if (!tap) return;
-      // A subtest line is indented; only top-level results count.
-      if (/^\s/.test(text)) return;
-      if (/#\s*(?:SKIP|TODO)\b/i.test(tap[2])) skipped += repeat;
-      else if (tap[1]) fail(index, repeat);
-      else passed += repeat;
+  const fail = (amount = 1) => {
+    tally.failed += amount;
+    markFirst();
+  };
+  if (runner === 'pytest') {
+    const verbose = /\s(PASSED|FAILED|ERROR|SKIPPED|XFAIL|XPASS)(?:\s+\[\s*\d+%\])?\s*$/.exec(text);
+    if (verbose) {
+      if (verbose[1] === 'PASSED' || verbose[1] === 'XPASS') tally.passed += repeat;
+      else if (verbose[1] === 'FAILED' || verbose[1] === 'ERROR') fail(repeat);
+      else tally.skipped += repeat;
       return;
     }
-    if (runner === 'vitest') {
-      // File lines: " ✓ src/a.test.ts (12 tests) 34ms", " ❯ src/b.test.ts (5 tests | 2 failed) 20ms".
-      // The × lines under a failed file repeat its failures.
-      const file = /^\s*[✓❯×]\s+\S+\s+\((\d+) tests?(?: \| (\d+) failed)?(?: \| (\d+) skipped)?\)/.exec(text);
-      if (file) {
-        const total = Number(file[1]);
-        const failedHere = Number(file[2] || 0);
-        const skippedHere = Number(file[3] || 0);
-        passed += Math.max(0, total - failedHere - skippedHere);
-        skipped += skippedHere;
-        if (failedHere) fail(index, failedHere);
-        return;
+    // Progress lines: "tests/test_a.py ..F.s   [ 40%]"
+    // and their wrapped continuations ("........  [ 56%]").
+    const dots = /^\S+\.py\s+([.FEsxX]+)(?:\s+\[\s*\d+%\])?\s*$/.exec(text)
+      || /^([.FEsxX]+)\s*\[\s*\d+%\]\s*$/.exec(text);
+    if (dots) {
+      for (const mark of dots[1]) {
+        if (mark === '.' || mark === 'X') tally.passed += 1;
+        else if (mark === 'F' || mark === 'E') fail();
+        else tally.skipped += 1;
       }
-      if (FAIL_MARK.test(text) && firstFailureLine === null) firstFailureLine = index;
-      return;
     }
-    if (runner === 'jest') {
-      // Without --verbose jest marks files only; each failed test gets a
-      // "● suite › test" block (but "● Console" is a log block).
-      if (/^\s*FAIL\s/.test(text)) {
-        if (firstFailureLine === null) firstFailureLine = index;
-        return;
-      }
-      if (/^\s*●\s(?!Console\b)/.test(text)) {
-        fail(index, repeat);
-        return;
-      }
-      if (PASS_MARK.test(text)) passed += repeat;
-      else if (FAIL_MARK.test(text) && firstFailureLine === null) firstFailureLine = index;
+    return;
+  }
+  if (runner === 'tap' || (runner === 'node:test' && /^\s*(?:not )?ok \d+ /.test(text))) {
+    const tap = /^\s*(not )?ok \d+\b(.*)$/.exec(text);
+    if (!tap) return;
+    // A subtest line is indented; only top-level results count.
+    if (/^\s/.test(text)) return;
+    if (/#\s*(?:SKIP|TODO)\b/i.test(tap[2])) tally.skipped += repeat;
+    else if (tap[1]) fail(repeat);
+    else tally.passed += repeat;
+    return;
+  }
+  if (runner === 'vitest') {
+    // File lines: " ✓ src/a.test.ts (12 tests) 34ms", " ❯ src/b.test.ts (5 tests | 2 failed) 20ms".
+    // The × lines under a failed file repeat its failures.
+    const file = /^\s*[✓❯×]\s+\S+\s+\((\d+) tests?(?: \| (\d+) failed)?(?: \| (\d+) skipped)?\)/.exec(text);
+    if (file) {
+      const total = Number(file[1]);
+      const failedHere = Number(file[2] || 0);
+      const skippedHere = Number(file[3] || 0);
+      tally.passed += Math.max(0, total - failedHere - skippedHere);
+      tally.skipped += skippedHere;
+      if (failedHere) fail(failedHere);
       return;
     }
-    if (runner === 'playwright' && /^\s*-\s+\d+\s/.test(text)) {
-      skipped += repeat;
+    if (FAIL_MARK.test(text)) markFirst();
+    return;
+  }
+  if (runner === 'jest') {
+    // Without --verbose jest marks files only; each failed test gets a
+    // "● suite › test" block (but "● Console" is a log block).
+    if (/^\s*FAIL\s/.test(text)) {
+      markFirst();
       return;
     }
-    if (PASS_MARK.test(text)) passed += repeat;
-    else if (FAIL_MARK.test(text)) {
-      // node:test's "✖ failing tests:" heads the repeat of the failures.
-      if (/failing tests:\s*$/.test(text)) return;
-      fail(index, repeat);
+    if (/^\s*●\s(?!Console\b)/.test(text)) {
+      fail(repeat);
+      return;
     }
-  });
-  return { passed, failed, skipped, firstFailureLine };
+    if (PASS_MARK.test(text)) tally.passed += repeat;
+    else if (FAIL_MARK.test(text)) markFirst();
+    return;
+  }
+  if (runner === 'playwright' && /^\s*-\s+\d+\s/.test(text)) {
+    tally.skipped += repeat;
+    return;
+  }
+  if (PASS_MARK.test(text)) tally.passed += repeat;
+  else if (FAIL_MARK.test(text)) {
+    // node:test's "✖ failing tests:" heads the repeat of the failures.
+    if (/failing tests:\s*$/.test(text)) return;
+    fail(repeat);
+  }
+}
+
+function liveCounts(runner, texts) {
+  const tally = newTally();
+  texts.forEach((text, index) => countRunnerLine(runner, text, texts.counts[index], tally, index));
+  return tally;
 }
 
 // Where the first failure is told in detail, for a run that has its final
@@ -735,3 +795,56 @@ export function parseRunnerSummary(lines) {
   if (!runner) return null;
   return { runner, ...liveCounts(runner, texts), final: false };
 }
+
+// One-line closing summaries (jest, vitest, pytest, turbo, node:test's
+// last line, Playwright's timed count).
+const CLOSING_LINES = [
+  /^\s*Tests:\s+.*\b\d+\s+total\s*$/,
+  /^\s*Tests\s{2,}.*\(\d+\)\s*$/,
+  /^=+ .*\bin [\d.]+s(?: \([^)]*\))? =+\s*$/,
+  /^\s*Tasks:\s+\d+ successful/,
+  /^\s*(?:ℹ|#)\s+duration_ms\s+[\d.]+\s*$/,
+  /^\s{2}\d+ passed \([\dhms.\s]+\)\s*$/,
+];
+
+// Headers that open a new run: a second run in the same log (a watch rerun,
+// `npm test` twice) counts from its own start. A jest or node:test file line
+// is a header too, but every file of a run prints one.
+function opensRun(runner, text) {
+  if (runner === 'node:test') return /^TAP version \d+/.test(text);
+  return runner === 'playwright' || runner === 'vitest' || runner === 'pytest' || runner === 'turbo';
+}
+
+/**
+ * The live counts of a whole log fed one line at a time, for a log too long
+ * to parse at once (the health poller keeps one per task as the file grows).
+ * `push(line, at)` takes a completed line (a string or `{ text, count }`) and
+ * what names it (a byte offset); `result()` is what parseRunnerSummary says
+ * of a run still going, `{ runner, passed, failed, skipped, firstFailureLine,
+ * final: false }` with `firstFailureLine` the `at` of the first failure, or
+ * null while no runner's header has been seen. Counting starts at the
+ * header: marks before it (a build's ✓ lines) are not a test run's.
+ */
+export function createRunnerTally() {
+  let runner = null;
+  let tally = newTally();
+  // A closing summary was seen: the next header (a jest file line too)
+  // starts the next run.
+  let closed = false;
+  return {
+    push(line, at) {
+      const text = lineTextOf(line);
+      const header = RUNNER_HEADERS.find(([, pattern]) => pattern.test(text));
+      if (header && (!runner || closed || opensRun(header[0], text))) {
+        runner = header[0];
+        tally = newTally();
+        closed = false;
+      }
+      if (runner) countRunnerLine(runner, text, countOf(line), tally, at);
+      if (runner && CLOSING_LINES.some((pattern) => pattern.test(text))) closed = true;
+    },
+    result() {
+      return runner ? { runner, ...tally, final: false } : null;
+    },
+  };
+}

package/shared/windows-system-tools.mjs

@@ -33,6 +33,31 @@ export function readEnvValue(env, name) {
   return '';
 }
 
+/**
+ * On Windows, TEMP and TMP as the relay and its children get them: without
+ * surrounding quotes (`"D:\My Temp"` puts PowerShell into ConstrainedLanguage
+ * mode), and a folder that is not there replaced by the user's own temp
+ * folder. Changes `env` in place; returns what changed, for one log line.
+ */
+export function normalizeTempEnv({ env = process.env, platform = process.platform, existsImpl = fs.existsSync } = {}) {
+  if (platform !== 'win32') return [];
+  const local = readEnvValue(env, 'LOCALAPPDATA') || (readEnvValue(env, 'USERPROFILE') && path.win32.join(readEnvValue(env, 'USERPROFILE'), 'AppData', 'Local'));
+  const fallback = local ? path.win32.join(local, 'Temp') : '';
+  const changes = [];
+  for (const name of ['TEMP', 'TMP']) {
+    const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
+    if (!key) continue;
+    const before = String(env[key]);
+    let value = before.trim().replace(/^"(.*)"$/, '$1').trim();
+    if ((!path.win32.isAbsolute(value) || !existsImpl(value)) && fallback && existsImpl(fallback)) value = fallback;
+    if (value !== before) {
+      env[key] = value;
+      changes.push(`${name} ${before} -> ${value}`);
+    }
+  }
+  return changes;
+}
+
 /** The key PATH is stored under in `env` (`Path` on most Windows machines). */
 export function envPathKey(env, platform = process.platform) {
   if (env && typeof env === 'object') {