@phnx-labs/agents-cli 1.22.42 → 1.22.44

package/dist/commands/sessions-picker.js

@@ -386,7 +386,7 @@ export function buildPreview(session) {
     const header = formatHeader(safe, events);
     const body = parseError
         ? '  ' + chalk.red(`Failed to parse session: ${parseError}`)
-        : formatCompactPreview(digest, safe);
+        : formatCompactPreview(digest, safe, events);
     const output = [header, '', body].filter(Boolean).join('\n');
     previewCache.set(cacheKey, output);
     return output;
@@ -398,8 +398,6 @@ const DOT = chalk.gray(' · ');
 function formatHeader(session, events) {
     const model = extractModel(events) || session.model;
     const { createdAgo, lastActiveAgo, duration } = extractTiming(session, events);
-    const totalMessages = session.messageCount ?? countMessages(events);
-    const totalTokens = session.tokenCount;
     // Line 1: Agent v version · shortId · model · account
     const line1 = [];
     line1.push(chalk.gray(`${displayAgent(session.agent)}${session.version ? ` v${session.version}` : ''}`));
@@ -429,18 +427,6 @@ function formatHeader(session, events) {
         line2.push(chalk.gray('last active ') + chalk.white(lastActiveAgo + ' ago'));
     if (duration)
         line2.push(chalk.gray('lasted ') + chalk.white(duration));
-    // Line 3: N msgs · T tokens · [label ·] uuid
-    const line3 = [];
-    if (totalMessages !== undefined) {
-        line3.push(chalk.bold.white(String(totalMessages)) + chalk.gray(` msg${totalMessages === 1 ? '' : 's'}`));
-    }
-    if (totalTokens !== undefined) {
-        line3.push(chalk.bold.white(formatTokens(totalTokens)) + chalk.gray(' tokens'));
-    }
-    if (session.filePath)
-        line3.push(chalk.gray(linkPath(session.filePath, session.id)));
-    else
-        line3.push(chalk.gray(session.id));
     // Line 4: ticket + PR — clickable when a URL is resolvable (OSC 8 hyperlink),
     // plain text otherwise. Only rendered when the session carries either.
     const line4 = [];
@@ -467,7 +453,6 @@ function formatHeader(session, events) {
         ...titleLines,
         line1.join(DOT),
         line2.join(DOT),
-        line3.join(DOT),
         ...(line4.length ? [line4.join(DOT)] : []),
     ].join('\n');
 }
@@ -512,24 +497,20 @@ export function formatTeamLineage(session) {
 }
 function formatMetaOnlyBody(session) {
     const lines = [];
+    const termWidth = process.stdout.columns || 80;
+    const valueWidth = termWidth - VERB_GUTTER - 5;
+    // Same verb-led rows as the digest body (RUSH-2757), from SessionMeta alone.
     if (session.topic) {
-        lines.push(chalk.cyan('Prompt: ') + chalk.white(truncate(session.topic.trim(), (process.stdout.columns || 80) - 12)));
-    }
-    const teamLine = formatTeamLineage(session);
-    if (teamLine) {
-        lines.push(chalk.cyan('Team:   ') + teamLine);
+        lines.push(verbLabel('Asked') + chalk.white(`"${truncate(session.topic.trim(), valueWidth)}"`));
     }
     const compact = formatTodoCompact(session.todos);
-    if (compact) {
-        lines.push(chalk.cyan('Todos: ') + chalk.white(compact));
+    const teamLine = formatTeamLineage(session);
+    const doing = [compact ? chalk.white(compact) : '', teamLine].filter(Boolean);
+    if (doing.length) {
+        lines.push(verbLabel('Doing') + doing.join(DOT));
     }
-    const termWidth = process.stdout.columns || 80;
     for (const l of session.todos?.items?.length ? renderTodos(session.todos.items, termWidth) : []) {
-        lines.push(l);
-    }
-    const dirs = session.recentDirectoriesTouched?.slice(0, DIRS_TOUCHED_MAX) ?? [];
-    if (dirs.length) {
-        lines.push(chalk.cyan('Dirs:   ') + chalk.white(dirs.join(chalk.gray(' · '))));
+        lines.push('  ' + l);
     }
     // `plan` is the whole ExitPlanMode markdown, not a path — summarize it. The
     // pane is height-clamped anyway, so pasting the blob would just push every
@@ -537,10 +518,24 @@ function formatMetaOnlyBody(session) {
     const planLines = session.plan?.trim() ? session.plan.trim().split('\n') : [];
     if (planLines.length) {
         const head = truncate(planLines[0].replace(/^#+\s*/, ''), termWidth - 20);
-        lines.push(chalk.cyan('Plan:   ') + chalk.white(head) + chalk.gray(` · ${planLines.length} lines`));
+        lines.push(verbLabel('Made') + chalk.white(head) + chalk.gray(` · plan, ${planLines.length} lines`));
     }
-    if (lines.length === 0)
-        return '';
+    const cost = [];
+    if (session.messageCount !== undefined) {
+        cost.push(chalk.white(String(session.messageCount)) + chalk.gray(` msg${session.messageCount === 1 ? '' : 's'}`));
+    }
+    if (session.tokenCount !== undefined) {
+        cost.push(chalk.white(formatTokens(session.tokenCount)) + chalk.gray(' tokens'));
+    }
+    if (cost.length) {
+        lines.push(verbLabel('Cost') + cost.join(DOT));
+    }
+    const dirs = session.recentDirectoriesTouched?.slice(0, DIRS_TOUCHED_MAX) ?? [];
+    const details = [
+        session.filePath ? chalk.gray(linkPath(session.filePath, session.id.slice(0, 8))) : chalk.gray(session.id.slice(0, 8)),
+        ...dirs.map(d => chalk.gray(d)),
+    ];
+    lines.push(verbLabel('Details ▸') + joinWidthCapped(details, valueWidth));
     return lines.map(l => '  ' + l).join('\n');
 }
 function extractModel(events) {
@@ -720,45 +715,42 @@ export function buildSessionPreviewDigest(events, session) {
         test: detectTestResult(events),
     };
 }
-function formatCompactPreview(digest, session) {
+// Verb-led row gutter (RUSH-2757): every row label pads to this width so the
+// values align into one scannable column. 'Details ▸' is the widest label.
+const VERB_GUTTER = 9;
+function verbLabel(v) {
+    return chalk.cyan(v.padEnd(VERB_GUTTER)) + ' ';
+}
+function formatCompactPreview(digest, session, events) {
     const { firstUser, lastAssistant, filesRead, toolCalls, planFile, todos, subAgentCount, toolTags, changes: chg, dirs, repos, artifacts, skills, plugins, hooks, links, errorCount, firstError, toolHistogram: hist, test, } = digest;
     const lines = [];
     const termWidth = process.stdout.columns || 80;
-    // Originating user prompt (first non-system user turn).
-    if (firstUser) {
-        const first = extractSessionTopic(firstUser) || cleanSessionPrompt(firstUser).split('\n').find(l => l.trim()) || '';
-        if (first) {
-            lines.push(chalk.cyan('Prompt: ') + chalk.white(truncate(first.trim(), termWidth - 12)));
-        }
+    const valueWidth = termWidth - VERB_GUTTER - 5;
+    // Asked — the originating user prompt (first non-system user turn), quoted.
+    const asked = firstUser
+        ? (extractSessionTopic(firstUser) || cleanSessionPrompt(firstUser).split('\n').find(l => l.trim()) || '')
+        : (session.topic && !isSyntheticUserMessage(session.topic) ? session.topic : '');
+    if (asked.trim()) {
+        lines.push(verbLabel('Asked') + chalk.white(`"${truncate(asked.trim(), valueWidth)}"`));
     }
-    else if (session.topic && !isSyntheticUserMessage(session.topic)) {
-        lines.push(chalk.cyan('Prompt: ') + chalk.white(truncate(session.topic.trim(), termWidth - 12)));
-    }
-    // Compact checklist: ✓done/total · current step (RUSH-2045).
+    // Doing — the work in motion: checklist progress (RUSH-2045), team lineage,
+    // sub-agent fan-out. The full checklist renders indented beneath.
     const compact = formatTodoCompact(todos);
-    if (compact) {
-        lines.push(chalk.cyan('Todos: ') + chalk.white(compact));
-    }
-    const todosRendered = todos?.items?.length ? renderTodos(todos.items, termWidth) : [];
-    if (todosRendered.length > 0) {
-        for (const l of todosRendered)
-            lines.push('  ' + l);
-    }
-    // Recent activity = directories touched (not raw tool calls). Prefer a
-    // parser-supplied dirsTouched when present; else derive from event paths.
-    // Width-capped: a long Dirs line used to wrap and swamp the whole pane.
-    if (dirs.length) {
-        lines.push(chalk.cyan('Dirs:    ') + joinWidthCapped(dirs, termWidth - 12));
-    }
-    // Repos worked in (basename of each `.git` root under the touched paths).
-    if (repos.length) {
-        lines.push(chalk.cyan('Repos:   ') + chalk.white(repos.slice(0, 4).join(chalk.gray(' · '))));
-    }
     const teamLine = formatTeamLineage(session);
-    if (teamLine) {
-        lines.push(chalk.cyan('Team:    ') + teamLine);
+    const doing = [
+        compact ? chalk.white(compact) : '',
+        teamLine,
+        subAgentCount ? chalk.gray(`${subAgentCount} sub-agent${subAgentCount === 1 ? '' : 's'}`) : '',
+    ].filter(Boolean);
+    if (doing.length) {
+        lines.push(verbLabel('Doing') + doing.join(DOT));
     }
-    const activity = [];
+    const todosRendered = todos?.items?.length ? renderTodos(todos.items, termWidth) : [];
+    for (const l of todosRendered)
+        lines.push('  ' + l);
+    // Made — what the session produced: file deltas, reads, artifacts (named +
+    // clickable), the plan file, and the PR when the session carries one.
+    const made = [];
     const changed = chg.created + chg.modified + chg.deleted;
     if (changed) {
         const parts = [
@@ -766,71 +758,61 @@ function formatCompactPreview(digest, session) {
             chg.modified ? chalk.yellow(`~${chg.modified}`) : '',
             chg.deleted ? chalk.red(`−${chg.deleted}`) : '',
         ].filter(Boolean).join(' ');
-        activity.push(`${parts} ${chalk.gray('changed')}`);
+        made.push(`${parts} ${chalk.gray('changed')}`);
     }
     if (filesRead)
-        activity.push(chalk.gray(`${filesRead} read`));
-    if (toolCalls)
-        activity.push(chalk.gray(`${toolCalls} tool${toolCalls === 1 ? '' : 's'}`));
-    if (activity.length) {
-        lines.push(chalk.cyan('Changes:  ') + activity.join(chalk.gray(' · ')));
-    }
-    // Documents the session produced (`.agents/artifacts|plans|reports`, other
-    // *.md/*.html creations) — the files a human browses later, named + clickable.
+        made.push(chalk.gray(`${filesRead} read`));
     if (artifacts.length) {
-        const shown = artifacts.slice(0, 5).map(a => linkPath(a.path, a.basename));
-        const more = artifacts.length > 5 ? chalk.gray(` · +${artifacts.length - 5} more`) : '';
-        lines.push(chalk.cyan('Artifacts: ') + shown.join(chalk.gray(' · ')) + more);
-    }
-    // Skills invoked (plugin skills included — they ride the same Skill tool).
-    if (skills.length) {
-        const shown = skills.slice(0, 5).map(s => chalk.white(s.name) + (s.count > 1 ? chalk.gray(` ×${s.count}`) : ''));
-        const more = skills.length > 5 ? chalk.gray(` · +${skills.length - 5} more`) : '';
-        lines.push(chalk.cyan('Skills:  ') + shown.join(chalk.gray(' · ')) + more);
+        const shown = artifacts.slice(0, 2).map(a => linkPath(a.path, a.basename));
+        const more = artifacts.length > 2 ? chalk.gray(` +${artifacts.length - 2}`) : '';
+        made.push(shown.join(chalk.gray(' · ')) + more);
     }
-    if (plugins.length) {
-        lines.push(chalk.cyan('Plugins: ') + chalk.white(plugins.slice(0, 5).join(chalk.gray(' · '))));
+    if (planFile) {
+        made.push(chalk.white(linkPath(planFile, planFile.split('/').pop() || planFile)));
     }
-    // Hooks fired (Claude transcripts record firings; other harnesses don't).
-    if (hooks.length) {
-        const shown = hooks.slice(0, 4).map(h => chalk.white(h.name) + (h.count > 1 ? chalk.gray(` ×${h.count}`) : '') + (h.failed ? chalk.red(` (${h.failed} failed)`) : ''));
-        const more = hooks.length > 4 ? chalk.gray(` · +${hooks.length - 4} more`) : '';
-        lines.push(chalk.cyan('Hooks:   ') + shown.join(chalk.gray(' · ')) + more);
+    if (session.prUrl) {
+        made.push(chalk.blue(linkUrl(session.prUrl, session.prNumber ? `PR#${session.prNumber}` : 'PR')));
     }
-    // Links mentioned in the conversation — clickable (OSC 8), tracker-classified.
-    if (links.length) {
-        const shown = links.slice(0, 5).map(l => chalk.blue(linkUrl(l.url, l.label)));
-        const more = links.length > 5 ? chalk.gray(` · +${links.length - 5} more`) : '';
-        lines.push(chalk.cyan('Links:   ') + shown.join(chalk.gray(' · ')) + more);
+    if (made.length) {
+        lines.push(verbLabel('Made') + made.join(DOT));
     }
-    // Error tally, mirroring the full summary's Errors section in one line.
+    // Health — error tally + the last test/build verdict; absent when both clean.
+    const health = [];
     if (errorCount) {
-        lines.push(chalk.cyan('Errors:  ') + chalk.red(`${errorCount} failure${errorCount === 1 ? '' : 's'}`) + chalk.gray(` — first: ${firstError || 'unknown'}`));
-    }
-    const metadata = [
-        ...toolTags,
-        subAgentCount ? `${subAgentCount} sub-agent${subAgentCount === 1 ? '' : 's'}` : '',
-    ].filter(Boolean);
-    if (metadata.length) {
-        lines.push(chalk.cyan('Meta:     ') + chalk.gray(metadata.join(' · ')));
-    }
-    // Tool mix (top 4) — what kind of work this was.
-    if (hist.length) {
-        lines.push(chalk.cyan('Tools:    ') + chalk.gray(hist.map(h => `${h.tool} ${h.count}`).join(' · ')));
+        health.push(chalk.red(`${errorCount} failure${errorCount === 1 ? '' : 's'}`) + chalk.gray(` — first: ${firstError || 'unknown'}`));
     }
-    // Last test/build verdict.
     if (test?.ok) {
         const bits = [
             test.passed !== undefined ? chalk.green(`${test.passed} pass`) : '',
             test.failed ? chalk.red(`${test.failed} fail`) : '',
         ].filter(Boolean).join(chalk.gray(' · '));
         const mark = test.failed ? chalk.red('✗') : chalk.green('✓');
-        lines.push(chalk.cyan('Tests:    ') + `${mark} ${test.runner}${bits ? ' ' + bits : ''}`);
+        health.push(`${mark} ${test.runner}${bits ? ' ' + bits : ''}`);
     }
-    if (planFile) {
-        const basename = planFile.split('/').pop() || planFile;
-        lines.push(chalk.cyan('Plan: ') + chalk.white(linkPath(planFile, basename)));
+    if (health.length) {
+        lines.push(verbLabel('Health') + health.join(DOT));
+    }
+    // Cost — volume: messages, tokens (moved here from the header's old line 3),
+    // and the top of the tool mix.
+    const totalMessages = session.messageCount ?? (events ? countMessages(events) : undefined);
+    const cost = [];
+    if (totalMessages !== undefined) {
+        cost.push(chalk.white(String(totalMessages)) + chalk.gray(` msg${totalMessages === 1 ? '' : 's'}`));
+    }
+    if (session.tokenCount !== undefined) {
+        cost.push(chalk.white(formatTokens(session.tokenCount)) + chalk.gray(' tokens'));
+    }
+    if (hist.length) {
+        cost.push(chalk.gray(hist.map(h => `${h.tool} ${h.count}`).join(' · ')));
     }
+    else if (toolCalls) {
+        cost.push(chalk.gray(`${toolCalls} tool${toolCalls === 1 ? '' : 's'}`));
+    }
+    if (cost.length) {
+        lines.push(verbLabel('Cost') + cost.join(DOT));
+    }
+    // Latest — the agent's last message, full and wrapped to the pane (the densest
+    // line in the preview; parts 1-2 of RUSH-2757 made it wrap instead of clip).
     if (lastAssistant) {
         const maxLines = todosRendered.length > 0 || compact ? LAST_RESPONSE_MAX_LINES_WITH_TODOS : LAST_RESPONSE_MAX_LINES;
         // Content sits at column 4 (outer body indent + the '  ' prefix below), so
@@ -838,14 +820,28 @@ function formatCompactPreview(digest, session) {
         const rendered = renderLastResponse(lastAssistant, maxLines, terminalWidth() - 4);
         if (rendered.length > 0) {
             lines.push('');
-            lines.push(chalk.cyan('Last response:'));
+            lines.push(chalk.cyan('Latest'));
             for (const l of rendered)
                 lines.push('  ' + l);
         }
     }
-    if (lines.length === 0) {
-        lines.push(chalk.gray('No activity recorded in this session.'));
-    }
+    // Details ▸ — the folded long tail: session id, skills, plugins, hooks, links,
+    // dirs, repos, capability tags. One width-capped line instead of seven labeled
+    // rows (a long tail used to wrap and swamp the whole pane); links stay
+    // clickable (OSC 8), hook failures stay red. Full lists go to the cap — it is
+    // the ONLY bounding, so its `… +N more` tail accounts for every hidden item
+    // (pre-slicing here made overflow vanish with no trace).
+    const details = [
+        session.filePath ? chalk.gray(linkPath(session.filePath, session.id.slice(0, 8))) : chalk.gray(session.id.slice(0, 8)),
+        ...skills.map(s => chalk.white(s.name) + (s.count > 1 ? chalk.gray(` ×${s.count}`) : '')),
+        ...plugins.map(p => chalk.white(p)),
+        ...hooks.map(h => chalk.white(h.name) + (h.failed ? chalk.red(` (${h.failed} failed)`) : '')),
+        ...links.map(l => chalk.blue(linkUrl(l.url, l.label))),
+        ...dirs.map(d => chalk.gray(d)),
+        ...repos.map(r => chalk.gray(r)),
+        ...toolTags.map(t => chalk.gray(t)),
+    ];
+    lines.push(verbLabel('Details ▸') + joinWidthCapped(details, valueWidth));
     return lines.map(l => '  ' + l).join('\n');
 }
 function classifySessionTool(tool, command) {
@@ -928,20 +924,26 @@ const SLUG_WORKTREE_RE = /--agents-worktrees-(.+)$/;
  * Join display tokens with ` · `, stopping before the line exceeds `maxWidth`
  * and appending `… +N more` for the rest. Keeps the Dirs line on one row.
  */
+/**
+ * Join pre-styled items with ` · ` up to a visible width, then `… +N more`.
+ * Width is measured ANSI-aware (stringWidth), so colored / OSC 8-linked items
+ * are not miscounted; items arrive already styled and are not recolored.
+ */
 function joinWidthCapped(items, maxWidth) {
-    const sep = ' · ';
     let out = '';
+    let width = 0;
     let shown = 0;
     for (const item of items) {
-        const next = shown === 0 ? item : out + sep + item;
-        if (shown > 0 && next.length > maxWidth)
+        const itemWidth = stringWidth(item);
+        const nextWidth = shown === 0 ? itemWidth : width + 3 + itemWidth;
+        if (shown > 0 && nextWidth > maxWidth)
             break;
-        out = next;
+        out = shown === 0 ? item : out + DOT + item;
+        width = nextWidth;
         shown++;
     }
     const remaining = items.length - shown;
-    const suffix = remaining > 0 ? ` … +${remaining} more` : '';
-    return chalk.white(out) + (suffix ? chalk.gray(suffix) : '');
+    return out + (remaining > 0 ? chalk.gray(` … +${remaining} more`) : '');
 }
 /** Relativize a file path to its parent dir, short enough for one preview line. */
 export function relativizeDir(filePath, cwd) {

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}`;
+}

package/dist/commands/setup.js

@@ -25,6 +25,8 @@ import { registerSetupMineCommand } from './setup-mine.js';
 import { registerSetupSecretsCommand } from './setup-secrets.js';
 import { registerSetupFleetCommand } from './setup-fleet.js';
 import { registerSetupWatchdogCommand, runWatchdogSetupWizard } from './setup-watchdog.js';
+import { registerAliasCommand } from './alias.js';
+import { registerBetaCommands } from './beta.js';
 import { runPreferencesStep } from './setup-preferences.js';
 import { getConfiguredDefaultProfileName, getProfile, getAutoDetectedProfile, isProfileLaunchableHere } from '../lib/browser/profiles.js';
 import { listInstalledBrowsers } from '../lib/browser/chrome.js';
@@ -362,7 +364,7 @@ export function registerSetupCommand(program) {
         .description('Set up agents-cli, or re-open the capability onboarding hub.')
         .option('-f, --force', 'Re-run setup even if ~/.agents/.system/ already exists (use with caution)')
         .option('--no-system-repo', 'Skip cloning the system repo (you must populate ~/.agents/.system/ yourself)');
-    // Capability subcommands: `agents setup browser|computer|mine|secrets|fleet`.
+    // Capability subcommands: `agents setup browser|computer|mine|secrets|fleet|alias|beta`.
     // Share/artifact publishing is set up by `agents artifacts setup` (RUSH-2580);
     // the hub below still offers it as a phase via runShareWizard.
     registerSetupBrowserCommand(setupCmd);
@@ -371,6 +373,8 @@ export function registerSetupCommand(program) {
     registerSetupSecretsCommand(setupCmd);
     registerSetupFleetCommand(setupCmd);
     registerSetupWatchdogCommand(setupCmd);
+    registerAliasCommand(setupCmd);
+    registerBetaCommands(setupCmd);
     setupCmd.command('status')
         .description('Show setup readiness for core, browser, computer, secrets, fleet, share, watchdog, and preferences.')
         .option('--json', 'print machine-readable JSON')
@@ -397,6 +401,8 @@ export function registerSetupCommand(program) {
       agents setup secrets
       agents setup fleet
       agents setup watchdog
+      agents setup alias add teams
+      agents setup beta enable factory
     `,
         notes: `
       What it does:
@@ -412,6 +418,8 @@ export function registerSetupCommand(program) {
         agents setup secrets     # choose secrets backend/policy defaults + import
         agents setup fleet       # discover Tailscale devices + configure SSH access
         agents setup watchdog    # choose which devices run the daemon watchdog pass
+        agents setup alias add teams  # PATH shorthand: teams runs agents teams
+        agents setup beta enable factory  # opt into preview features
 
       To install CLIs from agents.yaml and sync resources into version homes:
         agents sync --local -y