@yielded/agent 0.1.0-beta.173 → 0.1.0-beta.175

package/src/durable/ThreadWork.ts

@@ -1,4 +1,3 @@
-import type { Crypto } from "effect";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
 
 import { ReceiptId, RunId, SubmissionId, ThreadId, ToolCallId } from "../core/Identifiers.ts";
@@ -145,6 +144,10 @@ export const ThreadWorkCursor = Schema.Struct({
 
 export type ThreadWorkCursor = typeof ThreadWorkCursor.Type;
 
+/** Local snapshot request; it grants no claim or dispatch authority. */
+export const FreshAdmissionWork = Schema.Struct({ threadId: ThreadId, submissionId: SubmissionId });
+export type FreshAdmissionWork = typeof FreshAdmissionWork.Type;
+
 export const WorkThreadsRequest = Schema.Struct({
   afterThreadId: Schema.optionalKey(ThreadId),
   limit: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 32 })),
@@ -193,6 +196,12 @@ export class WorkDiscoveryUnavailable extends Schema.TaggedError<WorkDiscoveryUn
 
 /** Native owner pages and canonical-index maintenance, implemented at the storage owner. */
 export interface ThreadWorkStorage {
+  /** Native proof that this untouched root admission has no other recovery obligations.
+   * A caller must still claim and validate current controls before dispatch. */
+  readonly isOnlyFreshAdmission?: (
+    request: FreshAdmissionWork,
+  ) => Effect.Effect<boolean, ThreadStoreError>;
+
   readonly threads: (
     request: WorkThreadsRequest,
   ) => Effect.Effect<WorkThreadsPage, ThreadStoreError>;
@@ -487,7 +496,7 @@ export type WorkIndexChange =
 export const workIndexChanges = Effect.fnUntraced(function* (
   envelope: CanonicalRecordEnvelope,
   reporting: WorkerReportingMode,
-): Effect.fn.Return<ReadonlyArray<WorkIndexChange>, ThreadStoreError, Crypto.Crypto> {
+): Effect.fn.Return<ReadonlyArray<WorkIndexChange>, ThreadStoreError> {
   const { record, sequence } = envelope;
   const payload = record.payload;
 

package/src/durable/WakeScheduler.ts

@@ -1,5 +1,5 @@
 import type { Scope } from "effect";
-import { Context, Deferred, Effect, Layer, Ref, Stream } from "effect";
+import { Context, Deferred, Effect, Layer, Stream } from "effect";
 
 import { type ThreadId } from "../core/Identifiers.ts";
 
@@ -17,79 +17,47 @@ export interface WakeSubscriptionHub {
   readonly notify: (threadId: ThreadId) => Effect.Effect<void>;
 }
 
-interface WakeRegistration {
-  readonly id: number;
-  readonly deferred: Deferred.Deferred<void>;
-}
-
-type WakeRegistrations = ReadonlyMap<ThreadId, ReadonlyMap<number, Deferred.Deferred<void>>>;
-
 /**
  * Build the shared per-incarnation registration primitive used by host WakeSchedulers. The hub
  * contains hints only: eviction may discard it, while a reconnecting caller re-subscribes and
  * rechecks canonical storage. Scope finalizers remove cancelled waiters, and notify broadcasts
  * instead of consuming a signal that belongs to another waiter.
  */
-export const makeWakeSubscriptionHub: Effect.Effect<WakeSubscriptionHub> = Effect.gen(function* () {
-  const registrations = yield* Ref.make<WakeRegistrations>(new Map());
-  const nextId = yield* Ref.make(0);
-
-  const remove = (threadId: ThreadId, id: number) =>
-    Ref.update(registrations, (current) => {
-      const existing = current.get(threadId);
-
-      if (existing === undefined || !existing.has(id)) return current;
-      const next = new Map(current);
-      const thread = new Map(existing);
-
-      thread.delete(id);
-      if (thread.size === 0) {
-        next.delete(threadId);
-      } else {
-        next.set(threadId, thread);
-      }
-
-      return next;
+export const makeWakeSubscriptionHub: Effect.Effect<WakeSubscriptionHub> = Effect.sync(() => {
+  const registrations = new Map<ThreadId, Set<Deferred.Deferred<void>>>();
+
+  const subscribe = (threadId: ThreadId) =>
+    Effect.acquireRelease(
+      Effect.sync(() => {
+        const deferred = Deferred.makeUnsafe<void>();
+        let waiters = registrations.get(threadId);
+
+        if (waiters === undefined) {
+          waiters = new Set();
+          registrations.set(threadId, waiters);
+        }
+        waiters.add(deferred);
+
+        return deferred;
+      }),
+      (deferred) =>
+        Effect.sync(() => {
+          const waiters = registrations.get(threadId);
+
+          if (waiters?.delete(deferred) && waiters.size === 0) registrations.delete(threadId);
+        }),
+    ).pipe(Effect.map(Deferred.await));
+
+  const notify = (threadId: ThreadId) =>
+    Effect.sync(() => {
+      const waiters = registrations.get(threadId);
+
+      if (waiters === undefined) return;
+      // Detach before resuming: a resumed waiter may register its next wait immediately.
+      registrations.delete(threadId);
+      for (const waiter of waiters) Deferred.doneUnsafe(waiter, Effect.void);
     });
 
-  const subscribe = Effect.fnUntraced(function* (
-    threadId: ThreadId,
-  ): Effect.fn.Return<Effect.Effect<void>, never, Scope.Scope> {
-    const deferred = yield* Deferred.make<void>();
-    const id = yield* Ref.getAndUpdate(nextId, (current) => current + 1);
-    const registration: WakeRegistration = { id, deferred };
-
-    yield* Effect.addFinalizer(() => remove(threadId, registration.id));
-    yield* Ref.update(registrations, (current) => {
-      const next = new Map(current);
-      const thread = new Map(current.get(threadId) ?? []);
-
-      thread.set(registration.id, registration.deferred);
-      next.set(threadId, thread);
-
-      return next;
-    });
-
-    return Deferred.await(registration.deferred);
-  });
-
-  const notify = Effect.fnUntraced(function* (threadId: ThreadId) {
-    const waiters = yield* Ref.modify(registrations, (current) => {
-      const thread = current.get(threadId);
-
-      if (thread === undefined) return [[], current] as const;
-      const next = new Map(current);
-
-      next.delete(threadId);
-
-      return [[...thread.values()], next] as const;
-    });
-
-    yield* Effect.forEach(waiters, (waiter) => Deferred.succeed(waiter, undefined), {
-      discard: true,
-    });
-  });
-
   return { subscribe, notify };
 });
 

package/src/durable/internal/StorageOwner.ts

@@ -52,9 +52,13 @@ export const makeStorageOwner = Effect.fnUntraced(function* (gate: MutationGate)
   const active = new Map<string, { readonly claim: Claim; closed: boolean }>();
 
   const withMutation: MutationGate = (effect) =>
-    Effect.flatMap(ActiveOwner, (current) =>
-      current === identity ? effect : gate(Effect.provideService(effect, ActiveOwner, identity)),
-    );
+    Effect.withFiber((fiber) => {
+      const current = fiber.getRef(ActiveOwner);
+
+      return current === identity
+        ? effect
+        : gate(Effect.provideService(effect, ActiveOwner, identity));
+    });
 
   yield* Effect.addFinalizer(() =>
     withMutation(
@@ -70,7 +74,9 @@ export const makeStorageOwner = Effect.fnUntraced(function* (gate: MutationGate)
     identity,
     withMutation,
     withProgress: (threadId, effect) =>
-      Effect.flatMap(ActiveProgress, (current) => {
+      Effect.withFiber((fiber) => {
+        const current = fiber.getRef(ActiveProgress);
+
         if (current?.owner === identity && current.threadId === threadId) return effect;
 
         return Effect.suspend(() => {

package/src/durable/internal/agent-registration.ts

@@ -105,6 +105,11 @@ export const toolReplayContracts = Effect.fnUntraced(function* (
   // different host Crypto service must never inherit another host's digest map.
   const crypto = Option.getOrUndefined(yield* Effect.serviceOption(Crypto.Crypto));
 
+  const invalidContracts = () =>
+    DigestError.make({
+      message: "Operation contracts require serializable codecs and a version for every Tool",
+    });
+
   const prepared = yield* Effect.try({
     try: () => {
       const tools = Object.values(definition.toolkit.tools);
@@ -146,16 +151,38 @@ export const toolReplayContracts = Effect.fnUntraced(function* (
         return projection;
       };
 
-      const declarations = tools.map((tool) => {
-        const version = versions === undefined ? fallbackVersion : versions.tools[tool.name];
+      return {
+        _tag: "Compile" as const,
+        jsonSchema,
+        cacheable,
+        tools,
+        completionTool,
+        completionFromTools,
+      };
+    },
+    catch: () =>
+      DigestError.make({
+        message: "Operation contracts require serializable codecs and a version for every Tool",
+      }),
+  });
+
+  if (prepared._tag === "Cached") return prepared.contracts;
 
-        if (
-          version === undefined ||
-          (versions !== undefined && !Object.hasOwn(versions.tools, tool.name))
-        )
-          throw new Error("Every Tool needs an explicit replay semantic version");
+  const declarations = yield* Effect.forEach(
+    prepared.tools,
+    Effect.fnUntraced(function* (tool) {
+      const { version, present } = yield* Effect.try({
+        try: () => ({
+          version: versions === undefined ? fallbackVersion : versions.tools[tool.name],
+          present: versions === undefined || Object.hasOwn(versions.tools, tool.name),
+        }),
+        catch: invalidContracts,
+      });
 
-        return {
+      if (version === undefined || !present) return yield* invalidContracts();
+
+      return yield* Effect.try({
+        try: () => ({
           name: tool.name,
           contract: {
             version,
@@ -170,9 +197,9 @@ export const toolReplayContracts = Effect.fnUntraced(function* (
                   readonly: Context.get(tool.annotations, Tool.Readonly),
                 }
               : {}),
-            parameters: jsonSchema(tool.parametersSchema),
-            success: jsonSchema(tool.successSchema),
-            failure: jsonSchema(tool.failureSchema),
+            parameters: prepared.jsonSchema(tool.parametersSchema),
+            success: prepared.jsonSchema(tool.successSchema),
+            failure: prepared.jsonSchema(tool.failureSchema),
             failureMode: tool.failureMode,
             needsApproval:
               typeof tool.needsApproval === "function" ? "dynamic" : (tool.needsApproval ?? false),
@@ -185,28 +212,14 @@ export const toolReplayContracts = Effect.fnUntraced(function* (
                 (declaration) => declaration.tool === tool.name,
               ) ?? false,
           },
-        };
+        }),
+        catch: invalidContracts,
       });
-
-      return {
-        _tag: "Compile" as const,
-        declarations,
-        cacheable,
-        tools,
-        completionTool,
-        completionFromTools,
-      };
-    },
-    catch: () =>
-      DigestError.make({
-        message: "Operation contracts require serializable codecs and a version for every Tool",
-      }),
-  });
-
-  if (prepared._tag === "Cached") return prepared.contracts;
+    }),
+  );
 
   const contracts = Object.fromEntries(
-    yield* Effect.forEach(prepared.declarations, ({ name, contract }) =>
+    yield* Effect.forEach(declarations, ({ name, contract }) =>
       digestJson(contract).pipe(Effect.map((digest) => [name, digest] as const)),
     ),
   );
@@ -365,7 +378,7 @@ const omitTraceContext = Context.omit(
 const withoutTraceContext = <R>(context: Context.Context<R>): Context.Context<R> =>
   omitTraceContext(context) as Context.Context<R>;
 
-const captureReporting = <R>(reports: ReadonlyArray<WorkerReporting<unknown, R>>) =>
+const captureReporting = <E, R>(reports: ReadonlyArray<WorkerReporting<E, R>>) =>
   Effect.map(
     Effect.context<Exclude<R, Scope.Scope>>().pipe(Effect.map(withoutTraceContext)),
     (context) =>
@@ -405,18 +418,19 @@ export interface AgentAttemptContext {
   readonly attemptId: Claim["attemptId"];
 }
 
-const capture = <A extends ExecutableAgentBinding, Provides = never, Requires = never>(
+const capture = <A extends ExecutableAgentBinding, Requires>(
   agent: A,
-  attemptLayer?: (context: AgentAttemptContext) => Layer.Layer<Provides, never, Requires>,
-): Effect.Effect<
-  CapturedBinding,
-  never,
-  Exclude<DurableWorkerRequirements<A>, Provides> | Requires
-> =>
+  prepare: (
+    execute: ReturnType<CapturedAttempt<A>>,
+    context: AgentAttemptContext,
+  ) => Effect.Effect<
+    Option.Option<Settlement>,
+    DurableWorkerFailure | DurableBindingFailure,
+    Requires
+  >,
+): Effect.Effect<CapturedBinding, never, Requires> =>
   Effect.map(
-    Effect.context<Exclude<DurableWorkerRequirements<A>, Provides> | Requires>().pipe(
-      Effect.map(withoutTraceContext),
-    ),
+    Effect.context<Requires>().pipe(Effect.map(withoutTraceContext)),
     (context): CapturedBinding => ({
       agentId: agent.definition.id,
       definition: agent.definition,
@@ -433,29 +447,23 @@ const capture = <A extends ExecutableAgentBinding, Provides = never, Requires =
           claim.attemptId,
         );
 
-        const scoped =
-          attemptLayer === undefined
-            ? execute
-            : execute.pipe(
-                Effect.provide(
-                  Layer.fresh(
-                    attemptLayer({
-                      threadId,
-                      submissionId: claim.submissionId,
-                      attemptId: claim.attemptId,
-                    }),
-                  ),
-                ),
-              );
-
-        return scoped.pipe(Effect.provide(context)) as Effect.Effect<
-          Option.Option<Settlement>,
-          DurableWorkerFailure | DurableBindingFailure
-        >;
+        return prepare(execute, {
+          threadId,
+          submissionId: claim.submissionId,
+          attemptId: claim.attemptId,
+        }).pipe(Effect.provide(context));
       },
     }),
   );
 
+const captureWithAttemptLayer = <A extends ExecutableAgentBinding, Provides, Requires>(
+  agent: A,
+  attemptLayer: (context: AgentAttemptContext) => Layer.Layer<Provides, never, Requires>,
+) =>
+  capture(agent, (execute, context) =>
+    execute.pipe(Effect.provide(Layer.fresh(attemptLayer(context)))),
+  );
+
 /**
  * Build one exact worker registration from an executable Agent Binding and
  * its already-computed definition digests.
@@ -471,7 +479,7 @@ export const DurableWorkerBinding = {
     digests: DefinitionDigests,
   ): Effect.Effect<ResolvedBinding, never, DurableWorkerRequirements<A>> =>
     Effect.gen(function* () {
-      const binding = yield* capture(agent);
+      const binding = yield* capture(agent, (execute) => execute);
       const reporting = yield* captureReporting(backgroundReports(agent.definition));
 
       return { ...binding, digests, reporting };
@@ -479,7 +487,8 @@ export const DurableWorkerBinding = {
 } as const;
 
 /** INTERNAL identity-only capture retained for the legacy direct worker path. */
-export const makeLegacyWorkerBinding = capture;
+export const makeLegacyWorkerBinding = <A extends ExecutableAgentBinding>(agent: A) =>
+  capture(agent, (execute) => execute);
 
 export const resolveWorkerBinding = Effect.fnUntraced(function* (
   bindings: ReadonlyArray<ResolvedBinding>,
@@ -576,11 +585,9 @@ type EntryRequirements<Entry> = Entry extends unknown
     >
   : never;
 
-type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = [
-  Entries[number],
-] extends [never]
-  ? never
-  : EntryRequirements<Entries[number]>;
+type RegistrationRequirements<Entries extends ReadonlyArray<AgentRegistration>> = EntryRequirements<
+  Entries[number]
+>;
 
 const registrationDefinitions = (entry: AgentRegistration): DefinitionDigestInput => {
   const definition = entry.model === undefined ? entry.agent.definition : entry.agent;
@@ -655,10 +662,13 @@ const registrationDefinitions = (entry: AgentRegistration): DefinitionDigestInpu
   };
 };
 
-const compileRegistration = <Entry extends AgentRegistration>(
+// The public signature distributes over descriptors, including optional attempt Layers.
+// The implementation consumes their erased union and captures the selected Layer's context.
+function compileRegistration<Entry extends AgentRegistration>(
   entry: Entry,
-): Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>> =>
-  Effect.flatMap(
+): Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>>;
+function compileRegistration(entry: AgentRegistration) {
+  return Effect.flatMap(
     Effect.try({
       try: () => registrationDefinitions(entry),
       catch: () =>
@@ -666,10 +676,19 @@ const compileRegistration = <Entry extends AgentRegistration>(
     }),
     (definitions) =>
       Effect.gen(function* () {
-        const binding = yield* capture(
-          entry.model === undefined ? entry.agent : { definition: entry.agent, model: entry.model },
-          entry.attemptLayer,
-        );
+        const agent =
+          // The heterogeneous descriptor erases model services; the overload retains EntryRequirements.
+          // @effect-diagnostics-next-line anyUnknownInErrorContext:off
+          entry.model === undefined ? entry.agent : { definition: entry.agent, model: entry.model };
+
+        // Omitted attempt services need no Layer construction or provisioning scope.
+        const binding = yield* entry.attemptLayer === undefined
+          ? // Capture closes the erased requirements over the registration's actual Context.
+            // @effect-diagnostics-next-line anyUnknownInErrorContext:off
+            capture(agent, (execute) => execute)
+          : // The selected Layer discharges its services before the remaining Context is captured.
+            // @effect-diagnostics-next-line anyUnknownInErrorContext:off
+            captureWithAttemptLayer(agent, entry.attemptLayer);
 
         const reporting = yield* captureReporting(backgroundReports(binding.definition));
 
@@ -683,9 +702,8 @@ const compileRegistration = <Entry extends AgentRegistration>(
           reporting,
         };
       }),
-    // The erased descriptor accepts arbitrary provided services. Restore the concrete entry's
-    // Exclude<worker requirements, provided services> | layer requirements at this collection seam.
-  ) as Effect.Effect<ResolvedBinding, DigestError, Crypto.Crypto | EntryRequirements<Entry>>;
+  );
+}
 
 /** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */
 export const compileRegistrations = <const Entries extends ReadonlyArray<AgentRegistration>>(
@@ -695,16 +713,5 @@ export const compileRegistrations = <const Entries extends ReadonlyArray<AgentRe
   DigestError,
   Crypto.Crypto | RegistrationRequirements<Entries>
 > => {
-  // `Effect.forEach` instantiates a generic callback at its constraint. Specialize the callback to
-  // this tuple's distributed requirement union before collection so empty and heterogeneous tuples
-  // retain their exact service requirements.
-  const compileEntry = compileRegistration as unknown as (
-    entry: Entries[number],
-  ) => Effect.Effect<
-    ResolvedBinding,
-    DigestError,
-    Crypto.Crypto | RegistrationRequirements<Entries>
-  >;
-
-  return Effect.forEach(entries, compileEntry);
+  return Effect.forEach(entries, compileRegistration<Entries[number]>);
 };

package/src/durable/internal/canonical-json.ts

@@ -1,4 +1,4 @@
-import { Array, type Schema } from "effect";
+import { Array, Predicate, Result, Schema } from "effect";
 
 interface JsonLimits {
   readonly depth: number;
@@ -7,19 +7,36 @@ interface JsonLimits {
   readonly textUnits: number;
 }
 
+export class CanonicalJsonLimitError extends Schema.TaggedError<CanonicalJsonLimitError>()(
+  "CanonicalJsonLimitError",
+  { message: Schema.String },
+) {}
+
+// Only this codec's private synchronous aborts become typed bounds failures.
+const boundsFailures = new WeakMap<object, string>();
+
+const exceeded = (bound: "text" | "traversal" | "collection"): never => {
+  const message = `Canonical JSON exceeds its ${bound} bound`;
+  // oxlint-disable-next-line effect/no-native-error -- Private synchronous codec abort; the Result boundary translates only errors owned here.
+  const error = new RangeError(message);
+
+  boundsFailures.set(error, message);
+  // oxlint-disable-next-line effect/no-untyped-throw -- Abort synchronous JSON traversal at the first exceeded bound; the Result boundary catches this owned error.
+  throw error;
+};
+
 /** Values have already crossed their Schema boundary; visit each serialized occurrence. */
-export const canonicalJson = (value: Schema.Json, limits?: JsonLimits): string => {
+const serialize = (value: Schema.Json, limits?: JsonLimits): string => {
   let nodes = 0;
   let textUnits = 0;
 
   const charge = (length: number) => {
-    if (limits !== undefined && (textUnits += length) > limits.textUnits)
-      throw new RangeError("Canonical JSON exceeds its text bound");
+    if (limits !== undefined && (textUnits += length) > limits.textUnits) return exceeded("text");
   };
 
   const visit = (value: Schema.Json, depth: number): string => {
     if (limits !== undefined && (depth > limits.depth || ++nodes > limits.nodes))
-      throw new RangeError("Canonical JSON exceeds its traversal bound");
+      return exceeded("traversal");
     if (
       value === null ||
       typeof value === "boolean" ||
@@ -34,30 +51,54 @@ export const canonicalJson = (value: Schema.Json, limits?: JsonLimits): string =
     }
     if (Array.isArray<Schema.Json>(value)) {
       if (limits !== undefined && value.length > limits.collectionLength)
-        throw new RangeError("Canonical JSON exceeds its collection bound");
+        return exceeded("collection");
       charge(2 + Math.max(0, value.length - 1));
 
-      return `[${globalThis.Array.from(value, (entry) => visit(entry, depth + 1)).join(",")}]`;
+      let json = "[";
+
+      for (let index = 0; index < value.length; index++) {
+        if (index > 0) json += ",";
+        json += visit(value[index], depth + 1);
+      }
+
+      return `${json}]`;
     }
 
-    const entries = Object.entries(value).sort(([left], [right]) =>
-      left < right ? -1 : left > right ? 1 : 0,
-    );
+    const keys = Object.keys(value).sort();
 
-    if (limits !== undefined && entries.length > limits.collectionLength)
-      throw new RangeError("Canonical JSON exceeds its collection bound");
-    charge(2 + Math.max(0, entries.length - 1));
+    if (limits !== undefined && keys.length > limits.collectionLength)
+      return exceeded("collection");
+    charge(2 + Math.max(0, keys.length - 1));
+    let json = "{";
 
-    return `{${entries
-      .map(([key, entry]) => {
-        const encodedKey = JSON.stringify(key);
+    for (let index = 0; index < keys.length; index++) {
+      const key = keys[index];
+      const encodedKey = JSON.stringify(key);
 
-        charge(encodedKey.length + 1);
+      charge(encodedKey.length + 1);
+      if (index > 0) json += ",";
+      json += `${encodedKey}:${visit(value[key], depth + 1)}`;
+    }
 
-        return `${encodedKey}:${visit(entry, depth + 1)}`;
-      })
-      .join(",")}}`;
+    return `${json}}`;
   };
 
   return visit(value, 0);
 };
+
+export const canonicalJson = (value: Schema.Json): string => serialize(value);
+
+export const boundedCanonicalJson = (
+  value: Schema.Json,
+  limits: JsonLimits,
+): Result.Result<string, CanonicalJsonLimitError> => {
+  try {
+    return Result.succeed(serialize(value, limits));
+  } catch (cause) {
+    const message = Predicate.isObjectKeyword(cause) ? boundsFailures.get(cause) : undefined;
+
+    if (message !== undefined) return Result.fail(CanonicalJsonLimitError.make({ message }));
+    // oxlint-disable-next-line effect/no-untyped-throw -- Foreign JSON/getter errors retain their identity for the caller's typed capture boundary.
+    throw cause;
+  }
+};

package/src/durable/internal/prompt-history-cache.ts

@@ -1,4 +1,4 @@
-import { Effect, Option, Schema, Stream } from "effect";
+import { Effect, Option, Result, Schema, Stream } from "effect";
 import { Prompt } from "effect/ai";
 
 import type { RunId, ThreadId } from "../../core/Identifiers.ts";
@@ -87,7 +87,8 @@ function hydratePart(part: Prompt.PartEncoded): Prompt.Part {
     case "tool-approval-response":
       return Prompt.toolApprovalResponsePart(part);
   }
-  throw new Error(`Unhandled Prompt part: ${part satisfies never}`);
+
+  return part satisfies never;
 }
 
 const hydrateMessage = (message: Prompt.MessageEncoded): Prompt.Message => {
@@ -116,7 +117,8 @@ const hydrateMessage = (message: Prompt.MessageEncoded): Prompt.Message => {
         content: message.content.map((p) => hydratePart(p)),
       });
   }
-  throw new Error(`Unhandled Prompt message: ${message satisfies never}`);
+
+  return message satisfies never;
 };
 
 export interface PromptHistory {
@@ -291,7 +293,14 @@ export const makeCommittedPromptSuffix = (original: CanonicalRecordEnvelope) =>
     // as readPrompt, never raw provider values. Failure invalidates this derivative, not the commit.
     try {
       for (const fact of facts) {
-        const owned = captureRecord(fact);
+        const captured = captureRecord(fact);
+
+        if (Result.isFailure(captured)) {
+          discard();
+
+          return;
+        }
+        const owned = captured.success;
         const payload = owned.canonical.payload;
 
         if (