@humain/humain-code-contracts 0.3.2

package/dist/trace-http.d.ts

@@ -0,0 +1,1294 @@
+import { type Static, type TSchema, Type } from "typebox";
+import { type DhAckV1, type DhCoverage, type DhEventKind, type DhEventV1, type DhExternalId, type DhOutcome, type DhRejectionCode } from "./trace.ts";
+import { type DhExportHashOptions } from "./trace-export.ts";
+/** Schema ids introduced by this freeze. Existing dh.event/1, dh.artifact/1 and dh.ack/1 are unchanged. */
+export declare const DH_HTTP_SCHEMA_IDS: Readonly<{
+    readonly admissionBinding: "dh.admission-binding/1";
+    readonly workloadBinding: "dh.workload-binding/1";
+    readonly originDelegation: "dh.origin-delegation/1";
+    readonly artifactReceipt: "dh.artifact-receipt/1";
+    readonly controlReceipt: "dh.control-receipt/1";
+    readonly controlRequest: "dh.control-request/2";
+    readonly controlStatus: "dh.control-status/2";
+    readonly controlTarget: "dh.control-target/1";
+    readonly controlDelivery: "dh.control-delivery/1";
+    readonly controlHandshake: "dh.control-handshake/1";
+    readonly controllerCredential: "dh.controller-credential/1";
+    readonly cursorBinding: "dh.cursor-binding/2";
+    readonly snapshotCutoff: "dh.snapshot-cutoff/1";
+    readonly generationPage: "dh.generation-page/2";
+    readonly agentPage: "dh.agent-page/2";
+    readonly eventPage: "dh.event-page/2";
+    readonly exportManifestHeader: "dh.export-manifest-header/2";
+    readonly exportManifestPage: "dh.export-manifest-page/2";
+    readonly producerEnrollment: "dh.producer-enrollment/2";
+    readonly producerEnrollmentRequest: "dh.producer-enrollment-request/2";
+}>;
+/**
+ * Batch version decision record. dh.batch/1-proposal stays the ONLY schema managed ingress accepts.
+ * C0 resolves the synthetic-local lane to the proposal literal only. Production promotion remains
+ * a separate coordinated decision; it is never accepted alongside the proposal.
+ */
+export declare const DH_BATCH_VERSION_DECISION: Readonly<{
+    readonly accepted: "dh.batch/1-proposal";
+    readonly promotionCandidate: "dh.batch/1";
+    readonly status: "resolved-synthetic-local";
+    readonly dualVersionIngress: false;
+}>;
+/** Validation ceiling only; the real access-token TTL is an open policy input. Matches the current client ceiling. */
+export declare const DH_TOKEN_MAX_EXPIRES_IN_SECONDS = 600;
+export declare const DH_EXPORT_MANIFEST_MAX_SHARDS = 1024;
+/** Equal to DH_MAX_ACK_IDS (asserted in tests): one shard page is one bounded ACK-sized ID list. */
+export declare const DH_EXPORT_MANIFEST_SHARD_MAX_IDS = 1000;
+export declare const DH_GRANT_MAX_PROJECTS = 16;
+/** Provisional bound for continuation text; policy may lower it. */
+export declare const DH_CONTROL_MESSAGE_MAX_CHARS = 16384;
+export declare const DH_GRANT_PERMISSIONS: readonly ["review-metadata", "review-content", "export"];
+export type DhGrantPermission = (typeof DH_GRANT_PERMISSIONS)[number];
+/** Strict parser: plain-JSON gate, schema check, clone, re-check, calendar-valid instants, DTO semantics, freeze. */
+declare function dtoParser<T extends TSchema>(label: string, schema: () => T, semantic?: (value: Static<T>) => void): (value: unknown) => Static<T>;
+/**
+ * The strict DTO parser (plain-JSON wire gate, schema check, clone, re-check, instants, semantics, freeze)
+ * for sibling modules such as trace-payload.ts, so the gate is never re-implemented.
+ */
+export { dtoParser as dhStrictDtoParser };
+export declare const DH_ROUTE_AUDIENCES: readonly ["browser-review", "producer", "workload", "control", "records-policy"];
+export type DhRouteAudience = (typeof DH_ROUTE_AUDIENCES)[number];
+export type DhRouteMethod = "GET" | "POST" | "PUT" | "DELETE";
+export interface DhRoute {
+    readonly method: DhRouteMethod;
+    /** `{name}` placeholders are the only variable parts; see DH_PATH_PARAM_PATTERNS. */
+    readonly path: string;
+    readonly audience: DhRouteAudience;
+    readonly requestContentType: string | null;
+    readonly requestHeaders?: readonly string[];
+    readonly responseContentType: string | null;
+    readonly responseSchemaId?: string;
+    readonly successStatus: readonly number[];
+}
+declare const ROUTE_DEFINITIONS: {
+    readonly authorizeConsent: DhRoute;
+    readonly authorizeSubmit: DhRoute;
+    readonly clientToken: DhRoute;
+    readonly clientRevoke: DhRoute;
+    readonly producerEnroll: DhRoute;
+    readonly producerToken: DhRoute;
+    readonly producerRevoke: DhRoute;
+    readonly ingestRecords: DhRoute;
+    readonly ingestArtifactContent: DhRoute;
+    readonly reviewGenerations: DhRoute;
+    readonly reviewAgents: DhRoute;
+    readonly reviewEvents: DhRoute;
+    readonly reviewArtifact: DhRoute;
+    readonly reviewArtifactContent: DhRoute;
+    readonly usage: DhRoute;
+    readonly search: DhRoute;
+    readonly exportCreate: DhRoute;
+    readonly exportStatus: DhRoute;
+    readonly exportManifest: DhRoute;
+    readonly exportDownload: DhRoute;
+    readonly exportContent: DhRoute;
+    readonly controlTarget: DhRoute;
+    readonly controlCancel: DhRoute;
+    readonly controlRetry: DhRoute;
+    readonly controlContinue: DhRoute;
+    readonly controlRequest: DhRoute;
+    readonly generationDelete: DhRoute;
+    readonly legalHoldCreate: DhRoute;
+    readonly legalHoldRelease: DhRoute;
+};
+export type DhRouteId = keyof typeof ROUTE_DEFINITIONS;
+export declare const DH_ROUTES: Readonly<typeof ROUTE_DEFINITIONS>;
+/** ID segment validators. Only unreserved characters: no separators, dots-only segments, encodings or wildcards. */
+export declare const DH_PATH_PARAM_PATTERNS: Readonly<Record<string, RegExp>>;
+/** Builds a path from the frozen template. Params must be exactly the template's placeholders, each validated then percent-encoded. */
+export declare function buildDhRoutePath(id: DhRouteId, params: Readonly<Record<string, string>>): string;
+/**
+ * Grant permissions a browser-review route needs. Export reads (status, manifest, download, content)
+ * are authorized from the SERVER-STORED job, passed as `job` (its `contentIncluded`, e.g. from
+ * DhExportJobStatus): export + review-metadata always, plus review-content when the stored job
+ * includes content. A caller-supplied `includeContent` is ignored for them and a missing or malformed
+ * `job` throws. The server must evaluate this on every read, so a grant that lost review-content after
+ * creation can no longer read a content job. Only `exportCreate` (which creates the job) and the
+ * event/search views use `includeContent`. Control/producer/records-policy routes use no read-grant permission.
+ * `options` (and the `job` inside it) pass the plain-JSON wire gate before any member is read, so an accessor or
+ * non-plain object is rejected without executing user code.
+ */
+export declare function requiredDhPermissions(id: DhRouteId, options: {
+    includeContent?: boolean;
+    job?: Readonly<Pick<DhExportJobStatus, "contentIncluded">>;
+}): DhGrantPermission[];
+/** Credential classes are not interchangeable: a credential is valid only on routes of its own audience class. */
+export declare function assertDhCredentialForRoute(id: DhRouteId, credentialClass: string): void;
+export declare const parseDhAdmissionBinding: (value: unknown) => {
+    readonly schema: "dh.admission-binding/1";
+    readonly bindingId: string;
+    readonly generationRootBindingId: string;
+    readonly mappingRevision: string;
+    readonly tenantId: string;
+    readonly environmentId: string;
+    readonly projectId: string;
+    readonly nativeProjectId: string;
+    readonly nativeRunId: string;
+    readonly nativeSegmentId: string;
+    readonly generationId: string;
+    readonly rootAgentId: string;
+    readonly initiatingActorId: string;
+    readonly bindingEpoch: string;
+    readonly policyRevision: string;
+    readonly admittedAt: string;
+    readonly environment: "local";
+    readonly syntheticOnly: true;
+};
+export type DhAdmissionBinding = ReturnType<typeof parseDhAdmissionBinding>;
+export interface DhRecordOwner {
+    readonly bindingId: string;
+    readonly originProducerInstanceId: string;
+}
+export interface DhRecordBindingContext {
+    readonly rootBinding?: DhAdmissionBinding;
+    readonly registryMapping?: Readonly<Pick<DhAdmissionBinding, "tenantId" | "environmentId" | "projectId" | "nativeProjectId" | "mappingRevision">> | null;
+    readonly routeScope?: Readonly<{
+        environmentId: string;
+        projectId: string;
+    }>;
+    readonly previousBinding?: DhAdmissionBinding;
+    readonly owner?: DhRecordOwner;
+    readonly existingOwner?: DhRecordOwner;
+    readonly tombstoned?: boolean;
+    /** Login changes never rewrite the initiating actor. This field grants no authority. */
+    readonly currentActorId?: string;
+}
+/** Pure equality over supplied durable facts, not a registry lookup or authentication. */
+export declare function assertDhRecordBinding(recordInput: unknown, bindingInput: unknown, context?: DhRecordBindingContext): void;
+declare function grantScopeSchema(): Type.TObject<{
+    readonly environmentId: Type.TString;
+    readonly projectIds: Type.TArray<Type.TString>;
+    readonly permissions: Type.TArray<Type.TEnum<["review-metadata", "review-content", "export"]>>;
+}>;
+export type DhGrantScope = Static<ReturnType<typeof grantScopeSchema>>;
+declare function tokenResponseSchema(): Type.TObject<{
+    readonly access_token: Type.TString;
+    readonly token_type: Type.TLiteral<"Bearer">;
+    readonly expires_in: Type.TInteger;
+    readonly refresh_token: Type.TString;
+    readonly grant_scope: Type.TObject<{
+        readonly environmentId: Type.TString;
+        readonly projectIds: Type.TArray<Type.TString>;
+        readonly permissions: Type.TArray<Type.TEnum<["review-metadata", "review-content", "export"]>>;
+    }>;
+}>;
+export type DhTokenResponse = Static<ReturnType<typeof tokenResponseSchema>>;
+export declare const parseDhTokenResponse: (value: unknown) => {
+    readonly access_token: string;
+    readonly token_type: "Bearer";
+    readonly expires_in: number;
+    readonly refresh_token: string;
+    readonly grant_scope: {
+        readonly environmentId: string;
+        readonly projectIds: string[];
+        readonly permissions: ("export" | "review-content" | "review-metadata")[];
+    };
+};
+/** OAuth errors have no reflecting error_description or non-OAuth fields. */
+export declare const parseDhTokenError: (value: unknown) => {
+    readonly error: "invalid_client" | "invalid_grant" | "invalid_request" | "invalid_scope" | "server_error" | "temporarily_unavailable" | "unauthorized_client" | "unsupported_grant_type";
+};
+export type DhTokenError = ReturnType<typeof parseDhTokenError>;
+declare function tokenRequestSchema(): Type.TUnion<[Type.TObject<{
+    readonly grant_type: Type.TLiteral<"authorization_code">;
+    readonly client_id: Type.TString;
+    readonly code: Type.TString;
+    readonly code_verifier: Type.TString;
+    readonly redirect_uri: Type.TString;
+}>, Type.TObject<{
+    readonly grant_type: Type.TLiteral<"refresh_token">;
+    readonly client_id: Type.TString;
+    readonly refresh_token: Type.TString;
+}>]>;
+export type DhTokenRequest = Static<ReturnType<typeof tokenRequestSchema>>;
+export declare const parseDhTokenRequest: (input: string | URLSearchParams) => DhTokenRequest;
+declare function revokeRequestSchema(): Type.TObject<{
+    readonly client_id: Type.TString;
+    readonly token: Type.TString;
+    readonly token_type_hint: Type.TLiteral<"refresh_token">;
+}>;
+export type DhRevokeRequest = Static<ReturnType<typeof revokeRequestSchema>>;
+export declare const parseDhRevokeRequest: (input: string | URLSearchParams) => DhRevokeRequest;
+declare function authorizeQuerySchema(): Type.TObject<{
+    readonly response_type: Type.TLiteral<"code">;
+    readonly client_id: Type.TString;
+    readonly redirect_uri: Type.TString;
+    readonly state: Type.TString;
+    readonly code_challenge: Type.TString;
+    readonly code_challenge_method: Type.TLiteral<"S256">;
+    readonly environment_id: Type.TString;
+    readonly project_id: Type.TArray<Type.TString>;
+    readonly permission: Type.TArray<Type.TEnum<["review-metadata", "review-content", "export"]>>;
+}>;
+export type DhAuthorizeQuery = Static<ReturnType<typeof authorizeQuerySchema>>;
+export declare const parseDhAuthorizeQuery: (input: string | URLSearchParams) => DhAuthorizeQuery;
+declare function producerEnrollmentRequestSchema(): Type.TObject<{
+    readonly schema: Type.TLiteral<"dh.producer-enrollment-request/2">;
+    readonly bindingId: Type.TString;
+    readonly producerInstanceId: Type.TString;
+    readonly generationId: Type.TString;
+    readonly originStreamId: Type.TString;
+    readonly producer: Type.TObject<{
+        readonly issuer: Type.TEnum<["code", "cli", "flow"]>;
+        readonly version: Type.TString;
+        readonly mode: Type.TString;
+    }>;
+}>;
+export type DhProducerEnrollmentRequest = Static<ReturnType<typeof producerEnrollmentRequestSchema>>;
+/** Workload proof travels in the authentication header, never the body; a reviewer grant is never producer proof. */
+export declare const parseDhProducerEnrollmentRequest: (value: unknown) => {
+    readonly schema: "dh.producer-enrollment-request/2";
+    readonly bindingId: string;
+    readonly producerInstanceId: string;
+    readonly generationId: string;
+    readonly originStreamId: string;
+    readonly producer: {
+        readonly issuer: "cli" | "code" | "flow";
+        readonly version: string;
+        readonly mode: string;
+    };
+};
+declare function producerEnrollmentSchema(): Type.TObject<{
+    readonly schema: Type.TLiteral<"dh.producer-enrollment/2">;
+    readonly enrollmentId: Type.TString;
+    readonly tenantScope: Type.TObject<{
+        readonly environmentId: Type.TString;
+        readonly projectId: Type.TString;
+    }>;
+    readonly generationId: Type.TString;
+    readonly originStreamId: Type.TString;
+    readonly issuer: Type.TEnum<["code", "cli", "flow"]>;
+    readonly credentialVersion: Type.TInteger;
+    readonly bindingId: Type.TString;
+    readonly producerInstanceId: Type.TString;
+    readonly allowedOriginIssuers: Type.TArray<Type.TEnum<["code", "cli", "flow"]>>;
+}>;
+export type DhProducerEnrollment = Static<ReturnType<typeof producerEnrollmentSchema>>;
+export declare const parseDhProducerEnrollment: (value: unknown) => {
+    readonly schema: "dh.producer-enrollment/2";
+    readonly enrollmentId: string;
+    readonly tenantScope: {
+        readonly environmentId: string;
+        readonly projectId: string;
+    };
+    readonly generationId: string;
+    readonly originStreamId: string;
+    readonly issuer: "cli" | "code" | "flow";
+    readonly credentialVersion: number;
+    readonly bindingId: string;
+    readonly producerInstanceId: string;
+    readonly allowedOriginIssuers: ("cli" | "code" | "flow")[];
+};
+export declare const parseDhProducerTokenRequest: (value: unknown) => {
+    readonly enrollmentId: string;
+};
+export declare const parseDhProducerRevokeRequest: (value: unknown) => {
+    readonly enrollmentId: string;
+};
+declare function producerAudienceSchema(): Type.TObject<{
+    readonly environmentId: Type.TString;
+    readonly projectId: Type.TString;
+    readonly generationId: Type.TString;
+    readonly originStreamId: Type.TString;
+    readonly issuer: Type.TEnum<["code", "cli", "flow"]>;
+    readonly enrollmentId: Type.TString;
+    readonly credentialVersion: Type.TInteger;
+    readonly bindingId: Type.TString;
+    readonly producerInstanceId: Type.TString;
+    readonly allowedOriginIssuers: Type.TArray<Type.TEnum<["code", "cli", "flow"]>>;
+}>;
+export type DhProducerAudience = Static<ReturnType<typeof producerAudienceSchema>>;
+/** No refresh_token and no grant_scope: a producer credential cannot be refreshed into, or mistaken for, a read grant. */
+export declare const parseDhProducerTokenResponse: (value: unknown) => {
+    readonly access_token: string;
+    readonly token_type: "Bearer";
+    readonly expires_in: number;
+    readonly audience: {
+        readonly environmentId: string;
+        readonly projectId: string;
+        readonly generationId: string;
+        readonly originStreamId: string;
+        readonly issuer: "cli" | "code" | "flow";
+        readonly enrollmentId: string;
+        readonly credentialVersion: number;
+        readonly bindingId: string;
+        readonly producerInstanceId: string;
+        readonly allowedOriginIssuers: ("cli" | "code" | "flow")[];
+    };
+};
+export type DhProducerTokenResponse = ReturnType<typeof parseDhProducerTokenResponse>;
+export interface DhProducerAudienceExpectation {
+    environmentId: string;
+    projectId: string;
+    generationId: string;
+    originStreamId: string;
+    issuer: DhProducerAudience["issuer"];
+    enrollmentId: string;
+    credentialVersion: number;
+    bindingId: string;
+    producerInstanceId: string;
+    allowedOriginIssuers: readonly DhProducerAudience["issuer"][];
+}
+/**
+ * A producer credential is bound to one environment/project/generation/origin stream AND to its issuer,
+ * enrollment and credential version, so a credential from a superseded or other enrollment never passes.
+ */
+export declare function assertDhProducerAudience(audience: DhProducerAudience, expected: DhProducerAudienceExpectation): void;
+export declare const parseDhWorkloadBinding: (value: unknown) => {
+    readonly schema: "dh.workload-binding/1";
+    readonly workloadId: string;
+    readonly bindingId: string;
+    readonly producerInstanceId: string;
+    readonly launchNonce: string;
+    readonly issuer: "cli" | "code" | "flow";
+    readonly buildSha256: string;
+    readonly mode: string;
+    readonly credentialVersion: number;
+    readonly expiresAt: string;
+};
+export type DhWorkloadBinding = ReturnType<typeof parseDhWorkloadBinding>;
+export declare const parseDhOriginDelegation: (value: unknown) => {
+    readonly schema: "dh.origin-delegation/1";
+    readonly delegationId: string;
+    readonly bindingId: string;
+    readonly originProducerInstanceId: string;
+    readonly originStreamId: string;
+    readonly originIssuer: "cli" | "code" | "flow";
+    readonly relayProducerInstanceId: string;
+    readonly enrollmentId: string;
+    readonly credentialVersion: number;
+    readonly expiresAt: string;
+};
+export type DhOriginDelegation = ReturnType<typeof parseDhOriginDelegation>;
+/** Compare to a live server-issued receipt. A syntactically valid receipt grants nothing by itself. */
+export declare function assertDhOriginDelegation(delegationInput: unknown, expected: unknown): void;
+/** Exactly 32 bytes in canonical unpadded base64url; caller handles private custody and live verification. */
+export declare function parseDhWorkloadAuthorizationHeader(value: unknown): string;
+export declare function parseDhOriginDelegationHeader(value: unknown): string;
+declare function eventMetadataViewSchema(): Type.TObject<{
+    readonly eventId: Type.TString;
+    readonly generationId: Type.TString;
+    readonly agentId: Type.TString;
+    readonly parentAgentId: Type.TOptional<Type.TString>;
+    readonly attemptId: Type.TOptional<Type.TString>;
+    readonly retryOfAttemptId: Type.TOptional<Type.TString>;
+    readonly attemptNumber: Type.TOptional<Type.TInteger>;
+    readonly streamId: Type.TString;
+    readonly sequence: Type.TInteger;
+    readonly kind: Type.TEnum<["generation.started", "generation.finished", "agent.spawned", "attempt.started", "attempt.finished", "attempt.retry_scheduled", "model.request", "model.response", "tool.call", "tool.result", "file.change", "orchestration.decision", "cancellation.requested", "cancellation.outcome", "usage.reported", "capture.health", "control.correlation", "event.amendment"]>;
+    readonly occurredAt: Type.TString;
+    readonly recordedAt: Type.TString;
+    readonly outcome: Type.TOptional<Type.TEnum<["succeeded", "failed", "cancelled", "unknown"]>>;
+    /** The failure code only. Raw failure messages are content. */
+    readonly failureCode: Type.TOptional<Type.TString>;
+    readonly coverage: Type.TArray<Type.TObject<{
+        readonly path: Type.TString;
+        readonly state: Type.TEnum<["captured", "redacted", "truncated", "unavailable", "not-applicable", "inferred"]>;
+        readonly reason: Type.TOptional<Type.TEnum<["secret_redacted", "policy_redacted", "size_limit", "producer_lost", "worker_exited_before_flush", "legacy_producer", "not_captured_by_version", "provider_hidden", "not_applicable", "derived_from_summary"]>>;
+    }>>;
+    readonly artifactIds: Type.TArray<Type.TString>;
+}>;
+export type DhEventMetadataView = Static<ReturnType<typeof eventMetadataViewSchema>>;
+export declare const parseDhEventMetadataView: (value: unknown) => {
+    readonly eventId: string;
+    readonly generationId: string;
+    readonly agentId: string;
+    readonly parentAgentId?: string | undefined;
+    readonly attemptId?: string | undefined;
+    readonly retryOfAttemptId?: string | undefined;
+    readonly attemptNumber?: number | undefined;
+    readonly streamId: string;
+    readonly sequence: number;
+    readonly kind: "agent.spawned" | "attempt.finished" | "attempt.retry_scheduled" | "attempt.started" | "cancellation.outcome" | "cancellation.requested" | "capture.health" | "control.correlation" | "event.amendment" | "file.change" | "generation.finished" | "generation.started" | "model.request" | "model.response" | "orchestration.decision" | "tool.call" | "tool.result" | "usage.reported";
+    readonly occurredAt: string;
+    readonly recordedAt: string;
+    readonly outcome?: "cancelled" | "failed" | "succeeded" | "unknown" | undefined;
+    readonly failureCode?: string | undefined;
+    readonly coverage: {
+        readonly path: string;
+        readonly state: "captured" | "inferred" | "not-applicable" | "redacted" | "truncated" | "unavailable";
+        readonly reason?: "derived_from_summary" | "legacy_producer" | "not_applicable" | "not_captured_by_version" | "policy_redacted" | "producer_lost" | "provider_hidden" | "secret_redacted" | "size_limit" | "worker_exited_before_flush" | undefined;
+    }[];
+    readonly artifactIds: string[];
+};
+declare const parseEventMetadataPage: (value: unknown) => {
+    readonly schema: "dh.event-page/2";
+    readonly cursorBinding: {
+        readonly schema: "dh.cursor-binding/2";
+        readonly environmentId: string;
+        readonly projectId: string;
+        readonly resource: "agents" | "events" | "generations" | "manifest";
+        readonly generationId?: string | undefined;
+        readonly bindingId?: string | undefined;
+        readonly filterSha256: string;
+        readonly view: "content" | "metadata";
+        readonly cutoff: {
+            readonly schema: "dh.snapshot-cutoff/1";
+            readonly snapshotId: string;
+            readonly receiptOrdinal: number;
+            readonly captureCutoff: string;
+        };
+        readonly mappingRevision: string;
+        readonly authorizationRevision: string;
+        readonly principalId: string;
+        readonly grantId: string;
+        readonly sessionId: string;
+        readonly pageSize: number;
+    };
+    readonly nextCursor: string | null;
+    readonly captureCutoff: string;
+    readonly contentIncluded: false;
+    readonly items: {
+        readonly eventId: string;
+        readonly generationId: string;
+        readonly agentId: string;
+        readonly parentAgentId?: string | undefined;
+        readonly attemptId?: string | undefined;
+        readonly retryOfAttemptId?: string | undefined;
+        readonly attemptNumber?: number | undefined;
+        readonly streamId: string;
+        readonly sequence: number;
+        readonly kind: "agent.spawned" | "attempt.finished" | "attempt.retry_scheduled" | "attempt.started" | "cancellation.outcome" | "cancellation.requested" | "capture.health" | "control.correlation" | "event.amendment" | "file.change" | "generation.finished" | "generation.started" | "model.request" | "model.response" | "orchestration.decision" | "tool.call" | "tool.result" | "usage.reported";
+        readonly occurredAt: string;
+        readonly recordedAt: string;
+        readonly outcome?: "cancelled" | "failed" | "succeeded" | "unknown" | undefined;
+        readonly failureCode?: string | undefined;
+        readonly coverage: {
+            readonly path: string;
+            readonly state: "captured" | "inferred" | "not-applicable" | "redacted" | "truncated" | "unavailable";
+            readonly reason?: "derived_from_summary" | "legacy_producer" | "not_applicable" | "not_captured_by_version" | "policy_redacted" | "producer_lost" | "provider_hidden" | "secret_redacted" | "size_limit" | "worker_exited_before_flush" | undefined;
+        }[];
+        readonly artifactIds: string[];
+    }[];
+};
+export type DhEventMetadataPage = ReturnType<typeof parseEventMetadataPage>;
+export interface DhEventContentPage {
+    readonly schema: "dh.event-page/2";
+    readonly cursorBinding: DhCursorBinding;
+    readonly nextCursor: string | null;
+    readonly captureCutoff: string;
+    readonly contentIncluded: true;
+    readonly items: readonly DhEventV1[];
+}
+export type DhEventPage = DhEventMetadataPage | DhEventContentPage;
+/** The metadata view never carries payload, raw failure messages, coverage detail or redaction paths; content pages are full dh.event/1. */
+export declare function parseDhEventPage(value: unknown): DhEventPage;
+export declare const DH_ARTIFACT_AVAILABILITY: readonly ["available", "pending", "unavailable"];
+declare function artifactMetadataViewSchema(): Type.TObject<{
+    readonly artifactId: Type.TString;
+    readonly generationId: Type.TString;
+    readonly agentId: Type.TString;
+    readonly attemptId: Type.TOptional<Type.TString>;
+    readonly eventId: Type.TString;
+    readonly kind: Type.TEnum<["file-diff", "file-snapshot", "tool-output", "model-context", "log", "bundle"]>;
+    readonly mediaType: Type.TEnum<["text/plain", "text/x-diff", "application/json", "application/octet-stream"]>;
+    readonly sizeBytes: Type.TInteger;
+    readonly sha256: Type.TString;
+    /** available = bytes stored; pending = metadata acknowledged, bytes not yet; unavailable = never readable (lost, withheld or purged). */
+    readonly availability: Type.TEnum<["available", "pending", "unavailable"]>;
+    readonly coverage: Type.TObject<{
+        readonly state: Type.TEnum<["captured", "redacted", "truncated", "unavailable", "not-applicable", "inferred"]>;
+        readonly reason: Type.TOptional<Type.TEnum<["secret_redacted", "policy_redacted", "size_limit", "producer_lost", "worker_exited_before_flush", "legacy_producer", "not_captured_by_version", "provider_hidden", "not_applicable", "derived_from_summary"]>>;
+    }>;
+}>;
+export type DhArtifactMetadataView = Static<ReturnType<typeof artifactMetadataViewSchema>>;
+/** Excludes logicalPath (sensitive file names), redaction paths and coverage.detail. Bytes are a separate route and grant. */
+export declare const parseDhArtifactMetadataView: (value: unknown) => {
+    readonly artifactId: string;
+    readonly generationId: string;
+    readonly agentId: string;
+    readonly attemptId?: string | undefined;
+    readonly eventId: string;
+    readonly kind: "bundle" | "file-diff" | "file-snapshot" | "log" | "model-context" | "tool-output";
+    readonly mediaType: "application/json" | "application/octet-stream" | "text/plain" | "text/x-diff";
+    readonly sizeBytes: number;
+    readonly sha256: string;
+    readonly availability: "available" | "pending" | "unavailable";
+    readonly coverage: {
+        readonly state: "captured" | "inferred" | "not-applicable" | "redacted" | "truncated" | "unavailable";
+        readonly reason?: "derived_from_summary" | "legacy_producer" | "not_applicable" | "not_captured_by_version" | "policy_redacted" | "producer_lost" | "provider_hidden" | "secret_redacted" | "size_limit" | "worker_exited_before_flush" | undefined;
+    };
+};
+export declare const DH_CURSOR_RESOURCES: readonly ["generations", "agents", "events", "manifest"];
+export declare const parseDhSnapshotCutoff: (value: unknown) => {
+    readonly schema: "dh.snapshot-cutoff/1";
+    readonly snapshotId: string;
+    readonly receiptOrdinal: number;
+    readonly captureCutoff: string;
+};
+export type DhSnapshotCutoff = ReturnType<typeof parseDhSnapshotCutoff>;
+/** Internal lazy schema seam shared by existing read-page parsers. */
+export declare function dhCursorBindingSchema(): Type.TObject<{
+    readonly schema: Type.TLiteral<"dh.cursor-binding/2">;
+    readonly environmentId: Type.TString;
+    readonly projectId: Type.TString;
+    readonly resource: Type.TEnum<["generations", "agents", "events", "manifest"]>;
+    readonly generationId: Type.TOptional<Type.TString>;
+    readonly bindingId: Type.TOptional<Type.TString>;
+    readonly filterSha256: Type.TString;
+    readonly view: Type.TUnion<[Type.TLiteral<"metadata">, Type.TLiteral<"content">]>;
+    readonly cutoff: Type.TObject<{
+        readonly schema: Type.TLiteral<"dh.snapshot-cutoff/1">;
+        readonly snapshotId: Type.TString;
+        readonly receiptOrdinal: Type.TInteger;
+        readonly captureCutoff: Type.TString;
+    }>;
+    readonly mappingRevision: Type.TString;
+    readonly authorizationRevision: Type.TString;
+    readonly principalId: Type.TString;
+    readonly grantId: Type.TString;
+    readonly sessionId: Type.TString;
+    readonly pageSize: Type.TInteger;
+}>;
+export type DhCursorBinding = Static<ReturnType<typeof dhCursorBindingSchema>>;
+/** What an opaque cursor is authenticated against (server-side); clients compare it across continuation pages. */
+export declare const parseDhCursorBinding: (value: unknown) => {
+    readonly schema: "dh.cursor-binding/2";
+    readonly environmentId: string;
+    readonly projectId: string;
+    readonly resource: "agents" | "events" | "generations" | "manifest";
+    readonly generationId?: string | undefined;
+    readonly bindingId?: string | undefined;
+    readonly filterSha256: string;
+    readonly view: "content" | "metadata";
+    readonly cutoff: {
+        readonly schema: "dh.snapshot-cutoff/1";
+        readonly snapshotId: string;
+        readonly receiptOrdinal: number;
+        readonly captureCutoff: string;
+    };
+    readonly mappingRevision: string;
+    readonly authorizationRevision: string;
+    readonly principalId: string;
+    readonly grantId: string;
+    readonly sessionId: string;
+    readonly pageSize: number;
+};
+export declare function assertDhReadPageBinding(page: {
+    cursorBinding: unknown;
+    captureCutoff: string;
+    items: readonly unknown[];
+}, resource: "generations" | "agents" | "events", view?: "metadata" | "content"): void;
+/** Pure supplied-context checks; opaque storage and authentication remain server responsibilities. */
+export declare function assertDhCursorContext(context: {
+    registered: boolean;
+    now: string;
+    expiresAt: string;
+}): void;
+export declare function assertDhCursorProgress(previous: string | undefined, next: string | null, seen?: ReadonlySet<string>): void;
+/** Every field, including the cutoff and view, must be identical across pages of one snapshot. */
+export declare function assertDhCursorBinding(expected: unknown, actual: unknown): void;
+export declare const parseDhExportCreateRequest: (value: unknown) => {
+    readonly includeContent: boolean;
+    readonly acknowledgeNonRevocable: true;
+};
+export type DhExportCreateRequest = ReturnType<typeof parseDhExportCreateRequest>;
+/** GET exports/{jobId}. `DhExportJob` (jobId+state) stays the POST 202 handle. */
+export declare const parseDhExportJobStatus: (value: unknown) => {
+    readonly jobId: string;
+    readonly generationId: string;
+    readonly state: "failed" | "queued" | "ready" | "running";
+    readonly contentIncluded: boolean;
+    readonly captureCutoff?: string | undefined;
+};
+export type DhExportJobStatus = ReturnType<typeof parseDhExportJobStatus>;
+declare const parseManifestHeader: (value: unknown) => {
+    readonly jobId: string;
+    readonly generationId: string;
+    readonly tenantScope: {
+        readonly environmentId: string;
+        readonly projectId: string;
+    };
+    readonly bindingId: string;
+    readonly cutoff: {
+        readonly schema: "dh.snapshot-cutoff/1";
+        readonly snapshotId: string;
+        readonly receiptOrdinal: number;
+        readonly captureCutoff: string;
+    };
+    readonly captureCutoff: string;
+    readonly contentIncluded: boolean;
+    readonly policyRevision: string;
+    readonly schema: "dh.export-manifest-header/2";
+    readonly canonicalProfile: "dh.canonical-jcs/1";
+    readonly state: "sealed";
+    readonly eventCount: number;
+    readonly artifactCount: number;
+    readonly streamCount: number;
+    readonly omittedArtifactCount: number;
+    readonly shardCount: number;
+    readonly shards: {
+        readonly index: number;
+        readonly recordCount: number;
+        readonly sha256: string;
+    }[];
+    readonly manifestSha256: string;
+    readonly coverage: {
+        readonly state: "captured" | "inferred" | "not-applicable" | "redacted" | "truncated" | "unavailable";
+        readonly reason?: "derived_from_summary" | "legacy_producer" | "not_applicable" | "not_captured_by_version" | "policy_redacted" | "producer_lost" | "provider_hidden" | "secret_redacted" | "size_limit" | "worker_exited_before_flush" | undefined;
+    };
+};
+export declare function parseDhExportManifestHeader(value: unknown): ReturnType<typeof parseManifestHeader>;
+export type DhExportManifestHeader = ReturnType<typeof parseDhExportManifestHeader>;
+declare function manifestEntrySchema(): Type.TUnion<[Type.TObject<{
+    readonly bindingId: Type.TString;
+    readonly originProducerInstanceId: Type.TString;
+    readonly originStreamId: Type.TString;
+    readonly representation: Type.TEnum<["metadata", "content"]>;
+    readonly recordSha256: Type.TString;
+    readonly kind: Type.TLiteral<"event">;
+    readonly id: Type.TString;
+}>, Type.TObject<{
+    readonly bindingId: Type.TString;
+    readonly originProducerInstanceId: Type.TString;
+    readonly originStreamId: Type.TString;
+    readonly representation: Type.TEnum<["metadata", "content"]>;
+    readonly recordSha256: Type.TString;
+    readonly kind: Type.TLiteral<"artifact">;
+    readonly id: Type.TString;
+    readonly sha256: Type.TString;
+    readonly sizeBytes: Type.TInteger;
+    readonly bytes: Type.TEnum<["included", "omitted", "unavailable"]>;
+    readonly reason: Type.TOptional<Type.TEnum<["policy_redacted", "producer_lost", "size_limit", "not_captured_by_version"]>>;
+}>, Type.TObject<{
+    readonly bindingId: Type.TString;
+    readonly originProducerInstanceId: Type.TString;
+    readonly kind: Type.TLiteral<"stream">;
+    readonly id: Type.TString;
+    readonly prefixThroughSequence: Type.TInteger;
+    readonly state: Type.TEnum<["open", "closed", "lost", "disputed"]>;
+}>]>;
+export type DhManifestEntry = Static<ReturnType<typeof manifestEntrySchema>>;
+declare const parseManifestPage: (value: unknown) => {
+    readonly jobId: string;
+    readonly generationId: string;
+    readonly tenantScope: {
+        readonly environmentId: string;
+        readonly projectId: string;
+    };
+    readonly bindingId: string;
+    readonly cutoff: {
+        readonly schema: "dh.snapshot-cutoff/1";
+        readonly snapshotId: string;
+        readonly receiptOrdinal: number;
+        readonly captureCutoff: string;
+    };
+    readonly captureCutoff: string;
+    readonly contentIncluded: boolean;
+    readonly policyRevision: string;
+    readonly schema: "dh.export-manifest-page/2";
+    readonly shardIndex: number;
+    readonly sha256: string;
+    readonly entries: ({
+        readonly bindingId: string;
+        readonly originProducerInstanceId: string;
+        readonly originStreamId: string;
+        readonly representation: "content" | "metadata";
+        readonly recordSha256: string;
+        readonly kind: "event";
+        readonly id: string;
+    } | {
+        readonly bindingId: string;
+        readonly originProducerInstanceId: string;
+        readonly originStreamId: string;
+        readonly representation: "content" | "metadata";
+        readonly recordSha256: string;
+        readonly kind: "artifact";
+        readonly id: string;
+        readonly sha256: string;
+        readonly sizeBytes: number;
+        readonly bytes: "included" | "omitted" | "unavailable";
+        readonly reason?: "not_captured_by_version" | "policy_redacted" | "producer_lost" | "size_limit" | undefined;
+    } | {
+        readonly bindingId: string;
+        readonly originProducerInstanceId: string;
+        readonly kind: "stream";
+        readonly id: string;
+        readonly prefixThroughSequence: number;
+        readonly state: "closed" | "disputed" | "lost" | "open";
+    })[];
+    readonly nextCursor: string | null;
+};
+export declare function parseDhExportManifestPage(value: unknown): ReturnType<typeof parseManifestPage>;
+export type DhExportManifestPage = ReturnType<typeof parseDhExportManifestPage>;
+/** Navigation is outside the immutable sealed header. */
+export declare const parseDhExportManifestResponse: (value: unknown) => {
+    readonly header: {
+        readonly jobId: string;
+        readonly generationId: string;
+        readonly tenantScope: {
+            readonly environmentId: string;
+            readonly projectId: string;
+        };
+        readonly bindingId: string;
+        readonly cutoff: {
+            readonly schema: "dh.snapshot-cutoff/1";
+            readonly snapshotId: string;
+            readonly receiptOrdinal: number;
+            readonly captureCutoff: string;
+        };
+        readonly captureCutoff: string;
+        readonly contentIncluded: boolean;
+        readonly policyRevision: string;
+        readonly schema: "dh.export-manifest-header/2";
+        readonly canonicalProfile: "dh.canonical-jcs/1";
+        readonly state: "sealed";
+        readonly eventCount: number;
+        readonly artifactCount: number;
+        readonly streamCount: number;
+        readonly omittedArtifactCount: number;
+        readonly shardCount: number;
+        readonly shards: {
+            readonly index: number;
+            readonly recordCount: number;
+            readonly sha256: string;
+        }[];
+        readonly manifestSha256: string;
+        readonly coverage: {
+            readonly state: "captured" | "inferred" | "not-applicable" | "redacted" | "truncated" | "unavailable";
+            readonly reason?: "derived_from_summary" | "legacy_producer" | "not_applicable" | "not_captured_by_version" | "policy_redacted" | "producer_lost" | "provider_hidden" | "secret_redacted" | "size_limit" | "worker_exited_before_flush" | undefined;
+        };
+    };
+    readonly firstShardCursor: string | null;
+    readonly cursorBinding: {
+        readonly schema: "dh.cursor-binding/2";
+        readonly environmentId: string;
+        readonly projectId: string;
+        readonly resource: "agents" | "events" | "generations" | "manifest";
+        readonly generationId?: string | undefined;
+        readonly bindingId?: string | undefined;
+        readonly filterSha256: string;
+        readonly view: "content" | "metadata";
+        readonly cutoff: {
+            readonly schema: "dh.snapshot-cutoff/1";
+            readonly snapshotId: string;
+            readonly receiptOrdinal: number;
+            readonly captureCutoff: string;
+        };
+        readonly mappingRevision: string;
+        readonly authorizationRevision: string;
+        readonly principalId: string;
+        readonly grantId: string;
+        readonly sessionId: string;
+        readonly pageSize: number;
+    };
+};
+export type DhExportManifestResponse = ReturnType<typeof parseDhExportManifestResponse>;
+/** JCS shard body; hash its domain-separated bytes, never navigation cursors. */
+export declare function dhManifestShardCanonicalText(page: DhExportManifestPage): string;
+/** Convenience over the same bounded incremental algorithm. */
+export declare function validateDhExportManifest(headerInput: unknown, pageInputs: readonly unknown[], options: DhExportHashOptions): {
+    header: DhExportManifestHeader;
+    pages: readonly DhExportManifestPage[];
+};
+export declare const DH_CONTROL_ACTIONS: readonly ["cancel", "retry", "continue"];
+export type DhControlAction = (typeof DH_CONTROL_ACTIONS)[number];
+/** Acceptance, delivery and application are not termination: terminationConfirmed is a separate observation. */
+export declare const DH_CONTROL_STATES: readonly ["requested", "accepted", "delivered", "applied", "rejected", "unsupported", "unknown"];
+export type DhControlState = (typeof DH_CONTROL_STATES)[number];
+export declare const DH_CONTROL_REJECT_REASONS: readonly ["not_authorized", "scope_mismatch", "stale_epoch", "target_settled", "not_eligible", "policy_denied", "budget_exhausted", "workspace_unavailable"];
+export type DhControlRejectReason = (typeof DH_CONTROL_REJECT_REASONS)[number];
+declare function controlRequestSchema(): Type.TUnion<[Type.TObject<{
+    readonly schema: Type.TLiteral<"dh.control-request/2">;
+    readonly requestId: Type.TString;
+    readonly idempotencyKey: Type.TString;
+    readonly generationId: Type.TString;
+    readonly agentId: Type.TString;
+    readonly attemptId: Type.TString;
+    readonly bindingId: Type.TString;
+    readonly bindingEpoch: Type.TString;
+    readonly sessionEpoch: Type.TString;
+    readonly capabilityRevision: Type.TString;
+    readonly action: Type.TLiteral<"cancel">;
+    readonly payload: Type.TObject<{
+        readonly scope: Type.TUnion<[Type.TLiteral<"selected">, Type.TLiteral<"whole-run">]>;
+    }>;
+}>, Type.TObject<{
+    readonly schema: Type.TLiteral<"dh.control-request/2">;
+    readonly requestId: Type.TString;
+    readonly idempotencyKey: Type.TString;
+    readonly generationId: Type.TString;
+    readonly agentId: Type.TString;
+    readonly attemptId: Type.TString;
+    readonly bindingId: Type.TString;
+    readonly bindingEpoch: Type.TString;
+    readonly sessionEpoch: Type.TString;
+    readonly capabilityRevision: Type.TString;
+    readonly action: Type.TLiteral<"retry">;
+    readonly payload: Type.TObject<{
+        readonly sourceAttemptId: Type.TString;
+        /** new-attempt: same agent, new att_ (Flow/CLI worker). new-agent: new agent + cross-agent relation (Code native retry). */
+        readonly relation: Type.TUnion<[Type.TLiteral<"new-attempt">, Type.TLiteral<"new-agent">]>;
+        /** Literal on purpose: a retry cannot drop model/context/workspace policy or reset cumulative spend. */
+        readonly policy: Type.TObject<{
+            readonly model: Type.TLiteral<"retain">;
+            readonly context: Type.TLiteral<"retain">;
+            readonly workspace: Type.TLiteral<"retain">;
+            readonly spend: Type.TLiteral<"cumulative">;
+        }>;
+    }>;
+}>, Type.TObject<{
+    readonly schema: Type.TLiteral<"dh.control-request/2">;
+    readonly requestId: Type.TString;
+    readonly idempotencyKey: Type.TString;
+    readonly generationId: Type.TString;
+    readonly agentId: Type.TString;
+    readonly attemptId: Type.TString;
+    readonly bindingId: Type.TString;
+    readonly bindingEpoch: Type.TString;
+    readonly sessionEpoch: Type.TString;
+    readonly capabilityRevision: Type.TString;
+    readonly action: Type.TLiteral<"continue">;
+    readonly payload: Type.TObject<{
+        readonly message: Type.TString;
+    }>;
+}>]>;
+export type DhControlRequest = Static<ReturnType<typeof controlRequestSchema>>;
+export type DhCancelRequest = Extract<DhControlRequest, {
+    action: "cancel";
+}>;
+export type DhRetryRequest = Extract<DhControlRequest, {
+    action: "retry";
+}>;
+export type DhContinueRequest = Extract<DhControlRequest, {
+    action: "continue";
+}>;
+export declare const parseDhControlRequest: (value: unknown) => {
+    readonly schema: "dh.control-request/2";
+    readonly requestId: string;
+    readonly idempotencyKey: string;
+    readonly generationId: string;
+    readonly agentId: string;
+    readonly attemptId: string;
+    readonly bindingId: string;
+    readonly bindingEpoch: string;
+    readonly sessionEpoch: string;
+    readonly capabilityRevision: string;
+    readonly action: "cancel";
+    readonly payload: {
+        readonly scope: "selected" | "whole-run";
+    };
+} | {
+    readonly schema: "dh.control-request/2";
+    readonly requestId: string;
+    readonly idempotencyKey: string;
+    readonly generationId: string;
+    readonly agentId: string;
+    readonly attemptId: string;
+    readonly bindingId: string;
+    readonly bindingEpoch: string;
+    readonly sessionEpoch: string;
+    readonly capabilityRevision: string;
+    readonly action: "retry";
+    readonly payload: {
+        readonly sourceAttemptId: string;
+        readonly relation: "new-agent" | "new-attempt";
+        readonly policy: {
+            readonly model: "retain";
+            readonly context: "retain";
+            readonly workspace: "retain";
+            readonly spend: "cumulative";
+        };
+    };
+} | {
+    readonly schema: "dh.control-request/2";
+    readonly requestId: string;
+    readonly idempotencyKey: string;
+    readonly generationId: string;
+    readonly agentId: string;
+    readonly attemptId: string;
+    readonly bindingId: string;
+    readonly bindingEpoch: string;
+    readonly sessionEpoch: string;
+    readonly capabilityRevision: string;
+    readonly action: "continue";
+    readonly payload: {
+        readonly message: string;
+    };
+};
+export declare const parseDhCancelRequest: (value: unknown) => DhCancelRequest;
+export declare const parseDhRetryRequest: (value: unknown) => DhRetryRequest;
+export declare const parseDhContinueRequest: (value: unknown) => DhContinueRequest;
+export interface DhControlFence {
+    generationId: string;
+    agentId: string;
+    attemptId: string;
+    bindingId: string;
+    bindingEpoch: string;
+    sessionEpoch: string;
+    capabilityRevision: string;
+}
+/** A different generation/agent is a scope error; a replaced attempt or binding epoch is stale. Never apply a stale fence. */
+export declare function checkDhControlFence(request: DhControlFence, live: DhControlFence): "ok" | "scope_mismatch" | "stale_epoch" | "policy_denied";
+/** The POST body must match the action-specific route and the path's generation/agent. */
+export declare function assertDhControlRequestForRoute(id: DhRouteId, params: Readonly<Record<string, string>>, request: unknown): DhControlRequest;
+export interface DhControlReplayEntry {
+    /** Authenticated by the server, never taken from the request body. */
+    actor: string;
+    authorityId: string;
+    tenantId: string;
+    scope: {
+        environmentId: string;
+        projectId: string;
+    };
+    request: unknown;
+}
+/**
+ * Idempotency: entries with the same actor, environment/project, generation, agent, action and key are
+ * one request. Then a byte-equal canonical body (request id, attempt, epoch, payload) is a replay (`same`);
+ * anything else under that key is a `conflict` (HTTP 409, no second effect). Other keys/actors/scopes/targets are `distinct`.
+ */
+export declare function compareDhControlReplay(stored: DhControlReplayEntry, incoming: DhControlReplayEntry): "same" | "conflict" | "distinct";
+/** POST response: a correlated handle, not an effect. */
+export declare const parseDhControlReceipt: (value: unknown) => {
+    readonly schema: "dh.control-receipt/1";
+    readonly requestId: string;
+    readonly action: "cancel" | "continue" | "retry";
+    readonly state: "accepted" | "applied" | "delivered" | "rejected" | "requested" | "unknown" | "unsupported";
+    readonly reason?: "budget_exhausted" | "not_authorized" | "not_eligible" | "policy_denied" | "scope_mismatch" | "stale_epoch" | "target_settled" | "workspace_unavailable" | undefined;
+};
+export type DhControlReceipt = ReturnType<typeof parseDhControlReceipt>;
+export declare const parseDhControlRequestStatus: (value: unknown) => {
+    readonly schema: "dh.control-status/2";
+    readonly requestId: string;
+    readonly action: "cancel" | "continue" | "retry";
+    readonly generationId: string;
+    readonly agentId: string;
+    readonly attemptId: string;
+    readonly bindingId: string;
+    readonly bindingEpoch: string;
+    readonly sessionEpoch: string;
+    readonly capabilityRevision: string;
+    readonly requestSha256: string;
+    readonly state: "accepted" | "applied" | "delivered" | "rejected" | "requested" | "unknown" | "unsupported";
+    readonly reason?: "budget_exhausted" | "not_authorized" | "not_eligible" | "policy_denied" | "scope_mismatch" | "stale_epoch" | "target_settled" | "workspace_unavailable" | undefined;
+    readonly terminationConfirmed?: boolean | undefined;
+    readonly observed?: {
+        readonly startedAgentId?: string | undefined;
+        readonly startedAttemptId?: string | undefined;
+        readonly consumedByEventId?: string | undefined;
+    } | undefined;
+    readonly updatedAt: string;
+};
+export type DhControlRequestStatus = ReturnType<typeof parseDhControlRequestStatus>;
+export declare const parseDhControlTarget: (value: unknown) => {
+    readonly generationId: string;
+    readonly agentId: string;
+    readonly attemptId: string;
+    readonly bindingId: string;
+    readonly bindingEpoch: string;
+    readonly sessionEpoch: string;
+    readonly capabilityRevision: string;
+    readonly schema: "dh.control-target/1";
+    readonly updatedAt: string;
+};
+export type DhControlTarget = ReturnType<typeof parseDhControlTarget>;
+export declare const parseDhControlHandshake: (value: unknown) => {
+    readonly schema: "dh.control-handshake/1";
+    readonly bindingId: string;
+    readonly sessionEpoch: string;
+    readonly token: string;
+};
+export type DhControlHandshake = ReturnType<typeof parseDhControlHandshake>;
+export declare const parseDhControlDelivery: (value: unknown) => {
+    readonly schema: "dh.control-delivery/1";
+    readonly request: {
+        readonly schema: "dh.control-request/2";
+        readonly requestId: string;
+        readonly idempotencyKey: string;
+        readonly generationId: string;
+        readonly agentId: string;
+        readonly attemptId: string;
+        readonly bindingId: string;
+        readonly bindingEpoch: string;
+        readonly sessionEpoch: string;
+        readonly capabilityRevision: string;
+        readonly action: "cancel";
+        readonly payload: {
+            readonly scope: "selected" | "whole-run";
+        };
+    } | {
+        readonly schema: "dh.control-request/2";
+        readonly requestId: string;
+        readonly idempotencyKey: string;
+        readonly generationId: string;
+        readonly agentId: string;
+        readonly attemptId: string;
+        readonly bindingId: string;
+        readonly bindingEpoch: string;
+        readonly sessionEpoch: string;
+        readonly capabilityRevision: string;
+        readonly action: "retry";
+        readonly payload: {
+            readonly sourceAttemptId: string;
+            readonly relation: "new-agent" | "new-attempt";
+            readonly policy: {
+                readonly model: "retain";
+                readonly context: "retain";
+                readonly workspace: "retain";
+                readonly spend: "cumulative";
+            };
+        };
+    } | {
+        readonly schema: "dh.control-request/2";
+        readonly requestId: string;
+        readonly idempotencyKey: string;
+        readonly generationId: string;
+        readonly agentId: string;
+        readonly attemptId: string;
+        readonly bindingId: string;
+        readonly bindingEpoch: string;
+        readonly sessionEpoch: string;
+        readonly capabilityRevision: string;
+        readonly action: "continue";
+        readonly payload: {
+            readonly message: string;
+        };
+    };
+    readonly tenantScope: {
+        readonly environmentId: string;
+        readonly projectId: string;
+    };
+    readonly actorId: string;
+    readonly authorityId: string;
+    readonly authorizationRevision: string;
+    readonly authorizedAt: string;
+    readonly expiresAt: string;
+    readonly requestSha256: string;
+};
+export type DhControlDelivery = ReturnType<typeof parseDhControlDelivery>;
+export interface DhControlDeliveryContext {
+    live: DhControlFence;
+    scope: {
+        environmentId: string;
+        projectId: string;
+    };
+    actorId: string;
+    authorityId: string;
+    authorizationRevision: string;
+    authorized: boolean;
+    now: string;
+}
+export declare function assertDhControlDelivery(input: unknown, context: DhControlDeliveryContext, options: DhExportHashOptions): void;
+/** Non-secret registry descriptor only. The bearer is held privately and never serialized here. */
+export declare const parseDhControllerCredential: (value: unknown) => {
+    readonly schema: "dh.controller-credential/1";
+    readonly authorityId: string;
+    readonly actorId: string;
+    readonly bindingId: string;
+    readonly targets: {
+        readonly generationId: string;
+        readonly agentId: string;
+        readonly attemptId: string;
+    }[];
+    readonly actions: {
+        readonly cancelSelected: boolean;
+        readonly cancelWholeRun: boolean;
+        readonly continueLive: boolean;
+        readonly retryFresh: boolean;
+    };
+    readonly statusRead: boolean;
+    readonly discoverTarget: boolean;
+    readonly sessionVersion: number;
+    readonly credentialVersion: number;
+    readonly issuedAt: string;
+    readonly expiresAt: string;
+};
+export type DhControllerCredential = ReturnType<typeof parseDhControllerCredential>;
+export declare function assertDhControllerAction(input: unknown, targetInput: unknown, action: keyof DhControllerCredential["actions"], context: {
+    now: string;
+    liveVersion: number;
+    sessionVersion: number;
+    membershipActive: boolean;
+}): void;
+export declare function assertDhControlStatusEvidence(input: unknown, events: readonly DhEventV1[]): void;
+/** Socket/fd3 message framing only; no I/O or transport authority is implemented. */
+export declare function parseDhControlFrame(bytes: Uint8Array): DhControlDelivery | DhControlHandshake;
+export declare function dhControlFrameBytes(input: unknown): Uint8Array;
+/** POST-local reply context only: never an assertion of the collector's durable prefix. */
+export declare function parseDhPreviousAckedSequenceHeader(value: unknown): number;
+/** Validate at the transport boundary before invoking the unchanged prefix checker. Full batches are allowed. */
+export declare function assertDhAckSentBatch(sent: DhAckSentBatch): void;
+/** Structural view of a sent batch: a DhIngestBatch satisfies it. */
+export interface DhAckSentBatch {
+    readonly streamId: string;
+    readonly events: readonly {
+        readonly eventId: string;
+        readonly sequence: number;
+    }[];
+    readonly artifacts: readonly {
+        readonly artifactId: string;
+    }[];
+}
+export interface DhAckRejection {
+    id: string;
+    code: DhRejectionCode;
+    retryable: boolean;
+}
+/** `none` is the explicit empty prefix. With no accepted ids, ackedThroughSequence only repeats the previous watermark (0 when nothing was acknowledged): it never means sequence 0 was accepted. */
+export type DhAckEventPrefix = {
+    readonly kind: "none";
+} | {
+    readonly kind: "prefix";
+    readonly throughSequence: number;
+    readonly eventIds: readonly string[];
+};
+export interface DhBatchAckResult {
+    readonly ack: DhAckV1;
+    readonly eventPrefix: DhAckEventPrefix;
+    readonly eventRejections: readonly DhAckRejection[];
+    /** Batch ACK artifact entries are metadata receipts. Bytes are acknowledged only by a dh.artifact-receipt/1 from the PUT. */
+    readonly artifactMetadata: {
+        readonly accepted: readonly string[];
+        readonly rejected: readonly DhAckRejection[];
+    };
+    readonly bytesAcknowledged: false;
+}
+/** Value of `previousAckedSequence` when no event has been acknowledged yet (the uploader cursor's initial `-1`). */
+export declare const DH_ACK_NO_PREVIOUS_SEQUENCE = -1;
+/**
+ * Validates a dh.ack/1 against the batch that was actually sent. The ACK must name the same stream and
+ * only sent ids; accepted and rejected are disjoint; accepted events are exactly the first k sent events
+ * by sequence (k may be 0).
+ *
+ * `previousAckedSequence` is REQUIRED: the stream's current acknowledged watermark, or
+ * DH_ACK_NO_PREVIOUS_SEQUENCE (-1) when nothing is acknowledged yet. The accepted prefix must be gap-free
+ * and start at previous + 1, so `[0,10,20]` cannot be acknowledged as one prefix. For k > 0,
+ * ackedThroughSequence is the prefix's last sequence. For k = 0 it must repeat the previous watermark
+ * (0 when previous is -1, because dh.ack/1 cannot carry a negative value and the empty accepted list
+ * disambiguates), so an empty ACK can neither advance nor regress the stream.
+ */
+export declare function validateDhBatchAck(sent: DhAckSentBatch, ackInput: unknown, options: {
+    previousAckedSequence: number;
+}): DhBatchAckResult;
+/**
+ * Response to PUT artifacts/{artifactId}/content. Names only the requested artifact and carries no
+ * sequence, event id or watermark, so it cannot advance an event cursor or acknowledge metadata.
+ */
+export declare const parseDhArtifactReceipt: (value: unknown) => {
+    readonly schema: "dh.artifact-receipt/1";
+    readonly artifactId: string;
+    readonly sha256: string;
+    readonly sizeBytes?: number | undefined;
+    readonly state: "rejected" | "stored";
+    readonly rejection?: {
+        readonly code: "duplicate_conflict" | "rate_limited" | "schema_invalid" | "scope_denied" | "tombstoned" | "too_large";
+        readonly retryable: boolean;
+    } | undefined;
+    readonly receivedAt: string;
+};
+export type DhArtifactReceiptV1 = ReturnType<typeof parseDhArtifactReceipt>;
+export interface DhArtifactPutRequest {
+    artifactId: string;
+    sha256: string;
+    sizeBytes?: number;
+}
+export declare function validateDhArtifactReceipt(requested: DhArtifactPutRequest, receiptInput: unknown): DhArtifactReceiptV1;
+/** Same id, same canonical bytes is an idempotent redelivery; the same id with different bytes is a conflict and never overwrites. */
+export declare function classifyDhDuplicate(existing: unknown, incoming: unknown): "identical" | "conflict";
+export declare const DH_CONTROL_SUPPORT: readonly ["required", "unsupported"];
+export type DhControlSupport = (typeof DH_CONTROL_SUPPORT)[number];
+export interface DhRuntimeCapabilities {
+    readonly controls: Readonly<{
+        backgroundStatus: DhControlSupport;
+        cancelSelected: DhControlSupport;
+        cancelWholeRun: DhControlSupport;
+        continueLive: DhControlSupport;
+        retryFresh: DhControlSupport;
+    }>;
+    readonly modes: readonly string[];
+    readonly unsupportedModes: readonly string[];
+}
+/**
+ * "required" means the implementation and a positive qualification check are mandatory for full
+ * completion; an `unsupported` reply never satisfies it. "unsupportedModes" cannot claim full capture.
+ */
+export declare const DH_SUPPORTED_RUNTIMES: {
+    "cli-node": DhRuntimeCapabilities;
+    "cli-bun": DhRuntimeCapabilities;
+    flow: {
+        controls: {
+            readonly backgroundStatus: "required";
+            readonly cancelSelected: "required";
+            readonly cancelWholeRun: "required";
+            readonly continueLive: "required";
+            readonly retryFresh: "required";
+        };
+        modes: string[];
+        unsupportedModes: never[];
+    };
+};
+export type DhRuntimeId = keyof typeof DH_SUPPORTED_RUNTIMES;
+/**
+ * Public shape of the safe host capability `getFlowTraceProducer(ctx: ExtensionContext):
+ * FlowTraceProducer | undefined`, implemented and exported by the CLI (`@humain/humain-code`, C14).
+ * This package ships no implementation, recorder, config, token or transport. The host validates and
+ * narrows every input, binds `issuer=flow`/`via=flow` provenance and re-checks the live binding on each call.
+ */
+export interface FlowTraceIdentity {
+    readonly generationId: string;
+    readonly agentId: string;
+    readonly attemptId: string;
+    readonly environmentId: string;
+    readonly projectId: string;
+    /** Actual segment admission identity and epoch, never fabricated by the host. */
+    readonly bindingId: string;
+    readonly bindingEpoch: string;
+    /** Independent host session epoch; replacement disables stale capabilities. */
+    readonly sessionEpoch: string;
+}
+export interface FlowTraceEventInput {
+    kind: DhEventKind;
+    agentId?: string;
+    parentAgentId?: string;
+    attemptId?: string;
+    attemptNumber?: number;
+    retryOfAttemptId?: string;
+    outcome?: DhOutcome;
+    failure?: {
+        code: string;
+        message?: string;
+    };
+    payload: Record<string, unknown>;
+    fields?: Record<string, DhCoverage>;
+    removedFieldPaths?: readonly string[];
+    artifacts?: readonly string[];
+    eventId?: string;
+}
+export interface TraceChildEnv {
+    /** Variables to set on the child process environment. */
+    set: Record<string, string>;
+    /** Variables to delete from the child process environment. */
+    unset: string[];
+}
+export interface FlowTraceProducer {
+    readonly identity: Readonly<FlowTraceIdentity>;
+    recordEvent(input: FlowTraceEventInput): string | undefined;
+    eventIdForToolCall(toolCallId: string): string | undefined;
+    beginChildAgent(input: {
+        logicalTaskId: string;
+        nativeLaunchId: string;
+        parentEventId: string;
+        externalIds: readonly DhExternalId[];
+    }): string;
+    beginChildAttempt(agentId: string, input: {
+        attemptNumber: number;
+        retryOfAttemptId?: string;
+        externalIds: readonly DhExternalId[];
+    }): {
+        attemptId: string;
+        env: TraceChildEnv;
+    };
+    finishChildAttempt(agentId: string, attemptId: string, outcome: DhOutcome, failure?: {
+        code: string;
+        message?: string;
+    }): string | undefined;
+    recordRetryScheduled(agentId: string, failedAttemptId: string, nextAttemptNumber: number, delayMs: number): string | undefined;
+}
+//# sourceMappingURL=trace-http.d.ts.map