@shardflux/cli 0.20.0 → 0.23.0

package/dist/move.d.ts

@@ -3,6 +3,7 @@ import type { Ctx, Handler } from './commands.js';
 import type { Values } from './args.js';
 import type { Conversation } from './conversations.js';
 import type { LocalSession, SessionHarness, SessionState } from './local-sessions.js';
+import type { WorktreeMigration } from './move-worktrees.js';
 type Env = Record<string, string | undefined>;
 /** The project a folder belongs to: its Git repository's top, or the folder itself. */
 export declare function projectRoot(folder: string): string;
@@ -15,10 +16,17 @@ type MoveCell = Pick<ReturnType<Workspace['cell']>, 'exec' | 'files'>;
  * project space is mounted, as the conversation's durable copy with the same checkpoint metadata the guest writes
  * (transcripts/<id>/meta.json), so the session survives the VM from its first minute.
  */
-export declare function placeTranscript(cell: MoveCell, c: Pick<Conversation, 'id' | 'harness' | 'worktree_path'>, s: LocalSession, bytes: Buffer, folder: string, signal?: AbortSignal): Promise<{
+export declare function placeTranscript(cell: MoveCell, c: Pick<Conversation, 'id' | 'harness' | 'worktree_path'>, s: LocalSession, bytes: Buffer, folder: string, signal?: AbortSignal, worktrees?: WorktreeMigration): Promise<{
     native: string;
     durable: boolean;
 }>;
+/** Every working directory the whole transcript names in its record metadata, never in message or tool content. */
+export declare function transcriptCwds(bytes: Buffer): string[];
+/**
+ * The project a move goes to: --path when the session's records confirm it worked there (placeTranscript checks), the
+ * current folder's project when it worked there, else the project of where it works now.
+ */
+export declare function moveFolder(s: Pick<LocalSession, 'cwd' | 'cwds'>, here: string, explicit: boolean): string;
 export declare function moveSession(ctx: Ctx, values: Values): Promise<number>;
 /** `shard move --list`: this project's sessions on this computer, and where each moved one continues. */
 export declare function listMovable(ctx: Pick<Ctx, 'store' | 'apiUrl'>, values: Values, env: Env, now?: number): {
@@ -30,6 +38,7 @@ export declare function listMovable(ctx: Pick<Ctx, 'store' | 'apiUrl'>, values:
         updated_at: string;
         source: string;
         cwd: string;
+        cwds: string[];
         running: boolean;
         turn: "working" | "idle";
         moved: {

package/dist/move.js

@@ -31,8 +31,9 @@ import { openInChoices } from "./t3-mode.js";
 import { openClaudeDesktopSession, remoteControlUrl } from "./agent-target-commands.js";
 import { openUrl } from "./browser.js";
 import { SYNC_CHUNK_BYTES } from "./project-sync-transfer.js";
-import { completeRecords, continuedAfter, findLocalSession, homeRelativeTranscript, listLocalSessions, readTranscript, rewriteSessionPaths, sessionState } from "./local-sessions.js";
+import { completeRecords, continuedAfter, findLocalSession, homeRelativeTranscript, listLocalSessions, readTranscript, recordCwd, rewriteSessionPaths, sessionState } from "./local-sessions.js";
 import { installDivergenceNotice, movedKey, movedSession, movedSessions, rememberMoved } from "./moved-sessions.js";
+import { captureWorktreeMigration, inspectWorktreeMigration, migrationScope, preserveWorktreeMigration, referencedWorktrees, rewriteWorktreeTranscript } from "./move-worktrees.js";
 const VM_HOME = '/home/user';
 const SPACE = '/shardflux/project';
 /** A transcript above this moves with the repository's history bound. */
@@ -95,14 +96,27 @@ async function writeChunks(cell, path, bytes) {
  * project space is mounted, as the conversation's durable copy with the same checkpoint metadata the guest writes
  * (transcripts/<id>/meta.json), so the session survives the VM from its first minute.
  */
-export async function placeTranscript(cell, c, s, bytes, folder, signal) {
-    const sessionCwd = realOr(s.cwd), inside = relative(folder, sessionCwd);
-    if (inside.startsWith('..'))
-        throw new UsageError('The session ran outside this project folder; run shard move in its project.');
-    let moved = rewriteSessionPaths(bytes, folder, c.worktree_path);
-    if (s.cwd !== sessionCwd && !s.cwd.startsWith(`${folder}/`) && s.cwd !== folder) {
-        // The transcript recorded a path through a link (/tmp for /private/tmp): move that spelling too.
-        moved = rewriteSessionPaths(moved, s.cwd.slice(0, s.cwd.length - inside.length).replace(/\/$/, ''), c.worktree_path);
+export async function placeTranscript(cell, c, s, bytes, folder, signal, worktrees) {
+    // The project is confirmed by the session's own records (0.20.2+): any of them working in the folder, not only the
+    // first (a session started in a scratch folder that went on in this repository). Paths are moved for this folder;
+    // records of a folder outside it keep their bytes.
+    const here = confirmedCwds(s, bytes, folder, worktrees);
+    let moved = bytes;
+    if (worktrees) {
+        // Normalize linked spellings confirmed by record metadata before mapping
+        // longest registered prefixes. Scratch records outside the family stay intact.
+        for (const tree of [...worktrees.trees].sort((a, b) => b.source.length - a.source.length)) {
+            const spellings = here.filter(cwd => isInside(tree.source, realOr(cwd))).map(cwd => linkedSpelling(cwd, tree.source));
+            for (const spelled of new Set(spellings.filter((p) => !!p)))
+                moved = rewriteSessionPaths(moved, spelled, tree.source);
+        }
+        moved = rewriteWorktreeTranscript(moved, worktrees, c.worktree_path);
+    }
+    else {
+        moved = rewriteSessionPaths(moved, folder, c.worktree_path);
+        // A path recorded through a link (/tmp for /private/tmp): move that spelling too.
+        for (const spelled of new Set(here.map(cwd => linkedSpelling(cwd, folder)).filter((p) => !!p)))
+            moved = rewriteSessionPaths(moved, spelled, c.worktree_path);
     }
     const homeRelative = homeRelativeTranscript(s, c.worktree_path);
     const native = `${VM_HOME}/${homeRelative}`;
@@ -125,6 +139,52 @@ const realOr = (path) => { try {
 catch {
     return resolve(path);
 } };
+const isInside = (folder, path) => path === folder || path.startsWith(folder.endsWith('/') ? folder : `${folder}/`);
+/** The folder as `cwd` spells it through a link (/tmp/x for /private/tmp/x), or undefined when it spells it plainly. */
+function linkedSpelling(cwd, folder) {
+    if (isInside(folder, cwd))
+        return undefined;
+    const inside = relative(folder, realOr(cwd));
+    if (inside && !cwd.endsWith(`/${inside}`))
+        return undefined;
+    return inside ? cwd.slice(0, cwd.length - inside.length - 1) : cwd;
+}
+/** Every working directory the whole transcript names in its record metadata, never in message or tool content. */
+export function transcriptCwds(bytes) {
+    const out = new Set();
+    for (const line of bytes.toString('utf8').split('\n')) {
+        try {
+            const r = JSON.parse(line);
+            if (!r || typeof r !== 'object' || Array.isArray(r))
+                continue;
+            const cwd = recordCwd(r);
+            if (cwd)
+                out.add(cwd);
+        }
+        catch { /* a partial record */ }
+    }
+    return [...out];
+}
+function confirmedCwds(s, bytes, folder, worktrees) {
+    const roots = [folder, ...(worktrees?.trees.map(t => t.source) ?? [])];
+    const here = [...new Set([s.cwd, ...s.cwds, ...transcriptCwds(bytes)])].filter(cwd => roots.some(root => isInside(root, realOr(cwd))));
+    if (!here.length)
+        throw new UsageError('The session ran outside this project folder; run shard move in its project, or pass --path with the repository it worked in.');
+    return here;
+}
+/**
+ * The project a move goes to: --path when the session's records confirm it worked there (placeTranscript checks), the
+ * current folder's project when it worked there, else the project of where it works now.
+ */
+export function moveFolder(s, here, explicit) {
+    if (explicit)
+        return here;
+    const root = (cwd) => (existsSync(cwd) ? projectRoot(cwd) : here);
+    if (isInside(here, realOr(s.cwd)))
+        return root(s.cwd);
+    const inHere = [...s.cwds].reverse().find(cwd => isInside(here, realOr(cwd)));
+    return inHere ? root(inHere) : root(s.cwd);
+}
 async function alreadyMoved(ctx, m) {
     try {
         const c = await getConversation(ctx, m.conversation_id);
@@ -140,19 +200,49 @@ export async function moveSession(ctx, values) {
     const env = { ...process.env, ...ctx.io.env };
     const here = projectRoot(typeof values.path === 'string' ? values.path : process.cwd());
     const s = chooseSession(values, env, here);
-    const folder = typeof values.path === 'string' ? here : projectRoot(existsSync(s.cwd) ? s.cwd : here);
+    const folder = moveFolder(s, here, typeof values.path === 'string');
     const prior = movedSession(ctx.store.dir, ctx.apiUrl, s.harness, s.session_id);
-    if (prior) {
+    if (prior && values.plan !== true) {
         const live = await alreadyMoved(ctx, prior);
         if (live) {
             out(ctx, `This session already continues in the cloud as ${prior.key}. Open it: shard agents open ${prior.key}\n`, { already: true, moved: prior, conversation: live });
             return 0;
         }
     }
-    await waitForTurnEnd(ctx, s, env);
+    // A normal move continues the session from this checkout, uncommitted edits included; the repository's other
+    // worktrees and local branches stay on this computer, untouched (as `this-worktree-only` says explicitly).
+    // --preserve-all-worktrees copies them too.
+    const preserveAll = values['preserve-all-worktrees'] === true;
+    if (preserveAll && values['this-worktree-only'] === true)
+        throw new UsageError('Choose --preserve-all-worktrees or --this-worktree-only.');
+    if (values.plan !== true) {
+        // A local MCP caller is still in its turn: an unrelated folder is refused while it can still answer.
+        if (!preserveAll)
+            confirmedCwds(s, completeRecords(readTranscript(s.file)), folder);
+        await waitForTurnEnd(ctx, s, env);
+    }
     const bytes = completeRecords(readTranscript(s.file));
     if (bytes.length > TRANSCRIPT_LIMIT)
         throw new UsageError('This session’s transcript is above the 256 MiB move bound.');
+    const plan = preserveAll || values.plan === true ? await inspectWorktreeMigration(folder, bytes, ctx.signal) : null;
+    // Refuse before syncing credentials, creating a VM or snapshotting an unrelated
+    // folder. An explicit all-worktree scope also accepts record-confirmed linked owners.
+    confirmedCwds(s, bytes, folder, plan ?? undefined);
+    let elsewhere = [];
+    if (plan) {
+        await captureWorktreeMigration(plan, ctx.signal);
+        const scope = migrationScope(plan);
+        if (values.plan === true) {
+            out(ctx, `${JSON.stringify(scope, null, 2)}\n`, scope);
+            return 0;
+        }
+        ctx.io.stderr.write(`Preserving ${plan.trees.length} registered worktrees, ${plan.files} files, ${plan.bytes} file bytes (archives add headers). Includes ignored files and Git metadata:\n${plan.trees.map(t => `  ${t.source}`).join('\n')}\nSymlink targets and unrelated sibling folders are not uploaded.\n`);
+    }
+    else if (values['this-worktree-only'] !== true) {
+        elsewhere = await referencedWorktrees(folder, bytes, ctx.signal);
+        if (elsewhere.length && !ctx.json)
+            ctx.io.stderr.write(`This session also worked in ${elsewhere.length === 1 ? 'another worktree' : `${elsewhere.length} other worktrees`} of this repository (${elsewhere.join(', ')}); ${elsewhere.length === 1 ? 'it stays' : 'they stay'} on this computer. shard move --preserve-all-worktrees copies every worktree.\n`);
+    }
     const sha256 = createHash('sha256').update(bytes).digest('hex');
     if (!ctx.json)
         ctx.io.stderr.write(`Moving ${s.harness === 'claude' ? 'Claude Code' : 'Codex'} session “${s.title}” to the cloud…\n`);
@@ -162,11 +252,16 @@ export async function moveSession(ctx, values) {
         requireClaudeTerminal(ctx);
     let created;
     let placed;
+    let preserved;
     try {
         created = await createConversation(ctx, folder, s.harness, 'terminal', undefined, {}, {
             session_id: s.session_id, title: s.title,
+            ...(values['preserve-all-worktrees'] === true && plan ? { preserveWorktrees: true,
+                seedRepository: async (ws, c) => { preserved = await preserveWorktreeMigration(ws.cell(), plan, c, ctx.signal); } } : {}),
             // The workspace's cell handle is shared with the seed that follows: it stays open.
-            beforeSeed: async (ws, c) => { placed = await placeTranscript(ws.cell(), c, s, bytes, folder, ctx.signal); },
+            beforeSeed: async (ws, c) => {
+                placed = await placeTranscript(ws.cell(), c, s, bytes, folder, ctx.signal, values['preserve-all-worktrees'] === true && plan ? plan : undefined);
+            },
         });
     }
     catch (e) {
@@ -198,7 +293,7 @@ export async function moveSession(ctx, values) {
     if (!attach) {
         const quiet = { ...ctx, io: { ...ctx.io, stdout: { write: () => true } } };
         await conversationTerminal(quiet, ws, c, place, { ...values, detach: true });
-        out(ctx, `Moved to the cloud as ${c.key}: the same session, with its history. Open it: shard agents open ${c.key}\n`, { moved, conversation: c, workspace: ws.data, ...(placed ? { transcript: placed } : {}) });
+        out(ctx, `Moved to the cloud as ${c.key}: the same session, with its history. Open it: shard agents open ${c.key}\n`, { moved, conversation: c, workspace: ws.data, ...(placed ? { transcript: placed } : {}), ...(preserved ? { preserved } : {}), ...(elsewhere.length ? { other_worktrees: elsewhere } : {}) });
         return 0;
     }
     const where = openInChoices(ctx, project.slug)[s.harness];
@@ -208,7 +303,7 @@ export async function moveSession(ctx, values) {
         if (where === 'claude-desktop')
             return openClaudeDesktopSession(ctx, ws, c);
         const url = await remoteControlUrl(ctx, ws, c);
-        if (!openUrl(url, ctx.io.env))
+        if (!(await openUrl(url, ctx.io.env)))
             throw new Error(`could not open ${url}`);
         out(ctx, `${url}\n`, { moved, conversation: c, url });
         return 0;
@@ -223,7 +318,7 @@ export function listMovable(ctx, values, env, now = Date.now()) {
     const sessions = listLocalSessions(folder, env, { harness: harnessOf(values), limit: 10 }).map(s => {
         const m = moved[movedKey(s.harness, s.session_id)];
         const state = sessionState(s, env, now);
-        return { harness: s.harness, session_id: s.session_id, title: s.title, updated_at: s.updated_at, source: s.source, cwd: s.cwd,
+        return { harness: s.harness, session_id: s.session_id, title: s.title, updated_at: s.updated_at, source: s.source, cwd: s.cwd, cwds: s.cwds,
             running: state.running, turn: state.turn,
             moved: m ? { conversation_id: m.conversation_id, key: m.key, moved_at: m.moved_at, diverged: continuedAfter(s, m.bytes) } : null };
     });

package/dist/onboarding.d.ts

@@ -1,6 +1,7 @@
 import type { Ctx } from './commands.js';
 import type { Values } from './args.js';
 import type { CodexConnectorView, CodexHealth } from './codex-cloud.js';
+import type { MachineRow } from './machine-status.js';
 /**
  * The first-run demo's task: it shows the agent's own computer at work. The user copies it and pastes it into the
  * launcher themselves; Daylight's own CLAUDE.md and AGENTS.md say how to run it and test it in the desktop browser.
@@ -13,7 +14,7 @@ export type AgentApp = 'claude' | 'codex';
  * rest (Claude Code's installer uses ~/.local/bin).
  */
 export declare function installDirs(home: string): string[];
-/** Claude Code or Codex is on this Mac: its home folder (~/.claude, ~/.codex) or its command on PATH or in an install folder. */
+/** Claude Code or Codex is on this computer: its home folder (~/.claude, ~/.codex) or its command on PATH or in an install folder. */
 export declare function foundApps(env: NodeJS.ProcessEnv): Promise<AgentApp[]>;
 /** --apps claude,codex (repeatable or comma separated); unknown names are refused. */
 export declare function parseApps(value: unknown): AgentApp[] | undefined;
@@ -71,32 +72,35 @@ export interface T3SignInRow {
  * appears in T3 Code and the T3 app by itself. `startSignIn` (`--t3-connect`) starts that sign-in. Null when T3 Code
  * is not installed.
  */
-export declare function t3Connection(ctx: Ctx, signedIn: boolean, appDirs?: string[], platform?: NodeJS.Platform, startSignIn?: boolean): Promise<Connection | null>;
+export declare function t3Connection(ctx: Ctx, signedIn: boolean, appDirs?: string[], platform?: NodeJS.Platform, startSignIn?: boolean, scope?: Values): Promise<Connection | null>;
 /** Claude: the account login is ready and Claude itself accepts it right now. */
 export declare function claudeConnection(row: CredentialRow | undefined): Omit<Connection, 'id' | 'picked' | 'found'>;
-/** Codex: this Mac's Codex login is copied and the account's Codex remote device (one executor) is connected. */
+/** Codex: this computer's Codex login is copied and the account's Codex remote device (one executor) is connected. */
 export declare function codexConnection(local: boolean, synced: boolean, connector: CodexConnectorView | null, health: CodexHealth): Omit<Connection, 'id' | 'picked' | 'found'>;
 /**
  * The onboarding report, for an agent setting itself up from chat and for the menu bar app. It verifies every
  * connection live: the Shardflux account, Claude (Claude itself accepts the login) and Codex (the login is copied and
- * the account's Codex remote device is connected), for the apps picked (--apps, else saved, else found on this Mac).
+ * the account's Codex remote device is connected), for the apps picked (--apps, else saved, else found on this computer).
  * With --connect it also does what needs no sign-in: copies the Codex login and enables the Codex remote device.
  */
-export declare function onboardingReport(ctx: Ctx, values: Values): Promise<{
+export declare function onboardingReport(ctx: Ctx, values: Values, platform?: NodeJS.Platform): Promise<{
     version: number;
     api_url: string;
     apps: AgentApp[];
     found_apps: AgentApp[];
     connections: Connection[];
     ready: boolean;
+    connections_ready: boolean;
+    machine_ready: boolean | null;
     account_error: string | null;
+    machine: MachineRow | null;
     demo: {
         prompt: string;
         project: string;
         prepare: string[];
     };
     activity: {
-        state: "running" | "failed" | "suspended" | "deleted" | "creating" | "starting" | "suspending" | "resuming" | "forking" | "stopping" | "deleting";
+        state: "running" | "failed" | "creating" | "starting" | "suspending" | "suspended" | "resuming" | "forking" | "stopping" | "deleting" | "deleted";
         workspace: {
             id: string;
             key: string;
@@ -180,7 +184,7 @@ interface ProcessRow {
 export declare function activeCommands(processes: ProcessRow[]): string[];
 /** Commands and listening ports of a running VM. Never wakes a parked computer. */
 export declare function liveActivity(ctx: Ctx, ref: string): Promise<{
-    state: "running" | "failed" | "suspended" | "deleted" | "creating" | "starting" | "suspending" | "resuming" | "forking" | "stopping" | "deleting";
+    state: "running" | "failed" | "creating" | "starting" | "suspending" | "suspended" | "resuming" | "forking" | "stopping" | "deleting" | "deleted";
     workspace: {
         id: string;
         key: string;

package/dist/onboarding.js

@@ -6,12 +6,15 @@ import { resolveWorkspace } from "./commands.js";
 import { AgentStateStore } from "./agent-state.js";
 import { describeError } from "./errors.js";
 import { t3PhoneLink } from "./t3-phone.js";
+import { t3NeedsProject, t3SignInProject } from "./account-scope.js";
 import { readAgentCredentials, syncAgentCredentials } from "./agent-credentials.js";
 import { getConversation } from "./conversations.js";
 import { codexHealth, readCodexConnector, restartCodexConnector } from "./codex-cloud.js";
 import { applicationDirs } from "./agent-targets.js";
 import { configureT3Provider } from "./t3-provider.js";
 import { t3Install } from "./t3-mode.js";
+import { inspectMachineRow, rowText } from "./machine-status.js";
+import { launcherShortcut } from "./this-computer.js";
 /**
  * The first-run demo's task: it shows the agent's own computer at work. The user copies it and pastes it into the
  * launcher themselves; Daylight's own CLAUDE.md and AGENTS.md say how to run it and test it in the desktop browser.
@@ -37,7 +40,7 @@ export function installDirs(home) {
     return [join(home, '.local', 'bin'), join(home, '.claude', 'local'), join(home, '.npm-global', 'bin'), join(home, '.bun', 'bin'),
         join(home, '.volta', 'bin'), join(home, 'Library', 'pnpm')];
 }
-/** Claude Code or Codex is on this Mac: its home folder (~/.claude, ~/.codex) or its command on PATH or in an install folder. */
+/** Claude Code or Codex is on this computer: its home folder (~/.claude, ~/.codex) or its command on PATH or in an install folder. */
 export async function foundApps(env) {
     const home = env.HOME ?? homedir();
     const onPath = async (name) => {
@@ -69,7 +72,7 @@ export function parseApps(value) {
  * appears in T3 Code and the T3 app by itself. `startSignIn` (`--t3-connect`) starts that sign-in. Null when T3 Code
  * is not installed.
  */
-export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.io.env), platform = process.platform, startSignIn = false) {
+export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.io.env), platform = process.platform, startSignIn = false, scope = {}) {
     // The same install every T3 command uses (macOS and Linux): a build with ACP providers first.
     const app = t3Install(ctx.io.env, platform, appDirs);
     if (!app)
@@ -90,37 +93,52 @@ export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.
     // Stable T3: one T3 Connect sign-in per person (the API's, per account), then each project appears by itself. `next`
     // is for scripts: a project is set up for T3 Code with it.
     const ssh = { ...base, mode: 'ssh', next: shard(['agents', 'new', '--in', 't3', '--path', '<project>']) };
+    const selection = ['org', 'project'].flatMap(key => typeof scope[key] === 'string' ? [`--${key}`, scope[key]] : []);
     const offer = { ...ssh, state: 'action', fact: 'Your projects appear in T3 Code and the T3 app once connected.',
-        action: { title: 'Connect T3 Code', command: shard(['setup', '--inspect', '--t3-connect', '--json']) } };
+        action: { title: 'Connect T3 Code', command: shard(['setup', '--inspect', '--t3-connect', '--json', ...selection]) } };
     if (!signedIn)
         return offer;
-    const cloud = ctx.cloud();
+    let projectId;
     let status;
     try {
-        status = await cloud.t3.status();
+        // Status and sign-in must use the same person and organization. The key may belong to another organization
+        // (or another member); its connected state cannot decide whether this person's selected sign-in is connected.
+        if (ctx.sessionSource() !== null) {
+            projectId = await t3SignInProject(ctx, scope);
+            status = await ctx.account().t3.status(projectId ? { projectId } : {});
+        }
+        else
+            status = await ctx.cloud().t3.status();
     }
     catch {
         return { ...ssh, state: 'unknown', fact: 'T3 Connect could not be checked just now.', action: { title: 'Retry', retry: true } };
     }
     // Remembered for `agents targets`: with the sign-in, every project can start in T3 Code (t3Status).
-    try {
-        new AgentStateStore(ctx.store.dir).saveT3Connected(ctx.apiUrl, status.connected);
+    // A one-off --org/--project check must not replace the default target's remembered status.
+    if (selection.length === 0) {
+        try {
+            new AgentStateStore(ctx.store.dir).saveT3Connected(ctx.apiUrl, status.connected);
+        }
+        catch { /* the next check writes it */ }
     }
-    catch { /* the next check writes it */ }
     if (!status.connected) {
         if (!startSignIn)
             return offer;
-        const signIn = await startT3SignIn(ctx);
+        const signIn = await startT3SignIn(ctx, projectId);
         if (signIn === 'connected')
-            return t3Connection(ctx, signedIn, appDirs, platform, false);
+            return t3Connection(ctx, signedIn, appDirs, platform, false, scope);
         if (signIn.needs_login)
             return { ...offer, fact: 'Sign in to Shardflux on this computer to connect T3 Code.', t3_link: signIn };
         return { ...offer, fact: 'Confirm the code on the page that opened. This updates on its own.', t3_link: signIn,
             action: { title: 'Connect T3 Code', url: signIn.sign_in.verification_uri } };
     }
     const connected = { ...ssh, state: 'verified', fact: 'Your projects appear in T3 Code and the T3 app.' };
+    // Explicit account selection is a status check, not consent to relink the default computer's last workspace.
+    if (selection.length > 0)
+        return connected;
     // The newest project set up for T3 Code from this computer (agents.json; a targets.json entry from an older CLI still
-    // counts): where it is. One set up before T3 Connect, or whose link failed, is linked now: it is the person's choice.
+    // counts): where it is. One set up before T3 Connect is linked now. An existing error stays visible until the
+    // person explicitly requests another link; a periodic inspection must not restart permanent refusals.
     const recorded = new AgentStateStore(ctx.store.dir).t3Environments(ctx.apiUrl).at(-1);
     const manifest = await jsonFile(join(ctx.store.dir, 'targets.json'));
     const entries = Array.isArray(manifest?.entries) ? manifest.entries : [];
@@ -131,7 +149,9 @@ export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.
     try {
         const ws = await resolveWorkspace(ctx, key);
         const known = status.links.find(l => l.workspace_id === ws.id);
-        const link = !known || known.status === 'error' || known.status === 'needs_sign_in' ? (await t3PhoneLink(ctx, ws.id)).link : known;
+        if (known?.status === 'error')
+            return { ...ssh, state: 'info', fact: known.last_error ?? 'T3 Connect could not link this workspace. Check T3 Connect, then open this project in T3 Code again to retry.' };
+        const link = !known || known.status === 'needs_sign_in' ? (await t3PhoneLink(ctx, ws.id, ws.data.project_id)).link : known;
         // Linked to the person's T3 account: T3 Code and the T3 app list it once they are signed in to that account.
         if (link.status === 'linked')
             return { ...connected, fact: `${link.label} is linked to your T3 account.` };
@@ -149,19 +169,21 @@ export async function t3Connection(ctx, signedIn, appDirs = applicationDirs(ctx.
 }
 /**
  * Starts the person's T3 Connect sign-in (a pending one comes back again). It needs this computer's Shardflux session,
- * not only an API key. `connected` when the account already has one (409 `t3_signed_in`).
+ * not only an API key. `connected` when the account already has one (409 `t3_signed_in`). The sign-in is per
+ * organization: it is scoped by --project/--org, else the API key's project, else the saved default (0.20.2+; before,
+ * a person in two organizations got 422 project_id is required).
  */
-async function startT3SignIn(ctx) {
-    if (ctx.store.profile(ctx.apiUrl).session?.state !== 'active')
+async function startT3SignIn(ctx, projectId) {
+    if (ctx.sessionSource() === null)
         return { status: 'needs_sign_in', label: '', needs_login: true };
     try {
-        const flow = await ctx.account().t3.signIn();
+        const flow = await ctx.account().t3.signIn(projectId ? { projectId } : {});
         return { status: 'needs_sign_in', label: '', sign_in: { verification_uri: flow.verification_uri, user_code: flow.user_code, expires_at: flow.expires_at } };
     }
     catch (error) {
         if (error instanceof ShardfluxApiError && describeError(error).code === 't3_signed_in')
             return 'connected';
-        throw error;
+        throw t3NeedsProject(error) ?? error;
     }
 }
 const shard = (words) => ['shard', ...words];
@@ -176,7 +198,7 @@ export function claudeConnection(row) {
         return { state: 'action', fact: 'Claude no longer accepts this sign-in.', action: { ...signIn, title: 'Sign in to Claude again' } };
     return { state: 'verified', fact: 'Signed in. Works in every conversation, on web and phone.' };
 }
-/** Codex: this Mac's Codex login is copied and the account's Codex remote device (one executor) is connected. */
+/** Codex: this computer's Codex login is copied and the account's Codex remote device (one executor) is connected. */
 export function codexConnection(local, synced, connector, health) {
     const enable = { title: 'Connect Codex', command: shard(['agents', 'codex', 'enable']) };
     if (!synced) {
@@ -198,14 +220,14 @@ export function codexConnection(local, synced, connector, health) {
 /**
  * The onboarding report, for an agent setting itself up from chat and for the menu bar app. It verifies every
  * connection live: the Shardflux account, Claude (Claude itself accepts the login) and Codex (the login is copied and
- * the account's Codex remote device is connected), for the apps picked (--apps, else saved, else found on this Mac).
+ * the account's Codex remote device is connected), for the apps picked (--apps, else saved, else found on this computer).
  * With --connect it also does what needs no sign-in: copies the Codex login and enables the Codex remote device.
  */
-export async function onboardingReport(ctx, values) {
+export async function onboardingReport(ctx, values, platform = process.platform) {
     const saved = await jsonFile(resolve(ctx.store.dir, 'onboarding.json'));
     const state = saved?.api_url === ctx.apiUrl ? saved : undefined;
     const found = await foundApps(ctx.io.env);
-    // An empty saved pick means nothing was chosen yet: what is found on this Mac is pre-ticked.
+    // An empty saved pick means nothing was chosen yet: what is found on this computer is pre-ticked.
     const savedApps = Array.isArray(state?.apps) && state.apps.length ? parseApps(state.apps.filter(v => typeof v === 'string')) : undefined;
     const apps = parseApps(values.apps) ?? savedApps ?? found;
     const connect = values.connect === true;
@@ -256,7 +278,7 @@ export async function onboardingReport(ctx, values) {
                 let read = await readCodexConnector(ctx);
                 health = codexHealth(read.connector, read.workspaceState);
                 const synced = credentials.some(row => row.app === 'codex');
-                // One executor per account, enabled as `shard setup` does when this Mac is signed in to Codex. --retry-codex starts
+                // One executor per account, enabled as `shard setup` does when this computer is signed in to Codex. --retry-codex starts
                 // a failed or stuck one again, once.
                 if (connect && synced && (health === 'missing' || health === 'disabled')) {
                     read = { connector: await ctx.cloud().codex.enable({ signal: ctx.signal }), workspaceState: null };
@@ -279,24 +301,33 @@ export async function onboardingReport(ctx, values) {
     const claude = { id: 'claude', picked: apps.includes('claude'), found: found.includes('claude'),
         ...(!connected ? signIn : credentialError !== undefined ? failure(credentialError) : claudeConnection(credentials.find(row => row.app === 'claude'))) };
     const codex = { id: 'codex', picked: apps.includes('codex'), found: found.includes('codex'),
-        ...(!connected ? signIn : (credentialError ?? codexError) !== undefined ? failure(credentialError ?? codexError)
-            : codexConnection(localCodex, credentials.some(row => row.app === 'codex'), connector, health)) };
-    const t3 = await t3Connection(ctx, connected, undefined, undefined, values['t3-connect'] === true);
+        ...(!connected ? signIn : codexError instanceof ShardfluxApiError && codexError.reason === 'codex_chatgpt_login_required'
+            ? { state: 'action', fact: codexError.message, action: { title: 'Sign in with ChatGPT', command: ['codex', 'login'] } }
+            : (credentialError ?? codexError) !== undefined ? failure(credentialError ?? codexError)
+                : codexConnection(localCodex, credentials.some(row => row.app === 'codex'), connector, health)) };
+    const t3 = await t3Connection(ctx, connected || ctx.sessionSource() !== null, undefined, undefined, values['t3-connect'] === true, values);
     const connections = [account, claude, codex, ...(t3 ? [t3] : [])];
+    // The cloud machine (0.20.2+), the same row `shard machine setup --status` reports: whether what is installed carries
+    // over to new conversations. It never decides `ready`: conversations start without a saved machine too.
+    const machine = connected ? await inspectMachineRow(ctx) : null;
+    const shortcut = launcherShortcut(ctx.store.dir, platform);
+    const press = (what) => (shortcut ? `Press ${shortcut}, ${what}` : `Open a new conversation, ${what}`);
     // Ready: signed in and at least one agent app connected; the other can be connected later (Settings, or this again).
     const ready = account.state === 'verified' && [claude, codex].some(c => c.state === 'verified');
     const done = (value) => value === true || (typeof value === 'string' && value.length > 0);
     return {
-        version: 3, api_url: ctx.apiUrl, apps, found_apps: found, connections, ready, account_error: accountError,
+        version: 3, api_url: ctx.apiUrl, apps, found_apps: found, connections, ready, connections_ready: ready,
+        machine_ready: machine && !['unknown', 'unavailable'].includes(machine.state) ? machine.state === 'ready' && machine.version !== null && machine.version > 0 : null,
+        account_error: accountError, machine,
         demo: { prompt: DEMO_PROMPT, project: 'Daylight (sample)', prepare: shard(['setup', '--prepare-sample', '--json']) },
         activity: values.activity === true && typeof values.workspace === 'string' ? await liveActivity(ctx, values.workspace) : null,
         steps: [
             { id: 'account', title: 'Sign in to Shardflux', status: connected ? 'complete' : 'available', command: shard(['signup']) },
             { id: 'connect', title: 'Connect Claude, Codex or both', status: ready ? 'complete' : 'available' },
             { id: 'demo', title: 'Try it once: your agent’s own computer', status: done(state?.demo_finished) ? 'complete' : 'available',
-                action: 'Copy the task and press ⌥⇧Space. Paste the task, then Start. The agent installs what it needs, starts it and tests it in its own browser.' },
+                action: `Copy the task. ${press('paste the task, then Start.')} The agent installs what it needs, starts it and tests it in its own browser.` },
             { id: 'own', title: 'Your own project', status: done(state?.own_key) ? 'complete' : 'available',
-                action: 'Press ⌥⇧Space, pick your project and describe what you want.' },
+                action: press('pick your project and describe what you want.') },
         ],
     };
 }
@@ -305,7 +336,10 @@ export function onboardingText(report) {
     const names = { account: 'Shardflux', claude: 'Claude', codex: 'Codex', t3: 'T3 Code' };
     const mark = { verified: '✓', action: '!', pending: '…', unknown: '?', info: '·' };
     const lines = report.connections.filter(c => c.id === 'account' || c.picked || c.id === 't3').map(c => `${mark[c.state]} ${names[c.id]}: ${c.fact}${c.action?.command ? ` (${c.action.command.join(' ')})` : ''}`);
-    return `${lines.join('\n')}\n${report.ready ? `Ready. Try it once: ${report.demo.prompt}` : 'Not ready yet: finish the steps above, then run this again.'}\n`;
+    const machineMark = { ready: '✓', saving: '…', failed: '!', none: '·', unknown: '?', unavailable: '?' };
+    if (report.machine)
+        lines.push(`${machineMark[report.machine.state]} ${rowText(report.machine)}`);
+    return `${lines.join('\n')}\n${report.ready ? `Agent connections ready. Try it once: ${report.demo.prompt}` : 'Connections not ready yet: finish the steps above, then run this again.'}\n`;
 }
 /** What a person recognises, most telling first: installs, then how the app is run, then what it runs. */
 const RANKS = [/^(sudo|apt|apt-get|dpkg)$/, /^(npm|npx|pnpm|yarn|bun)$/, /^(node|python[0-9.]*|uv|vite|next|deno|docker|cargo|go|make)$/, /^(pip[0-9.]*|inotifywait)$/];