@peasant-labs/schema 0.1.0-rc10

package/dist/internal/generated/contract/zod.gen.js

@@ -0,0 +1,1623 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import * as z from 'zod';
+export const zActivityEdge = z.object({
+    from: z.string(),
+    taskCount: z.int(),
+    to: z.string()
+});
+/**
+ * Annotation Axis
+ *
+ * Subscription dimension for annotation channels
+ */
+export const zAnnotationAxis = z.enum([
+    'type',
+    'session',
+    'project'
+]);
+/**
+ * Annotation Datatype
+ *
+ * Storage type for annotation values (maps to SQLite STRICT column type)
+ */
+export const zAnnotationDatatype = z.enum([
+    'text',
+    'integer',
+    'real',
+    'boolean'
+]);
+export const zAnnotationEntryTarget = z.object({
+    endIndex: z.int(),
+    entryIndex: z.int(),
+    sessionId: z.string().min(1)
+}).superRefine((value, context) => {
+    if (value.sessionId === "")
+        context.addIssue({ code: "custom", message: "entry targets require a non-empty sessionId" });
+    if (value.endIndex <= value.entryIndex)
+        context.addIssue({ code: "custom", message: "entry targets require endIndex greater than entryIndex" });
+});
+export const zAnnotationManifestResponse = z.object({
+    digest: z.string(),
+    hashes: z.array(z.string())
+});
+/**
+ * Annotation Push Status
+ *
+ * Per-item annotation push outcome
+ */
+export const zAnnotationPushStatus = z.enum([
+    'created',
+    'updated',
+    'skipped',
+    'error'
+]);
+export const zAnnotationPushResult = z.object({
+    contentHash: z.string().optional(),
+    error: z.string().optional(),
+    status: zAnnotationPushStatus
+});
+export const zAnnotationPushResponse = z.object({
+    created: z.int(),
+    errors: z.int(),
+    results: z.array(zAnnotationPushResult).optional(),
+    skipped: z.int(),
+    updated: z.int()
+});
+/**
+ * Annotation Status
+ *
+ * ISO 11179 lifecycle state of an annotation type
+ */
+export const zAnnotationStatus = z.enum([
+    'proposed',
+    'active',
+    'deprecated',
+    'retired'
+]);
+/**
+ * Annotator Kind
+ *
+ * Type of entity that produced an annotation: human, agent (AI model), or rule (automated classifier)
+ */
+export const zAnnotatorKind = z.enum([
+    'human',
+    'agent',
+    'rule'
+]);
+export const zAnnotatorSummary = z.object({
+    description: z.string().optional(),
+    displayName: z.string(),
+    id: z.string(),
+    kind: zAnnotatorKind,
+    modelId: z.string().nullish(),
+    name: z.string(),
+    providerKey: z.string().nullish(),
+    status: z.string()
+});
+/**
+ * Association Conclusion
+ *
+ * Producer-supplied conclusion for a session-to-commit association: confirmed or candidate
+ */
+export const zAssociationConclusion = z.enum(['confirmed', 'candidate']);
+/**
+ * Association Evidence Kind
+ *
+ * Atomic observation supporting a session-to-commit association
+ */
+export const zAssociationEvidenceKind = z.enum([
+    'recorded_commit',
+    'touched_file',
+    'branch_membership',
+    'time_window'
+]);
+export const zAssociationEvidenceObservation = z.object({
+    branchName: z.string().nullish(),
+    kind: zAssociationEvidenceKind,
+    recordedCommitHash: z.string().nullish(),
+    touchedFilePath: z.string().nullish(),
+    windowEndMs: z.int().nullish(),
+    windowStartMs: z.int().nullish()
+}).superRefine((value, context) => {
+    const isAbsent = (detail) => detail === undefined || detail === null;
+    const isGoWhitespace = (codePoint) => (codePoint >= 0x0009 && codePoint <= 0x000D)
+        || codePoint === 0x0020
+        || codePoint === 0x0085
+        || codePoint === 0x00A0
+        || codePoint === 0x1680
+        || (codePoint >= 0x2000 && codePoint <= 0x200A)
+        || codePoint === 0x2028
+        || codePoint === 0x2029
+        || codePoint === 0x202F
+        || codePoint === 0x205F
+        || codePoint === 0x3000;
+    const hasNonEmptyString = (detail) => {
+        if (typeof detail !== "string")
+            return false;
+        for (const character of detail) {
+            const codePoint = character.codePointAt(0);
+            if (codePoint !== undefined && !isGoWhitespace(codePoint))
+                return true;
+        }
+        return false;
+    };
+    const hasValidTouchedFilePath = (detail) => typeof detail === "string"
+        && detail !== ""
+        && !detail.startsWith("/")
+        && !detail.startsWith("\\")
+        && !detail.includes("\\")
+        && !/^[A-Za-z]:\//.test(detail)
+        && !detail.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
+    const addIssue = (message) => context.addIssue({ code: "custom", message });
+    switch (value.kind) {
+        case "recorded_commit":
+            if (!hasNonEmptyString(value.recordedCommitHash))
+                addIssue("recorded_commit evidence requires a non-empty recordedCommitHash");
+            if (!isAbsent(value.touchedFilePath) || !isAbsent(value.branchName) || !isAbsent(value.windowStartMs) || !isAbsent(value.windowEndMs))
+                addIssue("recorded_commit evidence must not populate another detail arm");
+            return;
+        case "touched_file":
+            if (!hasValidTouchedFilePath(value.touchedFilePath))
+                addIssue("touched_file evidence requires a non-empty repository-relative touchedFilePath");
+            if (!isAbsent(value.recordedCommitHash) || !isAbsent(value.branchName) || !isAbsent(value.windowStartMs) || !isAbsent(value.windowEndMs))
+                addIssue("touched_file evidence must not populate another detail arm");
+            return;
+        case "branch_membership":
+            if (!hasNonEmptyString(value.branchName))
+                addIssue("branch_membership evidence requires a non-empty branchName");
+            if (!isAbsent(value.recordedCommitHash) || !isAbsent(value.touchedFilePath) || !isAbsent(value.windowStartMs) || !isAbsent(value.windowEndMs))
+                addIssue("branch_membership evidence must not populate another detail arm");
+            return;
+        case "time_window":
+            if (value.windowStartMs === undefined || value.windowStartMs === null || value.windowEndMs === undefined || value.windowEndMs === null) {
+                addIssue("time_window evidence requires windowStartMs and windowEndMs");
+            }
+            else if (value.windowStartMs > value.windowEndMs) {
+                addIssue("time_window evidence requires windowStartMs less than or equal to windowEndMs");
+            }
+            if (!isAbsent(value.recordedCommitHash) || !isAbsent(value.touchedFilePath) || !isAbsent(value.branchName))
+                addIssue("time_window evidence must not populate another detail arm");
+            return;
+    }
+});
+/**
+ * Association ID
+ *
+ * Opaque durable Peasant identifier for one session-to-commit association
+ */
+export const zAssociationID = z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/);
+export const zBatchCreateAnnotationsErrorResponse = z.object({
+    error: z.string(),
+    failingIndex: z.int()
+});
+export const zBatchCreateAnnotationsResponse = z.object({
+    ids: z.array(z.string()).nullable()
+});
+/**
+ * Built-in Command
+ *
+ * Claude Code built-in slash command name without the leading slash
+ */
+export const zBuiltinCommand = z.enum([
+    'exit',
+    'compact',
+    'clear',
+    'new',
+    'model',
+    'usage',
+    'cost',
+    'context',
+    'plugin',
+    'permissions',
+    'login',
+    'resume',
+    'plan',
+    'fast',
+    'voice',
+    'todos',
+    'reload-plugins',
+    'sandbox',
+    'config',
+    'statusline',
+    'upgrade',
+    'extra-usage',
+    'rate-limit-options',
+    'privacy-settings',
+    'help',
+    'commands'
+]);
+export const zCLILoginQuery = z.object({
+    port: z.int(),
+    state: z.string()
+});
+/**
+ * Change Binding
+ *
+ * Strength of the evidence connecting a recorded session to a code change
+ */
+export const zChangeBinding = z.enum(['bound', 'candidate']);
+export const zChangeSummary = z.object({
+    aheadCount: z.int(),
+    baseHash: z.string().optional(),
+    behindCount: z.int(),
+    branch: z.string(),
+    filesChanged: z.int(),
+    lastWorkMs: z.int().nullish(),
+    mergeCommitHash: z.string().optional(),
+    merged: z.boolean(),
+    mergedAtMs: z.int().nullish(),
+    newEdges: z.int(),
+    removedEdges: z.int(),
+    reverted: z.boolean().optional(),
+    sessionCount: z.int(),
+    taskCount: z.int(),
+    tipCommitMs: z.int().nullish(),
+    violations: z.int()
+});
+/**
+ * Channel Topic
+ *
+ * Subscribable WebSocket data stream
+ */
+export const zChannelTopic = z.enum([
+    'dashboard',
+    'sessions',
+    'session_detail',
+    'trends',
+    'quality',
+    'annotations',
+    'project_familiarity'
+]);
+export const zChannelSubscription = z.object({
+    axis: zAnnotationAxis.optional(),
+    id: z.string().optional(),
+    topic: zChannelTopic
+});
+export const zChildSessionRef = z.object({
+    id: z.string(),
+    project: z.string().optional(),
+    startTime: z.iso.datetime()
+});
+export const zCommitInfo = z.object({
+    authorEmail: z.string(),
+    authorName: z.string(),
+    authorTime: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    commitTime: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    hash: z.string(),
+    message: z.string()
+});
+/**
+ * Confidence
+ *
+ * Strength of evidence behind a derived relationship: high, medium, or low
+ */
+export const zConfidence = z.enum([
+    'high',
+    'medium',
+    'low'
+]);
+/**
+ * Content Kind
+ *
+ * Payload kind carried by a transcript content envelope
+ */
+export const zContentKind = z.enum(['session_detail']);
+export const zContractVersion = z.string().nullable();
+export const zCreateAnnotationRequest = z.object({
+    annotatorName: z.string().optional(),
+    confidence: z.number().nullish(),
+    isPrimary: z.boolean(),
+    reason: z.string().nullish(),
+    sessionId: z.string(),
+    targetAnnotationId: z.string().nullish(),
+    targetEntryEndIndex: z.int().nullish(),
+    targetEntryIndex: z.int().nullish(),
+    typeId: z.string(),
+    value: z.string()
+});
+export const zBatchCreateAnnotationsRequest = z.object({
+    annotations: z.array(zCreateAnnotationRequest).nullable()
+});
+export const zCreateAnnotationResponse = z.object({
+    id: z.string()
+});
+export const zDashboardPayload = z.object({
+    acceptanceRate: z.number(),
+    avgDurationMins: z.number(),
+    avgTurnsPerSession: z.number(),
+    harnessBreakdown: z.record(z.string(), z.int()).nullable(),
+    totalSessions: z.int(),
+    totalTokens: z.int()
+});
+export const zDayStats = z.object({
+    date: z.string(),
+    sessions: z.int(),
+    tokens: z.int()
+});
+/**
+ * Decay Level
+ *
+ * Recency band for project file familiarity
+ */
+export const zDecayLevel = z.enum([
+    'fresh',
+    'fading',
+    'stale',
+    'unexplored'
+]);
+export const zDiagnosticEntry = z.object({
+    errorType: z.string(),
+    location: z.string(),
+    message: z.string(),
+    remediation: z.string()
+});
+export const zDiagnosticsInfo = z.object({
+    partial: z.boolean().nullish(),
+    warnings: z.array(zDiagnosticEntry).nullable()
+});
+/**
+ * Diff Line Kind
+ *
+ * Unified-diff line kind: context, addition, or deletion
+ */
+export const zDiffLineKind = z.enum([
+    'context',
+    'add',
+    'del'
+]);
+export const zDiffLine = z.object({
+    kind: zDiffLineKind,
+    text: z.string()
+});
+export const zDiffHunk = z.object({
+    header: z.string().optional(),
+    lines: z.array(zDiffLine).nullable(),
+    newLines: z.int(),
+    newStart: z.int(),
+    oldLines: z.int(),
+    oldStart: z.int(),
+    sessionId: z.string().optional(),
+    sessionTitle: z.string().optional()
+});
+/**
+ * Edge Violation Kind
+ *
+ * Structural violation detected on a map edge
+ */
+export const zEdgeViolationKind = z.enum(['cycle', 'wrong_way']);
+export const zEdgeViolation = z.object({
+    from: z.string(),
+    kind: zEdgeViolationKind,
+    to: z.string()
+});
+/**
+ * Entry Type
+ *
+ * Classification of a single entry within an agent session transcript
+ */
+export const zEntryType = z.enum([
+    'text',
+    'tool_use',
+    'tool_result',
+    'thinking',
+    'system',
+    'error',
+    'result'
+]);
+export const zExchangeCodeRequest = z.object({
+    code: z.string(),
+    state: z.string()
+});
+export const zExchangeCodeResponse = z.object({
+    api_key: z.string(),
+    key_id: z.string(),
+    user_id: z.string(),
+    username: z.string()
+});
+/**
+ * File Change Status
+ *
+ * Git file delta status: modified, added, deleted, or renamed
+ */
+export const zFileChangeStatus = z.enum([
+    'M',
+    'A',
+    'D',
+    'R'
+]);
+export const zChangeDiffPayload = z.object({
+    binary: z.boolean(),
+    branch: z.string(),
+    file: z.string(),
+    hunks: z.array(zDiffHunk).nullable(),
+    oldPath: z.string().nullish(),
+    status: zFileChangeStatus,
+    truncated: z.boolean()
+});
+export const zFileChange = z.object({
+    linesAdded: z.int(),
+    linesRemoved: z.int(),
+    oldPath: z.string().nullish(),
+    path: z.string(),
+    status: zFileChangeStatus
+});
+export const zFileFamiliarity = z.object({
+    daysSince: z.int().nullable(),
+    decayLevel: zDecayLevel,
+    depth: z.int(),
+    humanTurns: z.int(),
+    isSourceFile: z.boolean(),
+    lastEngagedAt: z.string().nullable(),
+    path: z.string(),
+    sessionCount: z.int(),
+    totalTurns: z.int()
+});
+export const zFrictionCluster = z.object({
+    count: z.int(),
+    file: z.string(),
+    kind: z.string(),
+    label: z.string(),
+    sessions: z.int()
+});
+/**
+ * Harness
+ *
+ * AI coding tool or development environment
+ */
+export const zHarness = z.enum([
+    'claude-code',
+    'gemini-cli',
+    'codex',
+    'opencode',
+    'cursor',
+    'antigravity',
+    'strike'
+]);
+export const zHealthResponse = z.object({
+    status: z.string()
+});
+/**
+ * Host Slug
+ *
+ * Sanitized, filesystem-safe identifier derived from git remote; contains only [a-zA-Z0-9._<>-]
+ */
+export const zHostSlug = z.string().regex(/^[a-zA-Z0-9._<>-]+$/);
+export const zInsightClassification = z.object({
+    category: z.string(),
+    cause: z.string(),
+    resolution: z.string(),
+    severityLocus: z.string(),
+    severityScope: z.string()
+});
+/**
+ * Insight Kind
+ *
+ * What a SessionInsight observed: a decision, friction, an unusual rate elevation, or a retry loop
+ */
+export const zInsightKind = z.enum([
+    'decision',
+    'friction',
+    'unusual',
+    'retry_loop'
+]);
+/**
+ * Insight Provenance
+ *
+ * How a SessionInsight was produced: mechanical (rule-derived) or mined
+ */
+export const zInsightProvenance = z.enum(['mechanical', 'mined']);
+/**
+ * Interaction Type
+ *
+ * How deeply a session engaged with a project file
+ */
+export const zInteractionType = z.enum([
+    'mentioned',
+    'read',
+    'discussed',
+    'questioned'
+]);
+/**
+ * License
+ *
+ * Content license for a published transcript
+ */
+export const zLicense = z.enum([
+    'CC0-1.0',
+    'CC-BY-4.0',
+    'CC-BY-SA-4.0'
+]);
+export const zMapEdge = z.object({
+    count: z.int(),
+    from: z.string(),
+    to: z.string()
+});
+/**
+ * Map Node Kind
+ *
+ * Path-derived map node classification
+ */
+export const zMapNodeKind = z.enum([
+    'module',
+    'package',
+    'file'
+]);
+/**
+ * Message Type
+ *
+ * WebSocket message discriminator
+ */
+export const zMessageType = z.enum([
+    'subscribe',
+    'unsubscribe',
+    'dashboard',
+    'sessions',
+    'session_detail',
+    'trends',
+    'quality',
+    'annotations',
+    'project_familiarity',
+    'connected',
+    'error'
+]);
+export const zClientMessage = z.object({
+    channels: z.array(zChannelSubscription).optional(),
+    type: zMessageType
+});
+export const zMockConfigResponse = z.object({
+    api: z.array(z.string()).optional(),
+    enabled: z.boolean(),
+    tui: z.array(z.string()).optional(),
+    web: z.array(z.string()).optional()
+});
+/**
+ * Model ID
+ *
+ * Model identifier (e.g. 'claude-opus-4-6', 'gemini-2.0-flash')
+ */
+export const zModelID = z.string().min(1);
+export const zModelInfo = z.object({
+    harness: zHarness,
+    hostSlug: zHostSlug.optional(),
+    model: zModelID,
+    version: z.string().optional()
+});
+/**
+ * Project Hash
+ *
+ * SHA-256 hex digest of the project's origin URL or local path
+ */
+export const zProjectHash = z.string().regex(/^[0-9a-f]{64}$/).brand();
+export const zProjectContext = z.object({
+    filePath: z.string().optional(),
+    hash: zProjectHash,
+    name: z.string()
+});
+export const zProjectResolutionPayload = z.object({
+    project: z.string(),
+    projectHash: zProjectHash
+});
+export const zProjectSummary = z.object({
+    lastWorkMs: z.int().nullish(),
+    openChanges: z.int(),
+    project: z.string(),
+    projectHash: zProjectHash,
+    recordedFiles: z.int(),
+    sessions: z.int(),
+    totalFiles: z.int()
+});
+export const zProjectSummariesPayload = z.object({
+    projects: z.array(zProjectSummary).nullable()
+});
+export const zProvenance = z.object({
+    details: z.record(z.string(), z.string()).optional(),
+    function: z.string().optional(),
+    method: z.string(),
+    version: z.string().optional()
+});
+export const zPublishResponse = z.object({
+    blobKey: z.string(),
+    blobSizeBytes: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    created: z.boolean(),
+    publishedAt: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    transcriptId: z.string(),
+    updatedAt: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' })
+});
+export const zPublishedAssociation = z.object({
+    id: zAssociationID,
+    observedCommitHash: z.string()
+});
+export const zGitContext = z.object({
+    associations: z.array(zPublishedAssociation).optional(),
+    branch: z.string().nullish(),
+    commits: z.array(zCommitInfo).optional(),
+    remote: z.string().nullish(),
+    tracking: z.string().nullish(),
+    worktree: z.string().nullish()
+}).superRefine((value, context) => {
+    if (value.associations === undefined || value.associations === null)
+        return;
+    const seenIDs = new Map();
+    const seenObservedHashes = new Map();
+    for (const [index, association] of value.associations.entries()) {
+        if (association.observedCommitHash.trim() === "") {
+            context.addIssue({ code: "custom", path: ["associations", index, "observedCommitHash"], message: "published associations require a non-empty observedCommitHash" });
+        }
+        const priorID = seenIDs.get(association.id);
+        if (priorID !== undefined) {
+            context.addIssue({ code: "custom", path: ["associations", index, "id"], message: "published association IDs must be unique within one request" });
+        }
+        else {
+            seenIDs.set(association.id, index);
+        }
+        const priorObservedHash = seenObservedHashes.get(association.observedCommitHash);
+        if (priorObservedHash !== undefined) {
+            context.addIssue({ code: "custom", path: ["associations", index, "observedCommitHash"], message: "published association observedCommitHash values must be unique within one request" });
+        }
+        else {
+            seenObservedHashes.set(association.observedCommitHash, index);
+        }
+    }
+});
+/**
+ * Read Attribution State
+ *
+ * Whether per-file read attribution is recoverable for a node's editing sessions: complete, partial, or unavailable
+ */
+export const zReadAttributionState = z.enum([
+    'complete',
+    'partial',
+    'unavailable'
+]);
+/**
+ * Read State Grade
+ *
+ * Ordinal explicit read-state act: none, viewed, reviewed, or reviewed_in_detail
+ */
+export const zReadStateGrade = z.enum([
+    'none',
+    'viewed',
+    'reviewed',
+    'reviewed_in_detail'
+]);
+export const zMapNode = z.object({
+    agentEditedCount: z.int(),
+    attributedRegionCount: z.int(),
+    changedRegionCount: z.int(),
+    effortDensity: z.number(),
+    fileCount: z.int(),
+    id: z.string(),
+    kind: zMapNodeKind,
+    language: z.string().optional(),
+    layer: z.int(),
+    loc: z.int(),
+    name: z.string(),
+    order: z.int(),
+    parent: z.string().optional(),
+    readAttribution: zReadAttributionState,
+    readCount: z.int(),
+    readState: zReadStateGrade,
+    recordedFiles: z.int(),
+    reviewedRegionCount: z.int(),
+    totalFiles: z.int(),
+    touchCount: z.int()
+});
+export const zMapGraphPayload = z.object({
+    activityEdges: z.array(zActivityEdge).nullable(),
+    atCommit: z.string().optional(),
+    generatedAtMs: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    nodes: z.array(zMapNode).nullable(),
+    parsedLanguages: z.array(z.string()).nullable(),
+    projectHash: zProjectHash,
+    repoFound: z.boolean(),
+    repoPath: z.string().optional(),
+    structureEdges: z.array(zMapEdge).nullable(),
+    violations: z.array(zEdgeViolation).nullable()
+});
+export const zMapSlice = z.object({
+    activityEdges: z.array(zActivityEdge).nullable(),
+    nodes: z.array(zMapNode).nullable(),
+    structureEdges: z.array(zMapEdge).nullable()
+});
+export const zRedactionInfo = z.object({
+    applied: z.boolean(),
+    content_hash_at_redact: z.string().optional(),
+    level: z.string().optional(),
+    redacted_at_ms: z.int().nullish(),
+    rule_set_version: z.string().optional()
+});
+export const zReviewSuggestion = z.object({
+    daysSince: z.int(),
+    lastEngaged: z.string(),
+    path: z.string(),
+    suggestedPrompt: z.string()
+});
+/**
+ * Rewrite Method
+ *
+ * Mechanism the resolver used to map a ghost commit to its successor
+ */
+export const zRewriteMethod = z.enum([
+    'hash',
+    'patch_id',
+    'author_identity',
+    'message_embedded',
+    'temporal',
+    'none'
+]);
+/**
+ * Rewrite Resolution
+ *
+ * Whether a ledger-observed commit hash is live, was rewritten, or could not be resolved
+ */
+export const zRewriteResolution = z.enum([
+    'live',
+    'rewritten',
+    'unresolved'
+]);
+/**
+ * Role
+ *
+ * Sender role of a message turn
+ */
+export const zRole = z.enum([
+    'user',
+    'assistant',
+    'tool',
+    'system'
+]);
+/**
+ * Scale Kind
+ *
+ * Stevens measurement level: nominal (categories without order), ordinal (ordered categories), continuous (numeric range)
+ */
+export const zScaleKind = z.enum([
+    'nominal',
+    'ordinal',
+    'continuous'
+]);
+export const zSchemaVersionResponse = z.object({
+    annotationSchemaVersion: z.string(),
+    minPullContractVersion: z.string().optional(),
+    minPushContractVersion: z.string(),
+    pullContractVersion: z.string().optional(),
+    pushContractVersion: z.string(),
+    supportedTargetKinds: z.array(z.string()).nullable(),
+    supportedTypeIds: z.array(z.string()).nullable()
+});
+export const zSearchResult = z.object({
+    entryIndex: z.int(),
+    project: z.string(),
+    projectHash: zProjectHash.optional(),
+    role: z.string(),
+    score: z.number(),
+    sessionId: z.string(),
+    snippet: z.string()
+});
+export const zSearchPayload = z.object({
+    query: z.string(),
+    results: z.array(zSearchResult).nullable()
+});
+export const zServerMessage = z.object({
+    axis: zAnnotationAxis.optional(),
+    data: z.unknown().optional(),
+    id: z.string().optional(),
+    message: z.string().optional(),
+    topic: zChannelTopic.optional(),
+    type: zMessageType,
+    version: z.string().optional()
+});
+/**
+ * Session ID
+ *
+ * Unique session identifier (UUID, agent-{hex}, ses_{id}, sess_{id} (ACP), msg_{id}, or a Strike session ID)
+ */
+export const zSessionID = z.string().regex(/^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|agent-[a-f0-9]+|sess?_[a-zA-Z0-9]+|msg_[a-zA-Z0-9]+|[0-9]{8}T[0-9]{6}\.[0-9]{9}Z-[A-Z2-7]{26}|[A-Z2-7]{26})$/);
+export const zInsightEvidence = z.object({
+    commitHash: z.string().optional(),
+    entryIndex: z.int().nullish(),
+    file: z.string().optional(),
+    sessionId: zSessionID
+});
+export const zSessionAssociation = z.object({
+    conclusion: zAssociationConclusion,
+    confidence: zConfidence,
+    evidence: z.array(zAssociationEvidenceObservation).min(1),
+    id: zAssociationID,
+    sessionId: z.string().min(1)
+}).superRefine((value, context) => {
+    const kindOrder = ["recorded_commit", "touched_file", "branch_membership", "time_window"];
+    const compareStrings = (left, right) => {
+        const leftBytes = new TextEncoder().encode(left);
+        const rightBytes = new TextEncoder().encode(right);
+        const sharedLength = Math.min(leftBytes.length, rightBytes.length);
+        for (let index = 0; index < sharedLength; index += 1) {
+            const leftByte = leftBytes[index];
+            const rightByte = rightBytes[index];
+            if (leftByte < rightByte)
+                return -1;
+            if (leftByte > rightByte)
+                return 1;
+        }
+        return compareNumbers(leftBytes.length, rightBytes.length);
+    };
+    const compareNumbers = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+    const compareObservations = (left, right) => {
+        const leftKindOrder = kindOrder.indexOf(left.kind);
+        const rightKindOrder = kindOrder.indexOf(right.kind);
+        if (leftKindOrder !== rightKindOrder)
+            return compareNumbers(leftKindOrder, rightKindOrder);
+        switch (left.kind) {
+            case "recorded_commit": return compareStrings(typeof left.recordedCommitHash === "string" ? left.recordedCommitHash : "", typeof right.recordedCommitHash === "string" ? right.recordedCommitHash : "");
+            case "touched_file": return compareStrings(typeof left.touchedFilePath === "string" ? left.touchedFilePath : "", typeof right.touchedFilePath === "string" ? right.touchedFilePath : "");
+            case "branch_membership": return compareStrings(typeof left.branchName === "string" ? left.branchName : "", typeof right.branchName === "string" ? right.branchName : "");
+            case "time_window": {
+                const startOrder = compareNumbers(left.windowStartMs ?? 0, right.windowStartMs ?? 0);
+                return startOrder === 0 ? compareNumbers(left.windowEndMs ?? 0, right.windowEndMs ?? 0) : startOrder;
+            }
+        }
+        return 0;
+    };
+    for (let index = 1; index < value.evidence.length; index += 1) {
+        const previous = value.evidence[index - 1];
+        const current = value.evidence[index];
+        if (previous === undefined || current === undefined)
+            continue;
+        if (compareObservations(previous, current) >= 0) {
+            context.addIssue({ code: "custom", message: "association evidence must be duplicate-free and in canonical kind/detail order" });
+        }
+    }
+});
+export const zCommitRef = z.object({
+    associations: z.array(zSessionAssociation),
+    hasSession: z.boolean(),
+    hash: z.string(),
+    sessionIds: z.array(zSessionID),
+    subject: z.string(),
+    timeMs: z.int().nullish()
+});
+export const zRewrittenCommit = z.object({
+    associations: z.array(zSessionAssociation),
+    authorTimeMs: z.int().nullish(),
+    confidence: zConfidence,
+    ghostHash: z.string(),
+    method: zRewriteMethod,
+    resolution: zRewriteResolution,
+    sessionIds: z.array(zSessionID),
+    subject: z.string(),
+    successorHash: z.string().nullish()
+});
+export const zSessionIdentity = z.object({
+    parentUuid: zSessionID.nullish(),
+    schemaVersion: z.int(),
+    sessionId: zSessionID
+});
+export const zSessionInsight = z.object({
+    classification: zInsightClassification.nullish(),
+    confidence: zConfidence,
+    evidence: z.array(zInsightEvidence),
+    kind: zInsightKind,
+    provenance: zInsightProvenance,
+    subjects: z.array(z.string()),
+    summary: z.string().optional(),
+    title: z.string()
+});
+/**
+ * Session Outcome
+ *
+ * Resolution status of the session
+ */
+export const zSessionOutcome = z.enum([
+    'resolved',
+    'partial',
+    'failed'
+]);
+export const zQualityMetrics = z.object({
+    computeVersion: z.int().nullish(),
+    computedAt: z.int().nullish(),
+    costCacheReadUsd: z.number().nullish(),
+    costCacheWriteUsd: z.number().nullish(),
+    costInputUsd: z.number().nullish(),
+    costModelId: z.string().nullish(),
+    costOutputUsd: z.number().nullish(),
+    costReasoningUsd: z.number().nullish(),
+    costTotalUsd: z.number().nullish(),
+    discoveryTurns: z.int().nullish(),
+    durationMinutes: z.number().nullish(),
+    explorationRatio: z.number().nullish(),
+    filesTouched: z.int().nullish(),
+    inputTokens: z.int().nullish(),
+    linesChanged: z.int().nullish(),
+    m2TokenOutcomeRatio: z.number().nullish(),
+    m3UniqueToolCount: z.int().nullish(),
+    m4ConsecutiveErrorMax: z.int().nullish(),
+    m4ErrorRecoveryCount: z.int().nullish(),
+    m5AvgMessageTokens: z.int().nullish(),
+    m5ContextUtilizationPct: z.number().nullish(),
+    m5PeakContextTokens: z.int().nullish(),
+    m6LinesSurvived: z.int().nullish(),
+    m6LinesTotal: z.int().nullish(),
+    m6OutputSurvivalPct: z.number().nullish(),
+    m7SpecHasConstraints: z.boolean().nullish(),
+    m7SpecHasExamples: z.boolean().nullish(),
+    m7SpecWordCount: z.int().nullish(),
+    outcome: zSessionOutcome.nullish(),
+    outputTokens: z.int().nullish(),
+    retryLoops: z.int().nullish(),
+    retryTokensWasted: z.int().nullish(),
+    scope: z.string().nullish(),
+    scopeBreadth: z.int().nullish(),
+    signalDensity: z.number().nullish(),
+    specQualityScore: z.number().nullish(),
+    subagentCount: z.int().nullish(),
+    titleGenerated: z.string().nullish(),
+    toolCalls: z.int().nullish(),
+    totalTokens: z.int().nullish(),
+    turnCount: z.int().nullish(),
+    withinSessionReverts: z.int().nullish()
+});
+export const zSessionScorecard = z.object({
+    costTotalUsd: z.number().nullish(),
+    m2TokenOutcomeRatio: z.number().nullish(),
+    m4ConsecutiveErrorMax: z.int().nullish(),
+    m5ContextUtilizationPct: z.number().nullish(),
+    m6OutputSurvivalPct: z.number().nullish(),
+    m7SpecHasConstraints: z.boolean().nullish(),
+    m7SpecHasExamples: z.boolean().nullish(),
+    outcome: zSessionOutcome.optional(),
+    retryTokensWasted: z.int().nullish(),
+    signalDensity: z.number().nullish(),
+    specQualityScore: z.number().nullish(),
+    totalTokens: z.int().nullish(),
+    withinSessionReverts: z.int().nullish()
+});
+export const zSessionStats = z.object({
+    cachedReadTokens: z.int().nullish(),
+    cachedWriteTokens: z.int().nullish(),
+    durationMs: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    subagentCount: z.int(),
+    thoughtTokens: z.int().nullish(),
+    tokensIn: z.int(),
+    tokensOut: z.int(),
+    toolCallCount: z.int(),
+    turnCount: z.int()
+});
+export const zSessionSummary = z.object({
+    durationMins: z.number(),
+    harness: zHarness,
+    id: z.string(),
+    outcome: z.string().optional(),
+    parentSessionId: z.string().nullish(),
+    preview: z.string().optional(),
+    project: z.string().optional(),
+    projectHash: zProjectHash.optional(),
+    startTime: z.iso.datetime(),
+    toolCallCount: z.int(),
+    totalTokens: z.int(),
+    turnCount: z.int()
+});
+export const zSessionsPayload = z.object({
+    sessions: z.array(zSessionSummary).nullable()
+});
+export const zShutdownResponse = z.object({
+    status: z.string()
+});
+/**
+ * Source Format
+ *
+ * Transcript file format
+ */
+export const zSourceFormat = z.enum(['jsonl', 'json']);
+export const zSourceInfo = z.object({
+    filePath: z.string().optional(),
+    format: zSourceFormat
+});
+/**
+ * Stop Reason
+ *
+ * Reason why a session or turn ended (ACP-aligned)
+ */
+export const zStopReason = z.enum([
+    'end_turn',
+    'cancelled',
+    'max_tokens',
+    'max_turn_requests',
+    'refusal'
+]);
+export const zSubagentRef = z.object({
+    parentUuid: zSessionID,
+    sessionId: zSessionID
+});
+/**
+ * Target Kind
+ *
+ * What is being annotated: session-level, entry-level (turn/tool call), meta-annotation, project-level, a specific file version (content-hash keyed read-state receipt), or a durable session-to-commit association
+ */
+export const zTargetKind = z.enum([
+    'session',
+    'entry',
+    'annotation',
+    'project',
+    'file_version',
+    'association'
+]);
+export const zAnnotationPushItem = z.intersection(z.union([
+    z.object({
+        targetAssociationId: zAssociationID,
+        targetKind: z.literal('association')
+    }),
+    z.object({
+        sessionId: z.string().min(1),
+        targetKind: z.literal('session')
+    }),
+    z.object({
+        entryTarget: zAnnotationEntryTarget,
+        targetKind: z.literal('entry')
+    }),
+    z.object({
+        annotationId: z.string().min(1),
+        targetKind: z.literal('annotation')
+    }),
+    z.object({
+        projectHash: zProjectHash,
+        targetKind: z.literal('project')
+    })
+]), z.object({
+    annotationId: z.string().nullish(),
+    annotatorName: z.string().optional(),
+    confidence: z.number().nullish(),
+    contentHash: z.string(),
+    entryTarget: zAnnotationEntryTarget.nullish(),
+    isPrimary: z.boolean(),
+    projectHash: zProjectHash.nullish(),
+    provenance: zProvenance.nullish(),
+    reason: z.string().nullish(),
+    sessionId: z.string().nullish(),
+    targetAssociationId: zAssociationID.nullish(),
+    targetKind: zTargetKind,
+    typeId: z.string(),
+    value: z.string()
+})).superRefine((value, context) => {
+    const isPresent = (detail) => detail !== undefined && detail !== null;
+    const hasNonEmptyString = (detail) => typeof detail === "string" && detail !== "";
+    const hasOnly = (allowed) => {
+        const targetFields = [
+            ["targetAssociationId", value.targetAssociationId],
+            ["sessionId", value.sessionId],
+            ["entryTarget", value.entryTarget],
+            ["annotationId", value.annotationId],
+            ["projectHash", value.projectHash]
+        ];
+        return targetFields.every(([name, detail]) => allowed.includes(name) || !isPresent(detail));
+    };
+    const addIssue = (message) => context.addIssue({ code: "custom", message });
+    switch (value.targetKind) {
+        case "association":
+            if (!isPresent(value.targetAssociationId))
+                addIssue("association annotations require targetAssociationId");
+            if (!hasOnly(["targetAssociationId"]))
+                addIssue("association annotations must not mix target arms");
+            return;
+        case "session":
+            if (!hasNonEmptyString(value.sessionId))
+                addIssue("session annotations require a non-empty sessionId");
+            if (!hasOnly(["sessionId"]))
+                addIssue("session annotations must not mix target arms");
+            return;
+        case "entry":
+            if (!isPresent(value.entryTarget))
+                addIssue("entry annotations require entryTarget");
+            if (!hasOnly(["entryTarget"]))
+                addIssue("entry annotations must not mix target arms");
+            return;
+        case "annotation":
+            if (!hasNonEmptyString(value.annotationId))
+                addIssue("annotation targets require a non-empty annotationId");
+            if (!hasOnly(["annotationId"]))
+                addIssue("annotation targets must not mix target arms");
+            return;
+        case "project":
+            if (!isPresent(value.projectHash))
+                addIssue("project annotations require projectHash");
+            if (!hasOnly(["projectHash"]))
+                addIssue("project annotations must not mix target arms");
+            return;
+    }
+});
+export const zAnnotationPushRequest = z.object({
+    annotations: z.array(zAnnotationPushItem),
+    retractions: z.array(z.string()).optional()
+});
+export const zAnnotationSummary = z.object({
+    annotatorKind: zAnnotatorKind,
+    annotatorName: z.string(),
+    confidence: z.number().nullish(),
+    contentHash: z.string().nullish(),
+    createdAt: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    id: z.string(),
+    isPrimary: z.boolean(),
+    provenance: zProvenance.nullish(),
+    reason: z.string().nullish(),
+    supersededBy: z.string().nullish(),
+    targetAnnotationId: z.string().nullish(),
+    targetAssociationId: zAssociationID.nullish(),
+    targetContentHash: z.string().nullish(),
+    targetEntryEndIndex: z.int().nullish(),
+    targetEntryIndex: z.int().nullish(),
+    targetFilePath: z.string().nullish(),
+    targetKind: zTargetKind,
+    targetProjectHash: zProjectHash.nullish(),
+    targetSessionId: z.string().nullish(),
+    typeId: z.string(),
+    typeName: z.string(),
+    value: z.string()
+}).superRefine((value, context) => {
+    const isPresent = (detail) => detail !== undefined && detail !== null;
+    const hasNonEmptyString = (detail) => typeof detail === "string" && detail !== "";
+    const hasOnly = (allowed) => {
+        const targetFields = [
+            ["targetAssociationId", value.targetAssociationId],
+            ["targetSessionId", value.targetSessionId],
+            ["targetEntryIndex", value.targetEntryIndex],
+            ["targetEntryEndIndex", value.targetEntryEndIndex],
+            ["targetAnnotationId", value.targetAnnotationId],
+            ["targetProjectHash", value.targetProjectHash],
+            ["targetFilePath", value.targetFilePath],
+            ["targetContentHash", value.targetContentHash]
+        ];
+        return targetFields.every(([name, detail]) => allowed.includes(name) || !isPresent(detail));
+    };
+    const addIssue = (message) => context.addIssue({ code: "custom", message });
+    switch (value.targetKind) {
+        case "association":
+            if (!isPresent(value.targetAssociationId))
+                addIssue("association annotations require targetAssociationId");
+            if (!hasOnly(["targetAssociationId"]))
+                addIssue("association annotations must not mix target arms");
+            return;
+        case "session":
+            if (!hasNonEmptyString(value.targetSessionId))
+                addIssue("session annotations require a non-empty targetSessionId");
+            if (!hasOnly(["targetSessionId"]))
+                addIssue("session annotations must not mix target arms");
+            return;
+        case "entry":
+            if (!hasNonEmptyString(value.targetSessionId) || !isPresent(value.targetEntryIndex))
+                addIssue("entry annotations require targetSessionId and targetEntryIndex");
+            if (!hasOnly(["targetSessionId", "targetEntryIndex", "targetEntryEndIndex"]))
+                addIssue("entry annotations must not mix target arms");
+            if (value.targetEntryIndex !== undefined && value.targetEntryIndex !== null && value.targetEntryEndIndex !== undefined && value.targetEntryEndIndex !== null && value.targetEntryEndIndex <= value.targetEntryIndex)
+                addIssue("entry annotation targetEntryEndIndex must be greater than targetEntryIndex");
+            return;
+        case "annotation":
+            if (!hasNonEmptyString(value.targetAnnotationId))
+                addIssue("annotation targets require a non-empty targetAnnotationId");
+            if (!hasOnly(["targetAnnotationId"]))
+                addIssue("annotation targets must not mix target arms");
+            return;
+        case "project":
+            if (!isPresent(value.targetProjectHash))
+                addIssue("project annotations require targetProjectHash");
+            if (!hasOnly(["targetProjectHash"]))
+                addIssue("project annotations must not mix target arms");
+            return;
+        case "file_version":
+            if (!hasNonEmptyString(value.targetFilePath) || !hasNonEmptyString(value.targetContentHash))
+                addIssue("file_version annotations require non-empty targetFilePath and targetContentHash");
+            if (!hasOnly(["targetFilePath", "targetContentHash"]))
+                addIssue("file_version annotations must not mix target arms");
+            return;
+    }
+});
+export const zAnnotationsPayload = z.object({
+    annotations: z.array(zAnnotationSummary).nullable(),
+    axis: zAnnotationAxis,
+    id: z.string()
+});
+export const zPullAnnotation = z.object({
+    annotatorKind: zAnnotatorKind.optional(),
+    annotatorName: z.string().optional(),
+    authorUserId: z.string(),
+    authorUsername: z.string(),
+    confidence: z.number().nullish(),
+    contentHash: z.string().nullish(),
+    createdAt: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }).optional(),
+    id: z.string().optional(),
+    isPrimary: z.boolean().optional(),
+    provenance: zProvenance.optional(),
+    reason: z.string().nullish(),
+    supersededBy: z.string().nullish(),
+    targetAnnotationId: z.string().nullish(),
+    targetAssociationId: zAssociationID.optional(),
+    targetContentHash: z.string().nullish(),
+    targetEntryEndIndex: z.int().nullish(),
+    targetEntryIndex: z.int().nullish(),
+    targetFilePath: z.string().nullish(),
+    targetKind: zTargetKind.optional(),
+    targetProjectHash: zProjectHash.optional(),
+    targetSessionId: z.string().nullish(),
+    typeId: z.string().optional(),
+    typeName: z.string().optional(),
+    value: z.string().optional()
+});
+export const zQualitySession = z.object({
+    date: z.string(),
+    discoveryTurns: z.int(),
+    durationMinutes: z.number(),
+    effectiveAnnotations: z.array(zAnnotationSummary).optional(),
+    explorationRatio: z.number(),
+    filesTouched: z.int(),
+    id: z.string(),
+    inputTokens: z.int(),
+    linesChanged: z.int(),
+    outcome: z.string(),
+    outputTokens: z.int(),
+    project: z.string(),
+    retryLoops: z.int(),
+    retryTokensWasted: z.int(),
+    scope: z.string(),
+    scopeBreadth: z.int(),
+    signalDensity: z.number(),
+    specQualityScore: z.number(),
+    title: z.string(),
+    toolCalls: z.int(),
+    totalTokens: z.int(),
+    turnCount: z.int(),
+    withinSessionReverts: z.int()
+});
+export const zQualityPayload = z.object({
+    sessions: z.array(zQualitySession).nullable()
+});
+export const zTaskSummary = z.object({
+    editedFiles: z.array(z.string()).nullable(),
+    entryIndex: z.int(),
+    labels: z.array(z.string()).nullable(),
+    outcome: z.string().optional(),
+    readCount: z.int(),
+    readFiles: z.array(z.string()),
+    retryLoop: z.boolean(),
+    sessionId: z.string(),
+    startMs: z.int().nullish(),
+    title: z.string()
+});
+export const zChangeSession = z.object({
+    binding: zChangeBinding,
+    harness: z.string(),
+    sessionId: z.string(),
+    startMs: z.int().nullish(),
+    tasks: z.array(zTaskSummary).nullable(),
+    title: z.string()
+});
+export const zMapNodeDetailPayload = z.object({
+    costUsd: z.number().nullish(),
+    dependsOn: z.array(z.string()).nullable(),
+    insights: z.array(zSessionInsight),
+    kind: zMapNodeKind,
+    language: z.string().optional(),
+    lastTouchMs: z.int().nullish(),
+    loc: z.int(),
+    path: z.string(),
+    reEdits: z.int(),
+    recentCommits: z.array(zCommitRef).nullable(),
+    recordedFiles: z.int(),
+    retryLoops: z.int(),
+    rewrittenCommits: z.array(zRewrittenCommit),
+    sessionCount: z.int(),
+    shapedBy: z.array(zTaskSummary).nullable(),
+    taskCount: z.int(),
+    totalFiles: z.int(),
+    usedBy: z.array(z.string()).nullable()
+});
+export const zProjectTasksPayload = z.object({
+    fileFilter: z.string().optional(),
+    projectHash: zProjectHash,
+    tasks: z.array(zTaskSummary).nullable()
+});
+export const zTimelineSessionRef = z.object({
+    harness: zHarness,
+    hasCommitBinding: z.boolean(),
+    sessionId: zSessionID,
+    startMs: z.int().nullish(),
+    title: z.string()
+});
+export const zReviewListPayload = z.object({
+    changes: z.array(zChangeSummary),
+    defaultBranch: z.string().optional(),
+    projectHash: zProjectHash,
+    recentCommits: z.array(zCommitRef),
+    repoFound: z.boolean(),
+    rewrittenCommits: z.array(zRewrittenCommit),
+    sessions: z.array(zTimelineSessionRef)
+});
+export const zTimestampInfo = z.object({
+    end: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    ingested: z.int().nullish(),
+    start: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' })
+});
+/**
+ * Tool Call Kind
+ *
+ * Classification of a tool call, aligned with ACP ToolCallUpdate.kind
+ */
+export const zToolCallKind = z.enum([
+    'read',
+    'edit',
+    'delete',
+    'move',
+    'search',
+    'execute',
+    'think',
+    'fetch',
+    'other'
+]);
+export const zSessionEntry = z.object({
+    contentPreview: z.string().nullish(),
+    depth: z.int(),
+    entryId: z.string().nullish(),
+    entryIndex: z.int(),
+    entryType: zEntryType,
+    extra: z.string().nullish(),
+    harness: zHarness,
+    hasThinking: z.boolean(),
+    hasToolUse: z.boolean(),
+    isError: z.boolean(),
+    parentEntryId: z.string().nullish(),
+    parentIndex: z.int().nullish(),
+    partType: z.string().nullish(),
+    rawByteLength: z.int().nullish(),
+    role: zRole,
+    sessionId: zSessionID,
+    stopReason: zStopReason.nullish(),
+    timestampMs: z.int().nullish(),
+    tokensIn: z.int().nullish(),
+    tokensOut: z.int().nullish(),
+    toolCallId: z.string().nullish(),
+    toolInput: z.string().nullish(),
+    toolKind: zToolCallKind.nullish(),
+    toolNamesCsv: z.string().nullish(),
+    toolOutput: z.string().nullish()
+});
+export const zPublishRequest = z.object({
+    diagnostics: zDiagnosticsInfo,
+    entries: z.array(zSessionEntry).optional(),
+    git: zGitContext,
+    identity: zSessionIdentity,
+    license: zLicense.optional(),
+    model: zModelInfo,
+    project: zProjectContext,
+    quality: zQualityMetrics.nullish(),
+    source: zSourceInfo,
+    stats: zSessionStats,
+    subagents: z.array(zSubagentRef).optional(),
+    timestamp: zTimestampInfo
+});
+export const zToolCallDetail = z.object({
+    arguments: z.string(),
+    durationMs: z.int().nullish(),
+    exitCode: z.int().nullish(),
+    filePath: z.string().optional(),
+    id: z.string(),
+    isError: z.boolean().optional(),
+    name: z.string(),
+    result: z.string(),
+    toolKind: zToolCallKind.optional()
+});
+/**
+ * Transcript ID
+ *
+ * Village-side transcript identifier (canonical lowercase-hex UUID)
+ */
+export const zTranscriptID = z.uuid().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+export const zPullSkipGateItem = z.object({
+    annotationHashes: z.array(z.string()),
+    contentHash: z.string(),
+    transcriptId: zTranscriptID
+});
+export const zPullSkipGateRequest = z.object({
+    items: z.array(zPullSkipGateItem)
+});
+export const zPullSkipGateResult = z.object({
+    annotationsCurrent: z.boolean(),
+    contentCurrent: z.boolean(),
+    transcriptId: zTranscriptID
+});
+export const zPullSkipGateResponse = z.object({
+    results: z.array(zPullSkipGateResult)
+});
+export const zTrendsPayload = z.object({
+    days: z.array(zDayStats).nullable(),
+    totalSessions: z.int(),
+    totalTokens: z.int()
+});
+export const zTurnDetail = z.object({
+    agentName: z.string().optional(),
+    content: z.string(),
+    depth: z.int(),
+    entryType: zEntryType.optional(),
+    hasThinking: z.boolean().optional(),
+    index: z.int(),
+    parentIndex: z.int().nullish(),
+    role: zRole,
+    stopReason: zStopReason.nullish(),
+    timestamp: z.iso.datetime(),
+    tokensIn: z.int().nullish(),
+    tokensOut: z.int().nullish(),
+    toolCalls: z.array(zToolCallDetail).optional()
+});
+export const zSessionDetailPayload = z.object({
+    childSessions: z.array(zChildSessionRef).optional(),
+    durationMins: z.number(),
+    endTime: z.iso.datetime(),
+    gitBranch: z.string().optional(),
+    gitRemote: z.string().optional(),
+    harness: zHarness,
+    id: z.string(),
+    model: z.string().optional(),
+    outcome: zSessionOutcome.optional(),
+    project: z.string().optional(),
+    schemaVersion: z.string().optional(),
+    scorecard: zSessionScorecard.nullish(),
+    source: z.string().optional(),
+    startTime: z.iso.datetime(),
+    status: z.string().optional(),
+    tokensIn: z.int(),
+    tokensOut: z.int(),
+    toolCallCount: z.int(),
+    totalTokens: z.int(),
+    turnCount: z.int(),
+    turns: z.array(zTurnDetail).nullable(),
+    workingDirectory: z.string().optional()
+});
+export const zTranscriptContent = z.object({
+    contractVersion: z.string(),
+    kind: zContentKind,
+    sessionDetail: zSessionDetailPayload.nullish()
+});
+/**
+ * Type Origin
+ *
+ * Who created an annotation type: system (built-in), user (individual), or group (shared)
+ */
+export const zTypeOrigin = z.enum([
+    'system',
+    'user',
+    'group'
+]);
+export const zUnifiedMetadata = z.object({
+    contentHash: z.string(),
+    cwd: z.string().optional(),
+    derivedAt: z.int().nullish(),
+    diagnostics: zDiagnosticsInfo,
+    git: zGitContext,
+    harness: zHarness,
+    hostSlug: zHostSlug,
+    metadataHash: z.string(),
+    model: zModelID,
+    parentUuid: zSessionID.nullable(),
+    project: zProjectContext,
+    redaction: zRedactionInfo,
+    schemaVersion: z.int(),
+    sessionId: zSessionID,
+    source: zSourceInfo,
+    stats: zSessionStats,
+    subagents: z.array(zSubagentRef).nullable(),
+    timestamp: zTimestampInfo,
+    version: z.string()
+});
+export const zUnusualSignal = z.object({
+    kind: z.string(),
+    label: z.string(),
+    perChange: z.number(),
+    perProject: z.number()
+});
+export const zChangeDetailPayload = z.object({
+    baseRef: z.string(),
+    branch: z.string(),
+    costUsd: z.number().nullish(),
+    defaultBranch: z.string(),
+    files: z.array(zFileChange).nullable(),
+    frictions: z.array(zFrictionCluster).nullable(),
+    insights: z.array(zSessionInsight),
+    linesAdded: z.int(),
+    linesRemoved: z.int(),
+    newEdges: z.array(zMapEdge).nullable(),
+    newNodes: z.array(z.string()).nullable(),
+    outputTokens: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    removedEdges: z.array(zMapEdge).nullable(),
+    removedNodes: z.array(z.string()).nullable(),
+    slice: zMapSlice,
+    unrecordedCommits: z.array(zCommitRef).nullable(),
+    unusual: z.array(zUnusualSignal).nullable(),
+    violations: z.array(zEdgeViolation).nullable(),
+    work: z.array(zChangeSession).nullable()
+});
+/**
+ * Value Domain Kind
+ *
+ * ISO 11179 value domain: enumerated (finite allowed set) or described (range/pattern constraint)
+ */
+export const zValueDomainKind = z.enum(['enumerated', 'described']);
+export const zValueDomain = z.object({
+    constraintSpec: z.string().optional(),
+    datatype: zAnnotationDatatype,
+    kind: zValueDomainKind,
+    permissibleValues: z.array(z.string()).optional()
+});
+export const zAnnotationTypeSummary = z.object({
+    allowedTargetKinds: z.array(zTargetKind).optional(),
+    class: z.string(),
+    description: z.string().optional(),
+    displayName: z.string(),
+    family: z.string(),
+    id: z.string().optional(),
+    lowerIsBetter: z.boolean().nullish(),
+    origin: zTypeOrigin,
+    priorityOverride: z.int().nullish(),
+    scaleKind: zScaleKind.optional(),
+    status: zAnnotationStatus,
+    typeId: z.string(),
+    valueDomain: zValueDomain,
+    version: z.int()
+});
+export const zTaxonomyFamilyNode = z.object({
+    family: z.string(),
+    types: z.array(zAnnotationTypeSummary).nullable()
+});
+export const zTaxonomyNode = z.object({
+    class: z.string(),
+    families: z.array(zTaxonomyFamilyNode).nullable()
+});
+/**
+ * Visibility
+ *
+ * Access control level for a published transcript
+ */
+export const zVisibility = z.enum([
+    'private',
+    'group',
+    'public'
+]);
+export const zPullTranscriptInfo = z.object({
+    annotationCount: z.int(),
+    contentHash: z.string().optional(),
+    contractVersion: z.string().optional(),
+    harness: zHarness.optional(),
+    license: zLicense.optional(),
+    localId: z.string().optional(),
+    ownerUserId: z.string(),
+    ownerUsername: z.string(),
+    projectName: z.string().optional(),
+    publishedAt: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    title: z.string().optional(),
+    transcriptId: zTranscriptID,
+    updatedAt: z.coerce.bigint().min(BigInt('-9223372036854775808'), { error: 'Invalid value: Expected int64 to be >= -9223372036854775808' }).max(BigInt('9223372036854775807'), { error: 'Invalid value: Expected int64 to be <= 9223372036854775807' }),
+    visibility: zVisibility
+});
+export const zPullListResponse = z.object({
+    limit: z.int(),
+    page: z.int(),
+    total: z.int(),
+    transcripts: z.array(zPullTranscriptInfo).nullable()
+});
+export const zWalkthroughStep = z.object({
+    excerpt: z.string(),
+    file: z.string(),
+    line: z.int().nullish()
+});
+export const zWalkthroughTrail = z.object({
+    date: z.string(),
+    isCoherent: z.boolean(),
+    sessionId: z.string(),
+    steps: z.array(zWalkthroughStep).nullable(),
+    title: z.string(),
+    turnCount: z.int()
+});
+export const zFamiliarityPayload = z.object({
+    familiarityPct: z.number(),
+    files: z.array(zFileFamiliarity).nullable(),
+    freshnessDays: z.int().nullable(),
+    projectHash: zProjectHash,
+    suggestions: z.array(zReviewSuggestion).nullable(),
+    trails: z.array(zWalkthroughTrail).nullable(),
+    unexploredCount: z.int()
+});