@cuongtran001/kanna 1.3.0 → 1.4.0

package/src/server/event-store-tool-requests.test.ts

@@ -0,0 +1,210 @@
+import { describe, expect, test } from "bun:test"
+import type { ToolRequest } from "../shared/permission-policy"
+import type { ToolRequestEvent } from "./events"
+import {
+  applyToolRequestEvent,
+  deleteToolRequestsForChat,
+  getToolRequest,
+  listPendingToolRequests,
+  scanAllToolRequests,
+} from "./event-store-tool-requests"
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const TS = 1_700_000_000_000
+
+function makeRequest(overrides: Partial<ToolRequest> = {}): ToolRequest {
+  return {
+    id: "req-1",
+    chatId: "chat-1",
+    sessionId: "session-1",
+    toolUseId: "tool-use-1",
+    toolName: "Bash",
+    arguments: { command: "ls" },
+    canonicalArgsHash: "abc123",
+    policyVerdict: "ask",
+    status: "pending",
+    createdAt: TS,
+    expiresAt: TS + 600_000,
+    ...overrides,
+  }
+}
+
+function putEvent(req: ToolRequest): Extract<ToolRequestEvent, { type: "tool_request_put" }> {
+  return { v: 3, type: "tool_request_put", timestamp: TS, request: req }
+}
+
+function resolvedEvent(
+  id: string,
+  overrides: Partial<Extract<ToolRequestEvent, { type: "tool_request_resolved" }>> = {},
+): Extract<ToolRequestEvent, { type: "tool_request_resolved" }> {
+  return {
+    v: 3,
+    type: "tool_request_resolved",
+    timestamp: TS + 1000,
+    id,
+    status: "answered",
+    resolvedAt: TS + 1000,
+    ...overrides,
+  }
+}
+
+// ---------------------------------------------------------------------------
+// applyToolRequestEvent — tool_request_put
+// ---------------------------------------------------------------------------
+
+describe("applyToolRequestEvent / tool_request_put", () => {
+  test("inserts a defensive copy into the map", () => {
+    const map = new Map<string, ToolRequest>()
+    const req = makeRequest()
+    applyToolRequestEvent(map, putEvent(req))
+    expect(map.size).toBe(1)
+    expect(map.get("req-1")).toEqual(req)
+    // defensive copy — mutation of the original must not affect the stored value
+    req.status = "canceled"
+    expect(map.get("req-1")?.status).toBe("pending")
+  })
+
+  test("overwrites an existing entry for the same id", () => {
+    const map = new Map<string, ToolRequest>()
+    const first = makeRequest({ id: "req-1", toolName: "Read" })
+    const second = makeRequest({ id: "req-1", toolName: "Bash" })
+    applyToolRequestEvent(map, putEvent(first))
+    applyToolRequestEvent(map, putEvent(second))
+    expect(map.get("req-1")?.toolName).toBe("Bash")
+    expect(map.size).toBe(1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// applyToolRequestEvent — tool_request_resolved
+// ---------------------------------------------------------------------------
+
+describe("applyToolRequestEvent / tool_request_resolved", () => {
+  test("updates status, decision, resolvedAt, and mismatchReason", () => {
+    const map = new Map<string, ToolRequest>()
+    applyToolRequestEvent(map, putEvent(makeRequest()))
+    applyToolRequestEvent(map, resolvedEvent("req-1", {
+      status: "answered",
+      decision: { kind: "allow" },
+      resolvedAt: TS + 5000,
+      mismatchReason: undefined,
+    }))
+    const stored = map.get("req-1")
+    expect(stored?.status).toBe("answered")
+    expect(stored?.decision).toEqual({ kind: "allow" })
+    expect(stored?.resolvedAt).toBe(TS + 5000)
+  })
+
+  test("is a no-op when id is unknown", () => {
+    const map = new Map<string, ToolRequest>()
+    applyToolRequestEvent(map, resolvedEvent("nonexistent"))
+    expect(map.size).toBe(0)
+  })
+
+  test("preserves existing decision when event omits it", () => {
+    const map = new Map<string, ToolRequest>()
+    const req = makeRequest({ decision: { kind: "deny", reason: "blocked" } })
+    applyToolRequestEvent(map, putEvent(req))
+    applyToolRequestEvent(map, resolvedEvent("req-1", { status: "timeout", decision: undefined }))
+    expect(map.get("req-1")?.decision).toEqual({ kind: "deny", reason: "blocked" })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getToolRequest
+// ---------------------------------------------------------------------------
+
+describe("getToolRequest", () => {
+  test("returns a defensive copy when found", () => {
+    const map = new Map<string, ToolRequest>()
+    const req = makeRequest()
+    map.set("req-1", req)
+    const result = getToolRequest(map, "req-1")
+    expect(result).toEqual(req)
+    // defensive copy
+    result!.status = "canceled"
+    expect(map.get("req-1")?.status).toBe("pending")
+  })
+
+  test("returns null when not found", () => {
+    const map = new Map<string, ToolRequest>()
+    expect(getToolRequest(map, "missing")).toBeNull()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// listPendingToolRequests
+// ---------------------------------------------------------------------------
+
+describe("listPendingToolRequests", () => {
+  test("returns only pending requests for the given chatId", () => {
+    const map = new Map<string, ToolRequest>()
+    map.set("r1", makeRequest({ id: "r1", chatId: "chat-1", status: "pending" }))
+    map.set("r2", makeRequest({ id: "r2", chatId: "chat-1", status: "answered" }))
+    map.set("r3", makeRequest({ id: "r3", chatId: "chat-2", status: "pending" }))
+    const result = listPendingToolRequests(map, "chat-1")
+    expect(result).toHaveLength(1)
+    expect(result[0].id).toBe("r1")
+  })
+
+  test("returns empty array when no pending requests exist for chat", () => {
+    const map = new Map<string, ToolRequest>()
+    map.set("r1", makeRequest({ id: "r1", chatId: "chat-1", status: "answered" }))
+    expect(listPendingToolRequests(map, "chat-1")).toEqual([])
+  })
+
+  test("returns defensive copies", () => {
+    const map = new Map<string, ToolRequest>()
+    map.set("r1", makeRequest({ id: "r1", chatId: "chat-1", status: "pending" }))
+    const results = listPendingToolRequests(map, "chat-1")
+    results[0].status = "canceled"
+    expect(map.get("r1")?.status).toBe("pending")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// scanAllToolRequests
+// ---------------------------------------------------------------------------
+
+describe("scanAllToolRequests", () => {
+  test("returns defensive copies of every entry in the map", () => {
+    const map = new Map<string, ToolRequest>()
+    map.set("r1", makeRequest({ id: "r1" }))
+    map.set("r2", makeRequest({ id: "r2", chatId: "chat-2", status: "answered" }))
+    const all = scanAllToolRequests(map)
+    expect(all).toHaveLength(2)
+    // defensive copy
+    all[0].status = "canceled"
+    expect(map.get("r1")?.status).toBe("pending")
+  })
+
+  test("returns empty array for an empty map", () => {
+    expect(scanAllToolRequests(new Map())).toEqual([])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// deleteToolRequestsForChat
+// ---------------------------------------------------------------------------
+
+describe("deleteToolRequestsForChat", () => {
+  test("removes all entries belonging to the chat", () => {
+    const map = new Map<string, ToolRequest>()
+    map.set("r1", makeRequest({ id: "r1", chatId: "chat-1" }))
+    map.set("r2", makeRequest({ id: "r2", chatId: "chat-1" }))
+    map.set("r3", makeRequest({ id: "r3", chatId: "chat-2" }))
+    deleteToolRequestsForChat(map, "chat-1")
+    expect(map.size).toBe(1)
+    expect(map.has("r3")).toBe(true)
+  })
+
+  test("leaves the map unchanged when no entries belong to the chat", () => {
+    const map = new Map<string, ToolRequest>()
+    map.set("r1", makeRequest({ id: "r1", chatId: "chat-2" }))
+    deleteToolRequestsForChat(map, "chat-1")
+    expect(map.size).toBe(1)
+  })
+})

package/src/server/event-store-tool-requests.ts

@@ -0,0 +1,131 @@
+/**
+ * Tool-request read-model and write-path layers extracted from event-store.ts.
+ *
+ * All read functions are pure folds over the in-memory `toolRequestsById` map.
+ * Write functions (putToolRequest, resolveToolRequest) accept a ToolRequestWriteDeps
+ * so they can append to the event log without importing disk IO directly.
+ */
+import type { ToolRequest, ToolRequestDecision, ToolRequestStatus } from "../shared/permission-policy"
+import type { StoreEvent, ToolRequestEvent } from "./events"
+import {
+  buildPutToolRequestEvent,
+  buildResolveToolRequestEvent,
+} from "./event-store-write-ops"
+
+// ─── Write-path deps ──────────────────────────────────────────────────────
+
+export interface ToolRequestWriteDeps {
+  readonly toolRequestsById: Map<string, ToolRequest>
+  readonly toolRequestsLogPath: string
+  append: (filePath: string, event: StoreEvent) => Promise<void>
+}
+
+/**
+ * Apply a single `ToolRequestEvent` to the in-memory `toolRequestsById` map
+ * (mutates in place).
+ *
+ * Mirrors the two `case "tool_request_*"` branches that previously lived
+ * inside `EventStore.applyEvent`.
+ */
+export function applyToolRequestEvent(
+  toolRequestsById: Map<string, ToolRequest>,
+  event: ToolRequestEvent,
+): void {
+  switch (event.type) {
+    case "tool_request_put": {
+      toolRequestsById.set(event.request.id, { ...event.request })
+      break
+    }
+    case "tool_request_resolved": {
+      const existing = toolRequestsById.get(event.id)
+      if (!existing) break
+      toolRequestsById.set(event.id, {
+        ...existing,
+        status: event.status,
+        decision: event.decision ?? existing.decision,
+        resolvedAt: event.resolvedAt,
+        mismatchReason: event.mismatchReason,
+      })
+      break
+    }
+  }
+}
+
+/**
+ * Return a defensive copy of the tool request with the given id, or `null`
+ * if not found.
+ */
+export function getToolRequest(
+  toolRequestsById: Map<string, ToolRequest>,
+  id: string,
+): ToolRequest | null {
+  const req = toolRequestsById.get(id)
+  return req ? { ...req } : null
+}
+
+/**
+ * Return defensive copies of all pending tool requests for the given chat.
+ */
+export function listPendingToolRequests(
+  toolRequestsById: Map<string, ToolRequest>,
+  chatId: string,
+): ToolRequest[] {
+  const out: ToolRequest[] = []
+  for (const req of toolRequestsById.values()) {
+    if (req.chatId !== chatId) continue
+    if (req.status !== "pending") continue
+    out.push({ ...req })
+  }
+  return out
+}
+
+/**
+ * Return defensive copies of every tool request in the map.
+ */
+export function scanAllToolRequests(
+  toolRequestsById: Map<string, ToolRequest>,
+): ToolRequest[] {
+  return [...toolRequestsById.values()].map((req) => ({ ...req }))
+}
+
+/**
+ * Remove every tool request belonging to the given chat from the map
+ * (mutates in place).  Called when a chat is deleted.
+ */
+export function deleteToolRequestsForChat(
+  toolRequestsById: Map<string, ToolRequest>,
+  chatId: string,
+): void {
+  for (const [id, req] of toolRequestsById) {
+    if (req.chatId === chatId) {
+      toolRequestsById.delete(id)
+    }
+  }
+}
+
+// ─── Write-path functions ──────────────────────────────────────────────────
+
+/** Persist + apply a new tool request. */
+export async function putToolRequest(
+  deps: ToolRequestWriteDeps,
+  req: ToolRequest,
+): Promise<void> {
+  const event = buildPutToolRequestEvent(req)
+  applyToolRequestEvent(deps.toolRequestsById, event)
+  await deps.append(deps.toolRequestsLogPath, event)
+}
+
+/** Persist + apply a tool request resolution. */
+export async function resolveToolRequest(
+  deps: ToolRequestWriteDeps,
+  id: string,
+  args: { status: ToolRequestStatus; decision?: ToolRequestDecision; resolvedAt: number; mismatchReason?: string },
+): Promise<void> {
+  const event = buildResolveToolRequestEvent(deps.toolRequestsById, id, args)
+  applyToolRequestEvent(deps.toolRequestsById, event)
+  await deps.append(deps.toolRequestsLogPath, event)
+}
+
+// Re-export types consumed by event-store.ts method signatures so callers
+// can import them from one place.
+export type { ToolRequest, ToolRequestDecision, ToolRequestStatus }

package/src/server/event-store-transcript-write.adapter.ts

@@ -0,0 +1,291 @@
+/**
+ * Complex chat-transcript write operations extracted from event-store.ts.
+ *
+ * Contains methods that directly manipulate the transcript JSONL file or
+ * perform multi-step chat mutations (fork, delete, prune, appendMessage).
+ * All IO is performed through the injected StorageBackend.
+ *
+ * This module is an adapter (.adapter.ts) because it performs disk IO.
+ * It must NOT import from event-store.ts (no circular deps).
+ */
+import path from "node:path"
+import { LOG_PREFIX } from "../shared/branding"
+import { log } from "../shared/log"
+import { STORE_VERSION } from "../shared/types"
+import type { TranscriptEntry } from "../shared/types"
+import type { ToolRequest } from "../shared/permission-policy"
+import type { ChatEvent, ChatRecord, StoreEvent } from "./events"
+import { cloneTranscriptEntries } from "./events"
+import type { StorageBackend } from "./storage/backend"
+import { getForkedChatTitle, logSendToStartingProfile } from "./event-store-helpers"
+import {
+  buildArchiveChatEvent,
+  buildChatProviderEvent,
+  buildPendingForkSessionTokenEvent,
+  buildPlanModeEvent,
+  buildUnarchiveChatEvent,
+} from "./event-store-write-ops"
+import { deleteToolRequestsForChat } from "./event-store-tool-requests"
+import { applyChatMessageMetadata } from "./event-store-chat-lifecycle"
+import type { TranscriptCache } from "./event-store-messages.adapter"
+import type { ChatOp } from "../shared/chat-ops"
+
+const STALE_EMPTY_CHAT_MAX_AGE_MS = 30 * 60 * 1000
+
+// ─── Deps interface ────────────────────────────────────────────────────────
+
+export interface ChatTranscriptWriteDeps {
+  readonly storage: StorageBackend
+  readonly transcriptsDir: string
+  readonly dataDir: string
+  readonly transcriptCache: TranscriptCache
+  readonly seenMessageIdsByChatId: Map<string, Set<string>>
+  readonly chatsById: Map<string, ChatRecord>
+  readonly toolRequestsById: Map<string, ToolRequest>
+  readonly chatsLogPath: string
+  readonly turnsLogPath: string
+  /** Read the current write-chain promise. */
+  getWriteChain: () => Promise<void>
+  /** Replace the write-chain promise. */
+  setWriteChain: (p: Promise<void>) => void
+  /** Core append: writes event to disk + applies to in-memory state. */
+  append: <T extends StoreEvent>(filePath: string, event: T) => Promise<void>
+  /** Returns transcript entries for a chat (from cache or disk). */
+  getMessages: (chatId: string) => TranscriptEntry[]
+  /** Loads the transcript into cache (populating seen messageIds) without cloning. */
+  ensureTranscriptLoaded: (chatId: string) => void
+  /** Returns (or lazily creates) the seen-messageId dedup set for a chat. */
+  getSeenMessageIds: (chatId: string) => Set<string>
+  /** Returns pending tool requests for a chat. */
+  listPendingToolRequests: (chatId: string) => ToolRequest[]
+  /** Records a delta op for the `chat.ops` broadcast path. */
+  recordChatOp: (chatId: string, op: ChatOp) => void
+  /** Drops the chat's op-log (chat deleted/pruned). */
+  clearChatOps: (chatId: string) => void
+}
+
+// ─── Private helpers ───────────────────────────────────────────────────────
+
+function transcriptPath(deps: ChatTranscriptWriteDeps, chatId: string): string {
+  return path.join(deps.transcriptsDir, `${chatId}.jsonl`)
+}
+
+function requireChat(deps: ChatTranscriptWriteDeps, chatId: string): ChatRecord {
+  const chat = deps.chatsById.get(chatId)
+  if (!chat || chat.deletedAt) throw new Error("Chat not found")
+  return chat
+}
+
+// ─── Exported functions ────────────────────────────────────────────────────
+
+/** Removes the subagent-results directory for a deleted chat (best-effort). */
+export async function removeSubagentResultsDir(
+  deps: ChatTranscriptWriteDeps,
+  projectId: string,
+  chatId: string,
+): Promise<void> {
+  const dir = path.join(
+    deps.dataDir, "projects", projectId, "chats", chatId, "subagent-results",
+  )
+  try {
+    await deps.storage.remove(dir, { recursive: true })
+  } catch (err) {
+    log.warn(`${LOG_PREFIX} subagent-results cleanup failed`, { chatId, err })
+  }
+}
+
+/** Forks a chat: creates a new chat sharing the source transcript and session. */
+export async function forkChat(
+  deps: ChatTranscriptWriteDeps,
+  sourceChatId: string,
+): Promise<ChatRecord> {
+  const sourceChat = requireChat(deps, sourceChatId)
+  const sourceProvider = sourceChat.provider
+  if (!sourceProvider) throw new Error("Chat cannot be forked")
+
+  const sourceSessionToken =
+    sourceChat.sessionTokensByProvider[sourceProvider]
+    ?? (sourceChat.pendingForkSessionToken?.provider === sourceProvider
+      ? sourceChat.pendingForkSessionToken.token
+      : null)
+  if (!sourceSessionToken) throw new Error("Chat cannot be forked")
+
+  const chatId = crypto.randomUUID()
+  const createdAt = Date.now()
+  const createEvent: ChatEvent = {
+    v: STORE_VERSION,
+    type: "chat_created",
+    timestamp: createdAt,
+    chatId,
+    projectId: sourceChat.projectId,
+    title: getForkedChatTitle(sourceChat.title),
+    ...(sourceChat.stackId !== undefined ? { stackId: sourceChat.stackId } : {}),
+    ...(sourceChat.stackBindings !== undefined
+      ? { stackBindings: sourceChat.stackBindings.map((b) => ({ ...b })) }
+      : {}),
+  }
+  await deps.append(deps.chatsLogPath, createEvent)
+
+  const providerEv = buildChatProviderEvent(deps.chatsById, chatId, sourceProvider)
+  if (providerEv) await deps.append(deps.chatsLogPath, providerEv)
+
+  const planEv = buildPlanModeEvent(deps.chatsById, chatId, sourceChat.planMode)
+  if (planEv) await deps.append(deps.chatsLogPath, planEv)
+
+  const forkTokenEv = buildPendingForkSessionTokenEvent(
+    deps.chatsById, chatId, { provider: sourceProvider, token: sourceSessionToken },
+  )
+  if (forkTokenEv) await deps.append(deps.turnsLogPath, forkTokenEv)
+
+  const sourceEntries = deps.getMessages(sourceChatId)
+  if (sourceEntries.length > 0) {
+    const tPath = transcriptPath(deps, chatId)
+    const payload = sourceEntries.map((entry) => JSON.stringify(entry)).join("\n")
+    const newChain = deps.getWriteChain().then(async () => {
+      await deps.storage.mkdir(deps.transcriptsDir)
+      await deps.storage.writeText(tPath, `${payload}\n`)
+      const chat = deps.chatsById.get(chatId)
+      if (chat) {
+        chat.hasMessages = true
+        chat.updatedAt = Math.max(chat.updatedAt, createdAt)
+      }
+      if (deps.transcriptCache.has(chatId)) {
+        deps.transcriptCache.set(chatId, cloneTranscriptEntries(sourceEntries))
+      }
+    })
+    deps.setWriteChain(newChain)
+    await newChain
+  }
+
+  return deps.chatsById.get(chatId)!
+}
+
+/** Deletes a chat: appends a delete event, clears tool requests, and removes the results dir. */
+export async function deleteChat(
+  deps: ChatTranscriptWriteDeps,
+  chatId: string,
+): Promise<void> {
+  const chat = requireChat(deps, chatId)
+  const projectId = chat.projectId
+  const event: ChatEvent = {
+    v: STORE_VERSION,
+    type: "chat_deleted",
+    timestamp: Date.now(),
+    chatId,
+  }
+  await deps.append(deps.chatsLogPath, event)
+  deleteToolRequestsForChat(deps.toolRequestsById, chatId)
+  deps.clearChatOps(chatId)
+  await removeSubagentResultsDir(deps, projectId, chatId)
+}
+
+/** Archives a chat. */
+export async function archiveChat(
+  deps: ChatTranscriptWriteDeps,
+  chatId: string,
+): Promise<void> {
+  await deps.append(deps.chatsLogPath, buildArchiveChatEvent(deps.chatsById, chatId))
+}
+
+/** Unarchives a chat. */
+export async function unarchiveChat(
+  deps: ChatTranscriptWriteDeps,
+  chatId: string,
+): Promise<void> {
+  await deps.append(deps.chatsLogPath, buildUnarchiveChatEvent(deps.chatsById, chatId))
+}
+
+/** Prunes empty chats that have been idle past the max age. Returns pruned chat IDs. */
+export async function pruneStaleEmptyChats(
+  deps: ChatTranscriptWriteDeps,
+  args?: {
+    now?: number
+    maxAgeMs?: number
+    activeChatIds?: Iterable<string>
+    protectedChatIds?: Iterable<string>
+  },
+): Promise<string[]> {
+  const now = args?.now ?? Date.now()
+  const maxAgeMs = args?.maxAgeMs ?? STALE_EMPTY_CHAT_MAX_AGE_MS
+  const protectedChatIds = new Set([
+    ...(args?.activeChatIds ?? []),
+    ...(args?.protectedChatIds ?? []),
+  ])
+  const prunedChatIds: string[] = []
+
+  for (const chat of deps.chatsById.values()) {
+    if (chat.deletedAt || chat.archivedAt || protectedChatIds.has(chat.id)) continue
+    if (now - chat.createdAt < maxAgeMs) continue
+    if (chat.hasMessages) continue
+    if (deps.getMessages(chat.id).length > 0) {
+      chat.hasMessages = true
+      continue
+    }
+
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_deleted",
+      timestamp: now,
+      chatId: chat.id,
+    }
+    await deps.append(deps.chatsLogPath, event)
+
+    const tPath = transcriptPath(deps, chat.id)
+    await deps.storage.remove(tPath)
+    deps.transcriptCache.invalidate(chat.id)
+    deps.clearChatOps(chat.id)
+    await removeSubagentResultsDir(deps, chat.projectId, chat.id)
+
+    prunedChatIds.push(chat.id)
+  }
+
+  return prunedChatIds
+}
+
+/** Appends a transcript entry for a chat, with deduplication by messageId. */
+export async function appendMessage(
+  deps: ChatTranscriptWriteDeps,
+  chatId: string,
+  entry: TranscriptEntry,
+): Promise<void> {
+  requireChat(deps, chatId)
+  const payload = `${JSON.stringify(entry)}\n`
+  const tPath = transcriptPath(deps, chatId)
+  const queuedAt = performance.now()
+  const newChain = deps.getWriteChain().then(async () => {
+    const startedAt = performance.now()
+    const queueDelayMs = Number((startedAt - queuedAt).toFixed(1))
+    const mid = entry.messageId
+    if (typeof mid === "string" && mid.length > 0) {
+      deps.ensureTranscriptLoaded(chatId)
+      const seen = deps.getSeenMessageIds(chatId)
+      if (seen.has(mid)) {
+        logSendToStartingProfile("event_store.append_message_dedup", {
+          chatId,
+          messageId: mid,
+          kind: entry.kind,
+        })
+        return
+      }
+      seen.add(mid)
+    }
+    await deps.storage.mkdir(deps.transcriptsDir)
+    const beforeAppendAt = performance.now()
+    await deps.storage.appendText(tPath, payload)
+    const afterAppendAt = performance.now()
+    applyChatMessageMetadata(deps.chatsById, chatId, entry)
+    deps.transcriptCache.appendTo(chatId, { ...entry })
+    deps.recordChatOp(chatId, { kind: "entries.append", entries: [{ ...entry }] })
+    logSendToStartingProfile("event_store.append_message", {
+      chatId,
+      entryId: entry._id,
+      kind: entry.kind,
+      payloadBytes: payload.length,
+      queueDelayMs,
+      appendMs: Number((afterAppendAt - beforeAppendAt).toFixed(1)),
+      totalMs: Number((afterAppendAt - queuedAt).toFixed(1)),
+    })
+  })
+  deps.setWriteChain(newChain)
+  return newChain
+}