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

package/src/durable/RunJournal.ts

@@ -1,4 +1,4 @@
-import { Brand, type Crypto, Effect, Predicate, Schema, Stream, type DateTime } from "effect";
+import { Brand, Effect, Predicate, Schema, Stream, type DateTime } from "effect";
 import { Prompt } from "effect/ai";
 
 import {
@@ -13,7 +13,7 @@ import { type ExhaustedLimit } from "../core/RunEvent.ts";
 import { RunPolicyUsage } from "../core/RunPolicyUsage.ts";
 import { type Selection, type Snapshot } from "../core/ToolExposure.ts";
 import type { ToolParameterRejection } from "../core/ToolResult.ts";
-import { ModelCallUsage, summarizeModelUsage, type RunUsageSummary } from "../core/Usage.ts";
+import { type ModelCallUsage, summarizeModelUsage, type RunUsageSummary } from "../core/Usage.ts";
 import type { WorkerRef } from "../core/Worker.ts";
 import {
   CLEARED_TOOL_RESULT,
@@ -22,13 +22,14 @@ import {
   contextWindowMessage,
 } from "../engine/Compaction.ts";
 import type { RunTurnToolResult } from "../engine/RunOptions.ts";
-import { digestJson, type DigestError } from "./Digest.ts";
+import { digestJson } from "./Digest.ts";
 import {
   makeJournalMetadata,
   toolCallSettledRecordId,
   type JournalMetadata,
   type JournalRecordEnvelope,
 } from "./internal/journal-metadata.ts";
+import { continuationUsage } from "./internal/usage-totals.ts";
 import {
   type BatchId,
   type RecordId,
@@ -435,6 +436,36 @@ export interface RunJournalProjection {
   readonly pendingContextToolCallId?: string | undefined;
 }
 
+const initialPolicyUsage = () => ({
+  committedTurns: 0,
+  toolCalls: 0,
+  programmaticToolCalls: 0,
+  consecutiveToolFailures: 0,
+  finalizationUsed: false,
+  modelRestarts: 0,
+});
+
+const initialUsage = (modelUsage: Array<ModelCallUsage>) => ({
+  modelCalls: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  lastInputTokens: 0,
+  lastOutputTokens: 0,
+  costMicrousd: 0,
+  modelUsage,
+});
+
+/** Internal first-Run projection after exact input/checkpoint-absence verification. The
+ * new UserInputRecorded contributes no model message; the engine evaluates it later. */
+export const initialRunJournal = (history: Prompt.Prompt): RunJournalProjection => ({
+  policyUsage: RunPolicyUsage.make(initialPolicyUsage()),
+  usage: initialUsage([]),
+  prompt: history,
+  historyBefore: history,
+  historyFrom: CanonicalSequence.make(1),
+  committedTurns: 0,
+});
+
 interface ProjectedResponseUsage {
   readonly modelCalls: number;
   readonly inputTokens: number;
@@ -1049,15 +1080,7 @@ export const projectRunJournalStream = Effect.fnUntraced(function* <
   const modelUsage: Array<ModelCallUsage> = [];
   let unobservedModelCalls = 0;
 
-  const usage = {
-    modelCalls: 0,
-    inputTokens: 0,
-    outputTokens: 0,
-    lastInputTokens: 0,
-    lastOutputTokens: 0,
-    costMicrousd: 0,
-    modelUsage,
-  };
+  const usage = initialUsage(modelUsage);
 
   let toolSelection: Selection | undefined;
   let usageTurn = 0;
@@ -1079,14 +1102,7 @@ export const projectRunJournalStream = Effect.fnUntraced(function* <
   let pendingContextToolCallId: string | undefined;
   let ownerTerminated = false;
 
-  const policyUsage = {
-    committedTurns: 0,
-    toolCalls: 0,
-    programmaticToolCalls: 0,
-    consecutiveToolFailures: 0,
-    finalizationUsed: false,
-    modelRestarts: 0,
-  };
+  const policyUsage = initialPolicyUsage();
 
   const accountResponse = Effect.fnUntraced(function* (
     envelope: JournalRecordEnvelope,
@@ -1638,18 +1654,6 @@ export const promptFromCanonicalRecords = (
   );
 
 /** Everything one committed Turn contributes to its canonical batch. */
-/**
- * Staged usage is validated, never repaired: clamping negatives or truncating
- * fractions would under-record canonical usage, and NaN/Infinity must fail
- * typed instead of escaping as a record-construction defect (RUN-023).
- */
-const validStagedUsage = (label: string, value: number): Effect.Effect<number, RunJournalError> =>
-  Number.isSafeInteger(value) && value >= 0
-    ? Effect.succeed(value)
-    : Effect.fail(
-        journalError(`Staged ${label} must be a non-negative safe integer, got ${String(value)}`),
-      );
-
 export interface TurnCommitInput {
   readonly toolResultMaxBytes?: number | undefined;
   readonly toolSelectionMaxBytes?: number | undefined;
@@ -1694,8 +1698,9 @@ export interface TurnCommitInput {
 }
 
 const decodePersistedJson = Schema.decodeUnknownEffect(PersistedJson);
+const decodeModelResponse = Schema.decodeUnknownEffect(ModelResponseRecorded);
+const decodeToolSettled = Schema.decodeUnknownEffect(ToolCallSettled);
 const encodePrompt = Schema.encodeEffect(Prompt.Prompt);
-const decodeModelUsage = Schema.decodeUnknownEffect(Schema.Array(ModelCallUsage));
 
 const requireCanonicalTurn = (turn: number): Effect.Effect<void, RunJournalError> =>
   !Number.isInteger(turn) || turn <= 0
@@ -1704,7 +1709,7 @@ const requireCanonicalTurn = (turn: number): Effect.Effect<void, RunJournalError
 
 const modelResponseRecord = Effect.fnUntraced(function* (
   input: TurnCommitInput,
-): Effect.fn.Return<RecordEnvelope, RunJournalError | DigestError, Crypto.Crypto> {
+): Effect.fn.Return<RecordEnvelope, RunJournalError> {
   const promptMessages = input.responseMessages;
 
   if (promptMessages.length === 0) {
@@ -1741,30 +1746,60 @@ const modelResponseRecord = Effect.fnUntraced(function* (
     ),
   );
 
-  const modelUsage =
-    input.usage?.modelUsage === undefined
-      ? undefined
-      : yield* decodeModelUsage(input.usage.modelUsage).pipe(
-          Effect.mapError((cause) => journalError("Turn model usage failed to decode", cause)),
-        );
+  // Validate the detached messages and usage together; no mutable caller data is trusted.
+  const modelUsage = input.usage?.modelUsage;
 
-  if (modelUsage !== undefined) {
-    if (modelUsage.length === 0) {
+  const payload = yield* decodeModelResponse({
+    _tag: "ModelResponseRecorded",
+    toolResultMaxBytes: input.toolResultMaxBytes ?? MAX_PERSISTED_JSON_BYTES,
+    toolSelectionMaxBytes: input.toolSelectionMaxBytes ?? 0,
+    toolOperations: input.toolOperations ?? [],
+    ...(input.toolParameterRejections === undefined || input.toolParameterRejections.length === 0
+      ? {}
+      : { toolParameterRejections: input.toolParameterRejections }),
+    ...(input.toolExposure === undefined ? {} : { toolExposure: input.toolExposure }),
+    runId: input.runId,
+    turnId: input.turnId,
+    turn: input.turn,
+    messages,
+    ...(runScopedPrefixLength === undefined ? {} : { runScopedPrefixLength }),
+    ...(modelUsage === undefined ? {} : { modelUsage }),
+    ...(input.unobservedModelCalls === undefined || input.unobservedModelCalls === 0
+      ? {}
+      : {
+          unobservedModelCalls: input.unobservedModelCalls,
+        }),
+    ...(input.usage === undefined
+      ? {}
+      : {
+          inputTokens: input.usage.inputTokens,
+          outputTokens: input.usage.outputTokens,
+          // Written only when non-zero: absent re-seeds as zero, so the
+          // no-estimator case stays byte-identical to pre-cost histories.
+          ...(input.usage.costMicrousd === undefined || input.usage.costMicrousd === 0
+            ? {}
+            : {
+                costMicrousd: input.usage.costMicrousd,
+              }),
+        }),
+  }).pipe(
+    Effect.mapError((cause) => journalError("Invalid model response operation evidence", cause)),
+  );
+
+  if (payload.modelUsage !== undefined) {
+    if (payload.modelUsage.length === 0)
       return yield* journalError("Turn model usage must contain at least one completed call");
-    }
 
-    const summary = yield* summarizeModelUsage(modelUsage).pipe(
+    const summary = yield* continuationUsage(payload.modelUsage).pipe(
       Effect.mapError((cause) => journalError("Turn model usage exceeds accounting bounds", cause)),
     );
 
     if (
-      input.usage === undefined ||
-      input.usage.inputTokens !== summary.inputTokens.total ||
-      input.usage.outputTokens !== summary.outputTokens.total ||
-      (input.usage.costMicrousd ?? 0) !== summary.costMicrousd
-    ) {
+      payload.inputTokens !== summary.inputTokens ||
+      payload.outputTokens !== summary.outputTokens ||
+      (payload.costMicrousd ?? 0) !== summary.costMicrousd
+    )
       return yield* journalError("Turn detailed and aggregate model usage disagree");
-    }
   }
 
   return RecordEnvelope.make({
@@ -1773,44 +1808,7 @@ const modelResponseRecord = Effect.fnUntraced(function* (
     schemaVersion: 1,
     createdAt: input.createdAt,
     deploymentId: input.deploymentId,
-    payload: yield* ModelResponseRecorded.makeEffect({
-      toolResultMaxBytes: input.toolResultMaxBytes ?? MAX_PERSISTED_JSON_BYTES,
-      toolSelectionMaxBytes: input.toolSelectionMaxBytes ?? 0,
-      toolOperations: input.toolOperations ?? [],
-      ...(input.toolParameterRejections === undefined || input.toolParameterRejections.length === 0
-        ? {}
-        : { toolParameterRejections: input.toolParameterRejections }),
-      ...(input.toolExposure === undefined ? {} : { toolExposure: input.toolExposure }),
-      runId: input.runId,
-      turnId: input.turnId,
-      turn: input.turn,
-      messages,
-      ...(runScopedPrefixLength === undefined ? {} : { runScopedPrefixLength }),
-      ...(modelUsage === undefined ? {} : { modelUsage }),
-      ...(input.unobservedModelCalls === undefined || input.unobservedModelCalls === 0
-        ? {}
-        : {
-            unobservedModelCalls: yield* validStagedUsage(
-              "unobservedModelCalls",
-              input.unobservedModelCalls,
-            ),
-          }),
-      ...(input.usage === undefined
-        ? {}
-        : {
-            inputTokens: yield* validStagedUsage("inputTokens", input.usage.inputTokens),
-            outputTokens: yield* validStagedUsage("outputTokens", input.usage.outputTokens),
-            // Written only when non-zero: absent re-seeds as zero, so the
-            // no-estimator case stays byte-identical to pre-cost histories.
-            ...(input.usage.costMicrousd === undefined || input.usage.costMicrousd === 0
-              ? {}
-              : {
-                  costMicrousd: yield* validStagedUsage("costMicrousd", input.usage.costMicrousd),
-                }),
-          }),
-    }).pipe(
-      Effect.mapError((cause) => journalError("Invalid model response operation evidence", cause)),
-    ),
+    payload,
   });
 });
 
@@ -1820,33 +1818,27 @@ const toolSettledRecords = Effect.fnUntraced(function* (
   const toolRecords: Array<RecordEnvelope> = [];
 
   for (const part of input.toolResults) {
-    const result = yield* decodePersistedJson(part.result).pipe(
-      Effect.mapError((cause) =>
-        journalError(`Tool result ${part.toolCallId} exceeds canonical persistence bounds`, cause),
-      ),
+    const payload = yield* decodeToolSettled({
+      _tag: "ToolCallSettled",
+      ...(part.toolSelection === undefined ? {} : { toolSelection: part.toolSelection }),
+      runId: input.runId,
+      toolCallId: part.toolCallId,
+      toolName: part.toolName,
+      result: part.result,
+      isFailure: part.isFailure,
+      ...(part.budgetRejected === true ? { budgetRejected: true } : {}),
+    }).pipe(
+      Effect.mapError((cause) => journalError(`Invalid Tool result ${part.toolCallId}`, cause)),
     );
 
-    const toolCallId = yield* Effect.try({
-      try: () => decodeToolCallId(part.toolCallId),
-      catch: (cause) => journalError(`Invalid Tool Call ID ${part.toolCallId}`, cause),
-    });
-
     toolRecords.push(
       RecordEnvelope.make({
-        recordId: toolCallSettledRecordId(input.runId, input.turn, toolCallId),
+        recordId: toolCallSettledRecordId(input.runId, input.turn, payload.toolCallId),
         family: "thread",
         schemaVersion: 1,
         createdAt: input.createdAt,
         deploymentId: input.deploymentId,
-        payload: ToolCallSettled.make({
-          ...(part.toolSelection === undefined ? {} : { toolSelection: part.toolSelection }),
-          runId: input.runId,
-          toolCallId,
-          toolName: part.toolName,
-          result,
-          isFailure: part.isFailure,
-          ...(part.budgetRejected === true ? { budgetRejected: true } : {}),
-        }),
+        payload,
       }),
     );
   }
@@ -1854,7 +1846,7 @@ const toolSettledRecords = Effect.fnUntraced(function* (
   return toolRecords;
 });
 
-const runCompletionRecord = Effect.fnUntraced(function* (input: TurnCommitInput) {
+const runCompletionRecord = (input: TurnCommitInput) => {
   if (input.runCompletion === undefined) return undefined;
   const completion = { runId: input.runId, ...input.runCompletion };
 
@@ -1868,7 +1860,7 @@ const runCompletionRecord = Effect.fnUntraced(function* (input: TurnCommitInput)
       ...completion,
     }),
   });
-});
+};
 
 /**
  * Build a canonical batch from interpreter-validated Turn facts: one
@@ -1882,11 +1874,11 @@ const runCompletionRecord = Effect.fnUntraced(function* (input: TurnCommitInput)
  */
 export const turnCanonicalBatch = Effect.fnUntraced(function* (
   input: TurnCommitInput,
-): Effect.fn.Return<CanonicalBatch, RunJournalError | DigestError, Crypto.Crypto> {
+): Effect.fn.Return<CanonicalBatch, RunJournalError> {
   yield* requireCanonicalTurn(input.turn);
   const modelResponse = yield* modelResponseRecord(input);
   const toolRecords = yield* toolSettledRecords(input);
-  const completionRecord = yield* runCompletionRecord(input);
+  const completionRecord = runCompletionRecord(input);
 
   return CanonicalBatch.make({
     batchId: turnBatchId(input.runId, input.turn),
@@ -1907,7 +1899,7 @@ export const turnCanonicalBatch = Effect.fnUntraced(function* (
  */
 export const turnResponseBatch = Effect.fnUntraced(function* (
   input: TurnCommitInput,
-): Effect.fn.Return<CanonicalBatch, RunJournalError | DigestError, Crypto.Crypto> {
+): Effect.fn.Return<CanonicalBatch, RunJournalError> {
   yield* requireCanonicalTurn(input.turn);
   const modelResponse = yield* modelResponseRecord(input);
 
@@ -1926,11 +1918,11 @@ export const turnResponseBatch = Effect.fnUntraced(function* (
  */
 export const turnResultsBatch = Effect.fnUntraced(function* (
   input: TurnCommitInput,
-): Effect.fn.Return<CanonicalBatch, RunJournalError | DigestError, Crypto.Crypto> {
+): Effect.fn.Return<CanonicalBatch, RunJournalError> {
   yield* requireCanonicalTurn(input.turn);
   const toolRecords = yield* toolSettledRecords(input);
   const first = toolRecords[0];
-  const completionRecord = yield* runCompletionRecord(input);
+  const completionRecord = runCompletionRecord(input);
 
   if (first === undefined) {
     if (completionRecord === undefined) {

package/src/durable/RunStorage.ts

@@ -113,6 +113,11 @@ export interface RunWriter {
 
 export interface RunStorageSession extends RunWriter, RunOwnership {
   readonly claim: Claim;
+  /** Library-only initialization, before application/model IO. Hold progress before mutation
+   * so the captured controls and this owner's acknowledged input remain one read view. */
+  readonly withInitialization?: <A, E, R>(
+    effect: Effect.Effect<A, E, R>,
+  ) => Effect.Effect<A, E | OwnershipLost, R>;
   readonly refresh: Effect.Effect<void, ThreadStoreFailure>;
   readonly publishSettlement: (
     batch: CanonicalBatch,
@@ -171,71 +176,70 @@ const makeWriter = Effect.fnUntraced(function* (threadId: ThreadId) {
     }),
   );
 
-  const append: RunWriter["append"] = (batch, executions) =>
-    Effect.gen(function* () {
-      const captured = yield* PreparedAppend.capture(
-        AppendRequest.make({
-          threadId,
-          expectedTailSequence: tail.sequence,
-          batch,
-          ...(executions === undefined ? {} : { executions }),
-        }),
-      ).pipe(
-        Effect.mapError((cause) =>
-          ThreadStoreError.make({
-            operation: "capture append",
-            message: cause.message,
-            cause,
-          }),
-        ),
-      );
-
-      return yield* owner.withProgress(
+  const append: RunWriter["append"] = Effect.fnUntraced(function* (batch, executions) {
+    const captured = yield* PreparedAppend.capture(
+      AppendRequest.make({
         threadId,
-        owner.withMutation(
-          Effect.gen(function* () {
-            yield* checkActive;
-            for (let retries = 0; ; retries++) {
-              const result = yield* store
-                .append(
-                  captured.expectedTailSequence === tail.sequence
-                    ? captured
-                    : AppendRequest.make({
-                        ...captured,
-                        expectedTailSequence: tail.sequence,
-                      }),
-                )
-                .pipe(
-                  Effect.catchTag("AppendConflict", (conflict) => {
-                    if (
-                      conflict.reason !== "tail" ||
-                      conflict.actualTailSequence === undefined ||
-                      retries >= 8
-                    )
-                      return Effect.fail(conflict);
-                    tail = { sequence: conflict.actualTailSequence };
-                    if (captured.executions !== undefined) return Effect.fail(conflict);
-
-                    return Effect.succeed(undefined);
-                  }),
-                );
+        expectedTailSequence: tail.sequence,
+        batch,
+        ...(executions === undefined ? {} : { executions }),
+      }),
+    ).pipe(
+      Effect.mapError((cause) =>
+        ThreadStoreError.make({
+          operation: "capture append",
+          message: cause.message,
+          cause,
+        }),
+      ),
+    );
 
-              if (result === undefined) continue;
-              // A historical replay returns its original coordinates, not today's canonical tail.
-              if (result.replayed) yield* refresh;
-              else tail = { sequence: result.lastSequence };
-
-              return result;
-            }
-          }).pipe(
-            // Revoke uncertain writes before releasing the writer's mutation gate.
-            Effect.onError((cause) =>
-              isDefiniteWriteFailure(cause) ? Effect.void : ownership.release,
-            ),
+    return yield* owner.withProgress(
+      threadId,
+      owner.withMutation(
+        Effect.gen(function* () {
+          yield* checkActive;
+          for (let retries = 0; ; retries++) {
+            const result = yield* store
+              .append(
+                captured.expectedTailSequence === tail.sequence
+                  ? captured
+                  : AppendRequest.make({
+                      ...captured,
+                      expectedTailSequence: tail.sequence,
+                    }),
+              )
+              .pipe(
+                Effect.catchTag("AppendConflict", (conflict) => {
+                  if (
+                    conflict.reason !== "tail" ||
+                    conflict.actualTailSequence === undefined ||
+                    retries >= 8
+                  )
+                    return Effect.fail(conflict);
+                  tail = { sequence: conflict.actualTailSequence };
+                  if (captured.executions !== undefined) return Effect.fail(conflict);
+
+                  return Effect.succeed(undefined);
+                }),
+              );
+
+            if (result === undefined) continue;
+            // A historical replay returns its original coordinates, not today's canonical tail.
+            if (result.replayed) yield* refresh;
+            else tail = { sequence: result.lastSequence };
+
+            return result;
+          }
+        }).pipe(
+          // Revoke uncertain writes before releasing the writer's mutation gate.
+          Effect.onError((cause) =>
+            isDefiniteWriteFailure(cause) ? Effect.void : ownership.release,
           ),
         ),
-      );
-    });
+      ),
+    );
+  });
 
   const writer = {
     threadId,
@@ -317,6 +321,8 @@ export const make = Effect.gen(function* () {
             const session: RunStorageSession = {
               ...writer,
               claim: claimed,
+              withInitialization: (effect) =>
+                owner.withProgress(request.threadId, generation.use(effect)),
               release: generation.release,
               refresh: writer.refresh,
               markInputApplied: (marker) =>
@@ -371,73 +377,72 @@ export const make = Effect.gen(function* () {
                       ),
                     ),
                 ),
-              publishSettlement: (batch, executions) =>
-                Effect.gen(function* () {
-                  const captured = yield* PreparedAppend.capture(
-                    AppendRequest.make({
-                      threadId: request.threadId,
-                      expectedTailSequence: (yield* writer.tail).sequence,
-                      batch,
-                      ...(executions === undefined ? {} : { executions }),
+              publishSettlement: Effect.fnUntraced(function* (batch, executions) {
+                const captured = yield* PreparedAppend.capture(
+                  AppendRequest.make({
+                    threadId: request.threadId,
+                    expectedTailSequence: (yield* writer.tail).sequence,
+                    batch,
+                    ...(executions === undefined ? {} : { executions }),
+                  }),
+                ).pipe(
+                  Effect.mapError((cause) =>
+                    LedgerError.make({
+                      operation: "capture settlement",
+                      message: cause.message,
+                      cause,
                     }),
-                  ).pipe(
-                    Effect.mapError((cause) =>
-                      LedgerError.make({
-                        operation: "capture settlement",
-                        message: cause.message,
-                        cause,
-                      }),
-                    ),
-                  );
-
-                  return yield* owner.withProgress(
-                    request.threadId,
-                    owned(
-                      Effect.gen(function* () {
-                        for (let retries = 0; ; retries++) {
-                          const result = yield* publisher
-                            .publish(
-                              SettlementPublication.make({
-                                submissionId: claimed.submissionId,
-                                authority: { _tag: "Owned" },
-                                append: AppendRequest.make({
-                                  ...captured,
-                                  expectedTailSequence: (yield* writer.tail).sequence,
-                                }),
-                              }),
-                            )
-                            .pipe(
-                              Effect.catchTag("AppendConflict", (conflict) => {
-                                if (
-                                  conflict.reason !== "tail" ||
-                                  conflict.actualTailSequence === undefined ||
-                                  retries >= 8
-                                )
-                                  return Effect.fail(conflict);
-
-                                return writer.refresh.pipe(
-                                  Effect.andThen(
-                                    captured.executions === undefined
-                                      ? Effect.succeed(undefined)
-                                      : Effect.fail(conflict),
-                                  ),
-                                );
-                              }),
-                            );
-
-                          if (result === undefined) continue;
-                          adoptTail(result.tailSequence);
+                  ),
+                );
 
-                          return result;
-                        }
-                      }).pipe(
-                        Effect.onError((cause) =>
-                          isDefiniteWriteFailure(cause) ? Effect.void : generation.release,
-                        ),
+                return yield* owner.withProgress(
+                  request.threadId,
+                  owned(
+                    Effect.gen(function* () {
+                      for (let retries = 0; ; retries++) {
+                        const result = yield* publisher
+                          .publish(
+                            SettlementPublication.make({
+                              submissionId: claimed.submissionId,
+                              authority: { _tag: "Owned" },
+                              append: AppendRequest.make({
+                                ...captured,
+                                expectedTailSequence: (yield* writer.tail).sequence,
+                              }),
+                            }),
+                          )
+                          .pipe(
+                            Effect.catchTag("AppendConflict", (conflict) => {
+                              if (
+                                conflict.reason !== "tail" ||
+                                conflict.actualTailSequence === undefined ||
+                                retries >= 8
+                              )
+                                return Effect.fail(conflict);
+
+                              return writer.refresh.pipe(
+                                Effect.andThen(
+                                  captured.executions === undefined
+                                    ? Effect.succeed(undefined)
+                                    : Effect.fail(conflict),
+                                ),
+                              );
+                            }),
+                          );
+
+                        if (result === undefined) continue;
+                        adoptTail(result.tailSequence);
+
+                        return result;
+                      }
+                    }).pipe(
+                      Effect.onError((cause) =>
+                        isDefiniteWriteFailure(cause) ? Effect.void : generation.release,
                       ),
                     ),
-                  );
-                }),
+                  ),
+                );
+              }),
               reserveChildBudget: (value) =>
                 owned(
                   ledger.reserveChildBudget(