@sixb/core 0.1.20 → 0.1.22

package/src/storage/agents/in-memory.ts

@@ -1,32 +1,69 @@
 import { AGENT_MESSAGE_CONTENT_VERSION } from "../../agents/message"
-import { principalsEqual } from "../../auth"
+import { type Principal, principalsEqual } from "../../auth"
 import { parseSixbFailure } from "../../errors/internal"
 import type { SixbFailure } from "../../errors/types"
 import type { ExecutionStorage } from "../executions"
 import { AgentStorageError } from "./errors"
 import {
+  agentApprovalCallKey,
+  agentApprovalClaimable,
+  agentApprovalHoldsRun,
+  agentApprovalMatches,
+  agentApprovalRepairable,
+  agentApprovalStops,
   agentContextCheckpointMatchesCreateInput,
+  agentMemoryConflicts,
+  agentMemoryHistoryCutoff,
+  agentRunMayHoldCalls,
+  assertAgentApprovalCaller,
+  assertAgentApprovalModeInput,
   assertAgentContextCheckpointAnchors,
   assertAgentContextCheckpointAuthority,
   assertAgentContextCheckpointReplayState,
   assertAgentRunExecution,
+  assertAgentRunFinishPayload,
+  assertAwaitingApprovalFinish,
   assertConversationAgentRunSpec,
+  assertConversationThreadRow,
   assertCreateAgentContextCheckpointInput,
   assertCreateSubagentRunInput,
-  assertSubagentRunResult,
+  assertRequestAgentApprovalInput,
+  assertSaveAgentMemoryInput,
+  assertSubagentThreadTakesRun,
+  compareAgentMemoryPaths,
+  compareAgentThreadParticipants,
+  countsAsThreadMessage,
+  LIVE_AGENT_APPROVAL_STATUSES,
+  newAgentApprovalRecord,
+  newSubagentThreadRecord,
+  participantsToAdd,
+  planAgentThreadFork,
+  remapArtifactIds,
   snapshotAgentThreadSandboxParams,
   subagentRunMatchesCreateInput,
   transitionAgentThreadSandbox,
 } from "./provider"
 import type {
+  AddAgentThreadParticipantsInput,
+  AgentApprovalCursor,
+  AgentApprovalMode,
+  AgentApprovalModeStore,
+  AgentApprovalOutcome,
+  AgentApprovalRecord,
+  AgentApprovalStore,
   AgentContextCheckpointRecord,
   AgentContextCheckpointStore,
+  AgentMemoryChange,
+  AgentMemoryRepoRecord,
+  AgentMemoryRevisionRecord,
+  AgentMemoryStore,
   AgentMessageRecord,
   AgentMessageStore,
   AgentRunFailureCode,
   AgentRunRecord,
   AgentRunStore,
   AgentStorage,
+  AgentThreadParticipantRecord,
   AgentThreadRecord,
   AgentThreadSandboxState,
   AgentThreadStore,
@@ -37,17 +74,36 @@ import type {
   CreateAgentRunInput,
   CreateAgentThreadInput,
   CreateSubagentRunInput,
+  DecideAgentApprovalInput,
+  DecideAgentApprovalResult,
   DeleteAgentMessagesByRunInput,
   FinishAgentRunInput,
   FinishQueuedAgentRunInput,
+  ForkAgentThreadInput,
+  ListAgentApprovalsInput,
+  ListAgentApprovalsResult,
+  ListAgentMemoryRevisionsInput,
+  ListAgentMemoryRevisionsResult,
   ListAgentMessagesInput,
   ListAgentMessagesResult,
   ListAgentRunsInput,
   ListAgentRunsResult,
+  ListAgentThreadChildrenInput,
+  ListAgentThreadParticipantsInput,
   ListAgentThreadsInput,
   ListAgentThreadsResult,
+  ListThreadSubagentsInput,
+  MarkAgentApprovalsReportedInput,
   ReclaimAgentRunInput,
+  RemoveAgentThreadParticipantInput,
+  RequestAgentApprovalInput,
+  RequestAgentApprovalResult,
+  SaveAgentMemoryInput,
+  SaveAgentMemoryResult,
+  SettleAgentApprovalsInput,
   StartAgentRunInput,
+  StopAgentApprovalsInput,
+  StopAgentApprovalsResult,
   SubagentRunRecord,
   TransitionAgentThreadSandboxInput,
 } from "./types"
@@ -98,23 +154,41 @@ function applyWindow<T>(rows: T[], offset = 0, limit?: number): Window<T> {
 }
 
 /**
- * Shared in-memory state behind the four sub-stores. They are tiered for ergonomics
+ * Shared in-memory state behind the sub-stores. They are tiered for ergonomics
  * (`storage.runs.create(...)`), but several operations span tables — creating/finishing a run
  * updates the thread anchor, appending a message bumps thread stats, and checkpoint creation reads
  * run/thread/message anchors — so they all read and write the same maps through this object.
  */
 interface AgentStoreState {
   readonly threads: Map<string, AgentThreadRecord>
+  /** By thread key; each thread's participants in the order they were added. */
+  readonly participants: Map<string, AgentThreadParticipantRecord[]>
   readonly runs: Map<string, AgentRunRecord>
   readonly messages: Map<string, AgentMessageRecord>
   readonly checkpoints: Map<string, AgentContextCheckpointRecord>
+  readonly memory: Map<string, StoredAgentMemoryRepo>
+  readonly approvals: Map<string, AgentApprovalRecord>
+  /** By `[projectId, principal]` for a default, `[projectId, threadId, principal]` for a thread. */
+  readonly approvalModes: Map<string, AgentApprovalMode>
+}
+
+/** A memory repo as its two SQL tables hold it: revisions, and the file versions each wrote. */
+interface StoredAgentMemoryRepo {
+  /** Oldest first. */
+  readonly revisions: readonly Omit<AgentMemoryRevisionRecord, "changes">[]
+  /** In insertion order, so by revision. `contents: null` deleted the path. */
+  readonly files: readonly (AgentMemoryChange & { readonly revision: number })[]
 }
 
 export interface InMemoryAgentStorageSnapshot {
   readonly threads: Map<string, AgentThreadRecord>
+  readonly participants: Map<string, AgentThreadParticipantRecord[]>
   readonly runs: Map<string, AgentRunRecord>
   readonly messages: Map<string, AgentMessageRecord>
   readonly checkpoints: Map<string, AgentContextCheckpointRecord>
+  readonly memory: Map<string, StoredAgentMemoryRepo>
+  readonly approvals: Map<string, AgentApprovalRecord>
+  readonly approvalModes: Map<string, AgentApprovalMode>
 }
 
 // ── threads ───────────────────────────────────────────────────────────────────────────────────
@@ -154,6 +228,7 @@ class InMemoryAgentThreadStore implements AgentThreadStore {
     const record: AgentThreadRecord = {
       id: input.id,
       projectId: input.projectId,
+      kind: "conversation",
       ownerPrincipal: clone(input.ownerPrincipal),
       ...(sandboxParams === undefined ? {} : { sandboxParams }),
       ...(input.title === undefined ? {} : { title: input.title }),
@@ -168,20 +243,120 @@ class InMemoryAgentThreadStore implements AgentThreadStore {
     return clone(record)
   }
 
+  async fork(input: ForkAgentThreadInput): Promise<AgentThreadRecord> {
+    // No `await` between reading the source and writing the fork: one in-memory critical section.
+    const source = this.state.threads.get(key(input.projectId, input.sourceThreadId))
+    if (!source) {
+      throw new AgentStorageError(
+        "thread_not_found",
+        `[Sixb] Agent thread '${input.sourceThreadId}' not found for project '${input.projectId}'.`
+      )
+    }
+    assertConversationThreadRow(source, "can be forked")
+
+    const forkKey = key(input.projectId, input.id)
+    if (this.state.threads.has(forkKey)) {
+      throw new AgentStorageError(
+        "duplicate_id",
+        `[Sixb] Agent thread '${input.id}' already exists for project '${input.projectId}'.`
+      )
+    }
+
+    const activeRun =
+      source.activeRunId === null
+        ? undefined
+        : this.state.runs.get(key(input.projectId, source.activeRunId))
+
+    const messages = [...this.state.messages.values()]
+      .filter((message) => message.projectId === input.projectId)
+      .filter((message) => message.threadId === source.id)
+      .sort((left, right) => left.seq - right.seq)
+
+    const checkpoints = [...this.state.checkpoints.values()]
+      .filter((checkpoint) => checkpoint.projectId === input.projectId)
+      .filter((checkpoint) => checkpoint.threadId === source.id)
+      .sort(compareLatestCheckpoints)
+
+    const plan = planAgentThreadFork(input, {
+      ...(activeRun?.kind === "conversation"
+        ? { triggerMessageId: activeRun.triggerMessageId }
+        : {}),
+      messages: messages.map((message) => ({
+        ...message,
+        counted: countsAsThreadMessage(message),
+      })),
+      checkpoints,
+    })
+
+    this.state.threads.set(forkKey, clone(plan.thread))
+
+    const copyIds = new Map(plan.messages.map((copy) => [copy.sourceId, copy.id]))
+    for (const message of messages) {
+      const id = copyIds.get(message.id)
+      if (id === undefined) continue
+
+      const parts = JSON.parse(
+        remapArtifactIds(JSON.stringify(message.parts), input.artifactCopies)
+      ) as AgentMessageRecord["parts"]
+      this.state.messages.set(
+        key(input.projectId, id),
+        clone({ ...message, id, threadId: input.id, parts })
+      )
+    }
+
+    if (plan.checkpoint) {
+      this.state.checkpoints.set(key(input.projectId, plan.checkpoint.id), clone(plan.checkpoint))
+    }
+
+    return clone(plan.thread)
+  }
+
   async getById(params: { projectId: string; id: string }): Promise<AgentThreadRecord | null> {
     const record = this.state.threads.get(key(params.projectId, params.id))
     return record ? clone(record) : null
   }
 
+  async getByIds(params: {
+    readonly projectId: string
+    readonly ids: readonly string[]
+  }): Promise<readonly AgentThreadRecord[]> {
+    return [...new Set(params.ids)].flatMap((id) => {
+      const record = this.state.threads.get(key(params.projectId, id))
+      return record ? [clone(record)] : []
+    })
+  }
+
+  async listChildren(input: ListAgentThreadChildrenInput): Promise<readonly AgentThreadRecord[]> {
+    const offset = input.offset ?? 0
+    return [...this.state.threads.values()]
+      .filter((thread) => thread.projectId === input.projectId)
+      .filter((thread) => thread.parent?.threadId === input.parentThreadId)
+      .filter((thread) =>
+        input.parentRunId === undefined ? true : thread.parent?.spawnedBy === input.parentRunId
+      )
+      .sort((a, b) => compareByDate(a.createdAt, b.createdAt, a.id, b.id, "asc"))
+      .slice(offset, offset + (input.limit ?? 100))
+      .map(clone)
+  }
+
   async list(input: ListAgentThreadsInput): Promise<ListAgentThreadsResult> {
     const order = input.order ?? "desc"
     const statuses = input.statuses ? new Set(input.statuses) : null
     const filtered = [...this.state.threads.values()]
       .filter((thread) => thread.projectId === input.projectId)
+      .filter((thread) => thread.kind === "conversation")
       .filter((thread) => (statuses ? statuses.has(thread.status) : true))
       .filter((thread) =>
         input.ownerPrincipal ? principalsEqual(thread.ownerPrincipal, input.ownerPrincipal) : true
       )
+      .filter((thread) => {
+        const participant = input.participantPrincipal
+        if (!participant) return true
+
+        return this.participantsOf(thread.projectId, thread.id).some(
+          (record) => record.principal.id === participant.id
+        )
+      })
       .sort((a, b) =>
         compareByDate(
           a.lastMessageAt ?? a.createdAt,
@@ -195,6 +370,57 @@ class InMemoryAgentThreadStore implements AgentThreadStore {
     const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit)
     return { threads: page.map(clone), hasMore, total }
   }
+
+  async addParticipants(
+    input: AddAgentThreadParticipantsInput
+  ): Promise<readonly AgentThreadParticipantRecord[]> {
+    const threadKey = key(input.projectId, input.threadId)
+    const thread = this.state.threads.get(threadKey)
+    if (!thread) {
+      throw new AgentStorageError(
+        "thread_not_found",
+        `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`
+      )
+    }
+    assertConversationThreadRow(thread, "has participants")
+
+    // No `await` from here on: the read and the write are one critical section.
+    const existing = this.participantsOf(input.projectId, input.threadId)
+    const addedAt = new Date(input.addedAt ?? new Date())
+    const added = participantsToAdd(input, existing).map((principal) => ({
+      projectId: input.projectId,
+      threadId: input.threadId,
+      principal,
+      addedAt: new Date(addedAt),
+      addedBy: clone(input.addedBy),
+    }))
+
+    const participants = [...existing, ...added].sort(compareAgentThreadParticipants)
+    this.state.participants.set(threadKey, participants)
+    return clone(participants)
+  }
+
+  async removeParticipant(input: RemoveAgentThreadParticipantInput): Promise<boolean> {
+    const threadKey = key(input.projectId, input.threadId)
+    const existing = this.state.participants.get(threadKey)
+    const kept = existing?.filter((record) => record.principal.id !== input.principal.id)
+    if (!existing || !kept || kept.length === existing.length) return false
+
+    this.state.participants.set(threadKey, kept)
+    return true
+  }
+
+  async listParticipants(
+    input: ListAgentThreadParticipantsInput
+  ): Promise<readonly AgentThreadParticipantRecord[]> {
+    return [...new Set(input.threadIds)]
+      .flatMap((threadId) => clone(this.participantsOf(input.projectId, threadId)))
+      .sort(compareAgentThreadParticipants)
+  }
+
+  private participantsOf(projectId: string, threadId: string): AgentThreadParticipantRecord[] {
+    return this.state.participants.get(key(projectId, threadId)) ?? []
+  }
 }
 
 // ── runs ──────────────────────────────────────────────────────────────────────────────────────
@@ -223,6 +449,7 @@ class InMemoryAgentRunStore implements AgentRunStore {
         `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`
       )
     }
+    assertConversationThreadRow(thread, "takes turns")
     if (thread.activeRunId !== null) {
       throw new AgentStorageError(
         "active_run_exists",
@@ -344,18 +571,72 @@ class InMemoryAgentRunStore implements AgentRunStore {
       )
     }
 
+    // The child's thread: created by its first run, taken by a later one while it is idle.
+    const createdAt = new Date(input.createdAt ?? new Date())
+    const threadKey = key(input.projectId, input.thread.id)
+    const existingThread = this.state.threads.get(threadKey) ?? null
+    let thread: AgentThreadRecord
+    if (input.thread.create) {
+      if (existingThread) {
+        throw new AgentStorageError(
+          "duplicate_id",
+          `[Sixb] Agent thread '${input.thread.id}' already exists for project '${input.projectId}'.`
+        )
+      }
+      const conversation = this.state.threads.get(key(input.projectId, parent.threadId))
+      if (!conversation) {
+        throw new AgentStorageError(
+          "thread_not_found",
+          `[Sixb] Agent thread '${parent.threadId}' not found for project '${input.projectId}'.`
+        )
+      }
+      thread = newSubagentThreadRecord(input, conversation, createdAt)
+    } else {
+      assertSubagentThreadTakesRun(existingThread, input, parent.threadId)
+      thread = {
+        ...existingThread,
+        activeRunId: input.id,
+        messageCount: existingThread.messageCount + 1,
+        lastMessageAt: createdAt,
+        updatedAt: createdAt,
+      }
+    }
+
     const run: SubagentRunRecord = {
       kind: "subagent",
       id: input.id,
       projectId: input.projectId,
       executionId: input.executionId,
+      threadId: input.thread.id,
+      triggerMessageId: input.trigger.id,
       parentRunId: input.parentRunId,
       spawnKey: input.spawnKey,
       spec: clone(input.spec),
       status: "queued",
       attempt: 0,
-      createdAt: new Date(input.createdAt ?? new Date()),
+      createdAt,
+    }
+    const trigger: AgentMessageRecord = {
+      id: input.trigger.id,
+      projectId: input.projectId,
+      threadId: input.thread.id,
+      runId: input.id,
+      role: "user",
+      seq: nextMessageSeq(this.state, input.projectId, input.thread.id),
+      parts: clone(input.trigger.parts),
+      ...(input.trigger.metadata === undefined ? {} : { metadata: clone(input.trigger.metadata) }),
+      contentVersion: AGENT_MESSAGE_CONTENT_VERSION,
+      createdAt,
+    }
+    if (this.state.messages.has(key(input.projectId, trigger.id))) {
+      throw new AgentStorageError(
+        "duplicate_id",
+        `[Sixb] Agent message '${trigger.id}' already exists for project '${input.projectId}'.`
+      )
     }
+
+    this.state.threads.set(threadKey, clone(thread))
+    this.state.messages.set(key(input.projectId, trigger.id), clone(trigger))
     this.state.runs.set(runKey, clone(run))
     return clone(run)
   }
@@ -432,14 +713,13 @@ class InMemoryAgentRunStore implements AgentRunStore {
         `[Sixb] Execution token is no longer current on agent run '${input.id}'.`
       )
     }
-    if (input.status === "succeeded" && run.kind === "subagent") {
-      assertSubagentRunResult(input.result, run.id)
-    }
-    if (input.status === "succeeded" && run.kind === "conversation" && input.result !== undefined) {
-      throw new AgentStorageError(
-        "invalid_input",
-        `[Sixb] Conversational Agent run '${run.id}' cannot persist a subagent result.`
-      )
+    assertAgentRunFinishPayload(run.kind, input, run.id, "Sixb")
+    if (input.finishReason === "awaiting_approval") {
+      assertAwaitingApprovalFinish({
+        runId: run.id,
+        status: input.status,
+        holdsApproval: holdsRun(this.state, run.projectId, run.id),
+      })
     }
 
     const completedAt = new Date(input.completedAt ?? new Date())
@@ -461,6 +741,7 @@ class InMemoryAgentRunStore implements AgentRunStore {
     this.state.runs.set(key(input.projectId, input.id), clone(next))
 
     this.releaseThread(run, completedAt)
+    this.settleApprovals(run, input, completedAt)
 
     return clone(next)
   }
@@ -480,6 +761,37 @@ class InMemoryAgentRunStore implements AgentRunStore {
       .map(clone)
   }
 
+  async listThreadSubagents(
+    input: ListThreadSubagentsInput
+  ): Promise<readonly SubagentRunRecord[]> {
+    const runs = [...this.state.runs.values()].filter((run) => run.projectId === input.projectId)
+    const turns = new Map(
+      runs.flatMap((run) =>
+        run.kind === "conversation" && run.threadId === input.threadId ? [[run.id, run]] : []
+      )
+    )
+    const children = runs
+      .filter((run): run is SubagentRunRecord => run.kind === "subagent")
+      .filter((run) => turns.has(run.parentRunId))
+      .filter((run) => (input.spawnKey === undefined ? true : run.spawnKey === input.spawnKey))
+      .filter((run) =>
+        input.finishReason === undefined ? true : run.finishReason === input.finishReason
+      )
+      .sort((left, right) => {
+        const [a, b] = [turns.get(left.parentRunId), turns.get(right.parentRunId)]
+        return (
+          compareByDate(
+            a?.startedAt ?? a?.createdAt,
+            b?.startedAt ?? b?.createdAt,
+            left.parentRunId,
+            right.parentRunId,
+            "desc"
+          ) || compareByDate(left.createdAt, right.createdAt, left.id, right.id, "desc")
+        )
+      })
+    return children.slice(0, input.limit ?? 100).map(clone)
+  }
+
   async list(input: ListAgentRunsInput): Promise<ListAgentRunsResult> {
     const order = input.order ?? "desc"
     const statuses = input.statuses ? new Set(input.statuses) : null
@@ -488,9 +800,7 @@ class InMemoryAgentRunStore implements AgentRunStore {
     const filtered = [...this.state.runs.values()]
       .filter((run) => run.projectId === input.projectId)
       .filter((run) => (kinds ? kinds.has(run.kind) : true))
-      .filter((run) =>
-        input.threadId ? run.kind === "conversation" && run.threadId === input.threadId : true
-      )
+      .filter((run) => (input.threadId ? run.threadId === input.threadId : true))
       .filter((run) =>
         input.parentRunId ? run.kind === "subagent" && run.parentRunId === input.parentRunId : true
       )
@@ -534,8 +844,37 @@ class InMemoryAgentRunStore implements AgentRunStore {
     return run
   }
 
+  /**
+   * A turn that pauses keeps its calls for their decision. A turn that ends any other way cancels
+   * the ones still waiting, a late one included, and never resumes on the rest. A child that fails
+   * or is cancelled takes its own pending calls with it.
+   */
+  private settleApprovals(run: AgentRunRecord, input: FinishAgentRunInput, at: Date): void {
+    if (input.finishReason === "awaiting_approval" || !agentRunMayHoldCalls(run)) return
+
+    const turn = run.kind === "conversation"
+    if (!turn && input.status === "succeeded") return
+    for (const [approvalKey, approval] of this.state.approvals) {
+      if (approval.projectId !== run.projectId) continue
+      const ownCall = approval.runId === run.id || approval.callerRunId === run.id
+      const cancel = approval.status === "pending" && ownCall
+      const stop =
+        turn &&
+        approval.runId === run.id &&
+        approval.reportedInMessageId === undefined &&
+        approval.turnStoppedAt === undefined
+      if (!cancel && !stop) continue
+
+      this.state.approvals.set(approvalKey, {
+        ...approval,
+        ...(cancel ? { status: "cancelled" as const } : {}),
+        ...(stop ? { turnStoppedAt: new Date(at) } : {}),
+      })
+    }
+  }
+
+  /** A turn releases its conversation, a child run its own thread. */
   private releaseThread(run: AgentRunRecord, completedAt: Date): void {
-    if (run.kind !== "conversation") return
     const threadKey = key(run.projectId, run.threadId)
     const thread = this.state.threads.get(threadKey)
     if (thread && thread.activeRunId === run.id) {
@@ -578,7 +917,7 @@ class InMemoryAgentMessageStore implements AgentMessageStore {
     }
 
     const createdAt = new Date(input.createdAt ?? new Date())
-    const seq = this.nextSeq(input.projectId, input.threadId)
+    const seq = nextMessageSeq(this.state, input.projectId, input.threadId)
     const message: AgentMessageRecord = {
       id: input.id,
       projectId: input.projectId,
@@ -601,7 +940,7 @@ class InMemoryAgentMessageStore implements AgentMessageStore {
       threadKey,
       clone({
         ...thread,
-        messageCount: thread.messageCount + 1,
+        messageCount: thread.messageCount + (countsAsThreadMessage(input) ? 1 : 0),
         lastMessageAt: createdAt,
         updatedAt: createdAt,
       })
@@ -645,7 +984,7 @@ class InMemoryAgentMessageStore implements AgentMessageStore {
       threadKey,
       clone({
         ...thread,
-        messageCount: remainingMessages.length,
+        messageCount: remainingMessages.filter(countsAsThreadMessage).length,
         lastMessageAt: latestMessage?.createdAt,
         updatedAt,
       })
@@ -673,16 +1012,16 @@ class InMemoryAgentMessageStore implements AgentMessageStore {
     const { page, hasMore, total } = applyWindow(filtered, input.offset, input.limit)
     return { messages: page.map(clone), hasMore, total }
   }
+}
 
-  private nextSeq(projectId: string, threadId: string): number {
-    let max = 0
-    for (const message of this.state.messages.values()) {
-      if (message.projectId === projectId && message.threadId === threadId && message.seq > max) {
-        max = message.seq
-      }
+function nextMessageSeq(state: AgentStoreState, projectId: string, threadId: string): number {
+  let max = 0
+  for (const message of state.messages.values()) {
+    if (message.projectId === projectId && message.threadId === threadId && message.seq > max) {
+      max = message.seq
     }
-    return max + 1
   }
+  return max + 1
 }
 
 // ── context checkpoints ──────────────────────────────────────────────────────────────────────
@@ -707,6 +1046,7 @@ class InMemoryAgentContextCheckpointStore implements AgentContextCheckpointStore
     const existingForRun = [...this.state.checkpoints.values()].find(
       (checkpoint) =>
         checkpoint.projectId === input.projectId &&
+        checkpoint.threadId === input.threadId &&
         checkpoint.createdByRunId === input.createdByRunId
     )
     if (existingForRun) {
@@ -775,11 +1115,13 @@ class InMemoryAgentContextCheckpointStore implements AgentContextCheckpointStore
 
   async getByRunIds(input: {
     readonly projectId: string
+    readonly threadId: string
     readonly runIds: readonly string[]
   }): Promise<readonly AgentContextCheckpointRecord[]> {
     const byRunId = new Map(
       [...this.state.checkpoints.values()]
         .filter((checkpoint) => checkpoint.projectId === input.projectId)
+        .filter((checkpoint) => checkpoint.threadId === input.threadId)
         .map((checkpoint) => [checkpoint.createdByRunId, checkpoint] as const)
     )
     return [...new Set(input.runIds)].flatMap((runId) => {
@@ -794,50 +1136,465 @@ class InMemoryAgentContextCheckpointStore implements AgentContextCheckpointStore
         .filter(
           (checkpoint) => checkpoint.projectId === projectId && checkpoint.threadId === threadId
         )
-        .sort(
-          (left, right) =>
-            right.summarizedThroughSeq - left.summarizedThroughSeq ||
-            right.createdAt.getTime() - left.createdAt.getTime() ||
-            right.id.localeCompare(left.id)
-        )[0] ?? null
+        .sort(compareLatestCheckpoints)[0] ?? null
+    )
+  }
+}
+
+/** The order `getLatest` reads: the furthest boundary, then the newest. */
+function compareLatestCheckpoints(
+  left: AgentContextCheckpointRecord,
+  right: AgentContextCheckpointRecord
+): number {
+  return (
+    right.summarizedThroughSeq - left.summarizedThroughSeq ||
+    right.createdAt.getTime() - left.createdAt.getTime() ||
+    right.id.localeCompare(left.id)
+  )
+}
+
+// ── memory ────────────────────────────────────────────────────────────────────────────────────
+
+class InMemoryAgentMemoryStore implements AgentMemoryStore {
+  constructor(private readonly state: AgentStoreState) {}
+
+  async get(input: {
+    projectId: string
+    repoId: string
+    asOf?: Date
+    revision?: number
+  }): Promise<AgentMemoryRepoRecord> {
+    const repo = this.state.memory.get(key(input.projectId, input.repoId))
+    const { asOf, revision: upTo } = input
+    const saved = repo?.revisions.filter(
+      (entry) =>
+        (!asOf || entry.createdAt.getTime() <= asOf.getTime()) &&
+        (upTo === undefined || entry.revision <= upTo)
+    )
+    const revision = saved?.reduce((highest, entry) => Math.max(highest, entry.revision), 0) ?? 0
+    if (!repo || revision === 0) return { revision: 0, files: [] }
+    const files = [
+      ...latestMemoryFiles({
+        revisions: repo.revisions,
+        files: repo.files.filter((file) => file.revision <= revision),
+      }).values(),
+    ]
+      .flatMap((file) =>
+        file.contents === null ? [] : [{ path: file.path, contents: file.contents }]
+      )
+      .sort((left, right) => compareAgentMemoryPaths(left.path, right.path))
+    return { revision, files }
+  }
+
+  async save(input: SaveAgentMemoryInput): Promise<SaveAgentMemoryResult> {
+    assertSaveAgentMemoryInput(input)
+    const repoKey = key(input.projectId, input.repoId)
+    const repo = this.state.memory.get(repoKey) ?? { revisions: [], files: [] }
+    const head = repo.revisions.at(-1)?.revision ?? 0
+    const conflicts = agentMemoryConflicts(input, head, latestMemoryFiles(repo))
+    if (conflicts.length > 0) return { saved: false, revision: head, conflicts }
+
+    const revision = head + 1
+    const createdAt = input.createdAt ?? new Date()
+    const revisions = [
+      ...repo.revisions,
+      {
+        revision,
+        message: input.message,
+        author: clone(input.author),
+        ...(input.source === undefined ? {} : { source: input.source }),
+        createdAt: new Date(createdAt),
+      },
+    ]
+    const files = [...repo.files, ...input.changes.map((change) => ({ ...change, revision }))]
+
+    const cutoff = agentMemoryHistoryCutoff(createdAt).getTime()
+    const savedAt = new Map(revisions.map((entry) => [entry.revision, entry.createdAt.getTime()]))
+    const latest = latestMemoryFiles({ revisions, files })
+    this.state.memory.set(repoKey, {
+      revisions,
+      files: files.filter(
+        (file) => latest.get(file.path) === file || (savedAt.get(file.revision) ?? 0) >= cutoff
+      ),
+    })
+    return { saved: true, revision }
+  }
+
+  async listRevisions(
+    input: ListAgentMemoryRevisionsInput
+  ): Promise<ListAgentMemoryRevisionsResult> {
+    const repo = this.state.memory.get(key(input.projectId, input.repoId))
+    const newestFirst = [...(repo?.revisions ?? [])].reverse()
+    const { page, hasMore, total } = applyWindow(newestFirst, input.offset, input.limit)
+    const revisions = page.map(
+      (entry): AgentMemoryRevisionRecord => ({
+        ...clone(entry),
+        changes: (repo?.files ?? [])
+          .filter((file) => file.revision === entry.revision)
+          .map((file) => ({ path: file.path, deleted: file.contents === null }))
+          .sort((left, right) => compareAgentMemoryPaths(left.path, right.path)),
+      })
     )
+    return { revisions, hasMore, total }
+  }
+
+  async delete(input: { projectId: string; repoId: string }): Promise<void> {
+    this.state.memory.delete(key(input.projectId, input.repoId))
+  }
+}
+
+/** Each path's highest-revision version, the deleted ones included. */
+function latestMemoryFiles(
+  repo: StoredAgentMemoryRepo
+): Map<string, StoredAgentMemoryRepo["files"][number]> {
+  const latest = new Map<string, StoredAgentMemoryRepo["files"][number]>()
+  for (const file of repo.files) latest.set(file.path, file)
+  return latest
+}
+
+// ── approvals ─────────────────────────────────────────────────────────────────────────────────
+
+class InMemoryAgentApprovalStore implements AgentApprovalStore {
+  constructor(private readonly state: AgentStoreState) {}
+
+  async request(input: RequestAgentApprovalInput): Promise<RequestAgentApprovalResult> {
+    assertRequestAgentApprovalInput(input)
+
+    const threadId = assertAgentApprovalCaller({
+      request: input,
+      turn: this.state.runs.get(key(input.projectId, input.runId)) ?? null,
+      caller: this.state.runs.get(key(input.projectId, input.callerRunId)) ?? null,
+    })
+    const callKey = agentApprovalCallKey(input.call)
+    const live = [...this.state.approvals.values()].find(
+      (approval) =>
+        approval.projectId === input.projectId &&
+        approval.threadId === threadId &&
+        approval.callKey === callKey &&
+        (LIVE_AGENT_APPROVAL_STATUSES as readonly string[]).includes(approval.status)
+    )
+    if (live) return { approval: clone(live), created: false }
+
+    if (this.state.approvals.has(key(input.projectId, input.id))) {
+      throw new AgentStorageError(
+        "duplicate_id",
+        `[Sixb] Agent approval '${input.id}' already exists for project '${input.projectId}'.`
+      )
+    }
+    const approval = newAgentApprovalRecord(input, threadId)
+    this.state.approvals.set(key(input.projectId, input.id), clone(approval))
+    return { approval: clone(approval), created: true }
   }
+
+  async decide(input: DecideAgentApprovalInput): Promise<DecideAgentApprovalResult | null> {
+    const approvalKey = key(input.projectId, input.id)
+    const approval = this.state.approvals.get(approvalKey)
+    if (!approval) return null
+    if (approval.status !== "pending") return { approval: clone(approval), decided: false }
+
+    const decidedAt = new Date(input.decidedAt ?? new Date())
+    const next: AgentApprovalRecord =
+      approval.expiresAt <= decidedAt
+        ? { ...approval, status: "expired" }
+        : {
+            ...approval,
+            status: input.decision,
+            decidedAt,
+            decidedBy: clone(input.decidedBy),
+            ...(input.decision === "approved" && input.raisedMode !== undefined
+              ? { raisedMode: input.raisedMode }
+              : {}),
+          }
+    this.state.approvals.set(approvalKey, clone(next))
+    return { approval: clone(next), decided: next.status === input.decision }
+  }
+
+  async recordOutcome(input: {
+    readonly projectId: string
+    readonly id: string
+    readonly outcome: AgentApprovalOutcome
+  }): Promise<AgentApprovalRecord> {
+    const approvalKey = key(input.projectId, input.id)
+    const approval = this.state.approvals.get(approvalKey)
+    if (!approval) {
+      throw new AgentStorageError(
+        "invalid_state",
+        `[Sixb] Agent approval '${input.id}' not found for project '${input.projectId}'.`
+      )
+    }
+    if (approval.status !== "approved") {
+      throw new AgentStorageError(
+        "invalid_state",
+        `[Sixb] Agent approval '${input.id}' is not approved (status '${approval.status}').`
+      )
+    }
+    if (approval.outcome) return clone(approval)
+
+    const next = { ...approval, outcome: clone(input.outcome) }
+    this.state.approvals.set(approvalKey, clone(next))
+    return clone(next)
+  }
+
+  async settle(input: SettleAgentApprovalsInput): Promise<readonly AgentApprovalRecord[]> {
+    const settled: AgentApprovalRecord[] = []
+    for (const [approvalKey, approval] of this.state.approvals) {
+      if (
+        approval.projectId !== input.projectId ||
+        approval.threadId !== input.threadId ||
+        approval.status !== "pending"
+      ) {
+        continue
+      }
+      const next = { ...approval, status: input.status }
+      this.state.approvals.set(approvalKey, clone(next))
+      settled.push(next)
+    }
+    return settled.sort(compareApprovals).map(clone)
+  }
+
+  async expireDue(input: {
+    readonly projectId: string
+    readonly now: Date
+    readonly limit?: number
+  }): Promise<readonly AgentApprovalRecord[]> {
+    const due = [...this.state.approvals.values()]
+      .filter(
+        (approval) =>
+          approval.projectId === input.projectId &&
+          approval.status === "pending" &&
+          approval.expiresAt <= input.now
+      )
+      .sort(compareApprovals)
+      .slice(0, input.limit)
+
+    return due.map((approval) => {
+      const next = { ...approval, status: "expired" as const }
+      this.state.approvals.set(key(approval.projectId, approval.id), clone(next))
+      return clone(next)
+    })
+  }
+
+  async stop(input: StopAgentApprovalsInput): Promise<StopAgentApprovalsResult> {
+    const stoppedAt = new Date(input.stoppedAt ?? new Date())
+    const cancelled: AgentApprovalRecord[] = []
+    let stopped = 0
+    for (const [approvalKey, approval] of this.state.approvals) {
+      if (!agentApprovalStops(approval, input)) continue
+
+      const cancel = approval.status === "pending"
+      const stop = approval.turnStoppedAt === undefined
+      if (!cancel && !stop) continue
+      const next: AgentApprovalRecord = {
+        ...approval,
+        ...(cancel ? { status: "cancelled" as const } : {}),
+        ...(stop ? { turnStoppedAt: stoppedAt } : {}),
+      }
+      this.state.approvals.set(approvalKey, clone(next))
+      if (cancel) cancelled.push(next)
+      if (stop) stopped += 1
+    }
+    return { cancelled: cancelled.sort(compareApprovals).map(clone), stopped }
+  }
+
+  async holdsRun(input: { readonly projectId: string; readonly runId: string }): Promise<boolean> {
+    return holdsRun(this.state, input.projectId, input.runId)
+  }
+
+  async claimExecution(input: {
+    readonly projectId: string
+    readonly id: string
+    readonly claimedAt: Date
+    readonly staleBefore: Date
+  }): Promise<AgentApprovalRecord | null> {
+    const approvalKey = key(input.projectId, input.id)
+    const approval = this.state.approvals.get(approvalKey)
+    if (!approval || !agentApprovalClaimable(approval, input.staleBefore)) return null
+
+    const next = { ...approval, executionClaimedAt: new Date(input.claimedAt) }
+    this.state.approvals.set(approvalKey, clone(next))
+    return clone(next)
+  }
+
+  async listRepairable(input: {
+    readonly projectId: string
+    readonly claimableBefore: Date
+    readonly after?: AgentApprovalCursor
+    readonly limit: number
+  }): Promise<readonly AgentApprovalRecord[]> {
+    const { after } = input
+    return [...this.state.approvals.values()]
+      .filter(
+        (approval) =>
+          approval.projectId === input.projectId &&
+          agentApprovalRepairable(approval, input.claimableBefore) &&
+          (after === undefined ||
+            approval.createdAt > after.createdAt ||
+            (approval.createdAt.getTime() === after.createdAt.getTime() && approval.id > after.id))
+      )
+      .sort(compareApprovals)
+      .slice(0, input.limit)
+      .map(clone)
+  }
+
+  async markReported(input: MarkAgentApprovalsReportedInput): Promise<readonly string[]> {
+    const marked: string[] = []
+    for (const id of new Set(input.ids)) {
+      const approvalKey = key(input.projectId, id)
+      const approval = this.state.approvals.get(approvalKey)
+      if (
+        !approval ||
+        approval.threadId !== input.threadId ||
+        approval.reportedInMessageId !== undefined ||
+        (input.resuming === true && approval.turnStoppedAt !== undefined)
+      ) {
+        continue
+      }
+      this.state.approvals.set(approvalKey, { ...approval, reportedInMessageId: input.messageId })
+      marked.push(id)
+    }
+    return marked
+  }
+
+  async getById(params: {
+    readonly projectId: string
+    readonly id: string
+  }): Promise<AgentApprovalRecord | null> {
+    const approval = this.state.approvals.get(key(params.projectId, params.id))
+    return approval ? clone(approval) : null
+  }
+
+  async list(input: ListAgentApprovalsInput): Promise<ListAgentApprovalsResult> {
+    const matching = [...this.state.approvals.values()]
+      .filter((approval) => agentApprovalMatches(approval, input))
+      .sort(compareApprovals)
+    const { page, hasMore, total } = applyWindow(matching, input.offset, input.limit)
+    return { approvals: page.map(clone), hasMore, total }
+  }
+}
+
+function holdsRun(state: AgentStoreState, projectId: string, runId: string): boolean {
+  return [...state.approvals.values()].some(
+    (approval) => approval.projectId === projectId && agentApprovalHoldsRun(approval, runId)
+  )
+}
+
+/** Oldest first, then by id: the order every provider lists approvals in. */
+function compareApprovals(left: AgentApprovalRecord, right: AgentApprovalRecord): number {
+  return compareByDate(left.createdAt, right.createdAt, left.id, right.id, "asc")
+}
+
+class InMemoryAgentApprovalModeStore implements AgentApprovalModeStore {
+  constructor(private readonly state: AgentStoreState) {}
+
+  async getDefault(input: {
+    readonly projectId: string
+    readonly principal: Principal
+  }): Promise<AgentApprovalMode | null> {
+    return this.state.approvalModes.get(defaultModeKey(input)) ?? null
+  }
+
+  async setDefault(input: {
+    readonly projectId: string
+    readonly principal: Principal
+    readonly mode: AgentApprovalMode
+  }): Promise<void> {
+    assertAgentApprovalModeInput(input.mode)
+    this.state.approvalModes.set(defaultModeKey(input), input.mode)
+  }
+
+  async getForThread(input: {
+    readonly projectId: string
+    readonly threadId: string
+    readonly principal: Principal
+  }): Promise<AgentApprovalMode | null> {
+    return this.state.approvalModes.get(threadModeKey(input)) ?? null
+  }
+
+  async setForThread(input: {
+    readonly projectId: string
+    readonly threadId: string
+    readonly principal: Principal
+    readonly mode: AgentApprovalMode | null
+  }): Promise<void> {
+    if (input.mode !== null) assertAgentApprovalModeInput(input.mode)
+    if (!this.state.threads.has(key(input.projectId, input.threadId))) {
+      throw new AgentStorageError(
+        "thread_not_found",
+        `[Sixb] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`
+      )
+    }
+    if (input.mode === null) {
+      this.state.approvalModes.delete(threadModeKey(input))
+      return
+    }
+    this.state.approvalModes.set(threadModeKey(input), input.mode)
+  }
+}
+
+function defaultModeKey(input: { readonly projectId: string; readonly principal: Principal }) {
+  return JSON.stringify([input.projectId, input.principal.type, input.principal.id])
+}
+
+function threadModeKey(input: {
+  readonly projectId: string
+  readonly threadId: string
+  readonly principal: Principal
+}) {
+  return JSON.stringify([input.projectId, input.threadId, input.principal.type, input.principal.id])
 }
 
 export class InMemoryAgentStorage implements AgentStorage {
   private readonly state: AgentStoreState = {
     threads: new Map(),
+    participants: new Map(),
     runs: new Map(),
     messages: new Map(),
     checkpoints: new Map(),
+    memory: new Map(),
+    approvals: new Map(),
+    approvalModes: new Map(),
   }
 
   readonly threads: InMemoryAgentThreadStore
   readonly runs: InMemoryAgentRunStore
   readonly messages: InMemoryAgentMessageStore
   readonly checkpoints: InMemoryAgentContextCheckpointStore
+  readonly memory: InMemoryAgentMemoryStore
+  readonly approvals: InMemoryAgentApprovalStore
+  readonly approvalModes: InMemoryAgentApprovalModeStore
 
   constructor(executions: ExecutionStorage) {
     this.threads = new InMemoryAgentThreadStore(this.state)
     this.runs = new InMemoryAgentRunStore(this.state, executions)
     this.messages = new InMemoryAgentMessageStore(this.state)
     this.checkpoints = new InMemoryAgentContextCheckpointStore(this.state)
+    this.memory = new InMemoryAgentMemoryStore(this.state)
+    this.approvals = new InMemoryAgentApprovalStore(this.state)
+    this.approvalModes = new InMemoryAgentApprovalModeStore(this.state)
   }
 
   snapshot(): InMemoryAgentStorageSnapshot {
     return {
       threads: structuredClone(this.state.threads),
+      participants: structuredClone(this.state.participants),
       runs: structuredClone(this.state.runs),
       messages: structuredClone(this.state.messages),
       checkpoints: structuredClone(this.state.checkpoints),
+      memory: structuredClone(this.state.memory),
+      approvals: structuredClone(this.state.approvals),
+      approvalModes: structuredClone(this.state.approvalModes),
     }
   }
 
   restore(snapshot: InMemoryAgentStorageSnapshot): void {
     replace(this.state.threads, snapshot.threads)
+    replace(this.state.participants, snapshot.participants)
     replace(this.state.runs, snapshot.runs)
     replace(this.state.messages, snapshot.messages)
     replace(this.state.checkpoints, snapshot.checkpoints)
+    replace(this.state.memory, snapshot.memory)
+    replace(this.state.approvals, snapshot.approvals)
+    replace(this.state.approvalModes, snapshot.approvalModes)
   }
 }