core: capture codebase snapshots before and after each AI step for review

Author: thdxr

packages/opencode/src/session/processor.ts

@@ -432,6 +432,7 @@ export const layer: Layer.Layer<
                 providerID: ctx.model.providerID,
                 variant: input.assistantMessage.variant,
               },
+              snapshot: ctx.snapshot,
               timestamp: DateTime.makeUnsafe(Date.now()),
             })
             yield* session.updatePart({
@@ -444,6 +445,7 @@ export const layer: Layer.Layer<
             return
 
           case "finish-step": {
+            const completedSnapshot = yield* snapshot.track()
             const usage = Session.getUsage({
               model: ctx.model,
               usage: value.usage,
@@ -454,6 +456,7 @@ export const layer: Layer.Layer<
               reason: value.finishReason,
               cost: usage.cost,
               tokens: usage.tokens,
+              snapshot: completedSnapshot,
               timestamp: DateTime.makeUnsafe(Date.now()),
             })
             ctx.assistantMessage.finish = value.finishReason
@@ -462,7 +465,7 @@ export const layer: Layer.Layer<
             yield* session.updatePart({
               id: PartID.ascending(),
               reason: value.finishReason,
-              snapshot: yield* snapshot.track(),
+              snapshot: completedSnapshot,
               messageID: ctx.assistantMessage.id,
               sessionID: ctx.assistantMessage.sessionID,
               type: "step-finish",

packages/opencode/src/v2/session-event.ts

@@ -54,6 +54,7 @@ export namespace Step {
         providerID: Schema.String,
         variant: Schema.String.pipe(Schema.optional),
       }),
+      snapshot: Schema.String.pipe(Schema.optional),
     },
   })
   export type Started = Schema.Schema.Type<typeof Started>
@@ -74,6 +75,7 @@ export namespace Step {
           write: Schema.Number,
         }),
       }),
+      snapshot: Schema.String.pipe(Schema.optional),
     },
   })
   export type Ended = Schema.Schema.Type<typeof Ended>

packages/opencode/src/v2/session-message-updater.ts

@@ -94,6 +94,7 @@ export function update<Result>(adapter: Adapter<Result>, event: SessionEvent.Eve
             draft.time.completed = event.data.timestamp
             draft.cost = event.data.cost
             draft.tokens = event.data.tokens
+            if (event.data.snapshot) draft.snapshot = { ...draft.snapshot, end: event.data.snapshot }
           }),
         )
       }

packages/opencode/src/v2/session-message.ts

@@ -152,6 +152,10 @@ export class Assistant extends Schema.Class<Assistant>("Session.Message.Assistan
   type: Schema.Literal("assistant"),
   content: AssistantContent.pipe(Schema.Array),
   retries: AssistantRetry.pipe(Schema.Array, Schema.optional),
+  snapshot: Schema.Struct({
+    start: Schema.String.pipe(Schema.optional),
+    end: Schema.String.pipe(Schema.optional),
+  }).pipe(Schema.optional),
   cost: Schema.Number.pipe(Schema.optional),
   tokens: Schema.Struct({
     input: Schema.Number,
@@ -177,6 +181,7 @@ export class Assistant extends Schema.Class<Assistant>("Session.Message.Assistan
       },
       content: [],
       retries: [],
+      snapshot: event.data.snapshot ? { start: event.data.snapshot } : undefined,
     })
   }
 }

packages/opencode/test/v2/session-message-updater.test.ts

@@ -0,0 +1,41 @@
+import { expect, test } from "bun:test"
+import * as DateTime from "effect/DateTime"
+import { SessionID } from "../../src/session/schema"
+import { SessionEvent } from "../../src/v2/session-event"
+import { SessionMessageUpdater } from "../../src/v2/session-message-updater"
+
+test("step snapshots carry over to assistant messages", () => {
+  const state: SessionMessageUpdater.MemoryState = { messages: [], pending: [] }
+  const sessionID = SessionID.make("session")
+
+  SessionMessageUpdater.update(SessionMessageUpdater.memory(state), {
+    type: "session.next.step.started",
+    data: {
+      sessionID,
+      timestamp: DateTime.makeUnsafe(1),
+      model: { id: "model", providerID: "provider" },
+      snapshot: "before",
+    },
+  } satisfies SessionEvent.Event)
+
+  SessionMessageUpdater.update(SessionMessageUpdater.memory(state), {
+    type: "session.next.step.ended",
+    data: {
+      sessionID,
+      timestamp: DateTime.makeUnsafe(2),
+      reason: "stop",
+      cost: 0,
+      tokens: {
+        input: 1,
+        output: 2,
+        reasoning: 0,
+        cache: { read: 0, write: 0 },
+      },
+      snapshot: "after",
+    },
+  } satisfies SessionEvent.Event)
+
+  expect(state.messages[0]?.type).toBe("assistant")
+  if (state.messages[0]?.type !== "assistant") return
+  expect(state.messages[0].snapshot).toEqual({ start: "before", end: "after" })
+})