@openpond/evals 0.11.17 → 0.11.19

package/dist/native-conversations/collector.js

@@ -0,0 +1,322 @@
+import { agentImportNormalizerRevision } from "../connected-evidence/imports.js";
+import { watch } from "node:fs";
+import { contentHash } from "@openpond/harness";
+import { randomUUID } from "node:crypto";
+import { listSessions, readSession } from "./history.js";
+import { CollectorStore } from "./collector-store.js";
+import { CollectorErrors, } from "./collector-errors.js";
+import { collectorBranchAnchor } from "./collector-branches.js";
+import { CollectorSyncRequests } from "./collector-sync-requests.js";
+import { COLLECTOR_DEFAULTS, } from "./collector-contracts.js";
+/** Supervised single owner: acquisition and admission checkpoints survive monitor/service exits. */
+export async function runCollector(input) {
+    const store = await CollectorStore.open(input.directory), nonce = randomUUID();
+    store.database.exec("BEGIN IMMEDIATE");
+    try {
+        const retained = store.setting("owner");
+        if (retained) {
+            const owner = JSON.parse(retained);
+            let alive = true;
+            try {
+                process.kill(owner.pid, 0);
+            }
+            catch (error) {
+                alive = error.code !== "ESRCH";
+            }
+            if (alive)
+                throw new Error("The collector already has a live owner.");
+        }
+        store.set("owner", JSON.stringify({ pid: process.pid, nonce }));
+        store.database.exec("COMMIT");
+    }
+    catch (error) {
+        store.database.exec("ROLLBACK");
+        store.close();
+        throw error;
+    }
+    if (store.setting("desiredState") !== "running") {
+        store.set("owner", "");
+        store.close();
+        return;
+    }
+    store.set("pid", String(process.pid));
+    let dirty = true, lastReconcile = 0, lastHeartbeat = 0;
+    const watchers = new Map();
+    const errors = new CollectorErrors(store);
+    const syncRequests = new CollectorSyncRequests(store);
+    const reconciledRevisions = new Map();
+    function retained(connection) {
+        return (store.connections().find((item) => item.id === connection.id) ??
+            connection);
+    }
+    function heartbeatInput(connection) {
+        const pendingOperations = store.queued(connection.id);
+        const error = errors.message(connection.id, "heartbeat");
+        return {
+            pendingOperations,
+            error,
+            // A durable older completion may coexist with newly queued live work.
+            // Keep its receipt, but do not send an ineligible ACK that the server
+            // must reject while the current acquisition/admission state is unhealthy.
+            completedSyncRevision: !pendingOperations && !error ? connection.completedSyncRevision ?? 0 : 0,
+        };
+    }
+    function applyRemote(connection, remote) {
+        const current = retained(connection);
+        if (current.state === "disconnected" || remote.revision < current.revision)
+            return current;
+        const sync = syncRequests.observe(current, remote);
+        if (remote.revision > current.revision)
+            errors.set(current.id, "control", null);
+        const next = { ...current, ...sync, ...(remote.revision > current.revision ? { revision: remote.revision, state: remote.state } : {}), ...(remote.destinations ? { destinations: remote.destinations } : {}) };
+        store.put(next);
+        return next;
+    }
+    function recordFailure(connection, error, phase) {
+        const message = error instanceof Error ? error.message : "Collection failed.";
+        errors.set(connection.id, phase, message);
+        const status = error && typeof error === "object" && "status" in error
+            ? Number(error.status)
+            : 0;
+        const current = retained(connection);
+        // Authentication loss requires explicit reconnection; a timer or restart
+        // must never turn a revoked connection back into a paused/resumable one.
+        if (current.state !== "disconnected" && [400, 401, 403].includes(status))
+            store.put({
+                ...current,
+                state: status === 400 ? "paused" : "disconnected",
+            });
+    }
+    async function acquire(connection) {
+        // A request arriving mid-scan must not be acknowledged by the older scan.
+        const controlRevision = connection.revision;
+        const requestedSyncRevision = connection.requestedSyncRevision ?? 0;
+        let cursor;
+        const failures = [];
+        do {
+            if (Date.now() - lastHeartbeat >= COLLECTOR_DEFAULTS.heartbeatMs) {
+                lastHeartbeat = Date.now();
+                store.set("heartbeatAt", new Date().toISOString());
+                for (const current of store.connections()) {
+                    if (current.state === "disconnected")
+                        continue;
+                    try {
+                        const remote = await input.transport.heartbeat(current, heartbeatInput(current));
+                        applyRemote(current, remote);
+                        errors.set(current.id, "heartbeat", null);
+                    }
+                    catch (error) {
+                        recordFailure(current, error, "heartbeat");
+                    }
+                }
+            }
+            connection =
+                store.connections().find((item) => item.id === connection.id) ??
+                    connection;
+            if (connection.state !== "active")
+                return;
+            if (input.signal.aborted || store.setting("desiredState") !== "running")
+                return;
+            const page = await listSessions(connection.source, {
+                since: connection.since ?? undefined,
+                cursor,
+                limit: 50,
+            });
+            for (const native of page.items) {
+                const scanKey = JSON.stringify([native.path, native.nativeSessionId]);
+                const scanRevision = native.storageRevision
+                    ? contentHash([native.storageRevision, agentImportNormalizerRevision(connection.source.source)])
+                    : null;
+                store.progress.select(connection.id, scanKey);
+                if (input.signal.aborted ||
+                    store.setting("desiredState") !== "running" ||
+                    store.connections().find((item) => item.id === connection.id)
+                        ?.state !== "active")
+                    return;
+                try {
+                    if (scanRevision &&
+                        !store.sourceChanged(connection.id, scanKey, scanRevision) &&
+                        !store.progress.tracks(connection.id, scanKey))
+                        continue;
+                    const { files, preview, branchLeafId } = await readSession(connection.source, native, {
+                        branchAnchor: collectorBranchAnchor(store, connection.id, native.nativeSessionId),
+                    });
+                    let eligible = false;
+                    for (const session of preview.sessions) {
+                        const key = JSON.stringify([
+                            connection.source.instanceId,
+                            session.sessionId,
+                            session.branchId,
+                        ]);
+                        store.progress.retained(connection.id, scanKey, key);
+                        const selectedBoundaries = session.boundaries.filter((boundary) => boundary.projection === "turn" &&
+                            boundary.terminal !== "unknown" &&
+                            (!connection.since ||
+                                Date.parse(session.events[boundary.start].occurredAt ??
+                                    native.updatedAt) >= Date.parse(connection.since)));
+                        eligible ||= selectedBoundaries.length > 0;
+                        const changed = selectedBoundaries.filter((boundary) => store.changed(connection.id, key, boundary.id, contentHash([boundary.inputHash, boundary.revisionHash])));
+                        for (let offset = 0; offset < changed.length; offset += COLLECTOR_DEFAULTS.batchCases) {
+                            const selected = changed.slice(offset, offset + COLLECTOR_DEFAULTS.batchCases);
+                            const operationId = `sync-${contentHash([connection.id, key, selected.map((boundary) => [boundary.id, boundary.inputHash, boundary.revisionHash])]).slice(0, 48)}`;
+                            store.enqueue({
+                                operationId,
+                                connectionId: connection.id,
+                                sessionKey: key,
+                                contentHash: session.contentHash,
+                                files,
+                                boundaryIds: selected.map((boundary) => boundary.id),
+                                ...(branchLeafId ? { branchLeafId } : {}),
+                            }, selected.map((boundary) => ({
+                                id: boundary.id,
+                                revision: contentHash([
+                                    boundary.inputHash,
+                                    boundary.revisionHash,
+                                ]),
+                            })), scanKey);
+                        }
+                    }
+                    store.progress.read(connection.id, scanKey, eligible);
+                    if (scanRevision)
+                        store.scanned(connection.id, scanKey, scanRevision);
+                }
+                catch (error) {
+                    store.progress.failed(connection.id, scanKey, error instanceof Error ? error.message : "Unable to read session");
+                    failures.push(`${native.nativeSessionId}: ${error instanceof Error ? error.message : "Unable to read session"}`);
+                }
+            }
+            cursor = page.nextCursor ?? undefined;
+        } while (cursor);
+        store.progress.discovered(connection.id);
+        reconciledRevisions.set(connection.id, controlRevision);
+        syncRequests.acquired(connection.id, { controlRevision, requestedSyncRevision, succeeded: failures.length === 0 });
+        errors.set(connection.id, "source", failures.length
+            ? `${failures.length} session(s) need attention. ${failures[0]}`
+            : null);
+    }
+    try {
+        while (!input.signal.aborted &&
+            store.setting("desiredState") === "running") {
+            const connections = store.connections();
+            store.set("heartbeatAt", new Date().toISOString());
+            for (const connection of connections) {
+                if (connection.state === "disconnected")
+                    continue;
+                if (!watchers.has(connection.source.root))
+                    try {
+                        const watcher = watch(connection.source.root, { recursive: connection.source.acquisition !== "sqlite" }, () => {
+                            dirty = true;
+                        });
+                        watcher.on("error", () => {
+                            dirty = true;
+                        });
+                        watchers.set(connection.source.root, watcher);
+                    }
+                    catch {
+                        /* Reconciliation remains authoritative when platform watch is unavailable. */
+                    }
+            }
+            const heartbeat = Date.now() - lastHeartbeat >= COLLECTOR_DEFAULTS.heartbeatMs;
+            if (heartbeat)
+                lastHeartbeat = Date.now();
+            const reconcile = dirty ||
+                Date.now() - lastReconcile >= COLLECTOR_DEFAULTS.reconcileMs ||
+                store.setting("syncNow") === "yes";
+            if (reconcile) {
+                dirty = false;
+                lastReconcile = Date.now();
+                store.set("syncNow", "no");
+            }
+            for (let connection of connections) {
+                connection = retained(connection);
+                if (connection.state === "disconnected")
+                    continue;
+                let phase = "heartbeat";
+                try {
+                    if (heartbeat) {
+                        const remote = await input.transport.heartbeat(connection, heartbeatInput(connection));
+                        connection = applyRemote(connection, remote);
+                        errors.set(connection.id, "heartbeat", null);
+                    }
+                    if (connection.state !== "active") {
+                        reconciledRevisions.delete(connection.id);
+                        continue;
+                    }
+                    phase = "source";
+                    // Resume must scan before retained one-time completion can pause again,
+                    // even when the ordinary reconcile interval has not elapsed.
+                    if (reconcile || reconciledRevisions.get(connection.id) !== connection.revision || syncRequests.needsAcquisition(connection))
+                        await acquire(connection);
+                    connection =
+                        store.connections().find((item) => item.id === connection.id) ??
+                            connection;
+                    if (connection.state !== "active")
+                        continue;
+                    if (input.signal.aborted || store.setting("desiredState") !== "running")
+                        continue;
+                    phase = "admission";
+                    const next = store.next(connection.id);
+                    if (next)
+                        try {
+                            await input.transport.admit(connection, next.entry);
+                            store.acknowledge(next.entry);
+                            errors.set(connection.id, "admission", null);
+                        }
+                        catch (error) {
+                            store.retry(next.entry.operationId, next.attempts);
+                            throw error;
+                        }
+                    connection = retained(connection);
+                    if (input.signal.aborted || store.setting("desiredState") !== "running" || connection.state !== "active")
+                        continue;
+                    connection = syncRequests.complete(connection, errors.message(connection.id, "heartbeat"));
+                    if (syncRequests.needsAcknowledgement(connection) && heartbeatInput(connection).completedSyncRevision) {
+                        phase = "heartbeat";
+                        const remote = await input.transport.heartbeat(connection, heartbeatInput(connection));
+                        connection = applyRemote(connection, remote);
+                        errors.set(connection.id, "heartbeat", null);
+                    }
+                    if (!input.signal.aborted &&
+                        store.setting("desiredState") === "running" &&
+                        connection.state === "active" &&
+                        !connection.keepSyncing &&
+                        reconciledRevisions.get(connection.id) === connection.revision &&
+                        store.queued(connection.id) === 0 &&
+                        store.progress.status(connection.id).stage === "complete" &&
+                        !errors.source(connection.id) &&
+                        syncRequests.confirmed(connection.id) >= (connection.requestedSyncRevision ?? 0)) {
+                        phase = "control";
+                        if (!input.transport.pause)
+                            throw new Error("This transport cannot acknowledge completion of a one-time import.");
+                        const paused = await input.transport.pause(connection);
+                        applyRemote(connection, paused);
+                        errors.set(connection.id, "control", null);
+                    }
+                }
+                catch (error) {
+                    recordFailure(connection, error, phase);
+                }
+            }
+            await new Promise((resolve) => {
+                const done = () => {
+                    clearTimeout(timer);
+                    input.signal.removeEventListener("abort", done);
+                    resolve();
+                };
+                const timer = setTimeout(done, 1000);
+                input.signal.addEventListener("abort", done, { once: true });
+            });
+        }
+    }
+    finally {
+        for (const watcher of watchers.values())
+            watcher.close();
+        const owner = JSON.parse(store.setting("owner") || "{}");
+        if (owner.nonce === nonce) {
+            store.set("pid", "");
+            store.set("heartbeatAt", "");
+            store.set("owner", "");
+        }
+        store.close();
+    }
+}

package/dist/native-conversations/contracts.js

@@ -0,0 +1,11 @@
+export const NATIVE_SOURCE_NAMES = {
+    codex: "Codex",
+    claude_code: "Claude Code",
+    hermes: "Hermes",
+    openclaw: "OpenClaw",
+    opencode: "OpenCode",
+    grok_build: "Grok Build",
+    pi: "Pi",
+    oh_my_pi: "Oh My Pi",
+};
+export const NATIVE_READ_LIMIT = 32 * 1024 * 1024;

package/dist/native-conversations/database.js

@@ -0,0 +1,149 @@
+import { DatabaseSync } from "node:sqlite";
+import { join } from "node:path";
+import { listOpenClawSessions, readOpenClawSession, } from "./openclaw-database.js";
+import { NATIVE_READ_LIMIT } from "./contracts.js";
+function open(source) {
+    const file = source.root.endsWith(".db")
+        ? source.root
+        : join(source.root, source.source === "opencode" ? "opencode.db" : "state.db");
+    const database = new DatabaseSync(file, {
+        readOnly: true,
+        allowExtension: false,
+        enableDoubleQuotedStringLiterals: false,
+    });
+    database.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000; BEGIN");
+    return database;
+}
+export function listDatabaseSessions(source, input) {
+    if (source.source === "openclaw")
+        return listOpenClawSessions(source, input);
+    const database = open(source);
+    try {
+        const since = input.since ? Date.parse(input.since) : 0;
+        const rows = source.source === "opencode"
+            ? database
+                .prepare("SELECT id,title,directory AS cwd,time_updated AS updated, time_updated || ':' || COALESCE((SELECT MAX(time_updated) FROM message WHERE session_id=session.id),0) || ':' || COALESCE((SELECT MAX(time_updated) FROM part WHERE session_id=session.id),0) || ':' || (SELECT COUNT(*) FROM part WHERE session_id=session.id) AS revision FROM session WHERE id > ? AND time_updated >= ? ORDER BY id LIMIT ?")
+                .all(input.cursor ?? "", since, input.limit + 1)
+            : database
+                .prepare("SELECT id,title,cwd,MAX(COALESCE(last_activity_at,0),started_at) * 1000 AS updated FROM sessions WHERE id > ? AND MAX(COALESCE(last_activity_at,0),started_at) * 1000 >= ? ORDER BY id LIMIT ?")
+                .all(input.cursor ?? "", since, input.limit + 1);
+        const items = rows.slice(0, input.limit).map((row) => ({
+            nativeSessionId: String(row.id),
+            sourceInstanceId: source.instanceId,
+            path: String(row.id),
+            title: typeof row.title === "string" ? row.title : String(row.id),
+            cwd: typeof row.cwd === "string" ? row.cwd : null,
+            updatedAt: new Date(Number(row.updated)).toISOString(),
+            storageRevision: source.source === "opencode" ? String(row.revision) : undefined,
+        }));
+        return {
+            items,
+            nextCursor: rows.length > input.limit ? items.at(-1).nativeSessionId : null,
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+export function readDatabaseSession(source, sessionId) {
+    if (source.source === "openclaw")
+        return readOpenClawSession(source, sessionId);
+    const database = open(source);
+    try {
+        let result;
+        if (source.source === "opencode") {
+            const info = database
+                .prepare("SELECT id,title,directory,parent_id,version,time_created,time_updated FROM session WHERE id = ?")
+                .get(sessionId);
+            if (!info)
+                throw new Error("Native session is unavailable.");
+            const total = database
+                .prepare("SELECT (SELECT COALESCE(SUM(length(CAST(data AS BLOB))),0) FROM message WHERE session_id=?) + (SELECT COALESCE(SUM(length(CAST(data AS BLOB))),0) FROM part WHERE session_id=?) AS bytes")
+                .get(sessionId, sessionId);
+            if (Number(total?.bytes) > NATIVE_READ_LIMIT)
+                throw new Error("Native session exceeds the retained byte limit.");
+            const rows = database
+                .prepare("SELECT id,data FROM message WHERE session_id = ? ORDER BY time_created,id LIMIT 100001")
+                .all(sessionId);
+            if (rows.length > 100000)
+                throw new Error("Native session exceeds the event limit.");
+            let bytes = 0;
+            const messages = rows.map((row) => {
+                bytes += Buffer.byteLength(String(row.data));
+                if (bytes > NATIVE_READ_LIMIT)
+                    throw new Error("Native session exceeds the retained byte limit.");
+                const parts = database
+                    .prepare("SELECT id,data FROM part WHERE session_id = ? AND message_id = ? ORDER BY time_created,id LIMIT 100001")
+                    .all(sessionId, String(row.id));
+                if (parts.length > 100000)
+                    throw new Error("Native parts exceed the event limit.");
+                return {
+                    info: {
+                        ...JSON.parse(String(row.data)),
+                        id: row.id,
+                        sessionID: sessionId,
+                    },
+                    parts: parts.map((part) => {
+                        bytes += Buffer.byteLength(String(part.data));
+                        if (bytes > NATIVE_READ_LIMIT)
+                            throw new Error("Native session exceeds the retained byte limit.");
+                        return {
+                            ...JSON.parse(String(part.data)),
+                            id: part.id,
+                            sessionID: sessionId,
+                            messageID: row.id,
+                        };
+                    }),
+                };
+            });
+            result = {
+                info: {
+                    ...info,
+                    parentID: info.parent_id,
+                    time: { created: info.time_created, updated: info.time_updated },
+                },
+                messages,
+            };
+        }
+        else {
+            const info = database
+                .prepare("SELECT id,title,parent_session_id,system_prompt FROM sessions WHERE id = ?")
+                .get(sessionId);
+            if (!info)
+                throw new Error("Native session is unavailable.");
+            const total = database
+                .prepare("SELECT COALESCE(SUM(length(CAST(COALESCE(content,'') AS BLOB))+length(CAST(COALESCE(tool_calls,'') AS BLOB))),0) AS bytes FROM messages WHERE session_id=? AND active=1")
+                .get(sessionId);
+            if (Number(total?.bytes) > NATIVE_READ_LIMIT)
+                throw new Error("Native session exceeds the retained byte limit.");
+            const rows = database
+                .prepare("SELECT id,role,content,tool_call_id,tool_calls,timestamp,finish_reason,compacted FROM messages WHERE session_id = ? AND active = 1 ORDER BY id LIMIT 100001")
+                .all(sessionId);
+            if (rows.length > 100000)
+                throw new Error("Native session exceeds the event limit.");
+            let bytes = 0;
+            result = {
+                ...info,
+                messages: rows.map((row) => {
+                    bytes += Buffer.byteLength(JSON.stringify(row));
+                    if (bytes > NATIVE_READ_LIMIT)
+                        throw new Error("Native session exceeds the retained byte limit.");
+                    return {
+                        ...row,
+                        tool_calls: typeof row.tool_calls === "string"
+                            ? JSON.parse(row.tool_calls)
+                            : null,
+                    };
+                }),
+                message_count: rows.length,
+            };
+        }
+        const text = JSON.stringify(result);
+        if (Buffer.byteLength(text) > NATIVE_READ_LIMIT)
+            throw new Error("Native session exceeds the retained byte limit.");
+        return { path: `${sessionId}.json`, text };
+    }
+    finally {
+        database.close();
+    }
+}

package/dist/native-conversations/discovery.js

@@ -0,0 +1,135 @@
+import { homedir } from "node:os";
+import { realpath, stat, readdir, readFile } from "node:fs/promises";
+import { resolve, join, isAbsolute } from "node:path";
+import { contentHash } from "@openpond/harness";
+import { hermesHome, hermesLocations, ompLocations } from "./source-locations.js";
+import { NATIVE_SOURCE_NAMES, } from "./contracts.js";
+/** Discovery returns locations/capabilities only. Transcript reads require a selected source. */
+export async function discoverSources(input) {
+    const home = input.home ?? homedir(), env = input.environment ?? process.env;
+    const defaults = {
+        codex: env.CODEX_HOME || join(home, ".codex"),
+        claude_code: env.CLAUDE_CONFIG_DIR || join(home, ".claude"),
+        hermes: hermesHome(home, env),
+        openclaw: env.OPENCLAW_STATE_DIR || join(home, ".openclaw"),
+        opencode: join(env.XDG_DATA_HOME || join(home, ".local/share"), "opencode"),
+        grok_build: env.GROK_HOME || join(home, ".grok"),
+        pi: env.PI_CODING_AGENT_DIR || join(home, ".pi/agent"),
+        oh_my_pi: join(home, ".omp/agent"),
+    };
+    // Only documented non-secret source-location settings are read, and never emitted.
+    const piHome = defaults.pi;
+    let piRelativeSetting = false;
+    if (env.PI_CODING_AGENT_SESSION_DIR)
+        defaults.pi = resolve(env.PI_CODING_AGENT_SESSION_DIR);
+    else if (!input.locations?.pi) {
+        try {
+            const file = join(piHome, "settings.json");
+            if ((await stat(file)).size <= 1024 * 1024) {
+                const setting = JSON.parse(await readFile(file, "utf8"));
+                if (typeof setting.sessionDir === "string" &&
+                    setting.sessionDir.trim()) {
+                    if (isAbsolute(setting.sessionDir))
+                        defaults.pi = setting.sessionDir;
+                    else
+                        piRelativeSetting = true;
+                }
+            }
+        }
+        catch {
+            /* Missing/invalid settings do not authorize broader filesystem discovery. */
+        }
+    }
+    const result = [];
+    for (const source of Object.keys(NATIVE_SOURCE_NAMES)) {
+        const locations = input.locations?.[source]
+            ? [{ root: input.locations[source] }]
+            : source === "hermes"
+                ? await hermesLocations(resolve(defaults.hermes))
+                : source === "oh_my_pi"
+                    ? await ompLocations(home, env)
+                    : [{ root: defaults[source] }];
+        for (const location of locations) {
+            let root = resolve(location.root), available = false, file = false;
+            try {
+                root = await realpath(root);
+                const info = await stat(root);
+                file = info.isFile();
+                available = info.isDirectory() || file;
+            }
+            catch {
+                /* Absent or unreadable source is shown explicitly. */
+            }
+            if (location.reason)
+                available = false;
+            if (source === "openclaw" && available && !file) {
+                const agentsRoot = join(root, "agents");
+                const agents = await readdir(agentsRoot, { withFileTypes: true }).catch(() => []);
+                const databases = [];
+                for (const agent of agents.slice(0, 100)) {
+                    if (!agent.isDirectory() || agent.isSymbolicLink())
+                        continue;
+                    const database = join(agentsRoot, agent.name, "agent", "openclaw-agent.sqlite");
+                    if (await stat(database)
+                        .then((info) => info.isFile())
+                        .catch(() => false))
+                        databases.push(await realpath(database));
+                }
+                if (databases.length) {
+                    for (const database of databases)
+                        result.push({
+                            source,
+                            root: database,
+                            machineId: input.machineId,
+                            instanceId: `native-${contentHash([input.machineId, source, database]).slice(0, 40)}`,
+                            acquisition: "sqlite",
+                            available: true,
+                            capabilities: { history: true, live: true, nativeResume: false },
+                        });
+                    continue;
+                }
+            }
+            if (source === "pi" && piRelativeSetting && !input.locations?.pi) {
+                result.push({
+                    source,
+                    root,
+                    machineId: input.machineId,
+                    instanceId: `native-${contentHash([input.machineId, source, root]).slice(0, 40)}`,
+                    acquisition: "files",
+                    available: false,
+                    capabilities: { history: false, live: false, nativeResume: false },
+                    reason: "Pi config uses a working-directory-relative sessionDir. Select its resolved directory with --source-path.",
+                });
+                continue;
+            }
+            result.push({
+                source,
+                root,
+                machineId: input.machineId,
+                instanceId: `native-${contentHash([input.machineId, source, root]).slice(0, 40)}`,
+                acquisition: file && !/\.(?:db|sqlite)$/u.test(root)
+                    ? "files"
+                    : source === "hermes" ||
+                        source === "opencode" ||
+                        (source === "openclaw" && file)
+                        ? "sqlite"
+                        : source === "openclaw"
+                            ? "bundle"
+                            : "files",
+                available,
+                capabilities: {
+                    history: available,
+                    live: available && (source !== "openclaw" || file),
+                    nativeResume: false,
+                },
+                ...(!available
+                    ? {
+                        reason: location.reason ??
+                            "Source location is missing or unreadable. Select a custom location.",
+                    }
+                    : {}),
+            });
+        }
+    }
+    return result.filter((item, index) => result.findIndex((candidate) => candidate.instanceId === item.instanceId) === index);
+}