@peasant-labs/schema 0.1.0-rc9 → 0.1.1-rc1

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({
@@ -186,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()
@@ -230,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
  *
@@ -470,7 +512,8 @@ export const zHarness = z.enum([
     'codex',
     'opencode',
     'cursor',
-    'antigravity'
+    'antigravity',
+    'strike'
 ]);
 export const zHealthResponse = z.object({
     status: z.string()
@@ -575,18 +618,43 @@ 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()
 });
+/**
+ * Observed Model ID
+ *
+ * Exact UTF-8 model identifier observed on an assistant-generated turn; producer-enforced as assistant or subagent evidence. Values are non-empty and may not have a Unicode White_Space code point at either edge; all accepted bytes, including Unicode, mixed case, slashes, and internal spaces, are preserved.
+ */
+export const zObservedModelID = z.string().min(1).regex(/^(?:|[^\s\x85])(?:[\s\S]*(?:|[^\s\x85]))?(?![\s\S])/);
+/**
+ * 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,
@@ -614,6 +682,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' }),
@@ -625,7 +717,15 @@ export const zPublishResponse = z.object({
 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(),
@@ -658,6 +758,26 @@ export const zGitContext = z.object({
         }
     }
 });
+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
  *
@@ -809,9 +929,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(),
@@ -911,6 +1040,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(),
@@ -1007,6 +1180,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
@@ -1349,6 +1526,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(),
@@ -1401,6 +1618,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
  *
@@ -1423,6 +1652,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(),
@@ -1435,6 +1723,7 @@ export const zTurnDetail = z.object({
     entryType: zEntryType.optional(),
     hasThinking: z.boolean().optional(),
     index: z.int(),
+    observedModel: zObservedModelID.optional(),
     parentIndex: z.int().nullish(),
     role: zRole,
     stopReason: zStopReason.nullish(),
@@ -1576,6 +1865,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(),
@@ -1598,6 +1930,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(),

package/dist/internal/generated/enums.gen.d.ts

@@ -1,3 +1,5 @@
+import { type PublishOperationKind as PublishOperationKindContract } from "./contract/zod.gen.js";
+import { type VisibilityIntent as VisibilityIntentContract } from "./contract/zod.gen.js";
 import { type AnnotationAxis as AnnotationAxisContract } from "./contract/zod.gen.js";
 import { type AnnotationDatatype as AnnotationDatatypeContract } from "./contract/zod.gen.js";
 import { type AnnotationPushStatus as AnnotationPushStatusContract } from "./contract/zod.gen.js";
@@ -35,7 +37,24 @@ import { type TargetKind as TargetKindContract } from "./contract/zod.gen.js";
 import { type ToolCallKind as ToolCallKindContract } from "./contract/zod.gen.js";
 import { type TypeOrigin as TypeOriginContract } from "./contract/zod.gen.js";
 import { type ValueDomainKind as ValueDomainKindContract } from "./contract/zod.gen.js";
+import { type TranscriptUpdateLicense as TranscriptUpdateLicenseContract } from "./contract/zod.gen.js";
+import { type TranscriptUpdateVisibility as TranscriptUpdateVisibilityContract } from "./contract/zod.gen.js";
 import { type Visibility as VisibilityContract } from "./contract/zod.gen.js";
+export type PublishOperationKind = PublishOperationKindContract;
+export declare const PublishOperationKind: Readonly<{
+    readonly Preserve: "replace" | "append" | "preserve";
+    readonly Replace: "replace" | "append" | "preserve";
+    readonly Append: "replace" | "append" | "preserve";
+}>;
+export declare const AllPublishOperationKinds: readonly PublishOperationKind[];
+export declare function isPublishOperationKind(value: unknown): value is PublishOperationKind;
+export type VisibilityIntent = VisibilityIntentContract;
+export declare const VisibilityIntent: Readonly<{
+    readonly Private: "private" | "public";
+    readonly Public: "private" | "public";
+}>;
+export declare const AllVisibilityIntents: readonly VisibilityIntent[];
+export declare function isVisibilityIntent(value: unknown): value is VisibilityIntent;
 export type AnnotationAxis = AnnotationAxisContract;
 export declare const AnnotationAxis: Readonly<{
     readonly Type: "type" | "session" | "project";
@@ -206,12 +225,13 @@ export declare const AllFileChangeStatuses: readonly FileChangeStatus[];
 export declare function isFileChangeStatus(value: unknown): value is FileChangeStatus;
 export type Harness = HarnessContract;
 export declare const Harness: Readonly<{
-    readonly ClaudeCode: "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
-    readonly GeminiCLI: "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
-    readonly Codex: "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
-    readonly OpenCode: "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
-    readonly Cursor: "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
-    readonly Antigravity: "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
+    readonly ClaudeCode: "strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
+    readonly GeminiCLI: "strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
+    readonly Codex: "strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
+    readonly OpenCode: "strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
+    readonly Cursor: "strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
+    readonly Antigravity: "strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
+    readonly Strike: "strike" | "cursor" | "claude-code" | "gemini-cli" | "codex" | "opencode" | "antigravity";
 }>;
 /**
  * AllHarnesses is the ingestion-supported subset of Harness, not the full
@@ -395,6 +415,22 @@ export declare const ValueDomainKind: Readonly<{
 }>;
 export declare const AllValueDomainKinds: readonly ValueDomainKind[];
 export declare function isValueDomainKind(value: unknown): value is ValueDomainKind;
+export type TranscriptUpdateLicense = TranscriptUpdateLicenseContract;
+export declare const TranscriptUpdateLicense: Readonly<{
+    readonly Clear: "" | "CC0-1.0" | "CC-BY-4.0" | "CC-BY-SA-4.0";
+    readonly CC0: "" | "CC0-1.0" | "CC-BY-4.0" | "CC-BY-SA-4.0";
+    readonly CCBY: "" | "CC0-1.0" | "CC-BY-4.0" | "CC-BY-SA-4.0";
+    readonly CCBYSA: "" | "CC0-1.0" | "CC-BY-4.0" | "CC-BY-SA-4.0";
+}>;
+export declare const AllTranscriptUpdateLicenses: readonly TranscriptUpdateLicense[];
+export declare function isTranscriptUpdateLicense(value: unknown): value is TranscriptUpdateLicense;
+export type TranscriptUpdateVisibility = TranscriptUpdateVisibilityContract;
+export declare const TranscriptUpdateVisibility: Readonly<{
+    readonly Private: "private" | "public";
+    readonly Public: "private" | "public";
+}>;
+export declare const AllTranscriptUpdateVisibilities: readonly TranscriptUpdateVisibility[];
+export declare function isTranscriptUpdateVisibility(value: unknown): value is TranscriptUpdateVisibility;
 export type Visibility = VisibilityContract;
 export declare const Visibility: Readonly<{
     readonly Private: "private" | "public" | "group";

package/dist/internal/generated/enums.gen.js

@@ -1,4 +1,6 @@
 // Code generated from the canonical Go/OpenAPI contract. DO NOT EDIT.
+import { zPublishOperationKind } from "./contract/zod.gen.js";
+import { zVisibilityIntent } from "./contract/zod.gen.js";
 import { zAnnotationAxis } from "./contract/zod.gen.js";
 import { zAnnotationDatatype } from "./contract/zod.gen.js";
 import { zAnnotationPushStatus } from "./contract/zod.gen.js";
@@ -36,7 +38,26 @@ import { zTargetKind } from "./contract/zod.gen.js";
 import { zToolCallKind } from "./contract/zod.gen.js";
 import { zTypeOrigin } from "./contract/zod.gen.js";
 import { zValueDomainKind } from "./contract/zod.gen.js";
+import { zTranscriptUpdateLicense } from "./contract/zod.gen.js";
+import { zTranscriptUpdateVisibility } from "./contract/zod.gen.js";
 import { zVisibility } from "./contract/zod.gen.js";
+export const PublishOperationKind = Object.freeze({
+    Preserve: zPublishOperationKind.parse("preserve"),
+    Replace: zPublishOperationKind.parse("replace"),
+    Append: zPublishOperationKind.parse("append"),
+});
+export const AllPublishOperationKinds = Object.freeze([PublishOperationKind.Preserve, PublishOperationKind.Replace, PublishOperationKind.Append]);
+export function isPublishOperationKind(value) {
+    return zPublishOperationKind.safeParse(value).success;
+}
+export const VisibilityIntent = Object.freeze({
+    Private: zVisibilityIntent.parse("private"),
+    Public: zVisibilityIntent.parse("public"),
+});
+export const AllVisibilityIntents = Object.freeze([VisibilityIntent.Private, VisibilityIntent.Public]);
+export function isVisibilityIntent(value) {
+    return zVisibilityIntent.safeParse(value).success;
+}
 export const AnnotationAxis = Object.freeze({
     Type: zAnnotationAxis.parse("type"),
     Session: zAnnotationAxis.parse("session"),
@@ -229,13 +250,14 @@ export const Harness = Object.freeze({
     OpenCode: zHarness.parse("opencode"),
     Cursor: zHarness.parse("cursor"),
     Antigravity: zHarness.parse("antigravity"),
+    Strike: zHarness.parse("strike"),
 });
 /**
  * AllHarnesses is the ingestion-supported subset of Harness, not the full
  * canonical set (mirrors types.go's AllHarnesses doc comment). Every Harness
  * member remains individually valid and accepted by isHarness.
  */
-export const AllHarnesses = Object.freeze([Harness.ClaudeCode, Harness.GeminiCLI, Harness.Codex, Harness.OpenCode, Harness.Cursor]);
+export const AllHarnesses = Object.freeze([Harness.ClaudeCode, Harness.GeminiCLI, Harness.Codex, Harness.OpenCode, Harness.Cursor, Harness.Strike]);
 export function isHarness(value) {
     return zHarness.safeParse(value).success;
 }
@@ -433,6 +455,24 @@ export const AllValueDomainKinds = Object.freeze([ValueDomainKind.Enumerated, Va
 export function isValueDomainKind(value) {
     return zValueDomainKind.safeParse(value).success;
 }
+export const TranscriptUpdateLicense = Object.freeze({
+    Clear: zTranscriptUpdateLicense.parse(""),
+    CC0: zTranscriptUpdateLicense.parse("CC0-1.0"),
+    CCBY: zTranscriptUpdateLicense.parse("CC-BY-4.0"),
+    CCBYSA: zTranscriptUpdateLicense.parse("CC-BY-SA-4.0"),
+});
+export const AllTranscriptUpdateLicenses = Object.freeze([TranscriptUpdateLicense.Clear, TranscriptUpdateLicense.CC0, TranscriptUpdateLicense.CCBY, TranscriptUpdateLicense.CCBYSA]);
+export function isTranscriptUpdateLicense(value) {
+    return zTranscriptUpdateLicense.safeParse(value).success;
+}
+export const TranscriptUpdateVisibility = Object.freeze({
+    Private: zTranscriptUpdateVisibility.parse("private"),
+    Public: zTranscriptUpdateVisibility.parse("public"),
+});
+export const AllTranscriptUpdateVisibilities = Object.freeze([TranscriptUpdateVisibility.Private, TranscriptUpdateVisibility.Public]);
+export function isTranscriptUpdateVisibility(value) {
+    return zTranscriptUpdateVisibility.safeParse(value).success;
+}
 export const Visibility = Object.freeze({
     Private: zVisibility.parse("private"),
     Group: zVisibility.parse("group"),

package/dist/internal/generated/local-api.d.ts

@@ -485,6 +485,13 @@ export interface components {
          */
         SchemaMessageType: Schema.MessageType;
         SchemaMockConfigResponse: Schema.MockConfigResponse;
+        /**
+         * Observed Model ID
+         * @description Exact UTF-8 model identifier observed on an assistant-generated turn; producer-enforced as assistant or subagent evidence. Values are non-empty and may not have a Unicode White_Space code point at either edge; all accepted bytes, including Unicode, mixed case, slashes, and internal spaces, are preserved.
+         * @example anthropic/Claude-Opus-4-8
+         * @example provider/Model Family
+         */
+        SchemaObservedModelID: Schema.ObservedModelID;
         /**
          * Project Hash
          * @description SHA-256 hex digest of the project's origin URL or local path
@@ -563,11 +570,13 @@ export interface components {
         /**
          * Session ID
          * Format: session-id
-         * @description Unique session identifier (UUID, agent-{hex}, ses_{id}, sess_{id} (ACP), or msg_{id})
+         * @description Unique session identifier (UUID, agent-{hex}, ses_{id}, sess_{id} (ACP), msg_{id}, or a Strike session ID)
          * @example 99d59925-36bc-424c-a789-8be54d9702ba
          * @example agent-a3aee4f
          * @example ses_3cd91f52effeXd3QAJ54jOyzv5
          * @example sess_3cd91f52effeXd3QAJ54jOyzv5
+         * @example 20260728T123456.123456789Z-ABCDEFGHIJKLMNOPQRST234567
+         * @example ABCDEFGHIJKLMNOPQRST234567
          */
         SchemaSessionID: Schema.SessionID;
         SchemaSessionInsight: Schema.SessionInsight;