@turns/dev 0.0.4 → 0.0.6

package/dist/agent-anchor.js

@@ -8,7 +8,7 @@ import readline from 'node:readline';
 import { DatabaseSync } from 'node:sqlite';
 import { fileURLToPath } from 'node:url';
 import { WebSocket } from 'ws';
-import { ACP_PROFILES, lettaSessionIdentity, PROCESS_HARNESSES, parseLettaSessionIdentity, processEventSessionId, processInvocation, RPC_PROFILES, resolveHarnessCommand, rpcFrameSessionIdentity, rpcUiRequestIsInformational, } from "./harness-registry.js";
+import { ACP_PROFILES, lettaHeadlessEnvironment, lettaSessionIdentity, PROCESS_HARNESSES, parseLettaSessionIdentity, processEventSessionId, processInvocation, RPC_PROFILES, resolveHarnessCommand, rpcFrameSessionIdentity, rpcUiRequestIsInformational, } from "./harness-registry.js";
 import { recordLettaSessionContext } from "./letta-session-context.js";
 const socketIndex = process.argv.indexOf('--socket');
 const socketPath = socketIndex >= 0 ? path.resolve(process.argv[socketIndex + 1] || '') : '';
@@ -363,7 +363,7 @@ class LettaTransport extends LineTransport {
             ...(anchor.model && anchor.model !== 'auto' ? ['--model', anchor.model] : []),
             ...(createSession ? ['--new'] : ['--conversation', existing.conversationId]),
         ];
-        super(anchor, 'letta', resolveHarnessCommand('letta', { command: 'letta' }), args, anchor.cwd);
+        super(anchor, 'letta', resolveHarnessCommand('letta', { command: 'letta' }), args, anchor.cwd, lettaHeadlessEnvironment());
         this.conversationId = createSession ? '' : existing.conversationId;
         this.agentId = createSession ? '' : existing.agentId;
         this.permissionMode = anchor.permissionMode;
@@ -868,6 +868,9 @@ class AcpTransport extends LineTransport {
                 prompt: [{ type: 'text', text }],
             });
         }
+        if (this.profile.steer === 'session/prompt') {
+            return this.prompt(text, 12 * 60 * 60_000);
+        }
         return this.prompt(`/steer ${text}`, 12 * 60 * 60_000);
     }
 }
@@ -1436,9 +1439,11 @@ class Anchor {
         // send_message crosses a local socket after the queue claim crosses a
         // WebSocket, so either acknowledgement can be lost after the agent has
         // already accepted the turn. A replacement claim for the same prompt must
-        // adopt a running/successful turn instead of executing it again. Failed or
-        // interrupted turns remain retryable when the server issues a new claim.
-        if (sameClaim || (sameMessage && ['running', 'completed'].includes(this.currentTurn?.status))) {
+        // adopt it regardless of outcome instead of repeating work or turning a
+        // persistent harness failure into an automatic retry loop. A deliberate
+        // user retry arrives with a new queue message ID.
+        if (sameClaim ||
+            (sameMessage && ['running', 'completed', 'interrupted', 'error'].includes(this.currentTurn?.status))) {
             if (claimToken && claimToken !== this.currentTurn.claimToken) {
                 this.currentTurn = { ...this.currentTurn, claimToken };
             }

package/dist/file-browsing.js

@@ -3,24 +3,20 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { workingDirectoryIsAllowed } from "./directory-policy.js";
-import { uploadFileBytes, uploadFileStream } from "./path-resolution.js";
+import { uploadFileStream } from "./path-resolution.js";
 /**
  * Answering "what is in that directory?" from the machine that knows.
  *
  * A reader's browser cannot reach this machine, and this machine will not open
  * a port to let it try. Directories are small structured answers, so the daemon
- * sends their listing on the control socket immediately and stores the same
- * bytes in the background for offline browsing. Regular files still stream to
- * object storage; nothing stays open once the one browse upload finishes.
- *
- * A directory's fallback is stored at `_index.json` beneath it. Every path is
- * canonicalised before the allowlist is consulted, so a symlink pointing out
- * of an allowed tree is not a way to read the rest of the disk.
+ * sends their listing on the control socket for the server to normalize into
+ * SQLite. Regular files still stream to object storage; nothing stays open
+ * once the one browse upload finishes. Every path is canonicalised before the
+ * allowlist is consulted, so a symlink pointing out of an allowed tree is not
+ * a way to read the rest of the disk.
  */
 /** Kept in step with `MAX_DIRECTORY_ENTRIES` in the Worker's shared listing. */
 export const MAX_DIRECTORY_ENTRIES = 2_000;
-/** Kept in step with `DIRECTORY_INDEX_NAME` in the Worker's shared listing. */
-export const DIRECTORY_INDEX_NAME = '_index.json';
 /** One MB below the Worker request-body ceiling, matching the R2 endpoint. */
 export const MAX_BROWSE_FILE_BYTES = 199 * 1024 * 1024;
 /** The derived label used in reader-facing errors. */
@@ -31,9 +27,11 @@ export const FILE_TYPE_SAMPLE_BYTES = 64 * 1024;
 /** Extensions carrying their own type, where guessing text would be wrong. */
 const BINARY_CONTENT_TYPES = new Map([
     ['.apng', 'image/apng'],
+    ['.aac', 'audio/aac'],
     ['.avif', 'image/avif'],
     ['.bmp', 'image/bmp'],
     ['.gif', 'image/gif'],
+    ['.flac', 'audio/flac'],
     ['.gz', 'application/gzip'],
     ['.heic', 'image/heic'],
     ['.ico', 'image/x-icon'],
@@ -41,12 +39,20 @@ const BINARY_CONTENT_TYPES = new Map([
     ['.jpg', 'image/jpeg'],
     ['.mp3', 'audio/mpeg'],
     ['.mp4', 'video/mp4'],
+    ['.m4a', 'audio/mp4'],
+    ['.m4v', 'video/mp4'],
+    ['.mov', 'video/quicktime'],
+    ['.oga', 'audio/ogg'],
+    ['.ogg', 'audio/ogg'],
+    ['.ogv', 'video/ogg'],
+    ['.opus', 'audio/ogg'],
     ['.pdf', 'application/pdf'],
     ['.png', 'image/png'],
     ['.svg', 'image/svg+xml'],
     ['.wasm', 'application/wasm'],
     ['.webm', 'video/webm'],
     ['.webp', 'image/webp'],
+    ['.wav', 'audio/wav'],
     ['.zip', 'application/zip'],
 ]);
 /**
@@ -167,10 +173,6 @@ export function readDirectory(directory) {
     // clock inside the body would make every read produce different bytes.
     return { path: directory, entries, truncated: names.length > MAX_DIRECTORY_ENTRIES };
 }
-/** Where one directory's listing is stored, as a path in the machine's space. */
-export function directoryIndexPath(directory) {
-    return `${String(directory || '').replace(/\/+$/u, '')}/${DIRECTORY_INDEX_NAME}`;
-}
 export async function browseMachinePath({ requested, machine, baseUrl, options, workingDirectory = '', fetchImpl = fetch, }) {
     const resolved = resolveBrowsePath(requested, {
         workingDirectory,
@@ -182,16 +184,6 @@ export async function browseMachinePath({ requested, machine, baseUrl, options,
         if (body.byteLength > MAX_BROWSE_FILE_BYTES)
             throw new Error(`Directory listing is too large: ${resolved.path}`);
         const etag = crypto.createHash('sha256').update(body).digest('hex');
-        const cache = uploadFileBytes({
-            baseUrl,
-            options,
-            machine,
-            absolutePath: directoryIndexPath(resolved.path),
-            contentType: 'application/json',
-            contentEtag: etag,
-            body,
-            fetchImpl,
-        });
         return {
             path: resolved.path,
             kind: 'directory',
@@ -199,7 +191,6 @@ export async function browseMachinePath({ requested, machine, baseUrl, options,
             contentType: 'application/json',
             listing,
             etag,
-            cache,
         };
     }
     if (resolved.stat.size > MAX_BROWSE_FILE_BYTES) {
@@ -207,8 +198,9 @@ export async function browseMachinePath({ requested, machine, baseUrl, options,
     }
     const sample = readFileTypeSample(resolved.path, resolved.stat.size);
     const contentType = browseContentType(resolved.path, sample, sample.byteLength === resolved.stat.size);
+    const modifiedAt = isoTime(resolved.stat.mtimeMs);
     if (resolved.stat.size === 0)
-        return { path: resolved.path, kind: 'file', bytes: 0, contentType };
+        return { path: resolved.path, kind: 'file', bytes: 0, contentType, modifiedAt };
     await uploadFileStream({
         baseUrl,
         options,
@@ -216,7 +208,8 @@ export async function browseMachinePath({ requested, machine, baseUrl, options,
         absolutePath: resolved.path,
         contentType,
         bytes: resolved.stat.size,
+        modifiedAt,
         fetchImpl,
     });
-    return { path: resolved.path, kind: 'file', bytes: resolved.stat.size, contentType };
+    return { path: resolved.path, kind: 'file', bytes: resolved.stat.size, contentType, modifiedAt };
 }

package/dist/harness-registry.js

@@ -41,6 +41,10 @@ export const ACP_PROFILES = {
         command: 'opencode',
         args: ['acp'],
         homePaths: [['.opencode', 'bin', 'opencode']],
+        // OpenCode 1.18.21 gates its native task(background=true) schema behind
+        // this flag. Older versions ignore it; current versions expose a real
+        // independently addressable subagent lifecycle to daemon-launched turns.
+        env: { OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS: 'true' },
         options: [{ id: 'mode', value: 'build' }],
         mcp: true,
     },
@@ -101,6 +105,10 @@ export const ACP_PROFILES = {
         command: 'pool',
         args: ['acp'],
         resumeMethods: ['session/load'],
+        // Pool 1.0.16 implements ACP's same-session, concurrent prompt semantics:
+        // a second session/prompt while the first is running is folded into that
+        // turn. It is not the `/steer` slash command used by Hermes.
+        steer: 'session/prompt',
         // Poolside exposes permission policy as an ACP config option rather than
         // a session mode. Apply it per anchor so bypass runs cannot inherit its
         // interactive `default` (always ask) selection.
@@ -168,6 +176,27 @@ export function parseLettaSessionIdentity(value) {
     const match = /^letta:(agent-(?:local-)?[0-9a-f-]+):(.+)$/iu.exec(String(value || ''));
     return match ? { agentId: match[1], conversationId: match[2] } : { agentId: '', conversationId: String(value || '') };
 }
+/**
+ * Letta's TUI stores cloud credentials in ~/.letta/settings.json, while its
+ * headless transport requires LETTA_API_KEY in the spawned process. Return a
+ * narrow child-only environment overlay; explicit daemon environment wins.
+ */
+export function lettaHeadlessEnvironment(home = HOME) {
+    if (process.env.LETTA_API_KEY)
+        return {};
+    try {
+        const settings = JSON.parse(fs.readFileSync(path.join(home, '.letta', 'settings.json'), 'utf8'));
+        const apiKey = typeof settings?.env?.LETTA_API_KEY === 'string' ? settings.env.LETTA_API_KEY.trim() : '';
+        const baseUrl = typeof settings?.env?.LETTA_BASE_URL === 'string' ? settings.env.LETTA_BASE_URL.trim() : '';
+        return {
+            ...(apiKey ? { LETTA_API_KEY: apiKey } : {}),
+            ...(!process.env.LETTA_BASE_URL && baseUrl ? { LETTA_BASE_URL: baseUrl } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
 export const RPC_PROFILES = {
     // Prime selects an existing session only at process launch. The transcript
     // path is authoritative (its header id can differ from its filename id), so

package/dist/local-session-sources.js

@@ -3,20 +3,24 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
+import { StringDecoder } from 'node:string_decoder';
 import { readDeepseekTrajectoryHeader } from "./deepseek-trajectories.js";
 import { lettaSessionIdentity } from "./harness-registry.js";
 import { readLettaSessionContext } from "./letta-session-context.js";
 const HOME = os.homedir();
+const CLAUDE_LIVE_SESSIONS_ROOT = path.join(HOME, '.claude', 'sessions');
 const PROJECTION_ROOT = path.join(HOME, '.local', 'state', 'turns-dev', 'session-projections');
 const DEEPSEEK_SESSIONS_ROOT = path.join(path.resolve(process.env.DSH_HOME || path.join(HOME, '.dsh')), 'sessions');
 const JSON_FILE_CACHE = new Map();
 const CURSOR_WORKER_CWD_CACHE = new Map();
 const ANTIGRAVITY_TRANSCRIPT_CWD_CACHE = new Map();
+const GROK_SPAWNED_SUBAGENT_CACHE = new Map();
 const SUBAGENT_MARKER_CACHE = new Map();
 const LINEAGE_CACHE = new Map();
 const STORE_DESCRIPTOR_CACHE = new Map();
 const MAX_METADATA_CACHE_ENTRIES = 16_384;
 const OPAQUE_UUID_SOURCE = '[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}';
+const OPAQUE_UUID = new RegExp(`^${OPAQUE_UUID_SOURCE}$`, 'iu');
 function jsonObject(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }
@@ -63,7 +67,8 @@ const EXTRA_FILE_STORES = {
     },
     qwen: {
         root: path.join(HOME, '.qwen', 'projects'),
-        include: (file) => /[\\/]chats[\\/][^\\/]+\.jsonl$/i.test(file),
+        include: (file) => /[\\/]chats[\\/][^\\/]+\.jsonl$/i.test(file) ||
+            /[\\/]subagents[\\/][^\\/]+[\\/]agent-[^\\/]+\.jsonl$/i.test(file),
     },
     codebuddy: {
         root: path.join(HOME, '.codebuddy', 'projects'),
@@ -187,6 +192,14 @@ const STRUCTURAL_SUBAGENT_STORES = {
             parentSourcePath: `${match[1]}/messages.jsonl`,
         }),
     },
+    qwen: {
+        path: /^(.*)\/subagents\/([^/]+)\/(agent-[^/]+)\.jsonl$/iu,
+        lineage: (match) => ({
+            nativeSessionId: match[3],
+            parentNativeSessionId: match[2],
+            parentSourcePath: `${match[1]}/chats/${match[2]}.jsonl`,
+        }),
+    },
 };
 /** Interpret one harness's structural child path. `uploadable` lets the same
  * rule reject internal sidechains before discovery and lineage can diverge. */
@@ -385,6 +398,95 @@ function parsedObject(value) {
         return null;
     }
 }
+function grokSummaryFile(descriptor) {
+    if (descriptor?.harness !== 'grok' || path.basename(String(descriptor?.file || '')) !== 'chat_history.jsonl') {
+        return '';
+    }
+    return path.join(path.dirname(path.resolve(descriptor.file)), 'summary.json');
+}
+function grokSummary(descriptor) {
+    const file = grokSummaryFile(descriptor);
+    return file ? jsonFile(file) : null;
+}
+/** Grok 1.0.5 stores native subagents beside their parent with the same
+ * transcript shape. The adjacent summary is the child's durable type marker. */
+function grokSummaryMarksSubagent(descriptor) {
+    return (String(grokSummary(descriptor)?.session_kind || '')
+        .trim()
+        .toLowerCase() === 'subagent');
+}
+/** Child ids announced by one Grok transcript's successful spawn results.
+ * Results can occur anywhere in a long session, so scan the complete JSONL and
+ * cache by the append-only transcript's physical identity. */
+export function grokSpawnedSubagentIds(descriptor) {
+    if (descriptor?.harness !== 'grok')
+        return [];
+    const file = String(descriptor?.file || '');
+    const stat = safeStat(file);
+    if (!stat?.isFile())
+        return [];
+    const fingerprint = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+    const cached = GROK_SPAWNED_SUBAGENT_CACHE.get(file);
+    if (cached?.fingerprint === fingerprint) {
+        GROK_SPAWNED_SUBAGENT_CACHE.delete(file);
+        GROK_SPAWNED_SUBAGENT_CACHE.set(file, cached);
+        return cached.ids;
+    }
+    const ids = new Set();
+    const inspect = (line) => {
+        if (!line.includes('Subagent started in background.'))
+            return;
+        try {
+            const record = jsonObject(JSON.parse(line));
+            if (record?.type !== 'tool_result' || typeof record.content !== 'string')
+                return;
+            const id = /^Subagent started in background\.\r?\nsubagent_id:\s*([^\s]+)(?:\r?\n|$)/u.exec(record.content)?.[1];
+            if (id && OPAQUE_UUID.test(id))
+                ids.add(id);
+        }
+        catch { }
+    };
+    let handle;
+    try {
+        handle = fs.openSync(file, 'r');
+        const decoder = new StringDecoder('utf8');
+        const buffer = Buffer.alloc(64 * 1024);
+        let pending = '';
+        let offset = 0;
+        while (offset < stat.size) {
+            const bytesRead = fs.readSync(handle, buffer, 0, buffer.length, offset);
+            if (!bytesRead)
+                break;
+            offset += bytesRead;
+            pending += decoder.write(buffer.subarray(0, bytesRead));
+            let newline = pending.indexOf('\n');
+            while (newline >= 0) {
+                inspect(pending.slice(0, newline).replace(/\r$/u, ''));
+                pending = pending.slice(newline + 1);
+                newline = pending.indexOf('\n');
+            }
+        }
+        pending += decoder.end();
+        if (pending)
+            inspect(pending.replace(/\r$/u, ''));
+    }
+    catch {
+        return [];
+    }
+    finally {
+        try {
+            if (handle !== undefined)
+                fs.closeSync(handle);
+        }
+        catch { }
+    }
+    const value = [...ids];
+    GROK_SPAWNED_SUBAGENT_CACHE.set(file, { fingerprint, ids: value });
+    if (GROK_SPAWNED_SUBAGENT_CACHE.size > MAX_METADATA_CACHE_ENTRIES) {
+        GROK_SPAWNED_SUBAGENT_CACHE.delete(GROK_SPAWNED_SUBAGENT_CACHE.keys().next().value);
+    }
+    return value;
+}
 function recordMarksSubagent(record) {
     const root = parsedObject(record);
     if (!root)
@@ -435,6 +537,8 @@ export function nativeDescriptorIsSubagent(descriptor) {
         return true;
     if (descriptor?.isSubagent === true || descriptor?.threadSource === 'subagent')
         return true;
+    if (grokSummaryMarksSubagent(descriptor))
+        return true;
     const file = String(descriptor?.file || '');
     const stat = safeStat(file);
     const fingerprint = stat?.isFile() ? `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}` : '';
@@ -835,7 +939,8 @@ export function nativeDescriptorLineage(descriptor) {
     const sourcePath = String(descriptor?.sourcePath || descriptor?.file || '').replaceAll('\\', '/');
     const stat = safeStat(String(descriptor?.file || ''));
     const metadataStat = safeStat(claudeSubagentMetadataFile(descriptor));
-    const fingerprint = [stat, metadataStat]
+    const grokSummaryStat = safeStat(grokSummaryFile(descriptor));
+    const fingerprint = [stat, metadataStat, grokSummaryStat]
         .map((candidate) => candidate?.isFile() ? `${candidate.dev}:${candidate.ino}:${candidate.size}:${candidate.mtimeMs}` : '-')
         .join('|');
     const cacheKey = [
@@ -1309,7 +1414,7 @@ function nativeProcessSnapshots(procRoot) {
         }
         catch { }
         if (argv.length || environ)
-            processes.push({ argv, cmdline: argv.join(' '), environ, fdTargets });
+            processes.push({ pid: entry.name, argv, cmdline: argv.join(' '), environ, fdTargets });
     }
     return processes;
 }
@@ -1368,6 +1473,55 @@ function processRunsHarness(process, harness) {
         return true;
     return SCRIPT_RUNTIMES.has(executable) && names.has(executableStem(process.argv?.[1]));
 }
+function nativeProcessStartTime(procRoot, pid) {
+    try {
+        const stat = fs.readFileSync(path.join(procRoot, pid, 'stat'), 'utf8');
+        const commandEnd = stat.lastIndexOf(')');
+        if (commandEnd < 0)
+            return '';
+        // Fields after the command start at proc(5) field 3; starttime is field 22.
+        return stat.slice(commandEnd + 1).trim().split(/\s+/u)[19] || '';
+    }
+    catch {
+        return '';
+    }
+}
+/** Claude records an exact PID -> native-session association here even for a
+ * plain `claude` launch whose command line contains no session ID. Validate the
+ * kernel start time so a stale registration cannot attach to a reused PID. */
+function registeredClaudeSessionIds(processes, procRoot, sessionsRoot) {
+    const externalClaudeByPid = new Map(processes
+        .filter((process) => !process.environ.includes('TURNS_QUEUE_WORKER_ID=') && processRunsHarness(process, 'claude'))
+        .map((process) => [process.pid, process]));
+    if (!externalClaudeByPid.size)
+        return new Set();
+    let entries = [];
+    try {
+        entries = fs.readdirSync(sessionsRoot, { withFileTypes: true });
+    }
+    catch {
+        return new Set();
+    }
+    const sessionIds = new Set();
+    for (const entry of entries) {
+        const pid = /^(\d+)\.json$/u.exec(entry.name)?.[1];
+        if (!pid || !entry.isFile() || !externalClaudeByPid.has(pid))
+            continue;
+        try {
+            const registration = JSON.parse(fs.readFileSync(path.join(sessionsRoot, entry.name), 'utf8'));
+            const sessionId = String(registration?.sessionId || '').trim();
+            const registeredStart = String(registration?.procStart || '').trim();
+            if (String(registration?.pid) === pid &&
+                OPAQUE_UUID.test(sessionId) &&
+                registeredStart &&
+                registeredStart === nativeProcessStartTime(procRoot, pid)) {
+                sessionIds.add(sessionId);
+            }
+        }
+        catch { }
+    }
+    return sessionIds;
+}
 function queueManagedKeysFromProcesses(descriptors, processes) {
     const transcriptFiles = new Set();
     for (const process of processes) {
@@ -1403,7 +1557,7 @@ function queueManagedKeysFromProcesses(descriptors, processes) {
 export function queueManagedNativeDescriptorKeys(descriptors, procRoot = '/proc') {
     return queueManagedKeysFromProcesses(descriptors, nativeProcessSnapshots(procRoot));
 }
-export function externallyManagedNativeDescriptorKeys(descriptors, procRoot = '/proc') {
+export function externallyManagedNativeDescriptorKeys(descriptors, procRoot = '/proc', claudeSessionsRoot = CLAUDE_LIVE_SESSIONS_ROOT) {
     const snapshots = nativeProcessSnapshots(procRoot);
     const queueManaged = queueManagedKeysFromProcesses(descriptors, snapshots);
     const externalProcesses = snapshots.filter((process) => !process.environ.includes('TURNS_QUEUE_WORKER_ID='));
@@ -1424,7 +1578,16 @@ export function externallyManagedNativeDescriptorKeys(descriptors, procRoot = '/
         byHarness.set(descriptor.harness, group);
     }
     const managed = new Set();
+    const registeredClaude = byHarness.has('claude')
+        ? registeredClaudeSessionIds(snapshots, procRoot, claudeSessionsRoot)
+        : new Set();
     for (const [harness, candidates] of byHarness) {
+        if (harness === 'claude' && registeredClaude.size) {
+            for (const candidate of candidates) {
+                if (candidate.session && registeredClaude.has(candidate.session))
+                    managed.add(candidate.key);
+            }
+        }
         for (const process of externalProcesses) {
             if (!processRunsHarness(process, harness))
                 continue;

package/dist/path-resolution.js

@@ -145,7 +145,12 @@ export function resolvePathCandidate(candidate, workingDirectory, { allowedDirec
             continue;
         if (allowedDirectories.length && !insideAllowedDirectory(file, allowedDirectories))
             continue;
-        return { file, bytes: stat.size, contentType: agentImageContentType(file) };
+        return {
+            file,
+            bytes: stat.size,
+            contentType: agentImageContentType(file),
+            modifiedAt: Number.isFinite(stat.mtimeMs) ? new Date(stat.mtimeMs).toISOString() : '',
+        };
     }
     return null;
 }
@@ -167,13 +172,11 @@ function uploadHeaders(options) {
 /**
  * Put bytes in the account's private prefix, under the path they came from.
  *
- * The path is the object's identity rather than a description of it, so a
- * listing the machine composed for a directory is stored the same way a file
- * read off the disk is: whoever fetches it addresses the same path back. It is
- * addressed by machine and path alone — the session that happened to prompt the
- * upload is not part of what was stored, and nothing records it.
+ * The path is the object's identity rather than a description of it. It is
+ * addressed by machine and path alone — the session that happened to prompt
+ * the upload is not part of what was stored.
  */
-export async function uploadFileBytes({ baseUrl, options, machine, absolutePath, contentType, contentEtag, body, fetchImpl = fetch, }) {
+export async function uploadFileBytes({ baseUrl, options, machine, absolutePath, contentType, modifiedAt, body, fetchImpl = fetch, }) {
     const url = new URL(`/api/file/${encodeURIComponent(machine)}/${encodeURIComponent(absolutePath)}`, String(baseUrl));
     const response = await fetchImpl(url, {
         method: 'PUT',
@@ -181,7 +184,7 @@ export async function uploadFileBytes({ baseUrl, options, machine, absolutePath,
             ...uploadHeaders(options),
             'content-type': contentType,
             'content-length': String(body.byteLength),
-            ...(contentEtag ? { 'x-turns-content-etag': contentEtag } : {}),
+            ...(modifiedAt ? { 'x-turns-file-modified-at': modifiedAt } : {}),
         },
         body,
     });
@@ -190,7 +193,7 @@ export async function uploadFileBytes({ baseUrl, options, machine, absolutePath,
     return true;
 }
 /** Stream one on-disk file to R2 without retaining its body in the daemon. */
-export async function uploadFileStream({ baseUrl, options, machine, absolutePath, contentType, bytes, fetchImpl = fetch, }) {
+export async function uploadFileStream({ baseUrl, options, machine, absolutePath, contentType, bytes, modifiedAt, fetchImpl = fetch, }) {
     const url = new URL(`/api/file/${encodeURIComponent(machine)}/${encodeURIComponent(absolutePath)}`, String(baseUrl));
     const body = fs.createReadStream(absolutePath);
     try {
@@ -200,6 +203,7 @@ export async function uploadFileStream({ baseUrl, options, machine, absolutePath
                 ...uploadHeaders(options),
                 'content-type': contentType,
                 'content-length': String(bytes),
+                ...(modifiedAt ? { 'x-turns-file-modified-at': modifiedAt } : {}),
             },
             body,
             // Node requires this opt-in for a streaming request body.
@@ -226,6 +230,7 @@ export async function uploadResolvedFile({ baseUrl, options, machine, resolved,
         machine,
         absolutePath: resolved.file,
         contentType: resolved.contentType,
+        modifiedAt: resolved.modifiedAt,
         body,
         fetchImpl,
     });

package/dist/queue-worker.js

@@ -45,6 +45,70 @@ export async function reserveCreatingNativeSession(request, creating, sessionId,
         return;
     await request({ type: 'session.native.reserve', sessionId, agentSessionId });
 }
+function workingDirectoryFailure(message, directory, error) {
+    const detail = error instanceof Error ? error.message : String(error || 'Unknown filesystem error.');
+    return new Error(`${message}: ${directory}. ${detail}`, { cause: error });
+}
+/** Resolve the directory typed into a new-session draft on the machine that
+ * will run it. The browser cannot expand `~` because the daemon's home may be
+ * different from the viewer's, and a new project directory may not exist yet.
+ *
+ * Check the nearest existing ancestor against the daemon allowlist before
+ * creating anything. The final assertion repeats that check after mkdir so a
+ * symlinked ancestor cannot launch a session outside the allowlist.
+ */
+export function prepareNewSessionWorkingDirectory(requestedDirectory, allowedDirectories = [], homeDirectory = os.homedir()) {
+    const requested = String(requestedDirectory || '').trim();
+    if (!requested)
+        throw new Error('Choose a working directory.');
+    const expanded = requested === '~'
+        ? homeDirectory
+        : requested.startsWith('~/')
+            ? path.join(homeDirectory, requested.slice(2))
+            : requested;
+    if (!path.isAbsolute(expanded)) {
+        throw new Error(`Working directory must be an absolute path or start with ~/: ${requested}`);
+    }
+    const resolved = path.resolve(expanded);
+    let exists = true;
+    try {
+        fs.statSync(resolved);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            exists = false;
+        else
+            throw workingDirectoryFailure('Working directory is inaccessible', resolved, error);
+    }
+    if (!exists) {
+        let ancestor = path.dirname(resolved);
+        while (!fs.existsSync(ancestor)) {
+            const parent = path.dirname(ancestor);
+            if (parent === ancestor)
+                break;
+            ancestor = parent;
+        }
+        if (allowedDirectories.length && !workingDirectoryIsAllowed(ancestor, allowedDirectories)) {
+            throw new Error(`Working directory is outside the daemon allowlist: ${resolved}`);
+        }
+        try {
+            fs.mkdirSync(resolved, { recursive: true });
+        }
+        catch (error) {
+            throw workingDirectoryFailure('Working directory could not be created', resolved, error);
+        }
+    }
+    try {
+        const canonical = assertAllowedWorkingDirectory(resolved, allowedDirectories);
+        fs.accessSync(canonical, fs.constants.X_OK);
+        return canonical;
+    }
+    catch (error) {
+        if (/outside the daemon allowlist/iu.test(String(error?.message || error)))
+            throw error;
+        throw workingDirectoryFailure('Working directory is inaccessible', resolved, error);
+    }
+}
 /** The origin serving the same deployment as a `wss://…/api/socket` endpoint. */
 export function httpBaseUrl(websocketUrl) {
     const url = new URL(websocketUrl);
@@ -244,7 +308,13 @@ export function resultError(result) {
 }
 export function dispatchErrorIsRetryable(error) {
     const message = String(error?.message || error || '');
-    return !(/(?:not supported|does not support|no resumable native session|session key.*unavailable|no local transcript descriptor|working directory is unavailable|outside the daemon allowlist|agent executable not found)/iu.test(message) || /attachment .* (?:size mismatch|download failed \(4\d\d\))/iu.test(message));
+    // OpenCode emits this only after its provider stream has exhausted its own
+    // backoff. Re-queueing the turn starts that entire retry sequence again and
+    // also persists another copy of the user's prompt in the native session.
+    return !(/(?:not supported|does not support|no resumable native session|session key.*unavailable|no local transcript descriptor|working directory (?:is (?:unavailable|not a directory|inaccessible)|must be|could not be created)|outside the daemon allowlist|agent executable not found|provider finish_reason:\s*network_error)/iu.test(message) || /attachment .* (?:size mismatch|download failed \(4\d\d\))/iu.test(message));
+}
+export function queueFailureIsRetryable(error, promptStarted) {
+    return !promptStarted && dispatchErrorIsRetryable(error);
 }
 export async function actualHarnessStatus(entry) {
     if (!entry || entry.connection.closed)
@@ -505,7 +575,10 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                     promptId: claim.prompt.id,
                     claimToken: claim.claimToken,
                     error: redactor.redactText(error.message),
-                    retryable: dispatchErrorIsRetryable(error),
+                    // The anchor accepted and finished this prompt. Replaying it can
+                    // duplicate side effects and turns persistent harness failures (for
+                    // example, expired authentication) into an unbounded retry loop.
+                    retryable: queueFailureIsRetryable(error, true),
                 });
             }
             else {
@@ -572,11 +645,11 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             const workingDirectory = pendingNativeSession
                 ? String(claim.session?.workingDirectory || '')
                 : await nativeDescriptorWorkingDirectory(descriptor);
-            const fallbackDirectory = path.dirname(descriptor.file);
-            const selectedDirectory = workingDirectory && path.isAbsolute(workingDirectory) && fs.existsSync(workingDirectory)
-                ? workingDirectory
-                : fallbackDirectory;
-            cwd = assertAllowedWorkingDirectory(selectedDirectory, options.allowedDirectories);
+            cwd = pendingNativeSession
+                ? prepareNewSessionWorkingDirectory(workingDirectory, options.allowedDirectories)
+                : assertAllowedWorkingDirectory(workingDirectory && path.isAbsolute(workingDirectory) && fs.existsSync(workingDirectory)
+                    ? workingDirectory
+                    : path.dirname(descriptor.file), options.allowedDirectories);
             if (!fs.statSync(cwd).isDirectory())
                 throw new Error(`Working directory is unavailable: ${cwd}`);
             entry = await usableAnchor(sessionId, descriptor.harness, agentSessionId);
@@ -587,6 +660,10 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             ...claim,
             entry,
             renewTimer: null,
+            // Recovery only observes turns that an anchor already accepted. Treat
+            // an uncertain recovery failure conservatively for the same reason as a
+            // failed live turn: the prompt may already have produced side effects.
+            promptStarted: Boolean(recovery),
         };
         claims.set(sessionId, queued);
         const renewClaim = () => request({
@@ -645,6 +722,10 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             // boundary before starting this attempt so an earlier turn_error with
             // that ID cannot immediately settle the new turn.
             const eventCursor = entry.connection.eventCursor();
+            // A local request can lose its response after the anchor has accepted
+            // the prompt, so crossing this boundary permanently disables automatic
+            // replay even when the exact delivery outcome is unknown.
+            queued.promptStarted = true;
             await entry.connection.request('send_message', {
                 source: descriptor.harness,
                 sessionId,
@@ -712,7 +793,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                     promptId: claim.prompt.id,
                     claimToken: claim.claimToken,
                     error: redactor.redactText(error?.message || String(error)),
-                    retryable: dispatchErrorIsRetryable(error),
+                    retryable: queueFailureIsRetryable(error, Boolean(held?.promptStarted)),
                 }).catch(() => { });
             }
             claims.delete(sessionId);
@@ -956,8 +1037,8 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
      *
      * Unlike the rest of these handlers this touches no harness: browsing is a
      * property of the machine, so it answers for a stopped session as readily as
-     * for a running one. Directory bytes answer directly; their offline copy is
-     * stored behind that reply.
+     * for a running one. Directory bytes answer directly and the server indexes
+     * them in its Durable Object; only regular file bodies are uploaded to R2.
      */
     const handleFileBrowse = async (message, replyRpc) => {
         const sessionId = String(message.sessionId || '');
@@ -969,18 +1050,12 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
                 options,
                 workingDirectory: await browseWorkingDirectory(sessionId),
             });
-            const { cache, ...stored } = browsed.kind === 'directory' ? browsed : { ...browsed, cache: undefined };
             replyRpc.notify({
                 type: 'session.file.browse.result',
                 requestId: message.requestId,
                 sessionId,
                 ok: true,
-                ...stored,
-            });
-            // The direct listing is already useful. Its R2 copy is only the fallback
-            // for a later offline browse, so storage latency must not hold this reply.
-            void cache?.catch((error) => {
-                console.warn(`Directory browse fallback upload failed: ${redactor.redactText(error?.message || String(error))}`);
+                ...browsed,
             });
         }
         catch (error) {

package/dist/upload-sessions.js

@@ -6,12 +6,12 @@ import path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 import WebSocket from 'ws';
-import { createPathResolver, pathCandidates } from "./path-resolution.js";
 import { streamDeepseekTrajectoryLines } from "./deepseek-trajectories.js";
 import { normalizeAllowedDirectories, workingDirectoryIsAllowed } from "./directory-policy.js";
 import { discoverGitAssociation } from "./git-association.js";
-import { discoverLocalSessions, externallyManagedNativeDescriptorKeys, nativeDescriptorAgentSessionId, nativeDescriptorLineage, nativeDescriptorWorkingDirectory, nativeSessionShallowWatchRoots, nativeSessionWatchRoots, } from "./local-session-sources.js";
+import { discoverLocalSessions, externallyManagedNativeDescriptorKeys, grokSpawnedSubagentIds, nativeDescriptorAgentSessionId, nativeDescriptorLineage, nativeDescriptorWorkingDirectory, nativeSessionShallowWatchRoots, nativeSessionWatchRoots, } from "./local-session-sources.js";
 import { compactNativeRaw } from "./native-record-compaction.js";
+import { createPathResolver, pathCandidates } from "./path-resolution.js";
 import { httpBaseUrl, watchQueuedPrompts } from "./queue-worker.js";
 import { createSecretRedactor, REDACTION_VERSION } from "./secret-redaction.js";
 const HERE = path.dirname(fileURLToPath(import.meta.url));
@@ -292,6 +292,14 @@ export function linkNativeSessionParents(machine, descriptors) {
         descriptor,
         lineage: nativeDescriptorLineage(descriptor),
     }));
+    const storeNamespace = (descriptor) => {
+        const sourcePath = String(descriptor?.sourcePath || '').replaceAll('\\', '/');
+        if (descriptor?.harness === 'gemini')
+            return /^(.*?\/chats)(?:\/|$)/iu.exec(sourcePath)?.[1] || '';
+        if (descriptor?.harness === 'grok')
+            return /^(.*?\/sessions\/[^/]+)(?:\/|$)/iu.exec(sourcePath)?.[1] || '';
+        return '';
+    };
     const byNativeId = new Map();
     for (const record of records) {
         if (!record.lineage.nativeSessionId)
@@ -301,12 +309,18 @@ export function linkNativeSessionParents(machine, descriptors) {
         candidates.push(record.descriptor);
         byNativeId.set(key, candidates);
     }
-    const storeNamespace = (descriptor) => {
-        const sourcePath = String(descriptor?.sourcePath || '').replaceAll('\\', '/');
-        if (descriptor?.harness === 'gemini')
-            return /^(.*?\/chats)(?:\/|$)/iu.exec(sourcePath)?.[1] || '';
-        return '';
-    };
+    const grokParentsByChildId = new Map();
+    for (const record of records) {
+        if (record.descriptor.harness !== 'grok')
+            continue;
+        for (const childId of grokSpawnedSubagentIds(record.descriptor)) {
+            if (childId === record.lineage.nativeSessionId)
+                continue;
+            const candidates = grokParentsByChildId.get(childId) || [];
+            candidates.push(record.descriptor);
+            grokParentsByChildId.set(childId, candidates);
+        }
+    }
     return records.flatMap(({ descriptor, lineage }) => {
         // Internal harness sidechains such as Claude's compaction worker are still
         // children for identity/resume safety, but never become uploaded sessions.
@@ -329,19 +343,26 @@ export function linkNativeSessionParents(machine, descriptors) {
                 ? [...localCandidates].sort((left, right) => Number(right.mtimeMs || 0) - Number(left.mtimeMs || 0) ||
                     String(right.sourcePath).localeCompare(String(left.sourcePath)))[0]
                 : null;
+        const grokParentCandidates = descriptor.harness === 'grok' ? grokParentsByChildId.get(lineage.nativeSessionId) || [] : [];
+        const grokNamespace = storeNamespace(descriptor);
+        const localGrokParents = grokNamespace
+            ? grokParentCandidates.filter((candidate) => storeNamespace(candidate) === grokNamespace)
+            : grokParentCandidates;
+        const grokParent = localGrokParents.length === 1 ? localGrokParents[0] : null;
         // An exact structural parent path is stronger than a harness-wide native
         // ID match. This matters for Claude descendants, whose short runtime agent
         // IDs can recur in another project while the adjacent sidecar names the
         // correct transcript in this session's flat subagents directory.
-        const parentSourcePath = lineage.parentSourcePath || parent?.sourcePath;
+        const parentSourcePath = lineage.parentSourcePath || grokParent?.sourcePath || parent?.sourcePath;
+        const isSubagent = lineage.isSubagent || Boolean(grokParent);
         // An unresolved child cannot satisfy the sidebar contract. Leave it out of
         // native upload until its store exposes enough lineage to nest it safely.
-        if (lineage.isSubagent && !parentSourcePath)
+        if (isSubagent && !parentSourcePath)
             return [];
         return [
             {
                 ...descriptor,
-                isSubagent: lineage.isSubagent,
+                isSubagent,
                 ...(lineage.nativeTitle ? { nativeTitle: lineage.nativeTitle } : {}),
                 ...(lineage.nativeSubagentType ? { nativeSubagentType: lineage.nativeSubagentType } : {}),
                 ...(lineage.nativeSubagentDepth ? { nativeSubagentDepth: lineage.nativeSubagentDepth } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turns/dev",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",