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

package/src/durable/DurableAgentRuntime.ts

@@ -156,9 +156,9 @@ import {
   resolveWorkerBinding,
   CurrentBindingSelection,
 } from "./internal/agent-registration.ts";
-import { makeAgentUpdateRuntime } from "./internal/agent-updates.ts";
+import { makeAgentUpdateRuntime, nativeUpdateAccepted } from "./internal/agent-updates.ts";
 import { inspectForeignDiagnostic, safeUnknownString } from "./internal/foreign-diagnostic.ts";
-import { initialContext } from "./internal/initial-context.ts";
+import { initialContext, type InitialContextInput } from "./internal/initial-context.ts";
 import {
   makeJournalMetadata,
   type JournalMetadata,
@@ -403,6 +403,9 @@ import {
   getRunInput,
   ThreadReader,
   MAX_THREAD_EXPORT_PAGE_BYTES,
+  PreparedAppend,
+  type CommitBatch,
+  type ExecutionUpdate,
 } from "./ThreadStore.ts";
 import {
   type WorkIndexRebuildRequest,
@@ -594,6 +597,11 @@ export { threadCreatedBatchId, threadCreatedRecordId } from "./internal/thread-i
 export const recoveryRepairBatchId = (submissionId: SubmissionId, decisionTag: string): BatchId =>
   decodeBatchId(`repair:${submissionId}:${decisionTag}`);
 
+const isOriginalInputRecord = (
+  record: RecordEnvelope,
+): record is RecordEnvelope & { readonly payload: UserInputRecorded } =>
+  record.payload._tag === "UserInputRecorded";
+
 /** Deterministic record identity of one executed recovery decision's `RepairAnnotated` record. */
 export const recoveryRepairRecordId = (submissionId: SubmissionId, decisionTag: string): RecordId =>
   decodeRecordId(`repair:${submissionId}:${decisionTag}`);
@@ -1364,7 +1372,7 @@ interface OpenCallReview {
 
 interface InitialJournalSource {
   records: ReadonlyArray<JournalRecordEnvelope> | undefined;
-  readonly original: CanonicalRecordEnvelope;
+  readonly original: InitialContextInput;
   readonly suffix: ReadonlyArray<CanonicalRecordEnvelope>;
   cacheable: boolean;
   readonly prefix?: CachedPromptHistory;
@@ -1472,7 +1480,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
   // Rebuild the pinned admission and captured suffix using this runtime's host dependencies.
   const readInitialJournal = (
-    original: CanonicalRecordEnvelope,
+    original: InitialContextInput,
     suffix: ReadonlyArray<CanonicalRecordEnvelope>,
   ) =>
     initialContext(original).pipe(
@@ -2617,7 +2625,10 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       Effect.map(({ owned }) => owned),
     );
 
-  const withProgressSession = Effect.fnUntraced(function* (session: RunStorageSession) {
+  const withProgressSession = Effect.fnUntraced(function* (
+    session: RunStorageSession,
+    originalInput?: () => InitialContextInput | undefined,
+  ) {
     const { owned, progress } = yield* withProgress(session);
 
     activeProgress.set(session.threadId, { writer: progress });
@@ -2628,9 +2639,44 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       }),
     );
 
+    const inputWriter =
+      session.appendInput === undefined
+        ? undefined
+        : {
+            ...session,
+            append: session.appendInput,
+          };
+
     const wrapped: RunStorageSession = {
       ...session,
       append: owned.append,
+      ...(inputWriter === undefined
+        ? {}
+        : {
+            appendInput: (batch: CommitBatch) =>
+              storageOwner.withProgress(
+                session.threadId,
+                storageOwner.withMutation(
+                  Effect.gen(function* () {
+                    yield* session.checkActive;
+                    // The captured empty canonical prefix is enforced again by the append tail and
+                    // checkpoint revision-zero CAS. It is not a cache entry across preparation IO.
+                    const original = originalInput?.();
+                    const commit = progress.commit(batch);
+
+                    return yield* (
+                      original === undefined
+                        ? commit
+                        : progress.withVerifiedEmptyRun(
+                            runIdForSubmission(session.claim.submissionId),
+                            CanonicalSequence.make(original.sequence - 1),
+                            commit,
+                          )
+                    ).pipe(Effect.provideService(CurrentRunWriter, inputWriter));
+                  }),
+                ),
+              ),
+          }),
       publishSettlement: (batch) =>
         progress.publish(batch).pipe(Effect.provideService(CurrentRunSettlement, session)),
     };
@@ -3048,6 +3094,22 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         recovered += 1;
       });
 
+      // Retry permission cannot mask a recorded outcome or require a runnable old binding.
+      // Explicit factual resolutions and abort instructions retain their own handling below.
+      if (
+        (intent === undefined || intent.resolution._tag === "SafeToRetry") &&
+        declared !== undefined &&
+        nativeUpdateAccepted(submission, declared, records)
+      ) {
+        yield* appendClosedCall(ctx, submissionId, knownIds, call, {
+          result: { value: { emitted: true }, isFailure: false },
+          resolution: "completed-with-result",
+          author: RECONCILER_AUTHOR,
+          reason: "The exact native update was canonically accepted",
+        });
+        recovered += 1;
+        continue;
+      }
       if (intent !== undefined) {
         switch (intent.resolution._tag) {
           case "AbortSubmission":
@@ -3167,6 +3229,20 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     );
   });
 
+  const prepareOriginalInput = (submission: SubmissionSnapshot) =>
+    makeEnvelope(
+      submissionInputRecordId(submission.submissionId),
+      UserInputRecorded.make({
+        submissionId: submission.submissionId,
+        kind: "user",
+        runId: runIdForSubmission(submission.submissionId),
+        input: submission.inputPayload,
+        ...(submission.messageAdmission === undefined
+          ? {}
+          : { messageAdmission: submission.messageAdmission }),
+      }),
+    );
+
   /**
    * Plan step 2: append the deterministic `UserInputRecorded` record (batch idempotency makes it
    * exactly-once canonical, DUR-007) and mark it applied. When canonical history already carries
@@ -3192,18 +3268,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       return;
     }
 
-    const envelope = yield* makeEnvelope(
-      recordId,
-      UserInputRecorded.make({
-        submissionId,
-        kind: "user",
-        runId: runIdForSubmission(submissionId),
-        input: submission.inputPayload,
-        ...(submission.messageAdmission === undefined
-          ? {}
-          : { messageAdmission: submission.messageAdmission }),
-      }),
-    );
+    const envelope = yield* prepareOriginalInput(submission);
 
     const result = yield* appendBatch(
       ctx,
@@ -3254,8 +3319,13 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     maxDurationMillis: number,
     records: ReadonlyArray<CanonicalRecordEnvelope>,
     operational: ReadonlyArray<RecordEnvelope>,
+    input?: RecordEnvelope,
   ) {
     const writer = yield* CurrentRunWriter;
+    const append = input === undefined ? writer.append : writer.appendInput;
+
+    if (append === undefined)
+      return yield* RunJournalError.make({ message: "Fresh startup requires an input publisher" });
     const runId = runIdForSubmission(submission.submissionId);
     const recordId = runStartedRecordId(runId);
     const existing = yield* readRunStart(submission.threadId, runId, operational);
@@ -3304,13 +3374,21 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       }
       yield* hit("run:before-start-append");
       yield* appendBatch(
-        writer,
+        { threadId: writer.threadId, append },
         CanonicalBatch.make({
-          batchId: runStartedBatchId(runId),
+          batchId:
+            input === undefined
+              ? runStartedBatchId(runId)
+              : submissionInputBatchId(submission.submissionId),
           producerId: config.producerId,
-          records: [start, ...(context === undefined ? [] : [context])],
+          records: [
+            input ?? start,
+            ...(input === undefined ? [] : [start]),
+            ...(context === undefined ? [] : [context]),
+          ],
         }),
       );
+      if (input !== undefined) yield* hit("input:after-canonical-append");
       committed = true;
       yield* hit("run:after-start-append");
     });
@@ -4856,12 +4934,14 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       // Unrelated Thread traffic does not invalidate an already validated owner projection.
       const projectionThrough = Math.max(progressThrough ?? 0, records.at(-1)?.sequence ?? 0);
 
-      const originalInput = records.find(
-        ({ record: { payload } }) =>
-          payload._tag === "UserInputRecorded" &&
-          payload.kind === "user" &&
-          payload.submissionId === submissionId,
-      );
+      const originalInput =
+        initialJournal?.original ??
+        records.find(
+          ({ record: { payload } }) =>
+            payload._tag === "UserInputRecorded" &&
+            payload.kind === "user" &&
+            payload.submissionId === submissionId,
+        );
 
       if (originalInput === undefined)
         return yield* RunJournalError.make({ message: "Run has no original context boundary" });
@@ -5447,18 +5527,6 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           usageSummary: yield* currentUsageSummary(),
         };
       }
-      // Summaries cover only prior Runs. Pruning and rollover also map fully settled
-      // current-Run records and preserves the canonical instruction/input block during replay.
-      let ownerFirstSequence: CanonicalSequence | undefined;
-
-      for (const envelope of records) {
-        const payload = envelope.record.payload;
-
-        if ("runId" in payload && payload.runId === runId) {
-          ownerFirstSequence = envelope.sequence;
-          break;
-        }
-      }
 
       /** Only canonical joined inputs can require restoration from an earlier Attempt. */
       let joinBacklog: ReadonlyArray<JoinSnapshot> | undefined =
@@ -5839,6 +5907,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
               const start = yield* CurrentRunStart;
 
               yield* start.commit(yield* makeEnvelope(recordId, payload));
+              knownIds.add(originalInput.record.recordId);
               knownIds.add(runStartedRecordId(runId));
               knownIds.add(recordId);
               historyEvidence.clear();
@@ -6400,13 +6469,10 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
             );
           }
 
-          // Summaries use the initial prior-Run boundaries; pruning and rollover also admit
-          // complete current-Run boundaries from the fresh canonical source above.
+          // The validated original input bounds summaries even when startup deferred its append.
+          // Pruning and rollover also admit complete current-Run canonical boundaries.
           const coverable = sourceBoundaries.filter(
-            (boundary) =>
-              commit.kind !== "summarize" ||
-              ownerFirstSequence === undefined ||
-              boundary.sequence < ownerFirstSequence,
+            (boundary) => commit.kind !== "summarize" || boundary.sequence < originalInput.sequence,
           );
 
           if (coverable.length === 0) {
@@ -8164,6 +8230,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
       // before suspension; only acknowledged ranges enter this Attempt's disposable suffix.
       let committedPromptSuffix: CommittedPromptSuffix | undefined;
       const storageSession = session;
+      let pendingOriginal: InitialContextInput | undefined;
 
       yield* Effect.addFinalizer(() =>
         Effect.sync(() => {
@@ -8174,6 +8241,27 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
       const promptSession: RunStorageSession = {
         ...storageSession,
+        ...(storageSession.appendInput === undefined
+          ? {}
+          : {
+              appendInput: (batch: CommitBatch, executions?: ReadonlyArray<ExecutionUpdate>) =>
+                storageSession.appendInput!(batch, executions).pipe(
+                  Effect.tap((result) =>
+                    Effect.sync(() => {
+                      if (
+                        pendingOriginal !== undefined &&
+                        !result.replayed &&
+                        result.firstSequence === pendingOriginal.sequence
+                      )
+                        committedPromptSuffix = makeCommittedPromptSuffix({
+                          threadId: storageSession.threadId,
+                          sequence: result.firstSequence,
+                          record: batch.records[0]!,
+                        });
+                    }),
+                  ),
+                ),
+            }),
         append: (batch, executions) => {
           const suffix = committedPromptSuffix;
           const append = storageSession.append(batch, executions);
@@ -8209,7 +8297,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         },
       };
 
-      session = yield* withProgressSession(promptSession);
+      session = yield* withProgressSession(promptSession, () => pendingOriginal);
       const { claim, threadId } = session;
       const submissionId = claim.submissionId;
 
@@ -8254,6 +8342,41 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
                   view.records.some(({ record }) => record.payload._tag !== "ThreadCreated")
                 )
                   return undefined;
+                if (session.appendInput !== undefined) {
+                  const captured = yield* PreparedAppend.capture(
+                    AppendRequest.make({
+                      threadId,
+                      expectedTailSequence: before,
+                      batch: CanonicalBatch.make({
+                        batchId: submissionInputBatchId(submissionId),
+                        producerId: config.producerId,
+                        records: [yield* prepareOriginalInput(submission)],
+                      }),
+                    }),
+                  );
+
+                  const record = captured.records[0]!.canonical;
+
+                  if (!isOriginalInputRecord(record))
+                    return yield* RunJournalError.make({
+                      message: "Captured startup has no original input",
+                    });
+                  pendingOriginal = {
+                    threadId,
+                    sequence: CanonicalSequence.make(before + 1),
+                    record,
+                  };
+
+                  const start = yield* makeRunStart(
+                    submission,
+                    Duration.toMillis(registeredAgent.definition.policy.maxDuration),
+                    view.records,
+                    view.operational,
+                    record,
+                  ).pipe(Effect.provideService(CurrentRunWriter, session));
+
+                  return { snapshot, through: before, view, start, input: pendingOriginal };
+                }
                 const progress = progressWriters.get(session);
 
                 const applyInput = applyCanonicalInput(
@@ -8303,6 +8426,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
                     operational: accepted.operational,
                   },
                   start,
+                  input: undefined,
                 };
               }),
             )
@@ -8737,12 +8861,14 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         let initialJournal: InitialJournalSource | undefined;
 
         if (view.context === undefined) {
-          const original = currentRecords.find(
-            ({ record }) =>
-              record.payload._tag === "UserInputRecorded" &&
-              record.payload.kind === "user" &&
-              record.payload.submissionId === submissionId,
-          );
+          const original =
+            initialization?.input ??
+            currentRecords.find(
+              ({ record }) =>
+                record.payload._tag === "UserInputRecorded" &&
+                record.payload.kind === "user" &&
+                record.payload.submissionId === submissionId,
+            );
 
           if (original === undefined)
             return yield* RunJournalError.make({
@@ -8752,7 +8878,10 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           const suffix = currentRecords.filter((entry) => entry.sequence > original.sequence);
 
           const fresh =
-            !lineage.inputWasRecorded && tail.sequence === original.sequence && suffix.length === 0;
+            initialization?.input !== undefined ||
+            (!lineage.inputWasRecorded &&
+              tail.sequence === original.sequence &&
+              suffix.length === 0);
 
           // Every replay stays bounded at the ORIGINAL admission, never the later Thread tail.
           const source: InitialJournalSource = yield* Effect.gen(function* () {
@@ -8795,9 +8924,10 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         }
 
         committedPromptSuffix?.discard();
-        committedPromptSuffix = initialJournal?.cacheable
-          ? makeCommittedPromptSuffix(initialJournal.original)
-          : undefined;
+        committedPromptSuffix =
+          initialJournal?.cacheable && initialization?.input === undefined
+            ? makeCommittedPromptSuffix(initialJournal.original)
+            : undefined;
 
         const outcome = yield* runModel(
           agent,
@@ -8807,7 +8937,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
           currentRecords,
           canonical,
           initialJournal,
-          tail.sequence,
+          initialization?.input?.sequence ?? tail.sequence,
           view.progressThrough,
           view.progress,
           view.context,
@@ -9535,6 +9665,8 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     for (const intent of intents) {
       const original = declared.get(intent.toolCallId);
 
+      if (original !== undefined && nativeUpdateAccepted(submission, original, records)) continue;
+
       if (
         original === undefined ||
         (current !== undefined &&
@@ -9716,9 +9848,52 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
         return yield* applyUnknownResolutionsForRecovery(snapshot, evidence, records);
       }
       case "AwaitUnknownResolution": {
-        // This Submission stays parked awaiting the authorized DUR-017 resolution path;
-        // the settlement obligation stays visible, nothing replays.
-        return "unknown";
+        // Older Attempts may already have marked a native update unknown. Its exact
+        // canonical acceptance is a factual resolution, never permission to retry an
+        // external operation. The ledger wakes only when every unknown call is covered;
+        // the next owner appends closure under the original call identity.
+        const declared = yield* declaredCallsFor(
+          records,
+          runId,
+          new Set(evidence.openToolCalls.map((call) => call.toolCallId)),
+        );
+
+        let repaired = false;
+
+        for (const call of declared.values()) {
+          if (
+            snapshot.unknownResolutions.some((intent) => intent.toolCallId === call.toolCallId) ||
+            !nativeUpdateAccepted(submission, call, records)
+          )
+            continue;
+          yield* ledger
+            .recordUnknownResolution(
+              UnknownResolutionCommand.make({
+                submissionId: submission.submissionId,
+                toolCallId: call.toolCallId,
+                author: RECONCILER_AUTHOR,
+                reason: "The exact native update was canonically accepted",
+                resolution: {
+                  _tag: "CompletedWithResult",
+                  result: { emitted: true },
+                  isFailure: false,
+                },
+              }),
+            )
+            .pipe(
+              Effect.catchTag("UnknownResolutionConflict", (cause) =>
+                LedgerError.make({
+                  operation: "recover native update",
+                  message: "Native acceptance conflicts with a retained resolution",
+                  cause,
+                }),
+              ),
+            );
+          repaired = true;
+        }
+        if (repaired) yield* wake.notify(submission.threadId);
+
+        return repaired ? "repaired" : "unknown";
       }
       case "AwaitApprovalDecision": {
         return yield* awaitApprovalForRecovery(snapshot, evidence, decision);
@@ -10372,8 +10547,11 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
 
     const factual = intent?.resolution;
 
+    const acceptedNative =
+      factual === undefined && (yield* updateRuntime.accepted(submission, selected.declared));
+
     const reconciliation =
-      factual === undefined && selected.declared.executionKind === "ordinary"
+      factual === undefined && !acceptedNative && selected.declared.executionKind === "ordinary"
         ? yield* reconciler
             .reconcile(
               DeclaredToolCallEvidence.make({
@@ -10391,9 +10569,11 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
     const completed =
       factual?._tag === "CompletedWithResult"
         ? factual
-        : Option.isSome(reconciliation) && reconciliation.value._tag === "CompletedWithResult"
-          ? reconciliation.value
-          : undefined;
+        : acceptedNative
+          ? { result: { emitted: true }, isFailure: false }
+          : Option.isSome(reconciliation) && reconciliation.value._tag === "CompletedWithResult"
+            ? reconciliation.value
+            : undefined;
 
     const neverStarted =
       factual?._tag === "NeverHappened" ||

package/src/durable/RunContinuation.ts

@@ -52,7 +52,7 @@ import {
   subagentRequestedRecordId,
   subagentStartedRecordId,
 } from "./RunJournal.ts";
-import type { RunStorageSession, RunWriter } from "./RunStorage.ts";
+import type { RunStorageSession } from "./RunStorage.ts";
 import {
   submissionAbortRecordId,
   submissionInputRecordId,
@@ -74,7 +74,7 @@ export { RunContinuation, RunContextRecorded, EvidenceReference } from "./Record
 /** Writer and progress sequencer selected at the local owner's resource boundary. */
 export class CurrentRunWriter extends Context.Service<
   CurrentRunWriter,
-  Pick<RunWriter, "threadId" | "tail" | "append" | "withProgress">
+  Pick<RunStorageSession, "threadId" | "tail" | "append" | "appendInput" | "withProgress">
 >()("@effect-agent/thread/CurrentRunWriter") {}
 
 /** Settlement publication keeps its original atomic authority and claim-scoped implementation. */

package/src/durable/RunJournal.ts

@@ -1736,12 +1736,12 @@ const modelResponseRecord = Effect.fnUntraced(function* (
   }
 
   const encodedMessages = yield* encodePrompt(Prompt.fromMessages([...promptMessages])).pipe(
-    Effect.mapError((cause) => journalError("Turn Prompt messages failed to encode", cause)),
+    Effect.mapErrorEager((cause) => journalError("Turn Prompt messages failed to encode", cause)),
   );
 
   const messages = yield* decodePersistedJson(encodedMessages).pipe(
-    Effect.map(copyJson),
-    Effect.mapError((cause) =>
+    Effect.mapEager(copyJson),
+    Effect.mapErrorEager((cause) =>
       journalError("Turn Prompt messages exceed canonical persistence bounds", cause),
     ),
   );
@@ -1783,7 +1783,9 @@ const modelResponseRecord = Effect.fnUntraced(function* (
               }),
         }),
   }).pipe(
-    Effect.mapError((cause) => journalError("Invalid model response operation evidence", cause)),
+    Effect.mapErrorEager((cause) =>
+      journalError("Invalid model response operation evidence", cause),
+    ),
   );
 
   if (payload.modelUsage !== undefined) {
@@ -1791,7 +1793,9 @@ const modelResponseRecord = Effect.fnUntraced(function* (
       return yield* journalError("Turn model usage must contain at least one completed call");
 
     const summary = yield* continuationUsage(payload.modelUsage).pipe(
-      Effect.mapError((cause) => journalError("Turn model usage exceeds accounting bounds", cause)),
+      Effect.mapErrorEager((cause) =>
+        journalError("Turn model usage exceeds accounting bounds", cause),
+      ),
     );
 
     if (