openpond-sdk 0.11.4 → 0.11.6

package/dist/{chunk-YTGRET2L.js → chunk-7GA57BEJ.js}

@@ -1,94 +1,50 @@
 import {
+  AgentImportCommitRequestSchema,
+  AgentImportPreviewRequestSchema,
+  AgentImportUploadPartSchema,
+  ConnectedCaptureRequestSchema,
+  ConnectedCaseRefSchema,
+  ConnectedSourceSummarySchema,
   DatasetWorkspaceReceiptSchema
-} from "./chunk-HKAR3VPB.js";
+} from "./chunk-ILXO64IV.js";
 import {
   fetchConnectedJson
 } from "./chunk-T4APHDES.js";
 import {
   ImmutableReleaseRefSchema,
   contentHash
-} from "./chunk-QUOW6URQ.js";
-
-// src/connected-evidence-contracts.ts
-import { z } from "zod";
-import { ConnectedSourceKindSchema, ConnectedBoundarySchema, ConnectedUsageSummarySchema, CONNECTED_EVIDENCE_LIMITS } from "@openpond/evals/connected-evidence";
-var Id = z.string().trim().min(1).max(500);
-var Hash = z.string().regex(/^[a-f0-9]{64}$/);
-var ConnectedScopeSchema = z.object({ teamId: Id, ownerUserId: Id }).strict();
-var ConnectedCaseRefSchema = z.object({ id: Id, snapshotHash: Hash, boundaryId: Id, boundaryRevisionHash: Hash }).strict();
-var ConnectedSourceSummarySchema = z.object({
-  sourceId: Id,
-  source: ConnectedSourceKindSchema,
-  sessionId: Id,
-  snapshotHash: Hash,
-  title: z.string().max(500),
-  projectId: Id.nullable(),
-  capturedAt: z.string().datetime(),
-  boundaries: z.array(ConnectedBoundarySchema.omit({ start: true, end: true })).max(CONNECTED_EVIDENCE_LIMITS.boundaries)
-}).strict();
-var ConnectedCaptureRequestSchema = z.object({
-  operationId: Id,
-  conversationId: Id.optional(),
-  cursor: Id.optional(),
-  limit: z.number().int().min(1).max(50).default(20)
-}).strict();
-var AgentImportUploadRefSchema = z.object({ hash: Hash, parts: z.number().int().min(1).max(1500) }).strict();
-var AgentImportUploadPartSchema = AgentImportUploadRefSchema.extend({ index: z.number().int().nonnegative().max(1499), base64: z.string().max(35e4) }).strict();
-var AgentImportFileSchema = z.object({ path: z.string().min(1).max(500), encoding: z.enum(["utf8", "zstd"]), base64: z.string() }).strict();
-var AgentImportPreviewRequestSchema = z.object({
-  upload: AgentImportUploadRefSchema,
-  source: z.enum(["codex", "claude_code", "hermes", "openclaw", "opencode", "grok_build", "pi", "oh_my_pi"]),
-  branchLeafId: Id.optional(),
-  acquisition: z.object({ machineId: Id, sourceInstanceId: Id }).strict().optional(),
-  destination: z.discriminatedUnion("kind", [
-    z.object({ kind: z.literal("existing"), projectId: Id }).strict(),
-    z.object({ kind: z.literal("new"), name: z.string().trim().min(1).max(200) }).strict()
-  ])
-}).strict();
-var AgentImportCommitRequestSchema = AgentImportPreviewRequestSchema.extend({
-  operationId: Id,
-  previewHash: Hash,
-  selection: z.array(z.object({ sessionHash: Hash, boundaryIds: z.array(Id).min(1).max(CONNECTED_EVIDENCE_LIMITS.boundaries) }).strict()).min(1).max(CONNECTED_EVIDENCE_LIMITS.sessions)
-}).strict();
-var ConnectedHomeQuerySchema = z.object({ from: z.string().datetime(), to: z.string().datetime(), projectId: Id.optional() }).strict();
-var ConnectedHomeSummarySchema = z.object({
-  teamId: Id,
-  range: ConnectedHomeQuerySchema,
-  activity: z.object({ conversations: z.number().int().nonnegative(), turns: z.number().int().nonnegative(), chatTurns: z.number().int().nonnegative(), workTurns: z.number().int().nonnegative() }).strict(),
-  accounting: z.object({ contextSnapshots: z.number().int().nonnegative() }).strict(),
-  usage: ConnectedUsageSummarySchema
-}).strict();
+} from "./chunk-COPVBJPL.js";
 
 // src/connected-recorded-execution.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 import { ExperimentManifestSchema } from "@openpond/evals/experiments";
 import { TaskRecordSchema } from "@openpond/evals/tasksets";
-var Id2 = z2.string().min(1).max(200);
-var Hash2 = z2.string().regex(/^[a-f0-9]{64}$/);
-var ConnectedRecordedExecutionRequestSchema = z2.object({
-  operationId: Id2,
-  name: z2.string().trim().min(1).max(500),
-  projectId: Id2,
-  dataset: ImmutableReleaseRefSchema.extend({ revision: z2.number().int().positive() }).strict(),
-  caseIds: z2.array(Id2).min(1).max(1e4)
+var Id = z.string().min(1).max(200);
+var Hash = z.string().regex(/^[a-f0-9]{64}$/);
+var ConnectedRecordedExecutionRequestSchema = z.object({
+  operationId: Id,
+  name: z.string().trim().min(1).max(500),
+  projectId: Id,
+  dataset: ImmutableReleaseRefSchema.extend({ revision: z.number().int().positive() }).strict(),
+  caseIds: z.array(Id).min(1).max(1e4)
 }).strict().superRefine((value, ctx) => {
   if (new Set(value.caseIds).size !== value.caseIds.length) ctx.addIssue({ code: "custom", message: "Select each case once." });
 });
 var ConnectedRecordedSourceSchema = ConnectedCaseRefSchema.extend({
-  inputHash: Hash2,
-  outputHash: Hash2.nullable(),
+  inputHash: Hash,
+  outputHash: Hash.nullable(),
   task: TaskRecordSchema,
-  taskHash: Hash2
+  taskHash: Hash
 }).strict();
-var ConnectedRecordedExecutionSchema = z2.object({
-  schemaVersion: z2.literal("openpond.connectedRecordedExecution.v1"),
-  id: Id2,
-  teamId: Id2,
-  ownerUserId: Id2,
+var ConnectedRecordedExecutionSchema = z.object({
+  schemaVersion: z.literal("openpond.connectedRecordedExecution.v1"),
+  id: Id,
+  teamId: Id,
+  ownerUserId: Id,
   request: ConnectedRecordedExecutionRequestSchema,
   manifest: ExperimentManifestSchema,
-  sources: z2.array(ConnectedRecordedSourceSchema).min(1).max(1e4),
-  contentHash: Hash2
+  sources: z.array(ConnectedRecordedSourceSchema).min(1).max(1e4),
+  contentHash: Hash
 }).strict();
 function verifyConnectedRecordedExecution(raw) {
   const value = ConnectedRecordedExecutionSchema.parse(raw), { contentHash: actual, ...body } = value;
@@ -97,62 +53,62 @@ function verifyConnectedRecordedExecution(raw) {
     throw new Error("Recorded execution identity or population integrity failed.");
   return value;
 }
-var ConnectedRecordedListRequestSchema = z2.object({ projectId: Id2.optional(), cursor: Id2.optional(), limit: z2.number().int().min(1).max(50).default(20) }).strict();
-var ConnectedRecordedSummarySchema = z2.object({
-  id: Id2,
-  teamId: Id2,
-  ownerUserId: Id2,
-  projectId: Id2,
-  name: z2.string().min(1).max(500),
+var ConnectedRecordedListRequestSchema = z.object({ projectId: Id.optional(), cursor: Id.optional(), limit: z.number().int().min(1).max(50).default(20) }).strict();
+var ConnectedRecordedSummarySchema = z.object({
+  id: Id,
+  teamId: Id,
+  ownerUserId: Id,
+  projectId: Id,
+  name: z.string().min(1).max(500),
   dataset: ConnectedRecordedExecutionRequestSchema.shape.dataset,
-  manifestHash: Hash2,
-  contentHash: Hash2,
-  caseCount: z2.number().int().min(1).max(1e4),
-  createdAt: z2.string().datetime()
+  manifestHash: Hash,
+  contentHash: Hash,
+  caseCount: z.number().int().min(1).max(1e4),
+  createdAt: z.string().datetime()
 }).strict();
-var ConnectedRecordedListSchema = z2.object({ teamId: Id2, items: z2.array(ConnectedRecordedSummarySchema).max(50), nextCursor: Id2.nullable() }).strict();
+var ConnectedRecordedListSchema = z.object({ teamId: Id, items: z.array(ConnectedRecordedSummarySchema).max(50), nextCursor: Id.nullable() }).strict();
 
 // src/connected-evidence-client.ts
-import { z as z5 } from "zod";
-import { ConnectedBoundarySchema as ConnectedBoundarySchema2, ConnectedEventSchema, ConnectedUsageSummarySchema as ConnectedUsageSummarySchema2 } from "@openpond/evals/connected-evidence";
+import { z as z4 } from "zod";
+import { ConnectedBoundarySchema, ConnectedEventSchema, ConnectedUsageSummarySchema } from "@openpond/evals/connected-evidence";
 
 // src/connected-dataset-publication.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 import { RewardReleaseRefSchema } from "@openpond/evals/rewards";
-var ConnectedDatasetPublicationSchema = z3.object({
-  datasetId: z3.string().trim().min(1).max(240),
-  expectedRevision: z3.number().int().positive(),
-  operationId: z3.string().trim().min(1).max(240),
-  graders: z3.array(RewardReleaseRefSchema).min(1).max(100).optional()
+var ConnectedDatasetPublicationSchema = z2.object({
+  datasetId: z2.string().trim().min(1).max(240),
+  expectedRevision: z2.number().int().positive(),
+  operationId: z2.string().trim().min(1).max(240),
+  graders: z2.array(RewardReleaseRefSchema).min(1).max(100).optional()
 }).strict().superRefine((request, context) => {
   if (request.graders && new Set(request.graders.map((ref) => ref.id)).size !== request.graders.length)
     context.addIssue({ code: "custom", path: ["graders"], message: "Choose one exact revision of each grader." });
 });
 
 // src/connected-collection-status.ts
-import { z as z4 } from "zod";
-var Id3 = z4.string().min(1).max(500);
-var Count = z4.number().int().nonnegative();
-var ConnectedCollectionStatusSchema = z4.object({
-  teamId: Id3,
-  ownerUserId: Id3,
-  projectId: Id3.nullable(),
-  status: z4.enum(["active", "paused", "archived"]),
+import { z as z3 } from "zod";
+var Id2 = z3.string().min(1).max(500);
+var Count = z3.number().int().nonnegative();
+var ConnectedCollectionStatusSchema = z3.object({
+  teamId: Id2,
+  ownerUserId: Id2,
+  projectId: Id2.nullable(),
+  status: z3.enum(["active", "paused", "archived"]),
   revision: Count,
-  state: z4.enum(["collecting", "pending", "attention", "paused", "archived"]),
-  lastReconciledAt: z4.string().datetime().nullable(),
-  lastCapturedAt: z4.string().datetime().nullable(),
-  historyDays: z4.number().int().positive(),
+  state: z3.enum(["collecting", "pending", "attention", "paused", "archived"]),
+  lastReconciledAt: z3.string().datetime().nullable(),
+  lastCapturedAt: z3.string().datetime().nullable(),
+  historyDays: z3.number().int().positive(),
   sources: Count,
   tasks: Count,
-  datasets: z4.array(z4.object({
-    datasetId: Id3,
-    projection: z4.enum(["turn", "conversation"]),
+  datasets: z3.array(z3.object({
+    datasetId: Id2,
+    projection: z3.enum(["turn", "conversation"]),
     revision: Count
   }).strict()).max(2),
-  latestBatch: z4.object({
-    operationId: Id3,
-    updatedAt: z4.string().datetime(),
+  latestBatch: z3.object({
+    operationId: Id2,
+    updatedAt: z3.string().datetime(),
     scanned: Count,
     captured: Count,
     unchanged: Count,
@@ -160,85 +116,85 @@ var ConnectedCollectionStatusSchema = z4.object({
     failed: Count,
     excluded: Count,
     paused: Count,
-    hasMore: z4.boolean()
+    hasMore: z3.boolean()
   }).strict().nullable()
 }).strict();
 
 // src/connected-evidence-client.ts
-var Id4 = z5.string().min(1).max(500);
-var Hash3 = z5.string().regex(/^[a-f0-9]{64}$/);
-var ConnectedCollectionSchema = z5.object({ teamId: Id4, projectId: Id4.nullable(), status: z5.enum(["active", "paused", "archived"]), revision: z5.number().int().nonnegative() }).strict();
-var ConnectedCaptureReceiptSchema = z5.object({
-  teamId: Id4,
-  operationId: Id4,
-  projectId: Id4.nullable(),
-  outcomes: z5.array(z5.object({
-    conversationId: Id4,
-    state: z5.enum(["captured", "unchanged", "pending", "paused", "excluded", "failed"]),
-    sourceId: Id4.optional(),
-    snapshotHash: Hash3.optional(),
-    reason: z5.string().optional()
+var Id3 = z4.string().min(1).max(500);
+var Hash2 = z4.string().regex(/^[a-f0-9]{64}$/);
+var ConnectedCollectionSchema = z4.object({ teamId: Id3, projectId: Id3.nullable(), status: z4.enum(["active", "paused", "archived"]), revision: z4.number().int().nonnegative() }).strict();
+var ConnectedCaptureReceiptSchema = z4.object({
+  teamId: Id3,
+  operationId: Id3,
+  projectId: Id3.nullable(),
+  outcomes: z4.array(z4.object({
+    conversationId: Id3,
+    state: z4.enum(["captured", "unchanged", "pending", "paused", "excluded", "failed"]),
+    sourceId: Id3.optional(),
+    snapshotHash: Hash2.optional(),
+    reason: z4.string().optional()
   }).strict()).max(50),
-  nextCursor: Id4.nullable()
+  nextCursor: Id3.nullable()
 }).strict();
-var ConnectedCaseReadbackSchema = z5.object({
-  teamId: Id4,
+var ConnectedCaseReadbackSchema = z4.object({
+  teamId: Id3,
   ref: ConnectedCaseRefSchema,
   origin: ConnectedSourceSummarySchema.shape.source,
-  sessionId: Id4,
-  projectId: Id4,
-  capturedAt: z5.string().datetime(),
-  unmappedEvidence: z5.object({ count: z5.number().int().nonnegative().max(1e5), contentHash: Hash3 }).strict(),
-  evidence: z5.object({ input: z5.array(ConnectedEventSchema), observed: z5.array(ConnectedEventSchema), answer: z5.json(), boundary: ConnectedBoundarySchema2 }).strict()
+  sessionId: Id3,
+  projectId: Id3,
+  capturedAt: z4.string().datetime(),
+  unmappedEvidence: z4.object({ count: z4.number().int().nonnegative().max(1e5), contentHash: Hash2 }).strict(),
+  evidence: z4.object({ input: z4.array(ConnectedEventSchema), observed: z4.array(ConnectedEventSchema), answer: z4.json(), boundary: ConnectedBoundarySchema }).strict()
 }).strict();
-var ConnectedUnmappedEventsSchema = z5.object({
-  teamId: Id4,
-  sourceId: Id4,
-  snapshotHash: Hash3,
-  contentHash: Hash3,
-  count: z5.number().int().nonnegative(),
-  offset: z5.number().int().nonnegative(),
-  events: z5.array(ConnectedEventSchema).max(50),
-  nextOffset: z5.number().int().nonnegative().nullable()
+var ConnectedUnmappedEventsSchema = z4.object({
+  teamId: Id3,
+  sourceId: Id3,
+  snapshotHash: Hash2,
+  contentHash: Hash2,
+  count: z4.number().int().nonnegative(),
+  offset: z4.number().int().nonnegative(),
+  events: z4.array(ConnectedEventSchema).max(50),
+  nextOffset: z4.number().int().nonnegative().nullable()
 }).strict();
-var AgentImportPreviewSchema = z5.object({
-  teamId: Id4,
+var AgentImportPreviewSchema = z4.object({
+  teamId: Id3,
   source: AgentImportPreviewRequestSchema.shape.source,
-  sourceHash: Hash3,
-  previewHash: Hash3,
+  sourceHash: Hash2,
+  previewHash: Hash2,
   destination: AgentImportPreviewRequestSchema.shape.destination,
-  issues: z5.array(z5.object({ file: z5.string(), message: z5.string() }).strict()).max(100),
-  sessions: z5.array(z5.object({
-    sessionHash: Hash3,
-    sessionId: Id4,
+  issues: z4.array(z4.object({ file: z4.string(), message: z4.string() }).strict()).max(100),
+  sessions: z4.array(z4.object({
+    sessionHash: Hash2,
+    sessionId: Id3,
     origin: ConnectedSourceSummarySchema.shape.source,
-    exporterVersion: z5.string().nullable(),
-    eventCount: z5.number().int().nonnegative(),
-    boundaries: z5.array(z5.object({
-      id: Id4,
-      projection: z5.enum(["turn", "conversation"]),
-      answer: z5.boolean(),
-      process: z5.enum(["retained", "partial", "absent"]),
-      terminal: z5.enum(["completed", "failed", "cancelled", "unknown"])
+    exporterVersion: z4.string().nullable(),
+    eventCount: z4.number().int().nonnegative(),
+    boundaries: z4.array(z4.object({
+      id: Id3,
+      projection: z4.enum(["turn", "conversation"]),
+      answer: z4.boolean(),
+      process: z4.enum(["retained", "partial", "absent"]),
+      terminal: z4.enum(["completed", "failed", "cancelled", "unknown"])
     }).strict()).max(5001),
-    warnings: z5.array(z5.string()).max(100),
-    sample: z5.array(z5.object({ role: z5.enum(["user", "assistant", "system", "tool"]).nullable(), text: z5.string().max(4e3) }).strict()).max(3)
+    warnings: z4.array(z4.string()).max(100),
+    sample: z4.array(z4.object({ role: z4.enum(["user", "assistant", "system", "tool"]).nullable(), text: z4.string().max(4e3) }).strict()).max(3)
   }).strict()).max(1e3)
 }).strict();
-var AgentImportReceiptSchema = z5.object({
-  teamId: Id4,
-  operationId: Id4,
-  requestHash: Hash3,
-  previewHash: Hash3,
-  projectId: Id4.optional(),
-  state: z5.enum(["admitting", "publishing", "completed", "failed"]),
-  outcomes: z5.array(z5.object({
-    sessionHash: Hash3,
-    sourceId: Id4,
-    status: z5.enum(["imported", "already_present"]),
-    datasets: z5.array(z5.object({ datasetId: Id4, revision: z5.number().int().positive(), changed: z5.boolean() }).strict()).max(2)
+var AgentImportReceiptSchema = z4.object({
+  teamId: Id3,
+  operationId: Id3,
+  requestHash: Hash2,
+  previewHash: Hash2,
+  projectId: Id3.optional(),
+  state: z4.enum(["admitting", "publishing", "completed", "failed"]),
+  outcomes: z4.array(z4.object({
+    sessionHash: Hash2,
+    sourceId: Id3,
+    status: z4.enum(["imported", "already_present"]),
+    datasets: z4.array(z4.object({ datasetId: Id3, revision: z4.number().int().positive(), changed: z4.boolean() }).strict()).max(2)
   }).strict()).max(1e3),
-  error: z5.string().optional()
+  error: z4.string().optional()
 }).strict();
 var ConnectedEvidenceError = class extends Error {
   constructor(status, code, message) {
@@ -268,9 +224,9 @@ var ConnectedEvidenceClient = class {
     return result;
   }
   async list(input = {}, signal) {
-    const query = z5.object({ projectId: Id4.optional(), cursor: Id4.optional(), limit: z5.number().int().min(1).max(50).default(20) }).strict().parse(input);
+    const query = z4.object({ projectId: Id3.optional(), cursor: Id3.optional(), limit: z4.number().int().min(1).max(50).default(20) }).strict().parse(input);
     const params = new URLSearchParams(Object.entries(query).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)]));
-    const page = z5.object({ teamId: Id4, items: z5.array(ConnectedSourceSummarySchema).max(50), nextCursor: Id4.nullable() }).strict().parse(await this.request(`?${params}`, "GET", void 0, signal));
+    const page = z4.object({ teamId: Id3, items: z4.array(ConnectedSourceSummarySchema).max(50), nextCursor: Id3.nullable() }).strict().parse(await this.request(`?${params}`, "GET", void 0, signal));
     this.scope(page.teamId);
     if (page.items.length > query.limit || new Set(page.items.map((item) => item.sourceId)).size !== page.items.length || page.nextCursor !== null && page.nextCursor === query.cursor || query.projectId && page.items.some((item) => item.projectId !== query.projectId)) throw new Error("Connected source page differs from its requested scope.");
     return page;
@@ -284,7 +240,7 @@ var ConnectedEvidenceClient = class {
     return result;
   }
   async setCollection(paused, signal) {
-    const result = ConnectedCollectionSchema.parse(await this.request("/collection", "PUT", z5.object({ paused: z5.boolean() }).strict().parse({ paused }), signal));
+    const result = ConnectedCollectionSchema.parse(await this.request("/collection", "PUT", z4.object({ paused: z4.boolean() }).strict().parse({ paused }), signal));
     this.scope(result.teamId);
     return result;
   }
@@ -299,21 +255,21 @@ var ConnectedEvidenceClient = class {
     return result;
   }
   async unmappedEvents(input, signal) {
-    const request = z5.object({ id: Id4, snapshotHash: Hash3, contentHash: Hash3, offset: z5.number().int().nonnegative().default(0), limit: z5.number().int().min(1).max(50).default(20) }).strict().parse(input);
+    const request = z4.object({ id: Id3, snapshotHash: Hash2, contentHash: Hash2, offset: z4.number().int().nonnegative().default(0), limit: z4.number().int().min(1).max(50).default(20) }).strict().parse(input);
     const result = ConnectedUnmappedEventsSchema.parse(await this.request(`/${encodeURIComponent(request.id)}/unmapped-events?snapshotHash=${request.snapshotHash}&offset=${request.offset}&limit=${request.limit}`, "GET", void 0, signal));
     this.scope(result.teamId);
     if (result.sourceId !== request.id || result.snapshotHash !== request.snapshotHash || result.contentHash !== request.contentHash || result.offset !== request.offset || result.events.length > request.limit || result.events.some((event, index) => event.sequence !== request.offset + index) || result.nextOffset !== null && result.nextOffset !== request.offset + result.events.length) throw new Error("Unmapped source event page differs from its pinned snapshot.");
     return result;
   }
   async homeSummary(raw, signal) {
-    const querySchema = z5.object({ from: z5.string().datetime(), to: z5.string().datetime(), projectId: Id4.optional() }).strict(), query = querySchema.parse(raw);
+    const querySchema = z4.object({ from: z4.string().datetime(), to: z4.string().datetime(), projectId: Id3.optional() }).strict(), query = querySchema.parse(raw);
     const params = new URLSearchParams(Object.entries(query));
-    const result = z5.object({ teamId: Id4, range: querySchema, activity: z5.object({
-      conversations: z5.number().int().nonnegative(),
-      turns: z5.number().int().nonnegative(),
-      chatTurns: z5.number().int().nonnegative(),
-      workTurns: z5.number().int().nonnegative()
-    }).strict(), accounting: z5.object({ contextSnapshots: z5.number().int().nonnegative() }).strict(), usage: ConnectedUsageSummarySchema2 }).strict().parse(await this.request(`/summary?${params}`, "GET", void 0, signal));
+    const result = z4.object({ teamId: Id3, range: querySchema, activity: z4.object({
+      conversations: z4.number().int().nonnegative(),
+      turns: z4.number().int().nonnegative(),
+      chatTurns: z4.number().int().nonnegative(),
+      workTurns: z4.number().int().nonnegative()
+    }).strict(), accounting: z4.object({ contextSnapshots: z4.number().int().nonnegative() }).strict(), usage: ConnectedUsageSummarySchema }).strict().parse(await this.request(`/summary?${params}`, "GET", void 0, signal));
     this.scope(result.teamId);
     if (contentHash(result.range) !== contentHash(query) || result.activity.chatTurns + result.activity.workTurns !== result.activity.turns) throw new Error("Activity summary differs from its requested range.");
     for (const groups of [result.usage.days, result.usage.modes, result.usage.models]) {
@@ -324,7 +280,7 @@ var ConnectedEvidenceClient = class {
     return result;
   }
   async uploadPart(raw, signal) {
-    const body = AgentImportUploadPartSchema.parse(raw), result = z5.object({ teamId: Id4, hash: Hash3, parts: z5.number().int(), index: z5.number().int() }).strict().parse(await this.request("/imports/upload", "POST", body, signal));
+    const body = AgentImportUploadPartSchema.parse(raw), result = z4.object({ teamId: Id3, hash: Hash2, parts: z4.number().int(), index: z4.number().int() }).strict().parse(await this.request("/imports/upload", "POST", body, signal));
     this.scope(result.teamId);
     if (result.hash !== body.hash || result.parts !== body.parts || result.index !== body.index) throw new Error("Upload receipt differs from its part identity.");
     return result;
@@ -342,7 +298,7 @@ var ConnectedEvidenceClient = class {
     return result;
   }
   async readImport(operationId, signal) {
-    const id = Id4.parse(operationId), result = AgentImportReceiptSchema.parse(await this.request(`/imports/${encodeURIComponent(id)}`, "GET", void 0, signal));
+    const id = Id3.parse(operationId), result = AgentImportReceiptSchema.parse(await this.request(`/imports/${encodeURIComponent(id)}`, "GET", void 0, signal));
     this.scope(result.teamId);
     if (result.operationId !== id) throw new Error("Import identity mismatch.");
     return result;
@@ -363,7 +319,7 @@ var ConnectedEvidenceClient = class {
     return page;
   }
   async recordedExecution(id, signal) {
-    const result = verifyConnectedRecordedExecution(await this.request(`/recorded-executions/${encodeURIComponent(Id4.parse(id))}`, "GET", void 0, signal));
+    const result = verifyConnectedRecordedExecution(await this.request(`/recorded-executions/${encodeURIComponent(Id3.parse(id))}`, "GET", void 0, signal));
     this.scope(result.teamId);
     if (result.id !== id) throw new Error("Recorded execution identity mismatch.");
     return result;
@@ -377,7 +333,7 @@ var ConnectedEvidenceClient = class {
     return result;
   }
   async createSelection(input, signal) {
-    const request = z5.object({ operationId: Id4.max(240), projectId: Id4.max(240), name: z5.string().trim().min(1).max(200), cases: z5.array(ConnectedCaseRefSchema).min(1).max(500) }).strict().parse(input);
+    const request = z4.object({ operationId: Id3.max(240), projectId: Id3.max(240), name: z4.string().trim().min(1).max(200), cases: z4.array(ConnectedCaseRefSchema).min(1).max(500) }).strict().parse(input);
     const result = DatasetWorkspaceReceiptSchema.parse(await this.request("/datasets/selection", "POST", request, signal));
     this.scope(result.teamId);
     if (result.originProjectId !== request.projectId || result.workspace.draft.tasks.length !== request.cases.length || result.workspace.draft.tasks.some((task, index) => contentHash(task.input && typeof task.input === "object" && !Array.isArray(task.input) ? task.input.connectedEvidenceRef : null) !== contentHash(request.cases[index])))
@@ -396,7 +352,7 @@ var ConnectedEvidenceClient = class {
       ...body === void 0 ? {} : { body: JSON.stringify(body) }
     }, (status, code, message) => new ConnectedEvidenceError(status, code, message));
     if (!response.ok) {
-      const error = z5.object({ code: z5.string(), message: z5.string() }).safeParse(value);
+      const error = z4.object({ code: z4.string(), message: z4.string() }).safeParse(value);
       throw new ConnectedEvidenceError(response.status, error.success ? error.data.code : "connected_request_failed", error.success ? error.data.message : "Connected evidence request failed.");
     }
     return value;
@@ -404,67 +360,94 @@ var ConnectedEvidenceClient = class {
 };
 
 // src/connected-sync.ts
-import { z as z6 } from "zod";
-var Id5 = z6.string().trim().min(1).max(240);
-var ConnectedSyncRegistrationSchema = z6.object({
-  id: Id5,
+import { z as z5 } from "zod";
+import {
+  CollectorCoverageManifestSchema,
+  CollectorCoverageSummarySchema,
+  summarizeCollectorCoverage
+} from "@openpond/evals/connected-evidence";
+var Id4 = z5.string().trim().min(1).max(240);
+var ConnectedSyncCoveragePublishSchema = z5.object({
+  id: Id4,
+  expectedRevision: z5.number().int().positive(),
+  manifest: CollectorCoverageManifestSchema
+}).strict().refine(
+  (value) => value.id === value.manifest.connectionId && value.expectedRevision === value.manifest.connectionRevision,
+  "Collector coverage scope differs from its connection."
+);
+var ConnectedSyncCoverageReadSchema = z5.object({ id: Id4, cutoff: z5.iso.datetime().optional() }).strict();
+var ConnectedSyncCoverageReceiptSchema = z5.object({
+  schemaVersion: z5.literal("openpond.connectedSyncCoverageReceipt.v1"),
+  id: Id4,
+  teamId: Id4,
+  ownerUserId: Id4,
+  connectionId: Id4,
+  connectionRevision: z5.number().int().positive(),
+  receivedAt: z5.iso.datetime(),
+  summary: CollectorCoverageSummarySchema
+}).strict();
+var ConnectedSyncRegistrationSchema = z5.object({
+  id: Id4,
   source: AgentImportPreviewRequestSchema.shape.source,
-  machineId: Id5,
-  sourceInstanceId: Id5,
-  sourceLabel: z6.string().trim().min(1).max(200),
-  sourceRoot: z6.string().min(1).max(2e3),
+  machineId: Id4,
+  sourceInstanceId: Id4,
+  sourceLabel: z5.string().trim().min(1).max(200),
+  sourceRoot: z5.string().min(1).max(2e3),
   destination: AgentImportPreviewRequestSchema.shape.destination,
-  since: z6.string().datetime().nullable(),
-  keepSyncing: z6.boolean(),
-  expectedRevision: z6.number().int().nonnegative()
+  since: z5.string().datetime().nullable(),
+  keepSyncing: z5.boolean(),
+  expectedRevision: z5.number().int().nonnegative()
 }).strict();
-var ConnectedSyncControlSchema = z6.object({
-  id: Id5,
-  expectedRevision: z6.number().int().positive(),
-  action: z6.enum(["pause", "resume", "disconnect"])
+var ConnectedSyncControlSchema = z5.object({
+  id: Id4,
+  expectedRevision: z5.number().int().positive(),
+  action: z5.enum(["pause", "resume", "disconnect"])
 }).strict();
-var ConnectedSyncRequestSchema = z6.object({
-  id: Id5,
-  operationId: Id5,
-  expectedRevision: z6.number().int().positive()
+var ConnectedSyncRequestSchema = z5.object({
+  id: Id4,
+  operationId: Id4,
+  expectedRevision: z5.number().int().positive()
 }).strict();
-var ConnectedSyncHeartbeatSchema = z6.object({
-  id: Id5,
-  expectedRevision: z6.number().int().positive(),
-  pendingOperations: z6.number().int().min(0).max(1e4),
-  error: z6.string().max(500).nullable(),
-  completedSyncRevision: z6.number().int().nonnegative().default(0)
+var ConnectedSyncHeartbeatSchema = z5.object({
+  id: Id4,
+  expectedRevision: z5.number().int().positive(),
+  pendingOperations: z5.number().int().min(0).max(1e4),
+  error: z5.string().max(500).nullable(),
+  completedSyncRevision: z5.number().int().nonnegative().default(0)
 }).strict();
-var ConnectedSyncConnectionSchema = z6.object({
-  teamId: Id5,
-  id: Id5,
-  revision: z6.number().int().positive(),
+var ConnectedSyncConnectionSchema = z5.object({
+  teamId: Id4,
+  id: Id4,
+  revision: z5.number().int().positive(),
   source: AgentImportPreviewRequestSchema.shape.source,
-  sourceLabel: z6.string(),
-  sourceRoot: z6.string(),
-  taskDatasetId: Id5.nullable(),
-  conversationDatasetId: Id5.nullable(),
-  machineId: Id5,
-  sourceInstanceId: Id5,
-  projectId: Id5,
-  datasetIds: z6.array(Id5).max(2),
-  since: z6.string().datetime().nullable(),
-  keepSyncing: z6.boolean(),
-  state: z6.enum(["active", "paused", "disconnected"]),
-  health: z6.enum(["online", "offline"]),
-  lastHeartbeatAt: z6.string().datetime().nullable(),
-  lastAdmissionAt: z6.string().datetime().nullable(),
-  pendingOperations: z6.number().int().nonnegative(),
-  admittedTasks: z6.number().int().nonnegative(),
-  error: z6.string().nullable(),
-  requestedSyncRevision: z6.number().int().nonnegative().default(0),
-  completedSyncRevision: z6.number().int().nonnegative().default(0),
-  syncRequestedAt: z6.string().datetime().nullable().default(null),
-  syncCompletedAt: z6.string().datetime().nullable().default(null)
-}).strict().refine((value) => value.completedSyncRevision <= value.requestedSyncRevision && value.requestedSyncRevision <= value.revision, "Invalid sync acknowledgement generation.");
-var ConnectedSyncCommitSchema = z6.object({
-  connectionId: Id5,
-  expectedRevision: z6.number().int().positive(),
+  sourceLabel: z5.string(),
+  sourceRoot: z5.string(),
+  taskDatasetId: Id4.nullable(),
+  conversationDatasetId: Id4.nullable(),
+  machineId: Id4,
+  sourceInstanceId: Id4,
+  projectId: Id4,
+  datasetIds: z5.array(Id4).max(2),
+  since: z5.string().datetime().nullable(),
+  keepSyncing: z5.boolean(),
+  state: z5.enum(["active", "paused", "disconnected"]),
+  health: z5.enum(["online", "offline"]),
+  lastHeartbeatAt: z5.string().datetime().nullable(),
+  lastAdmissionAt: z5.string().datetime().nullable(),
+  pendingOperations: z5.number().int().nonnegative(),
+  admittedTasks: z5.number().int().nonnegative(),
+  error: z5.string().nullable(),
+  requestedSyncRevision: z5.number().int().nonnegative().default(0),
+  completedSyncRevision: z5.number().int().nonnegative().default(0),
+  syncRequestedAt: z5.string().datetime().nullable().default(null),
+  syncCompletedAt: z5.string().datetime().nullable().default(null)
+}).strict().refine(
+  (value) => value.completedSyncRevision <= value.requestedSyncRevision && value.requestedSyncRevision <= value.revision,
+  "Invalid sync acknowledgement generation."
+);
+var ConnectedSyncCommitSchema = z5.object({
+  connectionId: Id4,
+  expectedRevision: z5.number().int().positive(),
   request: AgentImportCommitRequestSchema
 }).strict();
 var ConnectedSyncClient = class {
@@ -476,9 +459,9 @@ var ConnectedSyncClient = class {
   }
   options;
   async list(signal) {
-    const result = z6.object({
-      teamId: Id5,
-      items: z6.array(ConnectedSyncConnectionSchema).max(100)
+    const result = z5.object({
+      teamId: Id4,
+      items: z5.array(ConnectedSyncConnectionSchema).max(100)
     }).strict().parse(await this.request("", "GET", void 0, signal));
     if (result.teamId !== this.options.teamId || result.items.some((item) => item.teamId !== result.teamId))
       throw new Error("Sync workspace mismatch.");
@@ -519,7 +502,12 @@ var ConnectedSyncClient = class {
   }
   async requestSync(raw, signal) {
     return this.connection(
-      await this.request("/sync-now", "POST", ConnectedSyncRequestSchema.parse(raw), signal),
+      await this.request(
+        "/sync-now",
+        "POST",
+        ConnectedSyncRequestSchema.parse(raw),
+        signal
+      ),
       raw.id
     );
   }
@@ -531,6 +519,45 @@ var ConnectedSyncClient = class {
       signal
     );
   }
+  async publishCoverage(raw, signal) {
+    const request = ConnectedSyncCoveragePublishSchema.parse(raw);
+    const receipt = this.coverageReceipt(
+      await this.request(
+        "/coverage",
+        "POST",
+        { action: "publish", ...request },
+        signal
+      ),
+      request.id
+    );
+    if (!receipt || receipt.connectionRevision !== request.expectedRevision || receipt.summary.manifestHash !== summarizeCollectorCoverage(request.manifest).manifestHash)
+      throw new Error(
+        "Collector coverage acknowledgement differs from the retained manifest."
+      );
+    return receipt;
+  }
+  async readCoverage(raw, signal) {
+    const request = ConnectedSyncCoverageReadSchema.parse(raw);
+    const query = new URLSearchParams(
+      request.cutoff ? { cutoff: request.cutoff } : {}
+    );
+    return this.coverageReceipt(
+      await this.request(
+        `/${encodeURIComponent(request.id)}/coverage?${query}`,
+        "GET",
+        void 0,
+        signal
+      ),
+      request.id
+    );
+  }
+  coverageReceipt(value, connectionId) {
+    if (value === null) return null;
+    const receipt = ConnectedSyncCoverageReceiptSchema.parse(value);
+    if (receipt.teamId !== this.options.teamId || receipt.connectionId !== connectionId)
+      throw new Error("Collector coverage workspace mismatch.");
+    return receipt;
+  }
   connection(raw, id) {
     const result = ConnectedSyncConnectionSchema.parse(raw);
     if (result.teamId !== this.options.teamId || result.id !== id)
@@ -564,18 +591,16 @@ var ConnectedSyncClient = class {
   }
 };
 
+// src/connected-evidence.ts
+import {
+  CollectorCoverageManifestSchema as CollectorCoverageManifestSchema2,
+  CollectorCoverageSessionSchema,
+  CollectorCoverageSummarySchema as CollectorCoverageSummarySchema2,
+  summarizeCollectorCoverage as summarizeCollectorCoverage2,
+  hashCollectorEligibleBoundaries
+} from "@openpond/evals/connected-evidence";
+
 export {
-  ConnectedScopeSchema,
-  ConnectedCaseRefSchema,
-  ConnectedSourceSummarySchema,
-  ConnectedCaptureRequestSchema,
-  AgentImportUploadRefSchema,
-  AgentImportUploadPartSchema,
-  AgentImportFileSchema,
-  AgentImportPreviewRequestSchema,
-  AgentImportCommitRequestSchema,
-  ConnectedHomeQuerySchema,
-  ConnectedHomeSummarySchema,
   ConnectedRecordedExecutionRequestSchema,
   ConnectedRecordedSourceSchema,
   ConnectedRecordedExecutionSchema,
@@ -593,12 +618,20 @@ export {
   AgentImportReceiptSchema,
   ConnectedEvidenceError,
   ConnectedEvidenceClient,
+  ConnectedSyncCoveragePublishSchema,
+  ConnectedSyncCoverageReadSchema,
+  ConnectedSyncCoverageReceiptSchema,
   ConnectedSyncRegistrationSchema,
   ConnectedSyncControlSchema,
   ConnectedSyncRequestSchema,
   ConnectedSyncHeartbeatSchema,
   ConnectedSyncConnectionSchema,
   ConnectedSyncCommitSchema,
-  ConnectedSyncClient
+  ConnectedSyncClient,
+  CollectorCoverageManifestSchema2 as CollectorCoverageManifestSchema,
+  CollectorCoverageSessionSchema,
+  CollectorCoverageSummarySchema2 as CollectorCoverageSummarySchema,
+  summarizeCollectorCoverage2 as summarizeCollectorCoverage,
+  hashCollectorEligibleBoundaries
 };
-//# sourceMappingURL=chunk-YTGRET2L.js.map
+//# sourceMappingURL=chunk-7GA57BEJ.js.map