openpond-sdk 0.9.9 → 0.11.0

package/dist/types/packages/sdk/src/connected-evidence-client.d.ts

@@ -0,0 +1,2460 @@
+import { z } from "zod";
+import { ConnectedCaptureRequestSchema, ConnectedCaseRefSchema, AgentImportUploadPartSchema, AgentImportPreviewRequestSchema, AgentImportCommitRequestSchema } from "./connected-evidence-contracts.js";
+import { ConnectedRecordedExecutionRequestSchema, ConnectedRecordedListRequestSchema } from "./connected-recorded-execution.js";
+import { type ConnectedDatasetPublication } from "./connected-dataset-publication.js";
+export declare const ConnectedCollectionSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        archived: "archived";
+        paused: "paused";
+    }>;
+    revision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ConnectedCaptureReceiptSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    projectId: z.ZodNullable<z.ZodString>;
+    outcomes: z.ZodArray<z.ZodObject<{
+        conversationId: z.ZodString;
+        state: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            paused: "paused";
+            captured: "captured";
+            unchanged: "unchanged";
+            excluded: "excluded";
+        }>;
+        sourceId: z.ZodOptional<z.ZodString>;
+        snapshotHash: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const ConnectedCaseReadbackSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    ref: z.ZodObject<{
+        id: z.ZodString;
+        snapshotHash: z.ZodString;
+        boundaryId: z.ZodString;
+        boundaryRevisionHash: z.ZodString;
+    }, z.core.$strict>;
+    origin: z.ZodEnum<{
+        hermes: "hermes";
+        openclaw: "openclaw";
+        native_chat: "native_chat";
+        native_work: "native_work";
+        codex: "codex";
+        claude_code: "claude_code";
+    }>;
+    sessionId: z.ZodString;
+    projectId: z.ZodString;
+    capturedAt: z.ZodString;
+    unmappedEvidence: z.ZodObject<{
+        count: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    evidence: z.ZodObject<{
+        input: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sequence: z.ZodNumber;
+            occurredAt: z.ZodNullable<z.ZodString>;
+            kind: z.ZodEnum<{
+                message: "message";
+                unknown: "unknown";
+                artifact: "artifact";
+                terminal: "terminal";
+                usage: "usage";
+                tool_call: "tool_call";
+                tool_result: "tool_result";
+                compaction: "compaction";
+            }>;
+            role: z.ZodNullable<z.ZodEnum<{
+                user: "user";
+                tool: "tool";
+                assistant: "assistant";
+                system: "system";
+            }>>;
+            callId: z.ZodNullable<z.ZodString>;
+            parentId: z.ZodNullable<z.ZodString>;
+            content: z.ZodJSONSchema;
+            usage: z.ZodNullable<z.ZodObject<{
+                invocationId: z.ZodString;
+                inputTokens: z.ZodNullable<z.ZodNumber>;
+                outputTokens: z.ZodNullable<z.ZodNumber>;
+                cachedInputTokens: z.ZodNullable<z.ZodNumber>;
+                totalTokens: z.ZodNullable<z.ZodNumber>;
+                provenance: z.ZodEnum<{
+                    billed_invocation: "billed_invocation";
+                    reported_invocation: "reported_invocation";
+                    reported_cumulative: "reported_cumulative";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        observed: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            sequence: z.ZodNumber;
+            occurredAt: z.ZodNullable<z.ZodString>;
+            kind: z.ZodEnum<{
+                message: "message";
+                unknown: "unknown";
+                artifact: "artifact";
+                terminal: "terminal";
+                usage: "usage";
+                tool_call: "tool_call";
+                tool_result: "tool_result";
+                compaction: "compaction";
+            }>;
+            role: z.ZodNullable<z.ZodEnum<{
+                user: "user";
+                tool: "tool";
+                assistant: "assistant";
+                system: "system";
+            }>>;
+            callId: z.ZodNullable<z.ZodString>;
+            parentId: z.ZodNullable<z.ZodString>;
+            content: z.ZodJSONSchema;
+            usage: z.ZodNullable<z.ZodObject<{
+                invocationId: z.ZodString;
+                inputTokens: z.ZodNullable<z.ZodNumber>;
+                outputTokens: z.ZodNullable<z.ZodNumber>;
+                cachedInputTokens: z.ZodNullable<z.ZodNumber>;
+                totalTokens: z.ZodNullable<z.ZodNumber>;
+                provenance: z.ZodEnum<{
+                    billed_invocation: "billed_invocation";
+                    reported_invocation: "reported_invocation";
+                    reported_cumulative: "reported_cumulative";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        answer: z.ZodJSONSchema;
+        boundary: z.ZodObject<{
+            id: z.ZodString;
+            familyKey: z.ZodString;
+            projection: z.ZodEnum<{
+                turn: "turn";
+                conversation: "conversation";
+            }>;
+            requestEventId: z.ZodString;
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+            inputHash: z.ZodString;
+            outputHash: z.ZodNullable<z.ZodString>;
+            revisionHash: z.ZodString;
+            terminal: z.ZodEnum<{
+                unknown: "unknown";
+                cancelled: "cancelled";
+                failed: "failed";
+                completed: "completed";
+            }>;
+            coverage: z.ZodObject<{
+                answer: z.ZodBoolean;
+                context: z.ZodEnum<{
+                    unknown: "unknown";
+                    retained: "retained";
+                    compacted: "compacted";
+                }>;
+                process: z.ZodEnum<{
+                    absent: "absent";
+                    partial: "partial";
+                    retained: "retained";
+                }>;
+                artifacts: z.ZodEnum<{
+                    absent: "absent";
+                    retained: "retained";
+                    references_only: "references_only";
+                }>;
+                replay: z.ZodLiteral<"unavailable">;
+                gaps: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const ConnectedUnmappedEventsSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    sourceId: z.ZodString;
+    snapshotHash: z.ZodString;
+    contentHash: z.ZodString;
+    count: z.ZodNumber;
+    offset: z.ZodNumber;
+    events: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        sequence: z.ZodNumber;
+        occurredAt: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            message: "message";
+            unknown: "unknown";
+            artifact: "artifact";
+            terminal: "terminal";
+            usage: "usage";
+            tool_call: "tool_call";
+            tool_result: "tool_result";
+            compaction: "compaction";
+        }>;
+        role: z.ZodNullable<z.ZodEnum<{
+            user: "user";
+            tool: "tool";
+            assistant: "assistant";
+            system: "system";
+        }>>;
+        callId: z.ZodNullable<z.ZodString>;
+        parentId: z.ZodNullable<z.ZodString>;
+        content: z.ZodJSONSchema;
+        usage: z.ZodNullable<z.ZodObject<{
+            invocationId: z.ZodString;
+            inputTokens: z.ZodNullable<z.ZodNumber>;
+            outputTokens: z.ZodNullable<z.ZodNumber>;
+            cachedInputTokens: z.ZodNullable<z.ZodNumber>;
+            totalTokens: z.ZodNullable<z.ZodNumber>;
+            provenance: z.ZodEnum<{
+                billed_invocation: "billed_invocation";
+                reported_invocation: "reported_invocation";
+                reported_cumulative: "reported_cumulative";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    nextOffset: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const AgentImportPreviewSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    source: z.ZodEnum<{
+        hermes: "hermes";
+        openclaw: "openclaw";
+        codex: "codex";
+        claude_code: "claude_code";
+    }>;
+    sourceHash: z.ZodString;
+    previewHash: z.ZodString;
+    destination: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"existing">;
+        projectId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"new">;
+        name: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    issues: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    sessions: z.ZodArray<z.ZodObject<{
+        sessionHash: z.ZodString;
+        sessionId: z.ZodString;
+        origin: z.ZodEnum<{
+            hermes: "hermes";
+            openclaw: "openclaw";
+            native_chat: "native_chat";
+            native_work: "native_work";
+            codex: "codex";
+            claude_code: "claude_code";
+        }>;
+        exporterVersion: z.ZodNullable<z.ZodString>;
+        eventCount: z.ZodNumber;
+        boundaries: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            projection: z.ZodEnum<{
+                turn: "turn";
+                conversation: "conversation";
+            }>;
+            answer: z.ZodBoolean;
+            process: z.ZodEnum<{
+                retained: "retained";
+                partial: "partial";
+                absent: "absent";
+            }>;
+            terminal: z.ZodEnum<{
+                unknown: "unknown";
+                cancelled: "cancelled";
+                failed: "failed";
+                completed: "completed";
+            }>;
+        }, z.core.$strict>>;
+        warnings: z.ZodArray<z.ZodString>;
+        sample: z.ZodArray<z.ZodObject<{
+            role: z.ZodNullable<z.ZodEnum<{
+                system: "system";
+                user: "user";
+                assistant: "assistant";
+                tool: "tool";
+            }>>;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const AgentImportReceiptSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    operationId: z.ZodString;
+    requestHash: z.ZodString;
+    previewHash: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        failed: "failed";
+        completed: "completed";
+        admitting: "admitting";
+        publishing: "publishing";
+    }>;
+    outcomes: z.ZodArray<z.ZodObject<{
+        sessionHash: z.ZodString;
+        sourceId: z.ZodString;
+        status: z.ZodEnum<{
+            imported: "imported";
+            already_present: "already_present";
+        }>;
+        datasets: z.ZodArray<z.ZodObject<{
+            datasetId: z.ZodString;
+            revision: z.ZodNumber;
+            changed: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare class ConnectedEvidenceError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(status: number, code: string, message: string);
+}
+export declare class ConnectedEvidenceClient {
+    private readonly options;
+    private readonly baseUrl;
+    constructor(options: {
+        apiKey: string;
+        baseUrl: string;
+        teamId: string;
+        fetch?: typeof fetch;
+    });
+    capture(raw: z.input<typeof ConnectedCaptureRequestSchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        operationId: string;
+        projectId: string | null;
+        outcomes: {
+            conversationId: string;
+            state: "pending" | "failed" | "paused" | "captured" | "unchanged" | "excluded";
+            sourceId?: string | undefined;
+            snapshotHash?: string | undefined;
+            reason?: string | undefined;
+        }[];
+        nextCursor: string | null;
+    }>;
+    list(input?: {
+        projectId?: string;
+        cursor?: string;
+        limit?: number;
+    }, signal?: AbortSignal): Promise<{
+        teamId: string;
+        items: {
+            sourceId: string;
+            source: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code";
+            sessionId: string;
+            snapshotHash: string;
+            title: string;
+            projectId: string | null;
+            capturedAt: string;
+            boundaries: {
+                id: string;
+                outputHash: string | null;
+                terminal: "unknown" | "cancelled" | "failed" | "completed";
+                projection: "turn" | "conversation";
+                familyKey: string;
+                requestEventId: string;
+                inputHash: string;
+                revisionHash: string;
+                coverage: {
+                    answer: boolean;
+                    context: "unknown" | "retained" | "compacted";
+                    process: "retained" | "partial" | "absent";
+                    artifacts: "retained" | "absent" | "references_only";
+                    replay: "unavailable";
+                    gaps: string[];
+                };
+            }[];
+        }[];
+        nextCursor: string | null;
+    }>;
+    read(raw: z.input<typeof ConnectedCaseRefSchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        ref: {
+            id: string;
+            snapshotHash: string;
+            boundaryId: string;
+            boundaryRevisionHash: string;
+        };
+        origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code";
+        sessionId: string;
+        projectId: string;
+        capturedAt: string;
+        unmappedEvidence: {
+            count: number;
+            contentHash: string;
+        };
+        evidence: {
+            input: {
+                id: string;
+                sequence: number;
+                occurredAt: string | null;
+                kind: "unknown" | "message" | "terminal" | "usage" | "artifact" | "tool_call" | "tool_result" | "compaction";
+                role: "system" | "user" | "assistant" | "tool" | null;
+                callId: string | null;
+                parentId: string | null;
+                content: z.core.util.JSONType;
+                usage: {
+                    invocationId: string;
+                    inputTokens: number | null;
+                    outputTokens: number | null;
+                    cachedInputTokens: number | null;
+                    totalTokens: number | null;
+                    provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+                } | null;
+            }[];
+            observed: {
+                id: string;
+                sequence: number;
+                occurredAt: string | null;
+                kind: "unknown" | "message" | "terminal" | "usage" | "artifact" | "tool_call" | "tool_result" | "compaction";
+                role: "system" | "user" | "assistant" | "tool" | null;
+                callId: string | null;
+                parentId: string | null;
+                content: z.core.util.JSONType;
+                usage: {
+                    invocationId: string;
+                    inputTokens: number | null;
+                    outputTokens: number | null;
+                    cachedInputTokens: number | null;
+                    totalTokens: number | null;
+                    provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+                } | null;
+            }[];
+            answer: z.core.util.JSONType;
+            boundary: {
+                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: "retained" | "partial" | "absent";
+                    artifacts: "retained" | "absent" | "references_only";
+                    replay: "unavailable";
+                    gaps: string[];
+                };
+            };
+        };
+    }>;
+    setCollection(paused: boolean, signal?: AbortSignal): Promise<{
+        teamId: string;
+        projectId: string | null;
+        status: "active" | "archived" | "paused";
+        revision: number;
+    }>;
+    collection(signal?: AbortSignal): Promise<{
+        teamId: string;
+        projectId: string | null;
+        status: "active" | "archived" | "paused";
+        revision: number;
+    }>;
+    unmappedEvents(input: {
+        id: string;
+        snapshotHash: string;
+        contentHash: string;
+        offset?: number;
+        limit?: number;
+    }, signal?: AbortSignal): Promise<{
+        teamId: string;
+        sourceId: string;
+        snapshotHash: string;
+        contentHash: string;
+        count: number;
+        offset: number;
+        events: {
+            id: string;
+            sequence: number;
+            occurredAt: string | null;
+            kind: "unknown" | "message" | "terminal" | "usage" | "artifact" | "tool_call" | "tool_result" | "compaction";
+            role: "system" | "user" | "assistant" | "tool" | null;
+            callId: string | null;
+            parentId: string | null;
+            content: z.core.util.JSONType;
+            usage: {
+                invocationId: string;
+                inputTokens: number | null;
+                outputTokens: number | null;
+                cachedInputTokens: number | null;
+                totalTokens: number | null;
+                provenance: "billed_invocation" | "reported_invocation" | "reported_cumulative";
+            } | null;
+        }[];
+        nextOffset: number | null;
+    }>;
+    homeSummary(raw: {
+        from: string;
+        to: string;
+        projectId?: string;
+    }, signal?: AbortSignal): Promise<{
+        teamId: string;
+        range: {
+            from: string;
+            to: string;
+            projectId?: string | undefined;
+        };
+        activity: {
+            conversations: number;
+            turns: number;
+            chatTurns: number;
+            workTurns: number;
+        };
+        accounting: {
+            contextSnapshots: number;
+        };
+        usage: {
+            total: {
+                invocations: number;
+                inputTokens: number;
+                cachedInputTokens: number;
+                outputTokens: number;
+                totalTokens: number;
+                missingInput: number;
+                missingCachedInput: number;
+                missingOutput: number;
+                missingTotal: number;
+                failures: number;
+                unattributed: number;
+            };
+            days: {
+                invocations: number;
+                inputTokens: number;
+                cachedInputTokens: number;
+                outputTokens: number;
+                totalTokens: number;
+                missingInput: number;
+                missingCachedInput: number;
+                missingOutput: number;
+                missingTotal: number;
+                failures: number;
+                unattributed: number;
+                key: string;
+            }[];
+            modes: {
+                invocations: number;
+                inputTokens: number;
+                cachedInputTokens: number;
+                outputTokens: number;
+                totalTokens: number;
+                missingInput: number;
+                missingCachedInput: number;
+                missingOutput: number;
+                missingTotal: number;
+                failures: number;
+                unattributed: number;
+                key: string;
+            }[];
+            models: {
+                invocations: number;
+                inputTokens: number;
+                cachedInputTokens: number;
+                outputTokens: number;
+                totalTokens: number;
+                missingInput: number;
+                missingCachedInput: number;
+                missingOutput: number;
+                missingTotal: number;
+                failures: number;
+                unattributed: number;
+                key: string;
+            }[];
+        };
+    }>;
+    uploadPart(raw: z.input<typeof AgentImportUploadPartSchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        hash: string;
+        parts: number;
+        index: number;
+    }>;
+    preview(raw: z.input<typeof AgentImportPreviewRequestSchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        source: "hermes" | "openclaw" | "codex" | "claude_code";
+        sourceHash: string;
+        previewHash: string;
+        destination: {
+            kind: "existing";
+            projectId: string;
+        } | {
+            kind: "new";
+            name: string;
+        };
+        issues: {
+            file: string;
+            message: string;
+        }[];
+        sessions: {
+            sessionHash: string;
+            sessionId: string;
+            origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code";
+            exporterVersion: string | null;
+            eventCount: number;
+            boundaries: {
+                id: string;
+                projection: "turn" | "conversation";
+                answer: boolean;
+                process: "retained" | "partial" | "absent";
+                terminal: "unknown" | "cancelled" | "failed" | "completed";
+            }[];
+            warnings: string[];
+            sample: {
+                role: "system" | "user" | "assistant" | "tool" | null;
+                text: string;
+            }[];
+        }[];
+    }>;
+    commit(raw: z.input<typeof AgentImportCommitRequestSchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        operationId: string;
+        requestHash: string;
+        previewHash: string;
+        state: "failed" | "completed" | "admitting" | "publishing";
+        outcomes: {
+            sessionHash: string;
+            sourceId: string;
+            status: "imported" | "already_present";
+            datasets: {
+                datasetId: string;
+                revision: number;
+                changed: boolean;
+            }[];
+        }[];
+        projectId?: string | undefined;
+        error?: string | undefined;
+    }>;
+    readImport(operationId: string, signal?: AbortSignal): Promise<{
+        teamId: string;
+        operationId: string;
+        requestHash: string;
+        previewHash: string;
+        state: "failed" | "completed" | "admitting" | "publishing";
+        outcomes: {
+            sessionHash: string;
+            sourceId: string;
+            status: "imported" | "already_present";
+            datasets: {
+                datasetId: string;
+                revision: number;
+                changed: boolean;
+            }[];
+        }[];
+        projectId?: string | undefined;
+        error?: string | undefined;
+    }>;
+    prepareRecorded(raw: z.input<typeof ConnectedRecordedExecutionRequestSchema>, signal?: AbortSignal): Promise<{
+        schemaVersion: "openpond.connectedRecordedExecution.v1";
+        id: string;
+        teamId: string;
+        ownerUserId: string;
+        request: {
+            operationId: string;
+            name: string;
+            projectId: string;
+            dataset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            caseIds: string[];
+        };
+        manifest: {
+            schemaVersion: "openpond.experimentManifest.v1";
+            id: string;
+            name: string;
+            teamId: string;
+            operationId: string;
+            maximumCostUsd: number | null;
+            dataset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            target: {
+                kind: "model";
+                modelId: string;
+                configurationHash: string;
+            } | {
+                kind: "harness";
+                source: {
+                    profileId: string;
+                    sourceRevision: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    catalogHash: string;
+                    definitionId: string;
+                    definitionHash: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    environmentHash: string;
+                    externalDatasetBinding?: {
+                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                        dataset: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        packageHash: string;
+                        profileId: string;
+                        target: {
+                            kind: "profile";
+                        } | {
+                            kind: "workflow";
+                            workflowId: string;
+                        } | {
+                            kind: "skill";
+                            skillPath: string;
+                        } | {
+                            kind: "agent_action";
+                            actionId: string;
+                        };
+                        declaredProfileCatalogHash: string | null;
+                        protectedProfileClosureHash: string;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        population: {
+                            taskId: string;
+                            seed: string;
+                            fixtureId: string | null;
+                        }[];
+                        evaluators: {
+                            release: {
+                                id: string;
+                                contentHash: string;
+                                revision: string | number;
+                            };
+                            feedbackKey: string;
+                            configurationHash: string;
+                            output: "boolean" | "score" | "category";
+                            categories: string[];
+                        }[];
+                        fieldMappingsHash: string;
+                        fieldMappings: {
+                            graderId: string;
+                            fields: {
+                                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                path: string[];
+                                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                sourcePath: string[];
+                            }[];
+                        }[];
+                        environmentHash: string;
+                        privateDatasetClosureHash: string;
+                        criterion: {
+                            minimumPassRate: number;
+                            requireComplete: boolean;
+                        };
+                        contentHash: string;
+                        recordedOrigin?: {
+                            execution: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            originalEvidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            members: {
+                                caseId: string;
+                                seed: string;
+                                fixtureId: string;
+                                sourceId: string;
+                                snapshotHash: string;
+                                boundaryRevisionHash: string;
+                            }[];
+                        } | undefined;
+                        gradingSource?: {
+                            pass: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            evidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                        } | undefined;
+                    } | undefined;
+                    sourceCandidate?: {
+                        candidateId: string;
+                        frozenRevision: number;
+                        frozenHash: string;
+                        harnessRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        protectedClosureHash: string;
+                    } | undefined;
+                };
+                model: {
+                    modelId: string;
+                    configurationHash: string;
+                };
+            } | {
+                kind: "agent";
+                source: {
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    agentSnapshot: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    sourcePackageHash: string;
+                };
+                model: {
+                    modelId: string;
+                    configurationHash: string;
+                };
+            } | {
+                kind: "fixture";
+                configurationHash: string;
+            };
+            evaluators: {
+                release: {
+                    id: string;
+                    contentHash: string;
+                    revision: string | number;
+                };
+                feedbackKey: string;
+                output: "boolean" | "score" | "category";
+                categories: string[];
+                configurationHash?: string | undefined;
+            }[];
+            population: {
+                caseId: string;
+                seed: string;
+                fixtureId: string | null;
+            }[];
+            createdAt: string;
+            contentHash: string;
+            execution?: {
+                packageHash: string;
+                runtimeTargetHash: string;
+                metricPolicyHash: string;
+                compatibility?: {
+                    protocol: "openpond.evaluation-execution.v1";
+                    targetKind: "harness" | "fixture" | "model" | "agent";
+                } | undefined;
+            } | undefined;
+            lineage?: {
+                definition: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                execution: {
+                    id: string;
+                    contentHash: string;
+                };
+                scoringPassId: string | null;
+                humanProjection?: {
+                    originalManifest: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    selectionHash: string;
+                    rulesHash: string;
+                } | undefined;
+            } | undefined;
+        };
+        sources: {
+            id: string;
+            snapshotHash: string;
+            boundaryId: string;
+            boundaryRevisionHash: string;
+            inputHash: string;
+            outputHash: string | null;
+            task: {
+                id: string;
+                clusterKey: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                input: Record<string, unknown>;
+                expectedOutput: Record<string, unknown> | null;
+                policyVisibleContext: Record<string, unknown>;
+                privilegedContextRef: string | null;
+                artifactRefs: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                }[];
+                tags: string[];
+                requiredOutputs?: {
+                    path: string;
+                    mediaType: string;
+                    schemaRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    } | null;
+                    maxBytes: number | null;
+                    metadata: Record<string, unknown>;
+                }[] | undefined;
+            };
+            taskHash: string;
+        }[];
+        contentHash: string;
+    }>;
+    listRecordedExecutions(input?: z.input<typeof ConnectedRecordedListRequestSchema>, signal?: AbortSignal): Promise<{
+        teamId: string;
+        items: {
+            id: string;
+            teamId: string;
+            ownerUserId: string;
+            projectId: string;
+            name: string;
+            dataset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            manifestHash: string;
+            contentHash: string;
+            caseCount: number;
+            createdAt: string;
+        }[];
+        nextCursor: string | null;
+    }>;
+    recordedExecution(id: string, signal?: AbortSignal): Promise<{
+        schemaVersion: "openpond.connectedRecordedExecution.v1";
+        id: string;
+        teamId: string;
+        ownerUserId: string;
+        request: {
+            operationId: string;
+            name: string;
+            projectId: string;
+            dataset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            caseIds: string[];
+        };
+        manifest: {
+            schemaVersion: "openpond.experimentManifest.v1";
+            id: string;
+            name: string;
+            teamId: string;
+            operationId: string;
+            maximumCostUsd: number | null;
+            dataset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            target: {
+                kind: "model";
+                modelId: string;
+                configurationHash: string;
+            } | {
+                kind: "harness";
+                source: {
+                    profileId: string;
+                    sourceRevision: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    catalogHash: string;
+                    definitionId: string;
+                    definitionHash: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    environmentHash: string;
+                    externalDatasetBinding?: {
+                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                        dataset: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        packageHash: string;
+                        profileId: string;
+                        target: {
+                            kind: "profile";
+                        } | {
+                            kind: "workflow";
+                            workflowId: string;
+                        } | {
+                            kind: "skill";
+                            skillPath: string;
+                        } | {
+                            kind: "agent_action";
+                            actionId: string;
+                        };
+                        declaredProfileCatalogHash: string | null;
+                        protectedProfileClosureHash: string;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        population: {
+                            taskId: string;
+                            seed: string;
+                            fixtureId: string | null;
+                        }[];
+                        evaluators: {
+                            release: {
+                                id: string;
+                                contentHash: string;
+                                revision: string | number;
+                            };
+                            feedbackKey: string;
+                            configurationHash: string;
+                            output: "boolean" | "score" | "category";
+                            categories: string[];
+                        }[];
+                        fieldMappingsHash: string;
+                        fieldMappings: {
+                            graderId: string;
+                            fields: {
+                                destination: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                path: string[];
+                                source: "input" | "output" | "expectedOutput" | "evaluatorContext";
+                                sourcePath: string[];
+                            }[];
+                        }[];
+                        environmentHash: string;
+                        privateDatasetClosureHash: string;
+                        criterion: {
+                            minimumPassRate: number;
+                            requireComplete: boolean;
+                        };
+                        contentHash: string;
+                        recordedOrigin?: {
+                            execution: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            originalEvidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            members: {
+                                caseId: string;
+                                seed: string;
+                                fixtureId: string;
+                                sourceId: string;
+                                snapshotHash: string;
+                                boundaryRevisionHash: string;
+                            }[];
+                        } | undefined;
+                        gradingSource?: {
+                            pass: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            evidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                        } | undefined;
+                    } | undefined;
+                    sourceCandidate?: {
+                        candidateId: string;
+                        frozenRevision: number;
+                        frozenHash: string;
+                        harnessRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        protectedClosureHash: string;
+                    } | undefined;
+                };
+                model: {
+                    modelId: string;
+                    configurationHash: string;
+                };
+            } | {
+                kind: "agent";
+                source: {
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    agentSnapshot: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    sourcePackageHash: string;
+                };
+                model: {
+                    modelId: string;
+                    configurationHash: string;
+                };
+            } | {
+                kind: "fixture";
+                configurationHash: string;
+            };
+            evaluators: {
+                release: {
+                    id: string;
+                    contentHash: string;
+                    revision: string | number;
+                };
+                feedbackKey: string;
+                output: "boolean" | "score" | "category";
+                categories: string[];
+                configurationHash?: string | undefined;
+            }[];
+            population: {
+                caseId: string;
+                seed: string;
+                fixtureId: string | null;
+            }[];
+            createdAt: string;
+            contentHash: string;
+            execution?: {
+                packageHash: string;
+                runtimeTargetHash: string;
+                metricPolicyHash: string;
+                compatibility?: {
+                    protocol: "openpond.evaluation-execution.v1";
+                    targetKind: "harness" | "fixture" | "model" | "agent";
+                } | undefined;
+            } | undefined;
+            lineage?: {
+                definition: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                execution: {
+                    id: string;
+                    contentHash: string;
+                };
+                scoringPassId: string | null;
+                humanProjection?: {
+                    originalManifest: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    selectionHash: string;
+                    rulesHash: string;
+                } | undefined;
+            } | undefined;
+        };
+        sources: {
+            id: string;
+            snapshotHash: string;
+            boundaryId: string;
+            boundaryRevisionHash: string;
+            inputHash: string;
+            outputHash: string | null;
+            task: {
+                id: string;
+                clusterKey: string;
+                split: "train" | "validation" | "test" | "frozen_eval";
+                input: Record<string, unknown>;
+                expectedOutput: Record<string, unknown> | null;
+                policyVisibleContext: Record<string, unknown>;
+                privilegedContextRef: string | null;
+                artifactRefs: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                }[];
+                tags: string[];
+                requiredOutputs?: {
+                    path: string;
+                    mediaType: string;
+                    schemaRef: {
+                        id: string;
+                        path: string;
+                        contentHash: string;
+                        sizeBytes: number;
+                        mediaType: string;
+                        visibility: "policy" | "verifier" | "host_private";
+                    } | null;
+                    maxBytes: number | null;
+                    metadata: Record<string, unknown>;
+                }[] | undefined;
+            };
+            taskHash: string;
+        }[];
+        contentHash: string;
+    }>;
+    publishDataset(input: ConnectedDatasetPublication, signal?: AbortSignal): Promise<{
+        schemaVersion: "openpond.datasetWorkspaceReceipt.v1";
+        teamId: string;
+        datasetId: string;
+        revision: number;
+        workspace: {
+            schemaVersion: "openpond.tasksetDraftWorkspace.v1";
+            draft: {
+                schemaVersion: "openpond.tasksetDraft.v1";
+                id: string;
+                revision: number;
+                profileId: string;
+                modelScope: {
+                    modelId: string;
+                    expectedModelRevision: number;
+                    source?: {
+                        schemaVersion: "openpond.modelTasksetDraftPreparation.v1";
+                        draftId: string;
+                        requestHash: string;
+                        sourcePackageHash: string;
+                        sourceTasksetRef: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        tasksetId: string;
+                        tasksetRevision: number;
+                        lineage: {
+                            schemaVersion: "openpond.modelTasksetAuthoring.v1";
+                            owner: {
+                                scopeId: string;
+                                modelId: string;
+                            };
+                            root: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            parent: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                        };
+                        authoringGraph?: "bound" | undefined;
+                    } | undefined;
+                } | null;
+                name: string;
+                objective: string;
+                purpose: "general" | "benchmark";
+                benchmark: {
+                    schemaVersion: "openpond.tasksetBenchmark.v1";
+                    definitionId: string;
+                    releaseId: string;
+                    releaseHash: string;
+                    managedReleasePath: string;
+                    adaptationSplit: "train" | "validation" | "test" | "frozen_eval";
+                    evaluationSplit: "train" | "validation" | "test" | "frozen_eval";
+                    primaryMetric: "foreground_tokens" | "success_rate" | "latency_ms" | "cost_usd";
+                    qualityGate: "none" | "non_regression" | "all_pass";
+                    source: "builtin" | "imported";
+                    metadata: Record<string, unknown>;
+                } | null;
+                preferenceComparison: {
+                    schemaVersion: "openpond.tasksetPreferenceComparisonBinding.v1";
+                    releaseId: string;
+                    releaseHash: string;
+                    publishedAt: string;
+                    metadata: Record<string, unknown>;
+                } | null;
+                status: "draft" | "validating" | "needs_review" | "published";
+                sourceRefs: ({
+                    schemaVersion: "openpond.connectedDatasetSource.v1";
+                    kind: "connected_activity";
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code";
+                    sourceId: string;
+                    sessionId: string;
+                    normalizerVersion: string;
+                    projection: "turn" | "conversation";
+                    ownerUserId: string;
+                    purpose: "recorded_evaluation";
+                    metadata: Record<string, unknown>;
+                } | {
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                    schemaVersion: "openpond.huggingFaceDatasetSource.v1";
+                    kind: "huggingface";
+                    repositoryId: string;
+                    repositoryUrl: string;
+                    revision: string;
+                    configuration: string;
+                    upstreamSplits: string[];
+                    gated: boolean;
+                    private: boolean;
+                    declaredLicense: string | null;
+                    sourceFileHashes: string[];
+                } | {
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                    schemaVersion: "openpond.uploadedFileDatasetSource.v1";
+                    kind: "uploaded_file";
+                    originalFileNames: string[];
+                    mediaTypes: string[];
+                    sourceFileHashes: string[];
+                    totalBytes: number;
+                    parserVersion: string;
+                } | {
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                    schemaVersion: "openpond.generatedDatasetSource.v1";
+                    kind: "generated";
+                    generatorId: string;
+                    generatorVersion: string;
+                    seed: number;
+                    generatorHash: string;
+                } | {
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                    schemaVersion: "openpond.learningBatchDatasetSource.v1";
+                    kind: "learning_batch";
+                    batch: {
+                        id: string;
+                        revision: number;
+                        contentHash: string;
+                    };
+                    taskDefinition: {
+                        id: string;
+                        revision: number;
+                        contentHash: string;
+                    };
+                    admittedBy: string;
+                } | {
+                    schemaVersion: "openpond.trainingSource.v1";
+                    id: string;
+                    profileId: string;
+                    sessionId: string;
+                    turnIds: string[];
+                    workspaceId: string | null;
+                    sourceHash: string;
+                    clusterKey: string;
+                    title: string;
+                    occurredAt: string;
+                    consent: {
+                        status: "pending" | "granted" | "denied" | "revoked";
+                        scope: "metadata_only" | "selected_turns" | "full_session";
+                        grantedBy: string | null;
+                        grantedAt: string | null;
+                        purpose: "task_authoring_and_evaluation";
+                    };
+                    connectedAppIds: string[];
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                })[];
+                policy: {
+                    policyVisibleFields: string[];
+                    privilegedFields: string[];
+                    hiddenGraderRefs: string[];
+                    connectedAppScopes: string[];
+                };
+                environment: {
+                    protocolVersion: "openpond.taskEnvironment.v1";
+                    kind: "agent" | "work" | "chat" | "program" | "stateful_harness";
+                    entrypoint: string;
+                    stateful: boolean;
+                    deterministicSeeds: boolean;
+                    toolNames: string[];
+                    lifecycle: ("grade" | "create" | "reset" | "step" | "cleanup")[];
+                    defaultTimeoutMs: number;
+                    networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+                    metadata: Record<string, unknown>;
+                    actionBindings?: {
+                        schemaVersion: "openpond.harnessActionBinding.v1";
+                        actionId: string;
+                        modelToolName: string;
+                        description: string;
+                        inputSchema: Record<string, unknown>;
+                        actionSchemaHash: string;
+                        agentRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        implementationHash: string;
+                        runtimeBindingId: string;
+                        capabilityReceiptHash: string;
+                        sideEffect: "read" | "write";
+                        studentVisible: boolean;
+                        timeoutMs: number;
+                        episodeArgumentBindings: {
+                            argument: string;
+                            source: "case_id";
+                        }[];
+                    }[] | undefined;
+                    resources?: {
+                        id: string;
+                        kind: "file" | "configuration" | "catalog" | "code_module";
+                        path: string;
+                        visibility: "privileged" | "policy_visible" | "policy_hidden";
+                        required: boolean;
+                        metadata: Record<string, unknown>;
+                        mediaType?: string | null | undefined;
+                    }[] | undefined;
+                };
+                output: {
+                    mode: "text" | "structured_json" | "artifacts";
+                    jsonSchema: Record<string, unknown> | null;
+                    renderer: {
+                        module: string;
+                        exportName: string;
+                        configRef: string | null;
+                    } | null;
+                };
+                capabilities: {
+                    schemaVersion: "openpond.tasksetCapabilities.v1";
+                    taskKind: "chat" | "single_agent" | "multi_agent" | "custom_program";
+                    supportedSignals: ("label" | "preference" | "feedback" | "demonstration" | "reward" | "correction")[];
+                    compatibleMethods: ("none" | "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opd" | "opsd" | "sdpo" | "retrieval")[];
+                    rewardKinds: ("none" | "exact" | "deterministic" | "model_judge" | "human")[];
+                    requiresTools: boolean;
+                    requiresState: boolean;
+                    requiresPrivilegedGrading: boolean;
+                    environmentPlacements: ("local" | "remote" | "colocated" | "provider_native")[];
+                    exportable: boolean;
+                    portabilityBlockers: string[];
+                };
+                metrics: {
+                    schemaVersion: "openpond.tasksetMetricPolicy.v1";
+                    primaryMetric: string;
+                    aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
+                    missingReward: "zero" | "exclude";
+                    customAggregator: {
+                        module: string;
+                        exportName: string;
+                        contentHash: string;
+                        timeoutMs: number;
+                        networkPolicy: "none";
+                    } | null;
+                    taskWeights?: Record<string, number> | undefined;
+                };
+                review: {
+                    enabled: boolean;
+                    candidateCount: number;
+                    minimumSamples: number;
+                    allowTies: boolean;
+                    allowRejectAll: boolean;
+                    rubric: string;
+                    criteria: {
+                        id: string;
+                        label: string;
+                        description: string;
+                        weight: number;
+                    }[];
+                };
+                tasks: {
+                    schemaVersion: "openpond.taskData.v1";
+                    id: string;
+                    clusterKey: string;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                    input: Record<string, unknown>;
+                    expectedOutput: Record<string, unknown> | null;
+                    policyVisibleContext: Record<string, unknown>;
+                    privilegedContextRef: string | null;
+                    tags: string[];
+                    metadata: Record<string, unknown>;
+                    sourceRefs: string[];
+                    assets?: {
+                        id: string;
+                        sourceRefId: string;
+                        artifactRef: string;
+                        fileName: string;
+                        mediaType: string;
+                        sha256: string;
+                        sizeBytes: number;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        metadata: Record<string, unknown>;
+                    }[] | undefined;
+                    resourceRefs?: string[] | undefined;
+                    requiredOutputs?: {
+                        path: string;
+                        mediaType: string;
+                        metadata: Record<string, unknown>;
+                        schemaRef?: string | null | undefined;
+                        maxBytes?: number | undefined;
+                    }[] | undefined;
+                }[];
+                graders: ({
+                    id: string;
+                    version: string;
+                    label: string;
+                    weight: number;
+                    hardGate: boolean;
+                    rewardEligible: boolean;
+                    privileged: boolean;
+                    metadata: Record<string, unknown>;
+                    kind: "file" | "content" | "state" | "test" | "diff" | "schema" | "runtime_event";
+                    config: Record<string, unknown>;
+                } | {
+                    id: string;
+                    version: string;
+                    label: string;
+                    weight: number;
+                    hardGate: boolean;
+                    rewardEligible: boolean;
+                    privileged: boolean;
+                    metadata: Record<string, unknown>;
+                    kind: "model_judge";
+                    rubric: string;
+                    judge: {
+                        providerId: "custom-openai-compatible" | "openpond" | "codex" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                        modelId: string;
+                    };
+                    calibrationFixtureRefs: string[];
+                    calibrationStatus: "passed" | "pending" | "failed";
+                    temperature: number;
+                } | {
+                    id: string;
+                    version: string;
+                    label: string;
+                    weight: number;
+                    hardGate: boolean;
+                    rewardEligible: boolean;
+                    privileged: boolean;
+                    metadata: Record<string, unknown>;
+                    kind: "human";
+                    rubric: string;
+                    reviewerRole: string;
+                    form?: {
+                        schemaVersion: "openpond.humanForm.v1";
+                        mode: "individual" | "pairwise";
+                        instructions: string;
+                        criteria: ({
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "score";
+                            minimum: number;
+                            maximum: number;
+                            step: number;
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                        } | {
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "category";
+                            options: string[];
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                        } | {
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "boolean";
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                        } | {
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "text";
+                            maximumLength: number;
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                            minimumLength?: number | undefined;
+                        } | {
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "preference";
+                            allowTie: boolean;
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                            requireStrength?: boolean | undefined;
+                        })[];
+                    } | undefined;
+                } | {
+                    id: string;
+                    version: string;
+                    label: string;
+                    weight: number;
+                    hardGate: boolean;
+                    rewardEligible: boolean;
+                    privileged: boolean;
+                    metadata: Record<string, unknown>;
+                    kind: "custom_verifier";
+                    module: string;
+                    exportName: string;
+                    timeoutMs: number;
+                    networkPolicy: "none";
+                    runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+                })[];
+                graderFixtures: {
+                    id: string;
+                    taskId: string;
+                    label: "infrastructure_failure" | "positive" | "negative" | "boundary" | "adversarial" | "prompt_injection";
+                    output: Record<string, unknown>;
+                    infrastructureError: string | null;
+                    expectedPassed: boolean;
+                    expectedRewardEligible: boolean;
+                    metadata: Record<string, unknown>;
+                }[];
+                learningSignals: {
+                    demonstrations: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "demonstration";
+                        prompt: string | null;
+                        response: string | null;
+                    }[];
+                    preferences: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "preference";
+                        prompt: string;
+                        chosen: string;
+                        rejected: string;
+                        rationale: string | null;
+                    }[];
+                    corrections: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "correction";
+                        original: string;
+                        corrected: string;
+                        rationale: string | null;
+                    }[];
+                    feedback: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "feedback";
+                        feedback: string;
+                        polarity: "neutral" | "positive" | "negative" | "mixed";
+                    }[];
+                    rewards: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "reward";
+                        task: string;
+                        rules: {
+                            id: string;
+                            points: number;
+                            condition: string;
+                        }[];
+                        otherwisePoints: number;
+                        executable: boolean;
+                    }[];
+                    labels: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "label";
+                        labelKind: "rubric";
+                        task: string;
+                        criteria: {
+                            id: string;
+                            label: string;
+                            description: string;
+                        }[];
+                        calibrationExamples: {
+                            positive: string;
+                            negative: string;
+                            boundary: string;
+                        };
+                    }[];
+                };
+                publishedTasksetRef: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                } | null;
+                createdAt: string;
+                updatedAt: string;
+                metadata: Record<string, unknown>;
+                datasetArtifact?: {
+                    schemaVersion: "openpond.datasetArtifact.v1";
+                    id: string;
+                    tasksetId: string;
+                    tasksetRevision: number;
+                    contentHash: string;
+                    format: "parquet";
+                    schema: {
+                        schemaVersion: "openpond.datasetSemanticSchema.v1";
+                        fields: {
+                            name: string;
+                            semanticRole: "metadata" | "feedback" | "messages" | "prompt" | "row_id" | "cluster_id" | "demonstration" | "chosen" | "rejected" | "expected_output" | "privileged_context" | "reward" | "tag";
+                            logicalType: "string" | "boolean" | "messages" | "integer" | "float" | "json";
+                            nullable: boolean;
+                            policy: "metadata" | "visible" | "privileged";
+                        }[];
+                        schemaHash: string;
+                    };
+                    shards: {
+                        id: string;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        path: string;
+                        contentHash: string;
+                        schemaHash: string;
+                        sizeBytes: number;
+                        rowCount: number;
+                        rowGroupCount: number;
+                    }[];
+                    rowCount: number;
+                    splitCounts: Record<"train" | "validation" | "test" | "frozen_eval", number>;
+                    sourceReceiptRefs: string[];
+                    mappingHash: string;
+                    qualityReportHash: string;
+                    createdAt: string;
+                } | null | undefined;
+            };
+            files: {
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                base64: string;
+            }[];
+            contentHash: string;
+        };
+        publication: {
+            tasksetId: string;
+            release: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            packageHash: string;
+        } | null;
+        originProjectId?: string | undefined;
+        ownerScope?: "workspace" | "personal" | undefined;
+    }>;
+    createSelection(input: {
+        operationId: string;
+        projectId: string;
+        name: string;
+        cases: z.input<typeof ConnectedCaseRefSchema>[];
+    }, signal?: AbortSignal): Promise<{
+        schemaVersion: "openpond.datasetWorkspaceReceipt.v1";
+        teamId: string;
+        datasetId: string;
+        revision: number;
+        workspace: {
+            schemaVersion: "openpond.tasksetDraftWorkspace.v1";
+            draft: {
+                schemaVersion: "openpond.tasksetDraft.v1";
+                id: string;
+                revision: number;
+                profileId: string;
+                modelScope: {
+                    modelId: string;
+                    expectedModelRevision: number;
+                    source?: {
+                        schemaVersion: "openpond.modelTasksetDraftPreparation.v1";
+                        draftId: string;
+                        requestHash: string;
+                        sourcePackageHash: string;
+                        sourceTasksetRef: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        tasksetId: string;
+                        tasksetRevision: number;
+                        lineage: {
+                            schemaVersion: "openpond.modelTasksetAuthoring.v1";
+                            owner: {
+                                scopeId: string;
+                                modelId: string;
+                            };
+                            root: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                            parent: {
+                                id: string;
+                                contentHash: string;
+                                revision: number;
+                            };
+                        };
+                        authoringGraph?: "bound" | undefined;
+                    } | undefined;
+                } | null;
+                name: string;
+                objective: string;
+                purpose: "general" | "benchmark";
+                benchmark: {
+                    schemaVersion: "openpond.tasksetBenchmark.v1";
+                    definitionId: string;
+                    releaseId: string;
+                    releaseHash: string;
+                    managedReleasePath: string;
+                    adaptationSplit: "train" | "validation" | "test" | "frozen_eval";
+                    evaluationSplit: "train" | "validation" | "test" | "frozen_eval";
+                    primaryMetric: "foreground_tokens" | "success_rate" | "latency_ms" | "cost_usd";
+                    qualityGate: "none" | "non_regression" | "all_pass";
+                    source: "builtin" | "imported";
+                    metadata: Record<string, unknown>;
+                } | null;
+                preferenceComparison: {
+                    schemaVersion: "openpond.tasksetPreferenceComparisonBinding.v1";
+                    releaseId: string;
+                    releaseHash: string;
+                    publishedAt: string;
+                    metadata: Record<string, unknown>;
+                } | null;
+                status: "draft" | "validating" | "needs_review" | "published";
+                sourceRefs: ({
+                    schemaVersion: "openpond.connectedDatasetSource.v1";
+                    kind: "connected_activity";
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    origin: "hermes" | "openclaw" | "native_chat" | "native_work" | "codex" | "claude_code";
+                    sourceId: string;
+                    sessionId: string;
+                    normalizerVersion: string;
+                    projection: "turn" | "conversation";
+                    ownerUserId: string;
+                    purpose: "recorded_evaluation";
+                    metadata: Record<string, unknown>;
+                } | {
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                    schemaVersion: "openpond.huggingFaceDatasetSource.v1";
+                    kind: "huggingface";
+                    repositoryId: string;
+                    repositoryUrl: string;
+                    revision: string;
+                    configuration: string;
+                    upstreamSplits: string[];
+                    gated: boolean;
+                    private: boolean;
+                    declaredLicense: string | null;
+                    sourceFileHashes: string[];
+                } | {
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                    schemaVersion: "openpond.uploadedFileDatasetSource.v1";
+                    kind: "uploaded_file";
+                    originalFileNames: string[];
+                    mediaTypes: string[];
+                    sourceFileHashes: string[];
+                    totalBytes: number;
+                    parserVersion: string;
+                } | {
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                    schemaVersion: "openpond.generatedDatasetSource.v1";
+                    kind: "generated";
+                    generatorId: string;
+                    generatorVersion: string;
+                    seed: number;
+                    generatorHash: string;
+                } | {
+                    id: string;
+                    profileId: string;
+                    title: string;
+                    sourceHash: string;
+                    occurredAt: string;
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                    schemaVersion: "openpond.learningBatchDatasetSource.v1";
+                    kind: "learning_batch";
+                    batch: {
+                        id: string;
+                        revision: number;
+                        contentHash: string;
+                    };
+                    taskDefinition: {
+                        id: string;
+                        revision: number;
+                        contentHash: string;
+                    };
+                    admittedBy: string;
+                } | {
+                    schemaVersion: "openpond.trainingSource.v1";
+                    id: string;
+                    profileId: string;
+                    sessionId: string;
+                    turnIds: string[];
+                    workspaceId: string | null;
+                    sourceHash: string;
+                    clusterKey: string;
+                    title: string;
+                    occurredAt: string;
+                    consent: {
+                        status: "pending" | "granted" | "denied" | "revoked";
+                        scope: "metadata_only" | "selected_turns" | "full_session";
+                        grantedBy: string | null;
+                        grantedAt: string | null;
+                        purpose: "task_authoring_and_evaluation";
+                    };
+                    connectedAppIds: string[];
+                    secretScanStatus: "passed" | "pending" | "blocked";
+                    piiScanStatus: "passed" | "pending" | "review" | "blocked";
+                    licensingStatus: "pending" | "approved" | "review" | "blocked";
+                    metadata: Record<string, unknown>;
+                })[];
+                policy: {
+                    policyVisibleFields: string[];
+                    privilegedFields: string[];
+                    hiddenGraderRefs: string[];
+                    connectedAppScopes: string[];
+                };
+                environment: {
+                    protocolVersion: "openpond.taskEnvironment.v1";
+                    kind: "agent" | "work" | "chat" | "program" | "stateful_harness";
+                    entrypoint: string;
+                    stateful: boolean;
+                    deterministicSeeds: boolean;
+                    toolNames: string[];
+                    lifecycle: ("grade" | "create" | "reset" | "step" | "cleanup")[];
+                    defaultTimeoutMs: number;
+                    networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+                    metadata: Record<string, unknown>;
+                    actionBindings?: {
+                        schemaVersion: "openpond.harnessActionBinding.v1";
+                        actionId: string;
+                        modelToolName: string;
+                        description: string;
+                        inputSchema: Record<string, unknown>;
+                        actionSchemaHash: string;
+                        agentRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        implementationHash: string;
+                        runtimeBindingId: string;
+                        capabilityReceiptHash: string;
+                        sideEffect: "read" | "write";
+                        studentVisible: boolean;
+                        timeoutMs: number;
+                        episodeArgumentBindings: {
+                            argument: string;
+                            source: "case_id";
+                        }[];
+                    }[] | undefined;
+                    resources?: {
+                        id: string;
+                        kind: "file" | "configuration" | "catalog" | "code_module";
+                        path: string;
+                        visibility: "privileged" | "policy_visible" | "policy_hidden";
+                        required: boolean;
+                        metadata: Record<string, unknown>;
+                        mediaType?: string | null | undefined;
+                    }[] | undefined;
+                };
+                output: {
+                    mode: "text" | "structured_json" | "artifacts";
+                    jsonSchema: Record<string, unknown> | null;
+                    renderer: {
+                        module: string;
+                        exportName: string;
+                        configRef: string | null;
+                    } | null;
+                };
+                capabilities: {
+                    schemaVersion: "openpond.tasksetCapabilities.v1";
+                    taskKind: "chat" | "single_agent" | "multi_agent" | "custom_program";
+                    supportedSignals: ("label" | "preference" | "feedback" | "demonstration" | "reward" | "correction")[];
+                    compatibleMethods: ("none" | "sft" | "dpo" | "grpo" | "ppo" | "sdft" | "opd" | "opsd" | "sdpo" | "retrieval")[];
+                    rewardKinds: ("none" | "exact" | "deterministic" | "model_judge" | "human")[];
+                    requiresTools: boolean;
+                    requiresState: boolean;
+                    requiresPrivilegedGrading: boolean;
+                    environmentPlacements: ("local" | "remote" | "colocated" | "provider_native")[];
+                    exportable: boolean;
+                    portabilityBlockers: string[];
+                };
+                metrics: {
+                    schemaVersion: "openpond.tasksetMetricPolicy.v1";
+                    primaryMetric: string;
+                    aggregation: "custom" | "mean_score" | "pass_rate" | "weighted_mean";
+                    missingReward: "zero" | "exclude";
+                    customAggregator: {
+                        module: string;
+                        exportName: string;
+                        contentHash: string;
+                        timeoutMs: number;
+                        networkPolicy: "none";
+                    } | null;
+                    taskWeights?: Record<string, number> | undefined;
+                };
+                review: {
+                    enabled: boolean;
+                    candidateCount: number;
+                    minimumSamples: number;
+                    allowTies: boolean;
+                    allowRejectAll: boolean;
+                    rubric: string;
+                    criteria: {
+                        id: string;
+                        label: string;
+                        description: string;
+                        weight: number;
+                    }[];
+                };
+                tasks: {
+                    schemaVersion: "openpond.taskData.v1";
+                    id: string;
+                    clusterKey: string;
+                    split: "train" | "validation" | "test" | "frozen_eval";
+                    input: Record<string, unknown>;
+                    expectedOutput: Record<string, unknown> | null;
+                    policyVisibleContext: Record<string, unknown>;
+                    privilegedContextRef: string | null;
+                    tags: string[];
+                    metadata: Record<string, unknown>;
+                    sourceRefs: string[];
+                    assets?: {
+                        id: string;
+                        sourceRefId: string;
+                        artifactRef: string;
+                        fileName: string;
+                        mediaType: string;
+                        sha256: string;
+                        sizeBytes: number;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        metadata: Record<string, unknown>;
+                    }[] | undefined;
+                    resourceRefs?: string[] | undefined;
+                    requiredOutputs?: {
+                        path: string;
+                        mediaType: string;
+                        metadata: Record<string, unknown>;
+                        schemaRef?: string | null | undefined;
+                        maxBytes?: number | undefined;
+                    }[] | undefined;
+                }[];
+                graders: ({
+                    id: string;
+                    version: string;
+                    label: string;
+                    weight: number;
+                    hardGate: boolean;
+                    rewardEligible: boolean;
+                    privileged: boolean;
+                    metadata: Record<string, unknown>;
+                    kind: "file" | "content" | "state" | "test" | "diff" | "schema" | "runtime_event";
+                    config: Record<string, unknown>;
+                } | {
+                    id: string;
+                    version: string;
+                    label: string;
+                    weight: number;
+                    hardGate: boolean;
+                    rewardEligible: boolean;
+                    privileged: boolean;
+                    metadata: Record<string, unknown>;
+                    kind: "model_judge";
+                    rubric: string;
+                    judge: {
+                        providerId: "custom-openai-compatible" | "openpond" | "codex" | "anthropic" | "openai" | "xai" | "google" | "openrouter" | "deepseek" | "zai" | "moonshot" | "together" | "groq";
+                        modelId: string;
+                    };
+                    calibrationFixtureRefs: string[];
+                    calibrationStatus: "passed" | "pending" | "failed";
+                    temperature: number;
+                } | {
+                    id: string;
+                    version: string;
+                    label: string;
+                    weight: number;
+                    hardGate: boolean;
+                    rewardEligible: boolean;
+                    privileged: boolean;
+                    metadata: Record<string, unknown>;
+                    kind: "human";
+                    rubric: string;
+                    reviewerRole: string;
+                    form?: {
+                        schemaVersion: "openpond.humanForm.v1";
+                        mode: "individual" | "pairwise";
+                        instructions: string;
+                        criteria: ({
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "score";
+                            minimum: number;
+                            maximum: number;
+                            step: number;
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                        } | {
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "category";
+                            options: string[];
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                        } | {
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "boolean";
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                        } | {
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "text";
+                            maximumLength: number;
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                            minimumLength?: number | undefined;
+                        } | {
+                            id: string;
+                            label: string;
+                            instructions: string;
+                            required: boolean;
+                            allowAbstain: boolean;
+                            kind: "preference";
+                            allowTie: boolean;
+                            requireRationale?: boolean | undefined;
+                            anchors?: {
+                                value: string | number | boolean;
+                                description: string;
+                            }[] | undefined;
+                            requireStrength?: boolean | undefined;
+                        })[];
+                    } | undefined;
+                } | {
+                    id: string;
+                    version: string;
+                    label: string;
+                    weight: number;
+                    hardGate: boolean;
+                    rewardEligible: boolean;
+                    privileged: boolean;
+                    metadata: Record<string, unknown>;
+                    kind: "custom_verifier";
+                    module: string;
+                    exportName: string;
+                    timeoutMs: number;
+                    networkPolicy: "none";
+                    runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+                })[];
+                graderFixtures: {
+                    id: string;
+                    taskId: string;
+                    label: "infrastructure_failure" | "positive" | "negative" | "boundary" | "adversarial" | "prompt_injection";
+                    output: Record<string, unknown>;
+                    infrastructureError: string | null;
+                    expectedPassed: boolean;
+                    expectedRewardEligible: boolean;
+                    metadata: Record<string, unknown>;
+                }[];
+                learningSignals: {
+                    demonstrations: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "demonstration";
+                        prompt: string | null;
+                        response: string | null;
+                    }[];
+                    preferences: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "preference";
+                        prompt: string;
+                        chosen: string;
+                        rejected: string;
+                        rationale: string | null;
+                    }[];
+                    corrections: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "correction";
+                        original: string;
+                        corrected: string;
+                        rationale: string | null;
+                    }[];
+                    feedback: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "feedback";
+                        feedback: string;
+                        polarity: "neutral" | "positive" | "negative" | "mixed";
+                    }[];
+                    rewards: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "reward";
+                        task: string;
+                        rules: {
+                            id: string;
+                            points: number;
+                            condition: string;
+                        }[];
+                        otherwisePoints: number;
+                        executable: boolean;
+                    }[];
+                    labels: {
+                        id: string;
+                        taskId: string | null;
+                        sourceRefs: string[];
+                        artifactRef: string;
+                        approved: boolean;
+                        confidence: number;
+                        metadata: Record<string, unknown>;
+                        kind: "label";
+                        labelKind: "rubric";
+                        task: string;
+                        criteria: {
+                            id: string;
+                            label: string;
+                            description: string;
+                        }[];
+                        calibrationExamples: {
+                            positive: string;
+                            negative: string;
+                            boundary: string;
+                        };
+                    }[];
+                };
+                publishedTasksetRef: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                } | null;
+                createdAt: string;
+                updatedAt: string;
+                metadata: Record<string, unknown>;
+                datasetArtifact?: {
+                    schemaVersion: "openpond.datasetArtifact.v1";
+                    id: string;
+                    tasksetId: string;
+                    tasksetRevision: number;
+                    contentHash: string;
+                    format: "parquet";
+                    schema: {
+                        schemaVersion: "openpond.datasetSemanticSchema.v1";
+                        fields: {
+                            name: string;
+                            semanticRole: "metadata" | "feedback" | "messages" | "prompt" | "row_id" | "cluster_id" | "demonstration" | "chosen" | "rejected" | "expected_output" | "privileged_context" | "reward" | "tag";
+                            logicalType: "string" | "boolean" | "messages" | "integer" | "float" | "json";
+                            nullable: boolean;
+                            policy: "metadata" | "visible" | "privileged";
+                        }[];
+                        schemaHash: string;
+                    };
+                    shards: {
+                        id: string;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        path: string;
+                        contentHash: string;
+                        schemaHash: string;
+                        sizeBytes: number;
+                        rowCount: number;
+                        rowGroupCount: number;
+                    }[];
+                    rowCount: number;
+                    splitCounts: Record<"train" | "validation" | "test" | "frozen_eval", number>;
+                    sourceReceiptRefs: string[];
+                    mappingHash: string;
+                    qualityReportHash: string;
+                    createdAt: string;
+                } | null | undefined;
+            };
+            files: {
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                base64: string;
+            }[];
+            contentHash: string;
+        };
+        publication: {
+            tasksetId: string;
+            release: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            };
+            packageHash: string;
+        } | null;
+        originProjectId?: string | undefined;
+        ownerScope?: "workspace" | "personal" | undefined;
+    }>;
+    private scope;
+    private request;
+}
+//# sourceMappingURL=connected-evidence-client.d.ts.map