@agen-ai/agent-orchestration 0.4.0 → 0.4.2

package/README.md

@@ -1,8 +1,15 @@
 # @agen-ai/agent-orchestration
 
 Optional managed delegation for applications using the AgenAI coding-agent SDK, at coordinated
-version `0.4.0`. This package sits above
-`@agen-ai/agent-runtime`. Core runtime consumers do not depend on it.
+unpublished source version `0.4.2` (published `0.4.1`). This package sits above
+`@agen-ai/agent-runtime`. Core runtime consumers do not depend on it. Current source uses Agent
+Protocol V12; published `0.4.1` uses V11 and the earlier `0.4.0` release uses V10. Managed store
+contract is 4; the reference SQLite format remains 3; retained historical requests cannot reconstruct live reply authority.
+
+External stores must implement the contract-4 transitions, including exact request retirement
+while an entered answer retains its own receipt. Declaring version 4 alone is insufficient.
+The unchanged SQLite format needs no format-3-to-4 migration. Keep every installed SDK package
+at one coordinated version and follow the [0.4.2 migration guide](../../MIGRATING-TO-0.4.2.md).
 
 The current implementation provides bounded target catalogs, a pure developer/user policy resolver,
 managed task coordination, a volatile store and host-injected completion delivery. A separately
@@ -177,17 +184,30 @@ runs independently from the sole child output reader, so output continues while
 `resolveRequest` delivers through the retained turn execution and returns `delivered`, `rejected` with
 `requestState: "pending" | "unavailable"`, or `delivery_uncertain`. A delivered receipt confirms provider-owned
 acceptance of that exact canonical answer or form step; it does not claim native transport acknowledgment,
-turn completion or approved effect completion. Only a definitive pending rejection restores answerability;
+turn completion or approved effect completion. Only a definitive pending rejection for a request that remains live restores answerability;
 uncertainty forbids replay. The receipt settles without waiting for a later output, request or terminal.
 An unavailable rejection removes only that exact request's eligibility; it does not complete the
 child or its parent. Request expiry, accepted interruption and terminality fence fresh answers.
 Local malformed, stale or pre-aborted answers reject before provider entry; entered provider
 exceptions and uncertain receipts retain the child output/cleanup owner and prohibit resending.
-Raw request answers and native diagnostics are not stored in observations.
+Canonical `request.unavailable` retires the exact request and aborts its host presentation signal,
+leaving the child run alive. A new request can be presented and answered while an already entered
+answer to the retired request remains unsettled. That original attempt retains its actual receipt,
+including a late `delivered` or `rejected`/`pending`; retirement never restores its eligibility or
+transfers its receipt to the new request. Retirement creates no response operation. Exact duplicate
+operation lookup still returns the original receipt under current host access checks.
+
+Returning from `onRequest` does not retire its signal. The coordinator retains only each request's
+historical identity and presentation controller until canonical retirement or run cleanup, bounded
+by the validated runtime's session-generation request census. It retains actual presentation
+callbacks independently even when they ignore their abort signal.
+Terminal output can initiate native quiescence before joining outstanding answers; the original
+reader, callbacks and controls all finish before host resources are released. Raw request answers
+and native diagnostics are not stored in observations.
 
 ## Store and capacity contract
 
-The in-memory store is explicitly volatile. Store port contract version 3 provides owner fencing, immutable outcomes,
+The in-memory store is explicitly volatile. Store port contract version 4 provides owner fencing, immutable outcomes,
 operation idempotency, bounded records and independent settlement/control capacity. The explicit
 `@agen-ai/agent-orchestration/store-adapter` entrypoint supplies a pure transition planner and closed
 row mutations for storage adapters. It does not provide a database, arbitrary transaction callback,
@@ -226,7 +246,12 @@ failure. V10 rejects a malformed `failed` terminal without its required error be
 An exception after observed dispatch remains `recovery_required` with `dispatch_uncertain`, and
 unresolved cleanup or control uncertainty still overrides an apparent definitive failure.
 An old store-port contract is rejected before ownership acquisition; persistence adapters must
-explicitly migrate their independent record format before presenting contract version 3.
+explicitly implement contract 4 before presenting that version. Contract 4 requires request retirement
+to change a waiting run to running and to preserve independently entered receipts without reviving
+retired eligibility or replacing a newer request. The reference SQLite format stays 3: SQL, headers,
+slots, record shapes and settled historical meanings are unchanged, and committed historical receipt
+bytes remain intact. Formats 1 and 2 retain their explicit offline migration path; startup does not
+rewrite them or recreate callbacks.
 
 ## Completion and restart
 

package/dist/coordinator/create.js

@@ -17,7 +17,7 @@ import { recoverRuns } from "./recovery.js";
 import { shutdown } from "./shutdown.js";
 async function createDelegationCoordinator(options) {
   const limits = parseDelegationLimits(options.limits);
-  if (options.store.contractVersion !== 3 || delegationInputDigest(limits) !== delegationInputDigest(options.store.limits)) {
+  if (options.store.contractVersion !== 4 || delegationInputDigest(limits) !== delegationInputDigest(options.store.limits)) {
     failDelegation("store_failed", "The coordinator requires the exact store contract and limits.");
   }
   validateDeliverySetup(options);

package/dist/coordinator/parse.d.ts

@@ -1,3 +1,4 @@
+import type { AgentRequestResolution } from "@agen-ai/agent-protocol";
 import { z } from "zod/v4";
 import type { DelegationLimits } from "../shared/limits.js";
 import type { DelegationSendTaskInput, DelegationSpawnTaskInput } from "./types.js";
@@ -6,5 +7,5 @@ export declare function parseSpawnTaskInput(input: unknown, limits: DelegationLi
 export declare function parseSendTaskInput(input: unknown, limits: DelegationLimits): DelegationSendTaskInput;
 export declare const parseOperationId: (input: unknown) => string;
 export declare const parseTaskId: (input: unknown) => string;
-export declare const parseRequestResolution: (input: unknown) => import("packages/agent-protocol/dist/index.js").AgentRequestResolution;
+export declare const parseRequestResolution: (input: unknown) => AgentRequestResolution;
 //# sourceMappingURL=parse.d.ts.map

package/dist/execution/cleanup.js

@@ -42,11 +42,14 @@ function cleanupRun(state, live) {
       live.request = void 0;
     }
     const reason = new DOMException("The managed run is closing.", "AbortError");
+    for (const presentation of live.requestPresentations.values()) presentation.abort.abort(reason);
+    live.requestPresentations.clear();
     live.controlAbort.abort(reason);
     const runtimeClosing = runtimeCleanup(state, live);
     live.lifetime.abort(reason);
     while (live.controls.size > 0) await Promise.allSettled(live.controls);
     if (!await runtimeClosing) return false;
+    await live.outputDrained;
     while (!live.resourcesReleased && live.resourceReleaseAttempts < 2) {
       live.resourceReleaseAttempts += 1;
       try {

package/dist/execution/control.js

@@ -141,7 +141,7 @@ async function continueRequest(state, input) {
   const { live, request } = pending;
   parseAgentRequestResolutionFor(request, resolution);
   const identity = { operationId, inputDigest: delegationInputDigest({ kind: "request_resolution", taskId: live.taskId, runId: live.runId, requestId: request.requestId, resolution }) };
-  return serializeControl(live, async () => {
+  const admission = await serializeControl(live, async () => {
     const [{ task }, run] = await Promise.all([state.task(live.taskId), state.run(live.taskId, live.runId)]);
     state.options.host.assertResultAccess({ scope: live.scope, task });
     state.options.host.assertRequestAccess({ handle: input.handle, task, run, request });
@@ -151,59 +151,70 @@ async function continueRequest(state, input) {
       if (existing.operation.kind !== "request_resolution" || existing.operation.inputDigest !== identity.inputDigest || existing.operation.taskId !== live.taskId || existing.operation.runId !== live.runId) {
         failDelegation("operation_conflict", "The operation identity already has different input or ownership.");
       }
-      return requestReceipt(live, operationId, existing.operation.disposition, existing.operation.requestState, true);
+      return { kind: "receipt", receipt: requestReceipt(live, operationId, existing.operation.disposition, existing.operation.requestState, true) };
     }
-    if (live.request !== pending || !live.stream || live.finishing || !live.turn || !live.requestHistory || live.uncertain || live.cancellation || run.phase !== "waiting" || live.execution?.signal.aborted || live.lifetime.signal.aborted) {
+    if (live.request !== pending || pending.eligibility !== "waiting" || !live.stream || live.finishing || !live.turn || live.uncertain || live.cancellation || run.phase !== "waiting" || live.execution?.signal.aborted || live.lifetime.signal.aborted) {
       failDelegation("request_unavailable", "The exact waiting request no longer has a live executor.");
     }
-    const history = live.requestHistory;
-    await markRequest(state, live, "resolution_intended", { ...history, state: "resolution_intended" }, identity);
-    live.request = void 0;
-    let disposition;
-    let requestState;
-    let localFailure;
-    let entered = false;
+    const history = pending.history;
+    pending.eligibility = "claimed";
     try {
-      const turn = live.turn;
-      const result = await boundedControl(state, live, (signal) => turn.resolveRequest({
-        resolution,
-        signal: AbortSignal.any([signal, live.lifetime.signal]),
-        onProviderExecutionStarted() {
-          state.options.host.assertRequestAccess({ handle: input.handle, task, run, request });
-          live.execution?.assertCurrent();
-          entered = true;
-        }
-      }));
-      disposition = result.status === "delivery_uncertain" ? "uncertain" : result.status;
-      if (result.status === "rejected") requestState = result.requestState;
+      await markRequest(state, live, "resolution_intended", { ...history, state: "resolution_intended" }, identity);
     } catch (error) {
-      if (error instanceof AgentProviderDelegatedOperationError || entered && error instanceof DOMException && error.name === "AbortError") {
-        disposition = "uncertain";
-      } else {
-        disposition = "rejected";
-        requestState = live.lifetime.signal.aborted || live.cancellation ? "unavailable" : "pending";
-        localFailure = { error };
-      }
-    }
-    if (disposition === "uncertain") live.uncertain = "request_executor_lost";
-    try {
-      await state.mutate(
-        live.taskId,
-        live.runId,
-        operationId,
-        identity.inputDigest,
-        (fence) => ({ ...fence, kind: "operation_receipt", disposition, at: now(), ...requestState ? { requestState } : {} })
-      );
-    } catch (error) {
-      live.uncertain = "storage_failed";
-      void finishRun(state, live, { kind: "recovery_required", reason: "storage_failed" }).catch(() => void 0);
+      if (!pending.signal.aborted && live.request === pending) pending.eligibility = "waiting";
       throw error;
     }
-    if (requestState === "pending" && !live.lifetime.signal.aborted && !live.cancellation) live.request = pending;
-    if (live.uncertain) void finishRun(state, live, { kind: "recovery_required", reason: live.uncertain }).catch(() => void 0);
-    if (localFailure) throw localFailure.error;
-    return requestReceipt(live, operationId, disposition, requestState);
+    live.requestAttempts.set(operationId, pending);
+    const turn = live.turn;
+    return { kind: "dispatch", invoke: async () => {
+      let disposition;
+      let requestState;
+      let localFailure;
+      let entered = false;
+      try {
+        const result = await boundedControl(state, live, (signal) => turn.resolveRequest({
+          resolution,
+          signal: AbortSignal.any([signal, live.lifetime.signal]),
+          onProviderExecutionStarted() {
+            state.options.host.assertRequestAccess({ handle: input.handle, task, run, request });
+            live.execution?.assertCurrent();
+            entered = true;
+          }
+        }));
+        disposition = result.status === "delivery_uncertain" ? "uncertain" : result.status;
+        if (result.status === "rejected") requestState = result.requestState;
+      } catch (error) {
+        if (error instanceof AgentProviderDelegatedOperationError || entered && error instanceof DOMException && error.name === "AbortError") {
+          disposition = "uncertain";
+        } else {
+          disposition = "rejected";
+          requestState = live.lifetime.signal.aborted || live.cancellation ? "unavailable" : "pending";
+          localFailure = { error };
+        }
+      }
+      if (disposition === "uncertain") live.uncertain = "request_executor_lost";
+      try {
+        await state.mutate(
+          live.taskId,
+          live.runId,
+          operationId,
+          identity.inputDigest,
+          (fence) => ({ ...fence, kind: "operation_receipt", disposition, at: now(), ...requestState ? { requestState } : {} })
+        );
+      } catch (error) {
+        live.uncertain = "storage_failed";
+        void finishRun(state, live, { kind: "recovery_required", reason: "storage_failed" }).catch(() => void 0);
+        throw error;
+      }
+      if (pending.eligibility !== "retired") {
+        pending.eligibility = requestState === "pending" && live.request === pending && !live.lifetime.signal.aborted && !live.cancellation ? "waiting" : "retired";
+      }
+      if (live.uncertain) void finishRun(state, live, { kind: "recovery_required", reason: live.uncertain }).catch(() => void 0);
+      if (localFailure) throw localFailure.error;
+      return requestReceipt(live, operationId, disposition, requestState);
+    } };
   });
+  return admission.kind === "receipt" ? admission.receipt : admission.invoke();
 }
 function resolveLiveRequest(state, input) {
   const pending = state.requests.get(input.handle);
@@ -217,10 +228,11 @@ function resolveLiveRequest(state, input) {
   if (prior) return state.track(prior.promise.then((receipt) => ({ ...receipt, duplicate: true })), pending.live);
   const work = state.track(continueRequest(state, input), pending.live);
   pending.live.pendingOperations.set(operationId, { digest, promise: work });
-  pending.live.requestResolution = work;
+  pending.resolution ??= work;
   void work.finally(() => {
     pending.live.pendingOperations.delete(operationId);
-    if (pending.live.requestResolution === work) pending.live.requestResolution = void 0;
+    pending.live.requestAttempts.delete(operationId);
+    if (pending.resolution === work) pending.resolution = void 0;
   }).catch(() => void 0);
   return work;
 }

package/dist/execution/scheduler.js

@@ -68,6 +68,8 @@ async function pump(state) {
         sessionId: parseAgentSessionId(createDelegationId()),
         turnId: parseAgentTurnId(createDelegationId()),
         controls: /* @__PURE__ */ new Set(),
+        requestAttempts: /* @__PURE__ */ new Map(),
+        requestPresentations: /* @__PURE__ */ new Map(),
         pendingOperations: /* @__PURE__ */ new Map(),
         observedStart: false,
         recordedStart: false,

package/dist/execution/state.d.ts

@@ -4,7 +4,7 @@ import type { DelegationTarget } from "../catalog/types.js";
 import type { CreateDelegationCoordinatorOptions } from "../coordinator/types.js";
 import type { DelegationChildResources, DelegationContinuation, DelegationExecutionLease, DelegationHostRequestHandle } from "../host/types.js";
 import type { DelegationCommitReceipt, DelegationMutationFence, DelegationStoreCommand } from "../store/types.js";
-import type { DelegationOwnerToken, DelegationParentScope, DelegationPolicyCeiling, DelegationResultReference, DelegationRunOutcome, DelegationRunRecord, DelegationTaskRecord, DelegationTaskView } from "../tasks/types.js";
+import type { DelegationHistoricalRequest, DelegationOwnerToken, DelegationParentScope, DelegationPolicyCeiling, DelegationResultReference, DelegationRunOutcome, DelegationRunRecord, DelegationTaskRecord, DelegationTaskView } from "../tasks/types.js";
 export interface ParentBinding {
     readonly scope: DelegationParentScope;
     readonly ancestor?: Readonly<{
@@ -18,6 +18,14 @@ export interface LiveRequest {
     readonly handle: DelegationHostRequestHandle;
     readonly live: LiveRun;
     readonly request: AgentRequest;
+    readonly history: DelegationHistoricalRequest;
+    readonly signal: AbortSignal;
+    eligibility: "waiting" | "claimed" | "retired";
+    resolution?: Promise<unknown>;
+}
+export interface RequestPresentation {
+    readonly history: DelegationHistoricalRequest;
+    readonly abort: AbortController;
 }
 export interface LiveRun {
     readonly taskId: string;
@@ -30,6 +38,8 @@ export interface LiveRun {
     readonly sessionId: AgentSessionId;
     readonly turnId: AgentTurnId;
     readonly controls: Set<Promise<unknown>>;
+    readonly requestAttempts: Map<string, LiveRequest>;
+    readonly requestPresentations: Map<AgentRequest["requestId"], RequestPresentation>;
     readonly pendingOperations: Map<string, Readonly<{
         digest: string;
         promise: Promise<unknown>;
@@ -40,8 +50,8 @@ export interface LiveRun {
     turn?: AgentProviderTurnExecution;
     rejectedOpening?: AgentProviderSessionCleanupError;
     stream?: Promise<void>;
+    outputDrained?: Promise<void>;
     request?: LiveRequest;
-    requestResolution?: Promise<unknown>;
     observedStart: boolean;
     recordedStart: boolean;
     controlTail: Promise<void>;
@@ -62,7 +72,6 @@ export interface LiveRun {
     cancellation?: Promise<unknown>;
     finishing?: Promise<void>;
     ready?: Promise<void>;
-    requestHistory?: DelegationRunRecord["pendingRequest"];
     schedule?: () => void;
     deadline?: ReturnType<typeof setTimeout>;
     removeRevocation?: () => void;

package/dist/execution/state.js

@@ -4,8 +4,6 @@ class CoordinatorState {
     this.options = options;
     this.owner = owner;
   }
-  options;
-  owner;
   live = /* @__PURE__ */ new Map();
   continuations = /* @__PURE__ */ new Map();
   requests = /* @__PURE__ */ new WeakMap();

package/dist/execution/stream.js

@@ -25,7 +25,7 @@ async function markRequest(state, live, stateChange, request, identity = operati
     live.runId,
     identity.operationId,
     identity.inputDigest,
-    (fence) => ({ ...fence, kind: "request_state", state: stateChange, request, at: now() })
+    (fence, _task, run) => stateChange === "unavailable" && (run.pendingRequest?.requestId !== request.requestId || run.pendingRequest.requestKind !== request.requestKind) ? void 0 : { ...fence, kind: "request_state", state: stateChange, request, at: now() }
   );
 }
 async function routeRequest(state, live, request) {
@@ -37,19 +37,28 @@ async function routeRequest(state, live, request) {
     state: "waiting"
   };
   await markRequest(state, live, "opened", historical);
-  live.requestHistory = historical;
   const handle = Object.freeze({});
-  const pending = { handle, live, request };
+  const presentationAbort = new AbortController();
+  const pending = {
+    handle,
+    live,
+    request,
+    history: historical,
+    signal: AbortSignal.any([presentationAbort.signal, live.lifetime.signal]),
+    eligibility: "waiting"
+  };
   live.request = pending;
   state.requests.set(handle, pending);
+  live.requestPresentations.set(request.requestId, { history: historical, abort: presentationAbort });
   await observe(state, live, { kind: "request", request: historical });
   const callback = Promise.resolve().then(async () => {
     const [{ task }, run] = await Promise.all([state.task(live.taskId), state.run(live.taskId, live.runId)]);
-    if (live.lifetime.signal.aborted || live.request !== pending) return;
-    await state.options.host.onRequest({ handle, task, run, request, signal: live.lifetime.signal });
+    if (pending.signal.aborted || live.request !== pending) return;
+    await state.options.host.onRequest({ handle, task, run, request, signal: pending.signal });
   });
   state.track(callback, live);
-  void callback.catch(() => {
+  void callback.catch((error) => {
+    if (pending.signal.aborted && (error === pending.signal.reason || error instanceof DOMException && error.name === "AbortError")) return;
     live.uncertain = "request_executor_lost";
     void finishRun(state, live, { kind: "recovery_required", reason: "request_executor_lost" }).catch(() => void 0);
   });
@@ -72,35 +81,60 @@ async function reduceOutput(state, live, output) {
     await observe(state, live, { kind: "text", text: event.payload.delta });
   } else if (event.type === "turn.started") await observe(state, live, { kind: "state", phase: "running" });
   else if (event.type === "request.opened") return { request: event.payload.request };
-  else if (event.type === "turn.completed") {
+  else if (event.type === "request.unavailable") {
+    const presentation = live.requestPresentations.get(event.payload.requestId);
+    if (presentation) {
+      const pending = live.request?.request.requestId === event.payload.requestId ? live.request : [...live.requestAttempts.values()].find((request) => request.request.requestId === event.payload.requestId);
+      if (pending) pending.eligibility = "retired";
+      presentation.abort.abort(new DOMException("The managed request is no longer available.", "AbortError"));
+      live.requestPresentations.delete(event.payload.requestId);
+      const historical = { ...presentation.history, state: "unavailable" };
+      await markRequest(state, live, "unavailable", historical);
+      await observe(state, live, { kind: "request", request: historical });
+    }
+  } else if (event.type === "turn.completed") {
     return { terminal: event.payload.outcome === "completed" ? { kind: "succeeded", result: { text: live.summary, truncated: live.truncated, references: [...live.references] } } : event.payload.outcome === "canceled" ? { kind: "canceled", confirmation: "provider_terminal" } : { kind: "failed", error: projectDelegationFailure(event.payload.error) } };
   }
   return {};
 }
 async function consumeTurn(state, live, outputs) {
   let terminal;
+  let drained;
+  live.outputDrained = new Promise((resolve) => {
+    drained = resolve;
+  });
   try {
     for await (const output of outputs) {
       const projected = await reduceOutput(state, live, output);
-      if (projected.request || projected.terminal) await live.requestResolution?.catch(() => void 0);
+      if (projected.request && live.request?.eligibility !== "retired") await live.request?.resolution?.catch(() => void 0);
       if (projected.request && !live.uncertain && !live.lifetime.signal.aborted) await routeRequest(state, live, projected.request);
       terminal = projected.terminal ?? terminal;
+      if (projected.terminal && live.requestAttempts.size > 0) {
+        live.terminal = projected.terminal;
+        void finishRun(state, live, projected.terminal).catch(() => void 0);
+      }
     }
-    live.stream = void 0;
-    if (!terminal) terminal = { kind: "recovery_required", reason: live.cancellation ? "cancellation_uncertain" : live.requestHistory ? "request_executor_lost" : "dispatch_uncertain" };
-  } catch {
-    live.stream = void 0;
-    terminal = live.observedStart ? { kind: "recovery_required", reason: live.uncertain ?? (live.cancellation ? "cancellation_uncertain" : "dispatch_uncertain") } : { kind: "failed", error: { category: "unknown", code: "turn_rejected", message: "The managed child turn was rejected before provider execution.", recovery: { kind: "unknown" } } };
-    if (!live.observedStart) {
-      try {
-        await operationReceipt(state, live, "rejected", operationIdentity(live, "turn"));
-      } catch {
-        live.uncertain = "storage_failed";
+    if (!terminal) terminal = { kind: "recovery_required", reason: live.cancellation ? "cancellation_uncertain" : live.request ? "request_executor_lost" : "dispatch_uncertain" };
+  } catch (error) {
+    const closedAfterTerminal = terminal !== void 0 && live.finishing !== void 0 && live.lifetime.signal.aborted && error instanceof DOMException && error.name === "AbortError";
+    if (!closedAfterTerminal) {
+      terminal = live.observedStart ? { kind: "recovery_required", reason: live.uncertain ?? (live.cancellation ? "cancellation_uncertain" : "dispatch_uncertain") } : { kind: "failed", error: { category: "unknown", code: "turn_rejected", message: "The managed child turn was rejected before provider execution.", recovery: { kind: "unknown" } } };
+      if (live.observedStart) live.uncertain = terminal.kind === "recovery_required" ? terminal.reason : "dispatch_uncertain";
+      else {
+        try {
+          await operationReceipt(state, live, "rejected", operationIdentity(live, "turn"));
+        } catch {
+          live.uncertain = "storage_failed";
+        }
       }
     }
+  } finally {
+    live.stream = void 0;
+    drained();
   }
-  live.terminal = terminal;
-  await finishRun(state, live, terminal);
+  const outcome = terminal ?? { kind: "recovery_required", reason: "dispatch_uncertain" };
+  live.terminal = outcome;
+  await finishRun(state, live, outcome);
 }
 export {
   consumeTurn,

package/dist/mcp/http.js

@@ -5,7 +5,6 @@ class McpHttpError extends Error {
     super("The MCP HTTP request is unavailable.");
     this.status = status;
   }
-  status;
 }
 function authorizeRequest(request, expectedHost, authorization) {
   if (request.headers.host !== expectedHost || request.headers.origin !== void 0) throw new McpHttpError(403);

package/dist/mcp/protocol.js

@@ -30,7 +30,7 @@ function mcpTools(binding) {
   return tools;
 }
 function createMcpProtocol(context, tools) {
-  const protocol = new Server({ name: "agenai_delegation", version: "0.4.0" }, {
+  const protocol = new Server({ name: "agenai_delegation", version: "0.4.2" }, {
     capabilities: { tools: {} },
     ...context.binding.instructions ? { instructions: context.binding.instructions.text } : {}
   });

package/dist/shared/operational-errors.js

@@ -4,7 +4,6 @@ class DelegationOperationError extends Error {
     this.code = code;
     this.name = "DelegationOperationError";
   }
-  code;
 }
 function failDelegation(code, message) {
   throw new DelegationOperationError(code, message);

package/dist/store/memory.js

@@ -52,7 +52,7 @@ function createInMemoryDelegationStore(options = {}) {
   const runObservations = (runId) => [...observations.values()].filter((observation) => observation.runId === runId);
   const page = (query, rows, key, input, envelopeBytes = 0) => pageDelegationRows({ storeId, query, rows, key, limits, ...input, envelopeBytes });
   return Object.freeze({
-    contractVersion: 3,
+    contractVersion: 4,
     persistence: "volatile",
     storeId,
     limits,

package/dist/store/types.d.ts

@@ -205,7 +205,7 @@ export type DelegationStoreScanPage = Readonly<{
     page: DelegationPage<DelegationNotificationRecord>;
 }>;
 export interface DelegationStore {
-    readonly contractVersion: 3;
+    readonly contractVersion: 4;
     readonly persistence: DelegationPersistence;
     readonly storeId: string;
     readonly limits: DelegationLimits;

package/dist/store-adapter/execution.js

@@ -96,8 +96,8 @@ function operationReceipt(context, command) {
     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";
+      if (run.pendingRequest.state !== "resolution_intended" && run.pendingRequest.state !== "unavailable") failDelegation("request_unavailable", "The exact request has no entered resolution intent.");
+      const state = run.pendingRequest.state === "unavailable" ? "unavailable" : command.disposition === "delivered" ? "resolved" : command.requestState === "pending" ? "waiting" : "unavailable";
       setRun(context, {
         phase: run.phase === "settled" ? "settled" : state === "waiting" ? "waiting" : "running",
         pendingRequest: { ...run.pendingRequest, state }
@@ -139,7 +139,10 @@ function requestState(context, command) {
       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 } });
+      setRun(context, {
+        ...command.state === "unavailable" && run.phase === "waiting" ? { phase: "running" } : {},
+        pendingRequest: { ...run.pendingRequest, state: command.state }
+      });
     }
   }
   context.receipt = { ...context.receipt, status: requireRun(context).phase };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agen-ai/agent-orchestration",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "private": false,
   "description": "Optional policy-governed managed delegation for the AgenAI coding-agent runtime.",
   "type": "module",
@@ -33,9 +33,9 @@
   "dependencies": {
     "zod": "4.4.3",
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@agen-ai/agent-protocol": "^0.4.0",
-    "@agen-ai/agent-runtime": "^0.4.0",
-    "@agen-ai/validation": "^0.4.0"
+    "@agen-ai/agent-protocol": "^0.4.2",
+    "@agen-ai/validation": "^0.4.2",
+    "@agen-ai/agent-runtime": "^0.4.2"
   },
   "devDependencies": {
     "tsup": "^8.5.0"