@agen-ai/agent-orchestration 0.0.0-stage → 0.4.0

package/dist/store-adapter/plan.js

@@ -0,0 +1,168 @@
+import { failDelegation } from "../shared/operational-errors.js";
+import { copyBoundedDelegationData } from "../shared/bounds.js";
+import { delegationInputDigest } from "../shared/identity.js";
+import { freezeDelegationData } from "../shared/immutable.js";
+import { DELEGATION_CRITICAL_SLOTS, DELEGATION_RUN_RESERVATION_BYTES, parseDelegationLimits } from "../shared/limits.js";
+import { parseDelegationStoreCommand } from "../store/parse.js";
+import { parseDelegationRunRecord, parseDelegationTaskRecord } from "../tasks/parse.js";
+import { admitRun } from "./admission.js";
+import { deriveTask, same } from "./context.js";
+import { dispatchIntent, operationReceipt, requestState } from "./execution.js";
+import { cancelRun, observeRun, retireRecovery, settle } from "./lifecycle.js";
+import { delivery, duplicateDelivery } from "./delivery.js";
+function operationKind(command) {
+  if (command.kind === "admit" || command.kind === "cancel") return command.kind;
+  if (command.kind === "dispatch_intent") return command.operationKind;
+  if (command.kind === "request_state" && command.state === "resolution_intended") return "request_resolution";
+  return void 0;
+}
+function duplicate(command, current) {
+  if (command.kind === "delivery_claim" || command.kind === "delivery_receipt") return duplicateDelivery(command, current);
+  const prior = current.operation;
+  const kind = operationKind(command);
+  if (prior && (prior.inputDigest !== command.inputDigest || kind && prior.kind !== kind || command.kind !== "admit" && (prior.taskId !== command.taskId || prior.runId !== command.runId))) {
+    failDelegation("operation_conflict", "The operation identity has different retained input or ownership.");
+  }
+  if (prior && command.kind === "operation_receipt" && prior.disposition === command.disposition) {
+    if (prior.requestState !== command.requestState || prior.message !== command.message) {
+      failDelegation("operation_conflict", "The final receipt identity has different retained content.");
+    }
+    return { ...prior.receipt, duplicate: true };
+  }
+  if (prior && kind && !(command.kind === "dispatch_intent" && command.attempt === 2 && prior.attempts !== 2)) {
+    return { ...prior.receipt, duplicate: true };
+  }
+  if (command.kind === "cancel") {
+    const canonical = current.criticalOperations.find((operation) => operation.kind === "cancel");
+    if (canonical) failDelegation("operation_conflict", `Cancellation already uses operation ${canonical.operationId}; retry that exact identity.`);
+  }
+  const run = current.runs.find((entry) => entry.runId === command.runId);
+  if (command.kind === "settle" && run?.finalization) {
+    if (run.finalization.operationId !== command.operationId || run.finalization.inputDigest !== command.inputDigest) {
+      failDelegation("operation_conflict", "A final outcome already has its canonical settlement.");
+    }
+    return {
+      duplicate: true,
+      status: "settled",
+      taskId: command.taskId,
+      taskRevision: run.finalization.taskRevision,
+      runId: run.runId,
+      runRevision: run.finalization.runRevision,
+      operationId: command.operationId,
+      ...current.notification ? { notificationId: current.notification.envelope.notificationId } : {}
+    };
+  }
+  if (command.kind === "observe" && run && command.observation.index <= run.observationIndex) {
+    if (!(current.observation && same(current.observation, command.observation)) && !(command.observation.index === run.observationIndex && run.lastObservationDigest === delegationInputDigest(command.observation))) {
+      failDelegation("operation_conflict", "An observation index has different or unavailable retained input.");
+    }
+    return {
+      duplicate: true,
+      status: current.observation?.kind === "omitted" || !current.observation ? "omitted" : "recorded",
+      taskId: run.taskId,
+      taskRevision: current.task.revision,
+      runId: run.runId,
+      runRevision: run.revision
+    };
+  }
+  if (command.kind === "retire_recovery" && current.task?.retirement) {
+    if (current.task.retirement.operationId !== command.operationId || current.task.retirement.inputDigest !== command.inputDigest) {
+      failDelegation("operation_conflict", "Retirement already has a different canonical operation.");
+    }
+    return { duplicate: true, status: "retired", taskId: command.taskId, taskRevision: current.task.revision };
+  }
+  return void 0;
+}
+function planDelegationStoreCommit(input) {
+  const command = parseDelegationStoreCommand(input.command);
+  const { current } = input;
+  if (!current.owner || current.storeId !== command.owner.storeId || !same(current.owner, command.owner)) {
+    failDelegation("owner_lost", "The store owner fence is no longer current.");
+  }
+  parseDelegationLimits(current.limits);
+  const { capacity, limits } = current;
+  if (Object.values(capacity).some((count) => !Number.isSafeInteger(count) || count < 0) || capacity.tasks > limits.maxTasks || capacity.runs > limits.maxRuns || capacity.tasks > capacity.runs || capacity.activeRuns > limits.maxActiveRuns || capacity.queuedRuns > limits.maxQueuedRuns || capacity.activeRuns + capacity.queuedRuns > capacity.runs || capacity.retainedInputBytes > limits.maxRetainedInputBytes || capacity.observationBytes > limits.maxRetainedObservationBytes || capacity.ordinaryOperations > limits.maxOrdinaryOperations || capacity.reservedBytes !== capacity.runs * DELEGATION_RUN_RESERVATION_BYTES || capacity.criticalSlots !== capacity.runs * DELEGATION_CRITICAL_SLOTS) {
+    failDelegation("store_failed", "The store capacity counters or configured reservations are inconsistent.");
+  }
+  if (current.runs.length > current.limits.maxRunsPerTask || current.criticalOperations.length > 4 || current.runs.some((run2) => run2.taskId !== command.taskId) || current.task && current.task.taskId !== command.taskId) failDelegation("store_failed", "The command snapshot is inconsistent.");
+  const retry = duplicate(command, current);
+  if (retry) return freezeDelegationData({ mutations: [], receipt: retry });
+  if ((current.task?.revision ?? 0) !== command.expectedTaskRevision) failDelegation("stale_revision", "The task revision changed.");
+  const retainedRun = current.runs.find((run2) => run2.runId === command.runId);
+  if (command.kind !== "admit" && command.kind !== "retire_recovery" && (!retainedRun || retainedRun.revision !== command.expectedRunRevision)) failDelegation("stale_revision", "The run revision changed.");
+  if (!current.task && command.kind !== "admit") failDelegation("stale_revision", "The task is unavailable.");
+  const newTask = command.kind === "admit" ? {
+    storeId: current.storeId,
+    taskId: command.taskId,
+    parent: command.admission.parent,
+    ...command.admission.ancestorTaskId ? { ancestorTaskId: command.admission.ancestorTaskId } : {},
+    depth: command.admission.depth,
+    policyCeilingRef: command.admission.policyCeiling.ceilingId,
+    completionPolicy: command.admission.completionPolicy,
+    state: "active",
+    revision: 1,
+    latestRunId: command.admission.runId,
+    runCount: 0,
+    createdAt: command.admission.createdAt
+  } : void 0;
+  const task = current.task ? { ...current.task, revision: current.task.revision + 1 } : newTask;
+  const run = retainedRun ? { ...retainedRun, revision: retainedRun.revision + 1 } : void 0;
+  const context = {
+    command,
+    current,
+    task,
+    run,
+    capacity: { ...current.capacity },
+    mutations: [],
+    receipt: {
+      duplicate: false,
+      status: "recorded",
+      taskId: task.taskId,
+      taskRevision: task.revision,
+      ...run ? { runId: run.runId, runRevision: run.revision } : {},
+      operationId: command.operationId
+    }
+  };
+  switch (command.kind) {
+    case "admit":
+      admitRun(context, command);
+      break;
+    case "dispatch_intent":
+      dispatchIntent(context, command);
+      break;
+    case "operation_receipt":
+      operationReceipt(context, command);
+      break;
+    case "observe":
+      observeRun(context, command);
+      break;
+    case "request_state":
+      requestState(context, command);
+      break;
+    case "cancel":
+      cancelRun(context, command);
+      break;
+    case "settle":
+      settle(context, command);
+      break;
+    case "delivery_claim":
+    case "delivery_receipt":
+      delivery(context, command);
+      break;
+    case "retire_recovery":
+      retireRecovery(context, command);
+      break;
+  }
+  deriveTask(context);
+  context.mutations.push({ kind: "task", value: parseDelegationTaskRecord(context.task) });
+  if (context.run) context.mutations.push({ kind: "run", value: parseDelegationRunRecord(context.run) });
+  context.mutations.push({ kind: "capacity", value: context.capacity });
+  const mutations = context.mutations.map((mutation) => {
+    const finalized = mutation.kind === "operation" ? { ...mutation, value: { ...mutation.value, receipt: context.receipt } } : mutation;
+    return copyBoundedDelegationData(finalized);
+  });
+  return freezeDelegationData({ mutations, receipt: context.receipt });
+}
+export {
+  planDelegationStoreCommit
+};

package/dist/store-adapter/types.d.ts

@@ -0,0 +1,45 @@
+import type { DelegationLimits } from "../shared/limits.js";
+import type { DelegationCommitReceipt, DelegationOperationRecord, DelegationStoreCapacity } from "../store/types.js";
+import type { DelegationNotificationRecord, DelegationOwnerToken, DelegationPolicyCeiling, DelegationRunRecord, DelegationTaskObservation, DelegationTaskRecord } from "../tasks/types.js";
+export interface DelegationStoreCommitCurrent {
+    readonly storeId: string;
+    readonly owner?: DelegationOwnerToken;
+    readonly limits: DelegationLimits;
+    readonly capacity: DelegationStoreCapacity;
+    readonly task?: DelegationTaskRecord;
+    readonly runs: readonly DelegationRunRecord[];
+    readonly operation?: DelegationOperationRecord;
+    readonly criticalOperations: readonly DelegationOperationRecord[];
+    readonly notification?: DelegationNotificationRecord;
+    readonly ceiling?: DelegationPolicyCeiling;
+    readonly observation?: DelegationTaskObservation;
+    readonly omissionObservation?: DelegationTaskObservation;
+    readonly runIdExists?: boolean;
+}
+export type DelegationStoreRowMutation = Readonly<{
+    kind: "task";
+    value: DelegationTaskRecord;
+}> | Readonly<{
+    kind: "run";
+    value: DelegationRunRecord;
+}> | Readonly<{
+    kind: "operation";
+    value: DelegationOperationRecord;
+}> | Readonly<{
+    kind: "observation";
+    value: DelegationTaskObservation;
+}> | Readonly<{
+    kind: "notification";
+    value: DelegationNotificationRecord;
+}> | Readonly<{
+    kind: "ceiling";
+    value: DelegationPolicyCeiling;
+}> | Readonly<{
+    kind: "capacity";
+    value: DelegationStoreCapacity;
+}>;
+export interface DelegationStoreCommitPlan {
+    readonly mutations: readonly DelegationStoreRowMutation[];
+    readonly receipt: DelegationCommitReceipt;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/tasks/failure.d.ts

@@ -0,0 +1,4 @@
+import type { AgentError } from "@agen-ai/agent-protocol";
+import type { DelegationPublicFailure } from "./types.js";
+export declare function projectDelegationFailure(error?: AgentError): DelegationPublicFailure;
+//# sourceMappingURL=failure.d.ts.map

package/dist/tasks/failure.js

@@ -0,0 +1,24 @@
+import { delegationDataBytes } from "../shared/identity.js";
+import { DELEGATION_FAILURE_BYTES } from "../shared/limits.js";
+import { fitDelegationText } from "../shared/text.js";
+function projectDelegationFailure(error) {
+  if (!error) return {
+    category: "unknown",
+    code: "child_failed",
+    message: "The managed child reported an unsuccessful terminal outcome.",
+    recovery: { kind: "unknown" }
+  };
+  const hint = error.recovery;
+  const recovery = hint.kind === "retry" ? { kind: hint.kind, ...hint.notBefore === void 0 ? {} : { notBefore: hint.notBefore } } : hint.kind === "user_action" ? { kind: hint.kind, action: hint.action } : { kind: hint.kind };
+  const failure = { category: error.category, code: error.code, recovery };
+  if (recovery.kind === "retry" && delegationDataBytes({ ...failure, message: "" }) > DELEGATION_FAILURE_BYTES) {
+    failure.recovery = { kind: "retry" };
+  }
+  return { ...failure, message: fitDelegationText(
+    error.message,
+    (message) => delegationDataBytes({ ...failure, message }) <= DELEGATION_FAILURE_BYTES
+  ) };
+}
+export {
+  projectDelegationFailure
+};

package/dist/tasks/parse.d.ts

@@ -0,0 +1,18 @@
+import type { DelegationTargetReference } from "../catalog/types.js";
+import type { DelegationCompletionEnvelope, DelegationHistoricalRequest, DelegationNotificationRecord, DelegationOwnerToken, DelegationParentScope, DelegationPolicyCeiling, DelegationResultReference, DelegationRunOutcome, DelegationRunRecord, DelegationTaskObservation, DelegationTaskRecord } from "./types.js";
+export declare const parseDelegationParentScope: (input: unknown) => DelegationParentScope;
+export declare const parseDelegationOwnerToken: (input: unknown) => DelegationOwnerToken;
+export declare const parseDelegationTaskRecord: (input: unknown) => DelegationTaskRecord;
+export declare const parseDelegationRunRecord: (input: unknown) => DelegationRunRecord;
+export declare const parseDelegationRunOutcome: (input: unknown) => DelegationRunOutcome;
+export declare const parseDelegationResultReference: (input: unknown) => DelegationResultReference;
+export declare const parseDelegationTaskObservation: (input: unknown) => DelegationTaskObservation;
+export declare const parseDelegationHistoricalRequest: (input: unknown) => DelegationHistoricalRequest;
+export declare const parseDelegationCompletionEnvelope: (input: unknown) => DelegationCompletionEnvelope;
+export declare const parseDelegationNotificationRecord: (input: unknown) => DelegationNotificationRecord;
+export declare function parseDelegationPolicyCeiling(input: unknown): DelegationPolicyCeiling;
+export declare function createDelegationPolicyCeiling(input: {
+    readonly origin: DelegationParentScope;
+    readonly targets: readonly DelegationTargetReference[];
+}): DelegationPolicyCeiling;
+//# sourceMappingURL=parse.d.ts.map

package/dist/tasks/parse.js

@@ -0,0 +1,66 @@
+import { z } from "zod/v4";
+import { copyBoundedDelegationData } from "../shared/bounds.js";
+import { delegationSchemaError, invalidDelegationData } from "../shared/errors.js";
+import { delegationCanonicalJson, delegationInputDigest } from "../shared/identity.js";
+import { freezeDelegationData } from "../shared/immutable.js";
+import {
+  CompletionEnvelopeSchema,
+  HistoricalRequestSchema,
+  NotificationSchema,
+  ObservationSchema,
+  OwnerTokenSchema,
+  ParentScopeSchema,
+  PolicyCeilingSchema,
+  ResultReferenceSchema,
+  RunOutcomeSchema,
+  RunRecordSchema,
+  TargetReferenceSchema,
+  TaskRecordSchema
+} from "./schemas.js";
+function parse(schema, input) {
+  const captured = copyBoundedDelegationData(input);
+  const parsed = schema.safeParse(captured);
+  if (!parsed.success) return delegationSchemaError(parsed.error, captured);
+  return freezeDelegationData(parsed.data);
+}
+const parseDelegationParentScope = (input) => parse(ParentScopeSchema, input);
+const parseDelegationOwnerToken = (input) => parse(OwnerTokenSchema, input);
+const parseDelegationTaskRecord = (input) => parse(TaskRecordSchema, input);
+const parseDelegationRunRecord = (input) => parse(RunRecordSchema, input);
+const parseDelegationRunOutcome = (input) => parse(RunOutcomeSchema, input);
+const parseDelegationResultReference = (input) => parse(ResultReferenceSchema, input);
+const parseDelegationTaskObservation = (input) => parse(ObservationSchema, input);
+const parseDelegationHistoricalRequest = (input) => parse(HistoricalRequestSchema, input);
+const parseDelegationCompletionEnvelope = (input) => parse(CompletionEnvelopeSchema, input);
+const parseDelegationNotificationRecord = (input) => parse(NotificationSchema, input);
+function parseDelegationPolicyCeiling(input) {
+  const value = parse(PolicyCeilingSchema, input);
+  const keys = value.targets.map(delegationCanonicalJson);
+  if (new Set(keys).size !== keys.length || keys.some((key, index) => index > 0 && keys[index - 1] >= key) || value.ceilingId !== delegationInputDigest({ origin: value.origin, targets: value.targets })) {
+    return invalidDelegationData("invalid_ceiling", [], "Policy ceilings require sorted unique exact references and their canonical digest.");
+  }
+  return value;
+}
+function createDelegationPolicyCeiling(input) {
+  const captured = parse(z.strictObject({ origin: ParentScopeSchema, targets: z.array(TargetReferenceSchema).max(1e3) }), input);
+  const origin = captured.origin;
+  const targets = [...captured.targets].sort((left, right) => {
+    const a = delegationCanonicalJson(left), b = delegationCanonicalJson(right);
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+  return parseDelegationPolicyCeiling({ origin, targets, ceilingId: delegationInputDigest({ origin, targets }) });
+}
+export {
+  createDelegationPolicyCeiling,
+  parseDelegationCompletionEnvelope,
+  parseDelegationHistoricalRequest,
+  parseDelegationNotificationRecord,
+  parseDelegationOwnerToken,
+  parseDelegationParentScope,
+  parseDelegationPolicyCeiling,
+  parseDelegationResultReference,
+  parseDelegationRunOutcome,
+  parseDelegationRunRecord,
+  parseDelegationTaskObservation,
+  parseDelegationTaskRecord
+};

package/dist/tasks/schemas.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod/v4";
+import type { DelegationCompletionEnvelope, DelegationHistoricalRequest, DelegationNotificationRecord, DelegationOwnerToken, DelegationParentScope, DelegationPolicyCeiling, DelegationPublicFailure, DelegationRunOutcome, DelegationRunRecord, DelegationTaskObservation, DelegationTaskRecord } from "./types.js";
+export declare const StoreIdSchema: z.ZodUUID;
+export declare const OpaqueIdSchema: z.ZodString;
+export declare const DigestSchema: z.ZodString;
+export declare const AtSchema: z.ZodISODateTime;
+export declare const CountSchema: z.ZodNumber;
+export declare const CompletionPolicySchema: z.ZodEnum<{
+    collect: "collect";
+    next_turn: "next_turn";
+    automatic: "automatic";
+}>;
+export declare const RunPhaseSchema: z.ZodEnum<{
+    queued: "queued";
+    preparing: "preparing";
+    running: "running";
+    waiting: "waiting";
+    settled: "settled";
+}>;
+export declare const ParentScopeSchema: z.ZodType<DelegationParentScope>;
+export declare const OwnerTokenSchema: z.ZodType<DelegationOwnerToken>;
+export declare const TargetReferenceSchema: z.ZodObject<{
+    catalogId: z.ZodString;
+    catalogRevision: z.ZodNumber;
+    targetId: z.ZodString;
+    targetRevision: z.ZodNumber;
+    sourceId: z.ZodString;
+    sourceRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const PolicyCeilingSchema: z.ZodType<DelegationPolicyCeiling>;
+export declare const HistoricalRequestSchema: z.ZodType<DelegationHistoricalRequest>;
+export declare const ResultReferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        artifact: "artifact";
+        host_result: "host_result";
+    }>;
+    digest: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const PublicFailureSchema: z.ZodType<DelegationPublicFailure>;
+export declare const RunOutcomeSchema: z.ZodType<DelegationRunOutcome>;
+export declare const TaskRecordSchema: z.ZodType<DelegationTaskRecord>;
+export declare const RunRecordSchema: z.ZodType<DelegationRunRecord>;
+export declare const ObservationSchema: z.ZodType<DelegationTaskObservation>;
+export declare const CompletionEnvelopeSchema: z.ZodType<DelegationCompletionEnvelope>;
+export declare const NotificationSchema: z.ZodType<DelegationNotificationRecord>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/tasks/schemas.js

@@ -0,0 +1,215 @@
+import { AgentFailureCategorySchema, AgentRecoveryHintSchema, AgentTurnInputContentSchema } from "@agen-ai/agent-protocol/zod";
+import { z } from "zod/v4";
+import { delegationDataBytes } from "../shared/identity.js";
+import { DELEGATION_FAILURE_BYTES } from "../shared/limits.js";
+import { CanonicalIdSchema, RevisionSchema } from "../shared/schemas.js";
+const StoreIdSchema = z.uuid();
+const OpaqueIdSchema = CanonicalIdSchema.max(128).refine((value) => new TextEncoder().encode(value).byteLength <= 128);
+const DigestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const AtSchema = z.iso.datetime();
+const CountSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const CompletionPolicySchema = z.enum(["collect", "next_turn", "automatic"]);
+const RunPhaseSchema = z.enum(["queued", "preparing", "running", "waiting", "settled"]);
+const ParentScopeSchema = z.strictObject({
+  parentId: OpaqueIdSchema,
+  scopeId: OpaqueIdSchema,
+  revision: RevisionSchema
+});
+const OwnerTokenSchema = z.strictObject({
+  storeId: StoreIdSchema,
+  epoch: RevisionSchema,
+  nonce: StoreIdSchema
+});
+const TargetReferenceSchema = z.strictObject({
+  catalogId: CanonicalIdSchema,
+  catalogRevision: RevisionSchema,
+  targetId: CanonicalIdSchema,
+  targetRevision: RevisionSchema,
+  sourceId: CanonicalIdSchema,
+  sourceRevision: RevisionSchema
+});
+const PolicyCeilingSchema = z.strictObject({
+  ceilingId: DigestSchema,
+  origin: ParentScopeSchema,
+  targets: z.array(TargetReferenceSchema).max(1e3)
+});
+const HistoricalRequestSchema = z.strictObject({
+  requestId: CanonicalIdSchema,
+  requestKind: z.enum(["approval", "elicitation"]),
+  openedAt: AtSchema,
+  expiresAt: AtSchema.optional(),
+  state: z.enum(["waiting", "resolution_intended", "resolved", "unavailable"])
+});
+const ResultReferenceSchema = z.strictObject({ id: CanonicalIdSchema, kind: z.enum(["artifact", "host_result"]), digest: DigestSchema.optional() }).refine((value) => delegationDataBytes(value) <= 256, "Result reference exceeds 256 bytes.");
+const PublicFailureSchema = z.strictObject({
+  category: AgentFailureCategorySchema,
+  code: z.string().min(1).max(128).regex(/^(?:\S|\S[\s\S]*\S)$/u),
+  message: z.string().max(DELEGATION_FAILURE_BYTES),
+  recovery: AgentRecoveryHintSchema.refine(
+    (hint) => hint.kind !== "wait_for_quota" || hint.quota === void 0,
+    "Parent-visible recovery cannot contain child quota identity."
+  )
+}).refine((value) => delegationDataBytes(value) <= DELEGATION_FAILURE_BYTES, "Failure exceeds 2 KiB of canonical JSON.");
+const RunOutcomeSchema = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("succeeded"), result: z.strictObject({
+    text: z.string().max(8192).refine((value) => new TextEncoder().encode(value).byteLength <= 8192),
+    truncated: z.boolean(),
+    references: z.array(ResultReferenceSchema).max(8)
+  }).refine((value) => delegationDataBytes(value) <= 8192, "Result summary exceeds 8 KiB of canonical JSON.") }),
+  z.strictObject({ kind: z.literal("failed"), error: PublicFailureSchema }),
+  z.strictObject({ kind: z.literal("canceled"), confirmation: z.enum(["not_dispatched", "provider_terminal"]) }),
+  z.strictObject({ kind: z.literal("recovery_required"), reason: z.enum([
+    "executor_lost",
+    "dispatch_uncertain",
+    "request_executor_lost",
+    "steering_uncertain",
+    "cancellation_uncertain",
+    "storage_failed"
+  ]) })
+]);
+const TaskRecordSchema = z.strictObject({
+  storeId: StoreIdSchema,
+  taskId: StoreIdSchema,
+  parent: ParentScopeSchema,
+  ancestorTaskId: StoreIdSchema.optional(),
+  depth: RevisionSchema,
+  policyCeilingRef: DigestSchema,
+  completionPolicy: CompletionPolicySchema,
+  state: z.enum(["active", "settled", "recovery_required", "retired"]),
+  revision: RevisionSchema,
+  latestRunId: StoreIdSchema,
+  runCount: RevisionSchema,
+  createdAt: AtSchema,
+  retiredAt: AtSchema.optional(),
+  retirement: z.strictObject({ operationId: StoreIdSchema, inputDigest: DigestSchema, reason: z.string().max(1e3) }).optional()
+});
+const RunRecordSchema = z.strictObject({
+  taskId: StoreIdSchema,
+  runId: StoreIdSchema,
+  ordinal: RevisionSchema,
+  previousRunId: StoreIdSchema.optional(),
+  continuationMode: z.enum(["next_turn", "follow_up"]).optional(),
+  admissionOperationId: StoreIdSchema,
+  admittedTarget: TargetReferenceSchema,
+  appliedTarget: TargetReferenceSchema.optional(),
+  admittedPolicyRevision: RevisionSchema,
+  admittedOriginPolicyRevision: RevisionSchema,
+  input: AgentTurnInputContentSchema,
+  ownerEpoch: RevisionSchema,
+  phase: RunPhaseSchema,
+  revision: RevisionSchema,
+  createdAt: AtSchema,
+  deadlineAt: AtSchema,
+  queuedStartDeadlineAt: AtSchema,
+  dispatch: z.enum(["none", "intended", "delegated"]),
+  preparation: z.enum(["none", "intended", "completed", "uncertain"]),
+  cancelRequested: z.boolean(),
+  pendingRequest: HistoricalRequestSchema.optional(),
+  outcome: RunOutcomeSchema.optional(),
+  settledAt: AtSchema.optional(),
+  observationIndex: CountSchema,
+  observationCount: CountSchema,
+  observationBytes: CountSchema,
+  omittedObservations: CountSchema,
+  ordinaryOperationCount: CountSchema,
+  lastObservationDigest: DigestSchema.optional(),
+  recoveryReason: z.enum(["executor_lost", "dispatch_uncertain", "request_executor_lost", "steering_uncertain", "cancellation_uncertain", "storage_failed"]).optional(),
+  finalization: z.strictObject({
+    operationId: StoreIdSchema,
+    inputDigest: DigestSchema,
+    taskRevision: CountSchema,
+    runRevision: CountSchema
+  }).optional()
+}).superRefine((value, context) => {
+  if (value.previousRunId !== void 0 !== (value.continuationMode !== void 0)) {
+    context.addIssue({ code: "custom", path: ["continuationMode"], message: "A continuation mode requires exactly one previous run reference." });
+  }
+  if (value.phase === "settled" !== (value.outcome !== void 0) || value.phase === "settled" !== (value.settledAt !== void 0)) {
+    context.addIssue({ code: "custom", path: ["phase"], message: "A settled run requires exactly one final outcome and timestamp." });
+  }
+  if (delegationDataBytes(value) > 65536 || delegationDataBytes(value.input) > 24576 || value.input.parts.reduce((count, part) => count + (part.type === "text" ? part.text.length : 0), 0) > 16e3) {
+    context.addIssue({ code: "custom", path: ["input"], message: "Internal run records require a bounded complete row and admitted input." });
+  }
+});
+const ObservationSchema = z.strictObject({
+  storeId: StoreIdSchema,
+  taskId: StoreIdSchema,
+  runId: StoreIdSchema,
+  index: RevisionSchema,
+  at: AtSchema,
+  kind: z.enum(["state", "text", "request", "omitted"]),
+  phase: RunPhaseSchema.optional(),
+  text: z.string().max(8192).optional(),
+  request: HistoricalRequestSchema.optional(),
+  omitted: RevisionSchema.optional()
+}).refine((value) => delegationDataBytes(value) <= 8192, "Canonical observation exceeds 8 KiB.");
+const CompletionEnvelopeSchema = z.strictObject({
+  storeId: StoreIdSchema,
+  notificationId: StoreIdSchema,
+  taskId: StoreIdSchema,
+  runId: StoreIdSchema,
+  parent: ParentScopeSchema,
+  policy: CompletionPolicySchema,
+  settledAt: AtSchema,
+  expiresAt: AtSchema,
+  outcome: RunOutcomeSchema
+}).refine((value) => delegationDataBytes(value) <= 12288, "Completion envelope exceeds 12 KiB.");
+const deliveryCommit = z.strictObject({
+  operationId: StoreIdSchema,
+  inputDigest: DigestSchema,
+  commandDigest: DigestSchema,
+  attemptId: StoreIdSchema,
+  attempt: RevisionSchema,
+  ownerEpoch: RevisionSchema,
+  receipt: z.strictObject({
+    duplicate: z.boolean(),
+    status: z.enum(["queued", "preparing", "running", "waiting", "settled", "recorded", "omitted", "retired"]),
+    taskId: StoreIdSchema,
+    taskRevision: RevisionSchema,
+    runId: StoreIdSchema.optional(),
+    runRevision: RevisionSchema.optional(),
+    operationId: StoreIdSchema.optional(),
+    notificationId: StoreIdSchema.optional()
+  })
+}).refine((value) => delegationDataBytes(value) <= 2048, "Delivery bookkeeping exceeds its reserved slot.");
+const NotificationSchema = z.strictObject({
+  envelope: CompletionEnvelopeSchema,
+  revision: RevisionSchema,
+  state: z.enum(["collectible", "pending", "claimed", "accepted", "rejected", "expired", "dismissed"]),
+  claim: z.strictObject({ ownerEpoch: RevisionSchema, attemptId: StoreIdSchema }).optional(),
+  attempts: CountSchema,
+  retryAt: AtSchema.optional(),
+  inboxId: OpaqueIdSchema.optional(),
+  acceptedAt: AtSchema.optional(),
+  reason: z.string().max(1e3).optional(),
+  delivery: z.strictObject({ claim: deliveryCommit.optional(), receipt: deliveryCommit.optional() }).optional()
+}).superRefine((value, context) => {
+  if (value.state === "claimed" !== (value.claim !== void 0)) {
+    context.addIssue({ code: "custom", path: ["claim"], message: "Only a claimed notification retains an active owner claim." });
+  }
+  if (delegationDataBytes({ outcome: value.envelope.outcome, notification: value }) > 32768) {
+    context.addIssue({ code: "custom", path: [], message: "Notification and outcome exceed their final reservation." });
+  }
+});
+export {
+  AtSchema,
+  CompletionEnvelopeSchema,
+  CompletionPolicySchema,
+  CountSchema,
+  DigestSchema,
+  HistoricalRequestSchema,
+  NotificationSchema,
+  ObservationSchema,
+  OpaqueIdSchema,
+  OwnerTokenSchema,
+  ParentScopeSchema,
+  PolicyCeilingSchema,
+  PublicFailureSchema,
+  ResultReferenceSchema,
+  RunOutcomeSchema,
+  RunPhaseSchema,
+  RunRecordSchema,
+  StoreIdSchema,
+  TargetReferenceSchema,
+  TaskRecordSchema
+};