@openpond/evals 0.11.18 → 0.11.19

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/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;;;;;;;;;CACuF,CAAC;AAK9H,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;
@@ -15,5 +17,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,CAAA;KAAE,EAAE,CAAC;CAC7C,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,CA+IrB"}

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

@@ -17,6 +17,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,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,CAqDnB;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"}

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"}

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

@@ -2,7 +2,7 @@ import type { ConnectedFile } from "../contracts.js";
 export declare function parseClaudeSession(file: ConnectedFile, rows: Record<string, unknown>[], leafId?: string): {
     schemaVersion: "openpond.connectedEvidence.v1";
     normalizerVersion: "connected-evidence-1";
-    origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code";
+    origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
     sessionId: string;
     branchId: string | null;
     parentSessionId: string | null;
@@ -70,5 +70,9 @@ export declare function parseClaudeSession(file: ConnectedFile, rows: Record<str
     }[];
     warnings: string[];
     contentHash: string;
+    acquisition?: {
+        machineId: string;
+        sourceInstanceId: string;
+    } | undefined;
 };
 //# sourceMappingURL=claude-code.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/claude-code.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkDvG"}
+{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/claude-code.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCvG"}

package/dist/types/connected-evidence/sources/codex-authorization.d.ts

@@ -0,0 +1,18 @@
+export declare const CODEX_AUTHORIZATION_PROJECTION_POLICY = "codex-native-authorization-v1";
+declare const POLICY = "codex-native-authorization-v1";
+type Omission = {
+    policy: typeof POLICY;
+    sourcePath: string;
+    sourceHash: string;
+    entries: number | null;
+};
+/** Native approved-command rules are account authority, not observed tool calls.
+ * Retain all other context and the original file/event identity. Unknown formats
+ * remain untouched for ordinary privacy admission; this is not secret scrubbing.
+ */
+export declare function projectCodexAuthorization(row: Record<string, unknown>): {
+    row: Record<string, unknown>;
+    omissions: Omission[];
+};
+export {};
+//# sourceMappingURL=codex-authorization.d.ts.map

package/dist/types/connected-evidence/sources/codex-authorization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-authorization.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/codex-authorization.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qCAAqC,kCAAkC,CAAC;AACrF,QAAA,MAAM,MAAM,kCAAwC,CAAC;AACrD,KAAK,QAAQ,GAAG;IAAE,MAAM,EAAE,OAAO,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE1G;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;EAqCrE"}

package/dist/types/connected-evidence/sources/codex.d.ts

@@ -2,7 +2,7 @@ import type { ConnectedFile } from "../contracts.js";
 export declare function parseCodexSession(file: ConnectedFile, rows: Record<string, unknown>[]): {
     schemaVersion: "openpond.connectedEvidence.v1";
     normalizerVersion: "connected-evidence-1";
-    origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code";
+    origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
     sessionId: string;
     branchId: string | null;
     parentSessionId: string | null;
@@ -70,5 +70,9 @@ export declare function parseCodexSession(file: ConnectedFile, rows: Record<stri
     }[];
     warnings: string[];
     contentHash: string;
+    acquisition?: {
+        machineId: string;
+        sourceInstanceId: string;
+    } | undefined;
 };
 //# sourceMappingURL=codex.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/codex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCrF"}
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/codex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKrE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCrF"}

package/dist/types/connected-evidence/sources/grok-build.d.ts

@@ -0,0 +1,79 @@
+import type { ConnectedFile } from "../contracts.js";
+/** Retained ACP updates are native Grok history; Markdown exports are not accepted. */
+export declare function parseGrokBuildSession(file: ConnectedFile, rows: Record<string, unknown>[]): {
+    schemaVersion: "openpond.connectedEvidence.v1";
+    normalizerVersion: "connected-evidence-1";
+    origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code" | "opencode" | "grok_build" | "pi" | "oh_my_pi";
+    sessionId: string;
+    branchId: string | null;
+    parentSessionId: string | null;
+    exporterVersion: string | null;
+    sourceFiles: {
+        path: string;
+        contentHash: string;
+        sizeBytes: number;
+    }[];
+    events: {
+        id: string;
+        sequence: number;
+        occurredAt: string | null;
+        kind: "message" | "unknown" | "artifact" | "terminal" | "usage" | "tool_call" | "tool_result" | "compaction";
+        role: "user" | "tool" | "assistant" | "system" | null;
+        callId: string | null;
+        parentId: string | null;
+        content: import("zod").JSONType;
+        usage: {
+            invocationId: string;
+            inputTokens: number | null;
+            outputTokens: number | null;
+            cachedInputTokens: number | null;
+            totalTokens: number | null;
+            provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+        } | null;
+    }[];
+    unmappedEvents: {
+        id: string;
+        sequence: number;
+        occurredAt: string | null;
+        kind: "message" | "unknown" | "artifact" | "terminal" | "usage" | "tool_call" | "tool_result" | "compaction";
+        role: "user" | "tool" | "assistant" | "system" | null;
+        callId: string | null;
+        parentId: string | null;
+        content: import("zod").JSONType;
+        usage: {
+            invocationId: string;
+            inputTokens: number | null;
+            outputTokens: number | null;
+            cachedInputTokens: number | null;
+            totalTokens: number | null;
+            provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+        } | null;
+    }[];
+    boundaries: {
+        id: string;
+        familyKey: string;
+        projection: "turn" | "conversation";
+        requestEventId: string;
+        start: number;
+        end: number;
+        inputHash: string;
+        outputHash: string | null;
+        revisionHash: string;
+        terminal: "unknown" | "cancelled" | "failed" | "completed";
+        coverage: {
+            answer: boolean;
+            context: "unknown" | "retained" | "compacted";
+            process: "absent" | "partial" | "retained";
+            artifacts: "absent" | "retained" | "references_only";
+            replay: "unavailable";
+            gaps: string[];
+        };
+    }[];
+    warnings: string[];
+    contentHash: string;
+    acquisition?: {
+        machineId: string;
+        sourceInstanceId: string;
+    } | undefined;
+};
+//# sourceMappingURL=grok-build.d.ts.map

package/dist/types/connected-evidence/sources/grok-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok-build.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/grok-build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,iBAAiB,CAAC;AASrE,uFAAuF;AACvF,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4JhC"}