@peasant-labs/schema 0.1.0-rc6 → 0.1.0-rc9

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

@@ -29,7 +29,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(),
@@ -89,6 +94,98 @@ export const zAnnotatorSummary = z.object({
     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()
@@ -189,6 +286,16 @@ export const zCommitInfo = z.object({
     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
  *
@@ -352,13 +459,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
  *
@@ -381,6 +481,30 @@ export const zHealthResponse = z.object({
  * 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
  *
@@ -417,26 +541,6 @@ export const zMapNodeKind = z.enum([
     'package',
     'file'
 ]);
-export const zMapNode = z.object({
-    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(),
-    recordedFiles: z.int(),
-    totalFiles: z.int(),
-    touchCount: z.int()
-});
-export const zMapSlice = z.object({
-    activityEdges: z.array(zActivityEdge).nullable(),
-    nodes: z.array(zMapNode).nullable(),
-    structureEdges: z.array(zMapEdge).nullable()
-});
 /**
  * Message Type
  *
@@ -483,18 +587,6 @@ export const zModelInfo = z.object({
  * 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 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 zProjectContext = z.object({
     filePath: z.string().optional(),
     hash: zProjectHash,
@@ -530,6 +622,102 @@ 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()
+});
+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(),
@@ -543,6 +731,29 @@ export const zReviewSuggestion = z.object({
     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
  *
@@ -601,18 +812,95 @@ export const zServerMessage = z.object({
  * Unique session identifier (UUID, agent-{hex}, ses_{id}, sess_{id} (ACP), or msg_{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 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
  *
@@ -742,15 +1030,38 @@ export const zSubagentRef = z.object({
 /**
  * Target Kind
  *
- * What is being annotated: session-level, entry-level (turn/tool call), meta-annotation, or project-level
+ * 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'
+    'project',
+    '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(),
@@ -761,12 +1072,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({
@@ -781,14 +1139,74 @@ export const zAnnotationSummary = z.object({
     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(),
@@ -809,8 +1227,11 @@ export const zPullAnnotation = z.object({
     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(),
@@ -852,6 +1273,7 @@ export const zTaskSummary = z.object({
     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(),
@@ -868,6 +1290,7 @@ export const zChangeSession = z.object({
 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(),
@@ -877,6 +1300,7 @@ export const zMapNodeDetailPayload = z.object({
     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(),
@@ -901,6 +1325,7 @@ export const zReviewListPayload = z.object({
     projectHash: zProjectHash,
     recentCommits: z.array(zCommitRef),
     repoFound: z.boolean(),
+    rewrittenCommits: z.array(zRewrittenCommit),
     sessions: z.array(zTimelineSessionRef)
 });
 export const zTimestampInfo = z.object({
@@ -1091,6 +1516,7 @@ export const zChangeDetailPayload = z.object({
     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(),