@openpond/evals 0.11.18 → 0.11.20

package/dist/native-conversations/openclaw-database.js

@@ -0,0 +1,130 @@
+import { DatabaseSync } from "node:sqlite";
+import { zstdDecompressSync } from "node:zlib";
+import { createHash } from "node:crypto";
+import { readOpenClawColdArchive } from "./openclaw-cold-archive.js";
+import { NATIVE_READ_LIMIT, } from "./contracts.js";
+function open(source) {
+    const database = new DatabaseSync(source.root, {
+        readOnly: true,
+        allowExtension: false,
+        enableDoubleQuotedStringLiterals: false,
+    });
+    database.exec("PRAGMA query_only=ON; PRAGMA busy_timeout=1000; BEGIN");
+    return database;
+}
+function has(database, table) {
+    return !!database
+        .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?")
+        .get(table);
+}
+export function listOpenClawSessions(source, input) {
+    const database = open(source);
+    try {
+        // Every hot transcript retains a native session header, including prior reset windows.
+        const archiveUnion = has(database, "session_transcript_archives")
+            ? "UNION ALL SELECT session_id AS id,created_at AS updated,archive_sha256 AS revision FROM session_transcript_archives"
+            : "";
+        const coldUnion = has(database, "session_transcript_cold_archives")
+            ? "UNION ALL SELECT session_id AS id,archived_at AS updated,archive_sha256 AS revision FROM session_transcript_cold_archives"
+            : "";
+        const rows = database
+            .prepare(`SELECT id,MAX(updated) AS updated,MAX(revision) AS revision FROM (
+      SELECT session_id AS id,MAX(created_at) AS updated,CAST(MAX(seq) AS TEXT) AS revision FROM transcript_events GROUP BY session_id
+      ${archiveUnion} ${coldUnion}) WHERE id > ? GROUP BY id ORDER BY id LIMIT ?`)
+            .all(input.cursor ?? "", input.limit + 1);
+        const items = rows.slice(0, input.limit).map((row) => ({
+            nativeSessionId: String(row.id),
+            sourceInstanceId: source.instanceId,
+            path: String(row.id),
+            title: String(row.id),
+            cwd: null,
+            updatedAt: new Date(Number(row.updated) || 0).toISOString(),
+        }));
+        return {
+            items,
+            nextCursor: rows.length > input.limit ? items.at(-1).nativeSessionId : null,
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+export function readOpenClawSession(source, sessionId) {
+    const database = open(source);
+    try {
+        if (has(database, "session_transcript_cold_archives")) {
+            const cold = readOpenClawColdArchive(database, source, sessionId);
+            if (cold)
+                return cold;
+        }
+        const hasHot = database
+            .prepare("SELECT 1 FROM transcript_events WHERE session_id=? LIMIT 1")
+            .get(sessionId);
+        if (!hasHot) {
+            if (!has(database, "session_transcript_archives"))
+                throw new Error("OpenClaw archive is unavailable.");
+            const metadata = database
+                .prepare("SELECT archive_name,length(archive_blob) AS bytes FROM session_transcript_archives WHERE session_id=? ORDER BY created_at DESC LIMIT 1")
+                .get(sessionId);
+            if (!metadata || Number(metadata.bytes) > NATIVE_READ_LIMIT)
+                throw new Error("OpenClaw archive is missing or exceeds the retained byte limit.");
+            const archive = database
+                .prepare("SELECT archive_blob,archive_sha256,encoding FROM session_transcript_archives WHERE archive_name=? AND session_id=?")
+                .get(String(metadata.archive_name), sessionId);
+            if (!(archive.archive_blob instanceof Uint8Array) ||
+                createHash("sha256").update(archive.archive_blob).digest("hex") !==
+                    archive.archive_sha256)
+                throw new Error("OpenClaw archive checksum differs from its retained receipt.");
+            if (archive.encoding !== "zstd" && archive.encoding !== "identity")
+                throw new Error("Unsupported OpenClaw archive encoding.");
+            const bytes = archive.encoding === "zstd"
+                ? zstdDecompressSync(archive.archive_blob, {
+                    maxOutputLength: NATIVE_READ_LIMIT,
+                })
+                : archive.archive_blob;
+            const text = new TextDecoder("utf8", { fatal: true }).decode(bytes);
+            const header = JSON.parse(text.split("\n", 1)[0]);
+            if (header.type !== "session" || header.id !== sessionId)
+                throw new Error("OpenClaw archive identity differs from selected session.");
+            return { path: `${sessionId}.jsonl`, text };
+        }
+        const total = database
+            .prepare("SELECT COUNT(*) AS n,SUM(COALESCE(event_utf8_bytes,length(CAST(event_json AS BLOB)),0)) AS bytes FROM transcript_events WHERE session_id=?")
+            .get(sessionId);
+        if (Number(total.n) > 100000 || Number(total.bytes) > NATIVE_READ_LIMIT)
+            throw new Error("OpenClaw transcript exceeds the retained size limit.");
+        const rows = database
+            .prepare("SELECT seq,event_json,event_zstd,event_utf8_bytes FROM transcript_events WHERE session_id=? ORDER BY seq LIMIT 100001")
+            .all(sessionId);
+        let bytes = 0;
+        const lines = rows.map((row) => {
+            let text;
+            if (typeof row.event_json === "string")
+                text = row.event_json;
+            else {
+                if (!(row.event_zstd instanceof Uint8Array) ||
+                    Number(row.event_utf8_bytes) > NATIVE_READ_LIMIT)
+                    throw new Error("Unsupported OpenClaw compressed transcript record.");
+                const decoded = zstdDecompressSync(row.event_zstd, {
+                    maxOutputLength: NATIVE_READ_LIMIT,
+                });
+                if (decoded.length !== Number(row.event_utf8_bytes))
+                    throw new Error("OpenClaw compressed transcript size differs from its receipt.");
+                text = new TextDecoder("utf8", { fatal: true }).decode(decoded);
+            }
+            bytes += Buffer.byteLength(text);
+            if (bytes > NATIVE_READ_LIMIT)
+                throw new Error("OpenClaw transcript exceeds retained size limit.");
+            return text;
+        });
+        if (!lines.length)
+            throw new Error("OpenClaw transcript is unavailable.");
+        const header = JSON.parse(lines[0]);
+        if (header.type !== "session" || header.id !== sessionId)
+            throw new Error("OpenClaw transcript identity differs from selected session.");
+        return { path: `${sessionId}.jsonl`, text: lines.join("\n") + "\n" };
+    }
+    finally {
+        database.close();
+    }
+}

package/dist/native-conversations/readiness.js

@@ -0,0 +1,4 @@
+/** An empty/incomplete session is discovered history, but not a training case. */
+export class NativeSessionNotReadyError extends Error {
+    constructor() { super("This session has no retained user request yet."); }
+}

package/dist/native-conversations/source-locations.js

@@ -0,0 +1,112 @@
+import { opendir, readFile, stat } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+export function hermesHome(home, env) {
+    const configured = env.HERMES_HOME?.trim();
+    if (configured) {
+        const expanded = configured.replace(/\$(\w+)|\$\{([^}]+)\}/gu, (match, bare, braced) => env[bare || braced] ?? match);
+        return resolve(expanded === "~" ? home : expanded.startsWith("~/") ? join(home, expanded.slice(2)) : expanded);
+    }
+    const suffix = env.HERMES_DATA_DIR_SUFFIX || "";
+    return process.platform === "win32"
+        ? join(env.LOCALAPPDATA?.trim() || join(home, "AppData", "Local"), `hermes${suffix}`)
+        : join(home, `.hermes${suffix}`);
+}
+const isDirectory = (path) => stat(path).then((s) => s.isDirectory()).catch(() => false);
+const isFile = (path) => stat(path).then((s) => s.isFile()).catch(() => false);
+/** A bounded metadata-only inventory. No profile config or credential files are read. */
+async function profileNames(root, valid) {
+    const names = [];
+    const directory = await opendir(root).catch(() => null);
+    if (!directory)
+        return names;
+    let entries = 0;
+    for await (const entry of directory) {
+        if (++entries > 100)
+            throw new Error("More than 100 profile entries. Select the exact --source-path.");
+        if (entry.isDirectory() && !entry.isSymbolicLink() && valid(entry.name))
+            names.push(entry.name);
+    }
+    return names.sort();
+}
+export async function hermesLocations(root) {
+    // A launcher may already have selected a named profile. Never enumerate its siblings.
+    if (basename(dirname(root)) === "profiles")
+        return [{ root }];
+    const profiles = join(root, "profiles");
+    try {
+        const names = await profileNames(profiles, (name) => /^[a-z0-9][a-z0-9_-]{0,63}$/u.test(name));
+        const locations = [];
+        // Retained state.db is the only identity marker relevant to this history reader.
+        // Deleted profiles are deliberately excluded, even if their old DB remains.
+        for (const name of names) {
+            if (await stat(join(profiles, ".deleted", name)).then(() => true).catch(() => false))
+                continue;
+            if (await isFile(join(profiles, name, "state.db")))
+                locations.push({ root: join(profiles, name) });
+        }
+        let active = "";
+        const activeFile = join(root, "active_profile");
+        if (await stat(activeFile).then((s) => s.isFile() && s.size <= 1024).catch(() => false))
+            active = (await readFile(activeFile, "utf8")).replace(/^\uFEFF/u, "").trim().toLowerCase();
+        if (active && active !== "default") {
+            if (!/^[a-z0-9][a-z0-9_-]{0,63}$/u.test(active))
+                return [{ root, reason: "Hermes active profile is invalid. Select the exact --source-path." }];
+            const selected = locations.findIndex((location) => location.root === join(profiles, active));
+            if (selected < 0)
+                locations.unshift({ root: join(profiles, active), reason: "Hermes active profile has no retained live state database. Select a profile explicitly." });
+            else
+                locations.unshift(...locations.splice(selected, 1));
+        }
+        if (await isFile(join(root, "state.db")) || !locations.length)
+            locations.push({ root });
+        return locations;
+    }
+    catch (error) {
+        return [{ root, reason: error instanceof Error ? error.message : "Cannot inventory Hermes profiles. Select the exact --source-path." }];
+    }
+}
+function validOmpProfile(name) {
+    return /^[a-z0-9][a-z0-9._-]{0,63}$/u.test(name) && !name.endsWith(".") &&
+        !/^(?:con|prn|aux|nul|com[0-9]|lpt[0-9])(?:\.|$)/iu.test(name);
+}
+export async function ompLocations(home, env) {
+    const base = join(home, env.PI_CONFIG_DIR || ".omp");
+    const selected = (env.OMP_PROFILE !== undefined ? env.OMP_PROFILE : env.PI_PROFILE)?.trim();
+    if (selected && selected !== "default" && !validOmpProfile(selected))
+        return [{ root: base, reason: "Oh My Pi profile is invalid. Select the exact --source-path." }];
+    // Launch-time session override has higher priority than the agent directory.
+    if (env.PI_CODING_AGENT_SESSION_DIR)
+        return [{ root: resolve(env.PI_CODING_AGENT_SESSION_DIR) }];
+    const xdg = (process.platform === "linux" || process.platform === "darwin") && env.XDG_DATA_HOME
+        ? join(env.XDG_DATA_HOME, "omp") : undefined;
+    async function location(profile) {
+        const standard = profile ? join(base, "profiles", profile, "agent") : join(base, "agent");
+        // Named profiles ignore the default-profile agent override. A native launch
+        // may export its own profile-derived value; explicit empty OMP_PROFILE clears it.
+        const inheritedProfile = env.PI_PROFILE?.trim();
+        const inherited = inheritedProfile && validOmpProfile(inheritedProfile)
+            ? join(base, "profiles", inheritedProfile, "agent") : undefined;
+        const override = !profile && env.PI_CODING_AGENT_DIR && env.PI_CODING_AGENT_DIR !== inherited
+            ? resolve(env.PI_CODING_AGENT_DIR) : undefined;
+        const candidate = xdg && (profile ? join(xdg, "profiles", profile) : xdg);
+        return { root: (!override || override === standard) && candidate && await isDirectory(candidate) ? candidate : override || standard };
+    }
+    if (selected || env.OMP_PROFILE !== undefined || env.PI_PROFILE !== undefined || env.PI_CODING_AGENT_DIR)
+        return [await location(selected && selected !== "default" ? selected : undefined)];
+    try {
+        const names = new Set(await profileNames(join(base, "profiles"), validOmpProfile));
+        if (xdg)
+            for (const name of await profileNames(join(xdg, "profiles"), validOmpProfile))
+                names.add(name);
+        const result = [await location()];
+        for (const name of [...names].sort()) {
+            const candidate = await location(name);
+            if (await isDirectory(join(candidate.root, "sessions")))
+                result.push(candidate);
+        }
+        return result;
+    }
+    catch (error) {
+        return [{ root: base, reason: error instanceof Error ? error.message : "Cannot inventory Oh My Pi profiles. Select the exact --source-path." }];
+    }
+}

package/dist/native-conversations/supervisor.js

@@ -0,0 +1,208 @@
+import { randomUUID } from "node:crypto";
+import { retainAppImageRuntime, removeAppImageRuntimes } from "./appimage-runtime.js";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir, writeFile, rm, rename } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { contentHash } from "@openpond/harness";
+import { CollectorStore } from "./collector-store.js";
+const execute = promisify(execFile);
+const command = async (file, args) => {
+    await execute(file, args, {
+        timeout: 15000,
+        maxBuffer: 16384,
+        windowsHide: true,
+    });
+};
+const xml = (value) => value
+    .replace(/&/gu, "&")
+    .replace(/</gu, "&lt;")
+    .replace(/>/gu, "&gt;")
+    .replace(/"/gu, "&quot;");
+const systemd = (value) => `"${value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"').replace(/%/gu, "%%").replace(/\$/gu, "$$")}"`;
+function identity(directory) {
+    return `openpond-import-${contentHash(directory).slice(0, 16)}`;
+}
+export async function configureCollector(directory, connection) {
+    const store = await CollectorStore.open(directory);
+    try {
+        store.put(connection);
+    }
+    finally {
+        store.close();
+    }
+}
+export async function collectorStatus(directory) {
+    const store = await CollectorStore.open(directory);
+    try {
+        return store.status();
+    }
+    finally {
+        store.close();
+    }
+}
+export async function controlCollector(directory, action, connectionId) {
+    const store = await CollectorStore.open(directory);
+    try {
+        if (action === "start" || action === "stop")
+            store.set("desiredState", action === "start" ? "running" : "stopped");
+        else if (action === "sync")
+            store.set("syncNow", "yes");
+        else {
+            const connection = store
+                .connections()
+                .find((item) => item.id === connectionId);
+            if (!connection)
+                throw new Error("Select a retained connection.");
+            store.put({
+                ...connection,
+                state: action === "pause"
+                    ? "paused"
+                    : action === "resume"
+                        ? "active"
+                        : "disconnected",
+            });
+        }
+        return store.status();
+    }
+    finally {
+        store.close();
+    }
+}
+/** Per-user logon supervision. Installing does not override the retained Stop intent. */
+export async function installCollectorService(input) {
+    if (!isAbsolute(input.directory) ||
+        !isAbsolute(input.executable) ||
+        [input.directory, input.executable, ...input.args].some((value) => /[\r\n\0]/u.test(value)))
+        throw new Error("Collector service requires absolute paths and single-line arguments.");
+    const retainedRuntime = await retainAppImageRuntime(input);
+    if (retainedRuntime)
+        input = { ...input, ...retainedRuntime, environment: { ...input.environment, ELECTRON_RUN_AS_NODE: "1", APPIMAGE_EXTRACT_AND_RUN: "1" } };
+    const environment = Object.entries(input.environment ?? {});
+    if (environment.some(([key, value]) => !["OPENPOND_HOME", "ELECTRON_RUN_AS_NODE", "APPIMAGE_EXTRACT_AND_RUN"].includes(key) ||
+        typeof value !== "string" ||
+        /[\r\n\0]/u.test(value)))
+        throw new Error("Unsupported service environment setting.");
+    const home = input.home ?? homedir(), name = identity(input.directory);
+    const launch = [
+        ...input.args,
+        "import",
+        "service",
+        "run",
+        "--collector-dir",
+        input.directory,
+    ];
+    if (process.platform === "linux") {
+        const directory = join(home, ".config/systemd/user");
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        await atomicServiceFile(join(directory, `${name}.service`), `[Unit]\nDescription=OpenPond conversation importer\nAfter=network-online.target\n[Service]\nType=simple\n${environment.map(([key, value]) => `Environment=${systemd(`${key}=${value}`)}`).join("\n")}\nExecStart=${[input.executable, ...launch].map(systemd).join(" ")}\nRestart=on-failure\nRestartSec=5\nUMask=0077\nNoNewPrivileges=true\n[Install]\nWantedBy=default.target\n`, { mode: 0o600 });
+        await command("systemctl", ["--user", "daemon-reload"]);
+        await command("systemctl", ["--user", "enable", `${name}.service`]);
+    }
+    else if (process.platform === "darwin") {
+        const directory = join(home, "Library/LaunchAgents");
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const file = join(directory, `${name}.plist`);
+        let loaded = false;
+        try {
+            await command("launchctl", ["print", `gui/${process.getuid()}/${name}`]);
+            loaded = true;
+        }
+        catch {
+            /* A first installation has no loaded job. Bootstrap below reports actual setup errors. */
+        }
+        if (loaded)
+            await command("launchctl", [
+                "bootout",
+                `gui/${process.getuid()}/${name}`,
+            ]);
+        await writeFile(file, `<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"><plist version="1.0"><dict><key>Label</key><string>${name}</string><key>ProgramArguments</key><array>${[input.executable, ...launch].map((value) => `<string>${xml(value)}</string>`).join("")}</array><key>EnvironmentVariables</key><dict>${environment.map(([key, value]) => `<key>${xml(key)}</key><string>${xml(value)}</string>`).join("")}</dict><key>RunAtLoad</key><true/><key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict><key>ThrottleInterval</key><integer>5</integer></dict></plist>`, { mode: 0o600 });
+        await command("launchctl", ["bootstrap", `gui/${process.getuid()}`, file]);
+    }
+    else if (process.platform === "win32") {
+        const user = (await execute("whoami", [], { timeout: 5000, maxBuffer: 1024 })).stdout.trim();
+        const file = join(input.directory, "scheduled-task.xml");
+        await mkdir(input.directory, { recursive: true });
+        const quoted = (value) => `"${value.replace(/(\\*)"/gu, '$1$1\\"').replace(/(\\+)$/u, "$1$1")}"`;
+        const script = join(input.directory, "start-collector.ps1");
+        const ps = (value) => `'${value.replace(/'/gu, "''")}'`;
+        await writeFile(script, `${environment.map(([key, value]) => `$env:${key} = ${ps(value)}`).join("\n")}\n& ${[input.executable, ...launch].map(ps).join(" ")}\nexit $LASTEXITCODE\n`, { mode: 0o600 });
+        await writeFile(file, `<?xml version="1.0"?><Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task"><Triggers><LogonTrigger><Enabled>true</Enabled><UserId>${xml(user)}</UserId></LogonTrigger></Triggers><Principals><Principal id="Owner"><UserId>${xml(user)}</UserId><LogonType>InteractiveToken</LogonType><RunLevel>LeastPrivilege</RunLevel></Principal></Principals><Settings><MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy><DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries><StopIfGoingOnBatteries>false</StopIfGoingOnBatteries><ExecutionTimeLimit>PT0S</ExecutionTimeLimit><RestartOnFailure><Interval>PT1M</Interval><Count>999</Count></RestartOnFailure></Settings><Actions Context="Owner"><Exec><Command>powershell.exe</Command><Arguments>${xml(["-NoProfile", "-NonInteractive", "-File", script].map(quoted).join(" "))}</Arguments></Exec></Actions></Task>`, { mode: 0o600 });
+        await command("schtasks", ["/Create", "/TN", name, "/XML", file, "/F"]);
+    }
+    else
+        throw new Error("This OS has no qualified per-user supervisor. Run the collector in the foreground.");
+    return {
+        name,
+        platform: process.platform,
+        status: await collectorStatus(input.directory),
+    };
+}
+/** Removing supervision preserves receipts, pending uploads and retained datasets. */
+export async function uninstallCollectorService(directory, home = homedir()) {
+    await controlCollector(directory, "stop");
+    const name = identity(directory);
+    if (process.platform === "linux") {
+        await command("systemctl", [
+            "--user",
+            "disable",
+            "--now",
+            `${name}.service`,
+        ]);
+        await rm(join(home, ".config/systemd/user", `${name}.service`), {
+            force: true,
+        });
+        await command("systemctl", ["--user", "daemon-reload"]);
+    }
+    else if (process.platform === "darwin") {
+        await command("launchctl", ["bootout", `gui/${process.getuid()}/${name}`]);
+        await rm(join(home, "Library/LaunchAgents", `${name}.plist`), {
+            force: true,
+        });
+    }
+    else if (process.platform === "win32") {
+        await command("schtasks", ["/End", "/TN", name]);
+        await command("schtasks", ["/Delete", "/TN", name, "/F"]);
+        await rm(join(directory, "scheduled-task.xml"), { force: true });
+        await rm(join(directory, "start-collector.ps1"), { force: true });
+    }
+    else
+        throw new Error("No per-user supervisor is available.");
+    if (process.platform === "linux")
+        await removeAppImageRuntimes(directory);
+    return collectorStatus(directory);
+}
+export async function startCollectorService(directory) {
+    await controlCollector(directory, "start");
+    const name = identity(directory);
+    try {
+        if (process.platform === "linux")
+            await command("systemctl", ["--user", "restart", `${name}.service`]);
+        else if (process.platform === "darwin")
+            await command("launchctl", [
+                "kickstart",
+                "-k",
+                `gui/${process.getuid()}/${name}`,
+            ]);
+        else if (process.platform === "win32")
+            await command("schtasks", ["/Run", "/TN", name]);
+        else
+            throw new Error("No per-user supervisor is available.");
+    }
+    catch (error) {
+        await controlCollector(directory, "stop");
+        throw error;
+    }
+    return collectorStatus(directory);
+}
+async function atomicServiceFile(file, text, options) {
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, text, { ...options, flag: "wx" });
+        await rename(temporary, file);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

package/dist/native-conversations/titles.js

@@ -0,0 +1,38 @@
+import { object } from "../connected-evidence/normalize.js";
+function titleText(value) {
+    if (typeof value !== "string")
+        return null;
+    return value.replace(/\s+/gu, " ").trim().slice(0, 160) || null;
+}
+/** Retained provider titles take precedence over a preview of the first real user prompt. */
+export function claudeConversationTitle(rows, sessionId) {
+    const owned = rows.filter((row) => row.sessionId === undefined || row.sessionId === sessionId);
+    for (const row of [...owned].reverse()) {
+        if (row.type === "custom-title") {
+            const title = titleText(row.customTitle);
+            if (title)
+                return title;
+        }
+    }
+    for (const row of [...owned].reverse()) {
+        if (row.type === "summary") {
+            const title = titleText(row.summary);
+            if (title)
+                return title;
+        }
+    }
+    for (const row of owned) {
+        if (row.type !== "user" || row.sessionId !== sessionId || row.isMeta || row.isSidechain)
+            continue;
+        const content = object(row.message).content;
+        const title = titleText(Array.isArray(content)
+            ? content.filter((part) => object(part).type === "text").map((part) => object(part).text).filter((part) => typeof part === "string").join(" ")
+            : content);
+        if (title)
+            return title;
+    }
+    return sessionId;
+}
+export function retainedConversationTitle(value, sessionId) {
+    return titleText(value) ?? sessionId;
+}

package/dist/rewards.js

@@ -163,7 +163,7 @@ export async function executeRewardBinding(input) {
                 }
             }
             else {
-                const [evidence] = await gradeEvidence({ task: input.task, evidence: input.evidence, graders: [compileSource(source, reward)], modelJudge: input.modelJudge, customVerifier: input.customVerifier, purpose: input.purpose, signal: input.signal });
+                const [evidence] = await gradeEvidence({ task: input.task, evidence: input.evidence, evaluatorContext: input.evaluatorContext, graders: [compileSource(source, reward)], modelJudge: input.modelJudge, customVerifier: input.customVerifier, purpose: input.purpose, signal: input.signal });
                 if (!evidence)
                     throw new LearningDomainError("reward_evidence_missing");
                 Object.assign(result, { status: evidence.score === null ? "unavailable" : "scored", rawScore: evidence.score, passed: evidence.score === null ? null : evidence.passed, evidenceHashes: [evidence.contentHash], graderEvidence: evidence, message: evidence.feedback.join("\n") });

package/dist/types/connected-evidence/contracts.d.ts

@@ -18,6 +18,10 @@ export declare const ConnectedSourceKindSchema: z.ZodEnum<{
     native_work: "native_work";
     codex: "codex";
     claude_code: "claude_code";
+    opencode: "opencode";
+    grok_build: "grok_build";
+    pi: "pi";
+    oh_my_pi: "oh_my_pi";
 }>;
 export declare const ConnectedUsageSchema: z.ZodObject<{
     invocationId: z.ZodString;
@@ -117,11 +121,19 @@ export declare const ConnectedSessionSchema: z.ZodObject<{
         native_work: "native_work";
         codex: "codex";
         claude_code: "claude_code";
+        opencode: "opencode";
+        grok_build: "grok_build";
+        pi: "pi";
+        oh_my_pi: "oh_my_pi";
     }>;
     sessionId: z.ZodString;
     branchId: z.ZodNullable<z.ZodString>;
     parentSessionId: z.ZodNullable<z.ZodString>;
     exporterVersion: z.ZodNullable<z.ZodString>;
+    acquisition: z.ZodOptional<z.ZodObject<{
+        machineId: z.ZodString;
+        sourceInstanceId: z.ZodString;
+    }, z.core.$strict>>;
     sourceFiles: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         contentHash: z.ZodString;
@@ -252,6 +264,9 @@ export type ConnectedFile = {
     text: string;
 };
 export declare function hasRecordedConnectedAnswer(event: ConnectedEvent): boolean;
+/** Status/discovery returns no evaluator payload. Large retained histories still
+ * require the exact session, input, observed-output and answer hashes to match. */
+export declare function resolveConnectedBoundaryMetadata(sessionValue: unknown, boundaryId: string): ConnectedBoundary;
 /** Bytes stay in one immutable snapshot; cases retain cutoffs, not copied history. */
 export declare function resolveConnectedBoundary(sessionValue: unknown, boundaryId: string): {
     input: {

package/dist/types/connected-evidence/contracts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,0BAA0B,EAAG,+BAAwC,CAAC;AACnF,eAAO,MAAM,4BAA4B,EAAG,sBAA+B,CAAC;AAC5E,eAAO,MAAM,yBAAyB;;;;;;;;;CACuF,CAAC;AAK9H,eAAO,MAAM,yBAAyB;;;;;;;EAAuF,CAAC;AAC9H,eAAO,MAAM,oBAAoB;;;;;;;;;;;kBAGtB,CAAC;AACZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMtB,CAAC;AACZ,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQzB,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASxB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3D,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,cAAc,WAK/D;AAED,sFAAsF;AACtF,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBjF"}
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,0BAA0B,EAAG,+BAAwC,CAAC;AACnF,eAAO,MAAM,4BAA4B,EAAG,sBAA+B,CAAC;AAC5E,eAAO,MAAM,yBAAyB;;;;;;;;;CACwF,CAAC;AAK/H,eAAO,MAAM,yBAAyB;;;;;;;;;;;EAAmI,CAAC;AAC1K,eAAO,MAAM,oBAAoB;;;;;;;;;;;kBAGtB,CAAC;AACZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMtB,CAAC;AACZ,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQzB,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAUxB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3D,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,cAAc,WAK/D;AAkBD;mFACmF;AACnF,wBAAgB,gCAAgC,CAAC,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,iBAAiB,CAE7G;AACD,sFAAsF;AACtF,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKjF"}

package/dist/types/connected-evidence/imports.d.ts

@@ -1,5 +1,7 @@
 import { type ConnectedFile, type ConnectedSession, type ConnectedSourceKind } from "./contracts.js";
 export type ExternalAgentSource = Exclude<ConnectedSourceKind, "native_chat" | "native_work">;
+/** Cache identity includes source projection policy, independent of file mtimes. */
+export declare function agentImportNormalizerRevision(source: ExternalAgentSource): string;
 export type AgentImportPreview = {
     schemaVersion: "openpond.agentImportPreview.v1";
     source: ExternalAgentSource;
@@ -8,6 +10,7 @@ export type AgentImportPreview = {
     issues: {
         file: string;
         message: string;
+        code?: "no_user_request";
     }[];
 };
 /** Never admits malformed files partly or executes referenced paths/commands. */
@@ -15,5 +18,9 @@ export declare function previewAgentImport(input: {
     source: ExternalAgentSource;
     files: ConnectedFile[];
     branchLeafId?: string;
+    acquisition?: {
+        machineId: string;
+        sourceInstanceId: string;
+    };
 }): AgentImportPreview;
 //# sourceMappingURL=imports.d.ts.map

package/dist/types/connected-evidence/imports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/imports.ts"],"names":[],"mappings":"AACA,OAAO,EAA6B,KAAK,aAAa,EAAE,KAAK,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAMhI,MAAM,MAAM,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,EAAE,aAAa,GAAG,aAAa,CAAC,CAAC;AAC9F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,aAAa,EAAE,gCAAgC,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IACjG,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC3E,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,kBAAkB,CA8C5I"}
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/imports.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACzB,MAAM,gBAAgB,CAAC;AAaxB,MAAM,MAAM,mBAAmB,GAAG,OAAO,CACvC,mBAAmB,EACnB,aAAa,GAAG,aAAa,CAC9B,CAAC;AACF,oFAAoF;AACpF,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,mBAAmB,UAExE;AACD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,aAAa,EAAE,gCAAgC,CAAC;IAChD,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,iBAAiB,CAAA;KAAE,EAAE,CAAC;CACvE,CAAC;AAEF,iFAAiF;AACjF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE;IACxC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/D,GAAG,kBAAkB,CAgJrB"}

package/dist/types/connected-evidence/normalize.d.ts

@@ -1,4 +1,7 @@
 import { type ConnectedEvent, type ConnectedFile, type ConnectedSession, type ConnectedSourceKind } from "./contracts.js";
+export declare class ConnectedSessionWithoutUserRequestError extends Error {
+    constructor();
+}
 export declare function connectedTimestamp(value: unknown, units?: "seconds" | "milliseconds"): string | null;
 export declare function connectedFileIdentity(file: ConnectedFile): {
     path: string;
@@ -17,6 +20,10 @@ export declare function normalizeConnectedSession(input: {
     contextComplete?: boolean;
     includeConversation?: boolean;
     unmappedEvents?: ConnectedEvent[];
+    acquisition?: {
+        machineId: string;
+        sourceInstanceId: string;
+    };
 }): ConnectedSession;
 export declare function connectedJsonLines(file: ConnectedFile): Record<string, unknown>[];
 export declare function object(value: unknown): Record<string, unknown>;

package/dist/types/connected-evidence/normalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/normalize.ts"],"names":[],"mappings":"AACA,OAAO,EACmB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,KAAK,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE3I,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,GAAE,SAAS,GAAG,cAA+B,GAAG,MAAM,GAAG,IAAI,CAIpH;AACD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa;;;;EAExD;AACD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,MAAM,EAAE,mBAAmB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1G,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,MAAM,EAAE,cAAc,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACjK,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;CACnC,GAAG,gBAAgB,CAoDnB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAWjF;AACD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE9D;AACD,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,cAAc,CAEtH;AACD,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAAC,SAAS,CAAC,CAAsD"}
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/normalize.ts"],"names":[],"mappings":"AACA,OAAO,EACmB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,KAAK,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE3I,qBAAa,uCAAwC,SAAQ,KAAK;;CAEjE;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,GAAE,SAAS,GAAG,cAA+B,GAAG,MAAM,GAAG,IAAI,CAIpH;AACD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa;;;;EAExD;AACD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,MAAM,EAAE,mBAAmB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1G,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAC;IAAC,MAAM,EAAE,cAAc,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACjK,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAAC,WAAW,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC;CAClG,GAAG,gBAAgB,CAuDnB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAgBjF;AACD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAE9D;AACD,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,cAAc,CAEtH;AACD,wBAAgB,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAAC,SAAS,CAAC,CAAsD"}

package/dist/types/connected-evidence/sources/claude-branches.d.ts

@@ -0,0 +1,19 @@
+export type ClaudeBranch = {
+    leafId: string;
+    chainHash: string;
+    title: string;
+    updatedAt: string | null;
+    messages: number;
+};
+/** One native graph owns selection, import and Desktop inspection semantics. */
+export declare function claudeGraph(rows: Record<string, unknown>[]): {
+    sessionId: string;
+    leaves: Record<string, unknown>[];
+    select: (leafId: string) => {
+        chain: Record<string, unknown>[];
+        missingParent: boolean;
+        chainHash: string;
+    };
+    branches: () => ClaudeBranch[];
+};
+//# sourceMappingURL=claude-branches.d.ts.map

package/dist/types/connected-evidence/sources/claude-branches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-branches.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/claude-branches.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5H,gFAAgF;AAChF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;;;qBAWjC,MAAM;;;;;oBAeT,YAAY,EAAE;EAYpC"}