@dynamicalsystems/idl 0.6.1

package/src/index.ts

@@ -0,0 +1,110 @@
+export { closed, Hex64, NonEmptyString, Orn, Reference, SafeInt, UtcSecond } from "./primitives.js";
+export type { ProfileEntry } from "./primitives.js";
+export {
+  DISPATCH_CONSUME_PROFILE,
+  DISPATCH_MAX_SKEW_SECONDS,
+  DispatchConsumeRequestSchema,
+  DispatchLeaseSchema,
+  DispatchRefusalCodeSchema,
+  DispatchRefusalSchema,
+} from "./kernel/dispatch-consume.v1.js";
+export type {
+  DispatchConsumeRequest,
+  DispatchLease,
+  DispatchRefusal,
+  DispatchRefusalCode,
+} from "./kernel/dispatch-consume.v1.js";
+export {
+  AcceptedSchema,
+  ExecutionDocumentSchema,
+  ExecutionLawSchema,
+  ExecutionResourcesSchema,
+  OPERATION_PROFILE,
+  OperationBeforeSchema,
+  OperationCleanupSchema,
+  OperationCostSchema,
+  OperationEvidenceSchema,
+  OperationExecutionSchema,
+  OperationRequestSchema,
+  OperationStatusSchema,
+  ReadbackSchema,
+} from "./run/operation.v1.js";
+export type {
+  Accepted,
+  ExecutionDocument,
+  ExecutionLaw,
+  ExecutionResources,
+  OperationBefore,
+  OperationCleanup,
+  OperationCost,
+  OperationEvidence,
+  OperationExecution,
+  OperationRequest,
+  OperationStatus,
+  Readback,
+} from "./run/operation.v1.js";
+export {
+  PRICE_PROFILE_REFERENCE,
+  SCOPE_REFERENCE,
+  SIGNED_LAW_DOMAIN,
+  SIGNED_LAW_PROFILE,
+  SignedLawBundleSchema,
+} from "./infra/signed-law.v1.js";
+export {
+  RESOURCE_DESCRIPTOR_KIND,
+  RESOURCE_DESCRIPTOR_PROFILE,
+  ResourceDescriptorSchema,
+} from "./infra/resource-descriptor.v1.js";
+export type { ResourceDescriptor } from "./infra/resource-descriptor.v1.js";
+export { ADOPTION_FACT_PROFILE, AdoptionFactSchema } from "./infra/adoption-fact.v1.js";
+export type { AdoptionFact } from "./infra/adoption-fact.v1.js";
+export type { SignedLawBundle } from "./infra/signed-law.v1.js";
+export {
+  REVOCATIONS_PROFILE,
+  RevocationPointerSchema,
+  RevocationSchema,
+} from "./registry/revocations.v1.js";
+export type { RevocationPointer, RevocationSnapshot } from "./registry/revocations.v1.js";
+export {
+  BOOTSTRAP_PROFILE,
+  BootstrapActionSchema,
+  BootstrapIntentSchema,
+  SignedBootstrapIntentSchema,
+} from "./kernel/bootstrap.v1.js";
+export type {
+  BootstrapAction,
+  BootstrapIntent,
+  SignedBootstrapIntent,
+} from "./kernel/bootstrap.v1.js";
+export {
+  ORDINARY_AUTHORITY_PROFILE,
+  OrdinaryAuthoritySchema,
+} from "./kernel/ordinary-authority.v1.js";
+export type { OrdinaryAuthority } from "./kernel/ordinary-authority.v1.js";
+export { EXECUTOR_PROTOCOL_VERSION, PROVIDER_PROTOCOL_VERSION } from "./run/contract-versions.js";
+export type { ExecutorProtocolVersion, ProviderProtocolVersion } from "./run/contract-versions.js";
+
+import type { ProfileEntry } from "./primitives.js";
+import { dispatchConsumeV1 } from "./kernel/dispatch-consume.v1.js";
+import { operationV1 } from "./run/operation.v1.js";
+import { signedLawV1 } from "./infra/signed-law.v1.js";
+import { resourceDescriptorV1 } from "./infra/resource-descriptor.v1.js";
+import { adoptionFactV1 } from "./infra/adoption-fact.v1.js";
+import { revocationsV1 } from "./registry/revocations.v1.js";
+import { bootstrapV1 } from "./kernel/bootstrap.v1.js";
+import { ordinaryAuthorityV1 } from "./kernel/ordinary-authority.v1.js";
+
+/** Every profile this version of the package defines, keyed by literal.
+ * Profile modules are added here as they are extracted; the rules test
+ * and the schema emitter walk this registry, so a module that is not
+ * registered does not exist. */
+export const PROFILES: Readonly<Record<string, ProfileEntry>> = {
+  [dispatchConsumeV1.literal]: dispatchConsumeV1,
+  [operationV1.literal]: operationV1,
+  [signedLawV1.literal]: signedLawV1,
+  [resourceDescriptorV1.literal]: resourceDescriptorV1,
+  [adoptionFactV1.literal]: adoptionFactV1,
+  [revocationsV1.literal]: revocationsV1,
+  [bootstrapV1.literal]: bootstrapV1,
+  [ordinaryAuthorityV1.literal]: ordinaryAuthorityV1,
+};

package/src/infra/adoption-fact.v1.ts

@@ -0,0 +1,47 @@
+// dsg.infra.adoption-fact/1
+// Owner: dsg-infra (governance/adoption.py is the producer: it verifies an
+// exported kernel bootstrap record snapshot offline - canonical digest,
+// event hash chain, stream heads, artifact bytes - and emits the accepted
+// root-authorizing operation as this fact). The tofu baseline root
+// consumes it and re-validates independently: its deployment-specific
+// conditions (which root string, testOnly false for the real baseline)
+// are that root's own law, deliberately NOT part of this shape - a
+// synthetic testOnly fact is a valid FACT, just never a valid deployed
+// authorization.
+//
+// Lifted from dsg-infra governance/adoption.py at e9d9501 and
+// infrastructure/environments/dsg-run/adoption.tf (S01, commit fccf709).
+import { type Static, Type } from "@sinclair/typebox";
+import { closed, Hex64, NonEmptyString, Orn, type ProfileEntry } from "../primitives.js";
+
+export const ADOPTION_FACT_PROFILE = "dsg.infra.adoption-fact/1" as const;
+
+const AdoptionFactSchemaValue = closed({
+  profile: Type.Literal(ADOPTION_FACT_PROFILE),
+  /** The root the record names as active baseline owner. */
+  root: NonEmptyString,
+  lineage: NonEmptyString,
+  /** The accepted root-authorizing operation. */
+  operation: NonEmptyString,
+  /** Count of accepted root operations; ownership needs at least one. */
+  generation: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }),
+  /** Canonical digest of the verified record snapshot. */
+  snapshotSha256: Hex64,
+  /** initialize establishes the first owner; cutover transfers it. restore
+   *  and enrollment move custody and human roots, never root ownership. */
+  action: Type.Union([
+    Type.Literal("initialize_kernel_record"),
+    Type.Literal("cutover_single_writer"),
+  ]),
+  signer: Orn,
+  humanRoot: NonEmptyString,
+  testOnly: Type.Boolean(),
+});
+export const AdoptionFactSchema: typeof AdoptionFactSchemaValue = AdoptionFactSchemaValue;
+export type AdoptionFact = Static<typeof AdoptionFactSchema>;
+
+export const adoptionFactV1: ProfileEntry = {
+  literal: ADOPTION_FACT_PROFILE,
+  rootShape: "fact",
+  shapes: { fact: AdoptionFactSchema },
+};

package/src/infra/resource-descriptor.v1.ts

@@ -0,0 +1,58 @@
+// dsg.infra.resource-descriptor/1
+// Owner: dsg-infra (policy/resource-descriptor.schema.json is the source;
+// law_contract.py validates this exact shape and evaluate_descriptor
+// returns its canonical digest). A concrete provider-neutral resource: the
+// thing rendered from a workload and gated against the signed law's
+// capability limits before any provider API sees it. Distinct from
+// signed-law's capabilityProfile, which states allowed LIMITS; this
+// document states one concrete resource checked against them.
+//
+// The wire carries kind "dsg.infra.resource-descriptor" plus
+// schemaVersion 1; the /1 literal itself is the version marker signed-law
+// fields pin (scope.resourceDescriptorVersion, capabilities
+// .descriptorVersion), so the constant lives here and signed-law imports
+// it. Lifted verbatim from dsg-infra policy/resource-descriptor.schema.json
+// at fccf709.
+import { type Static, Type } from "@sinclair/typebox";
+import { closed, NonEmptyString, type ProfileEntry } from "../primitives.js";
+
+export const RESOURCE_DESCRIPTOR_PROFILE = "dsg.infra.resource-descriptor/1" as const;
+/** The document kind: the profile literal without its version suffix; the
+ * version rides in schemaVersion. Frozen /1 wire choice. */
+export const RESOURCE_DESCRIPTOR_KIND = "dsg.infra.resource-descriptor" as const;
+
+const prefixedDigest = Type.String({ pattern: "^sha256:[0-9a-f]{64}$" });
+
+const ResourceDescriptorSchemaValue = closed({
+  schemaVersion: Type.Literal(1),
+  kind: Type.Literal(RESOURCE_DESCRIPTOR_KIND),
+  workloadClass: NonEmptyString,
+  lifecycle: Type.Union([Type.Literal("ephemeral"), Type.Literal("durable")]),
+  machineType: Type.String({ pattern: "^[a-z][a-z0-9]*-[a-z0-9]+-[0-9]+$" }),
+  accelerator: Type.Union([Type.String({ minLength: 1 }), Type.Null()]),
+  acceleratorCount: Type.Integer({ minimum: 0 }),
+  vcpuCount: Type.Integer({ minimum: 1 }),
+  memoryGiB: Type.Integer({ minimum: 1 }),
+  maxRunSeconds: Type.Integer({ minimum: 1 }),
+  maxParallelism: Type.Integer({ minimum: 1 }),
+  region: NonEmptyString,
+  imageDigest: prefixedDigest,
+  moduleDigest: prefixedDigest,
+  externalIp: Type.Literal(false),
+  network: Type.Literal("private"),
+  reservation: closed({
+    gpuSeconds: Type.Integer({ minimum: 0 }),
+    usdMicroUnits: Type.Integer({ minimum: 0 }),
+  }),
+});
+export const ResourceDescriptorSchema: typeof ResourceDescriptorSchemaValue =
+  ResourceDescriptorSchemaValue;
+export type ResourceDescriptor = Static<typeof ResourceDescriptorSchema>;
+
+export const resourceDescriptorV1: ProfileEntry = {
+  literal: RESOURCE_DESCRIPTOR_PROFILE,
+  literalNote:
+    "carried as kind (unversioned) plus schemaVersion on the document; the /1 literal is the version marker signed-law pins",
+  rootShape: "descriptor",
+  shapes: { descriptor: ResourceDescriptorSchema },
+};

package/src/infra/signed-law.v1.ts

@@ -0,0 +1,277 @@
+// dsg.infra.signed-law/1
+// Owner: dsg-infra (the S02 law producer; both prior copies were generated
+// from dsg-infra policy/law-bundle.schema.json, source SHA-256
+// bc3692395cf994567115c76d8fce66a7e9ebe7b2c50c70e1c83b8b10693a838c).
+//
+// The literal is the signing DOMAIN: it appears as the `domain` member of
+// the canonical signature input (JCS of {domain, payload, payloadSha256,
+// testOnly}), not as a field of the bundle itself; the bundle carries
+// `kind` plus `schemaVersion` instead. Lifted verbatim from dsg-kernel
+// packages/signing/src/law-schema.ts at ffafe305, byte-identical to the
+// module registry copy at 1f8c994.
+import { Type, type Static } from "@sinclair/typebox";
+import type { ProfileEntry } from "../primitives.js";
+import { RESOURCE_DESCRIPTOR_PROFILE } from "./resource-descriptor.v1.js";
+
+export const SIGNED_LAW_PROFILE = "dsg.infra.signed-law/1" as const;
+/** The signature-input domain member is exactly the profile literal. */
+export const SIGNED_LAW_DOMAIN = SIGNED_LAW_PROFILE;
+
+/** The scope vocabulary version today's laws cite in
+ * standingOrder.scopeReference. The FIELD stays an open nonempty string on
+ * purpose (a law may cite a future scope); this constant is the value in
+ * force, exported so no consumer hand-types it. */
+export const SCOPE_REFERENCE = "dsg.infra.scope/1" as const;
+
+/** The price-profile version today's laws cite in priceProfile.reference.
+ * Same rule: the field stays open; this is the value in force. */
+export const PRICE_PROFILE_REFERENCE = "dsg.infra.price-profile/1" as const;
+
+const nullableString = Type.Union([Type.String({ minLength: 1 }), Type.Null()]);
+const authority = Type.Object(
+  {
+    issuerType: Type.Literal("human"),
+    issuerReference: nullableString,
+    designationReference: nullableString,
+    signatureReference: nullableString,
+    humanSignatureRequired: Type.Literal(true),
+    releaseAutomationMayIssue: Type.Literal(false),
+  },
+  { additionalProperties: false },
+);
+const utcSecond = Type.String({
+  pattern: "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$",
+});
+const standingOrder = Type.Object(
+  {
+    reference: nullableString,
+    designationReference: nullableString,
+    scopeReference: Type.String({ minLength: 1 }),
+    issuedAt: Type.Union([utcSecond, Type.Null()]),
+    expiresAt: Type.Union([utcSecond, Type.Null()]),
+  },
+  { additionalProperties: false },
+);
+const scope = Type.Object(
+  {
+    actions: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
+    workloadClasses: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
+    providers: Type.Array(Type.Literal("provider-neutral"), { minItems: 1, uniqueItems: true }),
+    regions: Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true }),
+    resourceDescriptorVersion: Type.Literal(RESOURCE_DESCRIPTOR_PROFILE),
+  },
+  { additionalProperties: false },
+);
+const validity = Type.Object(
+  {
+    clock: Type.Literal("UTC"),
+    notBefore: Type.Union([utcSecond, Type.Null()]),
+    notAfter: Type.Union([utcSecond, Type.Null()]),
+  },
+  { additionalProperties: false },
+);
+const revocation = Type.Object(
+  {
+    snapshotReference: nullableString,
+    failClosed: Type.Literal(true),
+    checks: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
+  },
+  { additionalProperties: false },
+);
+const ceiling = Type.Object(
+  {
+    unit: Type.String({ minLength: 1 }),
+    period: Type.String({ minLength: 1 }),
+    scope: Type.Union([Type.Literal("person"), Type.Literal("organization")]),
+    value: Type.Union([Type.Integer({ minimum: 0 }), Type.Null()]),
+  },
+  { additionalProperties: false },
+);
+const capabilityProfile = Type.Object(
+  {
+    lifecycle: Type.Union([Type.Literal("ephemeral"), Type.Literal("durable")]),
+    machinePrefixes: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
+    accelerators: Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true }),
+    maxRunSeconds: Type.Union([Type.Integer({ minimum: 0 }), Type.Null()]),
+    maxParallelism: Type.Union([Type.Integer({ minimum: 1 }), Type.Null()]),
+    maxGpuInstances: Type.Union([Type.Integer({ minimum: 0 }), Type.Null()]),
+    maxVcpus: Type.Union([Type.Integer({ minimum: 1 }), Type.Null()]),
+    network: Type.Literal("private"),
+    externalIpAllowed: Type.Literal(false),
+  },
+  { additionalProperties: false },
+);
+const capabilities = Type.Object(
+  {
+    providerNeutral: Type.Literal(true),
+    descriptorVersion: Type.Literal(RESOURCE_DESCRIPTOR_PROFILE),
+    profiles: Type.Record(Type.String(), capabilityProfile, { minProperties: 1 }),
+  },
+  { additionalProperties: false },
+);
+const priceProfile = Type.Object(
+  {
+    reference: Type.String({ minLength: 1 }),
+    status: Type.Union([Type.Literal("unassigned"), Type.Literal("retained")]),
+    currency: Type.Literal("USD"),
+    unit: Type.Literal("micro_usd"),
+    basis: Type.Literal("retained-conservative-on-demand"),
+    rates: Type.Object(
+      {
+        vcpuSecond: Type.Optional(Type.Integer({ minimum: 0 })),
+        memoryGiBSecond: Type.Optional(Type.Integer({ minimum: 0 })),
+        gpuSecond: Type.Optional(Type.Integer({ minimum: 0 })),
+        startup: Type.Optional(Type.Integer({ minimum: 0 })),
+      },
+      { additionalProperties: false },
+    ),
+    safetyFactorBps: Type.Union([Type.Integer({ minimum: 10000 }), Type.Null()]),
+    validFrom: Type.Union([utcSecond, Type.Null()]),
+    validUntil: Type.Union([utcSecond, Type.Null()]),
+  },
+  { additionalProperties: false },
+);
+const bootstrap = Type.Object(
+  {
+    mode: Type.Literal("finite-human-root"),
+    rootReferences: Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true }),
+    allowedActions: Type.Array(
+      Type.Union([
+        Type.Literal("enroll_human_root"),
+        Type.Literal("initialize_kernel_record"),
+        Type.Literal("restore_kernel_record"),
+        Type.Literal("cutover_single_writer"),
+      ]),
+      { minItems: 1, uniqueItems: true },
+    ),
+    maxUses: Type.Integer({ minimum: 1, maximum: 1 }),
+    expiresAt: Type.Union([utcSecond, Type.Null()]),
+    projectCreationAllowed: Type.Literal(false),
+    requiresHumanSignature: Type.Literal(true),
+    automationCanSatisfy: Type.Literal(false),
+  },
+  { additionalProperties: false },
+);
+const digest = Type.String({ pattern: "^sha256:[0-9a-f]{64}$" });
+const policyBundle = Type.Object(
+  {
+    digest: digest,
+    manifest: Type.Record(
+      Type.String({ pattern: "^policy/[A-Za-z0-9._-]+\\.rego$" }),
+      Type.String({ pattern: "^[0-9a-f]{64}$" }),
+      { additionalProperties: false, minProperties: 1 },
+    ),
+  },
+  { additionalProperties: false },
+);
+const lawInputProfile = Type.Object(
+  {
+    requiresRunCeiling: Type.Boolean(),
+    requiresExpirationLabel: Type.Boolean(),
+    maxRunSeconds: Type.Integer({ minimum: 1 }),
+    allowExternalIp: Type.Literal(false),
+    machinePrefixes: Type.Array(Type.String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
+    accelerators: Type.Array(Type.String({ minLength: 1 }), { uniqueItems: true }),
+    maxGpuInstances: Type.Integer({ minimum: 0 }),
+    maxTotalVcpus: Type.Integer({ minimum: 1 }),
+    maxParallelism: Type.Integer({ minimum: 1 }),
+    network: Type.Literal("private"),
+  },
+  { additionalProperties: false },
+);
+const lawInputs = Type.Object(
+  {
+    cloudflare: Type.Object(
+      {
+        approvedZoneId: Type.String({ minLength: 1 }),
+        approvedAccountId: Type.String({ minLength: 1 }),
+      },
+      { additionalProperties: false },
+    ),
+    planLimits: Type.Object(
+      {
+        maxGpuInstances: Type.Integer({ minimum: 0 }),
+        maxTotalVcpus: Type.Integer({ minimum: 1 }),
+        approvedLocations: Type.Array(Type.String({ minLength: 1 }), {
+          minItems: 1,
+          uniqueItems: true,
+        }),
+      },
+      { additionalProperties: false },
+    ),
+    profiles: Type.Object(
+      { compute: lawInputProfile, plane: lawInputProfile },
+      { additionalProperties: false },
+    ),
+  },
+  { additionalProperties: false },
+);
+const evaluationInputs = Type.Object(
+  { policyBundle: policyBundle, lawInputs: lawInputs },
+  { additionalProperties: false },
+);
+const lawDocument = Type.Object(
+  {
+    schemaVersion: Type.Literal(1),
+    kind: Type.Literal("dsg.infra.law"),
+    lawId: Type.String({ minLength: 1 }),
+    status: Type.Union([Type.Literal("unissued"), Type.Literal("issued")]),
+    authority: authority,
+    standingOrder: standingOrder,
+    scope: scope,
+    validity: validity,
+    revocation: revocation,
+    ceilings: Type.Object(
+      {
+        gpuSecondsPerPersonUtcWeek: ceiling,
+        usdMicroUnitsPerPersonUtcMonth: ceiling,
+        usdMicroUnitsPerOrganizationUtcMonth: ceiling,
+      },
+      { additionalProperties: false },
+    ),
+    capabilities: capabilities,
+    priceProfile: priceProfile,
+    bootstrap: bootstrap,
+    evaluationInputs: evaluationInputs,
+  },
+  { additionalProperties: false },
+);
+const signature = Type.Object(
+  {
+    algorithm: Type.Literal("Ed25519"),
+    keyClass: Type.Union([
+      Type.Literal("synthetic-test-only"),
+      Type.Literal("human-authority"),
+      Type.Literal("release-automation"),
+    ]),
+    publicKeyHex: Type.String({ pattern: "^[0-9a-f]{64}$" }),
+    signatureHex: Type.String({ pattern: "^[0-9a-f]{128}$" }),
+  },
+  { additionalProperties: false },
+);
+const signedLawBundle = Type.Object(
+  {
+    schemaVersion: Type.Literal(1),
+    kind: Type.Union([
+      Type.Literal("dsg.infra.signed-law"),
+      Type.Literal("dsg.infra.signed-law-fixture"),
+    ]),
+    testOnly: Type.Boolean(),
+    deployedAuthority: Type.Boolean(),
+    payload: lawDocument,
+    canonicalPayload: Type.String({ minLength: 1 }),
+    payloadSha256: Type.String({ pattern: "^[0-9a-f]{64}$" }),
+    canonicalSignatureInput: Type.String({ minLength: 1 }),
+    signature: signature,
+  },
+  { additionalProperties: false },
+);
+export const SignedLawBundleSchema = signedLawBundle;
+export type SignedLawBundle = Static<typeof SignedLawBundleSchema>;
+
+export const signedLawV1: ProfileEntry = {
+  literal: SIGNED_LAW_PROFILE,
+  literalNote:
+    "carried as the domain member of the canonical signature input, not as a bundle field",
+  shapes: { bundle: SignedLawBundleSchema },
+};

package/src/kernel/bootstrap.v1.ts

@@ -0,0 +1,68 @@
+// dsg.kernel.bootstrap/1
+// Owner: dsg-kernel (K14). The finite bootstrap intent: a signed,
+// single-use, expiring authorization for exactly one of four record
+// actions, binding plan and resource-spec digests. enroll_human_root
+// (M030) is the additive action that anchors ordinary-authority
+// enrollment; initialization is never reinterpreted as enrollment. The
+// record-held bootstrap event payloads stay in the kernel.
+//
+// Lifted verbatim from dsg-kernel packages/core/src/contracts.ts at
+// 00b33ac1. createdAt/expiresAt are frozen /1 nonempty strings, recorded
+// in FROZEN_EXEMPTIONS; exact-second patterns would be a /2 against
+// already-recorded signed intents.
+import { type Static, Type } from "@sinclair/typebox";
+import { closed, Hex64, NonEmptyString, Orn, type ProfileEntry } from "../primitives.js";
+
+export const BOOTSTRAP_PROFILE = "dsg.kernel.bootstrap/1" as const;
+
+const BootstrapActionSchemaValue = Type.Union([
+  Type.Literal("initialize_kernel_record"),
+  Type.Literal("restore_kernel_record"),
+  Type.Literal("cutover_single_writer"),
+  Type.Literal("enroll_human_root"),
+]);
+export const BootstrapActionSchema: typeof BootstrapActionSchemaValue = BootstrapActionSchemaValue;
+export type BootstrapAction = Static<typeof BootstrapActionSchema>;
+
+const BootstrapIntentSchemaValue = closed({
+  version: Type.Literal(BOOTSTRAP_PROFILE),
+  operation: NonEmptyString,
+  action: BootstrapActionSchema,
+  lineage: NonEmptyString,
+  humanRoot: NonEmptyString,
+  signer: Orn,
+  scope: NonEmptyString,
+  resources: Type.Array(
+    closed({
+      identity: NonEmptyString,
+      specSha256: Hex64,
+    }),
+    { minItems: 1, uniqueItems: true },
+  ),
+  planSha256: Hex64,
+  preconditionsSha256: Hex64,
+  createdAt: NonEmptyString,
+  expiresAt: NonEmptyString,
+  maxUses: Type.Literal(1),
+  cost: closed({
+    currency: Type.Literal("USD"),
+    maxMicroUsd: Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+    assumptionsSha256: Hex64,
+  }),
+  testOnly: Type.Boolean(),
+});
+export const BootstrapIntentSchema: typeof BootstrapIntentSchemaValue = BootstrapIntentSchemaValue;
+export type BootstrapIntent = Static<typeof BootstrapIntentSchema>;
+
+const SignedBootstrapIntentSchemaValue = closed({
+  body: BootstrapIntentSchema,
+  signature: Type.String({ pattern: "^[0-9a-f]{128}$" }),
+});
+export const SignedBootstrapIntentSchema: typeof SignedBootstrapIntentSchemaValue =
+  SignedBootstrapIntentSchemaValue;
+export type SignedBootstrapIntent = Static<typeof SignedBootstrapIntentSchema>;
+
+export const bootstrapV1: ProfileEntry = {
+  literal: BOOTSTRAP_PROFILE,
+  shapes: { intent: BootstrapIntentSchema, signed: SignedBootstrapIntentSchema },
+};

package/src/kernel/dispatch-consume.v1.ts

@@ -0,0 +1,114 @@
+// dsg.kernel.dispatch-consume/1
+// Owner: dsg-kernel (the consume route produces the lease and the refusal;
+// the plane produces the request).
+//
+// K05/I3: the dispatch-authorization consume contract between the kernel
+// and the plane. Immediately before its first non-cleanup cloud mutation -
+// identity, bucket and IAM preparation included, not only job submission -
+// the plane consumes a short-lived, single-operation dispatch authorization
+// bound to operation, generation, envelope digest, law digest and
+// reservation. The committed consume event is the authorization ordering
+// point; it is not atomic with any provider API. A replay returns the
+// original lease and never renews it; a renewal is a new recorded
+// authorization decision for the same operation and reservation.
+//
+// Lifted verbatim from dsg-kernel packages/core/src/dispatch.ts at commit
+// c2d39d95 (wire shapes only; the record-held event payloads stay in the
+// kernel). This file is frozen: changes ship as dispatch-consume.v2.ts.
+import { type Static, Type } from "@sinclair/typebox";
+import {
+  closed,
+  Hex64,
+  NonEmptyString,
+  Orn,
+  Reference,
+  UtcSecond,
+  type ProfileEntry,
+} from "../primitives.js";
+
+export const DISPATCH_CONSUME_PROFILE = "dsg.kernel.dispatch-consume/1" as const;
+
+/** The bounded clock skew a lease check must tolerate, in seconds. */
+export const DISPATCH_MAX_SKEW_SECONDS = 300;
+
+const DispatchConsumeRequestSchemaValue = closed({
+  profile: Type.Literal(DISPATCH_CONSUME_PROFILE),
+  /** The kernel operation identity from the accepted OperationRequest. */
+  operationId: NonEmptyString,
+  /** The workspace generation the plane admitted the operation at. */
+  generation: Type.Integer({ minimum: 0 }),
+  /** The Case the operation belongs to - the stream the consume event
+   *  lands on and the stream the reservation was recorded on. */
+  caseOrn: Orn,
+  /** SHA256(JCS(complete OperationRequest)) - the M010 envelope digest. */
+  envelopeSha256: Hex64,
+  /** The exact retained signed-law bytes the Case pins. */
+  lawSha256: Hex64,
+  /** The K04 reservation the authorization is bound to: sha256 is the
+   *  reservation event's record id. */
+  reservation: Reference,
+  requestedAt: UtcSecond,
+  /** False: first consumption or idempotent replay of it. True: an explicit
+   *  renewal - a new recorded authorization decision for the same operation
+   *  and reservation after lease expiry with the work known unsubmitted. A
+   *  replay never renews; only this flag does, and it re-runs every
+   *  revocation check at the current record state. */
+  renewal: Type.Boolean(),
+});
+export const DispatchConsumeRequestSchema: typeof DispatchConsumeRequestSchemaValue =
+  DispatchConsumeRequestSchemaValue;
+export type DispatchConsumeRequest = Static<typeof DispatchConsumeRequestSchema>;
+
+const DispatchLeaseSchemaValue = closed({
+  profile: Type.Literal(DISPATCH_CONSUME_PROFILE),
+  /** The consume event's record id: the committed ordering point. */
+  leaseId: Hex64,
+  operationId: NonEmptyString,
+  generation: Type.Integer({ minimum: 0 }),
+  caseOrn: Orn,
+  envelopeSha256: Hex64,
+  lawSha256: Hex64,
+  reservation: Reference,
+  consumedAt: UtcSecond,
+  /** Fixed maximum duration from consumedAt; the plane checks validity
+   *  before each new non-cleanup call, Batch submission included. */
+  expiresAt: UtcSecond,
+  /** The bounded clock skew a lease check must tolerate, in seconds. */
+  maxSkewSeconds: Type.Integer({ minimum: 0, maximum: DISPATCH_MAX_SKEW_SECONDS }),
+  renewal: Type.Literal("new-authorization-required"),
+  /** False when this response replays an earlier committed consumption:
+   *  the lease bytes, expiry included, are the original's. */
+  fresh: Type.Boolean(),
+});
+export const DispatchLeaseSchema: typeof DispatchLeaseSchemaValue = DispatchLeaseSchemaValue;
+export type DispatchLease = Static<typeof DispatchLeaseSchema>;
+
+const DispatchRefusalCodeSchemaValue = Type.Union([
+  Type.Literal("unknown_operation"),
+  Type.Literal("no_reservation"),
+  Type.Literal("binding_mismatch"),
+  Type.Literal("revoked"),
+  Type.Literal("authority_refused"),
+  Type.Literal("renewal_requires_existing_consumption"),
+  Type.Literal("unavailable"),
+]);
+export const DispatchRefusalCodeSchema: typeof DispatchRefusalCodeSchemaValue =
+  DispatchRefusalCodeSchemaValue;
+export type DispatchRefusalCode = Static<typeof DispatchRefusalCodeSchema>;
+
+const DispatchRefusalSchemaValue = closed({
+  profile: Type.Literal(DISPATCH_CONSUME_PROFILE),
+  code: DispatchRefusalCodeSchema,
+  issues: Type.Array(NonEmptyString, { minItems: 1 }),
+});
+export const DispatchRefusalSchema: typeof DispatchRefusalSchemaValue = DispatchRefusalSchemaValue;
+export type DispatchRefusal = Static<typeof DispatchRefusalSchema>;
+
+export const dispatchConsumeV1: ProfileEntry = {
+  literal: DISPATCH_CONSUME_PROFILE,
+  shapes: {
+    request: DispatchConsumeRequestSchema,
+    lease: DispatchLeaseSchema,
+    refusal: DispatchRefusalSchema,
+  },
+};