@peasant-labs/schema 0.1.0-rc8 → 0.1.0

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

@@ -1,3 +1,4 @@
+// publication-contract-semantic-refinement
 // This file is auto-generated by @hey-api/openapi-ts
 import * as z from 'zod';
 export const zActivityEdge = z.object({
@@ -29,7 +30,12 @@ export const zAnnotationDatatype = z.enum([
 export const zAnnotationEntryTarget = z.object({
     endIndex: z.int(),
     entryIndex: z.int(),
-    sessionId: z.string()
+    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(),
@@ -181,6 +187,40 @@ export const zAssociationEvidenceObservation = z.object({
  * 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 zAuthoritativeCommitInfo = 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()
+}).strict();
+export const zAuthoritativeDiagnosticEntry = z.object({
+    errorType: z.string(),
+    location: z.string(),
+    message: z.string(),
+    remediation: z.string()
+}).strict();
+export const zAuthoritativeDiagnosticsInfo = z.object({
+    partial: z.boolean().nullish(),
+    warnings: z.array(zAuthoritativeDiagnosticEntry)
+}).strict();
+export const zAuthoritativeSessionStats = 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()
+}).strict();
+export const zAuthoritativeTimestampInfo = 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' })
+}).strict();
 export const zBatchCreateAnnotationsErrorResponse = z.object({
     error: z.string(),
     failingIndex: z.int()
@@ -225,6 +265,13 @@ export const zCLILoginQuery = z.object({
     port: z.int(),
     state: z.string()
 });
+export const zCanonicalPublishGitContext = z.object({
+    branch: z.string().nullable(),
+    commits: z.array(zAuthoritativeCommitInfo),
+    remote: z.string().nullable(),
+    tracking: z.string().nullable(),
+    worktree: z.string().nullable()
+}).strict();
 /**
  * Change Binding
  *
@@ -454,13 +501,6 @@ export const zFrictionCluster = z.object({
     label: z.string(),
     sessions: z.int()
 });
-export const zGitContext = z.object({
-    branch: z.string().nullish(),
-    commits: z.array(zCommitInfo).optional(),
-    remote: z.string().nullish(),
-    tracking: z.string().nullish(),
-    worktree: z.string().nullish()
-});
 /**
  * Harness
  *
@@ -472,7 +512,8 @@ export const zHarness = z.enum([
     'codex',
     'opencode',
     'cursor',
-    'antigravity'
+    'antigravity',
+    'strike'
 ]);
 export const zHealthResponse = z.object({
     status: z.string()
@@ -577,18 +618,37 @@ export const zMockConfigResponse = z.object({
  * Model identifier (e.g. 'claude-opus-4-6', 'gemini-2.0-flash')
  */
 export const zModelID = z.string().min(1);
+export const zAuthoritativeModelInfo = z.object({
+    harness: zHarness,
+    hostSlug: zHostSlug.optional(),
+    model: zModelID,
+    version: z.string().optional()
+}).strict();
 export const zModelInfo = z.object({
     harness: zHarness,
     hostSlug: zHostSlug.optional(),
     model: zModelID,
     version: z.string().optional()
 });
+/**
+ * Omitted preserves, null requests clear, and a canonical license replaces
+ */
+export const zOwnerUpdateLicenseIntent = z.enum([
+    'CC0-1.0',
+    'CC-BY-4.0',
+    'CC-BY-SA-4.0'
+]).nullable();
 /**
  * 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 zAuthoritativeProjectContext = z.object({
+    filePath: z.string().optional(),
+    hash: zProjectHash,
+    name: z.string()
+}).strict();
 export const zProjectContext = z.object({
     filePath: z.string().optional(),
     hash: zProjectHash,
@@ -616,6 +676,30 @@ export const zProvenance = z.object({
     method: z.string(),
     version: z.string().optional()
 });
+/**
+ * Publish Operation Kind
+ *
+ * Mutation semantic for one publish operation arm
+ */
+export const zPublishOperationKind = z.enum([
+    'preserve',
+    'replace',
+    'append'
+]);
+export const zPublishLicenseOperation = z.object({
+    kind: zPublishOperationKind,
+    license: zLicense.nullable()
+}).strict().superRefine((value, context) => {
+    const valid = (value.kind === "preserve" && value.license === null) || (value.kind === "replace" && value.license !== null);
+    if (!valid)
+        context.addIssue({ code: "custom", message: "license operation must be preserve+null or replace+license" });
+});
+/**
+ * Publish Request Fingerprint
+ *
+ * SHA3-256 digest of the canonical domain-separated publish operation
+ */
+export const zPublishRequestFingerprint = z.string().length(64).regex(/^[0-9a-f]{64}$/);
 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' }),
@@ -624,6 +708,70 @@ export const zPublishResponse = z.object({
     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()
+}).strict();
+export const zAuthoritativeGitContext = z.object({
+    associations: z.array(zPublishedAssociation).optional(),
+    branch: z.string().nullish(),
+    commits: z.array(zAuthoritativeCommitInfo).optional(),
+    remote: z.string().nullish(),
+    tracking: z.string().nullish(),
+    worktree: z.string().nullish()
+}).strict();
+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);
+        }
+    }
+});
+export const zPublishAssociationOperation = z.object({
+    associations: z.array(zPublishedAssociation),
+    kind: zPublishOperationKind
+}).strict().superRefine((value, context) => {
+    if (value.kind !== "append")
+        context.addIssue({ code: "custom", path: ["kind"], message: "association operation must append" });
+    const ids = new Set();
+    const hashes = new Set();
+    let prior = "";
+    for (const [index, association] of value.associations.entries()) {
+        const key = association.id + "\0" + association.observedCommitHash;
+        if (key < prior)
+            context.addIssue({ code: "custom", path: ["associations", index], message: "associations must use canonical ID and binding order" });
+        if (ids.has(association.id) || hashes.has(association.observedCommitHash) || association.observedCommitHash.trim() === "")
+            context.addIssue({ code: "custom", path: ["associations", index], message: "associations require unique nonempty IDs and bindings" });
+        ids.add(association.id);
+        hashes.add(association.observedCommitHash);
+        prior = key;
+    }
+});
 /**
  * Read Attribution State
  *
@@ -775,9 +923,18 @@ export const zServerMessage = z.object({
 /**
  * Session ID
  *
- * Unique session identifier (UUID, agent-{hex}, ses_{id}, sess_{id} (ACP), or msg_{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]+)$/);
+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 zAuthoritativeSessionIdentity = z.object({
+    parentSessionId: zSessionID.optional(),
+    schemaVersion: z.int(),
+    sessionId: zSessionID
+}).strict();
+export const zAuthoritativeSubagentRef = z.object({
+    parentUuid: zSessionID,
+    sessionId: zSessionID
+}).strict();
 export const zInsightEvidence = z.object({
     commitHash: z.string().optional(),
     entryIndex: z.int().nullish(),
@@ -877,6 +1034,50 @@ export const zSessionOutcome = z.enum([
     'partial',
     'failed'
 ]);
+export const zAuthoritativeQualityMetrics = 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()
+}).strict();
 export const zQualityMetrics = z.object({
     computeVersion: z.int().nullish(),
     computedAt: z.int().nullish(),
@@ -973,6 +1174,10 @@ export const zShutdownResponse = z.object({
  * Transcript file format
  */
 export const zSourceFormat = z.enum(['jsonl', 'json']);
+export const zAuthoritativeSourceInfo = z.object({
+    filePath: z.string().optional(),
+    format: zSourceFormat
+}).strict();
 export const zSourceInfo = z.object({
     filePath: z.string().optional(),
     format: zSourceFormat
@@ -1006,7 +1211,28 @@ export const zTargetKind = z.enum([
     'file_version',
     'association'
 ]);
-export const zAnnotationPushItem = z.object({
+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(),
@@ -1017,12 +1243,59 @@ export const zAnnotationPushItem = z.object({
     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).nullable(),
+    annotations: z.array(zAnnotationPushItem),
     retractions: z.array(z.string()).optional()
 });
 export const zAnnotationSummary = z.object({
@@ -1247,6 +1520,46 @@ export const zToolCallKind = z.enum([
     'fetch',
     'other'
 ]);
+export const zAuthoritativeSessionEntry = 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()
+}).strict();
+export const zCanonicalPublishReplacement = z.object({
+    diagnostics: zAuthoritativeDiagnosticsInfo,
+    entries: z.array(zAuthoritativeSessionEntry),
+    git: zCanonicalPublishGitContext,
+    identity: zAuthoritativeSessionIdentity,
+    model: zAuthoritativeModelInfo,
+    project: zAuthoritativeProjectContext,
+    quality: zAuthoritativeQualityMetrics.nullable(),
+    source: zAuthoritativeSourceInfo,
+    stats: zAuthoritativeSessionStats,
+    subagents: z.array(zAuthoritativeSubagentRef),
+    timestamp: zAuthoritativeTimestampInfo
+}).strict();
 export const zSessionEntry = z.object({
     contentPreview: z.string().nullish(),
     depth: z.int(),
@@ -1299,6 +1612,18 @@ export const zToolCallDetail = z.object({
     result: z.string(),
     toolKind: zToolCallKind.optional()
 });
+/**
+ * Transcript Content Hash
+ *
+ * SHA3-256 digest of the exact transcript file bytes
+ */
+export const zTranscriptContentHash = z.string().length(64).regex(/^[0-9a-f]{64}$/);
+export const zCanonicalPublishOperation = z.object({
+    associations: zPublishAssociationOperation,
+    contentHash: zTranscriptContentHash,
+    license: zPublishLicenseOperation,
+    replacement: zCanonicalPublishReplacement
+}).strict();
 /**
  * Transcript ID
  *
@@ -1321,6 +1646,65 @@ export const zPullSkipGateResult = z.object({
 export const zPullSkipGateResponse = z.object({
     results: z.array(zPullSkipGateResult)
 });
+/**
+ * TranscriptUpdateLicense
+ *
+ * License value for the owner transcript update operation: a canonical menu license, or the empty string to clear. Clearing a license that was actually granted is refused, because a granted Creative Commons license is irrevocable.
+ */
+export const zTranscriptUpdateLicense = z.enum([
+    '',
+    'CC0-1.0',
+    'CC-BY-4.0',
+    'CC-BY-SA-4.0'
+]);
+/**
+ * TranscriptUpdateVisibility
+ *
+ * Visibility values accepted by the owner transcript update operation. Organization-scoped visibility is deferred and is deliberately not offered here.
+ */
+export const zTranscriptUpdateVisibility = z.enum(['private', 'public']);
+export const zOwnerTranscriptUpdateRequest = z.object({
+    description: z.string().optional(),
+    license: zOwnerUpdateLicenseIntent.optional(),
+    tags: z.array(z.string()).optional(),
+    title: z.string().max(500).optional(),
+    visibility: zTranscriptUpdateVisibility.optional()
+}).strict();
+export const zOwnerTranscriptUpdateResponse = z.object({
+    description: z.string().nullable(),
+    license: zLicense.nullable(),
+    tags: z.array(z.string()),
+    title: z.string().nullable(),
+    transcriptId: zTranscriptID,
+    transcriptUrl: 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' }),
+    visibility: zTranscriptUpdateVisibility
+}).strict().superRefine((value, context) => {
+    let parsed;
+    try {
+        parsed = new URL(value.transcriptUrl);
+    }
+    catch {
+        context.addIssue({ code: "custom", path: ["transcriptUrl"], message: "transcriptUrl must be absolute HTTPS and bind transcriptId" });
+        return;
+    }
+    if (parsed.protocol !== "https:" || parsed.search || parsed.hash || parsed.pathname.replace(/\/$/, "") !== "/transcripts/" + value.transcriptId)
+        context.addIssue({ code: "custom", path: ["transcriptUrl"], message: "transcriptUrl must be exact HTTPS /transcripts/{transcriptId}" });
+    if (value.updatedAt <= 0n)
+        context.addIssue({ code: "custom", path: ["updatedAt"], message: "updatedAt must be positive" });
+    const tags = new Set();
+    for (const [index, tag] of value.tags.entries()) {
+        if (tag.trim() === "" || tag !== tag.trim() || tags.has(tag))
+            context.addIssue({ code: "custom", path: ["tags", index], message: "tags must be unique nonempty trimmed strings" });
+        tags.add(tag);
+    }
+});
+export const zTranscriptUpdateRequest = z.object({
+    description: z.string().optional(),
+    license: zTranscriptUpdateLicense.optional(),
+    title: z.string().max(500).optional(),
+    visibility: zTranscriptUpdateVisibility.optional()
+}).strict();
 export const zTrendsPayload = z.object({
     days: z.array(zDayStats).nullable(),
     totalSessions: z.int(),
@@ -1474,6 +1858,49 @@ export const zVisibility = z.enum([
     'group',
     'public'
 ]);
+export const zPublishNormalizedValues = z.object({
+    derivedTitle: z.string().nullable(),
+    entryHarnesses: z.array(zHarness),
+    rootHarness: zHarness,
+    schemaVersion: z.string(),
+    visibility: zVisibility
+}).strict().superRefine((value, context) => {
+    if (!/^[1-9][0-9]*$/.test(value.schemaVersion))
+        context.addIssue({ code: "custom", path: ["schemaVersion"], message: "schemaVersion must be positive canonical decimal text" });
+});
+export const zPublishAppliedState = z.object({
+    associations: z.array(zPublishedAssociation),
+    license: zLicense.nullable(),
+    normalizedValues: zPublishNormalizedValues
+}).strict();
+export const zAuthoritativePublishResponse = z.object({
+    applied: zPublishAppliedState,
+    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' }),
+    contentHash: zTranscriptContentHash,
+    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' }),
+    requestOperationFingerprint: zPublishRequestFingerprint,
+    transcriptId: zTranscriptID,
+    transcriptUrl: 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' }),
+    visibility: zVisibility
+}).strict().superRefine((value, context) => {
+    let parsed;
+    try {
+        parsed = new URL(value.transcriptUrl);
+    }
+    catch {
+        context.addIssue({ code: "custom", path: ["transcriptUrl"], message: "transcriptUrl must be absolute HTTPS and bind transcriptId" });
+        return;
+    }
+    if (parsed.protocol !== "https:" || parsed.search || parsed.hash || parsed.pathname.replace(/\/$/, "") !== "/transcripts/" + value.transcriptId)
+        context.addIssue({ code: "custom", path: ["transcriptUrl"], message: "transcriptUrl must be exact HTTPS /transcripts/{transcriptId}" });
+    if (value.blobKey.trim() === "" || value.blobSizeBytes < 0n || value.publishedAt <= 0n || value.updatedAt < value.publishedAt)
+        context.addIssue({ code: "custom", message: "blob facts and publication chronology must be complete and ordered" });
+    if (value.visibility !== value.applied.normalizedValues.visibility)
+        context.addIssue({ code: "custom", path: ["applied", "normalizedValues", "visibility"], message: "top-level and applied visibility must agree" });
+});
 export const zPullTranscriptInfo = z.object({
     annotationCount: z.int(),
     contentHash: z.string().optional(),
@@ -1496,6 +1923,28 @@ export const zPullListResponse = z.object({
     total: z.int(),
     transcripts: z.array(zPullTranscriptInfo).nullable()
 });
+/**
+ * Visibility Intent
+ *
+ * Optional desired final access for legacy compatibility; content replacement remains private and widening occurs separately
+ */
+export const zVisibilityIntent = z.enum(['private', 'public']);
+export const zAuthoritativePublishRequest = z.object({
+    contentHash: zTranscriptContentHash,
+    diagnostics: zAuthoritativeDiagnosticsInfo.optional(),
+    entries: z.array(zAuthoritativeSessionEntry).optional(),
+    git: zAuthoritativeGitContext.optional(),
+    identity: zAuthoritativeSessionIdentity.optional(),
+    license: zLicense.optional(),
+    model: zAuthoritativeModelInfo,
+    project: zAuthoritativeProjectContext.optional(),
+    quality: zAuthoritativeQualityMetrics.optional(),
+    source: zAuthoritativeSourceInfo.optional(),
+    stats: zAuthoritativeSessionStats.optional(),
+    subagents: z.array(zAuthoritativeSubagentRef).optional(),
+    timestamp: zAuthoritativeTimestampInfo.optional(),
+    visibilityIntent: zVisibilityIntent.optional()
+}).strict();
 export const zWalkthroughStep = z.object({
     excerpt: z.string(),
     file: z.string(),