@shardflux/cli 0.14.5 → 0.15.1

package/dist/browser-login.js

@@ -0,0 +1,145 @@
+/**
+ * `shard auth login --browser` (0.15.0+): sign in by approving this computer in the browser (API contracts §30.5, the
+ * OAuth 2.0 Device Authorization Grant of RFC 8628). POST /v1/auth/device returns a device code (kept in memory only,
+ * never printed) and a user code; the person opens <app>/cli?code=XXXX-XXXX, signs in or signs up there, checks that the
+ * page shows the same code and approves; meanwhile this polls POST /v1/auth/device/token every `interval` seconds
+ * (5 s more after each slow_down) until the API hands over the CLI session, the same kind `shard auth login` saves.
+ *
+ * The Mac app runs it with --json and reads NDJSON on stdout (one object per line):
+ *   {"event":"open","verification_uri_complete":"…","user_code":"ABCD-EFGH","expires_in":600,
+ *    "terms_url":"https://shardflux.dev/terms","privacy_url":"https://shardflux.dev/privacy"}
+ *   {"event":"signed_in","email":"…"}                              (exit 0), or
+ *   {"event":"error","code":"access_denied|expired_token|…","message":"…"}   (exit non-zero)
+ */
+import { ShardfluxApiError, ShardfluxProtocolError } from '@shardflux/sdk';
+const DEVICE_CODE = /^sfd_[A-Za-z0-9_-]{43}$/;
+const USER_CODE = /^[BCDFGHJKLMNPQRSTVWXZ]{4}-[BCDFGHJKLMNPQRSTVWXZ]{4}$/;
+const SESSION_TOKEN = /^sfu_[A-Za-z0-9_-]{43}$/;
+/** RFC 8628 §3.5: every slow_down adds at least 5 seconds to the interval (more when the server names a longer one). */
+const SLOW_DOWN_STEP_SECONDS = 5;
+const REQUEST_TIMEOUT_MS = 15_000;
+/** Polls keep going this long past expires_in while the API cannot be reached (it answers expired_token itself). */
+const EXPIRY_GRACE_MS = 30_000;
+/** The default name on the approval page: "shard CLI on <hostname>". */
+export function defaultClientName(hostname) {
+    const host = hostname.trim().replace(/\.local$/i, '');
+    return host ? `shard CLI on ${host}`.slice(0, 100) : 'shard CLI';
+}
+async function call(opts, path, body, signal) {
+    const doFetch = opts.fetch ?? fetch;
+    const headers = { 'content-type': 'application/json', accept: 'application/json' };
+    if (opts.userAgent)
+        headers['user-agent'] = opts.userAgent;
+    const base = (opts.baseUrl ?? 'https://api.shardflux.dev').replace(/\/+$/, '');
+    const res = await doFetch(`${base}${path}`, { method: 'POST', headers, body: JSON.stringify(body), signal });
+    const text = await res.text();
+    let parsed = null;
+    if (text.length > 0) {
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new ShardfluxProtocolError(`POST ${path} answered ${res.status} without JSON`, res.status, 'api');
+        }
+    }
+    const ra = Number(res.headers.get('retry-after'));
+    return { status: res.status, body: parsed, retryAfter: Number.isFinite(ra) && ra > 0 ? ra : undefined };
+}
+function apiError(status, body, retryAfter, path) {
+    const e = body?.error;
+    if (!e || typeof e.code !== 'string' || typeof e.message !== 'string')
+        return new ShardfluxProtocolError(`POST ${path} answered ${status} without an error body`, status, 'api');
+    return new ShardfluxApiError(status, body, 'api', retryAfter);
+}
+/** An error the CLI raises itself in the API's shape (the request expired while the API could not be reached). */
+function localError(code, message) {
+    return new ShardfluxApiError(400, { error: { code, message, request_id: '', retryable: false } }, 'api');
+}
+/** POST /v1/auth/device. */
+export async function startDeviceAuthorization(opts, clientName, signal) {
+    const path = '/v1/auth/device';
+    const r = await call(opts, path, { client_name: clientName }, signal);
+    if (r.status !== 200)
+        throw apiError(r.status, r.body, r.retryAfter, path);
+    const d = r.body;
+    if (!d ||
+        typeof d.device_code !== 'string' ||
+        !DEVICE_CODE.test(d.device_code) ||
+        typeof d.user_code !== 'string' ||
+        !USER_CODE.test(d.user_code) ||
+        typeof d.verification_uri_complete !== 'string' ||
+        !/^https?:\/\//.test(d.verification_uri_complete) ||
+        typeof d.expires_in !== 'number' ||
+        typeof d.interval !== 'number') {
+        throw new ShardfluxProtocolError(`POST ${path} answered without a device authorization`, r.status, 'api');
+    }
+    return d;
+}
+/** No answer: the connection failed or timed out, or something other than the API answered (a proxy's HTML page). */
+function transient(err) {
+    if (err instanceof TypeError && err.message === 'fetch failed')
+        return true;
+    return err instanceof Error && (err.name === 'TimeoutError' || err.name === 'ShardfluxProtocolError');
+}
+/**
+ * Polls POST /v1/auth/device/token until the session is issued (RFC 8628 §3.4, §3.5): waits `interval` seconds before
+ * each poll; a slow_down adds 5 s (or takes the server's longer interval); a connection failure or timeout doubles the
+ * interval (exponential backoff); 429 waits its Retry-After and 5xx the interval, while the request can still be
+ * approved. Stops on access_denied, expired_token and every other refusal (thrown as the API's error), and when the
+ * request's lifetime has passed.
+ */
+export async function waitForDeviceSession(opts, d, poll) {
+    const path = '/v1/auth/device/token';
+    const now = poll.now ?? Date.now;
+    const deadline = now() + d.expires_in * 1000 + EXPIRY_GRACE_MS;
+    const timeoutMs = poll.requestTimeoutMs ?? REQUEST_TIMEOUT_MS;
+    const unreachable = () => localError('expired_token', 'The sign-in request expired before Shardflux could be reached. Start again: shard auth login --browser');
+    let interval = Math.max(1, d.interval);
+    let wait = interval;
+    for (;;) {
+        await poll.sleep(wait * 1000);
+        if (poll.signal.aborted)
+            throw poll.signal.reason instanceof Error ? poll.signal.reason : new DOMException('Interrupted.', 'AbortError');
+        wait = interval;
+        let r;
+        try {
+            r = await call(opts, path, { device_code: d.device_code }, AbortSignal.any([poll.signal, AbortSignal.timeout(timeoutMs)]));
+        }
+        catch (err) {
+            if (poll.signal.aborted || !transient(err))
+                throw err;
+            // RFC 8628 §3.5: back off exponentially on connection timeouts.
+            interval *= 2;
+            wait = interval;
+            if (now() + wait * 1000 > deadline)
+                throw unreachable();
+            continue;
+        }
+        if (r.status === 200) {
+            const s = r.body;
+            if (!s || typeof s.session_token !== 'string' || !SESSION_TOKEN.test(s.session_token) || !s.user || typeof s.user.email !== 'string') {
+                throw new ShardfluxProtocolError(`POST ${path} answered 200 without a session`, 200, 'api');
+            }
+            return s;
+        }
+        const err = apiError(r.status, r.body, r.retryAfter, path);
+        const code = err instanceof ShardfluxApiError ? err.code : null;
+        if (code === 'authorization_pending')
+            continue;
+        if (code === 'slow_down') {
+            const given = err.details?.interval;
+            interval = Math.max(interval + SLOW_DOWN_STEP_SECONDS, typeof given === 'number' && Number.isFinite(given) ? given : 0);
+            wait = interval;
+            continue;
+        }
+        if (code === 'rate_limited' || r.status >= 500) {
+            const after = err instanceof ShardfluxApiError ? err.retryAfterSeconds : undefined;
+            wait = Math.max(interval, after ?? interval);
+            // Waiting past the request's lifetime cannot succeed: report the refusal now.
+            if (now() + wait * 1000 > deadline)
+                throw err;
+            continue;
+        }
+        throw err;
+    }
+}

package/dist/codex-cloud.d.ts

@@ -0,0 +1,49 @@
+import type { CodexCloudTask } from '@shardflux/sdk';
+import type { Ctx, Handler } from './commands.js';
+import type { Values } from './args.js';
+import type { Conversation } from './conversations.js';
+import type { InitialImage } from './initial-prompt.js';
+/** Only provider-returned task ids enter the registered Codex deep-link route. */
+export declare function openCodexThread(task: CodexCloudTask, env: Ctx['io']['env']): Promise<void>;
+export declare function submitCloudInitialPrompt(ctx: Ctx, c: Conversation, prompt: string, workspaceKey: string): Promise<void>;
+/** How long the account's Codex remote device may take to come up before it counts as stuck. */
+export declare const CODEX_STARTING_LIMIT_MS: number;
+export type CodexConnectorView = {
+    state: string;
+    environment_id: string | null;
+    last_error: string | null;
+    workspace_id?: string;
+    generation?: string;
+};
+/**
+ * The account's Codex remote device, as a person needs to know it: missing or disabled (enable it), starting (wait),
+ * ready, or failed, stuck (starting for longer than CODEX_STARTING_LIMIT_MS) or attention (retry once).
+ */
+export type CodexHealth = 'missing' | 'disabled' | 'starting' | 'ready' | 'failed' | 'stuck' | 'attention';
+/** When a connector generation started: its UUIDv7 time. */
+export declare function generationStarted(generation: string | undefined): number | null;
+export declare function codexHealth(c: CodexConnectorView | null, workspaceState: string | null, now?: number): CodexHealth;
+/** The connector and the state of its workspace (failed, deleted when it is gone). Never wakes anything. */
+export declare function readCodexConnector(ctx: Ctx): Promise<{
+    connector: CodexConnectorView | null;
+    workspaceState: string | null;
+}>;
+/**
+ * Starts the remote device again, once: disable, wait until it is disabled (bounded), enable. One executor per account
+ * throughout. Used by Retry in setup and Settings; never called in a loop.
+ */
+export declare function restartCodexConnector(ctx: Ctx, timeoutMs?: number): Promise<CodexConnectorView>;
+export declare function ensureCodexCloud(ctx: Ctx): Promise<{
+    organization_id: string;
+    project_id: string;
+    workspace_id: string;
+    generation: string;
+    enabled: boolean;
+    state: "starting" | "ready" | "attention" | "disabling" | "disabled";
+    environment_id: string | null;
+    last_error: string | null;
+    last_seen_at: string | null;
+}>;
+export declare function launchCodexCloud(ctx: Ctx, values: Values, path: string, images?: readonly InitialImage[]): Promise<number>;
+export declare function openCodexConversation(ctx: Ctx, c: Conversation): Promise<number>;
+export declare const CODEX_CLOUD_HANDLERS: Record<string, Handler>;

package/dist/codex-cloud.js

@@ -0,0 +1,157 @@
+import { spawn } from 'node:child_process';
+import { CodedError, UsageError } from "./errors.js";
+import { json } from "./format.js";
+import { syncAgentCredentials } from "./agent-credentials.js";
+import { createConversation, resumeConversation } from "./conversations.js";
+import { AgentStateStore } from "./agent-state.js";
+import { ensureProjectGit } from "./project-git.js";
+import { gitRunner } from "./agent-git.js";
+import { projectIdentity } from "./project-identity.js";
+import { uploadInitialImages } from "./initial-prompt.js";
+/** Only provider-returned task ids enter the registered Codex deep-link route. */
+export async function openCodexThread(task, env) {
+    const url = threadLink(task);
+    const program = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'rundll32' : 'xdg-open';
+    const args = process.platform === 'win32' ? ['url.dll,FileProtocolHandler', url] : [url];
+    const child = spawn(program, args, { env, stdio: 'ignore' });
+    await new Promise((resolve, reject) => { const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('Codex app did not open in time')); }, 10000); child.once('error', error => { clearTimeout(timer); reject(error); }); child.once('exit', code => { clearTimeout(timer); if (code === 0)
+        resolve();
+    else
+        reject(new Error(`Open this Cloud thread in Codex: ${task.desktop_url}`)); }); });
+}
+function threadLink(task) {
+    if (!task.thread_id || !/^[a-zA-Z0-9_-]{1,128}$/.test(task.thread_id) || task.desktop_url !== `codex://threads/${encodeURIComponent(task.thread_id)}?hostId=durable`)
+        throw new Error('Cloud returned an invalid Codex thread link');
+    return task.desktop_url;
+}
+export async function submitCloudInitialPrompt(ctx, c, prompt, workspaceKey) {
+    try {
+        await ctx.cloud().conversations.send(c.id, prompt, { idempotencyKey: `codex-initial-${c.id}`, signal: ctx.signal });
+    }
+    catch {
+        throw new CodedError('initial_prompt_failed', `Created ${workspaceKey}, but the initial prompt could not be confirmed. Open that conversation before starting another.`, undefined, { workspace_key: workspaceKey, conversation_id: c.id, submitted: null });
+    }
+}
+async function output(ctx, c, task, submitted = false) {
+    const url = threadLink(task);
+    if (ctx.json) {
+        ctx.io.stdout.write(json({ conversation: c, cloud: task, url, ...(submitted ? { initial_prompt: { submitted: true } } : {}) }));
+        return;
+    }
+    ctx.io.stdout.write(`${c.key}\n${task.desktop_url}\n`);
+    await openCodexThread(task, ctx.io.env);
+}
+/** How long the account's Codex remote device may take to come up before it counts as stuck. */
+export const CODEX_STARTING_LIMIT_MS = 5 * 60_000;
+/** When a connector generation started: its UUIDv7 time. */
+export function generationStarted(generation) {
+    const hex = generation?.replace(/-/g, '').slice(0, 12);
+    return hex && /^[0-9a-f]{12}$/i.test(hex) ? parseInt(hex, 16) : null;
+}
+export function codexHealth(c, workspaceState, now = Date.now()) {
+    if (!c)
+        return 'missing';
+    if (c.state === 'disabled' || c.state === 'disabling')
+        return 'disabled';
+    if (c.state === 'ready' && c.environment_id)
+        return 'ready';
+    const started = generationStarted(c.generation);
+    const late = started !== null && now - started > CODEX_STARTING_LIMIT_MS;
+    // A new device reports attention while its executor is still connecting, and the API tries again every 10 s on its
+    // own (staging: about 40 s after enable, ready 9 s later). Until the starting limit that is starting, not Retry.
+    if (c.state === 'attention')
+        return late || started === null ? 'attention' : 'starting';
+    if (workspaceState === 'failed' || workspaceState === 'deleted')
+        return 'failed';
+    if (late)
+        return 'stuck';
+    return 'starting';
+}
+/** The connector and the state of its workspace (failed, deleted when it is gone). Never wakes anything. */
+export async function readCodexConnector(ctx) {
+    const connector = await ctx.cloud().codex.connector().catch((error) => { if (error.status === 404)
+        return null; throw error; });
+    if (!connector?.workspace_id || connector.state !== 'starting')
+        return { connector, workspaceState: null };
+    const workspace = await ctx.cloud().workspaces.get(connector.workspace_id).then(w => w.data.deleted_at ? 'deleted' : w.data.observed_state, (error) => { if (error.status === 404)
+        return 'deleted'; throw error; });
+    return { connector, workspaceState: workspace };
+}
+/**
+ * Starts the remote device again, once: disable, wait until it is disabled (bounded), enable. One executor per account
+ * throughout. Used by Retry in setup and Settings; never called in a loop.
+ */
+export async function restartCodexConnector(ctx, timeoutMs = 60_000) {
+    const codex = ctx.cloud().codex;
+    await codex.disable();
+    const end = Date.now() + timeoutMs;
+    for (;;) {
+        const current = await codex.connector().catch((error) => { if (error.status === 404)
+            return null; throw error; });
+        if (!current || current.state === 'disabled')
+            break;
+        if (Date.now() >= end)
+            throw new UsageError('Codex is still switching off; try again in a minute.');
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    return await codex.enable({ signal: ctx.signal });
+}
+export async function ensureCodexCloud(ctx) {
+    await syncAgentCredentials(ctx.cloud(), { home: ctx.io.env.HOME ?? ctx.io.env.USERPROFILE, redact: value => ctx.addSecret(value) });
+    // A remote device that failed or is stuck starting gets one new start; a starting or ready one is left alone.
+    const { connector, workspaceState } = await readCodexConnector(ctx);
+    const health = codexHealth(connector, workspaceState);
+    if (health === 'failed' || health === 'stuck' || health === 'attention')
+        await restartCodexConnector(ctx);
+    else
+        await ctx.cloud().codex.enable({ signal: ctx.signal });
+    return ctx.cloud().codex.waitConnector({ timeoutMs: ctx.wakeTimeoutMs, signal: ctx.signal });
+}
+export async function launchCodexCloud(ctx, values, path, images = []) {
+    if (values.in !== undefined && values.in !== 'codex-app')
+        throw new UsageError('New Codex conversations open in Codex Cloud. Omit --in or use --in codex-app.');
+    if (values.like !== undefined)
+        throw new UsageError('Choose the project directory with --path; new Codex conversations use its latest machine template.');
+    const project = projectIdentity(path);
+    await ensureProjectGit(ctx, project.folder);
+    await gitRunner(project.folder, { ...process.env, ...ctx.io.env }, ctx.signal)(['rev-parse', 'HEAD']);
+    await ensureCodexCloud(ctx);
+    const created = await createConversation(ctx, path, 'codex', 'codex-cloud', typeof values.name === 'string' ? values.name : undefined);
+    const c = created.conversation;
+    // --computer: the conversation VM's desktop is on before Codex starts, so the thread gets the computer tools.
+    if (values.computer === true)
+        await created.workspace.setComputerUse(true);
+    // The thread's tools run in this VM, so its first message can name the images by their VM paths.
+    await uploadInitialImages(created.workspace.cell(), images, ctx.signal);
+    // Idempotency follows the durable conversation, including a lost response.
+    await ctx.cloud().codex.admit(c.id, { idempotencyKey: `codex-${c.id}`, signal: ctx.signal });
+    const task = await ctx.cloud().codex.waitTask(c.id, { timeoutMs: ctx.wakeTimeoutMs, signal: ctx.signal });
+    new AgentStateStore(ctx.store.dir).save(project.remote ?? project.folder, 'codex');
+    const submitted = typeof values.initialPrompt === 'string';
+    if (submitted)
+        await submitCloudInitialPrompt(ctx, c, values.initialPrompt, created.workspace.key);
+    await output(ctx, c, task, submitted);
+    return 0;
+}
+export async function openCodexConversation(ctx, c) {
+    if (c.state === 'done' || c.state === 'archived' || c.ended_at) {
+        c = await resumeConversation(ctx, c);
+        await ctx.cloud().codex.admit(c.id, { idempotencyKey: `codex-resume-${c.id}-${c.workspace_id}`, signal: ctx.signal });
+        const task = await ctx.cloud().codex.waitTask(c.id, { timeoutMs: ctx.wakeTimeoutMs, signal: ctx.signal });
+        await output(ctx, c, task);
+        return 0;
+    }
+    const task = await ctx.cloud().codex.task(c.id);
+    if (task.state === 'canceled')
+        throw new UsageError('This conversation’s Codex executor was removed. Start a new Cloud conversation; its saved branch and history remain available.');
+    if (task.state !== 'active' || !task.thread_id)
+        throw new UsageError('This Cloud conversation is not ready; inspect it with shard agents codex status.');
+    // Opening provider history does not wake the conversation VM.
+    await output(ctx, c, task);
+    return 0;
+}
+export const CODEX_CLOUD_HANDLERS = {
+    'agents codex status': async (ctx) => { ctx.io.stdout.write(json(await ctx.cloud().codex.connector())); return 0; },
+    'agents codex enable': async (ctx) => { ctx.io.stdout.write(json(await ensureCodexCloud(ctx))); return 0; },
+    'agents codex disable': async (ctx) => { ctx.io.stdout.write(json(await ctx.cloud().codex.disable())); return 0; },
+};

package/dist/command-center-actions.js

@@ -11,6 +11,7 @@ import { agentName as gitAgentName } from "./agent-git.js";
 import { randomUUID } from 'node:crypto';
 import { prepareAgentMachine } from "./agent-machine.js";
 import { OperationFailedError } from '@shardflux/sdk';
+import { launchConversationProject } from "./conversation-terminal.js";
 /** L9 can register target-specific handlers after detecting the installed applications. */
 export async function availableTargets(ctx) {
     const { HANDLERS } = await import("./handlers.js");
@@ -33,6 +34,12 @@ export async function agentAction(ctx, action, values, args) {
 }
 export const CENTER_HANDLERS = {
     async 'agents new'(ctx, values, [ref]) {
+        if ((values.prompt !== undefined || values['prompt-file'] !== undefined || values.image !== undefined) && (ref || values.name !== undefined || values.like !== undefined || values.in !== undefined)) {
+            throw new UsageError('An initial prompt needs a new conversation: use agents new --path <folder> --app claude|codex.');
+        }
+        if (!ref && values.name === undefined && values.like === undefined && values.in === undefined) {
+            return launchConversationProject(ctx, values, [str(values.path) ?? './', ...(str(values.app) ? [str(values.app)] : [])]);
+        }
         if (values.name !== undefined || !ref || values.path !== undefined) {
             return launchProject(ctx, { ...values, ...(ref && values.like === undefined ? { like: ref } : {}) }, [str(values.path) ?? './', ...(str(values.app) ? [str(values.app)] : [])]);
         }

package/dist/command-center-renderer.d.ts

@@ -15,6 +15,9 @@ export interface CenterView {
     };
     extraKeys: string[];
     menubarHint?: string;
+    doneCount?: number;
+    showDone?: boolean;
+    now?: number;
 }
 export declare function renderCenter(view: CenterView, columns: number, height: number, color?: boolean): string[];
 /** Cursor-address changed lines only; polling an unchanged view writes nothing. */

package/dist/command-center-renderer.js

@@ -1,6 +1,6 @@
-import { browserSessionNote, workspaceBrowserSessionNote } from "./browser-profile-copy.js";
 import { agentName } from "./command-center-model.js";
 import { setupLine } from "./assisted-setup.js";
+import { terminalBrand } from "./terminal-brand.js";
 /** API titles and local input never get to send terminal controls. */
 export function plain(value) { return [...value].map(ch => { const code = ch.codePointAt(0); return code < 32 || code >= 127 && code <= 159 ? ' ' : ch; }).join(''); }
 function width(ch) {
@@ -23,63 +23,67 @@ export function clip(value, columns) {
 export function renderCenter(view, columns, height, color = true) {
     columns = Math.max(1, Math.min(1000, columns));
     height = Math.max(1, Math.min(1000, height));
-    const lines = ['shardflux  /  Cloud agents', view.filter ? `Filter: ${view.filter}` : 'Projects / agents / sessions  ·  attention first', ''];
+    const prompt = view.prompt?.replace(/ {2}\(Enter accepts, Esc cancels\)$/, '');
+    const lines = [prompt ? `  ${prompt}` : '  + New conversation  n', view.filter && !prompt ? `  Search: ${view.filter}` : ''];
+    const selectedRow = view.rows.find(row => row.id === view.selected);
     const body = [];
-    const sites = (profiles) => [...new Set(profiles.flatMap(p => p.sites.map(s => s.site)))].join(', ');
-    // Project-scoped sessions reach every row, so they are named once; workspace-scoped ones sit under their agent.
-    const shared = [...new Map(view.rows.flatMap(r => r.browserProfiles ?? []).filter(p => p.scope === 'project').map(p => [p.name, p])).values()];
-    if (shared.length)
-        body.push({ text: `Browser sessions: ${sites(shared)}` }, { text: browserSessionNote }, { text: '' });
-    let project = '', key = '';
+    const age = (since) => {
+        if (!since || !Number.isFinite(Date.parse(since)))
+            return '';
+        const minutes = Math.max(0, Math.floor(((view.now ?? Date.now()) - Date.parse(since)) / 60000));
+        return minutes < 1 ? 'now' : minutes < 60 ? `${minutes}m` : minutes < 1440 ? `${Math.floor(minutes / 60)}h` : `${Math.floor(minutes / 1440)}d`;
+    };
     for (const row of view.rows) {
-        if (row.project !== project) {
-            project = row.project;
-            key = '';
-            body.push({ text: project });
-            const setup = view.rows.find(candidate => candidate.project === project && candidate.setup)?.setup;
-            const progress = setup && setupLine(project, setup);
-            if (progress)
-                body.push({ text: `  ${progress}` });
-        }
         if (row.start) {
-            body.push({ text: '  Start Claude here (or Codex)', id: row.id });
+            body.push({ text: `  Start a conversation in ${row.project}`, id: row.id });
             continue;
         }
-        if (row.key !== key) {
-            key = row.key;
-            body.push({ text: `  ${agentName(key, row.agent?.labels ?? row.workspace?.labels ?? {})}` });
-            const own = row.browserProfiles?.filter(p => p.scope !== 'project') ?? [];
-            if (own.length)
-                body.push({ text: `    Browser sessions: ${sites(own)}` }, { text: `    ${workspaceBrowserSessionNote}` });
-        }
-        const session = row.agent?.id.slice(row.agent.workspace_id.length + 1);
-        body.push({ text: `    [${row.badge}] ${row.agent ? `${row.agent.app}  ${clip(session, 12)}  ${row.agent.title || 'Untitled session'}` : 'Open a session'}`, id: row.id, badge: row.badge });
+        const title = row.agent?.title || (row.agent ? 'Untitled conversation' : 'Open a conversation');
+        const project = `${row.project}/${agentName(row.key, row.agent?.labels ?? row.workspace?.labels ?? {})}`;
+        const suffix = `  ${clip(project, Math.max(8, Math.floor(columns * 0.29)))}  ${age(row.agent?.since).padStart(3)}`;
+        const titleWidth = Math.max(1, columns - suffix.length - 7);
+        const name = clip(title, titleWidth);
+        body.push({ text: `  ${row.badge === 'done' ? '○' : '●'}  ${name}${' '.repeat(Math.max(0, titleWidth - [...name].reduce((n, c) => n + width(c), 0)))}${suffix}`, id: row.id, badge: row.badge });
     }
     if (!body.length)
-        body.push({ text: view.filter ? 'No matching sessions. Press / to change the filter.' : 'No cloud agents. Run shard <path> to start a project.' });
+        body.push({ text: view.message ? '' : view.filter ? '  No conversations match this search.' : '  Your conversations will appear here.' });
     const available = Math.max(0, height - 7);
     const selected = body.findIndex(r => r.id === view.selected);
     const start = Math.max(0, selected - available + 1);
     for (const row of body.slice(start, start + available)) {
-        let line = clip(`${row.id === view.selected ? '>' : ' '} ${row.text}`, columns);
+        let line = clip(row.text, columns);
+        if (row.id && row.id === view.selected)
+            line = '›' + line.slice(1);
         if (color) {
             if (row.badge === 'working')
-                line = `\x1b[38;5;208m${line}\x1b[0m`;
+                line = line.replace('●', `\x1b[38;2;${terminalBrand['sf-molten'].join(';')}m●\x1b[39m`);
             if (row.badge === 'done')
-                line = `\x1b[2m${line}\x1b[0m`;
-            if (row.id === view.selected)
-                line = `\x1b[7m${line}\x1b[0m`;
+                line = `\x1b[2m${line}\x1b[22m`;
+            if (row.id && row.id === view.selected)
+                line = `\x1b[48;2;${terminalBrand['sf-overlay'].join(';')}m\x1b[38;2;${terminalBrand['sf-ink'].join(';')}m${line}\x1b[0m`;
         }
         lines.push(line);
     }
-    while (lines.length < height - 4)
+    while (lines.length < height - 5)
         lines.push('');
-    lines.push(view.prompt ?? view.message, 'Enter open  o open in  n session  N agent  f fork  p park', `l logs  / filter  q quit${view.extraKeys.length ? `  ${view.extraKeys.join('  ')}` : ''}`, view.menubarHint ?? `${view.rows.length} session${view.rows.length === 1 ? '' : 's'}  ·  refresh every 2s`);
+    const profiles = selectedRow?.browserProfiles ?? [];
+    const sites = (rows) => [...new Set(rows.flatMap(p => p.sites.map(s => s.site)))].join(', ');
+    const sharedSites = sites(profiles.filter(p => p.scope === 'project'));
+    const ownSites = sites(profiles.filter(p => p.scope !== 'project'));
+    const browserContext = [sharedSites && `project · ${sharedSites}`, ownSites && `conversation · ${ownSites}`].filter(Boolean).join('  |  ');
+    const detail = selectedRow && !selectedRow.start ? `${selectedRow.agent?.app === 'codex' ? 'Codex' : 'Claude'} · ${selectedRow.badge}${selectedRow.agent?.last_message ? ` · ${selectedRow.agent.last_message}` : ''}` : '';
+    lines.push(view.message || (selectedRow?.setup && setupLine(selectedRow.project, selectedRow.setup)) || detail);
+    lines.push(browserContext ? `  Browser sign-ins: ${browserContext}` : '');
+    lines.push(view.doneCount ? `  ${view.doneCount} done  ·  D ${view.showDone ? 'hide' : 'show'}` : '');
+    lines.push(view.prompt ? '  Enter continue   Esc cancel' : '  Enter open   n new   / search   ? actions   q quit');
+    lines.push(view.menubarHint ?? '');
     if (view.menu) {
-        const menu = [view.menu.title, ...view.menu.items.map((item, i) => `${i === view.menu.selected ? '>' : ' '} ${item}`), 'Enter select  Esc cancel'];
-        const offset = Math.min(3, Math.max(0, height - menu.length));
+        const menu = [`  ${view.menu.title}`, '', ...view.menu.items.map((item, i) => `${i === view.menu.selected ? '›' : ' '} ${item}`), '', '  Enter select   Esc back'];
+        const offset = Math.min(2, Math.max(0, height - menu.length));
         for (let i = 0; i < menu.length && offset + i < height; i++)
-            lines[offset + i] = menu[i];
+            lines[offset + i] = clip(menu[i], columns);
+        for (let i = offset + menu.length; i < height - 1; i++)
+            lines[i] = '';
     }
     return lines.slice(0, height).map(line => line.includes('\x1b') ? line : clip(line, columns));
 }