@phnx-labs/agents-cli 1.22.43 → 1.22.44

package/dist/commands/routines.test-fixture.d.ts

@@ -0,0 +1,86 @@
+import { describe } from 'vitest';
+import { spawnSync, spawn } from 'child_process';
+/**
+ * Shared fixture for the routines.*.test.ts suite slices (RUSH-2819).
+ *
+ * routines.test.ts was one 2,249-line file measured at ~194s of test time —
+ * one of the slowest files in CI, serializing an entire fork while every
+ * other selected file finished. The suite is split into topical slices so
+ * vitest's per-file fork parallelism can spread the subprocess-heavy tests
+ * across workers; the helpers each slice shares live here.
+ *
+ * Every test spawns the real CLI (`node --import tsx src/index.ts routines ...`)
+ * against an isolated mkdtemp HOME — no live ~/.agents state, no mocks, no
+ * imported writeJob/readJob. Modeled on `routines-webhook.test.ts`.
+ */
+export declare const REPO_ROOT: string;
+export declare const TSX_IMPORT: string;
+export declare const CLI_ENTRYPOINT: string;
+export declare const describeRoutines: typeof describe.skip;
+/** Provision an isolated HOME with agents.yaml, .system/.git, and optional routines + device registry. */
+export declare function makeHome(opts?: {
+    jobs?: Record<string, unknown>[];
+    projectJobs?: Record<string, unknown>[];
+    registry?: Record<string, unknown>;
+    deviceRoutines?: Record<string, string[]>;
+    /** Full mkdtemp prefix override — the daemon harness scopes its leak sweep by it. */
+    tmpPrefix?: string;
+}): string;
+/** Run `agents routines <args>` against an isolated HOME. */
+export declare function run(home: string, args: string[], extraEnv?: Record<string, string>, cwd?: string): ReturnType<typeof spawnSync>;
+export declare function readRoutineYaml(home: string, name: string): Record<string, unknown> | null;
+export declare function writeRunMeta(home: string, jobName: string, runId: string, meta: Record<string, unknown>): void;
+export declare function isProcessAlive(pid: number): boolean;
+/**
+ * Per-file isolated-daemon harness (RUSH-2367, RUSH-2819). Each slice that
+ * spawns a real `__daemon-run` process against an isolated HOME calls this
+ * once at module scope and registers its own leak detector — the tracked pid
+ * set MUST be private to the file that spawned it, since vitest's per-file
+ * fork isolation means the leak sweep only ever needs to answer for what THIS
+ * file started.
+ *
+ * `fileSlug` MUST be unique per test file: it names the mkdtemp prefix
+ * `makeDaemonHome` uses, and the CI leak sweep matches ONLY that prefix.
+ * The suite slices run in parallel forks, so a sweep over the shared
+ * `agents-routines-test-` prefix would catch a sibling file's still-running
+ * daemon and kill it mid-test — exactly what failed the first CI run of the
+ * RUSH-2819 split (run 32552954164: add's sweep killed a live daemon whose
+ * HOME belonged to a concurrently running slice).
+ */
+export declare function createDaemonHarness(fileSlug: string): {
+    startIsolatedDaemon: (home: string) => {
+        child: ReturnType<typeof spawn>;
+        pidPromise: Promise<number | null>;
+    };
+    stopIsolatedDaemon: (child: ReturnType<typeof spawn>) => Promise<void>;
+    registerLeakDetector: () => void;
+    makeDaemonHome: (opts?: Omit<Parameters<typeof makeHome>[0], 'tmpPrefix'>) => string;
+};
+export declare const baseJob: {
+    name: string;
+    schedule: string;
+    agent: string;
+    prompt: string;
+    cwd: string;
+    enabled: boolean;
+};
+export declare const registry: {
+    'yosemite-s0': {
+        name: string;
+        platform: string;
+    };
+    'mac-mini': {
+        name: string;
+        platform: string;
+    };
+    zion: {
+        name: string;
+        platform: string;
+    };
+};
+export declare function readDeviceRoutines(home: string, device: string): string[];
+export declare function writeDeviceRoutines(home: string, device: string, routines: string[]): void;
+/** Write a minimal project YAML so listProjectDefs() sees it. */
+export declare function writeProject(home: string, name: string): void;
+/** Env that points the projects dir at the isolated home. */
+export declare function projectsEnv(home: string): Record<string, string>;

package/dist/commands/routines.test-fixture.js

@@ -0,0 +1,345 @@
+import { describe, afterAll } from 'vitest';
+import { spawnSync, spawn, execFileSync } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as yaml from 'yaml';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createRequire } from 'module';
+/**
+ * Shared fixture for the routines.*.test.ts suite slices (RUSH-2819).
+ *
+ * routines.test.ts was one 2,249-line file measured at ~194s of test time —
+ * one of the slowest files in CI, serializing an entire fork while every
+ * other selected file finished. The suite is split into topical slices so
+ * vitest's per-file fork parallelism can spread the subprocess-heavy tests
+ * across workers; the helpers each slice shares live here.
+ *
+ * Every test spawns the real CLI (`node --import tsx src/index.ts routines ...`)
+ * against an isolated mkdtemp HOME — no live ~/.agents state, no mocks, no
+ * imported writeJob/readJob. Modeled on `routines-webhook.test.ts`.
+ */
+export const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const require = createRequire(import.meta.url);
+// `--import` takes a module specifier, not a path: a bare Windows path like
+// `D:\a\...\tsx\dist\loader.mjs` is parsed as a URL with protocol 'd:' and the
+// child dies with ERR_UNSUPPORTED_ESM_URL_SCHEME before running the CLI. Same
+// pattern as sessions.test.ts:21.
+export const TSX_IMPORT = pathToFileURL(require.resolve('tsx')).href;
+export const CLI_ENTRYPOINT = path.join(REPO_ROOT, 'src', 'index.ts');
+// win32: subprocess CLI + process-group signals / path spawn assumptions (RUSH-2215).
+export const describeRoutines = process.platform === 'win32' ? describe.skip : describe;
+/** Provision an isolated HOME with agents.yaml, .system/.git, and optional routines + device registry. */
+export function makeHome(opts = {}) {
+    const home = fs.mkdtempSync(opts.tmpPrefix ?? path.join(os.tmpdir(), 'agents-routines-test-'));
+    const agentsDir = path.join(home, '.agents');
+    const routinesDir = path.join(agentsDir, 'routines');
+    const projectDir = path.join(home, 'project');
+    const projectRoutinesDir = path.join(projectDir, '.agents', 'routines');
+    fs.mkdirSync(routinesDir, { recursive: true });
+    fs.mkdirSync(projectRoutinesDir, { recursive: true });
+    fs.mkdirSync(path.join(projectDir, '.git'), { recursive: true });
+    fs.writeFileSync(path.join(agentsDir, 'agents.yaml'), 'agents: {}\n');
+    fs.mkdirSync(path.join(agentsDir, '.system', '.git'), { recursive: true });
+    for (const job of opts.jobs ?? []) {
+        fs.writeFileSync(path.join(routinesDir, `${job.name}.yml`), yaml.stringify(job));
+    }
+    for (const job of opts.projectJobs ?? []) {
+        fs.writeFileSync(path.join(projectRoutinesDir, `${job.name}.yml`), yaml.stringify(job));
+    }
+    if (opts.registry) {
+        const devicesDir = path.join(agentsDir, '.history', 'devices');
+        fs.mkdirSync(devicesDir, { recursive: true });
+        fs.writeFileSync(path.join(devicesDir, 'registry.json'), JSON.stringify(opts.registry));
+    }
+    for (const [device, routines] of Object.entries(opts.deviceRoutines ?? {})) {
+        writeDeviceRoutines(home, device, routines);
+    }
+    return home;
+}
+/** Run `agents routines <args>` against an isolated HOME. */
+export function run(home, args, extraEnv = {}, cwd = REPO_ROOT) {
+    return spawnSync('node', ['--import', TSX_IMPORT, CLI_ENTRYPOINT, 'routines', ...args], {
+        cwd,
+        env: {
+            ...process.env,
+            HOME: home,
+            USERPROFILE: home,
+            // Point the device registry at this test's home (RUSH-2042): getDevicesDir()
+            // reads AGENTS_DEVICES_DIR, and the parent vitest fork exports its own via
+            // setup.ts — override it so the child reads the registry makeHome() wrote.
+            AGENTS_DEVICES_DIR: path.join(home, '.agents', '.history', 'devices'),
+            AGENTS_SKIP_MIGRATION: '1',
+            ...extraEnv,
+        },
+        encoding: 'utf-8',
+        timeout: 30_000,
+    });
+}
+export function readRoutineYaml(home, name) {
+    const p = path.join(home, '.agents', 'routines', `${name}.yml`);
+    if (!fs.existsSync(p))
+        return null;
+    return yaml.parse(fs.readFileSync(p, 'utf-8'));
+}
+export function writeRunMeta(home, jobName, runId, meta) {
+    const runDir = path.join(home, '.agents', '.history', 'runs', jobName, runId);
+    fs.mkdirSync(runDir, { recursive: true });
+    fs.writeFileSync(path.join(runDir, 'meta.json'), JSON.stringify(meta));
+}
+function daemonPidPath(home) {
+    return path.join(home, '.agents', '.cache', 'helpers', 'daemon', 'daemon.pid');
+}
+function readDaemonPid(home) {
+    const pidPath = daemonPidPath(home);
+    if (!fs.existsSync(pidPath))
+        return null;
+    const raw = fs.readFileSync(pidPath, 'utf-8').trim();
+    const pid = parseInt(raw, 10);
+    return isNaN(pid) ? null : pid;
+}
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Per-file isolated-daemon harness (RUSH-2367, RUSH-2819). Each slice that
+ * spawns a real `__daemon-run` process against an isolated HOME calls this
+ * once at module scope and registers its own leak detector — the tracked pid
+ * set MUST be private to the file that spawned it, since vitest's per-file
+ * fork isolation means the leak sweep only ever needs to answer for what THIS
+ * file started.
+ *
+ * `fileSlug` MUST be unique per test file: it names the mkdtemp prefix
+ * `makeDaemonHome` uses, and the CI leak sweep matches ONLY that prefix.
+ * The suite slices run in parallel forks, so a sweep over the shared
+ * `agents-routines-test-` prefix would catch a sibling file's still-running
+ * daemon and kill it mid-test — exactly what failed the first CI run of the
+ * RUSH-2819 split (run 32552954164: add's sweep killed a live daemon whose
+ * HOME belonged to a concurrently running slice).
+ */
+export function createDaemonHarness(fileSlug) {
+    const homePrefix = path.join(os.tmpdir(), `agents-routines-${fileSlug}-`);
+    /**
+     * Every daemon pid spawned via `startIsolatedDaemon` in this file, live for as
+     * long as `stopIsolatedDaemon` has not yet reaped it. Backstops the per-test
+     * try/finally: this file's `afterAll` (registered via `registerLeakDetector`)
+     * asserts the set is empty and force-kills + fails the suite on anything left
+     * in it — a leaked real daemon process is exactly the RUSH-2367 bug (three
+     * left running for up to 3.5 days on a fleet box, invisible to `agents daemon`
+     * because each served its own fixture HOME/registry).
+     */
+    const trackedDaemonPids = new Set();
+    /** Start the real scheduler foreground process against an isolated HOME. */
+    function startIsolatedDaemon(home) {
+        const child = spawn('node', ['--import', 'tsx', 'src/index.ts', '__daemon-run'], {
+            cwd: REPO_ROOT,
+            env: {
+                ...process.env,
+                HOME: home,
+                USERPROFILE: home,
+                // Without this override the daemon inherits the parent vitest process's real
+                // AGENTS_HISTORY_DIR (pointing at ~/.agents/.history). The daemon's SIGTERM
+                // sweep then reads live session records from the production history directory
+                // and kills real tmux-wrapped processes every five-minute tick (RUSH-2545).
+                AGENTS_HISTORY_DIR: path.join(home, '.agents', '.history'),
+                AGENTS_SKIP_MIGRATION: '1',
+            },
+            detached: true,
+            stdio: 'ignore',
+        });
+        if (child.pid)
+            trackedDaemonPids.add(child.pid);
+        const pidPromise = new Promise((resolve) => {
+            const deadline = Date.now() + 15_000;
+            const interval = setInterval(() => {
+                const pid = readDaemonPid(home);
+                if (pid) {
+                    clearInterval(interval);
+                    resolve(pid);
+                    return;
+                }
+                if (Date.now() >= deadline) {
+                    clearInterval(interval);
+                    resolve(null);
+                }
+            }, 50);
+        });
+        return { child, pidPromise };
+    }
+    /** Terminate a daemon process started by startIsolatedDaemon and wait for it to exit. */
+    async function stopIsolatedDaemon(child) {
+        const pid = child.pid;
+        try {
+            if (!pid)
+                return;
+            const closePromise = new Promise((resolve) => {
+                if (child.exitCode !== null || child.signalCode !== null) {
+                    resolve();
+                    return;
+                }
+                child.on('close', () => resolve());
+            });
+            if (child.exitCode !== null || child.signalCode !== null)
+                return;
+            const signalProcessGroup = process.platform !== 'win32';
+            const signal = (sig) => {
+                try {
+                    if (signalProcessGroup) {
+                        process.kill(-pid, sig);
+                    }
+                    else {
+                        child.kill(sig);
+                    }
+                }
+                catch {
+                    // already gone
+                }
+            };
+            signal('SIGTERM');
+            const timer = setTimeout(() => signal('SIGKILL'), 3_000);
+            await closePromise;
+            clearTimeout(timer);
+        }
+        finally {
+            if (pid)
+                trackedDaemonPids.delete(pid);
+        }
+    }
+    /**
+     * Suite-level leak detector (RUSH-2367). Every per-test try/finally above
+     * already reaps its own daemon on success, failure, or a thrown assertion —
+     * but nothing in JS runs if the whole vitest worker is killed externally
+     * before reaching `finally`, which is what actually produced three real
+     * orphaned daemons found alive on a fleet box for up to 3.5 days: their
+     * fixture HOME dirs still existed (the `finally`'s `fs.rmSync` never ran
+     * either), so no amount of in-test cleanup logic would have caught it. This
+     * is the second line of defense, not a substitute for the self-terminate
+     * guard in the daemon itself (`runDaemon`'s state-dir check).
+     *
+     * Two checks, after every test in this file has run:
+     *  1. Always: nothing THIS run spawned via `startIsolatedDaemon` may still be
+     *     alive — `trackedDaemonPids` is only ever non-empty here if a bug (not
+     *     an external kill) let one slip past its own test's `finally`.
+     *  2. CI only: sweep for any OTHER live `__daemon-run` process whose HOME
+     *     sits under THIS FILE's unique `agents-routines-<fileSlug>-` prefix —
+     *     a leak from a previous interrupted run of this same file. Scoped to
+     *     the per-file prefix because sibling slices run in parallel forks and
+     *     legitimately have live daemons under their own prefixes. POSIX-only
+     *     (`/proc`); best-effort and skipped where `/proc` is unavailable
+     *     (macOS CI legs).
+     *
+     * Either check force-kills what it finds and fails the suite — a silent
+     * "still running, we'll get it next time" is exactly how the original three
+     * accumulated.
+     */
+    function registerLeakDetector() {
+        afterAll(() => {
+            const leaks = [];
+            const killDaemon = (pid) => {
+                try {
+                    process.kill(-pid, 'SIGKILL');
+                }
+                catch { /* already gone, or never its own group leader */ }
+                try {
+                    process.kill(pid, 'SIGKILL');
+                }
+                catch { /* already gone */ }
+            };
+            for (const pid of trackedDaemonPids) {
+                if (isProcessAlive(pid)) {
+                    leaks.push(`pid ${pid} (spawned by this test run, never reaped by its own test)`);
+                    killDaemon(pid);
+                }
+            }
+            trackedDaemonPids.clear();
+            if (process.env.CI && process.platform !== 'win32') {
+                const prefix = homePrefix;
+                let psOut = '';
+                try {
+                    psOut = execFileSync('ps', ['-eo', 'pid=,args='], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+                }
+                catch { /* ps unavailable — nothing to sweep */ }
+                for (const line of psOut.split('\n')) {
+                    const m = line.trim().match(/^(\d+)\s+(.*)$/);
+                    if (!m)
+                        continue;
+                    const tokens = m[2].trim().split(/\s+/);
+                    if (tokens[tokens.length - 1] !== '__daemon-run')
+                        continue;
+                    const pid = parseInt(m[1], 10);
+                    if (isNaN(pid))
+                        continue;
+                    let home = null;
+                    try {
+                        const environ = fs.readFileSync(`/proc/${pid}/environ`, 'utf-8');
+                        const homeVar = environ.split('\0').find((v) => v.startsWith('HOME='));
+                        home = homeVar ? homeVar.slice(5) : null;
+                    }
+                    catch {
+                        continue;
+                    } // /proc unreadable (macOS, permissions) — best-effort only
+                    if (!home || !home.startsWith(prefix))
+                        continue;
+                    leaks.push(`pid ${pid} HOME=${home} (leaked from a previous interrupted run of this file)`);
+                    killDaemon(pid);
+                }
+            }
+            if (leaks.length > 0) {
+                throw new Error(`RUSH-2367 leak detector: ${leaks.length} __daemon-run process(es) survived this test file, ` +
+                    `now force-killed: ${leaks.join('; ')}`);
+            }
+        });
+    }
+    /** makeHome under this file's unique prefix — REQUIRED for any home a daemon runs against. */
+    function makeDaemonHome(opts = {}) {
+        return makeHome({ ...opts, tmpPrefix: homePrefix });
+    }
+    return { startIsolatedDaemon, stopIsolatedDaemon, registerLeakDetector, makeDaemonHome };
+}
+export const baseJob = {
+    name: 'test-job',
+    schedule: '0 3 * * *',
+    agent: 'claude',
+    prompt: 'noop',
+    // Agent routines now need an execution anchor to activate (RUSH-2290); home
+    // is a valid one and keeps these device/eligibility fixtures ready.
+    cwd: '~',
+    // Legacy fixture state: tests that specifically cover the new manifest model
+    // materialize a device document below.
+    enabled: true,
+};
+export const registry = {
+    'yosemite-s0': { name: 'yosemite-s0', platform: 'linux' },
+    'mac-mini': { name: 'mac-mini', platform: 'macos' },
+    'zion': { name: 'zion', platform: 'macos' },
+};
+export function readDeviceRoutines(home, device) {
+    const file = path.join(home, '.agents', 'devices', device, 'agents.yaml');
+    if (!fs.existsSync(file))
+        return [];
+    return yaml.parse(fs.readFileSync(file, 'utf-8')).routines ?? [];
+}
+export function writeDeviceRoutines(home, device, routines) {
+    const dir = path.join(home, '.agents', 'devices', device);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'agents.yaml'), yaml.stringify({ routines }));
+}
+// ---------------------------------------------------------------------------
+// Project-tagging tests (--project / --all-projects / list --json projectGroup)
+// ---------------------------------------------------------------------------
+/** Write a minimal project YAML so listProjectDefs() sees it. */
+export function writeProject(home, name) {
+    const dir = path.join(home, '.agents', 'projects');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${name}.yaml`), yaml.stringify({ name }));
+}
+/** Env that points the projects dir at the isolated home. */
+export function projectsEnv(home) {
+    return { AGENTS_PROJECTS_DIR: path.join(home, '.agents', 'projects') };
+}

package/dist/commands/sessions.test-fixture.d.ts

@@ -0,0 +1,24 @@
+import { describe } from 'vitest';
+/**
+ * Shared fixture for the sessions.*.test.ts suite slices (RUSH-2819).
+ *
+ * sessions.test.ts was one 2,600-line file measured at 172s — the single
+ * slowest file in CI, serializing an entire fork while every other selected
+ * file finished. The suite is split into topical slices so vitest's per-file
+ * fork parallelism can spread the subprocess-heavy tests across workers; the
+ * helpers each slice shares live here.
+ */
+export declare const describeLive: typeof describe.skip;
+export declare const repoRoot: string;
+export declare const cliEntry: string;
+export declare const tsxLoaderUrl: string;
+export declare function writeUpdateCache(tempHome: string): void;
+export declare function writeClaudeSession(tempHome: string, projectKey: string, sessionId: string, cwd: string, content: string, timestamp: string): void;
+export declare function writeCodexSession(tempHome: string, sessionId: string, cwd: string, prompt: string, timestamp: string): void;
+export declare function writeGeminiSession(tempHome: string, sessionId: string, cwd: string, prompt: string, timestamp: string, version?: string): void;
+export declare function writeOpenClawSetup(tempHome: string, version?: string): string;
+export declare function runAgents(args: string[], cwd: string, home: string, envOverrides?: Record<string, string>): import("node:child_process").SpawnSyncReturns<string>;
+export declare function outputOf(result: {
+    stdout: string;
+    stderr: string;
+}): string;

package/dist/commands/sessions.test-fixture.js

@@ -0,0 +1,224 @@
+import { describe } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { spawnSync } from 'child_process';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+/**
+ * Shared fixture for the sessions.*.test.ts suite slices (RUSH-2819).
+ *
+ * sessions.test.ts was one 2,600-line file measured at 172s — the single
+ * slowest file in CI, serializing an entire fork while every other selected
+ * file finished. The suite is split into topical slices so vitest's per-file
+ * fork parallelism can spread the subprocess-heavy tests across workers; the
+ * helpers each slice shares live here.
+ */
+// win32: Claude projects path joins absolute cwd with colons (RUSH-2215).
+export const describeLive = process.platform === 'win32' ? describe.skip : describe;
+export const repoRoot = process.cwd();
+export const cliEntry = path.join(repoRoot, 'src', 'index.ts');
+// Run the CLI as `node --import <tsx loader> src/index.ts`: spawning `node`
+// (always on PATH, no .cmd shell launcher) with the tsx ESM loader resolved to
+// an absolute file URL keeps tsx loadable regardless of the spawn cwd (which we
+// point at the project dir). Avoids both the Windows `tsx.cmd`-needs-a-shell
+// problem and shell:true arg-concatenation (which would split multi-word query
+// args like "prompt text").
+export const tsxLoaderUrl = pathToFileURL(createRequire(import.meta.url).resolve('tsx')).href;
+export function writeUpdateCache(tempHome) {
+    const packageJson = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf-8'));
+    fs.mkdirSync(path.join(tempHome, '.agents', '.cache'), { recursive: true });
+    fs.writeFileSync(path.join(tempHome, '.agents', '.cache', '.update-check'), JSON.stringify({ lastCheck: Date.now(), latestVersion: packageJson.version }), 'utf-8');
+    // ensureInitialized() checks for ~/.agents/.system/.git to confirm setup.
+    fs.mkdirSync(path.join(tempHome, '.agents', '.system', '.git'), { recursive: true });
+}
+export function writeClaudeSession(tempHome, projectKey, sessionId, cwd, content, timestamp) {
+    fs.mkdirSync(cwd, { recursive: true });
+    const sessionsDir = path.join(tempHome, '.claude', 'projects', projectKey);
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    fs.writeFileSync(path.join(sessionsDir, `${sessionId}.jsonl`), JSON.stringify({
+        type: 'user',
+        timestamp,
+        cwd,
+        sessionId,
+        version: '2.1.110',
+        gitBranch: 'main',
+        message: { role: 'user', content },
+    }) + '\n', 'utf-8');
+}
+export function writeCodexSession(tempHome, sessionId, cwd, prompt, timestamp) {
+    fs.mkdirSync(cwd, { recursive: true });
+    const sessionsDir = path.join(tempHome, '.codex', 'sessions', '2026', '04', '17');
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    const filePath = path.join(sessionsDir, `rollout-${timestamp.replace(/[:.]/g, '-')}-${sessionId}.jsonl`);
+    const lines = [
+        JSON.stringify({
+            timestamp,
+            type: 'session_meta',
+            payload: {
+                id: sessionId,
+                timestamp,
+                cwd,
+                originator: 'codex_cli_rs',
+                cli_version: '0.113.0',
+                source: 'cli',
+            },
+        }),
+        JSON.stringify({
+            timestamp,
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'developer',
+                content: [{ type: 'input_text', text: '<permissions instructions>\nFilesystem sandboxing.\n</permissions instructions>' }],
+            },
+        }),
+        JSON.stringify({
+            timestamp,
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'user',
+                content: [{ type: 'input_text', text: '<environment_context>\n  <cwd>/tmp/project</cwd>\n  <shell>zsh</shell>\n</environment_context>' }],
+            },
+        }),
+        JSON.stringify({
+            timestamp,
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'user',
+                content: [{ type: 'input_text', text: '<collaboration_mode># Collaboration Mode: Default\n</collaboration_mode>' }],
+            },
+        }),
+        JSON.stringify({
+            timestamp,
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'user',
+                content: [{ type: 'input_text', text: '# AGENTS.md instructions for /tmp/project\n\n<INSTRUCTIONS>\nDo work.\n</INSTRUCTIONS>' }],
+            },
+        }),
+        JSON.stringify({
+            timestamp,
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'user',
+                content: [{ type: 'input_text', text: prompt }],
+            },
+        }),
+        JSON.stringify({
+            timestamp,
+            type: 'response_item',
+            payload: {
+                type: 'message',
+                role: 'assistant',
+                content: [{ type: 'output_text', text: 'Looking into it now.' }],
+            },
+        }),
+    ];
+    fs.writeFileSync(filePath, lines.join('\n') + '\n', 'utf-8');
+}
+export function writeGeminiSession(tempHome, sessionId, cwd, prompt, timestamp, version = '0.29.5') {
+    const versionHome = path.join(tempHome, '.agents', '.history', 'versions', 'gemini', version, 'home');
+    const geminiHome = path.join(versionHome, '.gemini');
+    const projectHash = crypto.createHash('sha256').update(cwd).digest('hex');
+    const chatsDir = path.join(geminiHome, 'tmp', projectHash, 'chats');
+    fs.mkdirSync(cwd, { recursive: true });
+    fs.mkdirSync(chatsDir, { recursive: true });
+    fs.mkdirSync(path.dirname(path.join(tempHome, '.gemini')), { recursive: true });
+    const activeGeminiHome = path.join(tempHome, '.gemini');
+    if (!fs.existsSync(activeGeminiHome)) {
+        fs.symlinkSync(geminiHome, activeGeminiHome);
+    }
+    fs.writeFileSync(path.join(geminiHome, 'projects.json'), JSON.stringify({ projects: [cwd] }), 'utf-8');
+    fs.writeFileSync(path.join(chatsDir, `session-${timestamp.replace(/[:.]/g, '-')}-${sessionId.slice(0, 8)}.json`), JSON.stringify({
+        sessionId,
+        projectHash,
+        startTime: timestamp,
+        lastUpdated: timestamp,
+        messages: [
+            {
+                id: `${sessionId}-user`,
+                timestamp,
+                type: 'user',
+                content: [{ text: prompt }],
+            },
+            {
+                id: `${sessionId}-assistant`,
+                timestamp,
+                type: 'gemini',
+                content: 'Investigating now.',
+                model: 'gemini-3-flash-preview',
+                tokens: { total: 1234 },
+            },
+        ],
+    }, null, 2), 'utf-8');
+}
+export function writeOpenClawSetup(tempHome, version = '2026.3.8') {
+    const managedHome = path.join(tempHome, '.agents', '.history', 'versions', 'openclaw', version, 'home', '.openclaw');
+    fs.mkdirSync(managedHome, { recursive: true });
+    const activeHome = path.join(tempHome, '.openclaw');
+    fs.mkdirSync(path.dirname(activeHome), { recursive: true });
+    if (!fs.existsSync(activeHome)) {
+        fs.symlinkSync(managedHome, activeHome);
+    }
+    const managedWorkspace = path.join(managedHome, 'sergey');
+    fs.mkdirSync(managedWorkspace, { recursive: true });
+    fs.writeFileSync(path.join(managedHome, 'openclaw.json'), JSON.stringify({
+        agents: {
+            list: [
+                { id: 'sergey', workspace: path.join(activeHome, 'sergey') },
+            ],
+        },
+    }, null, 2), 'utf-8');
+    const binDir = path.join(tempHome, 'bin');
+    fs.mkdirSync(binDir, { recursive: true });
+    const openclawBin = path.join(binDir, 'openclaw');
+    fs.writeFileSync(openclawBin, `#!/bin/sh
+if [ "$1" = "--version" ]; then
+  echo "openclaw/${version}"
+  exit 0
+fi
+
+if [ "$1" = "channels" ] && [ "$2" = "status" ]; then
+  echo "- Telegram sergey (Sergey): enabled, configured, running, out:2h ago, mode:polling, token:config"
+  exit 0
+fi
+
+if [ "$1" = "cron" ] && [ "$2" = "list" ]; then
+  echo "ID NAME SCHEDULE NEXT LAST STATUS TARGET AGENT MODEL"
+  echo "12345678-1234-1234-1234-123456789abc sergey-hourly  cron */30 * * * * in 7h  48m ago  ok  isolated  sergey  -"
+  exit 0
+fi
+
+exit 1
+`, 'utf-8');
+    fs.chmodSync(openclawBin, 0o755);
+    return path.join(activeHome, 'sergey');
+}
+export function runAgents(args, cwd, home, envOverrides = {}) {
+    return spawnSync('node', ['--import', tsxLoaderUrl, cliEntry, ...args], {
+        cwd,
+        env: {
+            ...process.env,
+            HOME: home,
+            // os.homedir() (used via homeDir() in discovery) reads USERPROFILE on
+            // Windows and ignores HOME, so set both to redirect the home to tempHome.
+            USERPROFILE: home,
+            PATH: `${path.join(home, 'bin')}${path.delimiter}${process.env.PATH || ''}`,
+            // Some fixtures place files at $HOME/.agents/versions/<agent>/<ver>/ as
+            // legacy / synthetic state. The bootstrap-time migration would otherwise
+            // move those into ~/.agents-system/, breaking workspace-scoped lookups.
+            AGENTS_SKIP_MIGRATION: '1',
+            NODE_NO_WARNINGS: '1',
+            ...envOverrides,
+        },
+        encoding: 'utf-8',
+    });
+}
+export function outputOf(result) {
+    return `${result.stdout}${result.stderr}`;
+}