@shardflux/cli 0.18.1 → 0.19.1

package/CHANGELOG.md

@@ -1,6 +1,98 @@
 # Changelog
 
-## 0.18.1 (not yet published)
+## 0.19.1 (not yet published)
+
+- A first prompt is never lost to a slow or unusual start. `--prompt` / `--prompt-file` types the prompt only into the
+  agent's input box, never into one of its dialogs ("❯ 1. Yes"). If the terminal never shows the input box and
+  nothing was typed, the prompt goes to the conversation's own inbox, which delivers it once the agent reads input.
+  `--json` then reports `"initial_prompt": {"submitted": false, "queued": true}` instead of failing with
+  `initial_prompt_failed`.
+- Brings the Shardflux app for Ubuntu 0.1.3: Try it once never waits silently. A demo agent still waiting with nothing
+  said 45 s after its start gets its task once more through its conversation, and one line says so; still nothing
+  45 s later, one line says it hasn't started. The optional dependency on `@shardflux/desktop-linux-x64` / `-arm64` is
+  exactly 0.1.3.
+
+## 0.19.0 (2026-10-11)
+
+- A new conversation on an account without a saved machine gets its first prompt in seconds, whatever is in
+  `~/.claude` and `~/.codex`. The prompt is typed first, and this computer's Claude and Codex config is copied into
+  the VM after the start, by a detached `shard` that the starting command does not wait for (its one-line result goes
+  to `agent-config-sync.log` in the config directory). Before, the copy ran first, one request per file: a config with
+  3,000 files held the prompt back for over 5 minutes.
+- The config copy sends a pass as one archive and one command in the VM instead of a check and a write per file
+  (3,090 files: 6.6 s including plugin installs, an unchanged copy 1 s). The rules stay the same: a file you changed
+  in the VM is never overwritten or removed, and a path that is not a regular file there is skipped.
+- Claude Code plugins are installed by the VM's own Claude Code (`claude plugin marketplace add` and `claude plugin
+  install --scope user` for each user-scope plugin) instead of copying plugin caches and marketplace clones, so
+  Linux builds of each plugin are used. Codex's bundled `~/.codex/skills/.system` is left to the VM's Codex. A plugin
+  from a marketplace on a local folder is listed as skipped.
+- A config file that does not parse (`~/.claude.json`, `~/.codex/config.toml`, the plugin registries) is skipped with
+  its reason; the rest of the config is still copied.
+- A start reaches the agent about 7 s sooner: the snapshot of the working tree a conversation starts from is still
+  recorded before the agent starts, and its copy to the project's shared history now finishes in the background
+  (staging: Start to the first prompt typed 10.0 s, from 17.1 s).
+- `shard setup --inspect`'s demo step reads "Paste the task, then Start.": the launcher opens on Daylight (sample).
+- A conversation start tells the launcher which phase it is in (for the Mac menu bar and the Ubuntu app's phase line
+  under **Starting…**): with `SHARDFLUX_PROGRESS_FILE` naming a private file the launcher created, `shard agents new`
+  rewrites it atomically with one JSON line each time the phase changes, `{"phase":"copy_changes","line":"Copying
+  your changes…"}`. Phases: `computer` (Starting a computer…), `project` (Getting your project…), `checkout` (Checking
+  out your files…), `copy_changes` (Copying your changes…) and `harness` (Starting Claude… / Starting Codex…). Nothing
+  is written without the variable; a symlink, a file or directory others can read or write, or a file the launcher
+  already removed is never written.
+- T3 Code (stable 0.0.45) connects with T3 Connect, once per person: `shard setup --inspect --t3-connect --json`
+  starts the sign-in, and its `t3` row carries the page and code (`t3_link`). Once it is approved the row is
+  `verified` per account (`Your projects appear in T3 Code and the T3 app.`, or `<project> is linked to your T3
+  account.` for the newest project set up for T3 Code), and every project set up for T3 Code appears in T3 Code and
+  the T3 app signed in to that account. With the sign-in, `agents targets` reports T3 Code connected for every
+  project, so a project's first thread can start in T3 Code: it is linked first, then the thread starts. Without the
+  sign-in the row offers **Connect T3 Code**; `next` still names `shard agents new --in t3 --path <project>` for
+  scripts. `shard agents new|open --in t3` says the project is linked to your T3 account instead of how to add an SSH
+  environment, and the first time a project is set up for T3 Code it opens T3 on its Connections page
+  (`t3code://app/settings/connections`) once the project is linked (on Linux through T3's registered URL handler, else
+  T3 Code opens). The project's SSH host is still configured for anyone who adds it in T3 Code themselves.
+- Brings the Shardflux app for Ubuntu 0.1.2: T3 Code connects from the first run like Claude and Codex (one T3
+  Connect sign-in), and your own project starts in T3 Code. The optional dependency on
+  `@shardflux/desktop-linux-x64` / `-arm64` is exactly 0.1.2.
+
+- `shard usage` shows GPU-hours on plans that include them: a `GPU-hours` line with the hours used of those included,
+  the hours past them and the part billed as overage, and while the GPU is stopped a `GPU` line naming the reason
+  (`allowance_used`, `overage_paused`, `spend_cap_reached`) and what brings it back (turn on overage, upgrade, pay the
+  invoice, raise the cap, or the period reset). Workspaces keep running meanwhile. `shard billing overage` lists the
+  GPU-hour rate, and a 402 `entitlement_required` `not_included` refusal gets an upgrade hint naming the plans that
+  include the feature (the GPU: Startup or Scale). Needs SDK 0.25.0.
+
+- `shard move`: a Claude Code or Codex session on this computer continues in the cloud as the same session, with its
+  full history. `shard move --last` in the project folder moves its newest session (`--claude` or `--codex` to
+  choose), `--session <id>` a given one, and `--list` shows the project's sessions and where moved ones continue; `--json`
+  for scripts and apps, `--detach` to start it without opening it here. A running turn finishes here first. The
+  conversation starts from your project exactly as it is, uncommitted edits included (your working tree, index and
+  branch are untouched), its VM resumes the session (`claude --resume`, `codex resume`) with its paths moved to the
+  VM's folder, and the session's transcript is in the project space from the start. The cloud work comes back to
+  your checkout by itself, and typing in the local Claude Code copy shows one line that it now continues in the cloud.
+  Sessions from Claude Desktop's Code tab and the Codex app move the same way. Needs SDK 0.25.0.
+- When a moved session's conversation ends, its transcript comes back to the file it left on this computer, as long as
+  nobody continued that local copy meanwhile (the copy it replaces stays in the conversation's stash).
+- Claude Code's folder name for a long project path (above 200 characters) is the one Claude Code uses, so finished
+  conversations of such projects appear in its own history.
+- A new conversation's VM gets your project from Git: HEAD is checked out in the VM, and only what differs from HEAD
+  on this computer is copied (changed, added and untracked files Git does not ignore, `.env*` files, Git LFS files,
+  deletions), from `git status`, not a hash of every file. A project's file count, size and history no longer refuse
+  a start (`repository_too_large` is gone): a history above 32 MiB comes from origin as a blobless partial clone (all
+  commits and trees; HEAD's files in one request; the rest backfills in the background at the lowest priority), and
+  without a reachable origin the history bundle streams from this computer in chunks of any size. The only start
+  refusal left, a folder inside another repository, comes before a VM is allocated. `SHARDFLUX_TRACE_SEED=1` prints
+  each start phase's duration on stderr.
+- Project sync carries a project of any shape: no file-count limit and no per-file size limit. Files above 8 MiB
+  stream both ways one chunk at a time (verified against their hash, never held whole in memory), files older VMs
+  leave out of their manifest for size are hashed in the VM, and only what a VM cannot hold is reported as skipped
+  (sockets and devices, nested repositories, names with a backslash) instead of failing the sync. A path that turns
+  from a directory into a file (or back) syncs both ways.
+- The live twin's snapshot and landing carry files and bundles of any size (streamed from and to disk); the 64 MiB
+  per-file hold and the 256 MiB transfer bound are gone.
+- Conversation transcripts of any size mirror into the local stash (read in chunks, checked as UTF-8 and against
+  their hash); the 64 MiB mirror bound is gone. The project router copies history of any size between VMs.
+
+## 0.18.1 (2026-10-10)
 
 - `shard agents logs` takes a conversation id (`shard agents logs conv_… --json`) and follows that conversation's own
   terminal: the PTY its computer recorded for it (a fork's inherited one included), also when you name the

package/README.md

@@ -129,6 +129,21 @@ keeps the agent's own choice. The conversation keeps its model and effort when i
 adds `model_choice: {model, effort, applied}`. `shard agents targets --json` lists the choices as `models`, with menu
 and pill text and the agent's own default, so apps never hardcode them. `--in t3` passes them to T3 Code.
 
+Move a session from this computer to the cloud (0.19.0+): it continues there as the same Claude Code or Codex
+session, with its full history, from your project exactly as it is.
+
+```sh
+shard move --last                  # this project's newest session (--claude or --codex to choose)
+shard move --list                  # the project's sessions, and where moved ones continue
+shard move --session 3d085e35-aa66-4866-9a53-f09719d6767c --detach --json
+```
+
+A running turn finishes here first. Uncommitted edits come along, and your working tree, index and branch stay as
+they are. The cloud work comes back to your checkout by itself, and typing in the local Claude Code copy shows one line
+that it continues in the cloud. Sessions from Claude Desktop's Code tab and the Codex app move the same way; in the
+macOS menu bar, a project's recent sessions have **Move to cloud** in their ⋯ menu, and with the Shardflux MCP server
+you can ask the agent itself to continue in the cloud.
+
 Start a thread in T3 Code from the command line (0.17.0+):
 
 ```sh
@@ -1039,6 +1054,18 @@ names `details.reason`, and a hint says what to do (0.5.0+):
 | `spend_cap_reached` | The spend cap is reached: raise it (`shard billing overage cap <dollars>`, at most the plan price) or upgrade. |
 | `overage_paused` | A payment is past due: update the payment method (`shard billing portal --open`). |
 
+GPU-hours (0.19.0+): on plans with GPU-hours, `shard usage` adds a `GPU-hours` line with the hours used of those
+included (and, with overage on, the hours past them and the part billed), and a `GPU` line with the next step whenever
+GPU rendering needs one:
+
+```text
+GPU-hours  3.4 of 25 used
+```
+
+`shard billing overage` lists the GPU-hour rate with the others, and a 402 `entitlement_required` refusal with reason
+`not_included` gets a hint naming the plans that include the feature. [/limits](https://docs.shardflux.dev/limits#gpu-hours)
+has the allowances and the rate.
+
 ## Timing
 
 `--timing` (0.3.0+) says where the time of an open or a wait went. After the call, `shard` prints the lifecycle

package/dist/account-args.js

@@ -209,6 +209,7 @@ export const ACCOUNT_COMMANDS = [
             apps: { type: 'string', multiple: true, value: '<claude,codex>', description: 'The apps to verify (default: the ones found on this Mac). Repeatable or comma separated.' },
             connect: { type: 'boolean', description: 'With --inspect: also copy this Mac’s Codex login and enable the account’s Codex remote device when Codex is picked.' },
             'retry-codex': { type: 'boolean', description: 'With --inspect --connect: start a Codex remote device that failed or is stuck starting again, once.' },
+            't3-connect': { type: 'boolean', description: 'With --inspect: start your T3 Connect sign-in for T3 Code (0.0.45, over SSH); the t3 row carries its page and code (t3_link). After it, your projects appear in T3 Code and the T3 app (0.19.0+).' },
             'org-name': { type: 'string', value: '<name>', description: 'Name of the organization to create when you have none.' },
             'project-name': { type: 'string', value: '<name>', description: 'Name of the project to create when the organization has none (default Default).' },
             'key-name': { type: 'string', value: '<name>', description: 'Name of the API key (default "shard-cli <hostname>").' },

package/dist/agent-commands.d.ts

@@ -23,6 +23,7 @@ export declare function terminal(ctx: Ctx, ws: Workspace, app: 'claude' | 'codex
     pty?: string;
     title?: string;
     choice?: ModelChoice;
+    afterStart?: () => Promise<void> | undefined;
 }): Promise<number>;
 export declare const launchProject: Handler;
 /** The project VM launch; with `--in t3` a first message becomes a thread on the T3 server in it (SSH mode, 0.17.0+). */

package/dist/agent-commands.js

@@ -17,7 +17,7 @@ import { out, resolveWorkspace } from "./commands.js";
 import { savedMachine } from "./filesystem-state.js";
 import { startAgentConfigTunnels, syncAgentConfig } from "./agent-config-sync.js";
 import { rememberGitAgent } from "./agent-git-commands.js";
-import { projectWorkspacePath, seedAgentRepository, workspaceRepositoryPath } from "./agent-repository.js";
+import { preflightProjectSeed, projectWorkspacePath, seedAgentRepository, workspaceRepositoryPath } from "./agent-repository.js";
 import { agentName } from "./agent-git.js";
 import { cloudClaudeLogin, ensureCloudClaude, loginClaudeInWorkspace, requireClaudeTerminal } from "./claude-cloud-login.js";
 import { progress } from "./progress.js";
@@ -28,6 +28,7 @@ import { openInFor } from "./t3-mode.js";
 import { openClaudeDesktopSession, openDesktopWorkspace, queueT3Prewarm } from "./agent-target-commands.js";
 import { submitInitialPrompt, prepareInitialCodexProject } from "./initial-prompt.js";
 import { conversationWorkspace, conversationsUnavailable, getConversation, listConversations, resumeConversation } from "./conversations.js";
+import { conversationClient } from "./conversation-commands.js";
 import { conversationTerminal, reopenConversation } from "./conversation-terminal.js";
 import { CHOICE_PENDING, choiceReport, hasChoice, launchChoice, modelChoice, runFlags } from "./agent-models.js";
 const active = (session) => session.state === 'running' || session.state === 'starting';
@@ -145,15 +146,22 @@ export async function terminal(ctx, ws, app, agent, project, values, setupHash,
                 throw new Error(`project setup could not be queued: ${queued.stderr.trim() || `exit ${queued.exitCode}`}`);
         });
         store.save(project, app);
+        let delivery;
         if (typeof values.initialPrompt === 'string') {
-            await submitInitialPrompt(signal => cellConnector(cell, session.session_id)(0, signal), values.initialPrompt, ws.key, ctx.signal, app, bytes => cell.pty.input(session.session_id, bytes));
+            const text = values.initialPrompt;
+            // A conversation's guest delivers the prompt itself when this terminal never showed its input box (0.19.1+).
+            const queue = conversation ? () => conversationClient(ctx).conversations.send(conversation.id, text, { signal: ctx.signal }) : undefined;
+            delivery = await submitInitialPrompt(signal => cellConnector(cell, session.session_id)(0, signal), text, ws.key, ctx.signal, app, bytes => cell.pty.input(session.session_id, bytes), queue);
         }
+        // Work that must never delay the first prompt (the laptop's agent config, 0.19.0+) starts once the agent has it.
+        const after = conversation?.afterStart?.();
         if (!attach) {
             await preparation;
             // conversation (0.16.0+): which conversation this session is, also when its computer hosts several threads.
             // model_choice (0.17.0+): the requested model and effort, and whether this thread started with them.
-            ctx.io.stdout.write(json({ workspace: ws.data, session, ...(conversation ? { conversation: { id: conversation.id } } : {}), ...(typeof values.initialPrompt === 'string' ? { initial_prompt: { submitted: true } } : {}),
+            ctx.io.stdout.write(json({ workspace: ws.data, session, ...(conversation ? { conversation: { id: conversation.id } } : {}), ...(delivery ? { initial_prompt: delivery === 'submitted' ? { submitted: true } : { submitted: false, queued: true } } : {}),
                 ...(hasChoice(explicit) ? { model_choice: choiceReport(explicit, applied) } : {}) }));
+            await after;
             return 0;
         }
         ctx.io.stderr.write(`Shardflux · ${ws.key}\nDetach: Ctrl-] then d\n`);
@@ -171,7 +179,7 @@ export async function terminal(ctx, ws, app, agent, project, values, setupHash,
                     done();
             }),
         });
-        const [code] = await Promise.all([attached, preparation]);
+        const [code] = await Promise.all([attached, preparation, after]);
         return code;
     }
     finally {
@@ -222,8 +230,10 @@ export async function launchProjectWith(ctx, values, [path = './', explicitApp],
     const labels = projectLabels(project, agent, app);
     const local = like ? projectIdentity(path) : project;
     // A cloud-only --like launch must not initialize an unrelated local checkout.
-    if (!like?.labels.repo_remote || like.labels.repo_remote === (local.remote ?? `file://${local.folder}`))
+    if (!like?.labels.repo_remote || like.labels.repo_remote === (local.remote ?? `file://${local.folder}`)) {
         await ensureProjectGit(ctx, local.folder);
+        await preflightProjectSeed(local.folder, ctx.signal);
+    }
     const cloud = ctx.cloud();
     let existing = await cloud.workspaces.findByKey(`${project.slug}/${agent}`, { includeDeleted: false, signal: ctx.signal });
     const owner = agent === 'main' ? existing : like ?? await cloud.workspaces.findByKey(`${project.slug}/main`, { includeDeleted: false, signal: ctx.signal });

package/dist/agent-config-files.d.ts

@@ -17,7 +17,21 @@ export declare function readObject(file: string): Promise<ObjectValue | undefine
 export declare function collectTree(source: string, dest: string, files: ConfigFiles, issues: ConfigIssue[], parents?: Set<string>): Promise<void>;
 export declare function collectUserFiles(home: string, issues: ConfigIssue[]): Promise<ConfigFiles>;
 export declare function macBinary(bytes: Buffer): boolean;
-/** Preserve v2 install metadata and user-scope records, and copy just the trees needed to load them on Linux. */
-export declare function collectPlugins(home: string, remoteHome: string, files: ConfigFiles, issues: ConfigIssue[]): Promise<Set<string>>;
+/**
+ * Plugins travel as an install plan, never as files (0.19.0+): the VM's own Claude Code adds each marketplace from its
+ * source and installs each user-scope plugin (`claude plugin marketplace add` / `claude plugin install`), so plugin
+ * caches and marketplace clones (thousands of files, often built for macOS) are rebuilt there instead of copied.
+ * A marketplace with a local source cannot be rebuilt in the VM and is listed as skipped.
+ */
+export type PluginPlan = {
+    marketplaces: {
+        name: string;
+        source: string;
+    }[];
+    plugins: string[];
+};
+/** A remote marketplace source as `claude plugin marketplace add` takes it; undefined for a local one. */
+export declare function marketplaceSource(entry: ObjectValue): string | undefined;
+export declare function collectPlugins(home: string, issues: ConfigIssue[]): Promise<PluginPlan>;
 /** Only rewrite paths to files we actually send. Missing laptop paths are never made to look portable. */
 export declare function rewritePaths(value: unknown, home: string, remoteHome: string, files: ConfigFiles, issues: ConfigIssue[], item: string): unknown;

package/dist/agent-config-files.js

@@ -1,5 +1,5 @@
 import { readFile, readdir, realpath, stat } from 'node:fs/promises';
-import { join, relative, resolve } from 'node:path';
+import { join, relative } from 'node:path';
 import { LOCAL_PATH_REASON } from "./agent-config-report.js";
 export const object = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : {};
 export const text = (v) => typeof v === 'string' ? v : undefined;
@@ -48,7 +48,7 @@ export async function collectTree(source, dest, files, issues, parents = new Set
     if (info.isDirectory()) {
         const next = new Set(parents).add(resolved);
         for (const name of (await readdir(resolved)).sort()) {
-            if (excluded.has(name) || name.startsWith('.env.'))
+            if (excluded.has(name) || name.startsWith('.env.') || (dest === '.codex/skills' && name === '.system'))
                 continue;
             await collectTree(join(resolved, name), `${dest}/${name}`, files, issues, next);
         }
@@ -95,70 +95,57 @@ export function macBinary(bytes) {
         return bytes.length >= 8 && bytes.readUInt32BE(4) > 0 && bytes.readUInt32BE(4) <= 20;
     return new Set([0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe, 0xbebafeca, 0xbfbafeca]).has(magic);
 }
-/** Preserve v2 install metadata and user-scope records, and copy just the trees needed to load them on Linux. */
-export async function collectPlugins(home, remoteHome, files, issues) {
-    const skipped = new Set();
+/** A remote marketplace source as `claude plugin marketplace add` takes it; undefined for a local one. */
+export function marketplaceSource(entry) {
+    const source = object(entry.source);
+    const kind = text(source.source);
+    const value = kind === 'github' ? text(source.repo) : kind === 'git' || kind === 'url' ? text(source.url) : undefined;
+    return value && !value.startsWith('-') && !/[\0\r\n]/.test(value) ? value : undefined;
+}
+async function readPluginRegistry(file, item, issues) {
+    try {
+        return await readObject(file);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || /expected an object/.test(String(error))) {
+            issues.push({ item, reason: 'not valid JSON; skipped' });
+            return undefined;
+        }
+        throw error;
+    }
+}
+export async function collectPlugins(home, issues) {
+    const plan = { marketplaces: [], plugins: [] };
     const root = join(home, '.claude/plugins');
-    const installed = await readObject(join(root, 'installed_plugins.json'));
-    if (installed) {
-        const plugins = {};
-        for (const [id, records] of Object.entries(object(installed.plugins))) {
-            const kept = [];
-            for (const raw of Array.isArray(records) ? records : [records]) {
-                const record = object(raw);
-                if (record.scope !== 'user') {
-                    issues.push({ item: `plugin:${id}`, reason: 'project/local scope travels with its repository' });
-                    continue;
-                }
-                const path = text(record.installPath);
-                if (!path || !under(resolve(path), join(root, 'cache'))) {
-                    issues.push({ item: `plugin:${id}`, reason: 'install path is outside the plugin cache' });
-                    continue;
-                }
-                const dest = relative(home, resolve(path));
-                const tree = new Map();
-                const before = issues.length;
-                await collectTree(path, dest, tree, issues);
-                if (issues.length !== before || [...tree.values()].some(f => macBinary(f.content))) {
-                    issues.push({ item: `plugin:${id}`, reason: issues.length !== before ? 'plugin tree is incomplete' : 'contains macOS native binaries; install a Linux version' });
-                    continue;
-                }
-                for (const [name, file] of tree)
-                    files.set(name, file);
-                kept.push({ ...record, installPath: `${remoteHome}/${dest}` });
-            }
-            if (kept.length)
-                plugins[id] = kept;
-            else
-                skipped.add(id);
+    const known = await readPluginRegistry(join(root, 'known_marketplaces.json'), '.claude/plugins/known_marketplaces.json', issues);
+    const local = new Set();
+    for (const [name, raw] of Object.entries(known ?? {})) {
+        const source = marketplaceSource(object(raw));
+        if (source)
+            plan.marketplaces.push({ name, source });
+        else {
+            local.add(name);
+            issues.push({ item: `marketplace:${name}`, reason: 'local marketplace; add it in the VM with claude plugin marketplace add' });
         }
-        files.set('.claude/plugins/installed_plugins.json', { content: Buffer.from(JSON.stringify({ ...installed, plugins }) + '\n'), mode: '0600' });
     }
-    const known = await readObject(join(root, 'known_marketplaces.json'));
-    if (known) {
-        const portable = {};
-        for (const [id, raw] of Object.entries(known)) {
-            const entry = object(raw);
-            const location = text(entry.installLocation);
-            if (!location || !under(resolve(location), join(root, 'marketplaces'))) {
-                issues.push({ item: `marketplace:${id}`, reason: 'marketplace is outside the marketplace directory' });
-                continue;
-            }
-            const dest = relative(home, resolve(location));
-            const tree = new Map();
-            const before = issues.length;
-            await collectTree(location, dest, tree, issues);
-            if (issues.length !== before)
-                continue;
-            // Marketplace source can contain binary packages for other platforms; the installed version is checked above.
-            for (const [name, file] of tree)
-                if (!macBinary(file.content))
-                    files.set(name, file);
-            portable[id] = { ...entry, installLocation: `${remoteHome}/${dest}` };
+    const installed = await readPluginRegistry(join(root, 'installed_plugins.json'), '.claude/plugins/installed_plugins.json', issues);
+    for (const [id, records] of Object.entries(object(installed?.plugins))) {
+        const user = (Array.isArray(records) ? records : [records]).some(r => object(r).scope === 'user');
+        if (!user) {
+            issues.push({ item: `plugin:${id}`, reason: 'project/local scope travels with its repository' });
+            continue;
+        }
+        if (!/^[A-Za-z0-9._-]+(?:@[A-Za-z0-9._-]+)?$/.test(id)) {
+            issues.push({ item: `plugin:${id}`, reason: 'not a plugin@marketplace id' });
+            continue;
+        }
+        if (local.has(id.split('@')[1] ?? '')) {
+            issues.push({ item: `plugin:${id}`, reason: 'its marketplace is local to this computer' });
+            continue;
         }
-        files.set('.claude/plugins/known_marketplaces.json', { content: Buffer.from(JSON.stringify(portable) + '\n'), mode: '0600' });
+        plan.plugins.push(id);
     }
-    return skipped;
+    return plan;
 }
 /** Only rewrite paths to files we actually send. Missing laptop paths are never made to look portable. */
 export function rewritePaths(value, home, remoteHome, files, issues, item) {

package/dist/agent-config-sync.d.ts

@@ -28,6 +28,8 @@ export type ConfigManifest = {
         hash: string;
         created: boolean;
     }>;
+    /** The plugin install plan last applied in the VM (0.19.0+): an unchanged plan is not installed again. */
+    plugins_hash?: string;
     skipped: ConfigIssue[];
     mcp: McpStatus[];
     tunnels: ConfigTunnel[];
@@ -44,12 +46,21 @@ export type ConfigSyncResult = {
 export declare function configManifests(ctx: Pick<Ctx, 'store'>): Record<string, ConfigManifest>;
 /** `like` must not inherit generated MCP secrets restricted to the source workspace. */
 export declare function agentConfigLikeSecrets(ctx: Ctx, reference: string): Promise<string[] | undefined>;
-export declare function applyConfigFiles(cell: CellClient, home: string, files: ConfigFiles, previous: Record<string, ManifestFile>, trustManifest: boolean, issues: ConfigIssue[], signal: AbortSignal, deleteMissing?: boolean, progress?: (path: string, file: ManifestFile | undefined) => void): Promise<{
+/** At least this many files to check go into the VM as one archive and one command instead of a stat and a write each. */
+export declare const BULK_MIN_FILES = 8;
+export declare function applyConfigFiles(cell: CellClient, home: string, files: ConfigFiles, previous: Record<string, ManifestFile>, trustManifest: boolean, issues: ConfigIssue[], signal: AbortSignal, deleteMissing?: boolean, progress?: (path: string, file: ManifestFile | undefined) => void, trusted?: ReadonlySet<string>): Promise<{
     files: Record<string, ManifestFile>;
     copied: string[];
     removed: string[];
 }>;
 export declare function syncAgentConfig(ctx: Ctx, ws: Workspace): Promise<ConfigSyncResult>;
+/**
+ * Copies the laptop's agent config into a new conversation's VM after its agent started (0.19.0+): the first prompt
+ * never waits for it. From an installed shard it runs as its own detached process (`shard agents config-sync`, its
+ * output in agent-config-sync.log of the config directory), so the command that started the conversation reports the
+ * start at once; without a runtime (tests, an embedding) it runs here and the returned promise settles when it ends.
+ */
+export declare function syncAgentConfigAfterStart(ctx: Ctx, ws: Workspace): Promise<void> | undefined;
 /** Tunnels are owned by the attachment, and close even if the terminal fails or the user detaches. */
 export declare function startAgentConfigTunnels(ctx: Ctx, ws: Workspace): Promise<{
     stop(): Promise<void>;