@shardflux/cli 0.20.0 → 0.23.0

package/dist/codex-cloud.js

@@ -1,29 +1,34 @@
+import { randomUUID } from 'node:crypto';
 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, getConversation, recordedChoice, resumeConversation } from "./conversations.js";
+import { createConversation, conversationWorkspace, getConversation, localConversations, recordedChoice, resumeConversation, seedConversation } from "./conversations.js";
 import { CHOICE_PENDING, choiceReport, hasChoice, modelChoice } from "./agent-models.js";
 import { AgentStateStore } from "./agent-state.js";
+import { installedTargets } from "./agent-targets.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) {
+/** Cloud threads open in the browser, preserving the durable provider destination on every OS. */
+export async function openCodexThread(task, env, platform = process.platform) {
     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 program = platform === 'darwin' ? 'open' : platform === 'win32' ? 'rundll32' : 'xdg-open';
+    const args = 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)
+    await new Promise((resolve, reject) => { const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('Cloud chat 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}`)); }); });
+        reject(new Error(`Open this Cloud thread: ${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`)
+    if (!task.thread_id || !/^[a-zA-Z0-9_-]{1,128}$/.test(task.thread_id))
         throw new Error('Cloud returned an invalid Codex thread link');
-    return task.desktop_url;
+    const url = `https://chatgpt.com/local/${encodeURIComponent(task.thread_id)}`;
+    if (task.web_url != null && task.web_url !== url || task.desktop_url != null && task.desktop_url !== `codex://threads/${encodeURIComponent(task.thread_id)}?hostId=durable`)
+        throw new Error('Cloud returned an invalid Codex thread link');
+    return url;
 }
 export async function submitCloudInitialPrompt(ctx, c, prompt, workspaceKey) {
     try {
@@ -33,19 +38,32 @@ export async function submitCloudInitialPrompt(ctx, c, prompt, workspaceKey) {
         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 });
     }
 }
-/** Prints the Cloud thread (and its link) and opens it in the Codex app; --json prints it instead. */
+/** Prints the Cloud thread (and its link) and opens it in your browser; --json prints it instead. */
 export async function printCloudThread(ctx, c, task, submitted = false, choice) { return output(ctx, c, task, submitted, choice); }
+/** Whether this computer has the Codex app, which opens a Cloud thread's codex:// link (on Linux 0.23.0+). */
+const codexAppHere = (env) => installedTargets(env ?? {}).clients.includes('codex-app');
+/**
+ * A Cloud conversation where the Codex app cannot show it (0.23.0+): where its chat lives, whether it waits for an
+ * answer, and how to answer and follow it from here. Never a new start: the conversation exists.
+ */
+export function cloudChatElsewhere(c, url) {
+    return `${c.key} runs in Codex Cloud${c.state === 'needs_you' ? ' and is waiting for your answer' : ''}. Its chat opens in your browser: ${url}\n` +
+        `Answer it from here: shard conversations send ${c.id} "<your answer>"\nWhere it stands: shard conversations get ${c.id}\n`;
+}
 async function output(ctx, c, task, submitted = false, choice) {
-    const url = threadLink(task);
+    const url = threadLink(task), app = codexAppHere(ctx.io.env);
     // model_choice (0.17.0+): an admitted thread's record keeps the model and effort only when Cloud started it with them.
     const applied = hasChoice(choice) ? await cloudChoiceApplied(ctx, c, choice) : true;
+    // codex_app and reply_command (0.23.0+): without the Codex app, the conversation is answered with that command.
     if (ctx.json) {
-        ctx.io.stdout.write(json({ conversation: c, cloud: task, url, ...(submitted ? { initial_prompt: { submitted: true } } : {}), ...(hasChoice(choice) ? { model_choice: choiceReport(choice, applied) } : {}) }));
+        ctx.io.stdout.write(json({ conversation: c, cloud: task, url, previous_threads: (task.previous_thread_ids ?? []).map(id => ({ thread_id: id, url: threadLink({ thread_id: id }) })), codex_app: app, reply_command: ['shard', 'conversations', 'send', c.id, '<message>'], ...(submitted ? { initial_prompt: { submitted: true } } : {}), ...(hasChoice(choice) ? { model_choice: choiceReport(choice, applied) } : {}) }));
         return;
     }
     if (!applied)
         ctx.io.stderr.write(`${CHOICE_PENDING}\n`);
-    ctx.io.stdout.write(`${c.key}\n${task.desktop_url}\n`);
+    ctx.io.stdout.write(`${c.key}\n${url}\n`);
+    for (const id of task.previous_thread_ids ?? [])
+        ctx.io.stdout.write(`Earlier history: https://chatgpt.com/local/${encodeURIComponent(id)}\n`);
     await openCodexThread(task, ctx.io.env);
 }
 async function cloudChoiceApplied(ctx, c, choice) {
@@ -128,24 +146,75 @@ export async function launchCodexCloud(ctx, values, path, images = []) {
     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, choice);
-    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, choice);
-    return 0;
+    const patch = (id, update) => new AgentStateStore(ctx.store.dir).update(doc => {
+        const records = doc.conversations;
+        const r = records[id];
+        if (r?.cloud_start)
+            r.cloud_start = { ...r.cloud_start, ...update };
+    });
+    let release;
+    try {
+        const created = await createConversation(ctx, path, 'codex', 'codex-cloud', typeof values.name === 'string' ? values.name : undefined, choice, undefined, undefined, undefined, {
+            accepted(c) {
+                new AgentStateStore(ctx.store.dir).update(doc => {
+                    const records = doc.conversations;
+                    records[c.id].cloud_start = { ...(typeof values.initialPrompt === 'string' ? { prompt: values.initialPrompt } : {}), computer: values.computer === true, attachments_pending: images.length > 0, state: 'accepted', heartbeat_at: Date.now() };
+                });
+                release = carryStart(ctx, c.id);
+            },
+            async beforeSeed(ws, c) {
+                if (values.computer === true)
+                    await ws.setComputerUse(true);
+                await uploadInitialImages(ws.cell(), images, ctx.signal);
+                patch(c.id, { attachments_pending: false });
+            },
+        });
+        const c = created.conversation;
+        // --computer: the conversation VM's desktop is on before Codex starts, so the thread gets the computer tools.
+        // The thread's tools run in this VM, so its first message can name the images by their VM paths.
+        // 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);
+        patch(c.id, { state: 'active', submitted, prompt: undefined });
+        await output(ctx, c, task, submitted, choice);
+        return 0;
+    }
+    finally {
+        release?.();
+    }
 }
-export async function openCodexConversation(ctx, c) {
+/**
+ * While this process carries an accepted start it says so every 10 s (0.22.0+): the device helper resumes only a start
+ * nobody carries, never one a foreground command is still running.
+ */
+function carryStart(ctx, id) {
+    const beat = () => new AgentStateStore(ctx.store.dir).update(doc => { const r = doc.conversations[id]; if (r?.cloud_start)
+        r.cloud_start.heartbeat_at = Date.now(); });
+    beat();
+    const timer = setInterval(beat, 10_000);
+    timer.unref?.();
+    return () => clearInterval(timer);
+}
+/** A start whose carrying process said so in the last 45 s. */
+export const startCarried = (start) => Date.now() - (start.heartbeat_at ?? 0) < 45_000;
+export async function openCodexConversation(ctx, c, history) {
+    if (history) {
+        const task = await ctx.cloud().codex.task(c.id), ids = task.previous_thread_ids ?? [];
+        const id = history === true ? ids[0] : history;
+        if (!id || !ids.includes(id))
+            throw new UsageError('This conversation has no matching earlier Cloud history.');
+        return output(ctx, c, { ...task, thread_id: id, desktop_url: null, web_url: null }, false).then(() => 0);
+    }
+    const local = localConversations(ctx)[c.id];
+    if (local?.cloud_start && local.cloud_start.state !== 'active' && !c.ended_at) {
+        const task = await resumeCloudStartup(ctx, c);
+        await output(ctx, c, task, local.cloud_start.prompt !== undefined, recordedChoice(c));
+        return 0;
+    }
     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 });
@@ -153,7 +222,15 @@ export async function openCodexConversation(ctx, c) {
         await output(ctx, c, task);
         return 0;
     }
-    const task = await ctx.cloud().codex.task(c.id);
+    let task = await ctx.cloud().codex.task(c.id);
+    // A thread a connector change stopped (Codex Cloud turned off and on, or the active Codex account switched) continues
+    // in a new Cloud thread of this same conversation, on its VM and branch: an API that admits it again does so on
+    // request (0.23.0+); an older one answers with the stopped thread.
+    if (task.state === 'canceled') {
+        task = await ctx.cloud().codex.admit(c.id, { idempotencyKey: `codex-readmit-${c.id}-${randomUUID()}`, signal: ctx.signal });
+        if (task.state !== 'canceled')
+            task = await ctx.cloud().codex.waitTask(c.id, { timeoutMs: ctx.wakeTimeoutMs, signal: ctx.signal });
+    }
     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)
@@ -162,6 +239,33 @@ export async function openCodexConversation(ctx, c) {
     await output(ctx, c, task);
     return 0;
 }
+/** Continues the same accepted identity, never creates a replacement VM/chat. */
+export async function resumeCloudStartup(ctx, c) {
+    const local = localConversations(ctx)[c.id], start = local?.cloud_start;
+    if (!start)
+        throw new UsageError('This conversation has no local accepted startup.');
+    if (start.attachments_pending)
+        throw new CodedError('initial_images_pending', 'This accepted conversation still needs its initial images. Resume from the launcher with the retained images.', undefined, { conversation_id: c.id, workspace_key: c.key });
+    const release = carryStart(ctx, c.id);
+    try {
+        const ws = await conversationWorkspace(ctx, c);
+        // The same seed the start began: its own captured revision (never a newer checkout), or the copy seed.
+        await seedConversation(ctx, c, ws, local.folder);
+        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 });
+        if (start.prompt !== undefined && !start.submitted)
+            await submitCloudInitialPrompt(ctx, c, start.prompt, ws.key);
+        new AgentStateStore(ctx.store.dir).update(doc => {
+            const records = doc.conversations;
+            if (records[c.id]?.cloud_start)
+                records[c.id].cloud_start = { ...start, state: 'active', submitted: start.prompt !== undefined || start.submitted, prompt: undefined, error: undefined };
+        });
+        return task;
+    }
+    finally {
+        release();
+    }
+}
 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; },

package/dist/codex-linux.d.ts

@@ -0,0 +1,14 @@
+type Env = Record<string, string | undefined>;
+/** A Codex app install: its desktop entry and that entry's Exec as argv (field codes removed). */
+export interface LinuxCodexApp {
+    desktop_id: string;
+    exec: string[];
+}
+/** The installed Codex apps: entries that handle codex:// and whose program exists. The first entry with an id wins (XDG precedence). */
+export declare function linuxCodexApps(dirs: string[], env: Env): LinuxCodexApp[];
+/**
+ * Opens a codex:// link in that install, as the desktop does: its Exec with the link. Detached, so a cold start keeps
+ * running after `shard` exits; a running app takes the link in its window.
+ */
+export declare function openLinuxCodexLink(app: LinuxCodexApp, url: string, env: Env): Promise<void>;
+export {};

package/dist/codex-linux.js

@@ -0,0 +1,69 @@
+/**
+ * The Codex app on Linux (0.23.0+): OpenAI's ChatGPT app for Linux (package `chatgpt`: `chatgpt.desktop`,
+ * `Exec=chatgpt %U`) and community builds (`codex-desktop.desktop`) register the codex:// scheme, which opens a Codex
+ * thread (`codex://threads/<id>?hostId=durable` for a Cloud conversation). The app is the desktop entry in the XDG
+ * application folders (linuxApplicationDirs) that handles x-scheme-handler/codex.
+ */
+import { spawn } from 'node:child_process';
+import { accessSync, constants, readFileSync, readdirSync, statSync } from 'node:fs';
+import { delimiter, isAbsolute, join } from 'node:path';
+import { desktopEntry, desktopExec, t3OpenEnv } from "./t3-linux.js";
+/** Entry names worth reading (every entry in the folders would be hundreds of files on each `shard` run). */
+const MAYBE_ENTRY = /chatgpt|codex|openai/i;
+const executable = (path) => { try {
+    accessSync(path, constants.X_OK);
+    return statSync(path).isFile();
+}
+catch {
+    return false;
+} };
+const onPath = (name, env) => isAbsolute(name) ? executable(name) : (env.PATH ?? '').split(delimiter).filter(Boolean).some(dir => executable(join(dir, name)));
+/** The installed Codex apps: entries that handle codex:// and whose program exists. The first entry with an id wins (XDG precedence). */
+export function linuxCodexApps(dirs, env) {
+    const found = [], ids = new Set();
+    for (const dir of dirs) {
+        let names;
+        try {
+            names = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!name.endsWith('.desktop') || !MAYBE_ENTRY.test(name) || ids.has(name))
+                continue;
+            let text;
+            try {
+                text = readFileSync(join(dir, name), 'utf8');
+            }
+            catch {
+                continue;
+            }
+            ids.add(name);
+            const e = desktopEntry(text);
+            if (e.Hidden === 'true' || (e.Type ?? 'Application') !== 'Application' || !(e.MimeType ?? '').split(';').includes('x-scheme-handler/codex'))
+                continue;
+            if (e.TryExec && !onPath(e.TryExec, env))
+                continue;
+            const exec = desktopExec(e.Exec ?? '');
+            // `env VAR=value /usr/bin/codex-desktop %u` (a community entry): the program after the assignments must exist.
+            const program = exec?.[0] === 'env' ? exec.slice(1).find(a => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(a)) : exec?.[0];
+            if (!exec?.length || !program || !onPath(program, env))
+                continue;
+            found.push({ desktop_id: name, exec });
+        }
+    }
+    return found;
+}
+/**
+ * Opens a codex:// link in that install, as the desktop does: its Exec with the link. Detached, so a cold start keeps
+ * running after `shard` exits; a running app takes the link in its window.
+ */
+export async function openLinuxCodexLink(app, url, env) {
+    const [command, ...args] = app.exec;
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, [...args, url], { env: t3OpenEnv(env), stdio: 'ignore', detached: true });
+        child.once('spawn', () => { child.unref(); resolve(); });
+        child.once('error', reject);
+    });
+}

package/dist/command-center-actions.js

@@ -60,8 +60,14 @@ export const CENTER_HANDLERS = {
         }
         if (values.review === true)
             throw new UsageError('--review needs --on <conversation>.');
-        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 (values.prompt !== undefined || values['prompt-file'] !== undefined || values.image !== undefined) {
+            // --in terminal is where a new conversation opens anyway: it starts one with its first message (0.23.0+). Codex
+            // opens in Codex Cloud, which says so.
+            if (fresh && values.in === 'terminal')
+                return launchConversationProject(ctx, values, [str(values.path) ?? './', ...(str(values.app) ? [str(values.app)] : [])]);
+            const other = ref ? `the agent argument ${ref}` : values.name !== undefined ? '--name' : values.like !== undefined ? '--like' : values.in !== undefined ? `--in ${str(values.in)}` : undefined;
+            if (other)
+                throw new UsageError(`--prompt, --prompt-file and --image are for a new conversation and cannot be combined with ${other}: omit it.`, 'start one with shard agents new --path <folder> --app claude|codex --prompt "<task>"; --in auto opens it where agents targets --open-in says');
         }
         if (!ref && values.name === undefined && values.like === undefined && values.in === undefined) {
             return launchConversationProject(ctx, values, [str(values.path) ?? './', ...(str(values.app) ? [str(values.app)] : [])]);
@@ -69,7 +75,11 @@ export const CENTER_HANDLERS = {
         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)] : [])]);
         }
-        return agentAction(ctx, 'open', { ...values, in: 'terminal' }, [ref]);
+        // The agent's own terminal session: attached here, started detached with --json, or (without a terminal here) a
+        // tab of the person's terminal app, as agents open does (0.20.1+).
+        const next = { ...values };
+        delete next.in;
+        return agentAction(ctx, 'open', next, [ref]);
     },
     async 'agents fork'(ctx, values, [ref, name]) {
         if (!ref || !name || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(name))
@@ -141,8 +151,11 @@ export const CENTER_HANDLERS = {
             if (ws.labels.shard_conversation && CONVERSATION_ID.test(ws.labels.shard_conversation))
                 conversation = await getConversation(ctx, ws.labels.shard_conversation);
         }
-        if (conversation?.route === 'codex-cloud')
-            throw new UsageError(`Codex Cloud runs this conversation; follow it with shard agents open ${conversation.id}.`);
+        // Codex Cloud holds the conversation's output in its Codex thread; no terminal in the VM shows it (0.23.0+: the
+        // refusal names the commands that do).
+        if (conversation?.route === 'codex-cloud') {
+            throw new UsageError(`Codex Cloud runs this conversation, so its output is in its Codex thread, not a terminal: open the thread with shard agents open ${conversation.id}; shard c wait ${conversation.id} waits for its reply and shard c get ${conversation.id} shows it.`);
+        }
         if (conversation?.route === 'acp')
             throw new UsageError('This conversation runs through its ACP client, which shows its output; it has no terminal to follow.');
         if (conversation && values.app !== undefined && values.app !== conversation.harness)

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

@@ -24,6 +24,8 @@ export interface CenterRow {
 /** Older K5 captures used the workspace key as the agent label. K1 needs its leaf name. */
 export declare const agentName: (key: string, labels: Record<string, string>) => string;
 export declare const projectName: (key: string, labels: Record<string, string>) => string;
+/** What `shard agents open` gets for a row: a Cloud thread's conversation id, else the VM's key. */
+export declare const openReference: (row: Pick<CenterRow, "key" | "agent">) => string;
 export declare function loadCenter(ctx: Ctx): Promise<CenterData>;
 export declare function scopedProject(data: CenterData, scope: ProjectScope): string;
 export declare function centerRows(data: CenterData, scope?: ProjectScope, filter?: string): CenterRow[];

package/dist/command-center-model.js

@@ -6,6 +6,11 @@ import { readSetupProgress } from "./assisted-setup.js";
 export const agentName = (key, labels) => (labels.agent || key).split('/').at(-1);
 export const projectName = (key, labels) => labels.shard_project || key.split('/')[0];
 const parked = (workspace) => ['suspended', 'hibernated', 'parked'].includes(workspace?.observed_state ?? '');
+/** A Codex Cloud thread (API rows labeled shard_route=codex-cloud, 0.23.0+): it runs in Codex, so its VM being parked
+ * says nothing about it, and it opens by its conversation id, in Codex, without waking that VM. */
+const cloudThread = (agent) => agent?.labels.shard_route === 'codex-cloud' && !!agent.conversation_id;
+/** What `shard agents open` gets for a row: a Cloud thread's conversation id, else the VM's key. */
+export const openReference = (row) => cloudThread(row.agent) ? row.agent.conversation_id : row.key;
 export async function loadCenter(ctx) {
     const collect = async (path) => {
         const rows = [], cursors = new Set();
@@ -62,7 +67,7 @@ export function centerRows(data, scope, filter = '') {
         const workspace = workspaces.get(agent.workspace_id);
         if (workspace?.deleted_at)
             continue;
-        const badge = agent.app === 'claude' && agent.credential_status === 'needs_sign_in' ? 'Claude sign-in needed' : agent.state === 'exited' ? 'done' : parked(workspace) ? 'parked' : agent.state === 'waiting' ? 'needs you' : 'working';
+        const badge = agent.app === 'claude' && agent.credential_status === 'needs_sign_in' ? 'Claude sign-in needed' : agent.state === 'exited' ? 'done' : !cloudThread(agent) && parked(workspace) ? 'parked' : agent.state === 'waiting' ? 'needs you' : 'working';
         rows.push({ id: agent.id, key: agent.workspace_key, project: projectName(agent.workspace_key, agent.labels), agent, workspace, badge,
             attention: badge === 'Claude sign-in needed' ? -1 : ['needs you', 'working', 'parked', 'done'].indexOf(badge) });
         withSessions.add(agent.workspace_id);

package/dist/command-center.js

@@ -5,7 +5,7 @@ import { AgentStateStore } from "./agent-state.js";
 import { installedTargets } from "./agent-targets.js";
 import { randomUUID } from 'node:crypto';
 import { agentAction, availableTargets } from "./command-center-actions.js";
-import { centerRows, loadCenter } from "./command-center-model.js";
+import { centerRows, loadCenter, openReference } from "./command-center-model.js";
 import { AnsiRenderer, renderCenter } from "./command-center-renderer.js";
 import { CenterKeys } from "./command-center-keys.js";
 import { ensureMenubar } from "./menubar.js";
@@ -320,13 +320,13 @@ export async function showCenter(ctx, scope, options = {}) {
         const app = row.agent?.app || options.app || new AgentStateStore(ctx.store.dir).app(project, row.workspace?.labels.app === 'codex' ? 'codex' : 'claude');
         if (key === 'enter') {
             const target = new AgentStateStore(ctx.store.dir).target(project, ['terminal', ...installedTargets(ctx.io.env).targets]);
-            await dispatch('open', { app, project, in: target }, [row.key], true);
+            await dispatch('open', { app, project, in: target }, [openReference(row)], true);
         }
         else if (key === 'o') {
             const targets = await availableTargets(ctx);
             menu('Open in…', targets.map(target => ({ label: target, run: async () => {
                     new AgentStateStore(ctx.store.dir).saveTarget(project, target);
-                    await dispatch('open', { app, project, in: target }, [row.key], true);
+                    await dispatch('open', { app, project, in: target }, [openReference(row)], true);
                 } })));
         }
         else if (key === 'N' || key === 'f') {