@shardflux/cli 0.18.0 → 0.19.0

package/dist/project-sync.js

@@ -4,8 +4,8 @@ import { lstat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { AgentStateStore } from "./agent-state.js";
 import { projectWorkspacePath, seedAgentRepository } from "./agent-repository.js";
-import { contentIdentity, diffManifests, excludedSyncPath, ignoredProjectPaths, localManifest, MAX_SYNC_FILE_BYTES, parseManifest } from "./project-sync-manifest.js";
-import { applyLocalSyncFile, applyRemoteSyncBatch, readLocalSyncFile, readRemoteSyncFile } from "./project-sync-transfer.js";
+import { contentIdentity, diffManifests, excludedSyncPath, ignoredProjectPaths, localManifest, parseManifest } from "./project-sync-manifest.js";
+import { copyLocalSyncFile, pullRemoteFile, pushLocalFiles, remoteManifest } from "./project-sync-transfer.js";
 export { projectWorkspacePath } from "./agent-repository.js";
 /** L8 can read these reports without creating a watcher or touching a VM. */
 export function projectSyncConflicts(dir, key) {
@@ -22,7 +22,7 @@ export function projectReconciler(options) {
     const run = async () => {
         signal?.throwIfAborted();
         const localRaw = await localManifest(folder, signal, cache, Object.keys(state.common));
-        const remoteRaw = await cell.files.manifest(root, { maxFileBytes: MAX_SYNC_FILE_BYTES, knownPaths: [...new Set([...Object.keys(state.common), ...localRaw.entries.map((entry) => entry.path)])], signal });
+        const remoteRaw = await remoteManifest(cell, root, [...new Set([...Object.keys(state.common), ...localRaw.entries.map((entry) => entry.path)])], signal);
         const localPaths = new Set(localRaw.entries.map((entry) => entry.path));
         const alreadySkipped = new Set(localRaw.skipped.map((entry) => entry.path));
         for (const path of await ignoredProjectPaths(folder, remoteRaw.entries.map((entry) => entry.path).filter((path) => !localPaths.has(path) && !alreadySkipped.has(path)), signal))
@@ -36,24 +36,10 @@ export function projectReconciler(options) {
             }
         }
         const changes = diffManifests(local, remote, state.common, Date.now(), blocked);
-        let batch = new Map();
-        let expected = Object.create(null);
-        let batchBytes = 0;
-        const flush = async () => {
-            if (batch.size === 0)
-                return;
-            await applyRemoteSyncBatch(cell, root, batch, expected, signal);
-            batch = new Map();
-            expected = Object.create(null);
-            batchBytes = 0;
-        };
-        const upload = async (path, file, previous) => {
-            if (batch.size >= 128 || batchBytes + (file?.data.length ?? 0) > 8 << 20)
-                await flush();
-            batch.set(path, file);
-            expected[path] = previous;
-            batchBytes += file?.data.length ?? 0;
-        };
+        // Laptop-side deletions run before writes and VM-side deletions before uploads, so a directory can become a file.
+        const pushes = [], removals = [];
+        const expected = Object.create(null);
+        const pulls = [];
         for (const change of changes) {
             signal?.throwIfAborted();
             const { path, winner } = change;
@@ -74,28 +60,39 @@ export function projectReconciler(options) {
                 if (remote[copy])
                     copy += `-${randomUUID()}`;
                 if (loserEntry) {
-                    const losing = winner === 'local' ? await readRemoteSyncFile(cell, root, loserEntry) : await readLocalSyncFile(folder, loserEntry);
-                    const backup = { ...losing, entry: { ...losing.entry, path: copy } };
-                    await applyLocalSyncFile(folder, copy, backup);
-                    await upload(copy, backup);
-                    // Preserve both copies before modifying either original.
-                    await flush();
+                    // Preserve both copies before modifying either original: the losing version lands here, then in the VM.
+                    const backup = { ...loserEntry, path: copy };
+                    if (winner === 'local')
+                        await pullRemoteFile(cell, root, folder, copy, backup, { from: path, signal });
+                    else
+                        await copyLocalSyncFile(folder, loserEntry, copy);
+                    await pushLocalFiles(cell, root, folder, [backup], [], { signal });
                 }
                 const conflict = { path, copy: loserEntry ? copy : null, losingDeleted: !loserEntry, agent, winner, at: Date.now() };
                 state.conflicts.push(conflict);
                 save(state);
                 report(`Project sync conflict ${path}: ${winner} wins; ${conflict.copy ?? 'the other side deleted the file'}`);
             }
-            const file = winnerEntry ? (winner === 'local' ? await readLocalSyncFile(folder, winnerEntry) : await readRemoteSyncFile(cell, root, winnerEntry)) : undefined;
-            if (winner === 'local')
-                await upload(path, file, remote[path]);
+            if (winner === 'local') {
+                if (winnerEntry)
+                    pushes.push(winnerEntry);
+                else
+                    removals.push(path);
+                expected[path] = remote[path];
+            }
             else
-                await applyLocalSyncFile(folder, path, file, local[path]);
+                pulls.push({ path, ...(winnerEntry ? { entry: winnerEntry } : {}), ...(local[path] ? { expected: local[path] } : {}) });
         }
-        await flush();
+        for (const pull of pulls)
+            if (!pull.entry)
+                await pullRemoteFile(cell, root, folder, pull.path, undefined, { ...(pull.expected ? { expected: pull.expected } : {}), signal });
+        for (const pull of pulls)
+            if (pull.entry)
+                await pullRemoteFile(cell, root, folder, pull.path, pull.entry, { ...(pull.expected ? { expected: pull.expected } : {}), signal });
+        await pushLocalFiles(cell, root, folder, pushes, removals, { signal, expected });
         // Only observed equality advances the durable common hash. Changes made
         // during transfer remain relative to the previous common hash on next run.
-        const [afterLocal, afterRemote] = changes.length === 0 ? [localRaw, remoteRaw] : await Promise.all([localManifest(folder, signal, cache, Object.keys(state.common)), cell.files.manifest(root, { maxFileBytes: MAX_SYNC_FILE_BYTES, knownPaths: Object.keys(state.common), signal })]);
+        const [afterLocal, afterRemote] = changes.length === 0 ? [localRaw, remoteRaw] : await Promise.all([localManifest(folder, signal, cache, Object.keys(state.common)), remoteManifest(cell, root, Object.keys(state.common), signal)]);
         const l = parseManifest(afterLocal), r = parseManifest(afterRemote);
         for (const path of new Set([...Object.keys(l), ...Object.keys(r), ...Object.keys(state.common)])) {
             if (blocked.has(path))

package/dist/seed-phases.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The start path's phase clock. SHARDFLUX_TRACE_SEED=1 prints how long each phase of a conversation start took
+ * (`seed <phase> <ms> ms`) on stderr, for measurements and support. Silent otherwise.
+ *
+ * The same marks drive the launchers' phase line (0.19.0+): with SHARDFLUX_PROGRESS_FILE set to a private file the
+ * launcher created, a start rewrites that file with the phase it is in, as one JSON line
+ * (`{"phase":"copy_changes","line":"Copying your changes…"}`), each time the phase changes. Nothing is written
+ * without the variable, and a path that is not the caller's own private regular file is never written.
+ */
+export type StartPhase = 'computer' | 'project' | 'checkout' | 'copy_changes' | 'harness';
+type App = 'claude' | 'codex';
+export declare const startPhaseLine: (phase: StartPhase, app: App) => string;
+export declare function seedPhase(name: string, env?: Record<string, string | undefined>): void;
+/** A conversation start begins: the launcher's file (if any) is remembered and the first phase is written. */
+export declare function startProgress(app: App, env?: Record<string, string | undefined>): void;
+/** Moves the current start to this phase; the file is rewritten only when the phase changes. */
+export declare function startPhase(phase: StartPhase): void;
+/**
+ * The caller's own private file in the caller's own private directory: a regular file (a symlink is refused, never
+ * followed) owned by this user with no group or other access, in a directory owned by this user that nobody else can
+ * write to. A file the launcher already removed is not created again.
+ */
+export declare function privateProgressFile(file: string): boolean;
+/** Atomic: a sibling written exclusively (O_EXCL never follows a link), then renamed over the file. Never throws. */
+export declare function writeProgress(file: string, doc: {
+    phase: StartPhase;
+    line: string;
+}): boolean;
+export {};

package/dist/seed-phases.js

@@ -0,0 +1,83 @@
+import { closeSync, lstatSync, openSync, renameSync, unlinkSync, writeSync } from 'node:fs';
+import { dirname, isAbsolute } from 'node:path';
+const LINES = {
+    computer: 'Starting a computer…',
+    project: 'Getting your project…',
+    checkout: 'Checking out your files…',
+    copy_changes: 'Copying your changes…',
+};
+export const startPhaseLine = (phase, app) => phase === 'harness' ? `Starting ${app === 'codex' ? 'Codex' : 'Claude'}…` : LINES[phase];
+/** seedPhase marks the END of a phase: the phase that starts there. Unlisted marks stay in the current phase. */
+const NEXT = {
+    vm_running: 'project',
+    apply_history: 'checkout',
+    local_changes: 'checkout',
+    checkout_head: 'copy_changes',
+    seed_done: 'harness',
+};
+let last = performance.now();
+let target = null;
+export function seedPhase(name, env = process.env) {
+    const now = performance.now();
+    if (env.SHARDFLUX_TRACE_SEED)
+        process.stderr.write(`seed ${name} ${Math.round(now - last)} ms\n`);
+    last = now;
+    const next = NEXT[name];
+    if (next)
+        startPhase(next);
+}
+/** A conversation start begins: the launcher's file (if any) is remembered and the first phase is written. */
+export function startProgress(app, env = process.env) {
+    const file = env.SHARDFLUX_PROGRESS_FILE;
+    target = file ? { file, app, phase: null } : null;
+    startPhase('computer');
+}
+/** Moves the current start to this phase; the file is rewritten only when the phase changes. */
+export function startPhase(phase) {
+    if (!target || target.phase === phase)
+        return;
+    target.phase = phase;
+    writeProgress(target.file, { phase, line: startPhaseLine(phase, target.app) });
+}
+/**
+ * The caller's own private file in the caller's own private directory: a regular file (a symlink is refused, never
+ * followed) owned by this user with no group or other access, in a directory owned by this user that nobody else can
+ * write to. A file the launcher already removed is not created again.
+ */
+export function privateProgressFile(file) {
+    if (!isAbsolute(file) || typeof process.getuid !== 'function')
+        return false;
+    const uid = process.getuid();
+    try {
+        const stat = lstatSync(file), dir = lstatSync(dirname(file));
+        return stat.isFile() && stat.uid === uid && (stat.mode & 0o077) === 0
+            && dir.isDirectory() && dir.uid === uid && (dir.mode & 0o022) === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** Atomic: a sibling written exclusively (O_EXCL never follows a link), then renamed over the file. Never throws. */
+export function writeProgress(file, doc) {
+    if (!privateProgressFile(file))
+        return false;
+    const temp = `${file}.${process.pid}.${Math.random().toString(36).slice(2, 10)}.tmp`;
+    try {
+        const fd = openSync(temp, 'wx', 0o600);
+        try {
+            writeSync(fd, `${JSON.stringify(doc)}\n`);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(temp, file);
+        return true;
+    }
+    catch {
+        try {
+            unlinkSync(temp);
+        }
+        catch { /* never created */ }
+        return false;
+    }
+}

package/dist/t3-launch.js

@@ -125,7 +125,9 @@ export async function openT3Conversation(ctx, conversationId, values = {}) {
         return 0;
     }
     // Its VM as T3's SSH environment, with the checks every `agents open t3` makes: --reachable and the cloud Claude login.
-    let ws = await conversationWorkspace(ctx, conversation);
+    // A conversation whose VM was removed restores into a fresh one first (0.18.1+).
+    const { reopenConversation } = await import("./conversation-terminal.js");
+    let { ws } = await reopenConversation(ctx, conversation, values);
     if (values.reachable !== undefined)
         ws = await ctx.cloud().workspaces.open({ key: ws.key, ...agentReachability(values), wait: false });
     // A pooled thread (0.18.0+) runs on the account hub, not on the account's cloud Claude login.

package/dist/t3-mode.d.ts

@@ -64,7 +64,8 @@ export { t3HomeDir };
 export declare function t3ProviderRegistered(env: Record<string, string | undefined>): boolean;
 /**
  * T3 is connected when a new thread can start in it now: in ACP mode the Shardflux provider is in T3's settings and
- * this computer is signed in; in SSH mode this project has a T3 SSH environment set up from this computer (signed in).
+ * this computer is signed in; in SSH mode the account has its T3 Connect sign-in (0.19.0+: any project is set up on its
+ * first thread and linked to the person's T3 account), or this project has a T3 SSH environment set up from here.
  * `last_used_at` is looked up only when asked for (`agents targets`).
  */
 export declare function t3Status(ctx: Ctx, opts?: {
@@ -104,7 +105,11 @@ export declare function t3ThreadTitle(prompt: string): string;
  * shares one bundle id, so `open -b` could start another installed channel); on Linux its desktop entry with
  * `gtk-launch`, else its program (t3-linux.ts).
  */
-export declare function openT3(env: Record<string, string | undefined>, install: Pick<T3Install, 'path' | 'version' | 'linux'> | undefined): Promise<void>;
+/**
+ * Brings T3 Code to the front; `page` (a t3code://app/settings/… link, which T3 0.0.45 routes) opens it on that page.
+ * On Linux the page goes through T3's own URL handler (registered by the app with xdg-mime); without one, T3 opens.
+ */
+export declare function openT3(env: Record<string, string | undefined>, install: Pick<T3Install, 'path' | 'version' | 'linux'> | undefined, page?: string): Promise<void>;
 /** Starts the thread in the VM's T3 server (T3_THREAD_SCRIPT); the prompt travels on stdin, never in argv. */
 export declare function startSshThread(ctx: Ctx, ws: Workspace, version: string | undefined, projectPath: string, request: T3ThreadRequest): Promise<T3ThreadResult>;
 interface Descriptor {

package/dist/t3-mode.js

@@ -111,7 +111,8 @@ function sameProject(key, slug) {
 }
 /**
  * T3 is connected when a new thread can start in it now: in ACP mode the Shardflux provider is in T3's settings and
- * this computer is signed in; in SSH mode this project has a T3 SSH environment set up from this computer (signed in).
+ * this computer is signed in; in SSH mode the account has its T3 Connect sign-in (0.19.0+: any project is set up on its
+ * first thread and linked to the person's T3 account), or this project has a T3 SSH environment set up from here.
  * `last_used_at` is looked up only when asked for (`agents targets`).
  */
 export function t3Status(ctx, opts = {}) {
@@ -120,7 +121,8 @@ export function t3Status(ctx, opts = {}) {
         return { installed: false, mode: null, connected: false, version: null, last_used_at: null };
     const connected = acpSignedIn(ctx) && (install.mode === 'acp'
         ? t3ProviderRegistered(ctx.io.env)
-        : !!opts.project && new AgentStateStore(ctx.store.dir).t3Environments(ctx.apiUrl).some(e => sameProject(e.workspace, opts.project)));
+        : new AgentStateStore(ctx.store.dir).t3Connected(ctx.apiUrl)
+            || !!opts.project && new AgentStateStore(ctx.store.dir).t3Environments(ctx.apiUrl).some(e => sameProject(e.workspace, opts.project)));
     return { installed: true, mode: install.mode, connected, version: install.version, last_used_at: opts.lastUsed ? lastUsedDates(ctx, usagePaths(ctx, install).paths)[install.path] ?? null : null };
 }
 /** T3 and the other installed desktop apps whose last use decides the default: one Spotlight lookup covers them all. */
@@ -214,13 +216,28 @@ export function t3ThreadTitle(prompt) {
  * shares one bundle id, so `open -b` could start another installed channel); on Linux its desktop entry with
  * `gtk-launch`, else its program (t3-linux.ts).
  */
-export async function openT3(env, install) {
+/**
+ * Brings T3 Code to the front; `page` (a t3code://app/settings/… link, which T3 0.0.45 routes) opens it on that page.
+ * On Linux the page goes through T3's own URL handler (registered by the app with xdg-mime); without one, T3 opens.
+ */
+export async function openT3(env, install, page) {
     if (!install)
         throw t3NotInstalled();
+    // T3 0.0.45 routes a t3code://app/settings/… link only into a window that exists (DesktopClerk resumeProviderAuth),
+    // so T3 is opened first and the page follows once its window is up.
+    if (page) {
+        await openT3(env, install);
+        await delay(T3_PAGE_DELAY_MS);
+        if (install.linux) {
+            await openLinuxT3Page(env, page);
+            return;
+        }
+    }
     if (install.linux)
         return openLinuxT3(env, { path: install.path, version: install.version, linux: install.linux });
-    // As on Linux: an inherited ELECTRON_RUN_AS_NODE would start T3 as plain Node (t3OpenEnv).
-    const child = spawn('open', ['-a', install.path], { env: t3OpenEnv(env), stdio: 'ignore' });
+    // As on Linux: an inherited ELECTRON_RUN_AS_NODE would start T3 as plain Node (t3OpenEnv). `open -a` hands the page
+    // to the detected install itself (T3 channels share one bundle id).
+    const child = spawn('open', ['-a', install.path, ...(page ? [page] : [])], { env: t3OpenEnv(env), stdio: 'ignore' });
     await new Promise((resolve, reject) => {
         const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('T3 Code did not open in time')); }, 10_000);
         child.once('error', e => { clearTimeout(timer); reject(e); });
@@ -230,6 +247,23 @@ export async function openT3(env, install) {
             reject(new Error(`could not open T3 Code (open exited ${code})`)); });
     });
 }
+/** How long T3 gets to show its window before a page link (a cold start takes about two seconds on a Mac). */
+const T3_PAGE_DELAY_MS = 2500;
+/** A t3code:// page through T3's registered handler on Linux: false when none is registered (or xdg-open fails). */
+async function openLinuxT3Page(env, page) {
+    const run = (command, args) => new Promise(resolve => {
+        let out = '';
+        const child = spawn(command, args, { env: t3OpenEnv(env), stdio: ['ignore', 'pipe', 'ignore'] });
+        const timer = setTimeout(() => { child.unref(); resolve({ code: null, out }); }, 5000);
+        child.stdout?.on('data', (chunk) => { out += chunk.toString(); });
+        child.once('error', () => { clearTimeout(timer); resolve({ code: null, out }); });
+        child.once('exit', code => { clearTimeout(timer); resolve({ code, out }); });
+    });
+    const handler = await run('xdg-mime', ['query', 'default', 'x-scheme-handler/t3code']);
+    if (handler.code !== 0 || !handler.out.trim())
+        return false;
+    return (await run('xdg-open', [page])).code === 0;
+}
 // ── SSH mode: the T3 server in the project VM ──────────────────────────────────────────────────────────────────────
 /** Starts the thread in the VM's T3 server (T3_THREAD_SCRIPT); the prompt travels on stdin, never in argv. */
 export async function startSshThread(ctx, ws, version, projectPath, request) {

package/dist/thread-on-computer.js

@@ -11,6 +11,7 @@ import { table } from "./format.js";
 import { AgentStateStore } from "./agent-state.js";
 import { normalizeRemote, projectIdentity } from "./project-identity.js";
 import { progress } from "./progress.js";
+import { startPhase, startProgress } from "./seed-phases.js";
 import { conversationClient } from "./conversation-commands.js";
 import { conversationEnded, conversationName, conversationWorkspace, getConversation, listConversations, localConversations, rememberConversation, validateConversation, waitThreadReady } from "./conversations.js";
 import { syncAgentCredentials } from "./agent-credentials.js";
@@ -160,7 +161,10 @@ export async function startThreadOn(ctx, values, path, explicitApp) {
     else
         await ensureCodexCloud(ctx);
     progress(ctx, `Starting ${app === 'claude' ? 'Claude' : 'Codex'} on the computer with ${target.title || target.key}…`);
+    // The launcher's phase line (0.19.0+): the computer wakes, then the thread's harness starts on it.
+    startProgress(app, ctx.io.env);
     const ws = await conversationWorkspace(ctx, target);
+    startPhase('harness');
     const commit = await targetHead(ws, target, ctx.signal);
     const baseBranch = target.base_branch ?? undefined;
     await uploadInitialImages(ws.cell(), images, ctx.signal);

package/dist/worktree-twin.d.ts

@@ -1,7 +1,5 @@
 import type { CellClient } from '@shardflux/sdk';
 import { AgentStateStore } from './agent-state.js';
-/** Files above this stay at HEAD's version in a twin (the bound the seed copy already uses). */
-export declare const TWIN_MAX_FILE_BYTES: number;
 /** A file the landing rewrites must be untouched this long first. */
 export declare const QUIET_MS = 2000;
 export declare const HUB_PATH = "/shardflux/project/git/hub.git";
@@ -50,17 +48,15 @@ export interface Snapshot {
     branch: string | null;
     root: string;
     id: string;
-    held: string[];
     headTree: string;
 }
 /**
- * One snapshot commit of the worktree's working state (what `git add -A` sees; `.shard/` and files above the size gate
- * left at HEAD's version), first parent HEAD. Kept as refs/shard/twin/<worktree id>; an unchanged state reuses it.
+ * One snapshot commit of the worktree's working state (what `git add -A` sees, any file size; `.shard/` left out),
+ * first parent HEAD. Kept as refs/shard/twin/<worktree id>; an unchanged state reuses it.
  */
 export declare function snapshotWorktree(info: WorktreeInfo, options: {
     device: string;
     stateDir: string;
-    maxFileBytes?: number;
     now?: Date;
     signal?: AbortSignal;
 }): Promise<Snapshot>;

package/dist/worktree-twin.js

@@ -17,14 +17,10 @@ import { tmpdir } from 'node:os';
 import { basename, dirname, join, relative, resolve, sep } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { AgentStateStore } from "./agent-state.js";
-import { MAX_SYNC_FILE_BYTES } from "./project-sync-manifest.js";
-import { SYNC_CHUNK_BYTES } from "./project-sync-transfer.js";
-/** Files above this stay at HEAD's version in a twin (the bound the seed copy already uses). */
-export const TWIN_MAX_FILE_BYTES = MAX_SYNC_FILE_BYTES;
+import { readSyncFileTo, writeSyncFileFrom } from "./project-sync-transfer.js";
 /** A file the landing rewrites must be untouched this long first. */
 export const QUIET_MS = 2000;
 export const HUB_PATH = '/shardflux/project/git/hub.git';
-const TRANSFER_LIMIT = 256 << 20;
 const INLINE_BYTES = 512 << 10;
 const BACKUP_DAYS = 14;
 const BACKUP_BYTES = 1 << 30;
@@ -111,15 +107,14 @@ export const twinRef = (id) => `refs/shard/twin/${id}`;
 export const hubTwinRef = (device, id) => `refs/shard/twin/${device}/${id}`;
 const identity = (now) => ({ GIT_AUTHOR_NAME: 'Shardflux', GIT_AUTHOR_EMAIL: 'twin@shardflux.dev', GIT_COMMITTER_NAME: 'Shardflux', GIT_COMMITTER_EMAIL: 'twin@shardflux.dev',
     GIT_AUTHOR_DATE: `@${Math.floor(now.getTime() / 1000)} +0000`, GIT_COMMITTER_DATE: `@${Math.floor(now.getTime() / 1000)} +0000` });
-const excludedPath = (path) => path.split('/').some(part => part === '.git' || part === '.shard' || part.includes('.shard-tmp-'));
 /**
- * One snapshot commit of the worktree's working state (what `git add -A` sees; `.shard/` and files above the size gate
- * left at HEAD's version), first parent HEAD. Kept as refs/shard/twin/<worktree id>; an unchanged state reuses it.
+ * One snapshot commit of the worktree's working state (what `git add -A` sees, any file size; `.shard/` left out),
+ * first parent HEAD. Kept as refs/shard/twin/<worktree id>; an unchanged state reuses it.
  */
 export async function snapshotWorktree(info, options) {
     if (!info.head)
         throw new Error('the worktree has no commit yet');
-    const id = worktreeId(info.root), max = options.maxFileBytes ?? TWIN_MAX_FILE_BYTES, signal = options.signal;
+    const id = worktreeId(info.root), signal = options.signal;
     const dir = join(options.stateDir, 'twin');
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     const index = join(dir, `${id}.${process.pid}.${randomBytes(4).toString('hex')}.index`);
@@ -135,23 +130,9 @@ export async function snapshotWorktree(info, options) {
         }
         else
             await git(info.root, ['read-tree', info.head], { env, signal });
-        const candidates = (await git(info.root, ['ls-files', '-z', '-m', '-o', '--exclude-standard'], { signal })).stdout.toString('utf8').split('\0').filter(Boolean);
-        const held = [];
-        for (const path of candidates) {
-            if (excludedPath(path))
-                continue;
-            const st = lstatSync(join(info.root, path), { throwIfNoEntry: false });
-            if (st?.isFile() && st.size > max)
-                held.push(path);
-        }
-        const specs = ['.', ':(exclude).shard', ':(exclude,glob)**/.shard/**', ':(exclude,glob)**/*.shard-tmp-*', ...held.map(p => `:(exclude,literal)${p}`)];
+        // Every file, whatever its size: Git stores large files as streamed loose objects.
+        const specs = ['.', ':(exclude).shard', ':(exclude,glob)**/.shard/**', ':(exclude,glob)**/*.shard-tmp-*'];
         await git(info.root, ['add', '-A', '--ignore-errors', '--pathspec-from-file=-', '--pathspec-file-nul'], { env, input: specs.join('\0') + '\0', signal });
-        if (held.length) {
-            const atHead = (await git(info.root, ['ls-tree', '-z', '--full-tree', info.head, '--', ...held], { signal })).stdout.toString('utf8').split('\0').filter(Boolean);
-            const known = new Set(atHead.map(line => line.slice(line.indexOf('\t') + 1)));
-            const lines = [...atHead, ...held.filter(p => !known.has(p)).map(p => `0 ${'0'.repeat(40)}\t${p}`)];
-            await git(info.root, ['update-index', '-z', '--index-info'], { env, input: lines.join('\0') + '\0', signal });
-        }
         const tree = await gitText(info.root, ['write-tree'], { env, signal });
         const headTree = await gitText(info.root, ['rev-parse', `${info.head}^{tree}`], { signal });
         const previous = await verifyCommit(info.root, twinRef(id));
@@ -166,7 +147,7 @@ export async function snapshotWorktree(info, options) {
             commit = await gitText(info.root, ['commit-tree', tree, '-p', info.head, '-F', '-'], { env: identity(options.now ?? new Date()), input: message, signal });
             await git(info.root, ['update-ref', twinRef(id), commit], { signal });
         }
-        return { commit, tree, base: info.head, branch: info.branch, root: info.root, id, held, headTree };
+        return { commit, tree, base: info.head, branch: info.branch, root: info.root, id, headTree };
     }
     finally {
         rmSync(index, { force: true });
@@ -181,7 +162,7 @@ export async function refTwin(repo, branch, device, now = new Date()) {
     const id = createHash('sha256').update(`${realpathSync(repo)}\0${branch}`).digest('hex').slice(0, 16);
     const commit = await gitText(repo, ['commit-tree', tree, '-p', base, '-F', '-'], { env: identity(now), input: `Shardflux twin of ${branch}\n\n${SNAPSHOT_TRAILER}: ${device}/${id}\nShardflux-Branch: ${branch}\n` });
     await git(repo, ['update-ref', twinRef(id), commit]);
-    return { commit, tree, base, branch, root: realpathSync(repo), id, held: [], headTree: tree };
+    return { commit, tree, base, branch, root: realpathSync(repo), id, headTree: tree };
 }
 async function rawDiff(cwd, a, b) {
     const parts = (await git(cwd, ['diff-tree', '-r', '-z', '--raw', '--no-renames', '--no-abbrev', a, b])).stdout.toString('utf8').split('\0');
@@ -549,15 +530,11 @@ async function mergeInVm(cell, input, snap, mark) {
             const hasBundle = bundled.code === 0;
             let inline, uploaded = false;
             if (hasBundle) {
-                const bytes = await readFile(local);
-                if (bytes.length > TRANSFER_LIMIT)
-                    throw new Error('the twin exceeds the 256 MiB transfer bound');
-                // A small bundle rides in the script's input: no file round trips.
-                if (bytes.length <= INLINE_BYTES)
-                    inline = bytes.toString('base64');
+                // A small bundle rides in the script's input: no file round trips. A larger one streams from disk.
+                if (statSync(local).size <= INLINE_BYTES)
+                    inline = (await readFile(local)).toString('base64');
                 else {
-                    for (let at = 0; at < bytes.length; at += SYNC_CHUNK_BYTES)
-                        await cell.files.write(remote, bytes.subarray(at, at + SYNC_CHUNK_BYTES), { mode: '0600', append: at > 0 });
+                    await writeSyncFileFrom(cell, remote, local, input.signal);
                     uploaded = true;
                 }
             }
@@ -589,18 +566,10 @@ async function mergeInVm(cell, input, snap, mark) {
         return land;
     const fetched = join(tmpdir(), `shard-land-${randomUUID()}.bundle`), refs = landRefs(c.name);
     try {
-        let bytes;
         if (land.bundle_b64)
-            bytes = Buffer.from(land.bundle_b64, 'base64');
-        else {
-            const info = await cell.files.stat(out);
-            if (info.size > TRANSFER_LIMIT)
-                throw new Error('the landing exceeds the 256 MiB transfer bound');
-            bytes = await cell.files.read(out, { length: info.size + 1 });
-            if (bytes.length !== info.size)
-                throw new Error('the landing bundle changed while it was read');
-        }
-        await writeFile(fetched, bytes, { mode: 0o600 });
+            await writeFile(fetched, Buffer.from(land.bundle_b64, 'base64'), { mode: 0o600 });
+        else
+            await readSyncFileTo(cell, out, (await cell.files.stat(out)).size, fetched, input.signal);
         await git(input.repo, ['fetch', '-q', '--no-tags', fetched, `+refs/shard/land/tip:${refs.tip}`, `+refs/shard/land/result:${refs.result}`]);
         if (await verifyCommit(input.repo, refs.tip) !== land.tip || await verifyCommit(input.repo, refs.result) !== land.result)
             throw new Error('the landing bundle does not match the landing');
@@ -816,11 +785,7 @@ export async function sendTwinSeed(stateDir, cell, conversation, folder, signal)
     await git(folder, ['update-ref', ref, conversation.base_commit]);
     try {
         await git(folder, ['bundle', 'create', '-q', local, ref, '--not', `${conversation.base_commit}^1`]);
-        const bytes = await readFile(local);
-        if (bytes.length > TRANSFER_LIMIT)
-            throw new Error('the uncommitted changes exceed the 256 MiB transfer bound');
-        for (let at = 0; at < bytes.length; at += SYNC_CHUNK_BYTES)
-            await cell.files.write(remote, bytes.subarray(at, at + SYNC_CHUNK_BYTES), { mode: '0600', append: at > 0 });
+        await writeSyncFileFrom(cell, remote, local, signal);
         const r = await cell.exec.run(['git', '-C', conversation.worktree_path, '-c', 'core.hooksPath=/dev/null', 'fetch', '-q', '--no-tags', remote, `+${ref}:refs/shard/twin-seed`], { timeoutMs: 120_000, ...(signal ? { signal } : {}) });
         if (r.exitCode !== 0)
             throw new Error(`the conversation could not receive its starting snapshot: ${r.stderr.trim()}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/cli",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "type": "module",
   "description": "shard: the Shardflux command line. Create an account, sign in, set up keys and billing, then open, run commands in, move files to, suspend, resume and fork serverless agent workspaces.",
   "license": "Apache-2.0",
@@ -47,7 +47,7 @@
     "smol-toml": "1.9.0",
     "snappyjs": "0.7.0",
     "yaml": "2.9.1",
-    "@shardflux/sdk": "^0.24.0"
+    "@shardflux/sdk": "^0.25.0"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
@@ -58,9 +58,9 @@
     "typescript-eslint": "8.70.1"
   },
   "optionalDependencies": {
-    "@shardflux/desktop-linux-x64": "0.1.0",
-    "@shardflux/desktop-linux-arm64": "0.1.0",
-    "@shardflux/menubar-darwin": "^0.6.0"
+    "@shardflux/desktop-linux-x64": "0.1.2",
+    "@shardflux/desktop-linux-arm64": "0.1.2",
+    "@shardflux/menubar-darwin": "^0.7.0"
   },
   "scripts": {
     "build": "node scripts/build.mjs",