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

package/dist/store-adapter/admission.js

@@ -0,0 +1,90 @@
+import { failDelegation } from "../shared/operational-errors.js";
+import { delegationDataBytes } from "../shared/identity.js";
+import { DELEGATION_CRITICAL_SLOTS, DELEGATION_RUN_RESERVATION_BYTES } from "../shared/limits.js";
+import { addOperation, same } from "./context.js";
+function admitRun(context, command) {
+  const { admission } = command;
+  const { current } = context;
+  const { limits } = current;
+  if (current.runIdExists || current.runs.some((run) => run.runId === admission.runId)) {
+    failDelegation("operation_conflict", "The run identity is already retained.");
+  }
+  if (admission.depth > limits.maxDepth || delegationDataBytes(admission.input) > limits.maxInputBytes || admission.input.parts.reduce((count, part) => count + (part.type === "text" ? part.text.length : 0), 0) > limits.maxInputTextCharacters) {
+    failDelegation("capacity_exceeded", "The admitted depth or input exceeds its configured limit.");
+  }
+  if (!admission.policyCeiling.targets.some((target) => same(target, admission.target))) {
+    failDelegation("policy_denied", "The exact admitted target is outside the retained policy ceiling.");
+  }
+  if (Date.parse(admission.deadlineAt) <= Date.parse(admission.createdAt) || Date.parse(admission.queuedStartDeadlineAt) <= Date.parse(admission.createdAt) || Date.parse(admission.deadlineAt) - Date.parse(admission.createdAt) > limits.runTimeoutMs || Date.parse(admission.queuedStartDeadlineAt) - Date.parse(admission.createdAt) > limits.queuedStartTimeoutMs) {
+    failDelegation("capacity_exceeded", "Admission deadlines exceed their configured bounds.");
+  }
+  if (current.task) {
+    const previous = current.runs.find((run) => run.runId === admission.previousRunId);
+    if (!previous || command.runId !== previous.runId || command.expectedRunRevision !== previous.revision) {
+      failDelegation("stale_revision", "A continuation requires its exact previous run revision.");
+    }
+    if (admission.continuationMode === "next_turn" && (previous.phase !== "running" || previous.cancelRequested) || admission.continuationMode === "follow_up" && (previous.phase !== "settled" || previous.outcome?.kind === "recovery_required")) {
+      failDelegation("stale_revision", "The continuation mode does not match its previous run boundary.");
+    }
+    if (current.task.state === "retired" || current.task.state === "recovery_required" || !same(current.task.parent, admission.parent) || current.task.depth !== admission.depth || current.task.policyCeilingRef !== admission.policyCeiling.ceilingId || current.task.completionPolicy !== admission.completionPolicy || current.task.ancestorTaskId !== admission.ancestorTaskId || admission.previousRunId !== current.task.latestRunId || current.runs.some((run) => run.phase === "queued")) {
+      failDelegation("stale_revision", "A continuation must preserve its task and follow the latest safe run.");
+    }
+    if (current.runs.some((run) => run.phase === "waiting") || current.task.runCount >= limits.maxRunsPerTask) {
+      failDelegation("capacity_exceeded", "This task cannot admit another queued continuation.");
+    }
+  } else if (admission.previousRunId || command.expectedTaskRevision !== 0) {
+    failDelegation("stale_revision", "A new task cannot refer to an earlier run.");
+  }
+  const ceilingBytes = current.ceiling ? 0 : delegationDataBytes(admission.policyCeiling);
+  if (current.ceiling && !same(current.ceiling, admission.policyCeiling)) {
+    failDelegation("operation_conflict", "A retained ceiling digest has conflicting facts.");
+  }
+  const inputBytes = delegationDataBytes(admission.input) + ceilingBytes;
+  if (!current.task && context.capacity.tasks >= limits.maxTasks || context.capacity.runs >= limits.maxRuns || context.capacity.queuedRuns >= limits.maxQueuedRuns || context.capacity.retainedInputBytes + inputBytes > limits.maxRetainedInputBytes) {
+    failDelegation("capacity_exceeded", "The retained admission or queue capacity is full.");
+  }
+  context.capacity = {
+    ...context.capacity,
+    tasks: context.capacity.tasks + (current.task ? 0 : 1),
+    runs: context.capacity.runs + 1,
+    queuedRuns: context.capacity.queuedRuns + 1,
+    retainedInputBytes: context.capacity.retainedInputBytes + inputBytes,
+    reservedBytes: context.capacity.reservedBytes + DELEGATION_RUN_RESERVATION_BYTES,
+    criticalSlots: context.capacity.criticalSlots + DELEGATION_CRITICAL_SLOTS
+  };
+  context.task = { ...context.task, latestRunId: admission.runId, runCount: (current.task?.runCount ?? 0) + 1 };
+  context.run = {
+    taskId: command.taskId,
+    runId: admission.runId,
+    ordinal: context.task.runCount,
+    ...admission.previousRunId && admission.continuationMode ? {
+      previousRunId: admission.previousRunId,
+      continuationMode: admission.continuationMode
+    } : {},
+    admissionOperationId: command.operationId,
+    admittedTarget: admission.target,
+    admittedPolicyRevision: admission.policyRevision,
+    admittedOriginPolicyRevision: admission.originPolicyRevision,
+    input: admission.input,
+    ownerEpoch: command.owner.epoch,
+    phase: "queued",
+    revision: 1,
+    createdAt: admission.createdAt,
+    deadlineAt: admission.deadlineAt,
+    queuedStartDeadlineAt: admission.queuedStartDeadlineAt,
+    dispatch: "none",
+    preparation: "none",
+    cancelRequested: false,
+    observationIndex: 0,
+    observationCount: 0,
+    observationBytes: 0,
+    omittedObservations: 0,
+    ordinaryOperationCount: 0
+  };
+  context.receipt = { ...context.receipt, status: "queued", runId: admission.runId, runRevision: 1, operationId: command.operationId };
+  addOperation(context, "admit", admission.createdAt);
+  if (!current.ceiling) context.mutations.push({ kind: "ceiling", value: admission.policyCeiling });
+}
+export {
+  admitRun
+};

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

@@ -0,0 +1,20 @@
+import type { DelegationNotificationRecord, DelegationRunOutcome, DelegationRunRecord, DelegationTaskRecord } from "../tasks/types.js";
+import type { DelegationCommitReceipt, DelegationOperationKind, DelegationOperationRecord, DelegationStoreCapacity, DelegationStoreCommand } from "../store/types.js";
+import type { DelegationStoreCommitCurrent, DelegationStoreRowMutation } from "./types.js";
+export declare const criticalKinds: ReadonlySet<DelegationOperationKind>;
+export interface CommitContext {
+    command: DelegationStoreCommand;
+    current: DelegationStoreCommitCurrent;
+    task: DelegationTaskRecord;
+    run?: DelegationRunRecord;
+    capacity: DelegationStoreCapacity;
+    mutations: DelegationStoreRowMutation[];
+    receipt: DelegationCommitReceipt;
+}
+export declare function same(left: unknown, right: unknown): boolean;
+export declare function requireRun(context: CommitContext): DelegationRunRecord;
+export declare function setRun(context: CommitContext, change: Partial<DelegationRunRecord>): void;
+export declare function addOperation(context: CommitContext, kind: DelegationOperationKind, at: string, attempt?: number, request?: DelegationOperationRecord["request"]): void;
+export declare function settleRun(context: CommitContext, requested: DelegationRunOutcome, at: string): DelegationNotificationRecord;
+export declare function deriveTask(context: CommitContext): void;
+//# sourceMappingURL=context.d.ts.map

package/dist/store-adapter/context.js

@@ -0,0 +1,107 @@
+import { failDelegation } from "../shared/operational-errors.js";
+import { delegationCanonicalJson, delegationDataBytes, delegationSubordinateId } from "../shared/identity.js";
+import { DELEGATION_CRITICAL_SLOT_BYTES, DELEGATION_FINAL_RESERVATION_BYTES } from "../shared/limits.js";
+import { parseDelegationCompletionEnvelope } from "../tasks/parse.js";
+const criticalKinds = /* @__PURE__ */ new Set(["cancel", "interrupt", "session_close", "binding_cleanup"]);
+function same(left, right) {
+  return delegationCanonicalJson(left) === delegationCanonicalJson(right);
+}
+function requireRun(context) {
+  if (!context.run) return failDelegation("stale_revision", "The exact task run is unavailable.");
+  return context.run;
+}
+function setRun(context, change) {
+  const prior = requireRun(context);
+  const run = { ...prior, ...change };
+  if (prior.phase === "queued" && run.phase !== "queued") context.capacity = {
+    ...context.capacity,
+    queuedRuns: context.capacity.queuedRuns - 1,
+    activeRuns: context.capacity.activeRuns + (run.phase === "settled" ? 0 : 1)
+  };
+  if (prior.phase !== "queued" && prior.phase !== "settled" && run.phase === "settled") {
+    context.capacity = { ...context.capacity, activeRuns: context.capacity.activeRuns - 1 };
+  }
+  context.run = run;
+}
+function addOperation(context, kind, at, attempt = 1, request) {
+  const run = requireRun(context);
+  if (!criticalKinds.has(kind)) {
+    if (run.ordinaryOperationCount >= context.current.limits.maxOrdinaryOperationsPerRun || context.capacity.ordinaryOperations >= context.current.limits.maxOrdinaryOperations) {
+      failDelegation("capacity_exceeded", "The ordinary operation ledger is full.");
+    }
+    setRun(context, { ordinaryOperationCount: run.ordinaryOperationCount + 1 });
+    context.capacity = { ...context.capacity, ordinaryOperations: context.capacity.ordinaryOperations + 1 };
+  }
+  const operation = {
+    operationId: context.command.operationId,
+    parent: context.task.parent,
+    taskId: context.task.taskId,
+    runId: run.runId,
+    kind,
+    inputDigest: context.command.inputDigest,
+    ownerEpoch: context.command.owner.epoch,
+    disposition: kind === "admit" || kind === "cancel" ? "completed" : "intent",
+    attempts: attempt,
+    at,
+    ...request ? { request } : {},
+    receipt: { ...context.receipt, operationId: context.command.operationId }
+  };
+  if (delegationDataBytes(operation) > DELEGATION_CRITICAL_SLOT_BYTES) failDelegation("capacity_exceeded", "Operation exceeds its fixed ledger slot.");
+  context.mutations.push({ kind: "operation", value: operation });
+}
+function settleRun(context, requested, at) {
+  const run = requireRun(context);
+  if (run.outcome) failDelegation("operation_conflict", "A settled run outcome is immutable.");
+  const outcome = run.recoveryReason ? { kind: "recovery_required", reason: run.recoveryReason } : requested;
+  const notificationId = delegationSubordinateId(run.runId, "notification");
+  const envelope = parseDelegationCompletionEnvelope({
+    storeId: context.current.storeId,
+    notificationId,
+    taskId: run.taskId,
+    runId: run.runId,
+    parent: context.task.parent,
+    policy: context.task.completionPolicy,
+    settledAt: at,
+    expiresAt: new Date(Date.parse(at) + context.current.limits.notificationTtlMs).toISOString(),
+    outcome
+  });
+  const notification = {
+    envelope,
+    revision: 1,
+    state: context.task.completionPolicy === "collect" ? "collectible" : "pending",
+    attempts: 0
+  };
+  if (delegationDataBytes({ outcome, notification }) > DELEGATION_FINAL_RESERVATION_BYTES) {
+    failDelegation("capacity_exceeded", "Settlement exceeds its reserved final slot.");
+  }
+  setRun(context, {
+    phase: "settled",
+    outcome,
+    settledAt: at,
+    ...run.pendingRequest ? { pendingRequest: { ...run.pendingRequest, state: "unavailable" } } : {},
+    finalization: {
+      operationId: context.command.operationId,
+      inputDigest: context.command.inputDigest,
+      taskRevision: context.task.revision,
+      runRevision: run.revision
+    }
+  });
+  context.receipt = { ...context.receipt, status: "settled", notificationId };
+  context.mutations.push({ kind: "notification", value: notification });
+  return notification;
+}
+function deriveTask(context) {
+  const runs = context.current.runs.map((run) => run.runId === context.run?.runId ? context.run : run);
+  if (context.run && !runs.some((run) => run.runId === context.run?.runId)) runs.push(context.run);
+  const state = context.task.state === "retired" ? "retired" : runs.some((run) => run.outcome?.kind === "recovery_required" || run.recoveryReason) ? "recovery_required" : runs.some((run) => run.phase !== "settled") ? "active" : "settled";
+  context.task = { ...context.task, state };
+}
+export {
+  addOperation,
+  criticalKinds,
+  deriveTask,
+  requireRun,
+  same,
+  setRun,
+  settleRun
+};

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

@@ -0,0 +1,15 @@
+import type { DelegationCommitReceipt, DelegationStoreCommand } from "../store/types.js";
+import type { DelegationStoreCommitCurrent } from "./types.js";
+import type { CommitContext } from "./context.js";
+type DeliveryCommand = Extract<DelegationStoreCommand, {
+    kind: "delivery_claim" | "delivery_receipt";
+}>;
+export declare function deliveryAttemptIdentity(notificationId: string, attempt: number): {
+    attemptId: string;
+    claimOperationId: string;
+    receiptOperationId: string;
+};
+export declare function duplicateDelivery(command: DeliveryCommand, current: DelegationStoreCommitCurrent): DelegationCommitReceipt | undefined;
+export declare function delivery(context: CommitContext, command: DeliveryCommand): void;
+export {};
+//# sourceMappingURL=delivery.d.ts.map

package/dist/store-adapter/delivery.js

@@ -0,0 +1,81 @@
+import { delegationInputDigest, delegationSubordinateId } from "../shared/identity.js";
+import { failDelegation } from "../shared/operational-errors.js";
+import { parseDelegationNotificationRecord } from "../tasks/parse.js";
+function deliveryAttemptIdentity(notificationId, attempt) {
+  const attemptId = delegationSubordinateId(notificationId, `delivery-attempt:${attempt}`);
+  return { attemptId, claimOperationId: delegationSubordinateId(attemptId, "claim"), receiptOperationId: delegationSubordinateId(attemptId, "receipt") };
+}
+function duplicateDelivery(command, current) {
+  const notification = current.notification;
+  if (!notification || notification.envelope.notificationId !== command.notificationId || notification.envelope.taskId !== command.taskId || notification.envelope.runId !== command.runId) {
+    failDelegation("stale_revision", "The exact notification is unavailable.");
+  }
+  const kind = command.kind === "delivery_claim" ? "claim" : "receipt";
+  const retained = notification.delivery?.[kind];
+  const other = notification.delivery?.[kind === "claim" ? "receipt" : "claim"];
+  if (other?.operationId === command.operationId) failDelegation("operation_conflict", "Delivery operation identity belongs to the other bookkeeping slot.");
+  if (retained?.operationId === command.operationId) {
+    if (retained.ownerEpoch !== command.owner.epoch) failDelegation("stale_revision", "The retained delivery command belongs to a previous owner.");
+    if (retained.attemptId !== command.attemptId || retained.inputDigest !== command.inputDigest || retained.commandDigest !== delegationInputDigest(command)) failDelegation("operation_conflict", "The current delivery identity has different committed input.");
+    return { ...retained.receipt, duplicate: true };
+  }
+  const attempt = notification.attempts + (kind === "claim" ? 1 : 0);
+  if (!Number.isSafeInteger(attempt) || attempt < 1) failDelegation("capacity_exceeded", "Delivery attempt ordinal is exhausted.");
+  const identity = deliveryAttemptIdentity(command.notificationId, attempt);
+  if (command.attemptId !== identity.attemptId || command.operationId !== (kind === "claim" ? identity.claimOperationId : identity.receiptOperationId)) {
+    failDelegation("stale_revision", "The delivery attempt has been superseded or is not the next canonical attempt.");
+  }
+  return void 0;
+}
+function delivery(context, command) {
+  const prior = context.current.notification;
+  if (prior.revision !== command.expectedNotificationRevision || prior.envelope.policy === "collect") {
+    failDelegation("stale_revision", "The exact eligible notification revision is unavailable.");
+  }
+  context.receipt = { ...context.receipt, notificationId: command.notificationId };
+  const kind = command.kind === "delivery_claim" ? "claim" : "receipt";
+  const attempt = prior.attempts + (kind === "claim" ? 1 : 0);
+  const bookkeeping = {
+    operationId: command.operationId,
+    inputDigest: command.inputDigest,
+    commandDigest: delegationInputDigest(command),
+    attemptId: command.attemptId,
+    attempt,
+    ownerEpoch: command.owner.epoch,
+    receipt: context.receipt
+  };
+  const retained = { ...prior, revision: prior.revision + 1, delivery: { ...prior.delivery, [kind]: bookkeeping } };
+  let notification;
+  if (command.kind === "delivery_claim") {
+    if (prior.state !== "pending") failDelegation("stale_revision", "Only a pending notification can begin a new delivery attempt.");
+    if (Date.parse(prior.envelope.expiresAt) <= Date.parse(command.at) && prior.reason !== "uncertain") {
+      const { retryAt: _retryAt, reason: _reason, ...expired } = retained;
+      notification = { ...expired, attempts: attempt, state: "expired", reason: "expired" };
+    } else {
+      if (prior.retryAt && Date.parse(prior.retryAt) > Date.parse(command.at)) failDelegation("stale_revision", "The notification retry is not yet eligible.");
+      notification = { ...retained, attempts: attempt, state: "claimed", claim: { ownerEpoch: command.owner.epoch, attemptId: command.attemptId } };
+    }
+  } else {
+    if (prior.state !== "claimed" || prior.claim?.attemptId !== command.attemptId || prior.claim.ownerEpoch !== command.owner.epoch && command.result.status !== "uncertain") {
+      failDelegation("stale_revision", "The receipt does not match this owner or the exact lost-owner claim.");
+    }
+    const { claim: _claim, retryAt: _retryAt, reason: _reason, inboxId: _inboxId, acceptedAt: _acceptedAt, ...withoutClaim } = retained;
+    const result = command.result;
+    if (result.status === "blocked" || result.status === "uncertain") {
+      const delay = Date.parse(result.retryAt) - Date.parse(command.at);
+      if (delay < 1e3 || delay > 3e4) failDelegation("capacity_exceeded", "Delivery retry must be between one and thirty seconds.");
+    }
+    const change = result.status === "accepted" ? { state: "accepted", inboxId: result.inboxId, acceptedAt: result.acceptedAt } : result.status === "blocked" || result.status === "uncertain" ? {
+      state: "pending",
+      retryAt: result.retryAt,
+      reason: result.status === "blocked" ? result.reason : "uncertain"
+    } : { state: result.status, reason: result.reason };
+    notification = { ...withoutClaim, ...change };
+  }
+  context.mutations.push({ kind: "notification", value: parseDelegationNotificationRecord(notification) });
+}
+export {
+  delivery,
+  deliveryAttemptIdentity,
+  duplicateDelivery
+};

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

@@ -0,0 +1,12 @@
+import type { DelegationStoreCommand } from "../store/types.js";
+import { type CommitContext } from "./context.js";
+export declare function dispatchIntent(context: CommitContext, command: Extract<DelegationStoreCommand, {
+    kind: "dispatch_intent";
+}>): void;
+export declare function operationReceipt(context: CommitContext, command: Extract<DelegationStoreCommand, {
+    kind: "operation_receipt";
+}>): void;
+export declare function requestState(context: CommitContext, command: Extract<DelegationStoreCommand, {
+    kind: "request_state";
+}>): void;
+//# sourceMappingURL=execution.d.ts.map

package/dist/store-adapter/execution.js

@@ -0,0 +1,151 @@
+import { failDelegation } from "../shared/operational-errors.js";
+import { delegationDataBytes } from "../shared/identity.js";
+import { DELEGATION_CRITICAL_SLOT_BYTES } from "../shared/limits.js";
+import { addOperation, criticalKinds, requireRun, same, setRun } from "./context.js";
+const receiptDispositions = {
+  admit: [],
+  cancel: [],
+  prepare: ["completed", "rejected", "uncertain"],
+  configure: ["completed", "rejected", "uncertain"],
+  turn: ["delegated", "rejected", "uncertain"],
+  steer: ["delivered", "rejected", "uncertain"],
+  request_resolution: ["delivered", "rejected", "uncertain"],
+  interrupt: ["interruption_requested", "completed", "rejected", "uncertain"],
+  session_close: ["completed", "rejected", "uncertain"],
+  binding_cleanup: ["completed", "rejected", "uncertain"]
+};
+function dispatchIntent(context, command) {
+  const run = requireRun(context);
+  const kind = command.operationKind;
+  if (run.ownerEpoch !== command.owner.epoch && kind !== "prepare") {
+    failDelegation("recovery_required", "A new executor cannot replay any old provider or cleanup intent.");
+  }
+  const prior = context.current.criticalOperations.find((operation) => operation.kind === kind);
+  if (prior) {
+    if (kind !== "session_close" && kind !== "binding_cleanup" || command.attempt !== 2 || prior.attempts !== 1 || !["rejected", "uncertain"].includes(prior.disposition) || prior.operationId !== command.operationId || prior.inputDigest !== command.inputDigest) {
+      failDelegation("operation_conflict", "The reserved control slot is already assigned.");
+    }
+    context.mutations.push({ kind: "operation", value: {
+      ...prior,
+      attempts: 2,
+      disposition: "intent",
+      at: command.at,
+      ownerEpoch: command.owner.epoch,
+      receipt: context.receipt
+    } });
+    return;
+  }
+  if ((command.attempt ?? 1) !== 1) failDelegation("stale_revision", "A cleanup retry requires its retained first attempt.");
+  if (kind === "binding_cleanup" && !context.current.criticalOperations.some((operation) => operation.kind === "session_close")) {
+    failDelegation("stale_revision", "Combined cleanup must journal session close before binding cleanup.");
+  }
+  if (!criticalKinds.has(kind) && (context.task.state === "retired" || context.task.state === "recovery_required" || run.cancelRequested)) {
+    failDelegation("recovery_required", "This run no longer admits provider execution inputs.");
+  }
+  if (kind === "prepare") {
+    if (run.phase !== "queued" || run.dispatch !== "none") failDelegation("stale_revision", "Only an undispatched queued run can prepare.");
+    if (context.current.runs.some((other) => other.runId !== run.runId && ["preparing", "running", "waiting"].includes(other.phase)) || context.capacity.activeRuns >= context.current.limits.maxActiveRuns) failDelegation("capacity_exceeded", "No active executor slot is available.");
+    setRun(context, { phase: "preparing", preparation: "intended", ownerEpoch: command.owner.epoch });
+  } else if (kind === "turn") {
+    if (run.phase !== "preparing" || run.preparation !== "completed" || run.dispatch !== "none" || !command.appliedTarget || !same(command.appliedTarget, run.admittedTarget)) {
+      failDelegation("stale_target", "A first turn requires preparation and the exact applied target.");
+    }
+    setRun(context, { phase: "running", dispatch: "intended", appliedTarget: command.appliedTarget });
+  } else if (kind === "configure" && run.phase !== "preparing") {
+    failDelegation("stale_revision", "Configuration belongs to session preparation.");
+  } else if (kind === "steer" && run.phase !== "running") {
+    failDelegation("stale_revision", "Steering requires the active running turn.");
+  } else if (kind === "request_resolution") {
+    failDelegation("request_unavailable", "Request continuation must commit its exact historical request intent.");
+  } else if (kind === "interrupt" && (run.phase === "queued" || run.phase === "settled" || !run.cancelRequested)) {
+    failDelegation("stale_revision", "Interruption requires a live canceled run.");
+  }
+  addOperation(context, kind, command.at);
+  context.receipt = { ...context.receipt, status: requireRun(context).phase };
+}
+function operationReceipt(context, command) {
+  const prior = context.current.operation;
+  if (!prior || prior.runId !== command.runId || prior.inputDigest !== command.inputDigest) {
+    failDelegation("operation_conflict", "The exact provider intent is unavailable.");
+  }
+  if (!receiptDispositions[prior.kind].includes(command.disposition)) {
+    failDelegation("operation_conflict", "The receipt disposition is invalid for this operation kind.");
+  }
+  const rejectedRequest = prior.kind === "request_resolution" && command.disposition === "rejected";
+  if (rejectedRequest !== (command.requestState !== void 0)) {
+    failDelegation("operation_conflict", "Only a rejected request receipt requires authoritative request eligibility.");
+  }
+  if (["delivered", "rejected", "completed"].includes(prior.disposition) || prior.kind === "request_resolution" && prior.disposition === "uncertain") {
+    failDelegation("operation_conflict", "A final operation disposition is immutable.");
+  }
+  if (prior.ownerEpoch !== command.owner.epoch) failDelegation("recovery_required", "A new owner cannot invent a prior executor receipt.");
+  if (prior.kind === "binding_cleanup" && command.disposition === "completed" && !context.current.criticalOperations.some((operation2) => operation2.kind === "session_close" && operation2.disposition === "completed")) {
+    failDelegation("stale_revision", "Binding cleanup cannot complete before confirmed session close.");
+  }
+  const operation = {
+    ...prior,
+    disposition: command.disposition,
+    at: command.at,
+    ...command.requestState ? { requestState: command.requestState } : {},
+    ...command.message ? { message: command.message } : {},
+    receipt: { ...context.receipt, operationId: command.operationId }
+  };
+  if (delegationDataBytes(operation) > DELEGATION_CRITICAL_SLOT_BYTES) failDelegation("capacity_exceeded", "Operation receipt exceeds its fixed slot.");
+  context.mutations.push({ kind: "operation", value: operation });
+  if (prior.kind === "request_resolution") {
+    const run = requireRun(context);
+    if (!prior.request) failDelegation("operation_conflict", "Request delivery requires its exact retained request identity.");
+    if (run.pendingRequest?.requestId === prior.request.requestId && run.pendingRequest.requestKind === prior.request.requestKind) {
+      if (run.pendingRequest.state !== "resolution_intended") failDelegation("request_unavailable", "The exact request has no entered resolution intent.");
+      const state = command.disposition === "delivered" ? "resolved" : command.requestState === "pending" ? "waiting" : "unavailable";
+      setRun(context, {
+        phase: run.phase === "settled" ? "settled" : state === "waiting" ? "waiting" : "running",
+        pendingRequest: { ...run.pendingRequest, state }
+      });
+    }
+    context.receipt = { ...context.receipt, status: requireRun(context).phase };
+  }
+  if (prior.kind === "turn" && command.disposition === "delegated") setRun(context, { dispatch: "delegated" });
+  if (prior.kind === "prepare") {
+    if (command.disposition === "completed") setRun(context, { preparation: "completed" });
+    if (command.disposition === "uncertain") setRun(context, { preparation: "uncertain" });
+    if (command.disposition === "rejected") setRun(context, { preparation: "none" });
+  }
+  if (command.disposition === "uncertain" && prior.kind === "steer") setRun(context, { recoveryReason: "steering_uncertain" });
+  if (command.disposition === "uncertain" && (prior.kind === "configure" || prior.kind === "request_resolution")) {
+    setRun(context, { recoveryReason: prior.kind === "request_resolution" ? "request_executor_lost" : "dispatch_uncertain" });
+  }
+}
+function requestState(context, command) {
+  const run = requireRun(context);
+  if (command.state === "opened") {
+    if (run.phase !== "running" || command.request.state !== "waiting" || run.ownerEpoch !== command.owner.epoch) {
+      failDelegation("request_unavailable", "Only the current active executor stream can open a waiting request.");
+    }
+    setRun(context, { phase: "waiting", pendingRequest: command.request });
+  } else {
+    if (!run.pendingRequest || run.pendingRequest.requestId !== command.request.requestId || run.pendingRequest.requestKind !== command.request.requestKind) failDelegation("request_unavailable", "The exact historical request is unavailable.");
+    if (command.state === "resolution_intended") {
+      if (run.phase !== "waiting" || run.pendingRequest.state !== "waiting" || run.ownerEpoch !== command.owner.epoch || run.cancelRequested || run.pendingRequest.expiresAt && Date.parse(run.pendingRequest.expiresAt) <= Date.parse(command.at)) {
+        failDelegation("request_unavailable", "This request cannot accept a continuation intent.");
+      }
+      addOperation(
+        context,
+        "request_resolution",
+        command.at,
+        1,
+        { requestId: run.pendingRequest.requestId, requestKind: run.pendingRequest.requestKind }
+      );
+      setRun(context, { phase: "running", pendingRequest: { ...run.pendingRequest, state: "resolution_intended" } });
+    } else {
+      if (command.state === "resolved" && run.pendingRequest.state !== "resolution_intended") failDelegation("request_unavailable", "Resolution requires its prior intent.");
+      setRun(context, { pendingRequest: { ...run.pendingRequest, state: command.state } });
+    }
+  }
+  context.receipt = { ...context.receipt, status: requireRun(context).phase };
+}
+export {
+  dispatchIntent,
+  operationReceipt,
+  requestState
+};

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

@@ -0,0 +1,7 @@
+export { planDelegationStoreCommit } from "./plan.js";
+export type { DelegationStoreCommitCurrent, DelegationStoreCommitPlan, DelegationStoreRowMutation, } from "./types.js";
+export { delegationCanonicalJson, delegationDataBytes, delegationInputDigest, delegationSubordinateId } from "../shared/identity.js";
+export { parseDelegationStoreCommand, parseDelegationStoreReadInput, parseDelegationStoreScanInput } from "../store/parse.js";
+export { delegationCursorPrefix, parseDelegationPageCursor, summarizeDelegationRun } from "../store/pages.js";
+export { DELEGATION_CRITICAL_SLOT_BYTES, DELEGATION_CRITICAL_SLOTS, DELEGATION_FINAL_RESERVATION_BYTES, DELEGATION_RUN_RESERVATION_BYTES, } from "../shared/limits.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/store-adapter/index.js

@@ -0,0 +1,27 @@
+import { planDelegationStoreCommit } from "./plan.js";
+import { delegationCanonicalJson, delegationDataBytes, delegationInputDigest, delegationSubordinateId } from "../shared/identity.js";
+import { parseDelegationStoreCommand, parseDelegationStoreReadInput, parseDelegationStoreScanInput } from "../store/parse.js";
+import { delegationCursorPrefix, parseDelegationPageCursor, summarizeDelegationRun } from "../store/pages.js";
+import {
+  DELEGATION_CRITICAL_SLOT_BYTES,
+  DELEGATION_CRITICAL_SLOTS,
+  DELEGATION_FINAL_RESERVATION_BYTES,
+  DELEGATION_RUN_RESERVATION_BYTES
+} from "../shared/limits.js";
+export {
+  DELEGATION_CRITICAL_SLOTS,
+  DELEGATION_CRITICAL_SLOT_BYTES,
+  DELEGATION_FINAL_RESERVATION_BYTES,
+  DELEGATION_RUN_RESERVATION_BYTES,
+  delegationCanonicalJson,
+  delegationCursorPrefix,
+  delegationDataBytes,
+  delegationInputDigest,
+  delegationSubordinateId,
+  parseDelegationPageCursor,
+  parseDelegationStoreCommand,
+  parseDelegationStoreReadInput,
+  parseDelegationStoreScanInput,
+  planDelegationStoreCommit,
+  summarizeDelegationRun
+};

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

@@ -0,0 +1,15 @@
+import type { DelegationStoreCommand } from "../store/types.js";
+import { type CommitContext } from "./context.js";
+export declare function observeRun(context: CommitContext, command: Extract<DelegationStoreCommand, {
+    kind: "observe";
+}>): void;
+export declare function cancelRun(context: CommitContext, command: Extract<DelegationStoreCommand, {
+    kind: "cancel";
+}>): void;
+export declare function settle(context: CommitContext, command: Extract<DelegationStoreCommand, {
+    kind: "settle";
+}>): void;
+export declare function retireRecovery(context: CommitContext, command: Extract<DelegationStoreCommand, {
+    kind: "retire_recovery";
+}>): void;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/store-adapter/lifecycle.js

@@ -0,0 +1,80 @@
+import { failDelegation } from "../shared/operational-errors.js";
+import { delegationDataBytes, delegationInputDigest } from "../shared/identity.js";
+import { addOperation, requireRun, setRun, settleRun } from "./context.js";
+function observeRun(context, command) {
+  const run = requireRun(context);
+  const observation = command.observation;
+  if (run.phase === "queued" || run.phase === "settled" || run.ownerEpoch !== command.owner.epoch || observation.storeId !== context.current.storeId || observation.taskId !== run.taskId || observation.runId !== run.runId || observation.index !== run.observationIndex + 1 || observation.kind === "omitted") failDelegation("stale_revision", "Observation does not follow the live run's canonical index.");
+  const bytes = delegationDataBytes(observation);
+  const limits = context.current.limits;
+  const digest = delegationInputDigest(observation);
+  if (bytes > limits.maxObservationBytes || run.observationCount >= limits.maxRunObservations || run.observationBytes + bytes > limits.maxRunObservationBytes || context.capacity.observationBytes + bytes > limits.maxRetainedObservationBytes) {
+    const omitted = run.omittedObservations + 1;
+    const marker = context.current.omissionObservation;
+    context.mutations.push({ kind: "observation", value: marker ? { ...marker, omitted } : {
+      storeId: context.current.storeId,
+      taskId: run.taskId,
+      runId: run.runId,
+      index: observation.index,
+      at: observation.at,
+      kind: "omitted",
+      omitted
+    } });
+    setRun(context, { observationIndex: observation.index, omittedObservations: omitted, lastObservationDigest: digest });
+    context.receipt = { ...context.receipt, status: "omitted" };
+  } else {
+    context.mutations.push({ kind: "observation", value: observation });
+    setRun(context, {
+      observationIndex: observation.index,
+      observationCount: run.observationCount + 1,
+      observationBytes: run.observationBytes + bytes,
+      lastObservationDigest: digest
+    });
+    context.capacity = { ...context.capacity, observationBytes: context.capacity.observationBytes + bytes };
+  }
+}
+function cancelRun(context, command) {
+  const run = requireRun(context);
+  if (run.phase === "settled") {
+    context.receipt = { ...context.receipt, status: "settled" };
+    addOperation(context, "cancel", command.at);
+    return;
+  }
+  setRun(context, { cancelRequested: true });
+  if (run.phase === "queued" && run.preparation === "none" && run.dispatch === "none") {
+    settleRun(context, { kind: "canceled", confirmation: "not_dispatched" }, command.at);
+  }
+  addOperation(context, "cancel", command.at);
+}
+function settle(context, command) {
+  const run = requireRun(context);
+  if ((command.outcome.kind === "succeeded" || command.outcome.kind === "canceled" && command.outcome.confirmation === "provider_terminal") && run.phase !== "running" && run.phase !== "waiting") {
+    failDelegation("stale_revision", "Provider terminal truth requires a previously running turn.");
+  }
+  if (command.outcome.kind === "failed" && (run.preparation === "intended" || run.preparation === "uncertain") && run.phase === "preparing") failDelegation("recovery_required", "An unresolved preparation intent has no definitive failure receipt.");
+  if (command.outcome.kind === "canceled" && command.outcome.confirmation === "not_dispatched" && (run.phase !== "queued" || run.preparation !== "none" || run.dispatch !== "none")) {
+    failDelegation("stale_revision", "An execution intent cannot be settled as never dispatched.");
+  }
+  if (run.ownerEpoch !== command.owner.epoch && command.outcome.kind !== "recovery_required" && !(run.phase === "queued" && run.preparation === "none" && run.dispatch === "none")) {
+    failDelegation("recovery_required", "A new owner cannot reconstruct an old executor's terminal truth.");
+  }
+  settleRun(context, command.outcome, command.at);
+}
+function retireRecovery(context, command) {
+  if (context.task.state !== "recovery_required" || context.current.runs.some((run) => run.phase !== "settled")) {
+    failDelegation("recovery_required", "Only a fully settled recovery task can be retired.");
+  }
+  context.task = {
+    ...context.task,
+    state: "retired",
+    retiredAt: command.at,
+    retirement: { operationId: command.operationId, inputDigest: command.inputDigest, reason: command.reason }
+  };
+  context.receipt = { ...context.receipt, status: "retired" };
+}
+export {
+  cancelRun,
+  observeRun,
+  retireRecovery,
+  settle
+};

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

@@ -0,0 +1,7 @@
+import type { DelegationStoreCommand } from "../store/types.js";
+import type { DelegationStoreCommitCurrent, DelegationStoreCommitPlan } from "./types.js";
+export declare function planDelegationStoreCommit(input: {
+    readonly command: DelegationStoreCommand;
+    readonly current: DelegationStoreCommitCurrent;
+}): DelegationStoreCommitPlan;
+//# sourceMappingURL=plan.d.ts.map