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

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

@@ -89,6 +89,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 +281,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
  *
@@ -381,6 +483,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 +543,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 +589,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 +624,66 @@ 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' })
 });
+/**
+ * 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 +697,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 +778,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,13 +996,15 @@ 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({
     annotationId: z.string().nullish(),
@@ -781,14 +1037,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 +1125,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 +1171,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 +1188,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 +1198,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 +1223,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 +1414,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(),

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

@@ -3,9 +3,12 @@ import { type AnnotationDatatype as AnnotationDatatypeContract } from "./contrac
 import { type AnnotationPushStatus as AnnotationPushStatusContract } from "./contract/zod.gen.js";
 import { type AnnotationStatus as AnnotationStatusContract } from "./contract/zod.gen.js";
 import { type AnnotatorKind as AnnotatorKindContract } from "./contract/zod.gen.js";
+import { type AssociationConclusion as AssociationConclusionContract } from "./contract/zod.gen.js";
+import { type AssociationEvidenceKind as AssociationEvidenceKindContract } from "./contract/zod.gen.js";
 import { type BuiltinCommand as BuiltinCommandContract } from "./contract/zod.gen.js";
 import { type ChangeBinding as ChangeBindingContract } from "./contract/zod.gen.js";
 import { type ChannelTopic as ChannelTopicContract } from "./contract/zod.gen.js";
+import { type Confidence as ConfidenceContract } from "./contract/zod.gen.js";
 import { type ContentKind as ContentKindContract } from "./contract/zod.gen.js";
 import { type DecayLevel as DecayLevelContract } from "./contract/zod.gen.js";
 import { type DiffLineKind as DiffLineKindContract } from "./contract/zod.gen.js";
@@ -13,10 +16,16 @@ import { type EdgeViolationKind as EdgeViolationKindContract } from "./contract/
 import { type EntryType as EntryTypeContract } from "./contract/zod.gen.js";
 import { type FileChangeStatus as FileChangeStatusContract } from "./contract/zod.gen.js";
 import { type Harness as HarnessContract } from "./contract/zod.gen.js";
+import { type InsightKind as InsightKindContract } from "./contract/zod.gen.js";
+import { type InsightProvenance as InsightProvenanceContract } from "./contract/zod.gen.js";
 import { type InteractionType as InteractionTypeContract } from "./contract/zod.gen.js";
 import { type License as LicenseContract } from "./contract/zod.gen.js";
 import { type MapNodeKind as MapNodeKindContract } from "./contract/zod.gen.js";
 import { type MessageType as MessageTypeContract } from "./contract/zod.gen.js";
+import { type ReadAttributionState as ReadAttributionStateContract } from "./contract/zod.gen.js";
+import { type ReadStateGrade as ReadStateGradeContract } from "./contract/zod.gen.js";
+import { type RewriteMethod as RewriteMethodContract } from "./contract/zod.gen.js";
+import { type RewriteResolution as RewriteResolutionContract } from "./contract/zod.gen.js";
 import { type Role as RoleContract } from "./contract/zod.gen.js";
 import { type ScaleKind as ScaleKindContract } from "./contract/zod.gen.js";
 import { type SessionOutcome as SessionOutcomeContract } from "./contract/zod.gen.js";
@@ -70,6 +79,22 @@ export declare const AnnotatorKind: Readonly<{
 }>;
 export declare const AllAnnotatorKinds: readonly AnnotatorKind[];
 export declare function isAnnotatorKind(value: unknown): value is AnnotatorKind;
+export type AssociationConclusion = AssociationConclusionContract;
+export declare const AssociationConclusion: Readonly<{
+    readonly Confirmed: "candidate" | "confirmed";
+    readonly Candidate: "candidate" | "confirmed";
+}>;
+export declare const AllAssociationConclusions: readonly AssociationConclusion[];
+export declare function isAssociationConclusion(value: unknown): value is AssociationConclusion;
+export type AssociationEvidenceKind = AssociationEvidenceKindContract;
+export declare const AssociationEvidenceKind: Readonly<{
+    readonly RecordedCommit: "recorded_commit" | "touched_file" | "branch_membership" | "time_window";
+    readonly TouchedFile: "recorded_commit" | "touched_file" | "branch_membership" | "time_window";
+    readonly BranchMembership: "recorded_commit" | "touched_file" | "branch_membership" | "time_window";
+    readonly TimeWindow: "recorded_commit" | "touched_file" | "branch_membership" | "time_window";
+}>;
+export declare const AllAssociationEvidenceKinds: readonly AssociationEvidenceKind[];
+export declare function isAssociationEvidenceKind(value: unknown): value is AssociationEvidenceKind;
 export type BuiltinCommand = BuiltinCommandContract;
 export declare const BuiltinCommand: Readonly<{
     readonly Exit: "new" | "clear" | "resume" | "exit" | "compact" | "config" | "model" | "usage" | "cost" | "context" | "plugin" | "permissions" | "login" | "plan" | "fast" | "voice" | "todos" | "reload-plugins" | "sandbox" | "statusline" | "upgrade" | "extra-usage" | "rate-limit-options" | "privacy-settings" | "help" | "commands";
@@ -120,6 +145,14 @@ export declare const ChannelTopic: Readonly<{
 }>;
 export declare const AllChannelTopics: readonly ChannelTopic[];
 export declare function isChannelTopic(value: unknown): value is ChannelTopic;
+export type Confidence = ConfidenceContract;
+export declare const Confidence: Readonly<{
+    readonly High: "high" | "low" | "medium";
+    readonly Medium: "high" | "low" | "medium";
+    readonly Low: "high" | "low" | "medium";
+}>;
+export declare const AllConfidences: readonly Confidence[];
+export declare function isConfidence(value: unknown): value is Confidence;
 export type ContentKind = ContentKindContract;
 export declare const ContentKind: Readonly<{
     readonly SessionDetail: "session_detail";
@@ -187,6 +220,22 @@ export declare const Harness: Readonly<{
  */
 export declare const AllHarnesses: readonly Harness[];
 export declare function isHarness(value: unknown): value is Harness;
+export type InsightKind = InsightKindContract;
+export declare const InsightKind: Readonly<{
+    readonly Decision: "decision" | "friction" | "unusual" | "retry_loop";
+    readonly Friction: "decision" | "friction" | "unusual" | "retry_loop";
+    readonly Unusual: "decision" | "friction" | "unusual" | "retry_loop";
+    readonly RetryLoop: "decision" | "friction" | "unusual" | "retry_loop";
+}>;
+export declare const AllInsightKinds: readonly InsightKind[];
+export declare function isInsightKind(value: unknown): value is InsightKind;
+export type InsightProvenance = InsightProvenanceContract;
+export declare const InsightProvenance: Readonly<{
+    readonly Mechanical: "mechanical" | "mined";
+    readonly Mined: "mechanical" | "mined";
+}>;
+export declare const AllInsightProvenances: readonly InsightProvenance[];
+export declare function isInsightProvenance(value: unknown): value is InsightProvenance;
 export type InteractionType = InteractionTypeContract;
 export declare const InteractionType: Readonly<{
     readonly Mentioned: "mentioned" | "read" | "discussed" | "questioned";
@@ -228,6 +277,42 @@ export declare const MessageType: Readonly<{
 }>;
 export declare const AllMessageTypes: readonly MessageType[];
 export declare function isMessageType(value: unknown): value is MessageType;
+export type ReadAttributionState = ReadAttributionStateContract;
+export declare const ReadAttributionState: Readonly<{
+    readonly Complete: "complete" | "partial" | "unavailable";
+    readonly Partial: "complete" | "partial" | "unavailable";
+    readonly Unavailable: "complete" | "partial" | "unavailable";
+}>;
+export declare const AllReadAttributionStates: readonly ReadAttributionState[];
+export declare function isReadAttributionState(value: unknown): value is ReadAttributionState;
+export type ReadStateGrade = ReadStateGradeContract;
+export declare const ReadStateGrade: Readonly<{
+    readonly None: "none" | "viewed" | "reviewed" | "reviewed_in_detail";
+    readonly Viewed: "none" | "viewed" | "reviewed" | "reviewed_in_detail";
+    readonly Reviewed: "none" | "viewed" | "reviewed" | "reviewed_in_detail";
+    readonly ReviewedInDetail: "none" | "viewed" | "reviewed" | "reviewed_in_detail";
+}>;
+export declare const AllReadStateGrades: readonly ReadStateGrade[];
+export declare function isReadStateGrade(value: unknown): value is ReadStateGrade;
+export type RewriteMethod = RewriteMethodContract;
+export declare const RewriteMethod: Readonly<{
+    readonly Hash: "none" | "hash" | "patch_id" | "author_identity" | "message_embedded" | "temporal";
+    readonly PatchID: "none" | "hash" | "patch_id" | "author_identity" | "message_embedded" | "temporal";
+    readonly AuthorIdentity: "none" | "hash" | "patch_id" | "author_identity" | "message_embedded" | "temporal";
+    readonly MessageEmbedded: "none" | "hash" | "patch_id" | "author_identity" | "message_embedded" | "temporal";
+    readonly Temporal: "none" | "hash" | "patch_id" | "author_identity" | "message_embedded" | "temporal";
+    readonly None: "none" | "hash" | "patch_id" | "author_identity" | "message_embedded" | "temporal";
+}>;
+export declare const AllRewriteMethods: readonly RewriteMethod[];
+export declare function isRewriteMethod(value: unknown): value is RewriteMethod;
+export type RewriteResolution = RewriteResolutionContract;
+export declare const RewriteResolution: Readonly<{
+    readonly Live: "live" | "rewritten" | "unresolved";
+    readonly Rewritten: "live" | "rewritten" | "unresolved";
+    readonly Unresolved: "live" | "rewritten" | "unresolved";
+}>;
+export declare const AllRewriteResolutions: readonly RewriteResolution[];
+export declare function isRewriteResolution(value: unknown): value is RewriteResolution;
 export type Role = RoleContract;
 export declare const Role: Readonly<{
     readonly User: "user" | "system" | "assistant" | "tool";
@@ -272,10 +357,12 @@ export declare const AllStopReasons: readonly StopReason[];
 export declare function isStopReason(value: unknown): value is StopReason;
 export type TargetKind = TargetKindContract;
 export declare const TargetKind: Readonly<{
-    readonly Session: "session" | "annotation" | "project" | "entry";
-    readonly Entry: "session" | "annotation" | "project" | "entry";
-    readonly Annotation: "session" | "annotation" | "project" | "entry";
-    readonly Project: "session" | "annotation" | "project" | "entry";
+    readonly Session: "session" | "annotation" | "project" | "entry" | "file_version" | "association";
+    readonly Entry: "session" | "annotation" | "project" | "entry" | "file_version" | "association";
+    readonly Annotation: "session" | "annotation" | "project" | "entry" | "file_version" | "association";
+    readonly Project: "session" | "annotation" | "project" | "entry" | "file_version" | "association";
+    readonly FileVersion: "session" | "annotation" | "project" | "entry" | "file_version" | "association";
+    readonly Association: "session" | "annotation" | "project" | "entry" | "file_version" | "association";
 }>;
 export declare const AllTargetKinds: readonly TargetKind[];
 export declare function isTargetKind(value: unknown): value is TargetKind;