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

package/src/durable/DurableAgentRuntime.ts

@@ -158,7 +158,7 @@ import {
 } from "./internal/agent-registration.ts";
 import { makeAgentUpdateRuntime } 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)),
     };
@@ -3167,6 +3213,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 +3252,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 +3303,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 +3358,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 +4918,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 +5511,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 +5891,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 +6453,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 +8214,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 +8225,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 +8281,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 +8326,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 +8410,7 @@ const make = Effect.fnUntraced(function* (bindings: ReadonlyArray<ResolvedBindin
                     operational: accepted.operational,
                   },
                   start,
+                  input: undefined,
                 };
               }),
             )
@@ -8737,12 +8845,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 +8862,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 +8908,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 +8921,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,

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 (

package/src/durable/RunStorage.ts

@@ -113,6 +113,8 @@ export interface RunWriter {
 
 export interface RunStorageSession extends RunWriter, RunOwnership {
   readonly claim: Claim;
+  /** Atomic original input/context plus the ledger marker, when the adapter supports it. */
+  readonly appendInput?: RunWriter["append"];
   /** 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>(
@@ -176,69 +178,75 @@ const makeWriter = Effect.fnUntraced(function* (threadId: ThreadId) {
     }),
   );
 
-  const append: RunWriter["append"] = Effect.fnUntraced(function* (batch, executions) {
-    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,
+  const makeAppend = Effect.gen(function* () {
+    const publisher = yield* ThreadStore;
+
+    const append: RunWriter["append"] = Effect.fnUntraced(function* (batch, executions) {
+      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(
-      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,
+      return yield* owner.withProgress(
+        threadId,
+        owner.withMutation(
+          Effect.gen(function* () {
+            yield* checkActive;
+            for (let retries = 0; ; retries++) {
+              const result = yield* publisher
+                .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,
+            ),
           ),
         ),
-      ),
-    );
+      );
+    });
+
+    return append;
   });
 
   const writer = {
@@ -247,13 +255,14 @@ const makeWriter = Effect.fnUntraced(function* (threadId: ThreadId) {
     withProgress: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
       owner.withProgress(threadId, Effect.andThen(checkActive, effect)),
     tail: Effect.sync(() => tail),
-    append,
+    append: yield* makeAppend,
     checkActive: owner.withMutation(checkActive),
     refresh,
   };
 
   return {
     writer,
+    makeAppend,
     adoptTail: (sequence: CanonicalSequence) => {
       tail = { sequence };
     },
@@ -310,7 +319,7 @@ export const make = Effect.gen(function* () {
               });
             yield* store.materialize(ThreadMaterialization.make({ threadId: request.threadId }));
 
-            const { writer, adoptTail } = yield* makeWriter(request.threadId).pipe(
+            const { writer, makeAppend, adoptTail } = yield* makeWriter(request.threadId).pipe(
               Effect.provideService(WriterOwnership, generation),
               Effect.provideService(ThreadStore, store),
               Effect.provideService(StorageOwner, owner),
@@ -318,9 +327,22 @@ export const make = Effect.gen(function* () {
 
             const owned = <A, E>(effect: Effect.Effect<A, E>) => generation.use(effect);
 
+            const inputPublisher = ledger.appendInput;
+
+            const appendInput =
+              inputPublisher === undefined
+                ? undefined
+                : yield* makeAppend.pipe(
+                    Effect.provideService(ThreadStore, {
+                      ...store,
+                      append: (request) => inputPublisher(claimed.submissionId, request),
+                    }),
+                  );
+
             const session: RunStorageSession = {
               ...writer,
               claim: claimed,
+              ...(appendInput === undefined ? {} : { appendInput }),
               withInitialization: (effect) =>
                 owner.withProgress(request.threadId, generation.use(effect)),
               release: generation.release,

package/src/durable/SubmissionLedger.ts

@@ -36,6 +36,7 @@ import {
   ToolCallUnknown,
   WorkerAdmission,
 } from "./Records.ts";
+import type { AppendRequest, AppendResult, ThreadStoreFailure } from "./ThreadStore.ts";
 
 export { IdempotencyKey, JoinedToHost, QueueSequence, Principal } from "../core/Receipt.ts";
 
@@ -1113,6 +1114,13 @@ export class SubmissionLedger extends Context.Service<
     readonly selectHead: (
       request: ClaimRequest,
     ) => Effect.Effect<Option.Option<Claim>, LedgerError>;
+    /** Atomically publish a captured original input, active context and applied marker.
+     * Optional adapters retain the ordinary append-then-repair protocol. The captured input
+     * must be this owner's deterministic admission; a moved context boundary is refused. */
+    readonly appendInput?: (
+      submissionId: SubmissionId,
+      request: AppendRequest,
+    ) => Effect.Effect<AppendResult, ThreadStoreFailure>;
     readonly markInputApplied: (
       request: MarkInputAppliedRequest,
     ) => Effect.Effect<void, OwnershipLost | LedgerError>;