@shardflux/cli 0.23.1 → 0.24.1

package/dist/local-sessions.js

@@ -308,6 +308,44 @@ function codexRunning(env, id) {
     const r = spawnSync('perl', ['-e', 'use Fcntl qw(:flock); open(my $f, "<", $ARGV[0]) or exit 2; exit(flock($f, LOCK_EX|LOCK_NB) ? 0 : 1)', lock], { stdio: 'ignore', timeout: 5000 });
     return r.status === 1;
 }
+/** The actual writer, never a guessed PID from the transcript. Codex TUI's writer may be its shared daemon. */
+export function sessionProcessPid(s, env) {
+    if (s.harness === 'claude')
+        return claudeProcesses(env)?.find(p => p.sessionId === s.session_id)?.pid;
+    if (!codexRunning(env, s.session_id))
+        return undefined;
+    const lock = join(codexHome(env), 'thread-writer-locks', `${s.session_id}.lock`);
+    if (process.platform === 'linux') {
+        const st = statSync(lock, { bigint: true });
+        const major = ((st.dev >> 8n) & 0xfffn) | ((st.dev >> 32n) & 0xfffff000n);
+        const minor = (st.dev & 0xffn) | ((st.dev >> 12n) & 0xffffff00n);
+        try {
+            for (const line of readFileSync('/proc/locks', 'utf8').split('\n')) {
+                const m = /^\d+: FLOCK\s+ADVISORY\s+WRITE\s+(\d+)\s+([0-9a-f]+):([0-9a-f]+):(\d+)\s/.exec(line);
+                if (m && BigInt(`0x${m[2]}`) === major && BigInt(`0x${m[3]}`) === minor && BigInt(m[4]) === st.ino)
+                    return Number(m[1]);
+            }
+        }
+        catch { /* Fall through to lsof on systems without a readable proc lock table. */ }
+    }
+    const r = spawnSync('lsof', ['-t', '--', lock], { encoding: 'utf8', timeout: 2000 });
+    const pids = [...new Set((r.stdout ?? '').trim().split(/\s+/).map(Number).filter(p => Number.isSafeInteger(p) && p > 1))];
+    return pids.length === 1 ? pids[0] : undefined;
+}
+/** The selected thread's last started turn, from its native rollout (Codex 0.160.0). */
+export function sessionTurnId(s) {
+    const r = tail(s.file, statSync(s.file).size).reverse().find(r => r.type === 'event_msg' && obj(r.payload).type === 'task_started');
+    const id = obj(r?.payload).turn_id;
+    return typeof id === 'string' ? id : undefined;
+}
+/** Re-read the registry immediately before signalling: a PID reused after a session exits belongs to someone else. */
+export function sameClaudeProcess(s, env, pid) {
+    const p = claudeProcesses(env)?.find(p => p.sessionId === s.session_id && p.pid === pid);
+    if (!p)
+        return false;
+    const r = spawnSync('ps', ['-p', String(pid), '-o', 'lstart='], { encoding: 'utf8', timeout: 2000, env: { ...process.env, TZ: 'UTC' } });
+    return !!p.procStart && r.status === 0 && r.stdout.trim().replace(/\s+/g, ' ') === p.procStart.trim().replace(/\s+/g, ' ');
+}
 // ---------------------------------------------------------------------------------------------------------------
 // Listing, finding, state
 const within = (folder) => (cwd) => cwd === folder || cwd.startsWith(folder.endsWith('/') ? folder : `${folder}/`);

package/dist/main.js

@@ -371,6 +371,9 @@ const NO_NUDGE_REASONS = new Set([
     // Inbound ports (0.9.0): the hint names the command to expose or close a port.
     'port_not_exposed',
     'port_limit',
+    // Permission requests (0.25.0+): answered already (here or where the agent runs), or its agent no longer waits.
+    'permission_answered',
+    'permission_canceled',
 ]);
 /**
  * Whether a failure ends with the `feedback:` line (0.5.0+): every failure except the expected flow above (feedback

package/dist/move-files.d.ts

@@ -0,0 +1,39 @@
+import type { CellClient } from '@shardflux/sdk';
+import type { SessionHarness } from './local-sessions.js';
+export declare const VM_HOME = "/home/user";
+export interface SessionFile {
+    path: string;
+    bytes: number;
+    mode: number;
+    why: 'handed' | 'opened' | 'named';
+}
+export interface SessionFiles {
+    files: SessionFile[];
+    left: string[];
+}
+/** Absolute and home paths in free text: `@"/a b/c.md"`, `/x/y.md`, `~/notes.md`. */
+export declare function pathsIn(text: string): string[];
+/** What the transcript says the session was handed and opened, as spelled there (a `~/` path is not expanded yet). */
+export declare function sessionMentions(bytes: Buffer, harness: SessionHarness): {
+    handed: string[];
+    opened: string[];
+};
+/**
+ * The files to carry: regular files under `home`, outside every root (the moved checkout and the repository's other
+ * worktrees), not private, within the bounds. Handed files come first, then opened ones, then the ones a handed file
+ * names; `left` lists the ones past the bounds.
+ */
+export declare function sessionFiles(bytes: Buffer, harness: SessionHarness, home: string, roots: readonly string[]): SessionFiles;
+/** Where a carried file goes in the VM. */
+export declare const vmPath: (home: string, path: string) => string;
+/** `~/Downloads/handoff.md` for display. */
+export declare const homeSpelling: (home: string, path: string) => string;
+type FilesCell = Pick<CellClient, 'exec' | 'files'>;
+export declare function writeChunks(cell: Pick<FilesCell, 'files'>, path: string, bytes: Uint8Array, mode?: string): Promise<void>;
+/**
+ * Writes each file under the VM's home, then links this computer's home path to the VM's home when it is free there
+ * (`/Users/alex` → `/home/user`), so absolute paths in the history resolve. A VM without sudo keeps the home-relative
+ * copies; the link is a convenience, never a reason to fail the move.
+ */
+export declare function placeSessionFiles(cell: FilesCell, found: SessionFiles, home: string, signal?: AbortSignal): Promise<boolean>;
+export {};

package/dist/move-files.js

@@ -0,0 +1,167 @@
+/**
+ * Files a moved session used outside its project (0.25.0+): what the user handed it (an @-mention, a path typed in a
+ * prompt), what it opened with Read, Edit or Write, and the files a handed text file names (a handoff's own
+ * references). Each goes into the VM under its home at the same home-relative path, and the VM links this computer's
+ * home there, so a path the history names (/Users/alex/Downloads/handoff.md) opens in the cloud as it did here.
+ * Credential stores and keys are never carried; files past the bounds stay on this computer and are listed.
+ */
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve } from 'node:path';
+import { SYNC_CHUNK_BYTES } from "./project-sync-transfer.js";
+const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+export const VM_HOME = '/home/user';
+const MAX_FILES = 64, FILE_BYTES = 16 << 20, TOTAL_BYTES = 64 << 20;
+/** A handed file is read for the paths it names when it is text of at most this size. */
+const NAMES_BYTES = 1 << 20;
+/** Claude Code tools whose input names a file the session opened. */
+const FILE_TOOLS = new Set(['Read', 'Edit', 'MultiEdit', 'Write', 'NotebookEdit']);
+/** Home-relative stores of keys and sign-ins: never carried, whatever the session read. */
+const PRIVATE = ['.ssh', '.aws', '.gnupg', '.password-store', '.azure', '.kube', '.docker', '.netrc', '.npmrc', '.pypirc',
+    '.git-credentials', '.config/gh', '.config/gcloud', '.config/shardflux', '.claude/.credentials.json', '.claude.json',
+    '.codex/auth.json', 'Library/Keychains', 'Library/Cookies'];
+const PRIVATE_NAME = /^(\.env(\..*)?|id_[a-z0-9]+(\.pub)?|.*\.(pem|key|p12|pfx|keychain-db))$/i;
+/** Absolute and home paths in free text: `@"/a b/c.md"`, `/x/y.md`, `~/notes.md`. */
+export function pathsIn(text) {
+    const out = new Set();
+    for (const m of text.matchAll(/["'`](~?\/[^"'`\n]+)["'`]|(?:^|[\s(@[])(~?\/[^\s"'`()<>[\]]+)/g))
+        out.add(m[1] ?? m[2].replace(/[.,;:!?]+$/, ''));
+    return [...out];
+}
+/** What the transcript says the session was handed and opened, as spelled there (a `~/` path is not expanded yet). */
+export function sessionMentions(bytes, harness) {
+    const handed = new Set(), opened = new Set();
+    for (const line of bytes.toString('utf8').split('\n')) {
+        let r;
+        try {
+            r = obj(JSON.parse(line));
+        }
+        catch {
+            continue;
+        }
+        if (harness === 'claude') {
+            const attachment = obj(r.attachment);
+            if (r.type === 'attachment' && attachment.type === 'file' && typeof attachment.filename === 'string')
+                handed.add(attachment.filename);
+            const message = obj(r.message);
+            if (r.type === 'user' && r.isMeta !== true && typeof message.content === 'string')
+                for (const p of pathsIn(message.content))
+                    handed.add(p);
+            if (r.type === 'assistant' && Array.isArray(message.content)) {
+                for (const block of message.content.map(obj)) {
+                    if (block.type !== 'tool_use' || !FILE_TOOLS.has(String(block.name)))
+                        continue;
+                    const input = obj(block.input), path = input.file_path ?? input.notebook_path;
+                    if (typeof path === 'string')
+                        opened.add(path);
+                }
+            }
+        }
+        else {
+            const p = obj(r.payload);
+            if (r.type !== 'response_item' || p.type !== 'message' || p.role !== 'user' || !Array.isArray(p.content))
+                continue;
+            // Codex's own context blocks (<environment_context>, <turn_aborted>) are user-role records the user never typed.
+            for (const item of p.content.map(obj))
+                if (item.type === 'input_text' && typeof item.text === 'string' && !item.text.startsWith('<'))
+                    for (const q of pathsIn(item.text))
+                        handed.add(q);
+        }
+    }
+    return { handed: [...handed], opened: [...opened] };
+}
+const inside = (root, path) => path === root || path.startsWith(root.endsWith('/') ? root : `${root}/`);
+const realOr = (path) => { try {
+    return realpathSync(path);
+}
+catch {
+    return resolve(path);
+} };
+function isPrivate(home, path) {
+    const rel = relative(home, path);
+    return PRIVATE.some(p => rel === p || rel.startsWith(`${p}/`)) || rel.split('/').some(part => PRIVATE_NAME.test(part));
+}
+function isText(bytes) { return !bytes.subarray(0, 8192).includes(0); }
+/**
+ * The files to carry: regular files under `home`, outside every root (the moved checkout and the repository's other
+ * worktrees), not private, within the bounds. Handed files come first, then opened ones, then the ones a handed file
+ * names; `left` lists the ones past the bounds.
+ */
+export function sessionFiles(bytes, harness, home, roots) {
+    const realHome = realOr(home), realRoots = roots.map(realOr);
+    const expand = (p) => (p === '~' || p.startsWith('~/') ? home + p.slice(1) : p);
+    const files = [], left = [], seen = new Set();
+    let total = 0;
+    const consider = (spelled, why) => {
+        const path = resolve(expand(spelled));
+        if (!isAbsolute(expand(spelled)) || seen.has(path))
+            return undefined;
+        seen.add(path);
+        const real = realOr(path);
+        if (!inside(home, path) || !inside(realHome, real) || realRoots.some(root => inside(root, real)) || isPrivate(home, path) || isPrivate(realHome, real))
+            return undefined;
+        let st;
+        try {
+            st = statSync(real);
+        }
+        catch {
+            return undefined;
+        }
+        if (!st.isFile())
+            return undefined;
+        if (files.length >= MAX_FILES || st.size > FILE_BYTES || total + st.size > TOTAL_BYTES) {
+            left.push(path);
+            return undefined;
+        }
+        total += st.size;
+        const f = { path, bytes: st.size, mode: st.mode & 0o777, why };
+        files.push(f);
+        return f;
+    };
+    const { handed, opened } = sessionMentions(bytes, harness);
+    const given = handed.map(p => consider(p, 'handed')).filter((f) => !!f);
+    for (const p of opened)
+        consider(p, 'opened');
+    for (const f of given) {
+        if (f.bytes > NAMES_BYTES)
+            continue;
+        let text;
+        try {
+            text = readFileSync(f.path);
+        }
+        catch {
+            continue;
+        }
+        if (isText(text))
+            for (const p of pathsIn(text.toString('utf8')))
+                consider(p, 'named');
+    }
+    return { files, left };
+}
+/** Where a carried file goes in the VM. */
+export const vmPath = (home, path) => `${VM_HOME}/${relative(home, path)}`;
+/** `~/Downloads/handoff.md` for display. */
+export const homeSpelling = (home, path) => (inside(home, path) ? `~/${relative(home, path)}` : path);
+export async function writeChunks(cell, path, bytes, mode = '0600') {
+    if (!bytes.length) {
+        await cell.files.write(path, '', { mode });
+        return;
+    }
+    for (let at = 0; at < bytes.length; at += SYNC_CHUNK_BYTES)
+        await cell.files.write(path, bytes.subarray(at, at + SYNC_CHUNK_BYTES), { mode, append: at > 0 });
+}
+/**
+ * Writes each file under the VM's home, then links this computer's home path to the VM's home when it is free there
+ * (`/Users/alex` → `/home/user`), so absolute paths in the history resolve. A VM without sudo keeps the home-relative
+ * copies; the link is a convenience, never a reason to fail the move.
+ */
+export async function placeSessionFiles(cell, found, home, signal) {
+    for (const f of found.files) {
+        const target = vmPath(home, f.path);
+        await cell.files.mkdir(dirname(target), { parents: true });
+        await writeChunks(cell, target, readFileSync(f.path), `0${f.mode.toString(8)}`);
+    }
+    if (!found.files.length || home === VM_HOME)
+        return false;
+    const linked = await cell.exec.run(['sh', '-c', 'test -e "$1" || { sudo -n mkdir -p "$(dirname "$1")" && sudo -n ln -s "$2" "$1"; }', 'sh', home, VM_HOME], { timeoutMs: 10_000, ...(signal ? { signal } : {}) }).catch(() => null);
+    return linked?.exitCode === 0;
+}

package/dist/move-interrupt.d.ts

@@ -0,0 +1,18 @@
+import type { Ctx } from './commands.js';
+import type { LocalSession } from './local-sessions.js';
+type Env = Record<string, string | undefined>;
+/** Detached MCP children retain their parent chain; this also works for already-installed MCP servers. */
+export declare function processAncestor(ancestor: number, child?: number): boolean;
+export declare function selfMove(s: LocalSession, env: Env): boolean;
+/**
+ * Whether a move stops the session's turn itself. A self-move, and a session whose live process this computer cannot
+ * name (a Claude Code without the session registry, a Codex thread whose lock more than one process holds), let the
+ * turn end first instead.
+ */
+export declare function stopsLocalTurn(s: LocalSession, env: Env): boolean;
+/** Shared Codex daemons need thread-scoped interrupt AND background-terminal cleanup: interrupt alone leaves Bash alive. */
+export declare function interruptCodexThread(s: LocalSession, env: Env, signal: AbortSignal): Promise<void>;
+/** Stop before the project snapshot. The native harness owns its interrupt records; the local transcript is read-only here. */
+export declare function interruptLocalTurn(ctx: Pick<Ctx, 'io' | 'json' | 'signal'>, s: LocalSession, env: Env): Promise<boolean>;
+export declare const MOVE_CONTINUATION = "Continue the same reply after the move to the cloud. The local turn was interrupted for this move. Redo the interrupted step from its beginning, including re-running the interrupted tool call; never skip to the next step. Everything completed before the interruption is in this project and session history. Finish the original request without waiting for another prompt.";
+export {};

package/dist/move-interrupt.js

@@ -0,0 +1,193 @@
+/** Native interruption measured with Claude 2.1.295/2.1.300 and Codex 0.160.0; see ground-truth.md. */
+import { spawnSync } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import WebSocket from 'ws';
+import { UsageError } from "./errors.js";
+import { CLI_VERSION } from "./args.js";
+import { codexHome, sameClaudeProcess, sessionProcessPid, sessionState, sessionTurnId } from "./local-sessions.js";
+function processes() {
+    const r = spawnSync('ps', ['-axo', 'pid=,ppid=,stat=,lstart=,comm='], { encoding: 'utf8', timeout: 2000, env: { ...process.env, TZ: 'UTC' } });
+    if (r.status !== 0)
+        throw new UsageError('Couldn’t check the local commands. Retry the move.');
+    return r.stdout.split('\n').flatMap(line => {
+        const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+)$/.exec(line);
+        // Zombies and processes already exiting cannot write project files.
+        return m && !/[ZE]/.test(m[3]) ? [{ pid: Number(m[1]), parent: Number(m[2]), identity: m[4].replace(/\s+/g, ' ') }] : [];
+    });
+}
+function descendants(pid) {
+    const rows = processes(), ids = new Set([pid]);
+    for (;;) {
+        const before = ids.size;
+        for (const p of rows)
+            if (ids.has(p.parent))
+                ids.add(p.pid);
+        if (ids.size === before)
+            break;
+    }
+    return rows.filter(p => p.pid !== pid && ids.has(p.pid));
+}
+/** A standalone harness's commands cannot outlive the snapshot, even if its interruption leaves an orphan shell. */
+async function stopCommands(owned) {
+    const remaining = () => processes().filter(p => owned.some(o => o.pid === p.pid && o.identity === p.identity));
+    const send = (p, sig) => { try {
+        process.kill(p.pid, sig);
+    }
+    catch (e) {
+        if (e.code !== 'ESRCH')
+            throw e;
+    } };
+    for (const p of remaining())
+        send(p, 'SIGTERM');
+    const deadline = Date.now() + 1000;
+    while (remaining().length && Date.now() < deadline)
+        await delay(50);
+    for (const p of remaining())
+        send(p, 'SIGKILL');
+    if (remaining().length) {
+        await delay(100);
+        if (remaining().length)
+            throw new UsageError('A local command has not stopped. Stop it locally and retry the move.');
+    }
+}
+/** Detached MCP children retain their parent chain; this also works for already-installed MCP servers. */
+export function processAncestor(ancestor, child = process.pid) {
+    const r = spawnSync('ps', ['-axo', 'pid=,ppid='], { encoding: 'utf8', timeout: 2000 });
+    if (r.status !== 0)
+        throw new UsageError('Couldn’t check this session’s process. Retry the move.');
+    const parents = new Map(r.stdout.trim().split('\n').map(line => line.trim().split(/\s+/).map(Number)).map(([pid, parent]) => [pid, parent]));
+    const seen = new Set();
+    for (let p = child; p > 1 && !seen.has(p); p = parents.get(p) ?? 0) {
+        if (p === ancestor)
+            return true;
+        seen.add(p);
+    }
+    return false;
+}
+export function selfMove(s, env) {
+    const pid = sessionProcessPid(s, env);
+    return pid !== undefined && processAncestor(pid);
+}
+/**
+ * Whether a move stops the session's turn itself. A self-move, and a session whose live process this computer cannot
+ * name (a Claude Code without the session registry, a Codex thread whose lock more than one process holds), let the
+ * turn end first instead.
+ */
+export function stopsLocalTurn(s, env) {
+    const pid = sessionProcessPid(s, env);
+    return pid !== undefined && !processAncestor(pid);
+}
+/** Shared Codex daemons need thread-scoped interrupt AND background-terminal cleanup: interrupt alone leaves Bash alive. */
+export async function interruptCodexThread(s, env, signal) {
+    const turnId = sessionTurnId(s);
+    if (!turnId)
+        throw new UsageError('Couldn’t identify this Codex turn. Stop it locally and retry the move.');
+    const socket = realpathSync(join(codexHome(env), 'app-server-control', 'app-server-control.sock'));
+    const ws = new WebSocket(`ws+unix://${socket}:/`);
+    const pending = new Map();
+    const bounded = AbortSignal.any([signal, AbortSignal.timeout(5000)]);
+    let id = 0;
+    const fail = (error) => { for (const p of pending.values())
+        p.reject(error); pending.clear(); };
+    ws.on('error', fail);
+    ws.on('close', () => fail(new Error('Codex’s session control closed.')));
+    ws.on('message', data => {
+        let r;
+        const bytes = Array.isArray(data) ? Buffer.concat(data) : Buffer.isBuffer(data) ? data : Buffer.from(data);
+        try {
+            r = JSON.parse(bytes.toString('utf8'));
+        }
+        catch {
+            return;
+        }
+        const p = r.id === undefined ? undefined : pending.get(r.id);
+        if (!p)
+            return;
+        pending.delete(r.id);
+        if (r.error)
+            p.reject(new Error(`Codex could not stop the turn: ${JSON.stringify(r.error)}`));
+        else
+            p.resolve(r.result);
+    });
+    const abort = () => { fail(new Error('Codex did not confirm that the local turn stopped.')); ws.terminate(); };
+    bounded.addEventListener('abort', abort, { once: true });
+    const call = (method, params) => new Promise((resolve, reject) => {
+        bounded.throwIfAborted();
+        const next = ++id;
+        pending.set(next, { resolve, reject });
+        ws.send(JSON.stringify({ id: next, method, params }));
+    });
+    try {
+        await new Promise((resolve, reject) => { ws.once('open', resolve); ws.once('error', reject); bounded.addEventListener('abort', () => reject(bounded.reason), { once: true }); });
+        await call('initialize', { clientInfo: { name: 'shard_move', version: CLI_VERSION }, capabilities: { experimentalApi: true } });
+        ws.send(JSON.stringify({ method: 'initialized' }));
+        await call('turn/interrupt', { threadId: s.session_id, turnId });
+        await call('thread/backgroundTerminals/clean', { threadId: s.session_id });
+    }
+    finally {
+        bounded.removeEventListener('abort', abort);
+        ws.terminate();
+    }
+}
+/** Stop before the project snapshot. The native harness owns its interrupt records; the local transcript is read-only here. */
+export async function interruptLocalTurn(ctx, s, env) {
+    if (sessionState(s, env).turn !== 'working')
+        return false;
+    const pid = sessionProcessPid(s, env);
+    if (!pid)
+        throw new UsageError('Couldn’t identify this session’s live process. Stop its local turn and retry the move.');
+    if (processAncestor(pid))
+        throw new UsageError('A session cannot interrupt its own turn to move.');
+    if (!ctx.json)
+        ctx.io.stderr.write('Stopping the local turn and continuing it in the cloud…\n');
+    const args = s.harness === 'codex' ? spawnSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf8', timeout: 2000 }).stdout ?? '' : '';
+    const daemon = s.harness === 'codex' && args.includes('app-server') && args.includes('--managed-daemon');
+    if (daemon) {
+        // Only use the daemon that actually owns this thread’s lock; never connect to another CODEX_HOME.
+        if (!existsSync(join(codexHome(env), 'app-server-control', 'app-server-control.sock')))
+            throw new UsageError('Codex’s session control is unavailable. Stop it locally and retry the move.');
+        if (sessionProcessPid(s, env) !== pid)
+            throw new UsageError('This session’s process changed. Retry the move.');
+        await interruptCodexThread(s, env, ctx.signal);
+    }
+    else {
+        const owner = processes().find(p => p.pid === pid);
+        let owned = descendants(pid);
+        if (s.harness === 'claude') {
+            if (!sameClaudeProcess(s, env, pid))
+                throw new UsageError('This session’s process changed. Retry the move.');
+        }
+        else {
+            const comm = spawnSync('ps', ['-p', String(pid), '-o', 'comm='], { encoding: 'utf8', timeout: 2000 }).stdout?.trim() ?? '';
+            if (sessionProcessPid(s, env) !== pid || !/^codex(?:\.exe)?$/.test(basename(comm)))
+                throw new UsageError('This session’s process changed. Retry the move.');
+        }
+        process.kill(pid, 'SIGINT');
+        await delay(100, undefined, { signal: ctx.signal });
+        const same = () => owner && processes().some(p => p.pid === pid && p.identity === owner.identity);
+        if (same()) {
+            // Interactive Claude's OS signal handler can leave the turn running. Terminate that verified standalone
+            // harness, after giving Desktop/exec their native clean-interrupt path; never signal a shared daemon here.
+            owned = [...owned, ...descendants(pid)];
+            process.kill(pid, 'SIGTERM');
+            await delay(100, undefined, { signal: ctx.signal });
+            if (same())
+                process.kill(pid, 'SIGKILL');
+        }
+        await stopCommands(owned);
+    }
+    const deadline = Date.now() + 5000;
+    while (sessionState(s, env).turn === 'working') {
+        // macOS can retain an exiting native process and its busy registry entry while kill(pid, 0) still succeeds.
+        // Its userspace and the owned commands above are stopped; do not wait for corpse reaping to snapshot.
+        if (!daemon && !processes().some(p => p.pid === pid))
+            break;
+        if (Date.now() >= deadline)
+            throw new UsageError('The local turn has not stopped. Stop it locally and retry the move.');
+        await delay(50, undefined, { signal: ctx.signal });
+    }
+    return true;
+}
+export const MOVE_CONTINUATION = 'Continue the same reply after the move to the cloud. The local turn was interrupted for this move. Redo the interrupted step from its beginning, including re-running the interrupted tool call; never skip to the next step. Everything completed before the interruption is in this project and session history. Finish the original request without waiting for another prompt.';

package/dist/move.js

@@ -2,18 +2,20 @@
  * `shard move` (0.19.0+): a Claude Code or Codex session on this computer continues in a cloud conversation as the same
  * session, with its full history.
  *
- * 1. Waits until the session's current turn has ended (local-sessions.ts); a turn is never cut off.
+ * 1. Stops a user-moved session's local turn; an agent moving itself waits until its own turn ends.
  * 2. Starts a conversation from the live twin's snapshot of the project (uncommitted edits included; the working
  *    tree, index and HEAD are not touched) whose record starts with the session (harness_session_id).
  * 3. Puts the transcript, its paths rewritten to the VM's folder, at the harness's native path in the VM and as the
  *    conversation's durable copy in the project space, before the repository is seeded.
  * 4. The VM's guest resumes it (`claude --resume <id>`, `codex resume <id>`); this command attaches or detaches.
  * 5. Records the move here; the live twin brings the cloud work back to this checkout, and typing in the local copy
- *    shows one line saying it diverges (a Claude Code UserPromptSubmit hook; the local process is never stopped).
+ *    shows one line saying it diverges (a Claude Code UserPromptSubmit hook).
+ * 6. An interrupted turn receives a continuation prompt in the VM to redo the interrupted step and finish.
  */
 import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { existsSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, relative, resolve } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { ShardfluxApiError } from '@shardflux/sdk';
@@ -30,11 +32,12 @@ import { conversationTerminal } from "./conversation-terminal.js";
 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, 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';
+import { interruptLocalTurn, MOVE_CONTINUATION, stopsLocalTurn } from "./move-interrupt.js";
+import { seedPhase } from "./seed-phases.js";
+import { homeSpelling, placeSessionFiles, sessionFiles, VM_HOME, writeChunks } from "./move-files.js";
 const SPACE = '/shardflux/project';
 /** A transcript above this moves with the repository's history bound. */
 const TRANSCRIPT_LIMIT = 256 << 20;
@@ -83,14 +86,6 @@ export async function waitForTurnEnd(ctx, s, env, pollMs = 1000) {
         await delay(pollMs, undefined, { signal: ctx.signal });
     }
 }
-async function writeChunks(cell, path, bytes) {
-    if (!bytes.length) {
-        await cell.files.write(path, '', { mode: '0600' });
-        return;
-    }
-    for (let at = 0; at < bytes.length; at += SYNC_CHUNK_BYTES)
-        await cell.files.write(path, bytes.subarray(at, at + SYNC_CHUNK_BYTES), { mode: '0600', append: at > 0 });
-}
 /**
  * The session's transcript in the conversation's VM: at its native path (where the harness resumes it) and, when the
  * project space is mounted, as the conversation's durable copy with the same checkpoint metadata the guest writes
@@ -213,13 +208,19 @@ export async function moveSession(ctx, values) {
     // 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;
+    let interrupted = false;
     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);
+        if (stopsLocalTurn(s, env))
+            interrupted = await interruptLocalTurn(ctx, s, env);
+        else
+            await waitForTurnEnd(ctx, s, env);
+        if (interrupted)
+            seedPhase('local_turn_stopped');
     }
     const bytes = completeRecords(readTranscript(s.file));
     if (bytes.length > TRANSCRIPT_LIMIT)
@@ -243,6 +244,13 @@ export async function moveSession(ctx, values) {
         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`);
     }
+    // Files it used outside the project (an @-mentioned ~/Downloads/handoff.md) go along at the same paths (0.25.0+).
+    const home = env.HOME || homedir();
+    const files = sessionFiles(bytes, s.harness, home, [folder, ...(plan?.trees.map(t => t.source) ?? []), ...elsewhere]);
+    if (!ctx.json && files.files.length)
+        ctx.io.stderr.write(`Bringing ${files.files.length === 1 ? 'a file' : `${files.files.length} files`} it used outside the project: ${files.files.map(f => homeSpelling(home, f.path)).join(', ')}\n`);
+    if (!ctx.json && files.left.length)
+        ctx.io.stderr.write(`Staying on this computer (past the move’s 64 files, 64 MiB): ${files.left.map(p => homeSpelling(home, p)).join(', ')}\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`);
@@ -261,6 +269,7 @@ export async function moveSession(ctx, values) {
             // 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, values['preserve-all-worktrees'] === true && plan ? plan : undefined);
+                await placeSessionFiles(ws.cell(), files, home, ctx.signal);
             },
         });
     }
@@ -273,6 +282,7 @@ export async function moveSession(ctx, values) {
         throw e;
     }
     const { conversation: c, workspace: ws } = created;
+    const terminalValues = interrupted ? { ...values, initialPrompt: MOVE_CONTINUATION } : values;
     const moved = { api_url: ctx.apiUrl, harness: s.harness, session_id: s.session_id, folder, file: s.file, bytes: bytes.length, sha256,
         conversation_id: c.id, key: c.key, title: s.title, moved_at: new Date().toISOString() };
     rememberMoved(ctx.store.dir, moved);
@@ -292,14 +302,15 @@ export async function moveSession(ctx, values) {
     const attach = !ctx.json && values.detach !== true && ctx.io.stdin.isTTY === true;
     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 } : {}), ...(preserved ? { preserved } : {}), ...(elsewhere.length ? { other_worktrees: elsewhere } : {}) });
+        await conversationTerminal(quiet, ws, c, place, { ...terminalValues, 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 } : {}), ...(preserved ? { preserved } : {}), ...(elsewhere.length ? { other_worktrees: elsewhere } : {}),
+            ...(files.files.length ? { files: files.files.map(f => f.path) } : {}), ...(files.left.length ? { files_left: files.left } : {}) });
         return 0;
     }
     const where = openInChoices(ctx, project.slug)[s.harness];
     if (s.harness === 'claude' && (where === 'claude-desktop' || where === 'web')) {
         const quiet = { ...ctx, io: { ...ctx.io, stdout: { write: () => true } } };
-        await conversationTerminal(quiet, ws, c, place, { ...values, detach: true });
+        await conversationTerminal(quiet, ws, c, place, { ...terminalValues, detach: true });
         if (where === 'claude-desktop')
             return openClaudeDesktopSession(ctx, ws, c);
         const url = await remoteControlUrl(ctx, ws, c);
@@ -309,7 +320,7 @@ export async function moveSession(ctx, values) {
         return 0;
     }
     ctx.io.stderr.write(`Moved to the cloud as ${c.key}: the same session, with its history.\n`);
-    return conversationTerminal(ctx, ws, c, place, values);
+    return conversationTerminal(ctx, ws, c, place, terminalValues);
 }
 /** `shard move --list`: this project's sessions on this computer, and where each moved one continues. */
 export function listMovable(ctx, values, env, now = Date.now()) {

package/dist/onboarding.d.ts

@@ -22,6 +22,7 @@ type CredentialRow = {
     app: string;
     status?: string;
     scope?: string;
+    fingerprint?: string | null;
     access?: {
         verdict: 'usable' | 'refused' | 'unknown';
         checked_at: string;
@@ -75,8 +76,11 @@ export interface T3SignInRow {
 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 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'>;
+/**
+ * Codex: this computer's Codex login is copied and the account's Codex remote device (one executor) is connected.
+ * `renewed`: this computer has a Codex login other than the one in the cloud (a new sign-in not copied yet).
+ */
+export declare function codexConnection(local: boolean, synced: boolean, connector: CodexConnectorView | null, health: CodexHealth, renewed?: boolean): 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