@jstn-sdk/rcs 0.1.0 → 0.1.1

package/src/scripts/notify-hook/__tests__/team-worker-posttooluse.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawnSync } from 'node:child_process';
 import { chmod, mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
@@ -8,6 +8,20 @@ import { tmpdir } from 'node:os';
 import { handleTeamWorkerPostToolUseSuccess, teamWorkerPostToolUseInternals } from '../team-worker-posttooluse.js';
 import { readTeamEvents } from '../../../team/state/events.js';
 
+function execFileSyncCompat(command: string, args: string[], options: Parameters<typeof execFileSync>[2] = {}): string {
+  const result = spawnSync(command, args, {
+    encoding: 'utf-8',
+    ...options,
+  });
+  if (result.status !== 0 && !result.error) {
+    throw new Error(String(result.stderr || `spawnSync ${command} failed`));
+  }
+  if (result.status !== 0 && result.error) {
+    throw result.error;
+  }
+  return String(result.stdout ?? '');
+}
+
 async function initWorkerFixture(): Promise<{ cwd: string; stateRoot: string; env: NodeJS.ProcessEnv }> {
   const cwd = await mkdtemp(join(tmpdir(), 'rcs-posttooluse-worker-'));
   execFileSync('git', ['init'], { cwd, stdio: 'ignore' });
@@ -57,7 +71,7 @@ describe('handleTeamWorkerPostToolUseSuccess', () => {
     assert.ok(result.checkpointCommit);
     assert.deepEqual(result.operationKinds, ['auto_checkpoint', 'worker_clean_rebase', 'leader_integration_attempt']);
 
-    const log = execFileSync('git', ['log', '-1', '--pretty=%s'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const log = execFileSyncCompat('git', ['log', '-1', '--pretty=%s'], { cwd: fixture.cwd }).trim();
     assert.equal(log, 'rcs(team): auto-checkpoint worker-1');
 
     const events = await readTeamEvents('demo-team', fixture.cwd, { type: 'worker_integration_attempt_requested' });
@@ -83,11 +97,11 @@ describe('handleTeamWorkerPostToolUseSuccess', () => {
 
   it('records noop without creating a checkpoint commit', async () => {
     const fixture = await initWorkerFixture();
-    const before = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const before = execFileSyncCompat('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd }).trim();
 
     const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
 
-    const after = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const after = execFileSyncCompat('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd }).trim();
     assert.equal(result.status, 'noop');
     assert.equal(result.checkpointCommit, null);
     assert.equal(after, before);
@@ -109,9 +123,9 @@ describe('handleTeamWorkerPostToolUseSuccess', () => {
     await writeFile(join(fixture.cwd, 'feature.txt'), 'feature\n', 'utf-8');
 
     const first = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
-    const headAfterFirst = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const headAfterFirst = execFileSyncCompat('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd }).trim();
     const second = await handleTeamWorkerPostToolUseSuccess({ ...successPayload, tool_use_id: 'tool-2' }, fixture.cwd, fixture.env);
-    const headAfterSecond = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
+    const headAfterSecond = execFileSyncCompat('git', ['rev-parse', 'HEAD'], { cwd: fixture.cwd }).trim();
     const events = await readTeamEvents('demo-team', fixture.cwd, { type: 'worker_integration_attempt_requested' });
 
     assert.equal(first.status, 'applied');
@@ -127,8 +141,8 @@ describe('handleTeamWorkerPostToolUseSuccess', () => {
     await writeFile(join(fixture.cwd, 'unstaged.txt'), 'new work\n', 'utf-8');
 
     const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
-    const staged = execFileSync('git', ['diff', '--name-only', '--cached'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim().split('\n').filter(Boolean);
-    const status = execFileSync('git', ['status', '--porcelain=v1', '-uall'], { cwd: fixture.cwd, encoding: 'utf-8' });
+    const staged = execFileSyncCompat('git', ['diff', '--name-only', '--cached'], { cwd: fixture.cwd }).trim().split('\n').filter(Boolean);
+    const status = execFileSyncCompat('git', ['status', '--porcelain=v1', '-uall'], { cwd: fixture.cwd });
 
     assert.equal(result.status, 'skipped');
     assert.equal(result.reason, 'index_not_clean');
@@ -144,8 +158,8 @@ describe('handleTeamWorkerPostToolUseSuccess', () => {
     await writeFile(join(fixture.cwd, 'commit-fail.txt'), 'must not remain staged\n', 'utf-8');
 
     const result = await handleTeamWorkerPostToolUseSuccess(successPayload, fixture.cwd, fixture.env);
-    const staged = execFileSync('git', ['diff', '--name-only', '--cached'], { cwd: fixture.cwd, encoding: 'utf-8' }).trim();
-    const status = execFileSync('git', ['status', '--porcelain=v1', '-uall'], { cwd: fixture.cwd, encoding: 'utf-8' });
+    const staged = execFileSyncCompat('git', ['diff', '--name-only', '--cached'], { cwd: fixture.cwd }).trim();
+    const status = execFileSyncCompat('git', ['status', '--porcelain=v1', '-uall'], { cwd: fixture.cwd });
 
     assert.equal(result.status, 'skipped');
     assert.match(result.reason ?? '', /^git_commit_failed:/);

package/src/scripts/notify-hook/{ralph-session-resume.ts → forge-session-resume.ts}

@@ -7,25 +7,25 @@ import { resolveCodexPane } from '../tmux-hook-engine.js';
 import { safeString } from './utils.js';
 
 const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
-const RALPH_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled']);
-const RALPH_RESUME_LOCK_STALE_MS = 10_000;
-const RALPH_RESUME_LOCK_TIMEOUT_MS = 5_000;
-const RALPH_RESUME_LOCK_RETRY_MS = 25;
+const FORGE_TERMINAL_PHASES = new Set(['blocked_on_user', 'complete', 'failed', 'cancelled']);
+const FORGE_RESUME_LOCK_STALE_MS = 10_000;
+const FORGE_RESUME_LOCK_TIMEOUT_MS = 5_000;
+const FORGE_RESUME_LOCK_RETRY_MS = 25;
 
-interface RalphSessionResumeHooks {
+interface ForgeSessionResumeHooks {
   afterLockAcquired?: () => Promise<void> | void;
   afterTargetWrite?: () => Promise<void> | void;
 }
 
-interface RalphSessionResumeParams {
+interface ForgeSessionResumeParams {
   stateDir: string;
   payloadSessionId: string;
   payloadThreadId?: string;
   env?: NodeJS.ProcessEnv;
-  hooks?: RalphSessionResumeHooks;
+  hooks?: ForgeSessionResumeHooks;
 }
 
-export interface RalphSessionResumeResult {
+export interface ForgeSessionResumeResult {
   currentRcsSessionId: string;
   resumed: boolean;
   updatedCurrentOwner: boolean;
@@ -34,7 +34,7 @@ export interface RalphSessionResumeResult {
   targetPath?: string;
 }
 
-interface RalphStateCandidate {
+interface ForgeStateCandidate {
   sessionId: string;
   path: string;
   state: Record<string, unknown>;
@@ -51,7 +51,7 @@ async function sleep(ms: number): Promise<void> {
 async function maybeRecoverStaleLock(lockDir: string): Promise<boolean> {
   try {
     const info = await stat(lockDir);
-    if (Date.now() - info.mtimeMs <= RALPH_RESUME_LOCK_STALE_MS) {
+    if (Date.now() - info.mtimeMs <= FORGE_RESUME_LOCK_STALE_MS) {
       return false;
     }
     await rm(lockDir, { recursive: true, force: true });
@@ -61,14 +61,14 @@ async function maybeRecoverStaleLock(lockDir: string): Promise<boolean> {
   }
 }
 
-async function withRalphResumeLock<T>(
+async function withForgeResumeLock<T>(
   stateDir: string,
   fn: () => Promise<T>,
 ): Promise<T | null> {
-  const lockDir = join(stateDir, '.lock.ralph-session-resume');
+  const lockDir = join(stateDir, '.lock.forge-session-resume');
   const ownerPath = join(lockDir, 'owner');
   const ownerToken = lockOwnerToken();
-  const deadline = Date.now() + RALPH_RESUME_LOCK_TIMEOUT_MS;
+  const deadline = Date.now() + FORGE_RESUME_LOCK_TIMEOUT_MS;
   await mkdir(dirname(lockDir), { recursive: true }).catch(() => {});
 
   while (true) {
@@ -86,7 +86,7 @@ async function withRalphResumeLock<T>(
       if (err.code !== 'EEXIST') throw error;
       if (await maybeRecoverStaleLock(lockDir)) continue;
       if (Date.now() > deadline) return null;
-      await sleep(RALPH_RESUME_LOCK_RETRY_MS);
+      await sleep(FORGE_RESUME_LOCK_RETRY_MS);
     }
   }
 
@@ -119,13 +119,13 @@ async function writeJsonAtomic(path: string, value: unknown): Promise<void> {
   await rename(tempPath, path);
 }
 
-function isTerminalRalphPhase(value: unknown): boolean {
-  return RALPH_TERMINAL_PHASES.has(safeString(value).trim().toLowerCase());
+function isTerminalForgePhase(value: unknown): boolean {
+  return FORGE_TERMINAL_PHASES.has(safeString(value).trim().toLowerCase());
 }
 
-function isActiveRalphCandidate(state: Record<string, unknown> | null): state is Record<string, unknown> {
+function isActiveForgeCandidate(state: Record<string, unknown> | null): state is Record<string, unknown> {
   if (!state || typeof state !== 'object') return false;
-  return state.active === true && !isTerminalRalphPhase(state.current_phase);
+  return state.active === true && !isTerminalForgePhase(state.current_phase);
 }
 
 function readSessionIdFromEnvironment(env: NodeJS.ProcessEnv = process.env): string {
@@ -166,23 +166,23 @@ function bindCurrentPane(state: Record<string, unknown>, nowIso: string, env: No
   };
 }
 
-async function scanMatchingRalphCandidates(
+async function scanMatchingForgeCandidates(
   stateDir: string,
   currentRcsSessionId: string,
   payloadSessionId: string,
   payloadThreadId: string,
-): Promise<RalphStateCandidate[]> {
+): Promise<ForgeStateCandidate[]> {
   const sessionsRoot = join(stateDir, 'sessions');
   if (!existsSync(sessionsRoot)) return [];
 
   const entries = await readdir(sessionsRoot, { withFileTypes: true }).catch(() => []);
-  const matches: RalphStateCandidate[] = [];
+  const matches: ForgeStateCandidate[] = [];
   for (const entry of entries) {
     if (!entry.isDirectory() || !SESSION_ID_PATTERN.test(entry.name) || entry.name === currentRcsSessionId) continue;
-    const path = join(sessionsRoot, entry.name, 'ralph-state.json');
+    const path = join(sessionsRoot, entry.name, 'forge-state.json');
     if (!existsSync(path)) continue;
     const state = await readJson(path);
-    if (!isActiveRalphCandidate(state)) continue;
+    if (!isActiveForgeCandidate(state)) continue;
     const ownerSessionId = safeString(state.owner_codex_session_id).trim();
     const ownerThreadId = safeString(state.owner_codex_thread_id).trim();
     if (ownerSessionId) {
@@ -199,14 +199,14 @@ async function scanMatchingRalphCandidates(
   return matches;
 }
 
-export async function reconcileRalphSessionResume({
+export async function reconcileForgeSessionResume({
   stateDir,
   payloadSessionId,
   payloadThreadId = '',
   env = process.env,
   hooks,
-}: RalphSessionResumeParams): Promise<RalphSessionResumeResult> {
-  const lockedResult = await withRalphResumeLock(stateDir, async () => {
+}: ForgeSessionResumeParams): Promise<ForgeSessionResumeResult> {
+  const lockedResult = await withForgeResumeLock(stateDir, async () => {
     await hooks?.afterLockAcquired?.();
 
     const currentRcsSessionId = await readCurrentRcsSessionId(stateDir, env);
@@ -220,16 +220,16 @@ export async function reconcileRalphSessionResume({
     }
 
     const currentSessionDir = join(stateDir, 'sessions', currentRcsSessionId);
-    const currentRalphPath = join(currentSessionDir, 'ralph-state.json');
-    const currentRalphExists = existsSync(currentRalphPath);
-    const currentRalphState = currentRalphExists
-      ? await readJson(currentRalphPath)
+    const currentForgePath = join(currentSessionDir, 'forge-state.json');
+    const currentForgeExists = existsSync(currentForgePath);
+    const currentForgeState = currentForgeExists
+      ? await readJson(currentForgePath)
       : null;
     const nowIso = new Date().toISOString();
 
-    if (currentRalphState && currentRalphState.active === true) {
+    if (currentForgeState && currentForgeState.active === true) {
       let changed = false;
-      const updated: Record<string, unknown> = { ...currentRalphState };
+      const updated: Record<string, unknown> = { ...currentForgeState };
       const normalizedPayloadThreadId = safeString(payloadThreadId).trim();
       if (safeString(updated.owner_rcs_session_id).trim() !== currentRcsSessionId) {
         updated.owner_rcs_session_id = currentRcsSessionId;
@@ -261,24 +261,24 @@ export async function reconcileRalphSessionResume({
         changed = true;
       }
       if (changed) {
-        await writeJsonAtomic(currentRalphPath, updated);
+        await writeJsonAtomic(currentForgePath, updated);
       }
       return {
         currentRcsSessionId,
         resumed: false,
         updatedCurrentOwner: changed,
-        reason: 'current_ralph_active',
-        targetPath: currentRalphPath,
+        reason: 'current_forge_active',
+        targetPath: currentForgePath,
       };
     }
 
-    if (currentRalphExists) {
+    if (currentForgeExists) {
       return {
         currentRcsSessionId,
         resumed: false,
         updatedCurrentOwner: false,
-        reason: currentRalphState ? 'current_ralph_present' : 'current_ralph_unreadable',
-        targetPath: currentRalphPath,
+        reason: currentForgeState ? 'current_forge_present' : 'current_forge_unreadable',
+        targetPath: currentForgePath,
       };
     }
 
@@ -293,7 +293,7 @@ export async function reconcileRalphSessionResume({
       };
     }
 
-    const candidates = await scanMatchingRalphCandidates(
+    const candidates = await scanMatchingForgeCandidates(
       stateDir,
       currentRcsSessionId,
       normalizedPayloadSessionId,
@@ -304,7 +304,7 @@ export async function reconcileRalphSessionResume({
         currentRcsSessionId,
         resumed: false,
         updatedCurrentOwner: false,
-        reason: candidates.length === 0 ? 'no_matching_prior_ralph' : 'multiple_matching_prior_ralphs',
+        reason: candidates.length === 0 ? 'no_matching_prior_forge' : 'multiple_matching_prior_forges',
       };
     }
 
@@ -330,12 +330,12 @@ export async function reconcileRalphSessionResume({
       stop_reason: 'ownership_transferred',
     };
 
-    await writeJsonAtomic(currentRalphPath, nextState);
+    await writeJsonAtomic(currentForgePath, nextState);
     try {
       await hooks?.afterTargetWrite?.();
       await writeJsonAtomic(source.path, previousState);
     } catch (error) {
-      await rm(currentRalphPath, { force: true }).catch(() => {});
+      await rm(currentForgePath, { force: true }).catch(() => {});
       throw error;
     }
 
@@ -345,7 +345,7 @@ export async function reconcileRalphSessionResume({
       updatedCurrentOwner: false,
       reason: 'resumed_same_codex_session',
       sourcePath: source.path,
-      targetPath: currentRalphPath,
+      targetPath: currentForgePath,
     };
   });
 
@@ -360,3 +360,5 @@ export async function reconcileRalphSessionResume({
     reason: 'resume_lock_timeout',
   };
 }
+
+export const reconcileForgeSessionResumeAlias = reconcileForgeSessionResume;

package/src/scripts/notify-hook/team-dispatch.ts

@@ -1,12 +1,12 @@
 // @ts-nocheck
 import { appendFile, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
-import { appendFileSync, existsSync, mkdirSync } from 'fs';
-import { execFileSync } from 'child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'node:url';
 import { safeString } from './utils.js';
 import { isBridgeEnabled, resolveBridgeStateDir, resolveRuntimeBinaryPath } from '../../runtime/bridge.js';
 import { appendTeamDeliveryLog } from '../../team/delivery-log.js';
+import { spawnPlatformCommandSync } from '../../utils/platform-command.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -31,11 +31,38 @@ function runtimeExec(command, stateDir, team) {
   if (!isBridgeEnabled()) return;
   try {
     const binaryPath = resolveRuntimeBinaryPath();
-    execFileSync(binaryPath, ['exec', JSON.stringify(command), `--state-dir=${stateDir}`], {
+    const launchArgs = ['exec', JSON.stringify(command), `--state-dir=${stateDir}`];
+    let launchCommand = binaryPath;
+    let spawnArgs = launchArgs;
+    if (existsSync(binaryPath)) {
+      try {
+        const header = readFileSync(binaryPath, 'utf-8').slice(0, 128);
+        if (/^#!.*\bnode(?:\s|$)/.test(header)) {
+          launchCommand = process.execPath;
+          spawnArgs = [
+            '-e',
+            'const script=process.argv[1];process.argv=[process.execPath,script,...process.argv.slice(2)];require(script);',
+            binaryPath,
+            ...launchArgs,
+          ];
+        } else if (/^#!.*\b(?:bash|sh)(?:\s|$)/.test(header)) {
+          launchCommand = '/bin/bash';
+          spawnArgs = [binaryPath, ...launchArgs];
+        }
+      } catch {
+        // Keep the original binary launch path when the file cannot be inspected.
+      }
+    }
+    const { result } = spawnPlatformCommandSync(launchCommand, spawnArgs, {
+      encoding: 'utf-8',
       timeout: 5000,
-      stdio: ['pipe', 'pipe', 'pipe'],
       windowsHide: true,
     });
+    if (result.status !== 0) {
+      const stderr = safeString(result.stderr).trim();
+      if (stderr) throw new Error(stderr);
+      throw new Error(`failed (exit ${typeof result.status === 'number' ? result.status : 'unknown'})`);
+    }
   } catch (error) {
     recordBridgeFallback({
       stateDir,

package/src/scripts/notify-hook/visual-verdict.ts

@@ -45,13 +45,13 @@ async function maybePersistRuntimeVisualFeedback({ cwd, output, sessionId }: any
   if (candidates.length === 0) return;
 
   const { buildVisualLoopFeedback } = await import('../../visual/verdict.js');
-  const { recordRalphVisualFeedback } = await import('../../ralph/persistence.js');
+  const { recordForgeVisualFeedback } = await import('../../forge/persistence.js');
 
   for (const candidate of candidates) {
     try {
       const parsed = JSON.parse(candidate);
       const feedback = buildVisualLoopFeedback(parsed);
-      await recordRalphVisualFeedback(cwd, feedback, sessionId || undefined);
+      await recordForgeVisualFeedback(cwd, feedback, sessionId || undefined);
       return;
     } catch {
       // Try next candidate
@@ -90,7 +90,7 @@ export async function maybePersistVisualVerdict({ cwd, payload, stateDir, logsDi
   );
   if (!output) return;
 
-  // Runtime visual feedback (JSON/fenced JSON) for ralph-progress persistence.
+  // Runtime visual feedback (JSON/fenced JSON) for forge-progress persistence.
   // Non-fatal and observable via warn-level structured logging.
   try {
     await maybePersistRuntimeVisualFeedback({ cwd, output, sessionId });

package/src/scripts/notify-hook.ts

@@ -49,7 +49,7 @@ import {
 } from './notify-hook/auto-nudge.js';
 import { isManagedRcsSession } from './notify-hook/managed-tmux.js';
 import { logNotifyHookEvent } from './notify-hook/log.js';
-import { reconcileRalphSessionResume } from './notify-hook/ralph-session-resume.js';
+import { reconcileForgeSessionResume } from './notify-hook/forge-session-resume.js';
 import { sendPaneInput } from './notify-hook/team-tmux-guard.js';
 import {
   buildOperationalContext,
@@ -66,7 +66,7 @@ import {
 } from './notify-hook/team-worker.js';
 import { DEFAULT_MARKER } from './tmux-hook-engine.js';
 
-const RALPH_ACTIVE_PROGRESS_PHASES = new Set([
+const FORGE_ACTIVE_PROGRESS_PHASES = new Set([
   'start',
   'started',
   'starting',
@@ -299,11 +299,11 @@ async function main() {
     return;
   }
 
-  // Reconcile Ralph ownership for same-Codex-session continuation before
+  // Reconcile Forge ownership for same-Codex-session continuation before
   // lifecycle counters or injection read the active scope.
   if (!isTeamWorker) {
     try {
-      const resumeResult = await reconcileRalphSessionResume({
+      const resumeResult = await reconcileForgeSessionResume({
         stateDir,
         payloadSessionId,
         payloadThreadId,
@@ -312,7 +312,7 @@ async function main() {
       if (resumeResult.resumed || resumeResult.updatedCurrentOwner) {
         await logNotifyHookEvent(logsDir, {
           timestamp: new Date().toISOString(),
-          type: 'ralph_session_resume',
+          type: 'forge_session_resume',
           reason: resumeResult.reason,
           current_rcs_session_id: resumeResult.currentRcsSessionId || null,
           payload_codex_session_id: payloadSessionId || null,
@@ -326,7 +326,7 @@ async function main() {
       await logNotifyHookEvent(logsDir, {
         timestamp: new Date().toISOString(),
         level: 'warn',
-        type: 'ralph_session_resume_failure',
+        type: 'forge_session_resume_failure',
         payload_codex_session_id: payloadSessionId || null,
         error: error instanceof Error ? error.message : String(error),
       });
@@ -355,12 +355,12 @@ async function main() {
               const currentPhase = typeof state.current_phase === 'string'
                 ? state.current_phase.trim().toLowerCase()
                 : '';
-              const isActiveRalphProgress = (
-                (f === 'ralph-state.json' || state.mode === 'ralph')
-                && RALPH_ACTIVE_PROGRESS_PHASES.has(currentPhase)
+              const isActiveForgeProgress = (
+                (f === 'forge-state.json' || state.mode === 'forge')
+                && FORGE_ACTIVE_PROGRESS_PHASES.has(currentPhase)
               );
 
-              if (isActiveRalphProgress) {
+              if (isActiveForgeProgress) {
                 state.max_iterations = maxIterations + 10;
                 state.max_iterations_auto_expand_count = (asNumber(state.max_iterations_auto_expand_count) || 0) + 1;
                 state.max_iterations_auto_expanded_at = nowIso;

package/src/scripts/run-test-files.ts

@@ -3,7 +3,7 @@ import { readdirSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 
 const DEFAULT_TEST_TIMEOUT_MS = 0;
-const DEFAULT_RUNNER_TIMEOUT_MS = 30 * 60 * 1_000;
+const DEFAULT_RUNNER_TIMEOUT_MS = 0;
 
 function collectTests(path: string, out: string[]): void {
   let stats;