@turns/dev 0.0.1

package/dist/local-session-sources.js

@@ -0,0 +1,1448 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { readDeepseekTrajectoryHeader } from "./deepseek-trajectories.js";
+const HOME = os.homedir();
+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 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}';
+function jsonObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function nativeFileStoreIncludes(harness, file) {
+    return nativeSubagentPathLineage(harness, file)?.uploadable !== false;
+}
+const EXTRA_FILE_STORES = {
+    claude: {
+        root: path.join(HOME, '.claude', 'projects'),
+        include: (file) => file.endsWith('.jsonl') && nativeFileStoreIncludes('claude', file),
+    },
+    cursor: {
+        root: path.join(HOME, '.cursor', 'projects'),
+        include: (file) => /[\\/]agent-transcripts[\\/]([^\\/]+)[\\/]\1\.jsonl$/i.test(file),
+    },
+    codex: {
+        root: path.join(process.env.CODEX_HOME || path.join(HOME, '.codex'), 'sessions'),
+        include: (file) => /[\\/]rollout-[^\\/]+\.jsonl$/i.test(file),
+    },
+    grok: { root: path.join(HOME, '.grok', 'sessions'), include: (file) => path.basename(file) === 'chat_history.jsonl' },
+    kimi: {
+        root: path.join(HOME, '.kimi-code', 'sessions'),
+        include: (file) => /[\\/]agents[\\/][^\\/]+[\\/]wire\.jsonl$/i.test(file),
+    },
+    pi: {
+        root: path.join(HOME, '.pi', 'agent', 'sessions'),
+        include: (file) => file.endsWith('.jsonl') && !/[\\/]agents[\\/]/i.test(file),
+    },
+    gemini: {
+        root: path.join(HOME, '.gemini', 'tmp'),
+        include: (file) => /[\\/]chats[\\/](?:session-[^\\/]+\.jsonl|[^\\/]+\.json|[^\\/]+[\\/][^\\/]+\.jsonl)$/i.test(file),
+    },
+    antigravity: {
+        root: path.join(HOME, '.gemini', 'antigravity-cli', 'brain'),
+        include: (file) => path.basename(file) === 'transcript_full.jsonl',
+    },
+    copilot: {
+        root: path.join(process.env.COPILOT_HOME || path.join(HOME, '.copilot'), 'session-state'),
+        include: (file) => path.basename(file) === 'events.jsonl',
+    },
+    muse: {
+        root: path.join(HOME, '.local', 'share', 'muse', 'sessions'),
+        include: (file) => path.basename(file) === 'session.jsonl',
+    },
+    qwen: {
+        root: path.join(HOME, '.qwen', 'projects'),
+        include: (file) => /[\\/]chats[\\/][^\\/]+\.jsonl$/i.test(file),
+    },
+    codebuddy: {
+        root: path.join(HOME, '.codebuddy', 'projects'),
+        include: (file) => file.endsWith('.jsonl') && nativeFileStoreIncludes('codebuddy', file),
+    },
+    prime: {
+        root: path.join(HOME, '.prime', 'agent', 'sessions'),
+        include: (file) => path.dirname(file) === path.join(HOME, '.prime', 'agent', 'sessions') && file.endsWith('.jsonl'),
+    },
+    omp: {
+        root: path.join(HOME, '.omp', 'agent', 'sessions'),
+        include: (file) => /^\d{4}-\d{2}-\d{2}T.+_[0-9a-f-]{36}\.jsonl$/i.test(path.basename(file)),
+    },
+    cline: {
+        root: path.join(HOME, '.cline', 'data', 'sessions'),
+        include: (file) => file.endsWith('.messages.json'),
+    },
+    vibe: {
+        root: path.join(HOME, '.vibe', 'logs', 'session'),
+        include: (file) => path.basename(file) === 'messages.jsonl',
+    },
+    poolside: {
+        root: path.join(HOME, '.local', 'state', 'poolside', 'trajectories'),
+        include: (file) => /^trajectory-[^/]+\.ndjson$/i.test(path.basename(file)),
+    },
+};
+function safeStat(file) {
+    try {
+        return fs.statSync(file);
+    }
+    catch {
+        return null;
+    }
+}
+function walk(directory, visit) {
+    let entries;
+    try {
+        entries = fs.readdirSync(directory, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            walk(full, visit);
+        else if (entry.isFile())
+            visit(full);
+    }
+}
+function displayPath(file) {
+    const relative = path.relative(HOME, file);
+    return relative && !relative.startsWith('..') ? `~/${relative.replaceAll(path.sep, '/')}` : file;
+}
+const STRUCTURAL_SUBAGENT_STORES = {
+    claude: {
+        path: new RegExp(`^(.*)/(${OPAQUE_UUID_SOURCE})/subagents/agent-([^/]+)\\.jsonl$`, 'iu'),
+        excludedNativeSessionIds: [/^acompact(?:[-.]|$)/iu, /^aprompt[_-]?suggestion(?:[-.]|$)/iu],
+        lineage: (match) => ({
+            nativeSessionId: match[3],
+            parentNativeSessionId: match[2],
+            parentSourcePath: `${match[1]}/${match[2]}.jsonl`,
+        }),
+    },
+    codebuddy: {
+        path: new RegExp(`^(.*)/(${OPAQUE_UUID_SOURCE})/subagents/agent-([^/]+)\\.jsonl$`, 'iu'),
+        excludedNativeSessionIds: [/^acompact(?:[-.]|$)/iu, /^aprompt[_-]?suggestion(?:[-.]|$)/iu],
+        lineage: (match) => ({
+            nativeSessionId: match[3],
+            parentNativeSessionId: match[2],
+            parentSourcePath: `${match[1]}/${match[2]}.jsonl`,
+        }),
+    },
+    muse: {
+        path: new RegExp(`^(.*?/(${OPAQUE_UUID_SOURCE}))/subagent/(${OPAQUE_UUID_SOURCE})/session\\.jsonl$`, 'iu'),
+        // Muse 1.x uses this namespace for one-run reminder observers, not
+        // user-delegated conversations. Cancelled observers may never persist the
+        // reminder-decision event, so the structural namespace is authoritative.
+        uploadable: false,
+        lineage: (match) => ({
+            nativeSessionId: match[3],
+            parentNativeSessionId: match[2],
+            parentSourcePath: `${match[1]}/session.jsonl`,
+        }),
+    },
+    kimi: {
+        path: new RegExp(`^(.*?/session_(${OPAQUE_UUID_SOURCE}))/agents/(?!main/)([^/]+)/wire\\.jsonl$`, 'iu'),
+        lineage: (match) => ({
+            nativeSessionId: `${match[2]}/${match[3]}`,
+            parentNativeSessionId: match[2],
+            parentSourcePath: `${match[1]}/agents/main/wire.jsonl`,
+        }),
+    },
+    gemini: {
+        path: /^(.*?\/chats)\/([^/]+)\/([^/]+)\.jsonl$/iu,
+        lineage: (match) => ({
+            nativeSessionId: match[3],
+            parentNativeSessionId: match[2],
+        }),
+    },
+    cline: {
+        path: /^(.*?\/([^/]+))\/agent_([^/]+)\.messages\.json$/iu,
+        lineage: (match) => ({
+            nativeSessionId: `agent_${match[3]}`,
+            parentNativeSessionId: match[2],
+            parentSourcePath: `${match[1]}/${match[2]}.messages.json`,
+        }),
+    },
+    vibe: {
+        path: /^(.*?\/(session_[^/]+))\/agents\/([^/]+)\/messages\.jsonl$/iu,
+        lineage: (match) => ({
+            nativeSessionId: `${match[2]}/${match[3]}`,
+            parentSourcePath: `${match[1]}/messages.jsonl`,
+        }),
+    },
+};
+/** Interpret one harness's structural child path. `uploadable` lets the same
+ * rule reject internal sidechains before discovery and lineage can diverge. */
+export function nativeSubagentPathLineage(harness, sourcePath) {
+    const normalized = String(sourcePath || '').replaceAll('\\', '/');
+    const rule = STRUCTURAL_SUBAGENT_STORES[harness];
+    const match = rule?.path.exec(normalized);
+    if (!match)
+        return null;
+    const lineage = rule.lineage(match);
+    const uploadable = rule.uploadable !== false &&
+        !rule.excludedNativeSessionIds?.some((pattern) => pattern.test(lineage.nativeSessionId));
+    return { ...lineage, uploadable };
+}
+function claudeSubagentMetadataFile(descriptor) {
+    if (descriptor?.harness !== 'claude' && descriptor?.harness !== 'codebuddy')
+        return '';
+    const file = path.resolve(String(descriptor?.file || ''));
+    const name = path.basename(file);
+    if (!/^agent-.+\.jsonl$/iu.test(name))
+        return '';
+    return path.join(path.dirname(file), name.replace(/\.jsonl$/iu, '.meta.json'));
+}
+/** Claude keeps every descendant transcript in one flat directory. Its
+ * adjacent sidecar is the only durable source that distinguishes a direct
+ * child from a grandchild and also carries the human-readable dispatch label. */
+function claudeSubagentMetadata(descriptor, structural) {
+    if (!structural || (descriptor?.harness !== 'claude' && descriptor?.harness !== 'codebuddy'))
+        return null;
+    const metadataFile = claudeSubagentMetadataFile(descriptor);
+    if (!metadataFile)
+        return null;
+    const metadata = jsonFile(metadataFile);
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return null;
+    const heldParentAgentId = typeof metadata.parentAgentId === 'string' ? metadata.parentAgentId.trim() : '';
+    const parentAgentId = heldParentAgentId && heldParentAgentId !== structural.nativeSessionId && /^[^/\\\0]+$/u.test(heldParentAgentId)
+        ? heldParentAgentId
+        : '';
+    const description = typeof metadata.description === 'string' ? metadata.description.trim() : '';
+    const agentType = typeof metadata.agentType === 'string' ? metadata.agentType.trim() : '';
+    const spawnDepth = Number(metadata.spawnDepth);
+    const sourcePath = String(descriptor?.sourcePath || descriptor?.file || '').replaceAll('\\', '/');
+    const parentSourcePath = parentAgentId
+        ? sourcePath.replace(/agent-[^/]+\.jsonl$/iu, () => `agent-${parentAgentId}.jsonl`)
+        : '';
+    return {
+        ...(parentAgentId ? { parentAgentId, parentSourcePath } : {}),
+        ...(description ? { description } : {}),
+        ...(agentType ? { agentType } : {}),
+        ...(Number.isFinite(spawnDepth) && spawnDepth >= 1 ? { spawnDepth } : {}),
+    };
+}
+function nativeSessionIdFromPath(harness, sourcePath) {
+    const normalized = String(sourcePath || '').replaceAll('\\', '/');
+    const child = nativeSubagentPathLineage(harness, normalized);
+    if (child?.uploadable !== false && child?.nativeSessionId)
+        return child.nativeSessionId;
+    const patterns = {
+        claude: new RegExp(`/projects/[^/]+/(${OPAQUE_UUID_SOURCE})\\.jsonl$`, 'iu'),
+        codebuddy: new RegExp(`/projects/[^/]+/(${OPAQUE_UUID_SOURCE})\\.jsonl$`, 'iu'),
+        codex: new RegExp(`/rollout-[^/]*-(${OPAQUE_UUID_SOURCE})\\.jsonl$`, 'iu'),
+        antigravity: new RegExp(`/brain/(${OPAQUE_UUID_SOURCE})(?:/|$)`, 'iu'),
+        kimi: new RegExp(`/session_(${OPAQUE_UUID_SOURCE})(?:/|$)`, 'iu'),
+        grok: new RegExp(`/sessions/[^/]+/(${OPAQUE_UUID_SOURCE})(?:/|$)`, 'iu'),
+        copilot: new RegExp(`/session-state/(${OPAQUE_UUID_SOURCE})(?:/|$)`, 'iu'),
+        cursor: new RegExp(`/agent-transcripts/(${OPAQUE_UUID_SOURCE})(?:/|$)`, 'iu'),
+        muse: new RegExp(`/sessions/\\d{4}/\\d{2}/\\d{2}/(${OPAQUE_UUID_SOURCE})/session\\.jsonl$`, 'iu'),
+        qwen: /\/chats\/([^/]+)\.jsonl$/iu,
+        cline: /\/([^/]+)\.messages\.json$/iu,
+        poolside: /trajectory-(?:standalone_)?([0-9a-f-]{20,})\.ndjson$/iu,
+    };
+    return patterns[harness]?.exec(normalized)?.[1] || '';
+}
+function descriptorNativeSessionId(descriptor) {
+    return (String(descriptor?.nativeSessionId || '').trim() ||
+        nativeSessionIdFromPath(String(descriptor?.harness || ''), descriptor?.sourcePath || descriptor?.file));
+}
+function fileDescriptor(harness, file) {
+    const stat = safeStat(file);
+    if (!stat?.isFile() || stat.size === 0)
+        return null;
+    return {
+        harness,
+        agent: harness,
+        file,
+        sourcePath: displayPath(file),
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        createdAt: (stat.birthtimeMs > 0 ? stat.birthtime : stat.mtime).toISOString(),
+    };
+}
+/** Discover top-level and subagent DeepSeek trajectories with header metadata. */
+export function deepseekTrajectoryDescriptors(root = DEEPSEEK_SESSIONS_ROOT) {
+    const descriptors = [];
+    walk(root, (file) => {
+        if (!/^session\.jsonl(?:\.zstd)?$/u.test(path.basename(file)))
+            return;
+        const descriptor = fileDescriptor('deepseek', file);
+        if (!descriptor)
+            return;
+        let header;
+        try {
+            header = readDeepseekTrajectoryHeader(file);
+        }
+        catch {
+            return;
+        }
+        const createdAtMs = Number(header.createdAt);
+        const nativeSessionId = String(header.id || '').trim();
+        const shortId = nativeSessionId.replace(/^session-/u, '').slice(0, 8);
+        descriptors.push({
+            ...descriptor,
+            nativeSessionId,
+            ...(String(header.cwd || '').trim() ? { workingDirectory: String(header.cwd).trim() } : {}),
+            ...(Number.isFinite(createdAtMs) && createdAtMs > 0 ? { createdAt: new Date(createdAtMs).toISOString() } : {}),
+            nativeTitle: `DeepSeek ${shortId || 'session'}`,
+            isSubagent: header.origin === 'subagent' || Number(header.delegationDepth) > 0,
+            ...(String(header.parentSession || '').trim()
+                ? { parentNativeSessionId: String(header.parentSession).trim() }
+                : {}),
+        });
+    });
+    return descriptors;
+}
+function firstJsonDocument(file) {
+    const stat = safeStat(file);
+    if (!stat?.isFile())
+        return null;
+    let descriptor;
+    try {
+        descriptor = fs.openSync(file, 'r');
+        const buffer = Buffer.alloc(Math.min(Math.max(1, stat.size), 1024 * 1024));
+        const bytes = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+        const source = buffer
+            .subarray(0, bytes)
+            .toString('utf8')
+            .replace(/^\uFEFF/u, '');
+        const firstLine = source.split(/\r?\n/u, 1)[0];
+        try {
+            return JSON.parse(firstLine);
+        }
+        catch {
+            if (stat.size <= buffer.length) {
+                const parsed = JSON.parse(source);
+                return Array.isArray(parsed) ? parsed[0] : parsed;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            if (descriptor !== undefined)
+                fs.closeSync(descriptor);
+        }
+        catch { }
+    }
+    return null;
+}
+function parsedObject(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value))
+        return value;
+    if (typeof value !== 'string' || !value.startsWith('{'))
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function recordMarksSubagent(record) {
+    const root = parsedObject(record);
+    if (!root)
+        return false;
+    const candidates = [
+        root,
+        parsedObject(root.payload),
+        parsedObject(root.session),
+        parsedObject(root.header),
+        parsedObject(root.metadata),
+        parsedObject(root.payload)?.session,
+    ]
+        .map(parsedObject)
+        .filter(Boolean);
+    for (const candidate of candidates) {
+        const kindValues = [
+            candidate.thread_source,
+            candidate.threadSource,
+            candidate.session_type,
+            candidate.sessionType,
+            candidate.agent_type,
+            candidate.agentType,
+        ];
+        if (kindValues.some((value) => /^(?:subagent|sub-agent|child-agent|delegate)$/iu.test(String(value || '')))) {
+            return true;
+        }
+        if (candidate.is_subagent === true ||
+            candidate.isSubagent === true ||
+            candidate.is_sidechain === true ||
+            candidate.isSidechain === true)
+            return true;
+        const source = parsedObject(candidate.source);
+        if (source?.subagent || source?.sub_agent || source?.delegate)
+            return true;
+        if (/^(?:subagent|sub-agent|delegate)$/iu.test(String(candidate.source || '')))
+            return true;
+        const modelConfig = parsedObject(candidate.model_config || candidate.modelConfig);
+        if (modelConfig?._delegate_from)
+            return true;
+    }
+    return false;
+}
+/** True only when a native descriptor carries an explicit child-agent marker. */
+export function nativeDescriptorIsSubagent(descriptor) {
+    const sourcePath = String(descriptor?.sourcePath || descriptor?.file || '').replaceAll('\\', '/');
+    const structural = nativeSubagentPathLineage(descriptor?.harness, sourcePath);
+    if (structural)
+        return true;
+    if (descriptor?.isSubagent === true || descriptor?.threadSource === 'subagent')
+        return true;
+    const file = String(descriptor?.file || '');
+    const stat = safeStat(file);
+    const fingerprint = stat?.isFile() ? `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}` : '';
+    const cached = SUBAGENT_MARKER_CACHE.get(file);
+    if (cached?.fingerprint === fingerprint) {
+        // Refresh insertion order so the bounded map behaves as a tiny LRU.
+        SUBAGENT_MARKER_CACHE.delete(file);
+        SUBAGENT_MARKER_CACHE.set(file, cached);
+        return cached.value;
+    }
+    const value = recordMarksSubagent(firstJsonDocument(file));
+    SUBAGENT_MARKER_CACHE.set(file, { fingerprint, value });
+    if (SUBAGENT_MARKER_CACHE.size > MAX_METADATA_CACHE_ENTRIES) {
+        SUBAGENT_MARKER_CACHE.delete(SUBAGENT_MARKER_CACHE.keys().next().value);
+    }
+    return value;
+}
+function storeFingerprint(file) {
+    return [file, `${file}-wal`]
+        .map((candidate) => {
+        const stat = safeStat(candidate);
+        return stat?.isFile() ? `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}` : '-';
+    })
+        .join('|');
+}
+function cachedStoreDescriptors(file, load) {
+    const fingerprint = storeFingerprint(file);
+    const cached = STORE_DESCRIPTOR_CACHE.get(file);
+    if (cached?.fingerprint === fingerprint)
+        return cached.descriptors;
+    const descriptors = load();
+    STORE_DESCRIPTOR_CACHE.set(file, { fingerprint, descriptors });
+    return descriptors;
+}
+function writeFileIfChanged(file, contents) {
+    try {
+        const stat = fs.statSync(file);
+        if (stat.size === Buffer.byteLength(contents) && fs.readFileSync(file, 'utf8') === contents)
+            return;
+    }
+    catch { }
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(temporary, contents, { mode: 0o600 });
+    fs.renameSync(temporary, file);
+}
+function serializableRow(row) {
+    return Object.fromEntries(Object.entries(row).map(([key, value]) => [
+        key,
+        value instanceof Uint8Array
+            ? { __blob__: Buffer.from(value).toString('base64'), bytes: value.byteLength }
+            : typeof value === 'bigint'
+                ? value.toString()
+                : value,
+    ]));
+}
+function projectedDescriptor(harness, nativeSessionId, sourcePath, rows, metadata = {}) {
+    if (!rows.length)
+        return null;
+    const directory = path.join(PROJECTION_ROOT, harness);
+    const cacheName = `${crypto.createHash('sha256').update(nativeSessionId).digest('hex').slice(0, 24)}.jsonl`;
+    const file = path.join(directory, cacheName);
+    const contents = `${rows.map((row) => JSON.stringify(serializableRow(row))).join('\n')}\n`;
+    writeFileIfChanged(file, contents);
+    const stat = fs.statSync(file);
+    const created = metadata.createdAt ? new Date(metadata.createdAt) : stat.birthtime;
+    return {
+        harness,
+        agent: harness,
+        file,
+        sourcePath,
+        nativeSessionId,
+        size: stat.size,
+        mtimeMs: Number(metadata.updatedAtMs) || stat.mtimeMs,
+        createdAt: Number.isNaN(+created) ? stat.birthtime.toISOString() : created.toISOString(),
+        ...(metadata.workingDirectory ? { workingDirectory: String(metadata.workingDirectory) } : {}),
+        ...(metadata.title ? { nativeTitle: String(metadata.title) } : {}),
+    };
+}
+function gooseDescriptors() {
+    const file = path.join(HOME, '.local', 'share', 'goose', 'sessions', 'sessions.db');
+    if (!safeStat(file)?.isFile())
+        return [];
+    return cachedStoreDescriptors(file, () => {
+        const db = new DatabaseSync(file, { readOnly: true });
+        try {
+            const sessions = db
+                .prepare(`
+        SELECT * FROM sessions
+        WHERE parent_session_id IS NULL OR parent_session_id = ''
+        ORDER BY created_at, id
+      `)
+                .all();
+            const messages = db.prepare('SELECT * FROM messages WHERE session_id = ? ORDER BY id');
+            return sessions.flatMap((session) => {
+                const id = String(session.id || '').trim();
+                if (!id)
+                    return [];
+                const descriptor = projectedDescriptor('goose', id, `~/.local/share/goose/sessions/sessions.db#${encodeURIComponent(id)}`, messages.all(id), {
+                    createdAt: session.created_at,
+                    updatedAtMs: Date.parse(String(session.updated_at || '')),
+                    workingDirectory: session.working_dir,
+                    title: session.description || session.name,
+                });
+                return descriptor ? [descriptor] : [];
+            });
+        }
+        finally {
+            db.close();
+        }
+    });
+}
+function kiloDescriptors() {
+    const file = path.join(HOME, '.local', 'share', 'kilo', 'kilo.db');
+    if (!safeStat(file)?.isFile())
+        return [];
+    return cachedStoreDescriptors(file, () => {
+        const db = new DatabaseSync(file, { readOnly: true });
+        try {
+            const sessions = db.prepare('SELECT * FROM session WHERE parent_id IS NULL ORDER BY time_created, id').all();
+            const events = db.prepare('SELECT * FROM event WHERE aggregate_id = ? ORDER BY seq');
+            return sessions.flatMap((session) => {
+                const id = String(session.id || '').trim();
+                if (!id)
+                    return [];
+                const descriptor = projectedDescriptor('kilo', id, `~/.local/share/kilo/kilo.db#${encodeURIComponent(id)}`, events.all(id), {
+                    createdAt: Number(session.time_created) || undefined,
+                    updatedAtMs: Number(session.time_updated) || undefined,
+                    workingDirectory: session.directory,
+                    title: session.title,
+                });
+                return descriptor ? [descriptor] : [];
+            });
+        }
+        finally {
+            db.close();
+        }
+    });
+}
+function opencodeDescriptors() {
+    const candidates = [
+        path.join(HOME, '.local', 'share', 'opencode', 'opencode.db'),
+        path.join(HOME, '.local', 'state', 'opencode', 'opencode.db'),
+    ];
+    const file = candidates.find((candidate) => safeStat(candidate)?.isFile());
+    if (!file)
+        return [];
+    return cachedStoreDescriptors(file, () => {
+        const db = new DatabaseSync(file, { readOnly: true });
+        try {
+            const sessions = db.prepare('SELECT * FROM session WHERE parent_id IS NULL ORDER BY time_created, id').all();
+            const events = db.prepare('SELECT * FROM event WHERE aggregate_id = ? ORDER BY seq');
+            return sessions.flatMap((session) => {
+                const id = String(session.id || '');
+                if (!id)
+                    return [];
+                const descriptor = projectedDescriptor('opencode', id, `${displayPath(file)}#${encodeURIComponent(id)}`, events.all(id), {
+                    createdAt: Number(session.time_created) || undefined,
+                    updatedAtMs: Number(session.time_updated) || undefined,
+                    workingDirectory: session.directory,
+                    title: session.title,
+                });
+                return descriptor ? [descriptor] : [];
+            });
+        }
+        finally {
+            db.close();
+        }
+    });
+}
+function devinDescriptors() {
+    const file = path.join(HOME, '.local', 'share', 'devin', 'cli', 'sessions.db');
+    if (!safeStat(file)?.isFile())
+        return [];
+    return cachedStoreDescriptors(file, () => {
+        const db = new DatabaseSync(file, { readOnly: true });
+        try {
+            const sessions = db.prepare('SELECT * FROM sessions WHERE hidden = 0 ORDER BY created_at, id').all();
+            const nodes = db.prepare('SELECT * FROM message_nodes WHERE session_id = ? ORDER BY row_id');
+            const tools = db.prepare('SELECT * FROM tool_call_state WHERE session_id = ? ORDER BY tool_call_id');
+            return sessions.flatMap((session) => {
+                const id = String(session.id || '');
+                if (!id)
+                    return [];
+                const rows = [
+                    ...nodes.all(id).map((node) => ({
+                        type: 'devin.sqlite.message',
+                        session,
+                        node: {
+                            ...node,
+                            chat_message: (() => {
+                                try {
+                                    return JSON.parse(String(node.chat_message));
+                                }
+                                catch {
+                                    return node.chat_message;
+                                }
+                            })(),
+                        },
+                    })),
+                    ...tools.all(id).map((tool) => ({ type: 'devin.sqlite.tool', session, tool })),
+                ];
+                const descriptor = projectedDescriptor('devin', id, `${displayPath(file)}#${encodeURIComponent(id)}`, rows, {
+                    createdAt: Number(session.created_at) * 1000 || undefined,
+                    updatedAtMs: Number(session.last_activity_at) * 1000 || undefined,
+                    workingDirectory: session.working_directory,
+                    title: session.title,
+                });
+                return descriptor ? [descriptor] : [];
+            });
+        }
+        finally {
+            db.close();
+        }
+    });
+}
+function hermesDescriptors() {
+    const file = path.join(HOME, '.hermes', 'state.db');
+    if (!safeStat(file)?.isFile())
+        return [];
+    return cachedStoreDescriptors(file, () => {
+        const db = new DatabaseSync(file, { readOnly: true });
+        try {
+            const sessions = db
+                .prepare("SELECT * FROM sessions WHERE parent_session_id IS NULL OR parent_session_id = '' ORDER BY started_at, id")
+                .all();
+            const messages = db.prepare('SELECT * FROM messages WHERE session_id = ? ORDER BY id');
+            return sessions.flatMap((session) => {
+                const id = String(session.id || '');
+                if (!id)
+                    return [];
+                const descriptor = projectedDescriptor('hermes', id, `${displayPath(file)}#${encodeURIComponent(id)}`, messages.all(id), {
+                    createdAt: Number(session.started_at) * 1000 || undefined,
+                    updatedAtMs: Number(session.last_activity_at) * 1000 || undefined,
+                    workingDirectory: session.cwd,
+                    title: session.title,
+                });
+                return descriptor ? [descriptor] : [];
+            });
+        }
+        finally {
+            db.close();
+        }
+    });
+}
+export function openclawAcpWorkingDirectory(file, sessionKey = '') {
+    if (!String(sessionKey).includes(':acp-bridge:'))
+        return '';
+    for (const line of filePrefix(file, 128 * 1024).split('\n')) {
+        if (!line)
+            continue;
+        try {
+            const record = JSON.parse(line);
+            const message = record?.message;
+            if (record?.type !== 'message' || message?.role !== 'user' || typeof message?.content !== 'string')
+                continue;
+            const match = /^\[Working directory: ([^\]\n]+)\]\n/u.exec(message.content);
+            const directory = String(match?.[1] || '').trim();
+            if (path.isAbsolute(directory))
+                return path.resolve(directory);
+        }
+        catch { }
+    }
+    return '';
+}
+export function openclawNativeSessionId(sessionKey = '') {
+    return /^agent:[^:]+:acp-bridge:(.+)$/u.exec(String(sessionKey))?.[1] || String(sessionKey);
+}
+function openclawDescriptors() {
+    const sessionsRoot = path.join(HOME, '.openclaw', 'agents', 'main', 'sessions');
+    const indexFile = path.join(sessionsRoot, 'sessions.json');
+    let index;
+    try {
+        index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    return Object.entries(index || {}).flatMap(([sessionKey, metadata]) => {
+        const file = String(metadata?.sessionFile || path.join(sessionsRoot, `${metadata?.sessionId || ''}.jsonl`));
+        const descriptor = fileDescriptor('openclaw', file);
+        if (!descriptor)
+            return [];
+        const report = metadata?.systemPromptReport || {};
+        return [
+            {
+                ...descriptor,
+                sourcePath: `~/.openclaw/agents/main/sessions#${encodeURIComponent(sessionKey)}`,
+                nativeSessionId: openclawNativeSessionId(sessionKey),
+                // The Gateway runs in its agent workspace and records that as the
+                // native cwd. Its ACP bridge preserves the client cwd in the trusted
+                // prompt prefix instead; use that for scoped daemon ownership.
+                workingDirectory: openclawAcpWorkingDirectory(file, sessionKey) || report.workspaceDir || metadata?.cwd,
+                nativeTitle: metadata?.title || report?.sessionKey || sessionKey,
+                createdAt: Number(metadata?.sessionStartedAt)
+                    ? new Date(Number(metadata.sessionStartedAt)).toISOString()
+                    : descriptor.createdAt,
+                mtimeMs: Number(metadata?.updatedAt) || descriptor.mtimeMs,
+            },
+        ];
+    });
+}
+function filePrefix(file, maxBytes) {
+    let handle;
+    try {
+        const stat = fs.statSync(file);
+        const bytesToRead = Math.min(stat.size, maxBytes);
+        handle = fs.openSync(file, 'r');
+        const buffer = Buffer.alloc(bytesToRead);
+        const bytesRead = fs.readSync(handle, buffer, 0, buffer.length, 0);
+        return buffer
+            .subarray(0, bytesRead)
+            .toString('utf8')
+            .replace(/^\uFEFF/u, '');
+    }
+    catch {
+        return '';
+    }
+    finally {
+        try {
+            if (handle !== undefined)
+                fs.closeSync(handle);
+        }
+        catch { }
+    }
+}
+function recordPrefix(file, limit, maxBytes) {
+    let handle;
+    try {
+        const stat = fs.statSync(file);
+        const bytesToRead = Math.min(stat.size, maxBytes);
+        handle = fs.openSync(file, 'r');
+        const chunks = [];
+        let offset = 0;
+        let newlines = 0;
+        while (offset < bytesToRead && newlines < limit) {
+            const buffer = Buffer.alloc(Math.min(64 * 1024, bytesToRead - offset));
+            const bytesRead = fs.readSync(handle, buffer, 0, buffer.length, offset);
+            if (!bytesRead)
+                break;
+            const chunk = buffer.subarray(0, bytesRead);
+            chunks.push(chunk);
+            for (const byte of chunk)
+                if (byte === 0x0a)
+                    newlines += 1;
+            offset += bytesRead;
+        }
+        return Buffer.concat(chunks)
+            .toString('utf8')
+            .replace(/^\uFEFF/u, '');
+    }
+    catch {
+        return '';
+    }
+    finally {
+        try {
+            if (handle !== undefined)
+                fs.closeSync(handle);
+        }
+        catch { }
+    }
+}
+function firstRecords(descriptor, limit = 32, maxBytes = 1024 * 1024) {
+    try {
+        const stat = fs.statSync(descriptor.file);
+        const isJsonDocument = descriptor.file.endsWith('.json');
+        const text = isJsonDocument
+            ? filePrefix(descriptor.file, stat.size)
+            : recordPrefix(descriptor.file, limit, maxBytes);
+        if (isJsonDocument) {
+            const value = JSON.parse(text);
+            const values = Array.isArray(value) ? value.slice(0, limit) : [value];
+            return values.flatMap((candidate) => {
+                const object = jsonObject(candidate);
+                return object ? [object] : [];
+            });
+        }
+        return text
+            .split(/\r?\n/u)
+            .filter(Boolean)
+            .slice(0, limit)
+            .flatMap((line) => {
+            try {
+                const object = jsonObject(JSON.parse(line));
+                return object ? [object] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/** Native identity and parentage carried by a bounded transcript prefix. */
+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]
+        .map((candidate) => candidate?.isFile() ? `${candidate.dev}:${candidate.ino}:${candidate.size}:${candidate.mtimeMs}` : '-')
+        .join('|');
+    const cacheKey = [
+        descriptor?.harness,
+        sourcePath,
+        descriptor?.nativeSessionId,
+        descriptor?.parentNativeSessionId,
+        descriptor?.isSubagent,
+        descriptor?.threadSource,
+    ].join('\0');
+    const cached = LINEAGE_CACHE.get(cacheKey);
+    if (cached?.fingerprint === fingerprint) {
+        LINEAGE_CACHE.delete(cacheKey);
+        LINEAGE_CACHE.set(cacheKey, cached);
+        return cached.value;
+    }
+    const structural = nativeSubagentPathLineage(descriptor?.harness, sourcePath);
+    const claudeMetadata = claudeSubagentMetadata(descriptor, structural);
+    let nativeSessionId = structural?.nativeSessionId || descriptorNativeSessionId(descriptor);
+    let parentNativeSessionId = String(descriptor?.parentNativeSessionId || claudeMetadata?.parentAgentId || structural?.parentNativeSessionId || '').trim();
+    const parentSourcePath = claudeMetadata?.parentSourcePath || structural?.parentSourcePath || '';
+    let isSubagent = Boolean(structural) || nativeDescriptorIsSubagent(descriptor);
+    const needsRecords = !nativeSessionId || (isSubagent && !parentNativeSessionId && !parentSourcePath);
+    for (const record of needsRecords ? firstRecords(descriptor) : []) {
+        const payload = parsedObject(record?.payload);
+        const session = parsedObject(record?.session);
+        const source = parsedObject(payload?.source) || parsedObject(record?.source);
+        const subagent = parsedObject(source?.subagent) || parsedObject(source?.sub_agent) || parsedObject(source?.delegate);
+        const spawn = parsedObject(subagent?.thread_spawn) || parsedObject(subagent?.threadSpawn) || subagent;
+        const parent = [
+            spawn?.parent_thread_id,
+            spawn?.parentThreadId,
+            payload?.parent_session_id,
+            payload?.parentSessionId,
+            payload?.parentSession,
+            session?.parent_session_id,
+            session?.parentSessionId,
+            session?.parentSession,
+            record?.parent_session_id,
+            record?.parentSessionId,
+            record?.parentSession,
+        ].find((value) => typeof value === 'string' && value.trim());
+        if (!parentNativeSessionId && parent)
+            parentNativeSessionId = parent.trim();
+        if (!nativeSessionId) {
+            const own = [
+                payload?.id,
+                payload?.sessionId,
+                session?.id,
+                record?.sessionId,
+                record?.session_id,
+                record?.conversationId,
+                record?.conversation_id,
+                record?.threadId,
+                record?.id,
+            ].find((value) => typeof value === 'string' && value.trim());
+            if (own)
+                nativeSessionId = own.trim();
+        }
+        if ((descriptor?.harness === 'claude' || descriptor?.harness === 'codebuddy') && record?.isSidechain === true) {
+            isSubagent = true;
+            const agentId = String(record.agentId || '').trim();
+            if (agentId)
+                nativeSessionId = agentId;
+            const parentSession = String(record.sessionId || '').trim();
+            if (!parentNativeSessionId && parentSession)
+                parentNativeSessionId = parentSession;
+        }
+    }
+    if (parentNativeSessionId)
+        isSubagent = true;
+    const value = {
+        nativeSessionId,
+        parentNativeSessionId,
+        isSubagent,
+        ...(structural?.uploadable === false ? { uploadable: false } : {}),
+        ...(parentSourcePath ? { parentSourcePath } : {}),
+        ...(claudeMetadata?.description ? { nativeTitle: claudeMetadata.description } : {}),
+        ...(claudeMetadata?.agentType ? { nativeSubagentType: claudeMetadata.agentType } : {}),
+        ...(claudeMetadata?.spawnDepth ? { nativeSubagentDepth: claudeMetadata.spawnDepth } : {}),
+    };
+    LINEAGE_CACHE.set(cacheKey, { fingerprint, value });
+    if (LINEAGE_CACHE.size > MAX_METADATA_CACHE_ENTRIES) {
+        LINEAGE_CACHE.delete(LINEAGE_CACHE.keys().next().value);
+    }
+    return value;
+}
+function sidecarJson(descriptor, basename) {
+    const transcript = path.resolve(descriptor.file);
+    if (!transcript)
+        return null;
+    return jsonFile(path.join(path.dirname(transcript), basename));
+}
+function jsonFile(file) {
+    try {
+        const stat = fs.statSync(file);
+        const fingerprint = `${stat.size}:${stat.mtimeMs}`;
+        const cached = JSON_FILE_CACHE.get(file);
+        if (cached?.fingerprint === fingerprint)
+            return cached.value;
+        const value = jsonObject(JSON.parse(fs.readFileSync(file, 'utf8')));
+        if (!value)
+            return null;
+        JSON_FILE_CACHE.set(file, { fingerprint, value });
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function absolutePathCandidate(values) {
+    for (const value of values) {
+        if (typeof value === 'string' && path.isAbsolute(value.trim()))
+            return value.trim();
+    }
+    return '';
+}
+function clineMetadataWorkingDirectory(descriptor) {
+    const transcript = path.resolve(descriptor.file);
+    const metadataFile = transcript.endsWith('.messages.json')
+        ? `${transcript.slice(0, -'.messages.json'.length)}.json`
+        : '';
+    const metadata = metadataFile ? jsonFile(metadataFile) : null;
+    return absolutePathCandidate([metadata?.cwd, metadata?.workspace_root, metadata?.workspaceRoot]);
+}
+function cursorMetadataWorkingDirectory(descriptor) {
+    const transcript = path.resolve(descriptor.file);
+    const marker = `${path.sep}agent-transcripts${path.sep}`;
+    const markerIndex = transcript.lastIndexOf(marker);
+    if (markerIndex < 0)
+        return '';
+    const projectDirectory = transcript.slice(0, markerIndex);
+    const trust = jsonFile(path.join(projectDirectory, '.workspace-trusted'));
+    const trusted = absolutePathCandidate([trust?.workspacePath, trust?.workspace_path, trust?.cwd]);
+    if (trusted)
+        return trusted;
+    const workerLog = path.join(projectDirectory, 'worker.log');
+    const workerStat = safeStat(workerLog);
+    const workerFingerprint = workerStat ? `${workerStat.size}:${workerStat.mtimeMs}` : '';
+    const cachedWorker = CURSOR_WORKER_CWD_CACHE.get(workerLog);
+    if (cachedWorker?.fingerprint === workerFingerprint)
+        return cachedWorker.cwd;
+    const logged = /(?:^|\s)workspacePath=(\/[^\s]+)/u.exec(filePrefix(workerLog, 1024 * 1024))?.[1];
+    const cwd = logged && path.isAbsolute(logged) ? logged : '';
+    CURSOR_WORKER_CWD_CACHE.set(workerLog, { fingerprint: workerFingerprint, cwd });
+    return cwd;
+}
+function kimiMetadataWorkingDirectory(descriptor) {
+    const transcriptDirectory = path.dirname(path.resolve(descriptor.file));
+    const metadata = jsonFile(path.resolve(transcriptDirectory, '..', '..', 'state.json'));
+    const stateCandidate = absolutePathCandidate([
+        metadata?.cwd,
+        metadata?.workDir,
+        metadata?.working_directory,
+        metadata?.workingDirectory,
+    ]);
+    if (stateCandidate)
+        return stateCandidate;
+    const transcript = path.resolve(descriptor.file);
+    const marker = `${path.sep}sessions${path.sep}`;
+    const markerIndex = transcript.lastIndexOf(marker);
+    if (markerIndex < 0)
+        return '';
+    const workspaceId = transcript.slice(markerIndex + marker.length).split(path.sep, 1)[0];
+    const dataDirectory = transcript.slice(0, markerIndex);
+    const workspaces = jsonFile(path.join(dataDirectory, 'workspaces.json'));
+    const workspaceEntries = jsonObject(workspaces?.workspaces);
+    const workspace = jsonObject(workspaceEntries?.[workspaceId]);
+    return absolutePathCandidate([workspace?.root]);
+}
+function geminiMetadataWorkingDirectory(descriptor) {
+    const transcript = path.resolve(descriptor.file);
+    if (path.basename(path.dirname(transcript)) !== 'chats')
+        return '';
+    try {
+        const candidate = fs
+            .readFileSync(path.join(path.dirname(path.dirname(transcript)), '.project_root'), 'utf8')
+            .trim();
+        return path.isAbsolute(candidate) ? candidate : '';
+    }
+    catch {
+        return '';
+    }
+}
+function antigravityMetadataWorkingDirectory(descriptor) {
+    const transcript = path.resolve(descriptor.file);
+    const marker = `${path.sep}brain${path.sep}`;
+    const markerIndex = transcript.lastIndexOf(marker);
+    if (markerIndex < 0)
+        return '';
+    const relative = transcript.slice(markerIndex + marker.length);
+    const conversationId = relative.split(path.sep, 1)[0];
+    const appDirectory = transcript.slice(0, markerIndex);
+    const metadata = jsonFile(path.join(appDirectory, 'cache', 'conversation_metadata.json'));
+    const conversations = jsonObject(metadata?.conversations);
+    const conversation = jsonObject(conversations?.[conversationId]);
+    const summary = jsonObject(conversation?.summary);
+    const uris = summary?.WorkspaceURIs;
+    if (Array.isArray(uris)) {
+        for (const uri of uris) {
+            if (typeof uri !== 'string' || !uri.startsWith('file://'))
+                continue;
+            try {
+                const candidate = decodeURIComponent(new URL(uri).pathname);
+                if (path.isAbsolute(candidate))
+                    return candidate;
+            }
+            catch { }
+        }
+    }
+    const transcriptStat = safeStat(transcript);
+    const transcriptFingerprint = transcriptStat ? `${transcriptStat.size}:${transcriptStat.mtimeMs}` : '';
+    const cachedTranscript = ANTIGRAVITY_TRANSCRIPT_CWD_CACHE.get(transcript);
+    if (cachedTranscript?.fingerprint === transcriptFingerprint)
+        return cachedTranscript.cwd;
+    const findCwd = (value) => {
+        const object = jsonObject(value);
+        if (!object)
+            return '';
+        const direct = absolutePathCandidate([object.Cwd, object.cwd]);
+        if (direct)
+            return direct;
+        for (const child of Object.values(object)) {
+            const nested = findCwd(child);
+            if (nested)
+                return nested;
+        }
+        return '';
+    };
+    for (const record of firstRecords(descriptor, 256, 4 * 1024 * 1024)) {
+        const candidate = findCwd(record);
+        if (candidate) {
+            ANTIGRAVITY_TRANSCRIPT_CWD_CACHE.set(transcript, { fingerprint: transcriptFingerprint, cwd: candidate });
+            return candidate;
+        }
+    }
+    ANTIGRAVITY_TRANSCRIPT_CWD_CACHE.set(transcript, { fingerprint: transcriptFingerprint, cwd: '' });
+    return '';
+}
+function museMetadataWorkingDirectory(descriptor) {
+    let transcript = path.resolve(descriptor.file);
+    const seen = new Set();
+    for (let depth = 0; depth < 16 && transcript && !seen.has(transcript); depth += 1) {
+        seen.add(transcript);
+        const record = firstRecords({ file: transcript }).find((candidate) => candidate.payload_type === 'runtime.session.metadata');
+        const payload = jsonObject(record?.payload);
+        const metadata = jsonObject(payload?.record);
+        const candidate = absolutePathCandidate([metadata?.workspace_root, metadata?.cwd]);
+        if (!candidate)
+            return '';
+        const parentTranscript = path.join(candidate, 'session.jsonl');
+        const parentSessionId = path.basename(candidate);
+        if (!new RegExp(`^${OPAQUE_UUID_SOURCE}$`, 'iu').test(parentSessionId) || !safeStat(parentTranscript)?.isFile())
+            return candidate;
+        transcript = parentTranscript;
+    }
+    return '';
+}
+/** Bounded metadata inference owned by Turns and shared by uploader/queue. */
+export function nativeDescriptorWorkingDirectory(descriptor) {
+    if (descriptor.workingDirectory?.trim())
+        return descriptor.workingDirectory.trim();
+    const metadataResolvers = {
+        antigravity: antigravityMetadataWorkingDirectory,
+        cline: clineMetadataWorkingDirectory,
+        cursor: cursorMetadataWorkingDirectory,
+        gemini: geminiMetadataWorkingDirectory,
+        kimi: kimiMetadataWorkingDirectory,
+    };
+    const metadataCandidate = metadataResolvers[descriptor.harness]?.(descriptor) || '';
+    if (metadataCandidate)
+        return metadataCandidate;
+    if (descriptor.harness === 'vibe') {
+        const metadata = sidecarJson(descriptor, 'meta.json');
+        const environment = jsonObject(metadata?.environment);
+        const candidate = absolutePathCandidate([
+            environment?.working_directory,
+            environment?.workingDirectory,
+            metadata?.working_directory,
+            metadata?.workingDirectory,
+            metadata?.cwd,
+        ]);
+        if (candidate)
+            return candidate;
+    }
+    if (descriptor.harness === 'muse') {
+        const candidate = museMetadataWorkingDirectory(descriptor);
+        if (candidate)
+            return candidate;
+    }
+    if (descriptor.harness === 'grok') {
+        // Grok namespaces native sessions under an URL-encoded working directory:
+        // `~/.grok/sessions/%2Fhome%2Fkevin%2Fturns/<session>/...`. Resuming with
+        // the transcript directory as cwd makes the ACP server search the wrong
+        // namespace and report "Path not found".
+        const sourcePath = String(descriptor.sourcePath || descriptor.file).replaceAll('\\', '/');
+        const encoded = /(?:^|\/)\.grok\/sessions\/([^/]+)(?:\/|$)/u.exec(sourcePath)?.[1];
+        if (encoded) {
+            try {
+                const decoded = decodeURIComponent(encoded);
+                if (path.isAbsolute(decoded))
+                    return decoded;
+            }
+            catch { }
+        }
+    }
+    for (const record of firstRecords(descriptor)) {
+        const payload = jsonObject(record.payload);
+        const session = jsonObject(record.session);
+        const meta = jsonObject(record.meta);
+        const data = jsonObject(record.data);
+        const context = jsonObject(data?.context);
+        const sessionStart = jsonObject(record.session_start);
+        const candidates = [
+            record.cwd,
+            record.working_directory,
+            record.workingDirectory,
+            record.workspace,
+            payload?.cwd,
+            session?.working_directory,
+            session?.cwd,
+            meta?.workdir,
+            data?.cwd,
+            context?.cwd,
+            ...(Array.isArray(record.working_directories) ? record.working_directories : []),
+            ...(Array.isArray(sessionStart?.working_directories) ? sessionStart.working_directories : []),
+        ];
+        const found = absolutePathCandidate(candidates);
+        if (found)
+            return found;
+    }
+    return '';
+}
+/** Resolve the harness-native resumable session key from bounded native records
+ * and structural path metadata. This is intentionally not the
+ * turns.dev URL/session ID, which is machine-and-path stable. */
+export async function nativeDescriptorAgentSessionId(descriptor) {
+    const subagent = nativeDescriptorIsSubagent(descriptor);
+    // Child transcripts are observational sessions. Even when a harness exposes
+    // a technically valid child thread ID, turns.dev never dispatches prompts
+    // into work whose lifecycle and ownership belong to its parent agent.
+    if (subagent)
+        return '';
+    const structural = descriptorNativeSessionId(descriptor);
+    if (structural) {
+        // Kimi persists its ACP key as `session_<uuid>`. The path parser used to
+        // return only the captured UUID, which looks plausible but session/load
+        // correctly rejects as an unknown ID.
+        if (descriptor?.harness === 'kimi' && !structural.startsWith('session_'))
+            return `session_${structural}`;
+        return structural;
+    }
+    if (descriptor?.harness === 'muse') {
+        for (const record of firstRecords(descriptor)) {
+            const stream = jsonObject(record.stream);
+            const sessionId = stream?.kind === 'session' ? String(stream.id || '') : '';
+            if (sessionId)
+                return sessionId;
+        }
+    }
+    for (const record of firstRecords(descriptor)) {
+        const payload = jsonObject(record.payload);
+        const session = jsonObject(record.session);
+        const stream = jsonObject(record.stream);
+        const candidates = [
+            record.sessionId,
+            record.session_id,
+            record.conversationId,
+            record.conversation_id,
+            record.threadId,
+            record.id,
+            payload?.id,
+            payload?.sessionId,
+            session?.id,
+            stream?.kind === 'session' ? stream.id : '',
+        ];
+        const found = candidates.find((value) => typeof value === 'string' && value.length >= 8);
+        if (found)
+            return found;
+    }
+    if (descriptor?.harness === 'cursor') {
+        const cursorSessionId = /(?:^|\/)agent-transcripts\/([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})(?:\/|$)/iu.exec(String(descriptor?.sourcePath || descriptor?.file || '').replaceAll('\\', '/'))?.[1];
+        if (cursorSessionId)
+            return cursorSessionId;
+    }
+    if (descriptor?.harness === 'vibe') {
+        const transcript = path.resolve(String(descriptor?.file || ''));
+        if (path.basename(transcript) === 'messages.jsonl' &&
+            /^session_[0-9]{8}_[0-9]{6}_[0-9a-f]{8}$/iu.test(path.basename(path.dirname(transcript)))) {
+            try {
+                const metadata = sidecarJson(descriptor, 'meta.json');
+                const vibeSessionId = String(metadata?.session_id || '').trim();
+                // Vibe uses UUID-shaped opaque IDs but does not reserve the RFC version
+                // and variant nibbles (for example `...-a328-4c84-...`).
+                if (/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/iu.test(vibeSessionId)) {
+                    return vibeSessionId;
+                }
+            }
+            catch { }
+        }
+    }
+    const fragment = String(descriptor?.sourcePath || '').split('#', 2)[1] || '';
+    if (fragment) {
+        try {
+            return decodeURIComponent(fragment);
+        }
+        catch {
+            return fragment;
+        }
+    }
+    return '';
+}
+/**
+ * Detect independently owned native sessions from process identity and open files.
+ * Exact transcript paths carried by Turns queue-worker child environments are
+ * subtracted so an anchor never describes itself as independently managed.
+ */
+function nativeProcessSnapshots(procRoot) {
+    const processes = [];
+    let entries = [];
+    try {
+        entries = fs.readdirSync(procRoot, { withFileTypes: true });
+    }
+    catch { }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !/^\d+$/u.test(entry.name))
+            continue;
+        let argv = [];
+        let environ = '';
+        let fdTargets = [];
+        try {
+            argv = fs
+                .readFileSync(path.join(procRoot, entry.name, 'cmdline'), 'utf8')
+                .split('\0')
+                .filter(Boolean);
+        }
+        catch { }
+        try {
+            environ = fs.readFileSync(path.join(procRoot, entry.name, 'environ'), 'utf8');
+        }
+        catch { }
+        try {
+            fdTargets = fs.readdirSync(path.join(procRoot, entry.name, 'fd')).flatMap((descriptor) => {
+                try {
+                    const target = fs
+                        .readlinkSync(path.join(procRoot, entry.name, 'fd', descriptor))
+                        .replace(/ \(deleted\)$/u, '');
+                    return path.isAbsolute(target) ? [target] : [];
+                }
+                catch {
+                    return [];
+                }
+            });
+        }
+        catch { }
+        if (argv.length || environ)
+            processes.push({ argv, cmdline: argv.join(' '), environ, fdTargets });
+    }
+    return processes;
+}
+const HARNESS_PROCESS_NAMES = {
+    antigravity: ['agy', 'antigravity'],
+    claude: ['claude'],
+    cline: ['cline'],
+    codebuddy: ['codebuddy'],
+    codex: ['codex'],
+    copilot: ['copilot'],
+    cursor: ['cursor', 'cursor-agent'],
+    deepseek: ['deepseek'],
+    devin: ['devin'],
+    gemini: ['gemini'],
+    goose: ['goose'],
+    grok: ['grok'],
+    hermes: ['hermes'],
+    kilo: ['kilo'],
+    kimi: ['kimi', 'kimi-code'],
+    muse: ['muse'],
+    omp: ['omp'],
+    openclaw: ['openclaw'],
+    opencode: ['opencode'],
+    pi: ['pi'],
+    poolside: ['pool', 'poolside'],
+    prime: ['prime', 'prime-agent'],
+    qwen: ['qwen'],
+    vibe: ['vibe', 'vibe-acp'],
+};
+const SCRIPT_RUNTIMES = new Set(['node', 'nodejs', 'bun', 'deno', 'python', 'python3']);
+function executableStem(value) {
+    return path
+        .basename(String(value || ''))
+        .replace(/\.(?:[cm]?js|py)$/iu, '')
+        .toLowerCase();
+}
+function canonicalProcessFile(value) {
+    try {
+        return fs.realpathSync(value);
+    }
+    catch {
+        return path.resolve(value);
+    }
+}
+/** Ownership requires the process itself to be the harness. Merely mentioning
+ * `codex <session-id>` in a shell, grep, uploader log query, or tool command is
+ * not evidence that the referenced native session is running. Script launchers
+ * are accepted only when argv[0] is a known runtime and argv[1] is the harness
+ * entrypoint; a shell wrapper still has a real child harness process to find. */
+function processRunsHarness(process, harness) {
+    const names = new Set(HARNESS_PROCESS_NAMES[harness] || [harness]);
+    const executable = executableStem(process.argv?.[0]);
+    if (names.has(executable))
+        return true;
+    return SCRIPT_RUNTIMES.has(executable) && names.has(executableStem(process.argv?.[1]));
+}
+function queueManagedKeysFromProcesses(descriptors, processes) {
+    const transcriptFiles = new Set();
+    for (const process of processes) {
+        const environment = Object.fromEntries(process.environ
+            .split('\0')
+            .filter(Boolean)
+            .map((value) => {
+            const separator = value.indexOf('=');
+            return separator < 0 ? [value, ''] : [value.slice(0, separator), value.slice(separator + 1)];
+        }));
+        if (!environment.TURNS_QUEUE_WORKER_ID || !environment.TURNS_TRANSCRIPT_PATH)
+            continue;
+        try {
+            transcriptFiles.add(fs.realpathSync(environment.TURNS_TRANSCRIPT_PATH));
+        }
+        catch {
+            transcriptFiles.add(path.resolve(environment.TURNS_TRANSCRIPT_PATH));
+        }
+    }
+    return new Set(descriptors.flatMap((descriptor) => {
+        if (!descriptor?.file)
+            return [];
+        let file;
+        try {
+            file = fs.realpathSync(descriptor.file);
+        }
+        catch {
+            file = path.resolve(descriptor.file);
+        }
+        return transcriptFiles.has(file) ? [`${descriptor.harness}\0${descriptor.sourcePath}`] : [];
+    }));
+}
+export function queueManagedNativeDescriptorKeys(descriptors, procRoot = '/proc') {
+    return queueManagedKeysFromProcesses(descriptors, nativeProcessSnapshots(procRoot));
+}
+export function externallyManagedNativeDescriptorKeys(descriptors, procRoot = '/proc') {
+    const snapshots = nativeProcessSnapshots(procRoot);
+    const queueManaged = queueManagedKeysFromProcesses(descriptors, snapshots);
+    const externalProcesses = snapshots.filter((process) => !process.environ.includes('TURNS_QUEUE_WORKER_ID='));
+    const byHarness = new Map();
+    for (const descriptor of descriptors) {
+        const key = `${descriptor.harness}\0${descriptor.sourcePath}`;
+        if (queueManaged.has(key))
+            continue;
+        const session = descriptorNativeSessionId(descriptor);
+        const file = descriptor?.file ? canonicalProcessFile(descriptor.file) : '';
+        // A process with no session key is evidence only that a harness is
+        // running, not that it owns every historical transcript for that harness.
+        // An exact open transcript, however, identifies that one descriptor.
+        if (!session && !file)
+            continue;
+        const group = byHarness.get(descriptor.harness) || [];
+        group.push({ key, session, file });
+        byHarness.set(descriptor.harness, group);
+    }
+    const managed = new Set();
+    for (const [harness, candidates] of byHarness) {
+        for (const process of externalProcesses) {
+            if (!processRunsHarness(process, harness))
+                continue;
+            const openFiles = new Set(process.fdTargets.map(canonicalProcessFile));
+            for (const candidate of candidates) {
+                if ((candidate.session && process.cmdline.includes(candidate.session)) ||
+                    (candidate.file && openFiles.has(candidate.file))) {
+                    managed.add(candidate.key);
+                }
+            }
+        }
+    }
+    return managed;
+}
+function discoverLocalSessionInventory(only = '') {
+    const descriptors = [];
+    for (const [harness, store] of Object.entries(EXTRA_FILE_STORES)) {
+        walk(store.root, (file) => {
+            if (!store.include(file))
+                return;
+            const descriptor = fileDescriptor(harness, file);
+            if (descriptor)
+                descriptors.push(descriptor);
+        });
+    }
+    descriptors.push(...gooseDescriptors(), ...kiloDescriptors(), ...opencodeDescriptors(), ...devinDescriptors(), ...hermesDescriptors(), ...openclawDescriptors(), ...deepseekTrajectoryDescriptors());
+    const filtered = only
+        ? descriptors.filter((descriptor) => descriptor.harness.toLowerCase().includes(only.toLowerCase()) ||
+            descriptor.sourcePath.toLowerCase().includes(only.toLowerCase()))
+        : descriptors;
+    const unique = new Map();
+    for (const descriptor of filtered)
+        unique.set(`${descriptor.harness}\0${descriptor.sourcePath}`, descriptor);
+    return [...unique.values()].sort((left, right) => left.harness.localeCompare(right.harness) || left.sourcePath.localeCompare(right.sourcePath));
+}
+/** Roots watched by the native uploader. Direct transcript stores are watched
+ * recursively; database-backed stores are represented by their parent
+ * directories so a WAL append schedules a cached inventory refresh. */
+export function nativeSessionWatchRoots() {
+    return [
+        ...new Set([
+            ...Object.values(EXTRA_FILE_STORES).map((store) => store.root),
+            DEEPSEEK_SESSIONS_ROOT,
+            path.join(HOME, '.local', 'share', 'goose', 'sessions'),
+            path.join(HOME, '.local', 'share', 'kilo'),
+            path.join(HOME, '.local', 'share', 'opencode'),
+            path.join(HOME, '.local', 'state', 'opencode'),
+            path.join(HOME, '.local', 'share', 'devin', 'cli'),
+            path.join(HOME, '.hermes'),
+            path.join(HOME, '.openclaw', 'agents', 'main', 'sessions'),
+        ]),
+    ].filter((root) => safeStat(root)?.isDirectory());
+}
+/** Stores whose authoritative files live directly in the root. Recursive
+ * notifications here would wake the uploader for unrelated caches (notably
+ * the large ~/.hermes tree). */
+export function nativeSessionShallowWatchRoots() {
+    return [
+        path.join(HOME, '.local', 'share', 'goose', 'sessions'),
+        path.join(HOME, '.local', 'share', 'kilo'),
+        path.join(HOME, '.local', 'share', 'opencode'),
+        path.join(HOME, '.local', 'state', 'opencode'),
+        path.join(HOME, '.local', 'share', 'devin', 'cli'),
+        path.join(HOME, '.hermes'),
+        path.join(HOME, '.openclaw', 'agents', 'main', 'sessions'),
+        path.join(HOME, '.prime', 'agent', 'sessions'),
+        path.join(HOME, '.omp', 'agent', 'sessions'),
+        path.join(HOME, '.local', 'state', 'poolside', 'trajectories'),
+    ].filter((root) => safeStat(root)?.isDirectory());
+}
+/** Every native session in the harness stores on this machine. */
+export function discoverLocalSessions(only = '') {
+    return discoverLocalSessionInventory(only);
+}