@openpond/evals 0.11.21 → 0.12.0

package/dist/prepared-process-isolation.js

@@ -0,0 +1,131 @@
+/** Staged by the private verifier owner. Untrusted policy programs run with no
+ * capabilities as a different UID, outside the sealed private verifier tree.
+ * The parent must assess returned behavior; an exit code is never correctness. */
+export const PREPARED_PROCESS_ISOLATION_SOURCE = String.raw `
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomInt } from "node:crypto";
+
+const MAX_BYTES = 15 * 1024 * 1024, MAX_OUTPUT = 1024 * 1024;
+const usedUsers = new Set();
+const safePath = value => typeof value === "string" && value.length > 0 && value.length <= 2000
+  && !value.startsWith("/") && !/[\\\x00-\x1f\x7f]/.test(value)
+  && value.split("/").every(part => part && part !== "." && part !== ".." && !part.startsWith(".env"));
+
+/** files contain only public original/policy bytes and a public invocation
+ * adapter. Never stage independent assertions, expected answers or checkers. */
+export async function runPolicyProgram(input) {
+  const privateRoot = path.dirname(fileURLToPath(import.meta.url));
+  if (process.getuid?.() !== 0 || !path.basename(privateRoot).startsWith(".openpond-reward-verifier-"))
+    throw new Error("policy_process_isolation_runtime_unavailable");
+  if (!Array.isArray(input.files) || input.files.length < 1 || input.files.length > 100
+    || !safePath(input.entrypoint) || !input.files.some(file => file.path === input.entrypoint)
+    || !Number.isSafeInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 60000
+    || !Array.isArray(input.args ?? []) || (input.args ?? []).length > 100
+    || (input.args ?? []).some(arg => typeof arg !== "string" || arg.length > 2000 || arg.includes("\0")))
+    throw new Error("policy_process_isolation_input_invalid");
+  let total = 0;
+  const paths = new Set();
+  const files = input.files.map(file => {
+    if (!safePath(file.path) || paths.has(file.path) || typeof file.base64 !== "string")
+      throw new Error("policy_process_isolation_file_invalid");
+    paths.add(file.path);
+    const bytes = Buffer.from(file.base64, "base64");
+    if (bytes.toString("base64") !== file.base64) throw new Error("policy_process_isolation_file_invalid");
+    total += bytes.length;
+    if (total > MAX_BYTES) throw new Error("policy_process_isolation_file_limit");
+    return { path: file.path, bytes };
+  });
+  // Directory access seals request JSON, checker modules, helper source and
+  // private artifacts before any untrusted program can be spawned.
+  await fs.chmod(privateRoot, 0o700);
+  const stat = await fs.stat(privateRoot);
+  if (stat.uid !== 0 || (stat.mode & 0o777) !== 0o700) throw new Error("policy_process_private_tree_not_sealed");
+  for (const executable of ["/usr/bin/setsid", "/usr/bin/setpriv", "/usr/local/bin/bun"])
+    await fs.access(executable, 1);
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "openpond-policy-"));
+  let user;
+  do { user = randomInt(1000000, 2000000); } while (usedUsers.has(user));
+  usedUsers.add(user);
+  let child, timer, timedOut = false;
+  const kill = () => {
+    if (!child) return;
+    try { process.kill(-child.pid, "SIGKILL"); } catch {}
+    try { child.kill("SIGKILL"); } catch {}
+  };
+  try {
+    await fs.chmod(directory, 0o700);
+    await fs.chown(directory, user, user);
+    for (const file of files) {
+      const target = path.join(directory, file.path);
+      const parent = path.dirname(target);
+      await fs.mkdir(parent, { recursive: true, mode: 0o700 });
+      let current = parent;
+      while (current !== directory) {
+        await fs.chmod(current, 0o700); await fs.chown(current, user, user);
+        current = path.dirname(current);
+      }
+      await fs.writeFile(target, file.bytes, { mode: 0o600, flag: "wx" });
+      await fs.chown(target, user, user);
+    }
+    child = Bun.spawn(["/usr/bin/setsid", "/usr/bin/setpriv", "--reuid=" + user, "--regid=" + user, "--clear-groups",
+      "--no-new-privs", "--bounding-set=-all", "--inh-caps=-all", "--ambient-caps=-all",
+      "/usr/local/bin/bun", path.join(directory, input.entrypoint), ...(input.args ?? [])], {
+      cwd: directory, env: { PATH: "/usr/local/bin:/usr/bin:/bin", TMPDIR: directory }, stdout: "pipe", stderr: "pipe", stdin: "ignore",
+    });
+    timer = setTimeout(() => { timedOut = true; kill(); }, input.timeoutMs);
+    const read = async stream => {
+      const reader = stream.getReader(), chunks = [];
+      let bytes = 0;
+      try {
+        while (true) {
+          const item = await reader.read(); if (item.done) break;
+          bytes += item.value.byteLength;
+          if (bytes > MAX_OUTPUT) { kill(); throw new Error("policy_process_output_limit"); }
+          chunks.push(item.value);
+        }
+        return new TextDecoder("utf8", { fatal: true }).decode(Buffer.concat(chunks));
+      } finally { await reader.cancel(); reader.releaseLock(); }
+    };
+    const [stdout, stderr, exitCode] = await Promise.all([read(child.stdout), read(child.stderr), child.exited]);
+    return { stdout, stderr, exitCode, timedOut, isolation: { uid: user, gid: user, privateTreeSealed: true } };
+  } finally {
+    if (timer) clearTimeout(timer);
+    kill();
+    // A policy child can call setsid and escape its initial process group.
+    // Drain every process with this invocation's unique real UID before the
+    // next call; namespaces cannot grant a different outside UID or privilege.
+    try { await drainPolicyProcesses(user); }
+    finally { await fs.rm(directory, { recursive: true, force: true }); }
+  }
+}
+
+async function drainPolicyProcesses(user) {
+  const deadline = Date.now() + 2000;
+  let empty = 0;
+  while (Date.now() < deadline) {
+    const entries = (await fs.readdir("/proc")).filter(value => /^\d+$/.test(value));
+    if (entries.length > 10000) throw new Error("policy_process_inventory_limit");
+    let owned = 0;
+    for (const entry of entries) {
+      let status;
+      try { status = await fs.readFile("/proc/" + entry + "/status", "utf8"); }
+      catch (error) { if (["ENOENT", "ESRCH"].includes(error.code)) continue; throw error; }
+      const ids = /^Uid:\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)/m.exec(status);
+      if (ids && ids.slice(1).some(value => Number(value) === user)) {
+        // Zombies cannot fork, inspect a subsequent invocation or hold files.
+        if (/^State:\s+Z/m.test(status)) continue;
+        owned++;
+        try { process.kill(Number(entry), "SIGKILL"); }
+        catch (error) { if (error.code !== "ESRCH") throw error; }
+      }
+    }
+    empty = owned === 0 ? empty + 1 : 0;
+    if (empty >= 2) return;
+    await new Promise(resolve => setTimeout(resolve, 20));
+  }
+  throw new Error("policy_process_cleanup_unconfirmed");
+}
+`;

package/dist/rewards.js

@@ -4,7 +4,7 @@ import { ImmutableAssetRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema,
 import { gradeEvidence, GraderEvidenceSchema } from "./graders.js";
 import { CustomVerifierGraderSpecSchema, DeterministicGraderSpecSchema, GraderSpecSchema, HumanGraderSpecSchema, ModelJudgeGraderSpecSchema } from "./tasksets.js";
 import { assertBoundedTaskJson, validateTaskSchema } from "./task-schema.js";
-const bindingFields = { id: true, version: true, weight: true, hardGate: true, rewardEligible: true, privileged: true };
+const bindingFields = { taskIds: true, id: true, version: true, weight: true, hardGate: true, rewardEligible: true, privileged: true };
 export const FeedbackKeySchema = z.string().regex(/^[a-z][a-z0-9_]{0,79}$/);
 export function feedbackKeyForReward(reward) {
     return reward.feedbackKey ?? `reward_${contentHash(reward.id).slice(0, 24)}`;
@@ -49,6 +49,7 @@ export const RewardNormalizationSchema = z.discriminatedUnion("kind", [
 ]);
 export const RewardBindingSourceSchema = z.object({
     graderId: ReleaseIdSchema,
+    taskIds: z.array(ReleaseIdSchema).min(1).max(10_000).refine(ids => new Set(ids).size === ids.length, "Task scope must be unique.").optional(),
     reward: RewardReleaseRefSchema,
     role: z.enum(["training", "evaluation"]),
     normalization: RewardNormalizationSchema,
@@ -87,7 +88,7 @@ export const BoundRewardResultSchema = z.object({
     graderId: ReleaseIdSchema,
     reward: RewardReleaseRefSchema,
     role: z.enum(["training", "evaluation"]),
-    status: z.enum(["scored", "pending", "unavailable", "failed"]),
+    status: z.enum(["scored", "pending", "unavailable", "failed", "not_applicable"]),
     rawScore: z.number().finite().nullable(),
     normalizedScore: z.number().min(0).max(1).nullable(),
     passed: z.boolean().nullable(),
@@ -99,6 +100,7 @@ export const RewardCompositionContentSchema = z.object({
     schemaVersion: z.literal("openpond.rewardComposition.v1"),
     binding: RewardReleaseRefSchema,
     taskHash: ReleaseHashSchema,
+    taskId: ReleaseIdSchema.optional(),
     outputHash: ReleaseHashSchema,
     results: z.array(BoundRewardResultSchema).max(100),
     training: z.object({ status: z.enum(["scored", "pending", "unscorable", "not_configured"]), score: z.number().min(0).max(1).nullable(), passed: z.boolean().nullable() }).strict(),
@@ -149,6 +151,10 @@ export async function executeRewardBinding(input) {
     for (const { source, reward } of resolved) {
         input.signal?.throwIfAborted();
         const result = { graderId: source.graderId, reward: source.reward, role: source.role, status: "unavailable", rawScore: null, normalizedScore: null, passed: null, evidenceHashes: [], message: null };
+        if (source.taskIds && !source.taskIds.includes(input.task.id)) {
+            results.push({ ...result, status: "not_applicable" });
+            continue;
+        }
         try {
             if (reward.implementation.kind === "human") {
                 result.status = "pending";
@@ -183,11 +189,13 @@ export async function executeRewardBinding(input) {
         }
         results.push(BoundRewardResultSchema.parse(result));
     }
-    return composeBoundRewards({ binding: input.binding, taskHash: contentHash(input.task), outputHash: contentHash(input.evidence), results });
+    return composeBoundRewards({ binding: input.binding, ...(input.binding.sources.some(source => source.taskIds) ? { taskId: input.task.id } : {}), taskHash: contentHash(input.task), outputHash: contentHash(input.evidence), results });
 }
 export function composeBoundRewards(input) {
     const binding = RewardBindingSchema.parse(input.binding);
     assertRewardHash(binding);
+    if (binding.sources.some(source => source.taskIds) && !input.taskId)
+        throw new LearningDomainError("reward_task_scope_missing");
     const results = input.results.map((result) => BoundRewardResultSchema.parse(result));
     if (results.length !== binding.sources.length || new Set(results.map((result) => result.graderId)).size !== results.length)
         throw new LearningDomainError("reward_result_set_incomplete");
@@ -195,6 +203,9 @@ export function composeBoundRewards(input) {
         const result = results.find((candidate) => candidate.graderId === source.graderId);
         if (!result || contentHash(result.reward) !== contentHash(source.reward) || result.role !== source.role)
             throw new LearningDomainError("reward_result_binding_mismatch");
+        const applicable = !source.taskIds || source.taskIds.includes(input.taskId);
+        if (applicable === (result.status === "not_applicable") || !applicable && (result.graderEvidence || result.evidenceHashes.length || result.message !== null))
+            throw new LearningDomainError("reward_result_task_scope_mismatch");
         if (result.graderEvidence) {
             const { contentHash: evidenceHash, ...body } = result.graderEvidence;
             if (contentHash(body) !== evidenceHash || !result.evidenceHashes.includes(evidenceHash)
@@ -219,6 +230,7 @@ export function composeBoundRewards(input) {
         schemaVersion: "openpond.rewardComposition.v1",
         binding: { id: binding.id, revision: binding.revision, contentHash: binding.contentHash },
         taskHash: input.taskHash,
+        ...(input.taskId ? { taskId: input.taskId } : {}),
         outputHash: input.outputHash,
         results,
         training: aggregate("training"),
@@ -226,7 +238,7 @@ export function composeBoundRewards(input) {
     });
     return RewardCompositionSchema.parse({ ...content, contentHash: contentHash(content) });
     function aggregate(role) {
-        const selected = binding.sources.filter((source) => source.role === role).map((source) => ({ source, result: results.find((candidate) => candidate.graderId === source.graderId) }));
+        const selected = binding.sources.filter((source) => source.role === role && (!source.taskIds || source.taskIds.includes(input.taskId))).map((source) => ({ source, result: results.find((candidate) => candidate.graderId === source.graderId) }));
         if (!selected.length)
             return { status: "not_configured", score: null, passed: null };
         if (selected.some(({ source, result }) => source.required && result.status !== "scored" && result.status !== "pending"))
@@ -250,5 +262,5 @@ function withoutRewardHash(value) { const { contentHash: _hash, ...content } = v
 function compileSource(source, reward) {
     if (reward.implementation.kind === "learned_model")
         throw new LearningDomainError("learned_reward_requires_model_execution_adapter");
-    return GraderSpecSchema.parse({ ...reward.implementation, id: source.graderId, version: String(reward.revision), weight: source.weight, hardGate: source.hardGate, rewardEligible: source.role === "training", privileged: source.privileged });
+    return GraderSpecSchema.parse({ ...reward.implementation, ...(source.taskIds ? { taskIds: source.taskIds } : {}), id: source.graderId, version: String(reward.revision), weight: source.weight, hardGate: source.hardGate, rewardEligible: source.role === "training", privileged: source.privileged });
 }

package/dist/tasksets.js

@@ -28,6 +28,7 @@ export const EnvironmentContractSchema = z.object({
 }).strict();
 const GraderBaseSchema = z.object({
     id: ReleaseIdSchema,
+    taskIds: z.array(ReleaseIdSchema).min(1).max(10_000).refine(ids => new Set(ids).size === ids.length, "Grader task IDs must be unique.").optional(),
     version: z.string().trim().min(1).max(100),
     weight: z.number().nonnegative().max(1_000).default(1),
     hardGate: z.boolean().default(false),
@@ -120,6 +121,11 @@ export function validateTasksetRelease(input) {
             path: "environmentRelease",
         });
     }
+    const taskIds = new Set(taskset.tasks.map(task => task.id));
+    for (const grader of taskset.graders)
+        if (grader.taskIds?.some(id => !taskIds.has(id))) {
+            issues.push({ code: "grader_task_missing", severity: "error", message: `Grader ${grader.id} refers to a task outside this release.`, path: "graders" });
+        }
     const clusterSplits = new Map();
     for (const task of taskset.tasks) {
         if (taskset.metrics?.aggregation === "weighted_mean" && !Object.hasOwn(taskset.metrics.taskWeights, task.id)) {

package/dist/types/builtin-benchmarks/harness-refiner.d.ts

@@ -73,6 +73,7 @@ export declare const harnessRefinerBenchmarkRelease: {
         privileged: boolean;
         kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
         config: Record<string, unknown>;
+        taskIds?: string[] | undefined;
     } | {
         id: string;
         version: string;
@@ -90,6 +91,7 @@ export declare const harnessRefinerBenchmarkRelease: {
             visibility: "policy" | "verifier" | "host_private";
         };
         calibrationStatus: "pending" | "passed" | "failed";
+        taskIds?: string[] | undefined;
         model?: {
             providerId: string;
             modelId: string;
@@ -114,6 +116,7 @@ export declare const harnessRefinerBenchmarkRelease: {
         };
         timeoutMs: number;
         networkPolicy: "none";
+        taskIds?: string[] | undefined;
         runtime?: "isolated_javascript" | "sandbox_process" | undefined;
         exportName?: string | undefined;
     } | {
@@ -133,6 +136,7 @@ export declare const harnessRefinerBenchmarkRelease: {
             visibility: "policy" | "verifier" | "host_private";
         };
         reviewerRole: string;
+        taskIds?: string[] | undefined;
         form?: {
             schemaVersion: "openpond.humanForm.v1";
             mode: "individual" | "pairwise";

package/dist/types/builtin-benchmarks/harness-refiner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harness-refiner.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-benchmarks/harness-refiner.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqqD1C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASzE,CAAC"}
+{"version":3,"file":"harness-refiner.d.ts","sourceRoot":"","sources":["../../../../../src/builtin-benchmarks/harness-refiner.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqqD1C,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CASzE,CAAC"}

package/dist/types/conformance.d.ts

@@ -183,6 +183,7 @@ export declare const genericToolConformance: {
             privileged: boolean;
             kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
             config: Record<string, unknown>;
+            taskIds?: string[] | undefined;
         } | {
             id: string;
             version: string;
@@ -200,6 +201,7 @@ export declare const genericToolConformance: {
                 visibility: "policy" | "verifier" | "host_private";
             };
             calibrationStatus: "pending" | "passed" | "failed";
+            taskIds?: string[] | undefined;
             model?: {
                 providerId: string;
                 modelId: string;
@@ -224,6 +226,7 @@ export declare const genericToolConformance: {
             };
             timeoutMs: number;
             networkPolicy: "none";
+            taskIds?: string[] | undefined;
             runtime?: "isolated_javascript" | "sandbox_process" | undefined;
             exportName?: string | undefined;
         } | {
@@ -243,6 +246,7 @@ export declare const genericToolConformance: {
                 visibility: "policy" | "verifier" | "host_private";
             };
             reviewerRole: string;
+            taskIds?: string[] | undefined;
             form?: {
                 schemaVersion: "openpond.humanForm.v1";
                 mode: "individual" | "pairwise";
@@ -568,6 +572,7 @@ export declare const marketingPortfolioConformance: {
             privileged: boolean;
             kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
             config: Record<string, unknown>;
+            taskIds?: string[] | undefined;
         } | {
             id: string;
             version: string;
@@ -585,6 +590,7 @@ export declare const marketingPortfolioConformance: {
                 visibility: "policy" | "verifier" | "host_private";
             };
             calibrationStatus: "pending" | "passed" | "failed";
+            taskIds?: string[] | undefined;
             model?: {
                 providerId: string;
                 modelId: string;
@@ -609,6 +615,7 @@ export declare const marketingPortfolioConformance: {
             };
             timeoutMs: number;
             networkPolicy: "none";
+            taskIds?: string[] | undefined;
             runtime?: "isolated_javascript" | "sandbox_process" | undefined;
             exportName?: string | undefined;
         } | {
@@ -628,6 +635,7 @@ export declare const marketingPortfolioConformance: {
                 visibility: "policy" | "verifier" | "host_private";
             };
             reviewerRole: string;
+            taskIds?: string[] | undefined;
             form?: {
                 schemaVersion: "openpond.humanForm.v1";
                 mode: "individual" | "pairwise";

package/dist/types/conformance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../../../src/conformance.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}
+{"version":3,"file":"conformance.d.ts","sourceRoot":"","sources":["../../../../src/conformance.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEjC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGxC,CAAC"}

package/dist/types/connected-evidence/codex-command-observations.d.ts

@@ -0,0 +1,15 @@
+/** Interpret recorded syntax, never execute source code. Only sequential static
+ * exec_command calls have an unambiguous correspondence with retained results. */
+export declare function recordedCodexCommands(source: string): {
+    cmd: string;
+    maxOutputTokens: number;
+    cwd: string | null;
+}[];
+/** This deliberately bounded read-only prefix establishes that no earlier
+ * recorded command modified the checkout before the status observation. */
+export declare function isRecordedReadOnlyInventory(cmd: string): boolean;
+export declare function recordedCodexCommandResults(value: unknown, count: number): {
+    output: string;
+    originalTokenCount: number;
+}[];
+//# sourceMappingURL=codex-command-observations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codex-command-observations.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/codex-command-observations.ts"],"names":[],"mappings":"AAcA;kFACkF;AAClF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM;SAGrB,MAAM;qBAAmB,MAAM;SAAO,MAAM,GAAG,IAAI;IAiCjF;AAED;2EAC2E;AAC3E,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,WAEtD;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM;;;IAkBxE"}

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

@@ -111,6 +111,18 @@ export declare const ConnectedBoundarySchema: z.ZodObject<{
         gaps: z.ZodArray<z.ZodString>;
     }, z.core.$strict>;
 }, z.core.$strict>;
+/** Source-reported repository identity is reconstruction evidence, not an
+ * admitted checkout or proof that the working tree was clean. */
+export declare const ConnectedRepositoryContextSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.connectedRepositoryContext.v1">;
+    kind: z.ZodLiteral<"git">;
+    commitHash: z.ZodString;
+    branch: z.ZodNullable<z.ZodString>;
+    recordedAt: z.ZodNullable<z.ZodString>;
+    sourceFileHash: z.ZodString;
+    metadataHash: z.ZodString;
+    workingDirectoryHash: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 export declare const ConnectedSessionSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.connectedEvidence.v1">;
     normalizerVersion: z.ZodLiteral<"connected-evidence-1">;
@@ -134,6 +146,16 @@ export declare const ConnectedSessionSchema: z.ZodObject<{
         machineId: z.ZodString;
         sourceInstanceId: z.ZodString;
     }, z.core.$strict>>;
+    repositoryContext: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.connectedRepositoryContext.v1">;
+        kind: z.ZodLiteral<"git">;
+        commitHash: z.ZodString;
+        branch: z.ZodNullable<z.ZodString>;
+        recordedAt: z.ZodNullable<z.ZodString>;
+        sourceFileHash: z.ZodString;
+        metadataHash: z.ZodString;
+        workingDirectoryHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     sourceFiles: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         contentHash: z.ZodString;

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;;;;;;;;;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"}
+{"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;iEACiE;AACjE,eAAO,MAAM,gCAAgC;;;;;;;;;kBASlC,CAAC;AACZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWxB,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/git-file-contracts.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+/** A Git object proof pins bytes to recorded history. It does not establish
+ * that the historical working tree was clean or that these are all dependencies. */
+export declare const ConnectedGitFileProofSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.connectedGitFileProof.v1">;
+    path: z.ZodString;
+    commit: z.ZodObject<{
+        hash: z.ZodString;
+        base64: z.ZodString;
+    }, z.core.$strict>;
+    trees: z.ZodArray<z.ZodObject<{
+        hash: z.ZodString;
+        base64: z.ZodString;
+    }, z.core.$strict>>;
+    contentsBase64: z.ZodString;
+}, z.core.$strict>;
+export type ConnectedGitFileProof = z.infer<typeof ConnectedGitFileProofSchema>;
+//# sourceMappingURL=git-file-contracts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"git-file-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/git-file-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB;oFACoF;AACpF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;kBAM7B,CAAC;AACZ,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/types/connected-evidence/git-file-proof.d.ts

@@ -0,0 +1,13 @@
+export * from "./git-file-contracts.js";
+/** The caller must supply repositoryContext from an authorized, hash-verified
+ * connected snapshot. No filesystem access or caller-selected Git command occurs. */
+export declare function verifyConnectedGitFileProof(repositoryContext: unknown, raw: unknown): {
+    path: string;
+    commitHash: string;
+    gitObjectHash: string;
+    mode: string;
+    sizeBytes: number;
+    sha256: string;
+    contentsBase64: string;
+};
+//# sourceMappingURL=git-file-proof.d.ts.map

package/dist/types/connected-evidence/git-file-proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-file-proof.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/git-file-proof.ts"],"names":[],"mappings":"AAEA,cAAc,yBAAyB,CAAC;AAoCxC;qFACqF;AACrF,wBAAgB,2BAA2B,CAAC,iBAAiB,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO;;;;;;;;EAwCnF"}

package/dist/types/connected-evidence/git-starting-state.d.ts

@@ -0,0 +1,28 @@
+/** Verify only the original first-tool boundary. Later requests need their own
+ * captured state. Both the repository context and observations come from the
+ * authorized immutable snapshot, never caller-supplied cleanliness claims. */
+export declare function verifyConnectedGitStartingAssets(input: {
+    session: unknown;
+    boundaryId: string;
+    proofs: unknown[];
+}): {
+    schemaVersion: "openpond.connectedGitStartingAssets.v1";
+    sessionHash: string;
+    boundaryId: string;
+    inputHash: string;
+    revisionHash: string;
+    commitHash: string;
+    observationHash: string;
+    selectedPathsUnmodified: true;
+    dependencyClosureQualified: false;
+    assets: {
+        path: string;
+        commitHash: string;
+        gitObjectHash: string;
+        mode: string;
+        sizeBytes: number;
+        sha256: string;
+        contentsBase64: string;
+    }[];
+};
+//# sourceMappingURL=git-starting-state.d.ts.map

package/dist/types/connected-evidence/git-starting-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-starting-state.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/git-starting-state.ts"],"names":[],"mappings":"AA2BA;;8EAE8E;AAC9E,wBAAgB,gCAAgC,CAAC,KAAK,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE;;;;;;;;;;;;;;;;;;;EAiDlH"}

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

@@ -0,0 +1,3 @@
+export * from "./git-file-proof.js";
+export * from "./git-starting-state.js";
+//# sourceMappingURL=git.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/git.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC"}

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,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"}
+{"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,CAiJrB"}

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

@@ -4,4 +4,5 @@ export * from "./imports.js";
 export * from "./usage-summary.js";
 export * from "./python-correctness.js";
 export * from "./collector-coverage-contracts.js";
+export * from "./git-file-contracts.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/connected-evidence/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,yBAAyB,CAAC"}

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

@@ -24,6 +24,7 @@ export declare function normalizeConnectedSession(input: {
         machineId: string;
         sourceInstanceId: string;
     };
+    repositoryContext?: ConnectedSession["repositoryContext"];
 }): 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,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"}
+{"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;IACjG,iBAAiB,CAAC,EAAE,gBAAgB,CAAC,mBAAmB,CAAC,CAAC;CAC3D,GAAG,gBAAgB,CAwDnB;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-code.d.ts

@@ -74,5 +74,15 @@ export declare function parseClaudeSession(file: ConnectedFile, rows: Record<str
         machineId: string;
         sourceInstanceId: string;
     } | undefined;
+    repositoryContext?: {
+        schemaVersion: "openpond.connectedRepositoryContext.v1";
+        kind: "git";
+        commitHash: string;
+        branch: string | null;
+        recordedAt: string | null;
+        sourceFileHash: string;
+        metadataHash: string;
+        workingDirectoryHash?: string | undefined;
+    } | 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":"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"}
+{"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-metadata.d.ts

@@ -0,0 +1,10 @@
+/** Forked Codex rollouts retain their own header followed by ancestor headers.
+ * Only the declared, contiguous ancestry is metadata for that source. */
+export declare class CodexMetadataChain {
+    metadata: Record<string, unknown> | null;
+    private parentId;
+    private closed;
+    private readonly ids;
+    accept(row: Record<string, unknown>): boolean;
+}
+//# sourceMappingURL=codex-metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codex-metadata.d.ts","sourceRoot":"","sources":["../../../../../../src/connected-evidence/sources/codex-metadata.ts"],"names":[],"mappings":"AAAA;yEACyE;AACzE,qBAAa,kBAAkB;IAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAQ;IAChD,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqB;IAEzC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;CAgB9C"}

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

@@ -74,5 +74,15 @@ export declare function parseCodexSession(file: ConnectedFile, rows: Record<stri
         machineId: string;
         sourceInstanceId: string;
     } | undefined;
+    repositoryContext?: {
+        schemaVersion: "openpond.connectedRepositoryContext.v1";
+        kind: "git";
+        commitHash: string;
+        branch: string | null;
+        recordedAt: string | null;
+        sourceFileHash: string;
+        metadataHash: string;
+        workingDirectoryHash?: string | undefined;
+    } | 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;AAKrE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCrF"}
+{"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;AAMrE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8CrF"}

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

@@ -75,5 +75,15 @@ export declare function parseGrokBuildSession(file: ConnectedFile, rows: Record<
         machineId: string;
         sourceInstanceId: string;
     } | undefined;
+    repositoryContext?: {
+        schemaVersion: "openpond.connectedRepositoryContext.v1";
+        kind: "git";
+        commitHash: string;
+        branch: string | null;
+        recordedAt: string | null;
+        sourceFileHash: string;
+        metadataHash: string;
+        workingDirectoryHash?: string | undefined;
+    } | undefined;
 };
 //# sourceMappingURL=grok-build.d.ts.map

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

@@ -1 +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"}
+{"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"}