@turns/dev 0.0.5 → 0.0.7

package/dist/agent-anchor.js

@@ -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);
     }
 }

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. */
@@ -177,11 +173,7 @@ 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, }) {
+export async function browseMachinePath({ requested, machine, baseUrl, options, workingDirectory = '', contentEtag = '', fetchImpl = fetch, }) {
     const resolved = resolveBrowsePath(requested, {
         workingDirectory,
         allowedDirectories: options.allowedDirectories || [],
@@ -192,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',
@@ -209,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) {
@@ -217,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,
@@ -226,7 +208,9 @@ export async function browseMachinePath({ requested, machine, baseUrl, options,
         absolutePath: resolved.path,
         contentType,
         bytes: resolved.stat.size,
+        modifiedAt,
+        ...(contentEtag ? { contentEtag } : {}),
         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/file-edits.js

@@ -0,0 +1,82 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { workingDirectoryIsAllowed } from "./directory-policy.js";
+/**
+ * Applying a browser edit to a file this machine holds.
+ *
+ * The server's queue row says what the edit expects (`beforeHash`) and what it
+ * produces (`afterHash`); the bytes themselves are downloaded from the
+ * account's bucket only once the file on disk has been shown to still match
+ * what the editor started from. The replacement is written beside the target
+ * and renamed over it, so a crash mid-write leaves the original untouched, and
+ * the downloaded bytes are verified against `afterHash` before the rename —
+ * corrupt or truncated downloads never reach the file.
+ *
+ * A redelivered edit is settled by content: a file that already hashes to
+ * `afterHash` reports success without touching the disk, which is what lets
+ * the server re-offer an edit whose earlier answer was lost.
+ */
+/** SHA-256 of one file's bytes, streamed so large files cost no memory. */
+export async function hashFileSha256(file) {
+    const hash = crypto.createHash('sha256');
+    await pipeline(fs.createReadStream(file), hash);
+    return hash.digest('hex');
+}
+export async function applyFileEdit({ edit, baseUrl, options, fetchImpl = fetch, }) {
+    const requested = String(edit.path || '').trim();
+    if (!requested || !path.isAbsolute(requested)) {
+        throw new Error(`File edits need an absolute path: ${requested || '(empty)'}`);
+    }
+    let canonical;
+    let stat;
+    try {
+        canonical = fs.realpathSync(requested);
+        stat = fs.statSync(canonical);
+    }
+    catch {
+        throw new Error(`No such file: ${requested}`);
+    }
+    if (!stat.isFile())
+        throw new Error(`Not an editable file: ${canonical}`);
+    // The same allowlist that bounds browsing bounds writing: a file is editable
+    // exactly when the directory holding it could be browsed.
+    if (!workingDirectoryIsAllowed(path.dirname(canonical), options.allowedDirectories || [])) {
+        throw new Error(`Path is outside the daemon allowlist: ${canonical}`);
+    }
+    const current = await hashFileSha256(canonical);
+    if (current === edit.afterHash)
+        return { path: canonical, alreadyApplied: true };
+    if (current !== edit.beforeHash) {
+        throw new Error('The file changed on this machine after the edit was made, so it was not applied.');
+    }
+    const url = new URL(`/api/file-edits/${encodeURIComponent(String(edit.id || ''))}`, String(baseUrl));
+    const response = await fetchImpl(url, {
+        headers: { authorization: `Bearer ${options.token}` },
+    });
+    if (!response.ok || !response.body) {
+        throw new Error(`The edited file could not be downloaded (${response.status}).`);
+    }
+    const temporary = path.join(path.dirname(canonical), `.${path.basename(canonical)}.turns-edit-${process.pid}.tmp`);
+    try {
+        await pipeline(Readable.fromWeb(response.body), fs.createWriteStream(temporary, { mode: 0o600 }));
+        const written = fs.statSync(temporary);
+        if (Number(edit.bytes) !== written.size) {
+            throw new Error('The downloaded edit did not match its recorded size.');
+        }
+        if ((await hashFileSha256(temporary)) !== edit.afterHash) {
+            throw new Error('The downloaded edit did not match its recorded content hash.');
+        }
+        // The temporary file was created 0600 regardless of umask; give the
+        // replacement the permissions the original had before it takes its name.
+        fs.chmodSync(temporary, stat.mode & 0o7777);
+        fs.renameSync(temporary, canonical);
+    }
+    catch (error) {
+        fs.rmSync(temporary, { force: true });
+        throw error;
+    }
+    return { path: canonical, alreadyApplied: false };
+}

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.

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, contentEtag, fetchImpl = fetch, }) {
     const url = new URL(`/api/file/${encodeURIComponent(machine)}/${encodeURIComponent(absolutePath)}`, String(baseUrl));
     const body = fs.createReadStream(absolutePath);
     try {
@@ -200,6 +203,8 @@ export async function uploadFileStream({ baseUrl, options, machine, absolutePath
                 ...uploadHeaders(options),
                 'content-type': contentType,
                 'content-length': String(bytes),
+                ...(modifiedAt ? { 'x-turns-file-modified-at': modifiedAt } : {}),
+                ...(contentEtag ? { 'x-turns-content-etag': contentEtag } : {}),
             },
             body,
             // Node requires this opt-in for a streaming request body.
@@ -226,6 +231,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

@@ -7,6 +7,7 @@ import { pipeline } from 'node:stream/promises';
 import { anchorId, connectExistingAgentAnchors, launchAgentAnchor, waitForAgentTurn } from "./agent-anchor-client.js";
 import { assertAllowedWorkingDirectory, workingDirectoryIsAllowed } from "./directory-policy.js";
 import { browseMachinePath } from "./file-browsing.js";
+import { applyFileEdit } from "./file-edits.js";
 import { nativeDescriptorAgentSessionId, nativeDescriptorWorkingDirectory } from "./local-session-sources.js";
 import { compactRuntimeValue } from "./native-record-compaction.js";
 import { createSecretRedactor } from "./secret-redaction.js";
@@ -1037,8 +1038,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 || '');
@@ -1050,18 +1051,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) {
@@ -1074,6 +1069,55 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             });
         }
     };
+    /**
+     * Apply one queued browser edit, and report how it went.
+     *
+     * Edits are serialized through one chain: the server sends every pending
+     * edit for this machine in queue order, and applying them strictly in
+     * arrival order is what lets several edits to one file chain — each one's
+     * before-hash is the previous one's after-hash. After a real application the
+     * file is re-browsed so the stored copy readers open reflects the new bytes.
+     */
+    let fileEditChain = Promise.resolve();
+    const handleFileEdit = (message, replyRpc) => {
+        fileEditChain = fileEditChain.then(async () => {
+            const sessionId = String(message.sessionId || '');
+            const edit = message.edit || {};
+            try {
+                const applied = await applyFileEdit({ edit, baseUrl, options });
+                if (!applied.alreadyApplied) {
+                    await browseMachinePath({
+                        requested: applied.path,
+                        machine,
+                        baseUrl,
+                        options,
+                        // The applied bytes were verified against this hash, so store it
+                        // as their identity: a pane already showing them recognizes the
+                        // refresh instead of being offered its own save as a new version.
+                        contentEtag: String(edit.afterHash || ''),
+                    }).catch((error) => process.stderr.write(`Post-edit refresh failed for ${applied.path}: ${error?.message || error}\n`));
+                }
+                replyRpc.notify({
+                    type: 'session.file.edit.result',
+                    requestId: message.requestId,
+                    sessionId,
+                    editId: String(edit.id || ''),
+                    ok: true,
+                });
+            }
+            catch (error) {
+                replyRpc.notify({
+                    type: 'session.file.edit.result',
+                    requestId: message.requestId,
+                    sessionId,
+                    editId: String(edit.id || ''),
+                    ok: false,
+                    error: redactor.redactText(error?.message || String(error)),
+                });
+            }
+        });
+        return fileEditChain;
+    };
     const heartbeat = setInterval(() => {
         for (const [sessionId, entry] of anchors) {
             if (entry.connection.closed)
@@ -1095,6 +1139,8 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             void handleInteractionAnswer(message, rpc);
         if (message.type === 'session.file.browse.request')
             void handleFileBrowse(message, rpc);
+        if (message.type === 'session.file.edit.request')
+            void handleFileEdit(message, rpc);
     });
     const registered = new WeakSet();
     const registering = new WeakSet();
@@ -1106,6 +1152,7 @@ export async function watchQueuedPrompts({ rpc, options, machine, getDescriptors
             const ready = await control.request({
                 type: 'machine.register',
                 machineId: machine,
+                machineHostname: os.hostname(),
                 workerId,
                 workerInstanceId,
                 anchorSessionIds: [...anchors.keys()],

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.5",
+  "version": "0.0.7",
   "description": "Upload local AI agent sessions to turns.dev",
   "license": "MIT",
   "type": "module",