@hassangameryt/freeflow 0.7.2 → 0.7.3

package/pi-extension/src/cognitive-routing-v2/schemas.ts

@@ -1,29 +1,61 @@
 import { isObject } from "./types.js";
-const string = (maxLength = 32768) => ({ type: "string", minLength: 1, maxLength });
-const object = (properties: Record<string, any>, required = Object.keys(properties)) => ({
+const string = (maxLength = 32768, description?: string) => ({
+  type: "string",
+  minLength: 1,
+  maxLength,
+  ...(description ? { description } : {}),
+});
+const object = (
+  properties: Record<string, any>,
+  required = Object.keys(properties),
+  description?: string,
+  title?: string,
+) => ({
   type: "object",
   additionalProperties: false,
   properties,
   required,
+  ...(description ? { description } : {}),
+  ...(title ? { title } : {}),
 });
-const operation = (value: string) => ({ type: "string", enum: [value] });
-const submit = object(
-  {
-    operation: operation("submit"),
-    report: string(),
-    outcome: { type: "string", enum: ["completed", "partial", "blocked"] },
-    limitations: { type: "array", maxItems: 32, items: string(2048) },
-  },
-  ["operation", "report", "outcome"],
-);
+const operation = (value: string, description?: string) => ({
+  type: "string",
+  enum: [value],
+  ...(description ? { description } : {}),
+});
+const evidenceRefs = (description: string) => ({
+  type: "array",
+  maxItems: 64,
+  items: string(512),
+  description,
+});
+const worker = {
+  type: "string",
+  enum: ["helper", "executor"],
+  description: "Worker for this assignment. Required when delegation mode enables both workers.",
+};
+const report = (name: "submit" | "supplement") =>
+  object(
+    {
+      operation: operation(name),
+      report: string(),
+      outcome: { type: "string", enum: ["completed", "partial", "blocked"] },
+      limitations: { type: "array", maxItems: 32, items: string(2048) },
+    },
+    ["operation", "report", "outcome"],
+  );
 export const ROUTING_SCHEMAS: Record<string, any> = {
   freeflow_delegate: {
     oneOf: [
-      object({ operation: operation("assign"), contract: string() }),
-      object({ operation: operation("replace"), contract: string(), reason: string(2048) }),
+      object({ operation: operation("assign"), contract: string(), worker }, ["operation", "contract"]),
+      object({ operation: operation("replace"), contract: string(), reason: string(2048), worker }, [
+        "operation",
+        "contract",
+        "reason",
+      ]),
     ],
   },
-  freeflow_return: { oneOf: [submit, object({ operation: operation("retry") })] },
+  freeflow_return: { oneOf: [report("submit"), report("supplement"), object({ operation: operation("retry") })] },
   freeflow_unit: {
     oneOf: [
       object(
@@ -37,6 +69,15 @@ export const ROUTING_SCHEMAS: Record<string, any> = {
         ["operation"],
       ),
       object({ operation: operation("assess") }),
+      object(
+        {
+          operation: operation("recover"),
+          request: string(),
+          paths: { type: "array", maxItems: 32, items: string(4096) },
+        },
+        ["operation", "request"],
+      ),
+      object({ operation: operation("cancel-recovery"), reason: string(2048) }),
       object({
         operation: operation("close"),
         outcome: { type: "string", enum: ["accepted", "cancelled", "deferred"] },
@@ -48,18 +89,41 @@ export const ROUTING_SCHEMAS: Record<string, any> = {
     oneOf: [
       object(
         {
-          operation: operation("inspect"),
-          scope: { type: "string", enum: ["selected", "assignment", "active", "history"] },
-          cursor: string(128),
+          operation: operation("inspect", "Read current selection and offered evidence candidates."),
+          scope: {
+            type: "string",
+            enum: ["selected", "assignment", "active", "history"],
+            description: "Optional candidate scope; omit to inspect the current assignment.",
+          },
+          cursor: string(128, "Use the nextCursor returned by a previous inspection."),
         },
         ["operation"],
+        "Inspect selection and candidates without changing evidence state.",
+        "Inspect evidence selection",
+      ),
+      object(
+        {
+          operation: operation("add", "Select eligible worker task-evidence refs; do not include reason."),
+          refs: evidenceRefs(
+            "Exact eligible visible refs for worker task evidence. Add known eligible refs directly; inspect when identity, eligibility, representation, or selection state is unclear. Never add a ref marked not offered for new evidence selection.",
+          ),
+        },
+        ["operation", "refs"],
+        "Add evidence refs. This shape has no reason field.",
+        "Add evidence",
+      ),
+      object(
+        {
+          operation: operation("remove", "Withdraw selected or unresolved refs; reason is required."),
+          refs: evidenceRefs(
+            "Currently selected or unresolved refs to withdraw. A non-selectable ref may be removed with a reason to clear its unresolved request.",
+          ),
+          reason: string(2048, "Required only for remove; explain why the selection is being withdrawn."),
+        },
+        ["operation", "refs", "reason"],
+        "Remove evidence refs. This is the only operation that accepts reason.",
+        "Remove evidence",
       ),
-      object({ operation: operation("add"), refs: { type: "array", maxItems: 64, items: string(512) } }),
-      object({
-        operation: operation("remove"),
-        refs: { type: "array", maxItems: 64, items: string(512) },
-        reason: string(2048),
-      }),
     ],
   },
 };
@@ -73,7 +137,14 @@ for (const schema of Object.values(ROUTING_SCHEMAS)) {
   schema.properties.operation = {
     type: "string",
     enum: schema.oneOf.flatMap((branch: any) => branch.properties.operation.enum),
+    description: "Choose exactly one operation; each operation has a strict shape and rejects unknown fields.",
   };
+  if (schema.properties.refs)
+    schema.properties.refs = {
+      ...schema.properties.refs,
+      description:
+        "For add, use exact eligible visible refs directly when their identity and eligibility are clear; inspect when identity, eligibility, representation, or selection state is unclear. Never add refs marked not offered for new evidence selection. For remove, use currently selected or unresolved refs; a non-selectable ref may be named to clear its unresolved request and requires reason.",
+    };
 }
 
 export function matches(value: any, schema: any): boolean {

package/pi-extension/src/cognitive-routing-v2/state.ts

@@ -7,6 +7,7 @@ import {
   eventKey,
   eventValue,
   isObject,
+  isWorkerProfile,
   requireCondition as check,
   refFor,
   type RoutingEvent,
@@ -14,6 +15,7 @@ import {
   type NativeEntry,
   type Pair,
   type Handoff,
+  type Recovery,
   type Reservation,
 } from "./types.js";
 
@@ -28,6 +30,11 @@ const pair = (x: any): x is Pair =>
   identity(x.provider) &&
   identity(x.modelId) &&
   EFFORTS.includes(x.thinking);
+const profileOverrides = (x: any): boolean =>
+  isObject(x) &&
+  Object.keys(x).length > 0 &&
+  Object.keys(x).every((key) => PROFILES.includes(key as any)) &&
+  Object.values(x).every((value) => value === null || pair(value));
 const problemList = (xs: any): boolean =>
   Array.isArray(xs) &&
   xs.every(
@@ -60,6 +67,41 @@ const reservation = (r: any): r is Reservation =>
   Number.isFinite(r.outputReserve) &&
   r.outputReserve >= 0 &&
   text(r.estimateMethod);
+const recovery = (r: any): r is Recovery =>
+  shape(r, [
+    "id",
+    "assignmentId",
+    "assessmentHandoffId",
+    "baseReportRevision",
+    "request",
+    "requestedPaths",
+    "paths",
+    "state",
+    "requestHandoffId",
+    "supplementHandoffId",
+    "supplementRevision",
+    "cancellationReason",
+  ]) &&
+  identity(r.id) &&
+  identity(r.assignmentId) &&
+  identity(r.assessmentHandoffId) &&
+  Number.isSafeInteger(r.baseReportRevision) &&
+  r.baseReportRevision > 0 &&
+  text(r.request) &&
+  Array.isArray(r.requestedPaths) &&
+  r.requestedPaths.length <= 32 &&
+  r.requestedPaths.every((path: unknown) => text(path, 4096)) &&
+  new Set(r.requestedPaths).size === r.requestedPaths.length &&
+  Array.isArray(r.paths) &&
+  r.paths.length <= 32 &&
+  r.paths.every((path: unknown) => text(path, 4096)) &&
+  new Set(r.paths).size === r.paths.length &&
+  ["requested", "reading", "returning", "completed", "cancelled"].includes(r.state) &&
+  identity(r.requestHandoffId) &&
+  (r.supplementHandoffId === undefined || identity(r.supplementHandoffId)) &&
+  Number.isSafeInteger(r.supplementRevision) &&
+  r.supplementRevision >= 0 &&
+  (r.cancellationReason === undefined || text(r.cancellationReason, 2048));
 const handoff = (h: any): h is Handoff =>
   shape(h, [
     "id",
@@ -83,7 +125,7 @@ const handoff = (h: any): h is Handoff =>
   identity(h.executionId) &&
   identity(h.toolCallId) &&
   nullableId(h.basisUserEntryId) &&
-  ["delegate", "return"].includes(h.kind) &&
+  ["delegate", "return", "recovery-request", "recovery-return"].includes(h.kind) &&
   PROFILES.includes(h.from) &&
   PROFILES.includes(h.to) &&
   h.from !== h.to &&
@@ -95,15 +137,21 @@ const handoff = (h: any): h is Handoff =>
   h.limitations.every((x: unknown) => text(x, 2048)) &&
   (h.reason === undefined || text(h.reason, 4096)) &&
   (h.outcome === undefined || ["completed", "partial", "blocked"].includes(h.outcome)) &&
-  (h.kind !== "delegate" || (h.outcome === undefined && h.reportRevision === 0));
+  (["delegate", "recovery-request"].includes(h.kind)
+    ? h.outcome === undefined && h.reportRevision === 0
+    : ["completed", "partial", "blocked"].includes(h.outcome) && h.reportRevision > 0);
 const fields: Record<string, string[]> = {
   "execution-interrupted": ["executionId", "reason"],
   "assignment-resumed": ["assignmentId", "basisUserEntryId"],
   control: ["control", "profile", "reason"],
+  "profile-overrides": ["overrides", "reason"],
   "execution-opened": ["execution"],
   "execution-bound": ["executionId", "assistantEntryId", "resultEntryIds", "outcome"],
   "delegate-accepted": ["unit", "assignment", "handoff", "replacement"],
   "return-accepted": ["handoff"],
+  "recovery-request-accepted": ["recovery", "handoff"],
+  "recovery-supplement-accepted": ["recoveryId", "handoff"],
+  "recovery-cancelled": ["recoveryId", "reason"],
   "handoff-retry-requested": [
     "handoffId",
     "attemptId",
@@ -163,17 +211,21 @@ export function parseRoutingEvent(raw: unknown): RoutingEvent {
         "invalid_control",
       );
       break;
+    case "profile-overrides":
+      check(profileOverrides(d.overrides) && text(d.reason, 4096), "invalid_profile_overrides");
+      break;
     case "execution-opened": {
       const e = d.execution;
       check(
-        shape(e, ["id", "profile", "assignmentId", "basisUserEntryId", "pair", "resultEntryIds"]) &&
+        shape(e, ["id", "profile", "assignmentId", "recoveryId", "basisUserEntryId", "pair", "resultEntryIds"]) &&
           identity(e.id) &&
           ["solo", ...PROFILES].includes(e.profile) &&
           nullableId(e.basisUserEntryId) &&
           pair(e.pair) &&
           uniqueStrings(e.resultEntryIds) &&
           e.resultEntryIds.length === 0 &&
-          (e.assignmentId === undefined || identity(e.assignmentId)),
+          (e.assignmentId === undefined || identity(e.assignmentId)) &&
+          (e.recoveryId === undefined || identity(e.recoveryId)),
         "invalid_execution",
       );
       break;
@@ -221,13 +273,28 @@ export function parseRoutingEvent(raw: unknown): RoutingEvent {
       break;
     }
     case "return-accepted":
+      check(handoff(d.handoff) && d.handoff.kind === "return", "invalid_return");
+      break;
+    case "recovery-request-accepted":
       check(
-        handoff(d.handoff) &&
-          ["completed", "partial", "blocked"].includes(d.handoff.outcome) &&
-          d.handoff.reportRevision > 0,
-        "invalid_return",
+        recovery(d.recovery) &&
+          handoff(d.handoff) &&
+          d.handoff.kind === "recovery-request" &&
+          d.recovery.requestHandoffId === d.handoff.id &&
+          d.recovery.assignmentId === d.handoff.assignmentId &&
+          d.recovery.request === d.handoff.text,
+        "invalid_recovery_request",
       );
       break;
+    case "recovery-supplement-accepted":
+      check(
+        identity(d.recoveryId) && handoff(d.handoff) && d.handoff.kind === "recovery-return",
+        "invalid_recovery_supplement",
+      );
+      break;
+    case "recovery-cancelled":
+      check(identity(d.recoveryId) && text(d.reason, 2048), "invalid_recovery_cancellation");
+      break;
     case "handoff-retry-requested":
       check(
         identity(d.attemptId) &&
@@ -275,7 +342,10 @@ export function parseRoutingEvent(raw: unknown): RoutingEvent {
       );
       break;
     case "assessment-resumed":
-      check(nullableId(d.basisUserEntryId) && reservation(d.reservation), "invalid_resumption");
+      check(
+        nullableId(d.basisUserEntryId) && (d.reservation === undefined || reservation(d.reservation)),
+        "invalid_resumption",
+      );
       break;
     case "unit-closed":
       check(
@@ -315,6 +385,7 @@ export function initialState(): State {
     units: new Map(),
     assignments: new Map(),
     handoffs: new Map(),
+    recoveries: new Map(),
     executions: new Map(),
     selections: new Map(),
     reservations: new Map(),
@@ -322,6 +393,7 @@ export function initialState(): State {
     exposure: new Map(),
     authors: new Map(),
     resumeBasis: new Map(),
+    profileOverrides: new Map(),
     events: new Map(),
     eventIds: new Map(),
   };
@@ -344,6 +416,7 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
           units: new Map([...state.units].map(([k, v]) => [k, { ...v }])),
           assignments: new Map([...state.assignments].map(([k, v]) => [k, { ...v }])),
           handoffs: new Map([...state.handoffs].map(([k, v]) => [k, { ...v }])),
+          recoveries: new Map([...state.recoveries].map(([k, v]) => [k, { ...v, paths: [...v.paths] }])),
           executions: new Map([...state.executions].map(([k, v]) => [k, { ...v }])),
           selections: new Map(state.selections),
           reservations: new Map(state.reservations),
@@ -351,17 +424,27 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
           exposure: new Map(state.exposure),
           authors: new Map(state.authors),
           resumeBasis: new Map(state.resumeBasis),
+          profileOverrides: new Map(state.profileOverrides),
           events: new Map(state.events),
           eventIds: new Map(state.eventIds),
           assessment: state.assessment ? { ...state.assessment } : undefined,
         },
     d = e.data;
   const assignment = () => (s.assignmentId ? s.assignments.get(s.assignmentId) : undefined);
+  const assignmentWorker = () => {
+    const a = assignment();
+    const h = a ? s.handoffs.get(a.delegateHandoffId) : undefined;
+    check(h?.kind === "delegate" && h.assignmentId === a?.id && isWorkerProfile(h.to), "assignment_worker_missing");
+    return h.to;
+  };
   const pending = () => (s.pendingId ? s.handoffs.get(s.pendingId) : undefined);
   const isPending = () => pending() && ["pending", "blocked"].includes(pending()!.state);
   const currentReturn = (id: string) => {
     const h = s.handoffs.get(id);
-    check(h && h.kind === "return" && h.assignmentId === s.assignmentId, "not_current_return");
+    check(
+      h && ["return", "recovery-return"].includes(h.kind) && h.assignmentId === s.assignmentId,
+      "not_current_return",
+    );
     return h;
   };
   switch (d.type) {
@@ -384,6 +467,14 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
       s.control = d.control;
       s.profile = d.profile;
       break;
+    case "profile-overrides":
+      for (const profile of PROFILES) {
+        if (!Object.hasOwn(d.overrides, profile)) continue;
+        const override = d.overrides[profile];
+        if (override === null) s.profileOverrides.delete(profile);
+        else s.profileOverrides.set(profile, override);
+      }
+      break;
     case "execution-opened":
       check(!s.executions.has(d.execution.id), "duplicate_execution");
       s.executions.set(d.execution.id, d.execution);
@@ -417,7 +508,7 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
       check(
         h.kind === "delegate" &&
           h.from === "coordinator" &&
-          h.to === "executor" &&
+          isWorkerProfile(h.to) &&
           h.state === "pending" &&
           h.text === d.assignment.contract &&
           h.assignmentId === d.assignment.id &&
@@ -435,9 +526,9 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
         check(a?.state === "outstanding" && a.id === d.replacement.assignmentId && u, "no_replaceable_assignment");
         check(
           ![...s.executions.values()].some(
-            (x) => x.assignmentId === a.id && x.profile === "executor" && !x.assistantEntryId && !x.interrupted,
+            (x) => x.assignmentId === a.id && isWorkerProfile(x.profile) && !x.assistantEntryId && !x.interrupted,
           ),
-          "unresolved_executor_execution",
+          "unresolved_worker_execution",
         );
         check(
           !isPending() || (pending()!.kind === "delegate" && d.replacement.supersededHandoffId === pending()!.id),
@@ -456,14 +547,14 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
       break;
     }
     case "return-accepted": {
-      check(s.control === "automatic" && s.profile === "executor", "wrong_control");
+      check(s.control === "automatic" && s.profile === assignmentWorker(), "wrong_control");
       const a = assignment(),
         h = d.handoff;
       check(
         a &&
           h.assignmentId === a.id &&
           h.kind === "return" &&
-          h.from === "executor" &&
+          h.from === assignmentWorker() &&
           h.to === "coordinator" &&
           h.state === "pending",
         "return_identity_mismatch",
@@ -493,11 +584,101 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
       };
       break;
     }
+    case "recovery-request-accepted": {
+      const a = assignment(),
+        base = s.handoffs.get(d.recovery.assessmentHandoffId),
+        h = d.handoff;
+      check(
+        s.control === "automatic" &&
+          s.profile === "coordinator" &&
+          a?.state === "returned" &&
+          d.recovery.assignmentId === a.id &&
+          d.recovery.state === "requested" &&
+          d.recovery.supplementRevision === 0 &&
+          d.recovery.supplementHandoffId === undefined &&
+          d.recovery.cancellationReason === undefined &&
+          s.assessment?.handoffId === base?.id &&
+          base?.kind === "return" &&
+          a.returnHandoffId === base.id &&
+          base.state === "configured" &&
+          base.reportRevision === d.recovery.baseReportRevision &&
+          !s.recoveryId &&
+          !isPending() &&
+          h.kind === "recovery-request" &&
+          h.assignmentId === a.id &&
+          h.from === "coordinator" &&
+          h.to === assignmentWorker() &&
+          h.state === "pending" &&
+          !s.handoffs.has(h.id) &&
+          !s.recoveries.has(d.recovery.id),
+        "recovery_not_available",
+      );
+      s.recoveries.set(d.recovery.id, d.recovery);
+      s.recoveryId = d.recovery.id;
+      s.handoffs.set(h.id, h);
+      s.pendingId = h.id;
+      s.assessment.view = "suspended";
+      s.assessment.suspensionReason = "recovery";
+      s.assessment.basisUserEntryId = h.basisUserEntryId;
+      s.assessment.problems = [];
+      break;
+    }
+    case "recovery-supplement-accepted": {
+      const a = assignment(),
+        r = s.recoveries.get(d.recoveryId),
+        h = d.handoff,
+        previous = r?.supplementHandoffId ? s.handoffs.get(r.supplementHandoffId) : undefined;
+      check(
+        s.control === "automatic" &&
+          s.profile === assignmentWorker() &&
+          a?.state === "returned" &&
+          r?.id === s.recoveryId &&
+          r.assignmentId === a.id &&
+          s.assessment?.handoffId === r.assessmentHandoffId &&
+          s.handoffs.get(r.assessmentHandoffId)?.reportRevision === r.baseReportRevision &&
+          ["reading", "returning"].includes(r.state) &&
+          h.kind === "recovery-return" &&
+          h.assignmentId === a.id &&
+          h.from === assignmentWorker() &&
+          h.to === "coordinator" &&
+          h.state === "pending" &&
+          (!previous ? !s.handoffs.has(h.id) : ["pending", "blocked"].includes(previous.state) && previous.id === h.id),
+        "recovery_not_returnable",
+      );
+      const expectedRevision = (previous?.reportRevision ?? 0) + 1;
+      check(h.reportRevision === expectedRevision, "invalid_report_revision");
+      r.state = "returning";
+      r.supplementHandoffId = h.id;
+      r.supplementRevision = h.reportRevision;
+      s.handoffs.set(h.id, h);
+      s.pendingId = h.id;
+      break;
+    }
+    case "recovery-cancelled": {
+      const r = s.recoveries.get(d.recoveryId);
+      check(
+        s.control === "automatic" &&
+          s.profile === "coordinator" &&
+          r?.id === s.recoveryId &&
+          ["requested", "reading", "returning"].includes(r.state),
+        "recovery_not_cancellable",
+      );
+      const p = pending();
+      if (p) {
+        check([r.requestHandoffId, r.supplementHandoffId].includes(p.id), "handoff_pending");
+        p.state = "superseded";
+        s.pendingId = undefined;
+      }
+      r.state = "cancelled";
+      r.cancellationReason = d.reason;
+      s.recoveryId = undefined;
+      break;
+    }
     case "handoff-retry-requested": {
       const h = currentReturn(d.handoffId);
       check(
         s.control === "automatic" &&
-          s.profile === "executor" &&
+          s.profile === assignmentWorker() &&
           ["blocked", "pending"].includes(h.state) &&
           h.reportRevision === d.reportRevision &&
           (s.selections.get(h.assignmentId)?.revision ?? 0) === d.selectionRevision,
@@ -517,6 +698,11 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
       check(d.reservation.selectionRevision === (s.selections.get(h.assignmentId)?.revision ?? 0), "stale_selection");
       s.reservations.set(h.id, d.reservation);
       if (s.assessment?.handoffId === h.id) s.assessment.reservation = d.reservation;
+      if (h.kind === "recovery-return") {
+        const recovery = [...s.recoveries.values()].find((candidate) => candidate.supplementHandoffId === h.id);
+        if (recovery && s.assessment?.handoffId === recovery.assessmentHandoffId)
+          s.assessment.reservation = d.reservation;
+      }
       break;
     }
     case "handoff-state": {
@@ -528,6 +714,12 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
         check(d.observedPair, "configuration_unobserved");
         s.profile = h.to;
         s.pendingId = undefined;
+        const r = s.recoveryId ? s.recoveries.get(s.recoveryId) : undefined;
+        if (r && h.id === r.requestHandoffId) r.state = "reading";
+        if (r && h.id === r.supplementHandoffId) {
+          r.state = "completed";
+          s.recoveryId = undefined;
+        }
       }
       if (d.state === "superseded") s.pendingId = undefined;
       break;
@@ -537,8 +729,10 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
       check(
         a?.id === d.assignmentId &&
           s.control === "automatic" &&
-          s.profile === "executor" &&
-          (a.state === "outstanding" || (a.state === "returned" && isPending())),
+          s.profile === assignmentWorker() &&
+          (a.state === "outstanding" ||
+            (a.state === "returned" &&
+              (isPending() || (s.recoveryId !== undefined && s.recoveries.get(s.recoveryId)?.state === "reading")))),
         "selection_wrong_phase",
       );
       check(d.selection.revision === (s.selections.get(a.id)?.revision ?? 0) + 1, "selection_revision");
@@ -548,6 +742,7 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
     case "assessment-suspended": {
       check(s.assessment?.handoffId === d.handoffId, "assessment_missing");
       s.assessment.view = "suspended";
+      s.assessment.suspensionReason = d.reason;
       s.assessment.basisUserEntryId = d.basisUserEntryId;
       s.assessment.problems = d.problems;
       break;
@@ -556,19 +751,24 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
       check(
         s.control === "automatic" &&
           s.profile === "coordinator" &&
+          !s.recoveryId &&
           s.assessment?.handoffId === d.handoffId &&
           s.assessment.view === "suspended",
-        "assessment_not_suspended",
-      );
-      check(
-        d.reservation.selectionRevision === (s.selections.get(s.assessment.assignmentId)?.revision ?? 0),
-        "stale_selection",
+        s.recoveryId ? "recovery_outstanding" : "assessment_not_suspended",
       );
+      if (d.reservation)
+        check(
+          d.reservation.selectionRevision === (s.selections.get(s.assessment.assignmentId)?.revision ?? 0),
+          "stale_selection",
+        );
       s.assessment.view = "active";
+      s.assessment.suspensionReason = undefined;
       s.assessment.basisUserEntryId = d.basisUserEntryId;
-      s.assessment.reservation = d.reservation;
+      if (d.reservation) {
+        s.assessment.reservation = d.reservation;
+        s.reservations.set(d.handoffId, d.reservation);
+      }
       s.assessment.problems = [];
-      s.reservations.set(d.handoffId, d.reservation);
       break;
     }
     case "unit-closed": {
@@ -578,7 +778,24 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
         s.control === "automatic" && s.profile === "coordinator" && u?.id === s.unitId && u.state === "open",
         "unit_not_open",
       );
-      if (d.outcome === "accepted") check(a?.state !== "outstanding" && !isPending(), "unfinished_work");
+      if (d.outcome === "accepted")
+        check(a?.state !== "outstanding" && !isPending() && !s.recoveryId, "unfinished_work");
+      const recovery = s.recoveryId ? s.recoveries.get(s.recoveryId) : undefined;
+      if (recovery) {
+        check(
+          d.outcome !== "accepted" && ["requested", "reading", "returning"].includes(recovery.state),
+          "unfinished_work",
+        );
+        const transfer = pending();
+        if (transfer) {
+          check([recovery.requestHandoffId, recovery.supplementHandoffId].includes(transfer.id), "handoff_pending");
+          transfer.state = "superseded";
+          s.pendingId = undefined;
+        }
+        recovery.state = "cancelled";
+        recovery.cancellationReason = d.assessment;
+        s.recoveryId = undefined;
+      }
       if (a?.state === "outstanding") {
         check(d.supersededAssignmentId === a.id && d.outcome !== "accepted", "supersession_required");
         a.state = "superseded";
@@ -602,7 +819,7 @@ function applyEvent(state: State, event: RoutingEvent, owned = false): State {
     case "sources-exposed": {
       const x = s.executions.get(d.executionId);
       check(x && x.profile === d.view, "exposure_execution_missing");
-      if (d.view === "executor") for (const source of d.sources) s.exposure.set(source.ref, source.bodyHash);
+      if (isWorkerProfile(d.view)) for (const source of d.sources) s.exposure.set(source.ref, source.bodyHash);
       break;
     }
   }