@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/grok-cli/reader.ts

@@ -0,0 +1,302 @@
+import { basename, dirname, join } from "node:path"
+import { exists, isDir, ls, readJson, readJsonl } from "../../fsutil.ts"
+import type { Session, SessionHeader, Turn } from "../../session/types.ts"
+import { clip, header, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import { CONTINUED_NOTE, LABEL, SUMMARY_PREFIX, SYNTHETIC, TOOL, grokKind, sessionsDir, unwrapReminder } from "./records.ts"
+
+// Reads Grok CLI sessions: <home>/.grok/sessions/<encoded cwd>/<uuid>/. The conversation comes from
+// chat_history.jsonl, the messages Grok gives the model (tool calls paired with results by id);
+// updates.jsonl adds what only the screen log has: when each prompt and tool call happened and whether a
+// call failed. Subagents are sessions of their own in the same tree, linked from the parent's
+// subagents/<id>/meta.json and named in the spawn_subagent result.
+
+type Row = Record<string, any>
+
+interface Summary {
+  info?: { id?: string; cwd?: string }
+  generated_title?: string
+  session_summary?: string
+  created_at?: string
+  updated_at?: string
+  last_active_at?: string
+  current_model_id?: string
+  session_kind?: string
+  git_remotes?: string[]
+  head_branch?: string
+  head_commit?: string
+}
+
+const textOf = (content: unknown): { text: string; images: number } => {
+  if (typeof content === "string") return { text: content, images: 0 }
+  let images = 0
+  const parts: string[] = []
+  for (const p of Array.isArray(content) ? (content as Row[]) : []) {
+    if (typeof p?.text === "string") parts.push(p.text)
+    else if (p?.type === "image" || p?.type === "image_url") images++
+  }
+  return { text: parts.join("\n"), images }
+}
+
+/** What updates.jsonl knows that chat_history.jsonl does not: prompt and call times, failed calls. */
+function screenLog(path: string) {
+  const promptAt = new Map<number, string>()
+  const callAt = new Map<string, string>()
+  const resultAt = new Map<string, string>()
+  const failed = new Set<string>()
+  for (const o of readJsonl(path).rows) {
+    const u = o?.params?.update as Row | undefined
+    const at = iso(o?.params?._meta?.agentTimestampMs) ?? iso(o?.timestamp)
+    if (!u || !at) continue
+    if (u.sessionUpdate === "user_message_chunk" && typeof u._meta?.promptIndex === "number" && !promptAt.has(u._meta.promptIndex)) promptAt.set(u._meta.promptIndex, at)
+    if (u.sessionUpdate === "tool_call" && typeof u.toolCallId === "string") callAt.set(u.toolCallId, at)
+    if (u.sessionUpdate === "tool_call_update" && typeof u.toolCallId === "string") {
+      if (u.status === "failed") failed.add(u.toolCallId)
+      if (u.status === "completed" || u.status === "failed") resultAt.set(u.toolCallId, at)
+    }
+  }
+  return { promptAt, callAt, resultAt, failed }
+}
+
+/**
+ * The conversation from updates.jsonl alone, for a folder with no chat_history.jsonl (the sanitized grok 1.0.5
+ * capture in the session-migrate corpus has only summary.json and updates.jsonl). The screen log has the
+ * same turns: prompts (user_message_chunk), reply text in chunks, tool_call and its tool_call_update with
+ * the result; it lacks the model's own reasoning items and system reminders.
+ */
+function turnsFromScreenLog(path: string, h: SessionHeader, model: string | undefined, lost: ReturnType<typeof lossCounter>): { turns: Turn[]; spawnResults: Array<{ callId: string; text: string }> } {
+  const turns: Turn[] = []
+  const spawnResults: Array<{ callId: string; text: string }> = []
+  const names = new Map<string, string>()
+  const answered = new Set<string>()
+  let streaming: "user" | "assistant" | "reasoning" | undefined
+  let userModel = model
+  const append = (kind: "user" | "assistant" | "reasoning", text: string, at: string | undefined) => {
+    const last = turns[turns.length - 1]
+    if (streaming === kind && last?.kind === kind) {
+      ;(last as { text: string }).text += text
+      return
+    }
+    streaming = kind
+    if (kind === "assistant") {
+      noteModel(h, userModel)
+      turns.push({ kind, ...(at ? { at } : {}), text, ...(userModel ? { model: userModel } : {}) })
+    } else turns.push({ kind, ...(at ? { at } : {}), text })
+  }
+  for (const o of readJsonl(path).rows) {
+    const u = o?.params?.update as Row | undefined
+    if (!u || typeof u.sessionUpdate !== "string") continue
+    const at = iso(o?.params?._meta?.agentTimestampMs) ?? iso(o?.timestamp)
+    const chunk = typeof u.content?.text === "string" ? (u.content.text as string) : ""
+    switch (u.sessionUpdate) {
+      case "user_message_chunk":
+        if (typeof u._meta?.modelId === "string") userModel = u._meta.modelId
+        // Chunks of one prompt share a promptIndex; a new index is a new prompt.
+        if (streaming === "user" && (turns[turns.length - 1] as { promptIndex?: number } | undefined)?.promptIndex === u._meta?.promptIndex) append("user", chunk, at)
+        else {
+          streaming = undefined
+          append("user", chunk, at)
+          ;(turns[turns.length - 1] as { promptIndex?: unknown }).promptIndex = u._meta?.promptIndex
+        }
+        break
+      case "agent_message_chunk":
+        append("assistant", chunk, at)
+        break
+      case "agent_thought_chunk":
+        append("reasoning", chunk, at)
+        break
+      case "tool_call": {
+        if (typeof u.toolCallId !== "string") break
+        streaming = undefined
+        const name = typeof u._meta?.["x.ai/tool"]?.name === "string" ? (u._meta["x.ai/tool"].name as string) : typeof u.title === "string" ? u.title : "unknown"
+        names.set(u.toolCallId, name)
+        turns.push({ kind: "tool_call", ...(at ? { at } : {}), id: u.toolCallId, name, toolKind: grokKind(name) ?? toolKindOf(name), input: u.rawInput ?? {} })
+        break
+      }
+      case "tool_call_update": {
+        // The first update of a call only restates it (kind, title, locations); the one with a status is the result.
+        if (typeof u.toolCallId !== "string" || (u.status !== "completed" && u.status !== "failed") || answered.has(u.toolCallId)) break
+        answered.add(u.toolCallId)
+        streaming = undefined
+        let images = 0
+        const parts: string[] = []
+        for (const c of Array.isArray(u.content) ? (u.content as Row[]) : []) {
+          if (typeof c?.content?.text === "string") parts.push(c.content.text)
+          else if (c?.content?.type === "image") images++
+        }
+        if (images) lost.add("images", images)
+        const raw = parts.join("\n")
+        const { text, truncated } = clip(raw)
+        turns.push({ kind: "tool_result", ...(at ? { at } : {}), callId: u.toolCallId, ok: u.status === "completed", output: text, ...(truncated ? { truncated } : {}) })
+        if (names.get(u.toolCallId) === "spawn_subagent") spawnResults.push({ callId: u.toolCallId, text: raw })
+        break
+      }
+      case "turn_completed":
+        streaming = undefined
+        break
+      default:
+        break
+    }
+  }
+  for (const t of turns) delete (t as { promptIndex?: unknown }).promptIndex
+  return { turns: turns.filter((t) => (t.kind === "user" || t.kind === "assistant" || t.kind === "reasoning" ? t.text.trim() : true)), spawnResults }
+}
+
+/** One session folder as a portable session (children not attached). */
+function readOne(dir: string): { session: Session; spawnResults: Array<{ callId: string; text: string }> } {
+  const summary = readJson<Summary>(join(dir, "summary.json")) ?? {}
+  const id = summary.info?.id ?? basename(dir)
+  const screenOnly = !exists(join(dir, "chat_history.jsonl")) && exists(join(dir, "updates.jsonl"))
+  if (!exists(join(dir, "chat_history.jsonl")) && !screenOnly) throw new Error(`${dir} has no chat_history.jsonl; Grok keeps the conversation there`)
+  const cwd = summary.info?.cwd
+  const h = header(TOOL, id, {
+    sourcePath: dir,
+    ...(summary.generated_title || summary.session_summary ? { title: summary.generated_title || summary.session_summary } : {}),
+    project: {
+      ...(cwd ? { cwd } : {}),
+      ...(summary.git_remotes?.[0] ? { gitRemote: summary.git_remotes[0] } : {}),
+      ...(summary.head_branch ? { gitBranch: summary.head_branch } : {}),
+      ...(summary.head_commit ? { gitCommit: summary.head_commit } : {}),
+    },
+    ...(iso(summary.created_at) ? { startedAt: iso(summary.created_at) } : {}),
+    ...(iso(summary.last_active_at ?? summary.updated_at) ? { updatedAt: iso(summary.last_active_at ?? summary.updated_at) } : {}),
+  })
+  const lost = lossCounter()
+  if (screenOnly) {
+    const r = turnsFromScreenLog(join(dir, "updates.jsonl"), h, summary.current_model_id, lost)
+    lost.add("model history (no chat_history.jsonl: read from the screen log)")
+    lost.flush(h)
+    return { session: { header: h, turns: r.turns }, spawnResults: r.spawnResults }
+  }
+  const log = screenLog(join(dir, "updates.jsonl"))
+  const { rows, bad } = readJsonl(join(dir, "chat_history.jsonl"))
+  if (bad) lost.add("unreadable chat history lines", bad)
+
+  const turns: Turn[] = []
+  const names = new Map<string, string>()
+  const spawnResults: Array<{ callId: string; text: string }> = []
+  for (const r of rows) {
+    switch (r.type) {
+      case "system":
+        // Grok's own system prompt; it writes a fresh one when the session loads.
+        break
+      case "user": {
+        const { text, images } = textOf(r.content)
+        if (images) lost.add("images", images)
+        if (r[SYNTHETIC]) {
+          const inner = unwrapReminder(text)
+          const from = inner.match(CONTINUED_NOTE)
+          if (from) h.parent = { id: from[1]!, kind: "continued" }
+          else if (inner.startsWith(SUMMARY_PREFIX)) turns.push({ kind: "compaction", summary: inner.replace(/^\[[^\]]*\]\s*/, "") })
+          else lost.add("Grok reminders and context (not carried)")
+          break
+        }
+        if (!text.trim()) break
+        const at = typeof r.prompt_index === "number" ? log.promptAt.get(r.prompt_index) : undefined
+        turns.push({ kind: "user", ...(at ? { at } : {}), text })
+        break
+      }
+      case "reasoning": {
+        const summaryText = (Array.isArray(r.summary) ? (r.summary as Row[]) : []).map((s) => s?.text).filter((t): t is string => typeof t === "string").join("\n")
+        if (summaryText.trim()) turns.push({ kind: "reasoning", text: summaryText })
+        if (r.encrypted_content) lost.add("encrypted reasoning")
+        break
+      }
+      case "assistant": {
+        const model = typeof r.model_id === "string" ? r.model_id : undefined
+        noteModel(h, model)
+        const text = typeof r.content === "string" ? r.content : textOf(r.content).text
+        if (text.trim()) turns.push({ kind: "assistant", text, ...(model ? { model } : {}) })
+        for (const c of Array.isArray(r.tool_calls) ? (r.tool_calls as Row[]) : []) {
+          if (typeof c?.id !== "string" || typeof c?.name !== "string") continue
+          let input: unknown = c.arguments
+          if (typeof c.arguments === "string") {
+            try {
+              input = JSON.parse(c.arguments)
+            } catch {
+              input = c.arguments
+            }
+          }
+          names.set(c.id, c.name)
+          const at = log.callAt.get(c.id)
+          turns.push({ kind: "tool_call", ...(at ? { at } : {}), id: c.id, name: c.name, toolKind: grokKind(c.name) ?? toolKindOf(c.name), input })
+        }
+        break
+      }
+      case "tool_result": {
+        if (typeof r.tool_call_id !== "string") break
+        const raw = typeof r.content === "string" ? r.content : textOf(r.content).text
+        const { text, truncated } = clip(raw)
+        const at = log.resultAt.get(r.tool_call_id)
+        turns.push({ kind: "tool_result", ...(at ? { at } : {}), callId: r.tool_call_id, ok: !log.failed.has(r.tool_call_id), output: text, ...(truncated ? { truncated } : {}) })
+        if (names.get(r.tool_call_id) === "spawn_subagent") spawnResults.push({ callId: r.tool_call_id, text: raw })
+        break
+      }
+      default:
+        lost.add(`unknown chat history types: ${String(r.type)}`)
+    }
+  }
+  lost.flush(h)
+  return { session: { header: h, turns }, spawnResults }
+}
+
+/** Subagent sessions named in the parent's subagents/ folder, each placed after the spawn call whose result names it. */
+function attachChildren(dir: string, parent: Session, spawnResults: Array<{ callId: string; text: string }>) {
+  const sub = join(dir, "subagents")
+  const kids: Array<{ session: Session; callId?: string; description?: string }> = []
+  for (const childId of ls(sub)) {
+    const meta = readJson<Row>(join(sub, childId, "meta.json"))
+    const childDir = join(dirname(dir), childId)
+    if (!meta || !isDir(childDir)) continue
+    try {
+      const child = readOne(childDir).session
+      child.header.parent = { id: parent.header.id, kind: "subagent" }
+      const callId = spawnResults.find((r) => r.text.includes(childId))?.callId
+      kids.push({ session: child, ...(callId ? { callId } : {}), ...(typeof meta.description === "string" ? { description: meta.description } : {}) })
+    } catch {
+      parent.header.lost.push("an unreadable subagent session")
+    }
+  }
+  if (!kids.length) return
+  const out: Turn[] = []
+  const unplaced = kids.filter((k) => !k.callId)
+  for (const t of parent.turns) {
+    out.push(t)
+    if (t.kind !== "tool_result") continue
+    for (const k of kids.filter((k) => k.callId === t.callId))
+      out.push({ kind: "subagent", ...(k.session.header.startedAt ? { at: k.session.header.startedAt } : {}), sessionId: k.session.header.id, callId: t.callId, ...(k.description ? { description: k.description } : {}) })
+  }
+  for (const k of unplaced) out.push({ kind: "subagent", ...(k.session.header.startedAt ? { at: k.session.header.startedAt } : {}), sessionId: k.session.header.id, ...(k.description ? { description: k.description } : {}) })
+  parent.turns = out
+  parent.children = kids.map((k) => k.session)
+}
+
+export const grokReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const refs: SessionRef[] = []
+    const root = sessionsDir(home)
+    for (const group of ls(root)) {
+      const groupDir = join(root, group)
+      if (!isDir(groupDir)) continue
+      for (const name of ls(groupDir)) {
+        const dir = join(groupDir, name)
+        const s = readJson<Summary>(join(dir, "summary.json"))
+        // Subagent sessions are read as part of their parent.
+        if (!s?.info?.id || s.session_kind === "subagent" || !(exists(join(dir, "chat_history.jsonl")) || exists(join(dir, "updates.jsonl")))) continue
+        const title = s.generated_title || s.session_summary
+        const updatedAt = iso(s.last_active_at ?? s.updated_at)
+        refs.push({ tool: TOOL, sourceId: s.info.id, path: dir, ...(title ? { title } : {}), ...(s.info.cwd ? { cwd: s.info.cwd } : {}), ...(updatedAt ? { updatedAt } : {}) })
+      }
+    }
+    return refs.sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
+  },
+
+  async read(ref: SessionRef): Promise<Session> {
+    const { session, spawnResults } = readOne(ref.path)
+    attachChildren(ref.path, session, spawnResults)
+    return session
+  },
+}

package/src/adapters/grok-cli/records.ts

@@ -0,0 +1,172 @@
+import { readFileSync } from "node:fs"
+import { join } from "node:path"
+import { exists, versionOf } from "../../fsutil.ts"
+import type { ToolKind } from "../../session/types.ts"
+
+// What the xAI Grok CLI ("Grok Build", the official closed-source binary) keeps per session, as far as
+// this adapter relies on it. Checked against grok 0.2.103: the sessions it wrote on the author's Mac
+// (structure and counts only), sessions it created itself in a throwaway GROK_HOME, and what its own
+// `grok sessions list`, `grok export` and ACP `session/load` + `_x.ai/session/info` do with written ones.
+//
+// A session is a folder <GROK_HOME>/sessions/<url-encoded cwd>/<uuidv7>/ holding two parallel logs:
+// updates.jsonl, the ACP session/update stream the screen is rebuilt from (export and the resume replay
+// read only this), and chat_history.jsonl, the messages the model is given (session/load rebuilds the
+// model context only from this; a session without it resumes with an empty context). summary.json is the
+// entry the session list reads. The search index (sessions/session_search.sqlite) is rebuilt by Grok.
+
+export const TOOL = "grok-cli"
+export const LABEL = "Grok CLI"
+
+/** Grok versions the writer's files were checked against. */
+export const TESTED_VERSIONS = ["0.2.103"]
+
+export const grokHome = (home: string) => join(home, ".grok")
+export const sessionsDir = (home: string) => join(grokHome(home), "sessions")
+
+/**
+ * The folder name Grok gives a cwd: percent-encoding of everything outside RFC 3986's unreserved set
+ * (checked with spaces, @, +, comma, parentheses and ~ in the path). A cwd is not resolved first: /tmp
+ * and /private/tmp are different folders.
+ */
+export function encodeCwd(cwd: string): string {
+  return encodeURIComponent(cwd).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`)
+}
+
+/** Past 255 bytes Grok names the folder slug-plus-hash instead, with a hash this adapter does not reproduce. */
+export const MAX_FOLDER_NAME = 255
+
+/** Messages Grok adds for the model and marks as not typed by the person (all wrapped in <system-reminder>). */
+export const SYNTHETIC = "synthetic_reason"
+
+/** The installed Grok version ("grok 0.2.103 (89c3d36fb6f1)" → "0.2.103"), from the PATH or Grok's own bin folder. */
+export function grokVersion(home: string): string | undefined {
+  const own = join(grokHome(home), "bin", "grok")
+  const line = versionOf("grok") ?? (exists(own) ? versionOf(own) : undefined)
+  return line?.match(/(\d+\.\d+\.\d+)/)?.[1]
+}
+
+/** The model new sessions start with: [models] default in config.toml, else Grok's documented default. */
+export function defaultModel(home: string): string {
+  let text = ""
+  try {
+    text = readFileSync(join(grokHome(home), "config.toml"), "utf8")
+  } catch {
+    return "grok-build"
+  }
+  const section = text.split(/^\s*\[/m).find((s) => /^models\]/.test(s)) ?? ""
+  return section.match(/^\s*default\s*=\s*["']([^"']+)["']/m)?.[1] ?? "grok-build"
+}
+
+/** Grok's built-in tools, by what they do, with the metadata its own tool_call updates carry. */
+export interface GrokTool {
+  name: string
+  /** `x.ai/tool.kind` */
+  kind: string
+  label: string
+  namespace: string
+  readOnly: boolean
+  /** ACP ToolKind for the update's `kind`. */
+  acp: string
+}
+
+export const GROK_TOOLS: Record<string, GrokTool> = {
+  read_file: { name: "read_file", kind: "read", label: "Read", namespace: "grok_build", readOnly: true, acp: "read" },
+  run_terminal_command: { name: "run_terminal_command", kind: "execute", label: "Run Command", namespace: "grok_build", readOnly: false, acp: "execute" },
+  search_replace: { name: "search_replace", kind: "edit", label: "Edit", namespace: "grok_build", readOnly: false, acp: "edit" },
+  write: { name: "write", kind: "write", label: "Write", namespace: "opencode", readOnly: false, acp: "edit" },
+  list_dir: { name: "list_dir", kind: "list", label: "List Files", namespace: "grok_build", readOnly: true, acp: "search" },
+  grep: { name: "grep", kind: "search", label: "Search", namespace: "grok_build", readOnly: true, acp: "search" },
+  web_search: { name: "web_search", kind: "web_search", label: "Web Search", namespace: "grok_build", readOnly: true, acp: "fetch" },
+  todo_write: { name: "todo_write", kind: "plan", label: "Plan", namespace: "grok_build", readOnly: false, acp: "other" },
+  spawn_subagent: { name: "spawn_subagent", kind: "task", label: "Subagent", namespace: "grok_build", readOnly: false, acp: "other" },
+  ask_user_question: { name: "ask_user_question", kind: "ask_user", label: "Ask User", namespace: "grok_build", readOnly: true, acp: "other" },
+}
+
+/** What a Grok tool name does; Grok's names are checked before the shared name patterns. */
+const KIND_OF: Record<string, ToolKind> = {
+  read_file: "read",
+  run_terminal_command: "shell",
+  get_command_or_subagent_output: "shell",
+  search_replace: "edit",
+  write: "write",
+  list_dir: "list",
+  grep: "search",
+  search_tool: "search",
+  web_search: "web",
+  todo_write: "todo",
+  spawn_subagent: "task",
+  ask_user_question: "ask",
+  use_tool: "mcp",
+}
+export const grokKind = (name: string): ToolKind | undefined => KIND_OF[name]
+
+const pick = (o: Record<string, unknown>, keys: string[]): unknown => {
+  for (const k of keys) if (o[k] !== undefined && o[k] !== null && o[k] !== "") return o[k]
+  return undefined
+}
+const str = (v: unknown) => (typeof v === "string" ? v : Array.isArray(v) && v.every((x) => typeof x === "string") ? v.join(" ") : undefined)
+
+/**
+ * A call from another tool as the Grok tool that does the same thing, with Grok's argument names, so the
+ * model sees calls it knows and the screen renders them like its own. Calls whose arguments do not map
+ * cleanly (an apply_patch, a filename glob, an MCP call) keep their own name and input.
+ */
+export function asGrokCall(kind: ToolKind, name: string, input: unknown): { tool?: GrokTool; name: string; input: unknown } {
+  if (GROK_TOOLS[name]) return { tool: GROK_TOOLS[name], name, input }
+  if (!input || typeof input !== "object" || Array.isArray(input)) return { name, input }
+  const o = input as Record<string, unknown>
+  const path = str(pick(o, ["file_path", "target_file", "path", "filePath", "absolute_path", "filename"]))
+  const as = (tool: string, args: Record<string, unknown>) => ({ tool: GROK_TOOLS[tool], name: tool, input: args })
+  switch (kind) {
+    case "read":
+      if (path) return as("read_file", { target_file: path, ...(typeof o.offset === "number" ? { offset: o.offset } : {}), ...(typeof o.limit === "number" ? { limit: o.limit } : {}) })
+      break
+    case "shell": {
+      const command = str(pick(o, ["command", "cmd", "commandLine"]))
+      if (command) return as("run_terminal_command", { command, ...(typeof o.description === "string" ? { description: o.description } : {}) })
+      break
+    }
+    case "edit": {
+      const oldS = str(pick(o, ["old_string", "old_str", "oldText", "old_text"]))
+      const newS = pick(o, ["new_string", "new_str", "newText", "new_text"])
+      if (path && oldS !== undefined && typeof newS === "string")
+        return as("search_replace", { file_path: path, old_string: oldS, new_string: newS, ...(o.replace_all === true ? { replace_all: true } : {}) })
+      break
+    }
+    case "write": {
+      const content = pick(o, ["content", "contents", "file_text", "fileText", "text"])
+      if (path && typeof content === "string") return as("write", { file_path: path, content })
+      break
+    }
+    case "list": {
+      const dir = str(pick(o, ["target_directory", "path", "dir_path", "directory", "relative_workspace_path"]))
+      if (dir) return as("list_dir", { target_directory: dir })
+      break
+    }
+    case "search": {
+      // Only content searches: a filename glob has a pattern too, but grep would read it as a regex.
+      const pattern = str(pick(o, ["pattern", "regex", "query"]))
+      if (/grep|ripgrep|search_files/i.test(name) && pattern) return as("grep", { pattern, ...(path ? { path } : {}), ...(typeof o.glob === "string" ? { glob: o.glob } : {}) })
+      break
+    }
+    case "web": {
+      const query = str(pick(o, ["query", "q"]))
+      if (/search/i.test(name) && query) return as("web_search", { query })
+      break
+    }
+    default:
+      break
+  }
+  return { name, input }
+}
+
+/** The note the writer puts first; the reader recognises it and records where the session came from. */
+export const continuedNote = (label: string, id: string, when: string) =>
+  `This session continues ${label} session ${id}, carried over by brain session on ${when}. The conversation after this note is its history; reasoning and anything listed as lost did not carry over. Check files before relying on details, since they may have changed.`
+export const CONTINUED_NOTE = /This session continues .+? session (\S+), carried over by brain session/
+
+/** The start of a compaction summary the writer gives the model in place of the turns it replaced. */
+export const SUMMARY_PREFIX = "[Summary of the earlier conversation"
+
+export const reminder = (text: string) => `<system-reminder>\n${text}\n</system-reminder>`
+export const unwrapReminder = (text: string) => text.replace(/^\s*<system-reminder>\n?/, "").replace(/\n?<\/system-reminder>\s*$/, "")