@shardflux/cli 0.19.1 → 0.22.0

package/dist/initial-prompt.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { readInput, str, strs } from "./commands.js";
 import { PtyOutputCursor } from "./agent-terminal.js";
 import { CodedError, UsageError } from "./errors.js";
+import { seedEvent, seedPhase } from "./seed-phases.js";
 import { ShardfluxApiError } from '@shardflux/sdk';
 import { parse, stringify } from 'smol-toml';
 /** The user chose this repository. Trust exactly that new VM worktree before launching Codex's first turn. */
@@ -150,6 +151,41 @@ export function inputBoxReady(tail, glyph) {
     const at = plain.lastIndexOf(glyph);
     return at >= 0 && !/^[\s\u00a0]*\d+\./.test(plain.slice(at + glyph.length));
 }
+/**
+ * The first prompt typed by the VM's own guest (0.21.1+, with a guest that has it): `sf-agent conversation first-prompt` waits for
+ * the input box, pastes, waits for the paste to show and presses Enter inside the VM, with the same checks as
+ * `submitInitialPrompt`, in one request from here instead of an attachment and three round trips. Nothing was typed
+ * when the result is `unsupported` (an older guest without the command: this terminal types it) or `not_ready` (the
+ * harness never showed its input box within the guest's wait: the conversation's inbox takes it, where there is one).
+ */
+export async function guestFirstPrompt(cell, ptyId, app, prompt, workspaceKey, signal) {
+    const asked = Date.now();
+    const r = await cell.exec.run(['sf-agent', 'conversation', 'first-prompt', '--pty', ptyId, '--app', app], { stdin: prompt, timeoutMs: 30_000, maxOutputBytes: 8192, signal });
+    let result;
+    try {
+        result = JSON.parse(r.stdout.trim().split('\n').at(-1) ?? '');
+    }
+    catch {
+        result = undefined;
+    }
+    // The guest's own steps, on this computer's clock from when the request left (an upper bound by its transit).
+    for (const [name, ms] of [['guest_input_box', result?.ready_ms], ['guest_echo', result?.echo_ms], ['guest_submitted', result?.submitted_ms]]) {
+        if (typeof ms === 'number')
+            seedEvent(name, asked + ms);
+    }
+    // An older guest answers "unknown tool conversation_first-prompt" and prints no result.
+    if (!result || typeof result.pasted !== 'boolean')
+        return 'unsupported';
+    if (result.submitted === true) {
+        seedPhase('prompt_echo');
+        return 'submitted';
+    }
+    if (!result.pasted)
+        return 'not_ready';
+    // Typed into the input box: it must not be typed again.
+    const sent = typeof result.echo_ms === 'number' && result.echo_ms > 0;
+    throw new CodedError('initial_prompt_failed', `Created ${workspaceKey}, but the initial prompt ${sent ? 'could not be confirmed' : 'was not submitted'}. Open that conversation before starting another.`, undefined, { workspace_key: workspaceKey, submitted: sent });
+}
 /**
  * Wait for the native terminal to enable paste before submitting one first turn. No blind timing or input replay.
  * When nothing was typed yet and the terminal never became ready, `queue` hands the prompt to the conversation's guest
@@ -162,6 +198,7 @@ export async function submitInitialPrompt(connect, prompt, workspaceKey, signal,
     let sent = false, pasted = false;
     try {
         connection = await connect(bounded);
+        seedPhase('attach');
         let tail = '', pasteEnabled = false;
         const cursor = new PtyOutputCursor();
         for await (const message of connection.messages()) {
@@ -176,8 +213,10 @@ export async function submitInitialPrompt(connect, prompt, workspaceKey, signal,
             pasteEnabled ||= tail.includes('\x1b[?2004h');
             // eslint-disable-next-line no-control-regex -- Strip native terminal ANSI before matching prompt echo.
             const plain = tail.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').replace(/\s/g, '');
-            if (sent && bytes.length)
+            if (sent && bytes.length) {
+                seedPhase('prompt_echo');
                 return 'submitted';
+            }
             if (pasted) {
                 // A long prompt overflows the input box: a 24-row terminal shows only its end, so either end confirms the paste.
                 const compact = prompt.replace(/\s/g, '');
@@ -188,6 +227,7 @@ export async function submitInitialPrompt(connect, prompt, workspaceKey, signal,
                     await write(enter);
                 else
                     connection.input(enter);
+                seedPhase('prompt_enter');
                 sent = true;
                 tail = '';
                 continue;
@@ -196,10 +236,12 @@ export async function submitInitialPrompt(connect, prompt, workspaceKey, signal,
             if (!ready || !pasteEnabled)
                 continue;
             const paste = Buffer.from(`\x1b[200~${prompt}\x1b[201~`);
+            seedPhase('input_box');
             if (write)
                 await write(paste);
             else
                 connection.input(paste);
+            seedPhase('prompt_paste');
             pasted = true;
             tail = '';
         }

package/dist/large-media.d.ts

@@ -0,0 +1,14 @@
+/** Images, audio and video from this size on (marketing assets of a few hundred KB are the common case). */
+export declare const LARGE_MEDIA_BYTES: number;
+export interface OutsideFile {
+    path: string;
+    size: number;
+    mode: number;
+    meta: string;
+}
+/** The worktree's large untracked media, sorted; each file's sample is judged once per version (size, times, inode). */
+export declare function largeUntrackedMedia(root: string, stateDir: string, id: string, signal?: AbortSignal): Promise<OutsideFile[]>;
+/** Pathspecs that leave these files out of `git add -A`. */
+export declare const outsideSpecs: (files: readonly OutsideFile[]) => string[];
+/** The Git object id of a file's bytes with no filters (`git hash-object --no-filters`), streamed. */
+export declare function blobId(path: string, format: 'sha1' | 'sha256', size: number): Promise<string>;

package/dist/large-media.js

@@ -0,0 +1,100 @@
+/**
+ * Large untracked media (0.22.0+): untracked files of at least LARGE_MEDIA_BYTES whose bytes barely compress (video,
+ * images, audio, archives). Twin snapshots leave them out, so a start or a landing never hashes and stores hundreds of
+ * megabytes in Git; a start carries them as files beside the snapshot instead (prepared-repository.ts), and the VM's
+ * Git ignores them as the user's Git sees them: untracked. Text, however large, stays in the snapshot.
+ */
+import { createHash } from 'node:crypto';
+import { constants, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { lstat, open } from 'node:fs/promises';
+import { join } from 'node:path';
+import { deflateRawSync } from 'node:zlib';
+import { projectGitPaths, validSyncPath } from "./project-sync-manifest.js";
+/** Images, audio and video from this size on (marketing assets of a few hundred KB are the common case). */
+export const LARGE_MEDIA_BYTES = 256 << 10;
+/** A 64 KiB sample that deflates to at least this share of its size counts as incompressible. */
+const INCOMPRESSIBLE = 0.92;
+/** A path the VM can write and its Git can ignore with one exclude line (no line breaks, valid UTF-8). */
+const carriable = (path) => validSyncPath(path) && !/[\n\r]/.test(path) && Buffer.from(path, 'utf8').toString('utf8') === path && !path.includes('�');
+async function sampleIncompressible(path) {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const sample = Buffer.allocUnsafe(64 << 10), { bytesRead } = await file.read(sample, 0, sample.length, 0);
+        return bytesRead > 0 && deflateRawSync(sample.subarray(0, bytesRead), { level: 1 }).length >= bytesRead * INCOMPRESSIBLE;
+    }
+    finally {
+        await file.close();
+    }
+}
+/** The worktree's large untracked media, sorted; each file's sample is judged once per version (size, times, inode). */
+export async function largeUntrackedMedia(root, stateDir, id, signal) {
+    const candidates = [];
+    await projectGitPaths(root, ['ls-files', '-z', '--others', '--exclude-standard'], path => { candidates.push(path); }, { signal });
+    const dir = join(stateDir, 'twin'), cachePath = join(dir, `${id}.media.json`);
+    let cache = {};
+    try {
+        cache = JSON.parse(readFileSync(cachePath, 'utf8'));
+    }
+    catch { /* first snapshot */ }
+    const next = {}, found = [];
+    let at = 0;
+    await Promise.all(Array.from({ length: Math.min(16, candidates.length) }, async () => {
+        for (let i = at++; i < candidates.length; i = at++) {
+            const path = candidates[i];
+            if (path.endsWith('/') || path.split('/').some(part => part === '.shard' || part.includes('.shard-tmp-')) || !carriable(path))
+                continue;
+            let st;
+            try {
+                st = await lstat(join(root, path));
+            }
+            catch {
+                continue;
+            }
+            if (!st.isFile() || st.size < LARGE_MEDIA_BYTES)
+                continue;
+            const meta = `${st.size}:${st.mtimeMs}:${st.ctimeMs}:${st.ino}:${st.mode}`;
+            let media = cache[path]?.meta === meta ? cache[path].media : undefined;
+            if (media === undefined) {
+                try {
+                    media = await sampleIncompressible(join(root, path));
+                }
+                catch {
+                    continue;
+                }
+            }
+            next[path] = { meta, media };
+            if (media)
+                found.push({ path, size: st.size, mode: st.mode & 0o777, meta });
+        }
+    }));
+    if (JSON.stringify(next) !== JSON.stringify(cache)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const temp = `${cachePath}.${process.pid}.tmp`;
+        writeFileSync(temp, JSON.stringify(next), { mode: 0o600 });
+        renameSync(temp, cachePath);
+    }
+    return found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+/** Pathspecs that leave these files out of `git add -A`. */
+export const outsideSpecs = (files) => files.map(f => `:(exclude,literal)${f.path}`);
+/** The Git object id of a file's bytes with no filters (`git hash-object --no-filters`), streamed. */
+export async function blobId(path, format, size) {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW), hash = createHash(format).update(`blob ${size}\0`);
+    try {
+        const buffer = Buffer.allocUnsafe(4 << 20);
+        let read = 0;
+        for (;;) {
+            const { bytesRead } = await file.read(buffer, 0, buffer.length, read);
+            if (!bytesRead)
+                break;
+            hash.update(buffer.subarray(0, bytesRead));
+            read += bytesRead;
+        }
+        if (read !== size)
+            throw new Error('changed while it was read');
+    }
+    finally {
+        await file.close();
+    }
+    return hash.digest('hex');
+}

package/dist/linux-terminal.d.ts

@@ -3,9 +3,11 @@ import type { Values } from './args.js';
 /** Linux terminals use the existing native Codex harness; explicit app routes keep Cloud. */
 export declare function linuxTerminalSession(ctx: Pick<Ctx, 'io' | 'json'>, values: Values, platform?: NodeJS.Platform): boolean;
 export declare const shellWord: (s: string) => string;
-export declare function linuxTerminalCommand(argv: string[], env: Record<string, string | undefined>): {
+/**
+ * The Linux default terminal running `argv` (in `cwd` when given): $TERMINAL, x-terminal-emulator, then gnome-terminal.
+ * The other terminal apps (Ghostty, kitty, WezTerm, Alacritty, Warp) open through terminal-apps.ts.
+ */
+export declare function linuxTerminalCommand(argv: string[], env: Record<string, string | undefined>, cwd?: string): {
     command: string;
     args: string[];
 } | null;
-/** Invoked before cloud work: the new terminal owns the attach, credentials and any prompts. */
-export declare function openLinuxTerminal(ctx: Ctx, ref: string, app?: string): Promise<number>;

package/dist/linux-terminal.js

@@ -1,12 +1,15 @@
 import { accessSync, constants } from 'node:fs';
 import { join } from 'node:path';
-import { spawn } from 'node:child_process';
 /** Linux terminals use the existing native Codex harness; explicit app routes keep Cloud. */
 export function linuxTerminalSession(ctx, values, platform = process.platform) {
     return platform === 'linux' && (values.in === 'terminal' || (values.in === undefined && !!ctx.io.stdin.isTTY && !ctx.json));
 }
 export const shellWord = (s) => `'${s.replaceAll("'", "'\\''")}'`;
-export function linuxTerminalCommand(argv, env) {
+/**
+ * The Linux default terminal running `argv` (in `cwd` when given): $TERMINAL, x-terminal-emulator, then gnome-terminal.
+ * The other terminal apps (Ghostty, kitty, WezTerm, Alacritty, Warp) open through terminal-apps.ts.
+ */
+export function linuxTerminalCommand(argv, env, cwd) {
     const executable = (name) => name.includes('/') ? [name] : (env.PATH ?? '').split(':').filter(Boolean).map(p => join(p, name));
     const exists = (name) => executable(name).some(p => { try {
         accessSync(p, constants.X_OK);
@@ -16,27 +19,10 @@ export function linuxTerminalCommand(argv, env) {
         return false;
     } });
     // The shell keeps the window open on an attach error so the user can read and retry it.
-    const attach = ['sh', '-c', `${argv.map(shellWord).join(' ')}; status=$?; if [ "$status" -ne 0 ]; then printf '\nPress Enter to close.'; read answer; fi; exit "$status"`];
+    const attach = ['sh', '-c', `${cwd ? `cd ${shellWord(cwd)} 2>/dev/null; ` : ''}${argv.map(shellWord).join(' ')}; status=$?; if [ "$status" -ne 0 ]; then printf '\nPress Enter to close.'; read answer; fi; exit "$status"`];
     for (const command of [...new Set([env.TERMINAL?.trim(), 'x-terminal-emulator', 'gnome-terminal'].filter((s) => !!s))]) {
         if (exists(command))
             return { command, args: [command === 'gnome-terminal' ? '--' : '-e', ...attach] };
     }
     return null;
 }
-/** Invoked before cloud work: the new terminal owns the attach, credentials and any prompts. */
-export async function openLinuxTerminal(ctx, ref, app) {
-    const words = ['agents', 'open', ref, '--in', 'terminal', ...(app ? ['--app', app] : [])];
-    const argv = ctx.runtime ? [ctx.runtime.node, ctx.runtime.script, '--api-url', ctx.apiUrl, ...words] : ['shard', ...words];
-    const choice = linuxTerminalCommand(argv, ctx.io.env);
-    if (choice) {
-        const child = spawn(choice.command, choice.args, { env: ctx.io.env, cwd: process.cwd(), detached: true, stdio: 'ignore' });
-        try {
-            await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', reject); });
-            child.unref();
-            return 0;
-        }
-        catch { /* print a runnable command if the terminal could not start */ }
-    }
-    ctx.io.stdout.write(`${['shard', '--api-url', ctx.apiUrl, ...words].map(shellWord).join(' ')}\n`);
-    return 0;
-}

package/dist/local-sessions.d.ts

@@ -4,8 +4,13 @@ export interface LocalSession {
     session_id: string;
     /** The transcript (Claude) or rollout (Codex) file. */
     file: string;
-    /** The session's working directory, as its transcript records it. */
+    /**
+     * The session's working directory (0.20.2+: the one most of its latest records name, ties to the newest; before, the
+     * first record's). A session started in a scratch folder that went on in a repository is that repository's.
+     */
     cwd: string;
+    /** Every working directory its records name (the transcript's head and tail), the latest used last (0.20.2+). */
+    cwds: string[];
     title: string;
     updated_at: string;
     bytes: number;
@@ -28,10 +33,29 @@ export declare const codexHome: (env: Env) => string;
 export declare function claudeProjectName(cwd: string): string;
 /** Records appended after `offset` (whole lines only). */
 export declare function recordsAfter(file: string, offset: number): Rec[];
+/** A record's working directory: Claude's `cwd` on every record, Codex's on session_meta and turn_context. */
+export declare function recordCwd(r: Rec): string;
+/** The working directories records name, the latest used last. */
+export declare function recordCwds(records: Rec[]): string[];
+/**
+ * Where a session works: the working directory most of its latest records name (the newest wins a tie), so a session
+ * started in a scratch folder that went on in a repository belongs to the repository, and a brief `cd` elsewhere at the
+ * end does not move it. `recent` is the transcript's tail; `fallback` when it names none.
+ */
+export declare function workingDirectory(recent: Rec[], fallback: string): string;
 /** 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';
-/** A project's sessions on this computer, newest first: those started in the folder or below it. */
+/**
+ * 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.
+ */
+export declare function workedIn(s: Pick<LocalSession, 'cwd' | 'cwds'>, folder: string): boolean;
+/**
+ * A project's sessions on this computer, newest first: those that worked in the folder or below it. Claude keeps a
+ * transcript under the folder it started in, so one that started elsewhere (a scratch folder) and went on here is found
+ * by its records: the newest transcripts of other folders whose last 64 KiB name this folder are read.
+ */
 export declare function listLocalSessions(folder: string, env: Env, options?: {
     harness?: SessionHarness;
     limit?: number;

package/dist/local-sessions.js

@@ -93,6 +93,37 @@ const oneLine = (text, max = 80) => {
     return line.length > max ? `${line.slice(0, max - 1).trimEnd()}…` : line;
 };
 // ---------------------------------------------------------------------------------------------------------------
+// Working directories
+/** A record's working directory: Claude's `cwd` on every record, Codex's on session_meta and turn_context. */
+export function recordCwd(r) {
+    if (typeof r.cwd === 'string')
+        return r.cwd;
+    return r.type === 'session_meta' || r.type === 'turn_context' ? str(obj(r.payload).cwd) : '';
+}
+/** The working directories records name, the latest used last. */
+export function recordCwds(records) {
+    const last = new Map();
+    records.forEach((r, i) => { const cwd = recordCwd(r); if (cwd)
+        last.set(cwd, i); });
+    return [...last.entries()].sort((a, b) => a[1] - b[1]).map(([cwd]) => cwd);
+}
+/** How many of the latest records with a working directory decide where a session works. */
+const LATEST_CWDS = 100;
+/**
+ * Where a session works: the working directory most of its latest records name (the newest wins a tie), so a session
+ * started in a scratch folder that went on in a repository belongs to the repository, and a brief `cd` elsewhere at the
+ * end does not move it. `recent` is the transcript's tail; `fallback` when it names none.
+ */
+export function workingDirectory(recent, fallback) {
+    const count = new Map(), last = new Map();
+    recent.map(recordCwd).filter(Boolean).slice(-LATEST_CWDS).forEach((cwd, i) => { count.set(cwd, (count.get(cwd) ?? 0) + 1); last.set(cwd, i); });
+    let best = '';
+    for (const [cwd, n] of count)
+        if (!best || n > count.get(best) || (n === count.get(best) && last.get(cwd) > last.get(best)))
+            best = cwd;
+    return best || fallback;
+}
+// ---------------------------------------------------------------------------------------------------------------
 // Claude
 function claudeText(content) {
     if (typeof content === 'string')
@@ -153,10 +184,12 @@ function claudeSession(file) {
         return null;
     const titled = [...last].reverse().find(r => (r.type === 'custom-title' && str(r.customTitle)) || (r.type === 'ai-title' && str(r.aiTitle)) || (r.type === 'summary' && str(r.summary)));
     const title = titled ? str(titled.customTitle) || str(titled.aiTitle) || str(titled.summary) : claudeText(obj(prompt.message).content);
-    // Where the session started: its folder (a later `cd` in a tool call moves later records' cwd, not the session).
+    // Where it works now (a session started in a scratch folder that went on in a repository is the repository's), and
+    // every folder it worked in.
     const started = [...first, ...last].find(r => str(r.cwd)) ?? prompt;
-    return { harness: 'claude', session_id: id, file, cwd: str(started.cwd), title: oneLine(title), updated_at: st.mtime.toISOString(), bytes: st.size,
-        source: str(prompt.entrypoint) || 'cli' };
+    const records = st.size <= (256 << 10) ? first : [...first, ...last];
+    return { harness: 'claude', session_id: id, file, cwd: workingDirectory(last, str(started.cwd)), cwds: recordCwds(records), title: oneLine(title),
+        updated_at: st.mtime.toISOString(), bytes: st.size, source: str(prompt.entrypoint) || 'cli' };
 }
 function claudeProcesses(env) {
     const dir = join(claudeConfigDir(env), 'sessions');
@@ -209,22 +242,33 @@ export function codexTurnFromRecords(records) {
     }
     return 'idle';
 }
-function codexSession(file, metaOnly) {
+/**
+ * A Codex rollout. `belongs` (a listing's folder test) is asked of its working directories: the head's first, and only
+ * when none matches, the tail's too (a thread that moved on to another folder in a later turn).
+ */
+function codexSession(file, belongs) {
     const match = ROLLOUT.exec(basename(file));
     if (!match)
         return null;
     const st = statSync(file);
     const first = head(file);
     const meta = first.find(r => r.type === 'session_meta');
-    const cwd = str(obj(meta?.payload).cwd);
-    if (!meta || !cwd || (metaOnly && !metaOnly(cwd)))
+    const started = str(obj(meta?.payload).cwd);
+    if (!meta || !started)
+        return null;
+    if (belongs && !recordCwds(first).some(belongs) && (st.size <= (256 << 10) || !tailNames(file, st.size, belongs)))
         return null;
     const last = tail(file, st.size);
     const prompt = [...first, ...last].map(codexPrompt).find(Boolean);
     if (!prompt)
         return null;
-    return { harness: 'codex', session_id: match[1], file, cwd, title: oneLine(prompt), updated_at: st.mtime.toISOString(), bytes: st.size,
-        source: str(obj(meta.payload).originator) || 'codex' };
+    const records = st.size <= (256 << 10) ? first : [...first, ...last];
+    return { harness: 'codex', session_id: match[1], file, cwd: workingDirectory(last, started), cwds: recordCwds(records), title: oneLine(prompt),
+        updated_at: st.mtime.toISOString(), bytes: st.size, source: str(obj(meta.payload).originator) || 'codex' };
+}
+/** Whether the transcript's last 64 KiB name a working directory `belongs` takes, in record metadata only. */
+function tailNames(file, size, belongs) {
+    return recordCwds(tail(file, size, 64 << 10)).some(belongs);
 }
 /** Every rollout file, newest first (one stat each; heads are read only for the ones a caller looks at). */
 function codexRollouts(env) {
@@ -273,14 +317,29 @@ const real = (path) => { try {
 catch {
     return path;
 } };
-/** A project's sessions on this computer, newest first: those started in the folder or below it. */
+/**
+ * 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.
+ */
+export function workedIn(s, folder) {
+    const inside = within(real(folder));
+    return [s.cwd, ...s.cwds].some(cwd => inside(real(cwd)));
+}
+/** Claude transcripts stored under another folder's name that a listing looks at (the newest), each by its tail first. */
+const FOREIGN_CLAUDE_LIMIT = 400;
+/**
+ * A project's sessions on this computer, newest first: those that worked in the folder or below it. Claude keeps a
+ * transcript under the folder it started in, so one that started elsewhere (a scratch folder) and went on here is found
+ * by its records: the newest transcripts of other folders whose last 64 KiB name this folder are read.
+ */
 export function listLocalSessions(folder, env, options = {}) {
     const root = real(folder), limit = options.limit ?? 10, inside = within(root), out = [];
+    const belongs = (cwd) => inside(real(cwd));
     if (options.harness !== 'codex') {
         const projects = join(claudeConfigDir(env), 'projects'), exact = claudeProjectName(root);
         let dirs = [];
         try {
-            dirs = readdirSync(projects).filter(d => d === exact || d.startsWith(`${exact}-`));
+            dirs = readdirSync(projects);
         }
         catch { /* no Claude sessions */ }
         const files = [];
@@ -292,22 +351,43 @@ export function listLocalSessions(folder, env, options = {}) {
             catch {
                 continue;
             }
+            const own = dir === exact || dir.startsWith(`${exact}-`);
             for (const name of names)
                 if (name.endsWith('.jsonl')) {
                     const file = join(projects, dir, name);
                     try {
-                        files.push({ file, mtime: statSync(file).mtimeMs });
+                        files.push({ file, mtime: statSync(file).mtimeMs, own });
                     }
                     catch { /* removed */ }
                 }
         }
-        let found = 0;
-        for (const { file } of files.sort((a, b) => b.mtime - a.mtime)) {
+        let found = 0, foreign = 0;
+        for (const { file, own } of files.sort((a, b) => b.mtime - a.mtime)) {
             if (found >= limit)
                 break;
-            const s = claudeSession(file);
+            if (!own) {
+                if (foreign >= FOREIGN_CLAUDE_LIMIT)
+                    continue;
+                foreign++;
+                let size;
+                try {
+                    size = statSync(file).size;
+                }
+                catch {
+                    continue;
+                }
+                if (!tailNames(file, size, belongs))
+                    continue;
+            }
+            let s;
+            try {
+                s = claudeSession(file);
+            }
+            catch {
+                continue;
+            }
             // A folder named like another's prefix ("app" and "app-web") is told apart by the recorded cwd.
-            if (s && inside(real(s.cwd))) {
+            if (s && workedIn(s, root)) {
                 out.push(s);
                 found++;
             }
@@ -318,7 +398,7 @@ export function listLocalSessions(folder, env, options = {}) {
         for (const { file } of codexRollouts(env)) {
             if (found >= limit)
                 break;
-            const s = codexSession(file, cwd => inside(real(cwd)));
+            const s = codexSession(file, belongs);
             if (s) {
                 out.push(s);
                 found++;
@@ -397,25 +477,34 @@ export function rewriteSessionPaths(bytes, from, to) {
         return bytes;
     const needles = [from, JSON.stringify(from).slice(1, -1)];
     const move = (path) => (path === from || path.startsWith(`${from}/`) ? to + path.slice(from.length) : path);
-    const rewrite = (value) => {
-        if (Array.isArray(value))
-            return value.map(rewrite);
-        if (!value || typeof value !== 'object')
-            return value;
+    const rewriteFields = (value) => {
         return Object.fromEntries(Object.entries(value).map(([key, leaf]) => {
             if (typeof leaf === 'string' && ['cwd', 'workdir', 'working_directory'].includes(key))
                 return [key, move(leaf)];
             if (Array.isArray(leaf) && ['workspace_roots', 'runtime_workspace_roots', 'writable_roots'].includes(key))
-                return [key, leaf.map(v => (typeof v === 'string' ? move(v) : rewrite(v)))];
-            return [key, rewrite(leaf)];
+                return [key, leaf.map(v => (typeof v === 'string' ? move(v) : v))];
+            return [key, leaf];
         }));
     };
+    const rewrite = (r) => {
+        const moved = rewriteFields(r);
+        if (r.type === 'session_meta' || r.type === 'turn_context') {
+            const payload = rewriteFields(obj(r.payload));
+            for (const key of ['sandbox_policy', 'permission_profile']) {
+                if (payload[key] && typeof payload[key] === 'object' && !Array.isArray(payload[key]))
+                    payload[key] = rewriteFields(obj(payload[key]));
+            }
+            moved.payload = payload;
+        }
+        return moved;
+    };
     const lines = bytes.toString('utf8').split('\n');
     return Buffer.from(lines.map(line => {
         if (!line || !needles.some(n => line.includes(n)))
             return line;
         try {
-            return JSON.stringify(rewrite(JSON.parse(line)));
+            const parsed = JSON.parse(line);
+            return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? JSON.stringify(rewrite(obj(parsed))) : line;
         }
         catch {
             return line;