@davesheffer/hunch 1.31.1 → 1.32.0

package/dist/core/stateContract.d.ts

@@ -0,0 +1,979 @@
+import { z } from "zod";
+import { type DeliveryEnvelope } from "./delivery.js";
+import { type Scope, type ActionReceipt, type Commitment, type DerivedState } from "./stateRecords.js";
+export * from "./stateRecords.js";
+export declare const STATE_CONTRACT_VERSION: "nuryel.state/1";
+export declare const STATE_READ_VERSION: "nuryel.state.read/1";
+export declare const STATE_WRITE_VERSION: "nuryel.state.write/1";
+export declare const STATE_SUBSCRIBE_VERSION: "nuryel.state.subscribe/1";
+export declare const STATE_RECORDS_VERSION: "nuryel.state.records/1";
+export declare const STATE_CAPTURE_VERSION: "nuryel.state.capture/1";
+export declare const STATE_CAPTURE_BATCH_VERSION: "nuryel.state.capture-batch/1";
+export declare const STATE_OBSERVATION_LINKS_VERSION: "nuryel.observation-links/1";
+export declare const STATE_OBSERVATION_REVIEW_VERSION: "nuryel.observation-review/1";
+export declare const STATE_OBSERVATION_PAGES_VERSION: "nuryel.observation-pages/1";
+/** Capabilities a server advertises; a client that needs one the server lacks gets a typed
+ *  `unsupported`, never a compatible-looking degraded answer. */
+export declare const STATE_CAPABILITIES: readonly ["nuryel.state.read/1", "nuryel.state.write/1", "nuryel.state.subscribe/1", "nuryel.state.records/1", "nuryel.state.capture/1", "nuryel.state.capture-batch/1", "nuryel.observation-links/1", "nuryel.observation-review/1", "nuryel.observation-pages/1", "nuryel.receipt/1", "nuryel.commitment/1", "nuryel.derived/1", "nuryel.entity/1", "nuryel.relationship/1"];
+export type StateCapability = (typeof STATE_CAPABILITIES)[number];
+/** Who is reading or writing. Grants are the scopes the principal may see; authorization is
+ *  decided BEFORE retrieval against these, never after ranking. */
+export declare const PrincipalSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        service: "service";
+        human: "human";
+        agent: "agent";
+    }>;
+    display: z.ZodOptional<z.ZodString>;
+    grants: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type Principal = z.infer<typeof PrincipalSchema>;
+/** One relevant assertion, never a whole conversation. Source text is transient input:
+ * only its exact supporting excerpt and a hashed external pointer may reach the store. */
+export declare const CaptureRequestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.capture/1">;
+    principal: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            service: "service";
+            human: "human";
+            agent: "agent";
+        }>;
+        display: z.ZodOptional<z.ZodString>;
+        grants: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    subject: z.ZodString;
+    statement: z.ZodString;
+    relevance: z.ZodObject<{
+        use: z.ZodEnum<{
+            decision: "decision";
+            constraint: "constraint";
+            preference: "preference";
+            operational_fact: "operational_fact";
+            ongoing_issue: "ongoing_issue";
+        }>;
+        reason: z.ZodString;
+    }, z.core.$strict>;
+    evidence: z.ZodArray<z.ZodObject<{
+        ref: z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        source_text: z.ZodString;
+        excerpt: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CaptureRequest = z.infer<typeof CaptureRequestSchema>;
+/** Sources cross the transport once; assertions name only their supporting excerpts. */
+export declare const CaptureBatchRequestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.capture-batch/1">;
+    principal: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            service: "service";
+            human: "human";
+            agent: "agent";
+        }>;
+        display: z.ZodOptional<z.ZodString>;
+        grants: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    sources: z.ZodArray<z.ZodObject<{
+        ref: z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        source_text: z.ZodString;
+    }, z.core.$strict>>;
+    observations: z.ZodArray<z.ZodObject<{
+        relevance: z.ZodObject<{
+            use: z.ZodEnum<{
+                decision: "decision";
+                constraint: "constraint";
+                preference: "preference";
+                operational_fact: "operational_fact";
+                ongoing_issue: "ongoing_issue";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>;
+        subject: z.ZodString;
+        statement: z.ZodString;
+        evidence: z.ZodArray<z.ZodObject<{
+            source: z.ZodNumber;
+            excerpt: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    reviews: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        record_id: z.ZodString;
+        expected_hash: z.ZodString;
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodObject<{
+            source: z.ZodNumber;
+            excerpt: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type CaptureBatchRequest = z.infer<typeof CaptureBatchRequestSchema>;
+export declare const CAPTURE_TRANSFORM = "agent-capture/1:";
+export declare const normalizeAssertion: (text: string) => string;
+export declare function captureTransform(scope: Scope, subject: string, statement: string, evidence: {
+    source: string;
+    excerpt: string;
+}[]): string;
+export declare const STATE_FACETS: readonly ["decisions", "constraints", "bugs", "findings", "receipts", "commitments", "derived", "entities", "relationships"];
+export type StateFacet = (typeof STATE_FACETS)[number];
+/** Union read: the partitions a principal wants in ONE answer. `scope` stays required (it is the
+ *  primary partition; its envelope and receipt lead the response). An entry the principal is not
+ *  granted is NAMED in `denied_scopes` — it never refuses the whole call, and is never described. */
+export declare const ReadScopesSchema: z.ZodArray<z.ZodObject<{
+    kind: z.ZodEnum<{
+        repository: "repository";
+        organization: "organization";
+        team: "team";
+        user: "user";
+    }>;
+    id: z.ZodString;
+}, z.core.$strict>>;
+export declare const ObservationCursorSchema: z.ZodObject<{
+    snapshot_hash: z.ZodString;
+    offset: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ReadRequestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.read/1">;
+    principal: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            service: "service";
+            human: "human";
+            agent: "agent";
+        }>;
+        display: z.ZodOptional<z.ZodString>;
+        grants: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>>>;
+    subject: z.ZodOptional<z.ZodString>;
+    task: z.ZodOptional<z.ZodString>;
+    profile: z.ZodOptional<z.ZodEnum<{
+        builder: "builder";
+        reviewer: "reviewer";
+        architect: "architect";
+    }>>;
+    budget_tokens: z.ZodOptional<z.ZodNumber>;
+    facets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        decisions: "decisions";
+        constraints: "constraints";
+        bugs: "bugs";
+        findings: "findings";
+        receipts: "receipts";
+        commitments: "commitments";
+        derived: "derived";
+        entities: "entities";
+        relationships: "relationships";
+    }>>>;
+    observed_page: z.ZodOptional<z.ZodObject<{
+        cursor: z.ZodOptional<z.ZodObject<{
+            snapshot_hash: z.ZodString;
+            offset: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ReadRequest = z.infer<typeof ReadRequestSchema>;
+declare const StateRefSchema: z.ZodObject<{
+    facet: z.ZodEnum<{
+        decisions: "decisions";
+        constraints: "constraints";
+        bugs: "bugs";
+        findings: "findings";
+        receipts: "receipts";
+        commitments: "commitments";
+        derived: "derived";
+        entities: "entities";
+        relationships: "relationships";
+    }>;
+    id: z.ZodString;
+    record_hash: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type StateRef = z.infer<typeof StateRefSchema>;
+/** The system-of-record answer for a subject: what is true now, on what it rests, what would
+ *  invalidate it. Carried beside the existing delivery envelope, under the same receipt. */
+export declare const StateOfRecordSchema: z.ZodObject<{
+    subject: z.ZodString;
+    current: z.ZodArray<z.ZodObject<{
+        facet: z.ZodEnum<{
+            decisions: "decisions";
+            constraints: "constraints";
+            bugs: "bugs";
+            findings: "findings";
+            receipts: "receipts";
+            commitments: "commitments";
+            derived: "derived";
+            entities: "entities";
+            relationships: "relationships";
+        }>;
+        id: z.ZodString;
+        record_hash: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    in_force: z.ZodArray<z.ZodObject<{
+        facet: z.ZodEnum<{
+            decisions: "decisions";
+            constraints: "constraints";
+            bugs: "bugs";
+            findings: "findings";
+            receipts: "receipts";
+            commitments: "commitments";
+            derived: "derived";
+            entities: "entities";
+            relationships: "relationships";
+        }>;
+        id: z.ZodString;
+        record_hash: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    done: z.ZodArray<z.ZodObject<{
+        facet: z.ZodEnum<{
+            decisions: "decisions";
+            constraints: "constraints";
+            bugs: "bugs";
+            findings: "findings";
+            receipts: "receipts";
+            commitments: "commitments";
+            derived: "derived";
+            entities: "entities";
+            relationships: "relationships";
+        }>;
+        id: z.ZodString;
+        record_hash: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    observed: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        facet: z.ZodEnum<{
+            decisions: "decisions";
+            constraints: "constraints";
+            bugs: "bugs";
+            findings: "findings";
+            receipts: "receipts";
+            commitments: "commitments";
+            derived: "derived";
+            entities: "entities";
+            relationships: "relationships";
+        }>;
+        id: z.ZodString;
+        record_hash: z.ZodString;
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    observed_truncated: z.ZodOptional<z.ZodBoolean>;
+    observed_page: z.ZodOptional<z.ZodObject<{
+        snapshot_hash: z.ZodString;
+        total: z.ZodNumber;
+        next_cursor: z.ZodNullable<z.ZodObject<{
+            snapshot_hash: z.ZodString;
+            offset: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    relationships_truncated: z.ZodOptional<z.ZodBoolean>;
+    depends_on: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"record">;
+        id: z.ZodString;
+        record_hash: z.ZodString;
+        scope: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        ref: z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"schema">;
+        name: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    invalidated_by: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type StateOfRecord = z.infer<typeof StateOfRecordSchema>;
+export declare const ReadResponseSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.read/1">;
+    receipt_id: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    state_of_record: z.ZodNullable<z.ZodObject<{
+        subject: z.ZodString;
+        current: z.ZodArray<z.ZodObject<{
+            facet: z.ZodEnum<{
+                decisions: "decisions";
+                constraints: "constraints";
+                bugs: "bugs";
+                findings: "findings";
+                receipts: "receipts";
+                commitments: "commitments";
+                derived: "derived";
+                entities: "entities";
+                relationships: "relationships";
+            }>;
+            id: z.ZodString;
+            record_hash: z.ZodString;
+            scope: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repository: "repository";
+                    organization: "organization";
+                    team: "team";
+                    user: "user";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        in_force: z.ZodArray<z.ZodObject<{
+            facet: z.ZodEnum<{
+                decisions: "decisions";
+                constraints: "constraints";
+                bugs: "bugs";
+                findings: "findings";
+                receipts: "receipts";
+                commitments: "commitments";
+                derived: "derived";
+                entities: "entities";
+                relationships: "relationships";
+            }>;
+            id: z.ZodString;
+            record_hash: z.ZodString;
+            scope: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repository: "repository";
+                    organization: "organization";
+                    team: "team";
+                    user: "user";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        done: z.ZodArray<z.ZodObject<{
+            facet: z.ZodEnum<{
+                decisions: "decisions";
+                constraints: "constraints";
+                bugs: "bugs";
+                findings: "findings";
+                receipts: "receipts";
+                commitments: "commitments";
+                derived: "derived";
+                entities: "entities";
+                relationships: "relationships";
+            }>;
+            id: z.ZodString;
+            record_hash: z.ZodString;
+            scope: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repository: "repository";
+                    organization: "organization";
+                    team: "team";
+                    user: "user";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        observed: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            facet: z.ZodEnum<{
+                decisions: "decisions";
+                constraints: "constraints";
+                bugs: "bugs";
+                findings: "findings";
+                receipts: "receipts";
+                commitments: "commitments";
+                derived: "derived";
+                entities: "entities";
+                relationships: "relationships";
+            }>;
+            id: z.ZodString;
+            record_hash: z.ZodString;
+            scope: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repository: "repository";
+                    organization: "organization";
+                    team: "team";
+                    user: "user";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        observed_truncated: z.ZodOptional<z.ZodBoolean>;
+        observed_page: z.ZodOptional<z.ZodObject<{
+            snapshot_hash: z.ZodString;
+            total: z.ZodNumber;
+            next_cursor: z.ZodNullable<z.ZodObject<{
+                snapshot_hash: z.ZodString;
+                offset: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        relationships_truncated: z.ZodOptional<z.ZodBoolean>;
+        depends_on: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"record">;
+            id: z.ZodString;
+            record_hash: z.ZodString;
+            scope: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    repository: "repository";
+                    organization: "organization";
+                    team: "team";
+                    user: "user";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"external">;
+            ref: z.ZodObject<{
+                system: z.ZodString;
+                object_type: z.ZodString;
+                object_key: z.ZodString;
+                version: z.ZodOptional<z.ZodString>;
+                content_hash: z.ZodOptional<z.ZodString>;
+                observed_at: z.ZodString;
+                locator: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"schema">;
+            name: z.ZodString;
+            fingerprint: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        invalidated_by: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    denied_scopes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>>>;
+    records: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>>>;
+    receipts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        scope: z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        receipt_id: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ReadResponse = z.infer<typeof ReadResponseSchema>;
+export declare const WriteRequestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.write/1">;
+    principal: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            service: "service";
+            human: "human";
+            agent: "agent";
+        }>;
+        display: z.ZodOptional<z.ZodString>;
+        grants: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    facet: z.ZodEnum<{
+        decisions: "decisions";
+        constraints: "constraints";
+        bugs: "bugs";
+        findings: "findings";
+        receipts: "receipts";
+        commitments: "commitments";
+        derived: "derived";
+        entities: "entities";
+        relationships: "relationships";
+    }>;
+    record: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    idempotency_key: z.ZodString;
+    expected_version: z.ZodDefault<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    supersedes: z.ZodOptional<z.ZodString>;
+    cause: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        ref: z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WriteRequest = z.infer<typeof WriteRequestSchema>;
+export declare const DURABILITY: readonly ["pushed", "committed", "local"];
+export declare const WriteResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.write/1">;
+    record_id: z.ZodString;
+    record_hash: z.ZodString;
+    durability: z.ZodEnum<{
+        committed: "committed";
+        pushed: "pushed";
+        local: "local";
+    }>;
+    outcome: z.ZodEnum<{
+        updated: "updated";
+        superseded: "superseded";
+        created: "created";
+        replayed: "replayed";
+    }>;
+    conflict: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        incumbent_id: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
+    record: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type WriteResult = z.infer<typeof WriteResultSchema>;
+export declare const CaptureBatchResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.capture-batch/1">;
+    results: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        index: z.ZodNumber;
+        status: z.ZodLiteral<"saved">;
+        result: z.ZodObject<{
+            schema: z.ZodLiteral<"nuryel.state.write/1">;
+            record_id: z.ZodString;
+            record_hash: z.ZodString;
+            durability: z.ZodEnum<{
+                committed: "committed";
+                pushed: "pushed";
+                local: "local";
+            }>;
+            outcome: z.ZodEnum<{
+                updated: "updated";
+                superseded: "superseded";
+                created: "created";
+                replayed: "replayed";
+            }>;
+            conflict: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                incumbent_id: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>>;
+            record: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        index: z.ZodNumber;
+        status: z.ZodLiteral<"refused">;
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>], "status">>;
+    reviews: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        index: z.ZodNumber;
+        status: z.ZodLiteral<"saved">;
+        result: z.ZodObject<{
+            schema: z.ZodLiteral<"nuryel.state.write/1">;
+            record_id: z.ZodString;
+            record_hash: z.ZodString;
+            durability: z.ZodEnum<{
+                committed: "committed";
+                pushed: "pushed";
+                local: "local";
+            }>;
+            outcome: z.ZodEnum<{
+                updated: "updated";
+                superseded: "superseded";
+                created: "created";
+                replayed: "replayed";
+            }>;
+            conflict: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                incumbent_id: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strict>>>;
+            record: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        index: z.ZodNumber;
+        status: z.ZodLiteral<"refused">;
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strict>], "status">>>;
+}, z.core.$strict>;
+export type CaptureBatchResult = z.infer<typeof CaptureBatchResultSchema>;
+export declare const SubscribeRequestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.subscribe/1">;
+    principal: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            service: "service";
+            human: "human";
+            agent: "agent";
+        }>;
+        display: z.ZodOptional<z.ZodString>;
+        grants: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    after_seq: z.ZodNumber;
+    subjects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    facets: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        decisions: "decisions";
+        constraints: "constraints";
+        bugs: "bugs";
+        findings: "findings";
+        receipts: "receipts";
+        commitments: "commitments";
+        derived: "derived";
+        entities: "entities";
+        relationships: "relationships";
+    }>>>;
+}, z.core.$strict>;
+export type SubscribeRequest = z.infer<typeof SubscribeRequestSchema>;
+export declare const ChangeEventSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.subscribe/1">;
+    seq: z.ZodNumber;
+    at: z.ZodString;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    facet: z.ZodEnum<{
+        decisions: "decisions";
+        constraints: "constraints";
+        bugs: "bugs";
+        findings: "findings";
+        receipts: "receipts";
+        commitments: "commitments";
+        derived: "derived";
+        entities: "entities";
+        relationships: "relationships";
+    }>;
+    record_id: z.ZodString;
+    record_hash: z.ZodString;
+    change: z.ZodEnum<{
+        updated: "updated";
+        retired: "retired";
+        superseded: "superseded";
+        created: "created";
+        invalidated: "invalidated";
+    }>;
+    subject: z.ZodOptional<z.ZodString>;
+    invalidates: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    cause: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"receipt">;
+        receipt_id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        ref: z.ZodObject<{
+            system: z.ZodString;
+            object_type: z.ZodString;
+            object_key: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            content_hash: z.ZodOptional<z.ZodString>;
+            observed_at: z.ZodString;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"write">;
+        principal: z.ZodString;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type ChangeEvent = z.infer<typeof ChangeEventSchema>;
+/** records — fetch records by id, grants first. A subscribe event names a record; this is how
+ *  a consumer gets its body without a subject read. Ids outside the grants are named in
+ *  `denied`, unknown ids in `missing`; neither is silently dropped. */
+export declare const RecordsRequestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.records/1">;
+    principal: z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            service: "service";
+            human: "human";
+            agent: "agent";
+        }>;
+        display: z.ZodOptional<z.ZodString>;
+        grants: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                repository: "repository";
+                organization: "organization";
+                team: "team";
+                user: "user";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type RecordsRequest = z.infer<typeof RecordsRequestSchema>;
+export declare const RecordsResponseSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"nuryel.state.records/1">;
+    scope: z.ZodObject<{
+        kind: z.ZodEnum<{
+            repository: "repository";
+            organization: "organization";
+            team: "team";
+            user: "user";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    records: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    facets: z.ZodRecord<z.ZodString, z.ZodEnum<{
+        decisions: "decisions";
+        constraints: "constraints";
+        bugs: "bugs";
+        findings: "findings";
+        receipts: "receipts";
+        commitments: "commitments";
+        derived: "derived";
+        entities: "entities";
+        relationships: "relationships";
+    }>>;
+    missing: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    denied: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type RecordsResponse = z.infer<typeof RecordsResponseSchema>;
+export declare const CapabilityNegotiationSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"nuryel.state/1">;
+    capabilities: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare function negotiate(offered: readonly string[], required?: readonly string[]): {
+    supported: string[];
+    unsupported: string[];
+};
+/** Canonical JSON: keys sorted by code unit at every level, `undefined` dropped, non-finite
+ *  numbers rejected. Two records with the same facts hash the same regardless of who wrote them. */
+export declare function canonicalize(value: unknown): unknown;
+export declare function stateHash(value: unknown): string;
+/** Identity = what makes two receipts the same action: who did what to which object, with which
+ *  request. Re-sending the same action replays the same receipt instead of minting a second one. */
+export declare function actionReceiptId(r: Pick<ActionReceipt, "scope" | "actor" | "action_kind" | "target" | "request_fingerprint"> & {
+    idempotency_key?: string;
+}): string;
+export declare function commitmentId(c: Pick<Commitment, "scope" | "subject" | "title" | "owner" | "due">): string;
+export declare function derivedId(d: Pick<DerivedState, "scope" | "subject" | "transform_version" | "dependencies">): string;
+export declare const STATE_INVARIANTS: readonly [{
+    readonly id: "authorization-before-retrieval";
+    readonly statement: "A record outside the principal's grants never enters a candidate set; filtering after ranking is a violation.";
+}, {
+    readonly id: "similarity-never-authorizes";
+    readonly statement: "Semantic similarity may find candidates; only deterministic dependency, freshness and grant checks make a record current or visible.";
+}, {
+    readonly id: "never-in-request-path";
+    readonly statement: "Nuryel is read and written by orchestrators; it never proxies, fetches or stores on an agent's behalf. A gate that checks state and refuses is allowed; an intermediary is not.";
+}, {
+    readonly id: "provenance-on-every-write";
+    readonly statement: "Every write carries provenance and an idempotency key; a replay returns the original record, never a duplicate.";
+}, {
+    readonly id: "one-live-decision-per-topic";
+    readonly statement: "A second live decision on a topic is refused with the incumbent named; supersession is explicit.";
+}, {
+    readonly id: "external-truth-stays-external";
+    readonly statement: "External systems remain authoritative for their own content; Nuryel holds credential-free pointers, versions and hashes, never mirrored bodies.";
+}, {
+    readonly id: "derived-state-carries-dependencies";
+    readonly statement: "A derived statement without dependencies cannot be invalidated and is therefore not state.";
+}, {
+    readonly id: "one-entity-per-external-ref";
+    readonly statement: "One external record is one entity in a partition: a second active entity carrying an external key an incumbent already carries is refused with the incumbent named, and a subject written as that record's external key is refused with the entity's id named. Identity is explicit refs, never similarity; merge is explicit — a retired entity names the survivor in `merged_into`, the ledger holds the `retired` event, nothing under the old id is rewritten and reads resolve to the survivor — and split is the explicit reverse; never a silent rewrite.";
+}, {
+    readonly id: "human-correction-outranks-agent-writes";
+    readonly statement: "A record a human confirmed is never overwritten or superseded by an agent or service principal: the agent may replay it, write derived state back stale with the external cause that moved, or close a commitment with a receipt on record. Changing what the human said takes a human.";
+}, {
+    readonly id: "derived-state-writer-owns-currentness";
+    readonly statement: "No source writes the drawer. The writer of a current derived statement owns keeping its dependencies true: re-validate them on a schedule or on a source event, and write the statement back stale with the moved pointer as cause when one no longer holds. Without this duty an agent may capture source-backed observations only as unknown; observations never assert currentness.";
+}];
+/** The memory supply chain's top tier: a record whose provenance a human signed. Same tier rule
+ *  as the strict gate's (strictgate.isHumanConfirmed), applied to a record instead of a source. */
+export declare function isHumanConfirmed(record: unknown): boolean;
+/** authorization-before-retrieval, checked on the way OUT as well: nothing in a read response
+ *  may sit outside the principal's grants. Bindings must also filter on the way in. */
+export declare function assertReadWithinGrants(principal: Principal, response: ReadResponse): void;
+/** provenance-on-every-write + scope agreement between the envelope and the record. */
+export declare function assertWriteWellFormed(request: WriteRequest): void;
+/** derived-state-carries-dependencies + content integrity. */
+export declare function assertDerivedState(d: DerivedState): void;
+/** Subscribe streams are strictly ordered per scope; a gap or regression means the caller must
+ *  resynchronize instead of trusting what it holds. */
+export declare function assertChangeSequence(events: readonly ChangeEvent[], afterSeq: number): void;
+/** A delivery envelope is the read receipt this contract reuses unchanged. */
+export declare function receiptOf(envelope: Pick<DeliveryEnvelope, "receipt_id">): string;