@shardflux/cli 0.23.0 → 0.24.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.24.0
+
+- Finish all active device port-forward cleanup and close the local listener and cell before returning the original tunnel-close error. Repeated stop and abort keep the same error and promise.
+
+- SSH and port tunnel reattachment stops on permanent HTTP upgrade refusals through the SDK, retaining the actual HTTP status instead of repeatedly refreshing a valid token.
+
+- Recheck the guest ACP supervisor before reusing an idle editor connection. After its owner changes, initialize and load the retained native session; a stable owner keeps its session and cursor.
+
+- Bind ACP input to the loaded supervisor using its Unix peer PID/start identity before provider stdin. A replacement between the owner check and request delivery requires loading the retained session again; no uncertain turn is replayed.
+
+- `shard volumes attach/detach --machine <volume>` and `--template <volume> [--path <repo>]` manage default shared mounts. Machine/template status show their defaults; JSON includes live and skipped results.
+
+- Finished Codex Cloud conversations land in your checkout like every other conversation: each turn that ends with its work committed lands in the branch the thread started from, and the thread goes on. A thread waiting on an approval or an answer lands once that turn finishes.
+
+- `shard move` interrupts a running local Claude Code or Codex reply and continues it automatically in the cloud, redoing the interrupted step. An agent calling `move_to_cloud` inside its own turn still waits for that turn to end. The local turn and its running commands stop before the project snapshot is taken.
+
+## 0.23.2 (2026-10-14)
+
+- Preserve API-key credential burst refusals (`tool_token_budget`, scope `api_key`) and their Retry-After without treating them as pre-handler admission or replaying arbitrary POSTs. Plan rollout preserves unmarked Free legacy hourly/burst behavior and uses effective workspace capacity for eligible shared hourly budgets; no client-side quota or extra retry layer.
+
+## 0.23.1
+
+- Pin the Ubuntu desktop packages to 0.1.11. Read the desktop account snapshot with the selected project key so organization, usage, spend and connector metadata match the macOS Settings app, including API-key-only profiles. Optional missing metadata stays unavailable. Conversation lists support --all with bounded cursor handling; the desktop reads all pages of conversations and workspace states.
+
 ## 0.23.0 (2026-10-14)
 
 - Codex Cloud enable and setup report when a ChatGPT sign-in is required, with `codex login` and `shard setup` as the next steps. Setup offers the sign-in action.

package/README.md

@@ -4,9 +4,11 @@ Historical template file lists: reads queue checksum-verified reconstruction whe
 
 Plan-derived API budgets (0.23.0+, SDK 0.27.0): `--json` error output includes `rate_limit` and `retry_after_seconds`; the text hint names the shared scope and delay. API request pacing follows the SDK admission timeout and preserves the request body. Reuse workspace credentials and reduce status polling when the returned budget asks for a delay.
 
+Credential key pacing (0.23.2+): when the service enables plan budgets for an eligible finite non-Free grant, workspace credentials share organization and workspace hourly allowances, plus a separate API-key burst. A `tool_token_budget` refusal can name `api_key`; honor `Retry-After` and reuse valid credentials. Unmarked Free grants retain the legacy principal hourly/burst policy. It does not promise that lifecycle work has not started, so it never authorizes replay of an arbitrary POST.
+
 Exec survives a dropped connection (0.23.0+): a lost start response is retried with the same session ID and reattaches to the command that already started, and a cut-off JSON answer is retried within the same safe retry boundary.
 
-Suspension controls arrive in 0.22.0 (next coordinated release). `shard operations progress <operation-id>` reads the actual phase, host deadline, cancellation window and safe next action. `shard operations cancel <operation-id>` requests cancellation; `--wait --timeout 5m` waits for confirmed `suspend_canceled` recovery of the original workspace. Asynchronous acceptance is labeled separately. The owning host refuses cancellation outside validated preparation; after capture, wait for the outcome and resume if it succeeded. These commands never reset, replace or launch a provider turn. `--json` preserves the reported values; unavailable progress is explicit.
+Suspension controls are available from 0.22.0. `shard operations progress <operation-id>` reads the actual phase, host deadline, cancellation window and safe next action. `shard operations cancel <operation-id>` requests cancellation; `--wait --timeout 5m` waits for confirmed `suspend_canceled` recovery of the original workspace. Asynchronous acceptance is labeled separately. The owning host refuses cancellation outside validated preparation; after capture, wait for the outcome and resume if it succeeded. These commands never reset, replace or launch a provider turn. `--json` preserves the reported values; unavailable progress is explicit.
 
 The command line for [Shardflux](https://shardflux.dev): serverless VMs for AI agents. Open a
 persistent workspace by key, run commands in it, move files in and out, and suspend, resume, fork
@@ -180,7 +182,7 @@ backup of later edits in other worktrees. External object alternates, nested rep
 resolution before preserve-all can upload; a registration whose folder is gone has nothing to copy and is listed as
 `stale_registrations`.
 
-A running turn finishes here first. Uncommitted edits come along, and your working tree, index and branch stay as
+With CLI 0.24.0+, a move during a reply stops the local turn and continues the same reply in the cloud automatically, redoing the interrupted step. An agent calling `move_to_cloud` inside its own turn waits for that turn to finish. 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
@@ -188,6 +190,10 @@ you can ask the agent itself to continue in the cloud. A session is listed under
 one that began in another folder such as Claude Desktop's scratch folder, and `--path <repository>` moves it from
 anywhere (0.22.0+).
 
+With menu bar 0.8.5+, a failed move stays at its session’s row with its reason on hover and **Retry move to cloud**
+in **⋯**. Retry or Refresh clears the previous failure. CLI 0.23.0+ records a matching stable Node.js path on macOS,
+and menu bar 0.8.5+ recovers Node.js after an upgrade removes the recorded binary.
+
 Start a thread in T3 Code from the command line (0.17.0+):
 
 ```sh
@@ -245,7 +251,8 @@ Finished conversations land in your checkout by themselves (0.16.0+, with the me
 conversation's turn ends with its work committed, the branch it started from moves to its commits and the changed
 files are written in place, next to your own uncommitted edits, which stay as they are (where both touched the same
 lines, your text is kept). `git status` keeps showing only your edits. A conversation started from a checkout with
-uncommitted edits starts from them too. Every rewritten file is backed up first:
+uncommitted edits starts from them too. A Codex Cloud thread lands after each turn it finishes (0.24.0+); one waiting
+on an approval or an answer lands once that turn finishes. Every rewritten file is backed up first:
 
 ```sh
 shard conversations landing            # auto (default), pr or off for this project
@@ -639,7 +646,7 @@ Projects that depend on `@shardflux/sdk` or the Python `shardflux` package keep
 `shard` tells you when a newer version exists, on stderr after the command's output:
 
 ```text
-@shardflux/cli 0.13.5 is outdated: 0.14.0 is available. Update: shard update
+@shardflux/cli 0.23.0 is outdated: 0.23.1 is available. Update: shard update
 ```
 
 or that the API no longer supports it (`... is no longer supported by the Shardflux API (minimum
@@ -1597,15 +1604,17 @@ shard agents new --app claude --path ./ --prompt "What is wrong on this page?" -
 
 `--image <file|->` (0.15.0+, repeatable) attaches up to five PNG, JPEG, GIF or WebP images of up to 10 MiB each to that first message. They are written into the conversation VM under `/home/user/.shardflux/attachments/` and named in the message: Claude Code attaches them as images and Codex opens them with its image viewer. `--image -` reads one image, or PNG images back to back, from standard input; use a file for `--prompt-file` when images come from standard input.
 
-Use `shard agents open <workspace> --in auto --json` to resolve where a conversation opens: a saved target first; then, for Claude (0.15.1+), the conversation itself in Claude Desktop when it is installed (`{"target":"claude-desktop","url":"claude://code/session_…","app_bundle_id":…}`), else Claude Code in the terminal (`{"target":"terminal","command":["shard","agents","open","<workspace>"]}`; without `--json` it attaches in this terminal). Codex opens its Cloud thread in the Codex app. claude.ai opens with `--in web`. The caller opens the `url` or app, or runs the command in a terminal. Explicit `--in terminal` retains terminal attachment. The menu uses this resolver for new and existing conversations, without provider URLs in Swift.
+With CLI 0.23.0+, a full conversation key or id opens that same Claude or Codex session from any folder, including after **Move to cloud**. A computer key opens its bound conversation.
+
+Use `shard agents open <workspace> --in auto --json` to resolve where a conversation opens: a saved target first; then, for Claude (0.15.1+), the conversation itself in Claude Desktop when it is installed (`{"target":"claude-desktop","url":"claude://code/session_…","app_bundle_id":…}`), else Claude Code in the terminal (`{"target":"terminal","command":["shard","agents","open","<workspace>"]}`; without `--json` it attaches in this terminal). Codex Cloud opens its current thread in your browser (CLI 0.23.0+). claude.ai opens with `--in web`. The caller opens the `url` or app, or runs the command in a terminal. Explicit `--in terminal` retains terminal attachment. The menu uses this resolver for new and existing conversations, without provider URLs in Swift.
 
-## Codex Cloud (0.15.0+, unreleased)
+## Codex Cloud (0.15.0+)
 
 New Codex conversations use `shard agents new --app codex --path <directory>` or `shard ./ codex`. Each gets a fresh conversation VM and a genuine Codex Cloud thread. `shard agents open <conversation-id>` opens the existing thread without waking its VM. These paths create no SSH device entries and need no pairing.
 
 `shard setup` uses your existing Codex ChatGPT login to register one executor for the account. Its small connector workspace stays resident and is billed as ordinary workspace memory/CPU usage, including while conversations wait. Use `--no-codex` to skip setup, `shard agents codex status` to inspect it, or `shard agents codex disable` to remove the executor and release its residency. Conversation VMs wake for tools and follow the normal adaptive idle policy afterwards.
 
-Explicit `agents new --in terminal`, `--in t3`, and `--like` launches keep their existing VM routes. Local Git is prepared and validated before Cloud enrollment. This branch's Cloud feature is awaiting release. Existing local-mode conversations keep their original route. Cloud uses OpenAI's model/configuration capabilities; local app-server plugins and settings are not automatically transferred.
+Explicit `agents new --in terminal`, `--in t3`, and `--like` launches keep their existing VM routes. Local Git is prepared and validated before Cloud enrollment. Existing local-mode conversations keep their original route. Cloud uses OpenAI's model/configuration capabilities; local app-server plugins and settings are not automatically transferred.
 
 Save progress (0.22.0+): Machine and template saves show source size and an estimated duration, then queued/build state and phase updates immediately. With `--json`, progress events go to stderr and the final stdout document includes `preflight` and `phases`. Failure and timeout output retain the latest counters and `details.last_progress`, with the build id and recovery action. If an older API cannot expose the build, JSON stderr emits `save_started` with the version/build id and leaves the phase unknown. Missing final host reports preserve the last observed progress.
 
@@ -1623,3 +1632,19 @@ its result while descendant drain can remain pending. TS/Python agent tools and
 Older clients read the same session response fields.
 
 Cloud history (0.23.0+): `shard agents open <conversation-id> --original` opens the original chat; `--history <thread-id>` opens an earlier linked chat. `--json` includes `previous_threads` with each history URL. Sign in with the Codex account that owns the selected chat.
+
+## Complete conversation lists (0.23.1+)
+
+`shard conversations list --all` reads every page, keeping the selected project, state and parent filters. `--json` returns `data` and `nextCursor`. Linux desktop 0.1.11+ reads all conversation and computer pages and shows the selected project key’s organization, usage, spend and connector status in Settings.
+
+## Default shared volumes (0.24.0+)
+
+```sh
+shard volumes attach --machine datasets --mount /mnt/datasets
+shard volumes attach --template cache --mount /mnt/cache --read-only --path ./repo
+shard machine --json
+shard template --json
+shard volumes detach --machine datasets
+```
+
+Defaults mount in new and running conversations. Removal waits for current work to finish and preserves manual attachments. Add `--json` to read propagation results.

package/dist/account-args.js

@@ -463,11 +463,11 @@ export const ACCOUNT_COMMANDS = [
     {
         path: ['volumes', 'attach'],
         summary: 'Attach a volume to a workspace at a path',
-        positionals: [{ name: 'ws', required: true }, { name: 'volume', required: true }],
-        options: { mount: { type: 'string', value: '<path>', description: 'Absolute guest path, e.g. /mnt/data (required).' }, 'read-only': { type: 'boolean', description: 'Mount read-only (default read-write).' }, ...VOLUME_WAIT },
+        positionals: [{ name: 'ws|volume' }, { name: 'volume' }],
+        options: { machine: { type: 'boolean', description: 'Apply to every machine conversation.' }, template: { type: 'boolean', description: 'Apply to this repository’s conversations.' }, path: { type: 'string', value: '<path>', description: 'Repository folder for --template (default cwd).' }, mount: { type: 'string', value: '<path>', description: 'Absolute guest path, e.g. /mnt/data (required).' }, 'read-only': { type: 'boolean', description: 'Mount read-only (default read-write).' }, ...VOLUME_WAIT },
         examples: ['shard volumes attach acme/demo datasets --mount /mnt/datasets --read-only'],
     },
-    { path: ['volumes', 'detach'], summary: 'Detach a volume from a workspace', positionals: [{ name: 'ws', required: true }, { name: 'volume', required: true }], options: { ...VOLUME_WAIT } },
+    { path: ['volumes', 'detach'], summary: 'Detach a volume from a workspace', positionals: [{ name: 'ws|volume' }, { name: 'volume' }], options: { machine: { type: 'boolean', description: 'Remove a machine default.' }, template: { type: 'boolean', description: 'Remove a project template default.' }, path: { type: 'string', value: '<path>', description: 'Repository folder for --template.' }, ...VOLUME_WAIT } },
     // ---- templates with the session ------------------------------------------------------------------------
     {
         path: ['templates', 'publish'],

package/dist/account-commands.js

@@ -1,3 +1,4 @@
+import { defaultVolumeCommand } from "./default-volume-commands.js";
 import { prepareOnboardingSample } from "./onboarding-sample.js";
 import { onboardingReport, onboardingText } from "./onboarding.js";
 /**
@@ -1950,7 +1951,13 @@ export const ACCOUNT_HANDLERS = {
         out(ctx, page.data.length ? attachmentTable(page.data) : `${v.name} is not attached.\n`, { data: page.data, next_cursor: page.nextCursor });
         return 0;
     },
-    async 'volumes attach'(ctx, values, [wsRef, volRef]) {
+    async 'volumes attach'(ctx, values, args) {
+        const done = await defaultVolumeCommand(ctx, values, args, 'attach');
+        if (done !== undefined)
+            return done;
+        const [wsRef, volRef] = args;
+        if (!wsRef || !volRef)
+            throw new UsageError('Supply a workspace and volume, or --machine/--template with one volume');
         const mount = need(values, 'mount', '--mount /mnt/data');
         if (!mount.startsWith('/'))
             throw new UsageError('--mount must be an absolute path, e.g. /mnt/data');
@@ -1961,7 +1968,13 @@ export const ACCOUNT_HANDLERS = {
         out(ctx, `Attached ${v.name} to ${ws.key} at ${a.mount_path} (${a.mode}): ${a.state}${a.mounted ? ', mounted' : ', mounted on the next start'}.\n`, r);
         return 0;
     },
-    async 'volumes detach'(ctx, values, [wsRef, volRef]) {
+    async 'volumes detach'(ctx, values, args) {
+        const done = await defaultVolumeCommand(ctx, values, args, 'detach');
+        if (done !== undefined)
+            return done;
+        const [wsRef, volRef] = args;
+        if (!wsRef || !volRef)
+            throw new UsageError('Supply a workspace and volume, or --machine/--template with one volume');
         const ws = await resolveWorkspace(ctx, wsRef);
         const v = await resolveVolume(ctx, volRef);
         const r = await waitedVolume(ctx, () => ctx.cloud().volumes.detach(ws.id, v.id, { wait: volumeWait(ctx, values) }));

package/dist/acp-journal.d.ts

@@ -5,12 +5,12 @@ export interface AcpCursor {
     from_seq: number;
     prompt_id?: RpcId;
 }
-export declare const ACP_INPUT_SCRIPT = "import json, os, socket, sys\npayload = sys.stdin.buffer.readline((2 << 20) + 1024)\nif not payload.endswith(b'\\n') or len(json.dumps(json.loads(payload)['message'], separators=(',', ':'), ensure_ascii=False).encode()) > 2 << 20:\n    raise ValueError('ACP input exceeds 2 MiB')\nfolder = os.open(sys.argv[1], os.O_RDONLY)\ntry:\n    with socket.socket(socket.AF_UNIX) as peer:\n        peer.settimeout(10)\n        address = os.path.join(sys.argv[1], 'control.sock')\n        if len(address.encode()) >= 108: address = '/proc/self/fd/%d/control.sock' % folder\n        peer.connect(address)\n        peer.sendall(payload)\n        response = peer.makefile('rb').readline(65536)\n        result = json.loads(response)\n        if result.get('accepted') is not True: raise ValueError(result.get('error', 'ACP input was not acknowledged'))\n        sys.stdout.buffer.write(response)\nfinally:\n    os.close(folder)\n";
+export declare const ACP_INPUT_SCRIPT = "import json, os, socket, struct, sys\npayload = sys.stdin.buffer.readline((2 << 20) + 1024)\nif not payload.endswith(b'\\n') or len(json.dumps(json.loads(payload)['message'], separators=(',', ':'), ensure_ascii=False).encode()) > 2 << 20:\n    raise ValueError('ACP input exceeds 2 MiB')\nfolder = os.open(sys.argv[1], os.O_RDONLY)\ntry:\n    with socket.socket(socket.AF_UNIX) as peer:\n        peer.settimeout(10)\n        address = os.path.join(sys.argv[1], 'control.sock')\n        if len(address.encode()) >= 108: address = '/proc/self/fd/%d/control.sock' % folder\n        peer.connect(address)\n        expected_pid, expected_start = sys.argv[2].split(':', 1)\n        pid, uid, _ = struct.unpack('3i', peer.getsockopt(socket.SOL_SOCKET, socket.SO_PEERCRED, struct.calcsize('3i')))\n        with open('/proc/%d/stat' % pid) as process:\n            start = process.read().rsplit(')', 1)[1].split()[19]\n        if uid != os.getuid() or str(pid) != expected_pid or start != expected_start:\n            raise ValueError('ACP supervisor changed before input; load this session before continuing')\n        peer.sendall(payload)\n        response = peer.makefile('rb').readline(65536)\n        result = json.loads(response)\n        if result.get('accepted') is not True: raise ValueError(result.get('error', 'ACP input was not acknowledged'))\n        sys.stdout.buffer.write(response)\nfinally:\n    os.close(folder)\n";
 /** Replay is finite; a live follower exists only while a turn/RPC needs output. Native supervision is CVB's. */
 export declare class AcpJournal {
     #private;
     readonly rpc: AcpRpc;
-    constructor(cell: CellClient, conversation: string, _harness: 'claude' | 'codex', cwd: string, cursor: AcpCursor, save: () => void, signal: AbortSignal);
+    constructor(cell: CellClient, conversation: string, _harness: 'claude' | 'codex', cwd: string, cursor: AcpCursor, save: () => void, signal: AbortSignal, owner: string);
     start(): Promise<void>;
     pause(): void;
     resume(): void;

package/dist/acp-journal.js

@@ -14,7 +14,7 @@ function retryableRead(error) {
 // start, a stdin frame, an output stream and a cancel (0.23.0+).
 const ONE_SHOT_INPUT = 192 << 10;
 // InputACP's private, same-uid socket receipt protocol. Stdin avoids Linux's 128 KiB per-argument limit.
-export const ACP_INPUT_SCRIPT = `import json, os, socket, sys
+export const ACP_INPUT_SCRIPT = `import json, os, socket, struct, sys
 payload = sys.stdin.buffer.readline((2 << 20) + 1024)
 if not payload.endswith(b'\\n') or len(json.dumps(json.loads(payload)['message'], separators=(',', ':'), ensure_ascii=False).encode()) > 2 << 20:
     raise ValueError('ACP input exceeds 2 MiB')
@@ -25,6 +25,12 @@ try:
         address = os.path.join(sys.argv[1], 'control.sock')
         if len(address.encode()) >= 108: address = '/proc/self/fd/%d/control.sock' % folder
         peer.connect(address)
+        expected_pid, expected_start = sys.argv[2].split(':', 1)
+        pid, uid, _ = struct.unpack('3i', peer.getsockopt(socket.SOL_SOCKET, socket.SO_PEERCRED, struct.calcsize('3i')))
+        with open('/proc/%d/stat' % pid) as process:
+            start = process.read().rsplit(')', 1)[1].split()[19]
+        if uid != os.getuid() or str(pid) != expected_pid or start != expected_start:
+            raise ValueError('ACP supervisor changed before input; load this session before continuing')
         peer.sendall(payload)
         response = peer.makefile('rb').readline(65536)
         result = json.loads(response)
@@ -40,6 +46,7 @@ export class AcpJournal {
     #conversation;
     #cwd;
     #cursor;
+    #owner;
     #save;
     #controller = new AbortController();
     #signal;
@@ -50,14 +57,17 @@ export class AcpJournal {
     #follower;
     #writing = Promise.resolve();
     #paused = 0;
-    constructor(cell, conversation, _harness, cwd, cursor, save, signal) {
+    constructor(cell, conversation, _harness, cwd, cursor, save, signal, owner) {
         if (!/^[a-zA-Z0-9_-]{1,96}$/.test(conversation))
             throw new Error('Invalid ACP conversation identity');
+        if (!/^[1-9][0-9]*:[0-9]+$/.test(owner))
+            throw new Error('Invalid ACP supervisor identity');
         this.#cell = cell;
         this.#conversation = conversation;
         this.#cwd = cwd;
         this.#cursor = cursor;
         this.#save = save;
+        this.#owner = owner;
         this.#signal = AbortSignal.any([signal, this.#controller.signal]);
         this.rpc = new AcpRpc(message => {
             const encoded = JSON.stringify(message);
@@ -83,7 +93,7 @@ export class AcpJournal {
         const dir = `/home/user/.local/share/shardflux/acp/${this.#conversation}`;
         const payload = Buffer.from(`{"mode":"input","input_id":${JSON.stringify(inputId)},"message":${message}}\n`);
         if (payload.length <= ONE_SHOT_INPUT) {
-            const r = await this.#cell.exec.run(['python3', '-c', ACP_INPUT_SCRIPT, dir], { cwd: this.#cwd, stdin: payload, timeoutMs: 15_000, maxOutputBytes: 65536, signal: this.#signal });
+            const r = await this.#cell.exec.run(['python3', '-c', ACP_INPUT_SCRIPT, dir, this.#owner], { cwd: this.#cwd, stdin: payload, timeoutMs: 15_000, maxOutputBytes: 65536, signal: this.#signal });
             let receipt;
             try {
                 receipt = JSON.parse(r.stdout);
@@ -95,7 +105,7 @@ export class AcpJournal {
                 throw new Error('ACP delivery is unverified; load this session before continuing.');
             return;
         }
-        const session = await this.#cell.exec.start({ argv: ['python3', '-c', ACP_INPUT_SCRIPT, dir], cwd: this.#cwd, stdin_open: true, timeout_ms: 15_000 }, this.#signal);
+        const session = await this.#cell.exec.start({ argv: ['python3', '-c', ACP_INPUT_SCRIPT, dir, this.#owner], cwd: this.#cwd, stdin_open: true, timeout_ms: 15_000 }, this.#signal);
         let offset = 0, stdout = '';
         try {
             while (offset < payload.length) {

package/dist/acp.js

@@ -45,6 +45,12 @@ export function acpModelOptions(catalog) {
     });
 }
 const SIGN_IN = 'Sign in to Shardflux from your editor (or run shard acp --login).';
+function supervisorOwner(workspaceId, conversationId, app, text) {
+    const status = JSON.parse(text);
+    if (status.conversation_id !== conversationId || status.harness !== app || !Number.isSafeInteger(status.pid) || status.pid <= 0 || !status.start)
+        throw new Error('ACP supervisor identity does not match this conversation.');
+    return status.ended ? null : `${workspaceId}:${status.pid}:${status.start}`;
+}
 export function acpError(error) {
     if (error instanceof RpcError) {
         if (error.code === -32000 && /authentication required|oauth.*(?:revoked|expired)|not (?:signed|logged) in/i.test(error.message))
@@ -368,11 +374,28 @@ export class ShardfluxAcp {
             await session.connecting;
             return false;
         }
-        if (session.transport && !session.transport.rpc.closed)
-            return false;
-        session.connecting = this.#start(session).finally(() => { session.connecting = undefined; });
+        let started = false;
+        session.connecting = (async () => {
+            if (session.transport && !session.transport.rpc.closed && session.ws && session.conversation) {
+                // An idle journal has no read follower. Its open local RPC cannot
+                // prove the supervisor still owns the guest after a cold recovery.
+                // Check only on use, before sending any input to that owner.
+                let owner = null;
+                try {
+                    owner = supervisorOwner(session.ws.id, session.conversation.id, session.record.app ?? parseAcpModel(session.record.model).app, await session.ws.cell().files.readText(`/home/user/.local/share/shardflux/acp/${session.conversation.id}/status.json`, { length: 8192 }));
+                }
+                catch (error) {
+                    if (error.status !== 404)
+                        throw error;
+                }
+                if (owner !== null && owner === session.record.owner)
+                    return;
+            }
+            started = true;
+            await this.#start(session);
+        })().finally(() => { session.connecting = undefined; });
         await session.connecting;
-        return true;
+        return started;
     }
     async #start(session) {
         const ctx = this.#ctx, { record } = session, app = record.app ?? parseAcpModel(record.model).app;
@@ -458,10 +481,9 @@ export class ShardfluxAcp {
             throw new Error('The guest did not claim this conversation harness.');
         session.conversation = c;
         rememberConversation(ctx, c, record.folder);
-        const status = JSON.parse(statusText);
-        if (status.conversation_id !== c.id || status.harness !== app || !Number.isSafeInteger(status.pid) || status.pid <= 0 || !status.start || status.ended)
+        const owner = supervisorOwner(session.ws.id, c.id, app, statusText);
+        if (owner === null)
             throw new Error('ACP supervisor identity does not match this conversation.');
-        const owner = `${session.ws.id}:${status.pid}:${status.start}`;
         const initialize = !record.nativeId || record.owner !== owner;
         // A cold restore can replace the journal owner without changing the VM id.
         // Its sequence starts at zero; an old cursor would drop initialize/load replies.
@@ -470,7 +492,7 @@ export class ShardfluxAcp {
             delete record.prompt_id;
         }
         record.workspaceId = session.ws.id;
-        const transport = new AcpJournal(cell, c.id, app, c.worktree_path, record, () => this.#save(record), ctx.signal);
+        const transport = new AcpJournal(cell, c.id, app, c.worktree_path, record, () => this.#save(record), ctx.signal, owner.slice(session.ws.id.length + 1));
         transport.rpc.handler = async (method, params, request) => {
             if (method.startsWith('fs/') || method.startsWith('terminal/'))
                 throw new RpcError(-32601, 'Files and commands run in your cloud workspace.');

package/dist/args.d.ts

@@ -1,4 +1,4 @@
-export declare const CLI_VERSION = "0.23.0";
+export declare const CLI_VERSION = "0.24.0";
 export interface OptionSpec {
     type: 'string' | 'boolean';
     short?: string;

package/dist/args.js

@@ -13,7 +13,7 @@ import { parseArgs } from 'node:util';
 import { ACCOUNT_COMMANDS } from "./account-args.js";
 import { UsageError } from "./errors.js";
 import { DEFAULT_CHOICE, MODEL_CHOICES } from "./agent-models.js";
-export const CLI_VERSION = '0.23.0';
+export const CLI_VERSION = '0.24.0';
 export const GLOBAL_OPTIONS = {
     'api-url': { type: 'string', value: '<url>', description: 'API base URL (default $SHARDFLUX_API_URL, else https://api.shardflux.dev).' },
     json: { type: 'boolean', description: 'Print machine-readable JSON on stdout (errors as JSON on stderr).' },
@@ -146,10 +146,9 @@ const LAYER_HELP = {
     template: 'The project template is this repository’s layer: toolchains, dependencies, services and project secrets. Setup after "shard ./" saves it; "shard template save" saves the current agent VM’s project changes, and "shard template delete" starts the project over from your machine. It is saved from an agent’s VM; "shard templates" builds templates for your own app’s workspaces instead.',
 };
 const KEY_COMMANDS = [
-    { path: ['conversations', 'list'], summary: 'List project conversations', positionals: [], options: {
+    { path: ['conversations', 'list'], summary: 'List project conversations', positionals: [], options: { all: { type: 'boolean', description: 'Fetch every page.' },
             project: { type: 'string', value: '<id>', description: 'Project ID for a user session.' }, state: { type: 'string', value: '<state>', description: 'Conversation state.' },
-            parent: { type: 'string', value: '<id>', description: 'Children of this conversation.' }, limit: { type: 'string', value: '<count>', description: 'Page size.' }, cursor: { type: 'string', value: '<cursor>', description: 'Next page cursor.' }
-        } },
+            parent: { type: 'string', value: '<id>', description: 'Children of this conversation.' }, limit: { type: 'string', value: '<count>', description: 'Page size.' }, cursor: { type: 'string', value: '<cursor>', description: 'Next page cursor.' } } },
     { path: ['conversations', 'resume'], summary: 'Resume a saved conversation in a fresh VM', positionals: [{ name: 'id', required: true }], options: {} },
     { path: ['conversations', 'reader'], summary: 'Open a read-only project space reader', positionals: [{ name: 'project_id', required: true }], options: {} },
     { path: ['conversations', 'get'], summary: 'Show a conversation and its current VM', positionals: [{ name: 'id', required: true }], options: {} },
@@ -1364,10 +1363,10 @@ const CLI_PROXY_COMMANDS = [
     { path: ['cli-proxy', 'forward'], hidden: true, summary: 'Forward 127.0.0.1:8317 to your hosted CLIProxyAPI (started at login)', positionals: [], options: {} },
 ];
 /** Every command: the account plane first (sign in, set up), then the project-key commands. */
-const MENUBAR_COMMANDS = ['start', 'stop', 'status'].map(action => ({
-    path: ['menubar', action], summary: `${action === 'start' ? 'Install and start' : action === 'stop' ? 'Stop' : 'Show'} the macOS menu bar app`,
-    positionals: [], options: { login: { type: 'string', value: '<on|off>', description: 'Enable or disable launch at login.' } },
-}));
+const MENUBAR_COMMANDS = [{ path: ['menubar', 'account'], hidden: true, summary: 'Read this profile’s desktop account snapshot', positionals: [], options: {} }, ...['start', 'stop', 'status'].map((action) => ({
+        path: ['menubar', action], summary: `${action === 'start' ? 'Install and start' : action === 'stop' ? 'Stop' : 'Show'} the macOS menu bar app`,
+        positionals: [], options: { login: { type: 'string', value: '<on|off>', description: 'Enable or disable launch at login.' } },
+    }))];
 const SETTINGS_COMMANDS = [{
         path: ['settings'], summary: 'Show or change this computer’s settings for cloud conversations (0.20.1+)', positionals: [], options: {
             'title-prefix': { type: 'string', value: '<text|none|default>', description: 'The marker your cloud conversations’ Claude session titles start with in claude.ai and the Claude app ("☁ Fix login bug · todo-app"): up to 16 characters on one line; none for no marker, default for ☁. New conversations use it.' },
@@ -1693,6 +1692,17 @@ export function parseCommandLine(argv, options = {}) {
         if (positionals[1] === undefined && flagged[0] !== undefined && positionals.length === 1)
             positionals.push(flagged[0]);
     }
+    if (command.path[0] === 'volumes' && ['attach', 'detach'].includes(command.path[1] ?? '')) {
+        if (values.machine === true && values.template === true)
+            throw new UsageError('Choose --machine or --template');
+        if (values.path !== undefined && values.template !== true)
+            throw new UsageError('--path requires --template');
+        const defaults = values.machine === true || values.template === true;
+        if (positionals.length < (defaults ? 1 : 2))
+            throw new UsageError(`missing <volume> for "shard ${command.path.join(' ')}"`);
+        if (defaults && positionals.length !== 1)
+            throw new UsageError('Supply one volume with --machine or --template');
+    }
     const specs = command.positionals;
     const variadic = specs.at(-1)?.variadic === true;
     const required = specs.filter((s) => s.required && !s.variadic).length;

package/dist/conversation-commands.js

@@ -19,9 +19,23 @@ export const CONVERSATION_HANDLERS = {
     async 'conversations reader'(ctx, _values, [id]) { const r = await conversationClient(ctx).conversations.spaceReader(id, { signal: ctx.signal }); out(ctx, `${r.workspace.workspace_key}\n`, r); return 0; },
     async 'conversations list'(ctx, values) {
         const state = str(values.state);
-        const page = await conversationClient(ctx).conversations.list({ projectId: str(values.project), state, parentId: str(values.parent), cursor: str(values.cursor), limit: values.limit ? Number(values.limit) : undefined });
+        const data = [], seen = new Set();
+        let cursor = str(values.cursor), next;
+        if (cursor)
+            seen.add(cursor);
+        do {
+            const page = await conversationClient(ctx).conversations.list({ projectId: str(values.project), state, parentId: str(values.parent), cursor, limit: values.limit ? Number(values.limit) : values.all ? 200 : undefined });
+            data.push(...page.data);
+            next = page.nextCursor;
+            cursor = next ?? undefined;
+            if (values.all && cursor) {
+                if (seen.has(cursor) || seen.size >= 100)
+                    throw new UsageError('The conversation list repeated its cursor. Try again.');
+                seen.add(cursor);
+            }
+        } while (values.all && cursor);
         // A conversation that needs you adds a fifth column: why (0.18.0+).
-        out(ctx, page.data.map(c => { const q = questionLine(c); return `${c.id}\t${displayTitle(c)}\t${c.state}\t${c.branch}${q ? `\t${q}` : ''}`; }).join('\n') + '\n', page);
+        out(ctx, data.map(c => { const q = questionLine(c); return `${c.id}\t${displayTitle(c)}\t${c.state}\t${c.branch}${q ? `\t${q}` : ''}`; }).join('\n') + '\n', { data, nextCursor: next });
         return 0;
     },
     async 'conversations get'(ctx, _values, [id]) { const c = await conversationClient(ctx).conversations.get(id); const q = questionLine(c, 200); out(ctx, `${displayTitle(c)}\n${c.state}\n${c.branch}\n${q ? `${q}\n` : ''}`, c); return 0; },

package/dist/conversations.js

@@ -87,12 +87,17 @@ export async function getConversation(ctx, id) {
     return validateConversation(c);
 }
 export async function listConversations(ctx, projectId) {
-    const all = [];
+    const all = [], seen = new Set();
     let cursor;
     do {
         const page = await conversationClient(ctx).conversations.list({ ...(projectId ? { projectId } : {}), limit: 200, ...(cursor ? { cursor } : {}) });
         all.push(...page.data.map(validateConversation));
         cursor = page.nextCursor ?? undefined;
+        if (cursor) {
+            if (seen.has(cursor) || seen.size >= 100)
+                throw new UsageError('The conversation list repeated its cursor. Try again.');
+            seen.add(cursor);
+        }
     } while (cursor);
     return all;
 }

package/dist/default-volume-commands.d.ts

@@ -0,0 +1,3 @@
+import type { Ctx } from './commands.js';
+import type { Values } from './args.js';
+export declare function defaultVolumeCommand(ctx: Ctx, values: Values, args: string[], action: 'attach' | 'detach'): Promise<number | undefined>;

package/dist/default-volume-commands.js

@@ -0,0 +1,35 @@
+import { NotFoundError, UsageError } from "./errors.js";
+import { projectIdentity, normalizeRemote } from "./project-identity.js";
+export async function defaultVolumeCommand(ctx, values, args, action) {
+    if (values.machine !== true && values.template !== true) {
+        if (values.path !== undefined)
+            throw new UsageError('--path requires --template');
+        return undefined;
+    }
+    if (values.machine === true && values.template === true)
+        throw new UsageError('Choose --machine or --template');
+    if (args.length !== 1)
+        throw new UsageError(`Use shard volumes ${action} --machine <volume> or --template <volume>`);
+    if (values.machine === true && values.path !== undefined)
+        throw new UsageError('--path requires --template');
+    const cloud = ctx.cloud();
+    const project = values.template === true ? projectIdentity(typeof values.path === 'string' ? values.path : '.') : undefined;
+    const api = project ? cloud.templates.projectVolumes(project.remote ?? normalizeRemote(`file://${project.folder}`)) : cloud.machine.volumes;
+    const options = { signal: ctx.signal };
+    let result;
+    if (action === 'attach') {
+        if (typeof values.mount !== 'string')
+            throw new UsageError('--mount /mnt/data is required');
+        const ref = args[0];
+        result = await api.attach({ ...(/^[a-f0-9-]{36}$/i.test(ref) ? { volumeId: ref } : { name: ref }), mountPath: values.mount, mode: values['read-only'] === true ? 'ro' : 'rw' }, options);
+    }
+    else {
+        const list = await api.list(options), v = list.volumes.find(v => v.volume_id === args[0] || v.name === args[0]);
+        if (!v)
+            throw new NotFoundError(`Default volume ${args[0]} was not found`);
+        result = await api.detach(v.volume_id, options);
+    }
+    ctx.io.stdout.write(ctx.json ? JSON.stringify(result) + '\n' : `${values.template === true ? 'template' : 'machine'}: ${result.volumes.map(v => `${v.name} at ${v.mount_path} (${v.mode})`).join(', ') || 'no default volumes'}\n` +
+        result.live.map(v => `${v.workspace_id}: ${v.status}${v.reason ? ` (${v.reason})` : ''}\n`).join(''));
+    return 0;
+}

package/dist/desktop-account.d.ts

@@ -0,0 +1,16 @@
+import type { Ctx } from './commands.js';
+/** The desktop Settings snapshot uses the selected project key's organization, as AccountClient on macOS does.
+ * The optional user identity comes from the session; saved credentials never imply connector liveness. */
+export declare function desktopAccount(ctx: Ctx): Promise<{
+    identity: {
+        id: string;
+        email: string;
+        email_verified: boolean;
+        display_name: string | null;
+        mfa_enabled: boolean;
+    } | null;
+    organization: Record<string, unknown>;
+    usage: Record<string, unknown> | null;
+    spend: Record<string, unknown> | null;
+    credentials: import("@shardflux/sdk").AgentCredentialMetadata[] | null;
+}>;

package/dist/desktop-account.js

@@ -0,0 +1,29 @@
+import { UsageError } from "./errors.js";
+/** The desktop Settings snapshot uses the selected project key's organization, as AccountClient on macOS does.
+ * The optional user identity comes from the session; saved credentials never imply connector liveness. */
+export async function desktopAccount(ctx) {
+    const token = ctx.apiKey().token;
+    const request = async (path) => {
+        const response = await (ctx.accountOptions().fetch ?? fetch)(new URL(`v1/${path}`, `${ctx.apiUrl.replace(/\/+$/, '')}/`), {
+            headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' }, redirect: 'error',
+            signal: AbortSignal.any([ctx.signal, AbortSignal.timeout(20_000)]),
+        });
+        if (!response.ok)
+            throw new UsageError(`Couldn’t refresh your account (${response.status}). Try again.`);
+        return await response.json();
+    };
+    const me = await ctx.cloud().me();
+    const org = me.api_key?.organization_id;
+    if (!org)
+        throw new UsageError('The project key did not identify its organization. Sign in to Shardflux again.');
+    const [organization, usage, spend, credentials, identity] = await Promise.all([
+        request(`organizations/${encodeURIComponent(org)}`),
+        request(`organizations/${encodeURIComponent(org)}/usage/summary`).catch(() => null),
+        request(`organizations/${encodeURIComponent(org)}/spend`).catch(() => null),
+        ctx.cloud().agentCredentials.list().catch(() => null),
+        ctx.sessionSource() ? ctx.account().me().then(value => value.user).catch(() => null) : Promise.resolve(null),
+    ]);
+    if (organization.id !== org || typeof organization.name !== 'string' || !organization.name)
+        throw new UsageError('The organization response is unreadable. Refresh your account and try again.');
+    return { identity, organization, usage, spend, credentials };
+}

package/dist/device-bridge.js

@@ -323,8 +323,24 @@ export async function devicePort(ws, cell, kind, ports, signal) {
     await new Promise((resolveListen, reject) => { server.once('error', reject); server.listen(ports.local_port, '127.0.0.1', resolveListen); });
     let stopping;
     const abort = () => { void stop().catch(() => undefined); };
-    const stop = () => stopping ??= (async () => { signal.removeEventListener('abort', abort); for (const socket of peers)
-        socket.destroy(); await Promise.all([...handles].map(h => h.close())); await new Promise(resolveClose => server.close(() => resolveClose())); cell.close(); })();
+    const stop = () => stopping ??= (async () => {
+        signal.removeEventListener('abort', abort);
+        for (const socket of peers)
+            socket.destroy();
+        let failure;
+        await Promise.all([...handles].map(async (handle) => {
+            try {
+                await handle.close();
+            }
+            catch (error) {
+                failure ??= { error };
+            }
+        }));
+        await new Promise(resolveClose => server.close(() => resolveClose()));
+        cell.close();
+        if (failure)
+            throw failure.error;
+    })();
     signal.addEventListener('abort', abort, { once: true });
     if (signal.aborted)
         abort();

package/dist/filesystem-commands.js

@@ -41,7 +41,8 @@ async function templateSource(ctx, project) {
 export function filesystemLine(state) {
     const rebase = state.rebase_deferred ? ', follows your machine on next use' : state.rebase_pending ? ', rebase pending' : '';
     const base = state.platform_base ? `; platform ${state.platform_base.slug}@${state.platform_base.version}${rebase}` : '';
-    return usageLine(state) + base + (state.cache_scope ? `; cache: ${state.cache_scope}` : '');
+    const volumes = state.volumes?.length ? `; volumes: ${state.volumes.map(v => `${v.name} at ${v.mount_path} (${v.mode})`).join(', ')}` : '';
+    return usageLine(state) + base + volumes + (state.cache_scope ? `; cache: ${state.cache_scope}` : '');
 }
 function usageLine(state) {
     const current = state.version > 0 ? `version ${state.version}` : '';

package/dist/local-sessions.d.ts

@@ -20,7 +20,7 @@ export interface LocalSession {
 export interface SessionState {
     /** A process has the session open right now. */
     running: boolean;
-    /** working: a turn is in progress (never cut off); idle: between turns, or no process is running it. */
+    /** working: a turn is in progress; idle: between turns, or no process is running it. */
     turn: 'working' | 'idle';
     pid?: number;
 }
@@ -46,6 +46,12 @@ export declare function workingDirectory(recent: Rec[], fallback: string): strin
 /** Whether the transcript's last turn is still running, from its records (see the module comment). */
 export declare function claudeTurnFromRecords(records: Rec[]): 'working' | 'idle';
 export declare function codexTurnFromRecords(records: Rec[]): 'working' | 'idle';
+/** The actual writer, never a guessed PID from the transcript. Codex TUI's writer may be its shared daemon. */
+export declare function sessionProcessPid(s: Pick<LocalSession, 'harness' | 'session_id' | 'file'>, env: Env): number | undefined;
+/** The selected thread's last started turn, from its native rollout (Codex 0.160.0). */
+export declare function sessionTurnId(s: Pick<LocalSession, 'file'>): string | undefined;
+/** Re-read the registry immediately before signalling: a PID reused after a session exits belongs to someone else. */
+export declare function sameClaudeProcess(s: Pick<LocalSession, 'session_id'>, env: Env, pid: number): boolean;
 /**
  * Whether a session worked in `folder` (or below it): any working directory its records name (0.20.2+; before, only
  * the first). A session started in a scratch folder that went on in a repository is listed under the repository too.

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/menubar.js

@@ -1,3 +1,4 @@
+import { desktopAccount } from "./desktop-account.js";
 import { execFile, spawn } from 'node:child_process';
 import { chmodSync, closeSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readdirSync, readFileSync, renameSync, rmSync, writeSync } from 'node:fs';
 import { createRequire } from 'node:module';
@@ -492,3 +493,4 @@ export const MENUBAR_HANDLERS = Object.fromEntries(['start', 'stop', 'status'].m
     };
     return [`menubar ${action}`, handler];
 }));
+MENUBAR_HANDLERS['menubar account'] = async (ctx) => { ctx.io.stdout.write(json(await desktopAccount(ctx))); return 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,14 +2,15 @@
  * `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';
@@ -34,6 +35,8 @@ 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";
+import { interruptLocalTurn, MOVE_CONTINUATION, stopsLocalTurn } from "./move-interrupt.js";
+import { seedPhase } from "./seed-phases.js";
 const VM_HOME = '/home/user';
 const SPACE = '/shardflux/project';
 /** A transcript above this moves with the repository's history bound. */
@@ -213,13 +216,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)
@@ -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,14 @@ 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 });
+        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 } : {}) });
         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 +319,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/worktree-twin-engine.js

@@ -20,17 +20,26 @@ import { join } from 'node:path';
 /** Its VM is gone: the conversation ended (archived after the retention window, or done). */
 export const ended = (c) => !!c.ended_at || c.state === 'archived';
 const revision = (c) => JSON.stringify([c.changes, c.summary]);
+/**
+ * A Codex Cloud thread (0.24.0+) lives on between turns, and Cloud's own thread state is its state: an idle thread (its
+ * turn finished) and one waiting on an approval, an answer or an error are both needs_you, and only the latter has a
+ * `question`. A landing is never recorded on it (the API ends a Cloud conversation that records one); the ledger keeps it.
+ */
+const cloud = (c) => c.route === 'codex-cloud';
+const asking = (c) => c.state === 'needs_you' && !(cloud(c) && !c.question);
 /** A turn ended with committed work only; the agent is not asking anything. */
 export function finished(c, agents) {
     if (ended(c))
         return 'state';
+    if (cloud(c))
+        return c.state === 'needs_you' && !c.question ? 'state' : null;
     const agent = agents.find(a => a.workspace_id === c.workspace_id && c.harness_session_id && a.id === `${c.workspace_id}:${c.harness_session_id}`);
     if (agent)
         return agent.state === 'working' ? null : agent;
     return c.state === 'unresolved' || c.state === 'done' ? 'state' : null;
 }
 export function eligible(c, ledger, now) {
-    if (c.route === 'codex-cloud' || c.join_mode === 'reviewer' || c.state === 'needs_you')
+    if (c.join_mode === 'reviewer' || asking(c))
         return false;
     if (!c.changes || c.changes.commits <= 0 || c.changes.uncommitted || c.landed?.how === 'discarded')
         return false;
@@ -40,7 +49,7 @@ export function eligible(c, ledger, now) {
         return false;
     if ((st.retry_at ?? 0) > now)
         return false;
-    if (st.landed_revision === revision(c) && (ended(c) || c.landed?.how === 'merged' || c.landed?.how === 'pr'))
+    if (st.landed_revision === revision(c) && (ended(c) || cloud(c) || c.landed?.how === 'merged' || c.landed?.how === 'pr'))
         return false;
     return st.conflict_revision !== revision(c);
 }
@@ -118,7 +127,7 @@ export class TwinEngine {
             const listedAt = d.now();
             const all = (await d.conversations(project)).filter(c => mine.has(c.id));
             for (const c of all)
-                if (!ended(c) && c.route !== 'codex-cloud' && c.join_mode !== 'reviewer') {
+                if (!ended(c) && c.join_mode !== 'reviewer') {
                     watched.add(c.id);
                     this.#watch(c, listedAt, signal);
                 }
@@ -236,7 +245,7 @@ export class TwinEngine {
         }
         // Landed at this revision already; only the API record is missing (a later report reset it on an older guest).
         if (st.landed_revision === rev) {
-            if (ended(c))
+            if (ended(c) || cloud(c))
                 return;
             if ((this.#posted.get(c.id) ?? 0) + 30_000 < d.now()) {
                 this.#posted.set(c.id, d.now());
@@ -354,8 +363,9 @@ export class TwinEngine {
         if (o.state !== 'landed')
             vm.close();
         const post = async (action, ref) => {
-            // An ended conversation cannot record a landing any more (the API refuses); the ledger keeps it.
-            if (ended(c))
+            // An ended conversation cannot record a landing any more (the API refuses), and a Codex Cloud thread goes on after
+            // one; the ledger keeps both.
+            if (ended(c) || cloud(c))
                 return;
             this.#posted.set(c.id, d.now());
             await d.land(c, action, ref);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/cli",
-  "version": "0.23.0",
+  "version": "0.24.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",
@@ -46,21 +46,23 @@
     "classic-level": "3.0.0",
     "smol-toml": "1.9.0",
     "snappyjs": "0.7.0",
+    "ws": "8.22.0",
     "yaml": "2.9.1",
-    "@shardflux/sdk": "^0.27.1"
+    "@shardflux/sdk": "^0.27.2"
   },
   "devDependencies": {
     "@eslint/js": "10.0.1",
     "@types/node": "24.13.6",
+    "@types/ws": "8.18.2",
     "eslint": "10.11.0",
     "playwright": "1.62.1",
     "typescript": "5.9.3",
     "typescript-eslint": "8.70.1"
   },
   "optionalDependencies": {
-    "@shardflux/desktop-linux-x64": "0.1.10",
-    "@shardflux/desktop-linux-arm64": "0.1.10",
-    "@shardflux/menubar-darwin": "^0.8.5"
+    "@shardflux/desktop-linux-arm64": "0.1.12",
+    "@shardflux/desktop-linux-x64": "0.1.12",
+    "@shardflux/menubar-darwin": "^0.8.6"
   },
   "scripts": {
     "build": "node scripts/build.mjs",