@100xprompt/brain 0.0.0-stage → 0.1.0

package/src/adapters/crush/records.ts

@@ -0,0 +1,169 @@
+import { join } from "node:path"
+import { exists, isDir, versionOf } from "../../fsutil.ts"
+import { resolveBin } from "../opencode/writer.ts"
+
+// Crush (charmbracelet/crush): where its stores are and what its rows look like, from the v0.100.0 source
+// (internal/db/migrations, internal/db/sql, internal/message/{message,content}.go, internal/config/load.go,
+// internal/projects/projects.go) and the store the v0.100.0 binary creates.
+//
+// Each project has its own store, <project>/.crush/crush.db: tables sessions and messages, a message's
+// content a JSON array of {type, data} parts (text, reasoning, tool_call, tool_result, finish, …). A tool
+// call sits in its assistant message; each result is a separate message with role "tool". Times are Unix
+// seconds and messages are read back ordered by created_at alone. The projects Crush has run in are listed in
+// ~/.local/share/crush/projects.json, which is how a reader finds the stores.
+
+export const TOOL = "crush"
+export const LABEL = "Crush"
+export const TESTED_VERSIONS = ["0.100.0"]
+
+/** The Crush binary: `go install`'s copy under home first (~/go/bin), else the one on PATH (brew, npm). */
+export const crushBin = (home: string) => resolveBin({ bin: "crush", installDir: "go" }, home)
+
+/** The installed Crush version ("crush version v0.100.0" → "0.100.0"). */
+export const crushVersion = (home: string) => versionOf(crushBin(home).path)?.match(/(\d+\.\d+\.\d+)/)?.[1]
+
+export const projectsFile = (home: string) => join(home, ".local", "share", "crush", "projects.json")
+
+/**
+ * The data folder Crush uses for a project folder, as config.setDefaults finds it: the closest `.crush` from
+ * the folder up to its repository root (never the one in the home folder), else `<folder>/.crush`. A
+ * data_directory set in the person's crush.json is not followed.
+ */
+export function dataDirFor(cwd: string, home: string): string {
+  let root = cwd
+  for (let dir = cwd; dir && dir !== "/"; dir = dir.slice(0, dir.lastIndexOf("/")) || "/")
+    if (exists(join(dir, ".git"))) {
+      root = dir
+      break
+    }
+  for (let dir = cwd; ; dir = dir.slice(0, dir.lastIndexOf("/")) || "/") {
+    if (isDir(join(dir, ".crush"))) {
+      if (dir === home) break
+      return join(dir, ".crush")
+    }
+    if (dir === root || dir === "/") break
+  }
+  return join(cwd, ".crush")
+}
+
+/** The goose migrations a v0.100.0 store has applied (version 0 is goose's own first row). */
+export const MIGRATIONS = [
+  0, 20250424200609, 20250515105448, 20250624000000, 20250627000000, 20250810000000, 20250812000000, 20260127000000, 20260902000000, 20260912000000,
+  20260921000000, 20260928000000, 20260928000001,
+]
+
+/** The schema Crush v0.100.0 leaves after its migrations, for a project that has no store yet. */
+export const SCHEMA = `
+CREATE TABLE goose_db_version (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  version_id INTEGER NOT NULL,
+  is_applied INTEGER NOT NULL,
+  tstamp TIMESTAMP DEFAULT (datetime('now'))
+);
+CREATE TABLE sessions (
+  id TEXT PRIMARY KEY,
+  parent_session_id TEXT,
+  title TEXT NOT NULL,
+  message_count INTEGER NOT NULL DEFAULT 0 CHECK (message_count >= 0),
+  prompt_tokens INTEGER NOT NULL DEFAULT 0 CHECK (prompt_tokens >= 0),
+  completion_tokens INTEGER NOT NULL DEFAULT 0 CHECK (completion_tokens>= 0),
+  cost REAL NOT NULL DEFAULT 0.0 CHECK (cost >= 0.0),
+  updated_at INTEGER NOT NULL,
+  created_at INTEGER NOT NULL
+, summary_message_id TEXT, todos TEXT, channel TEXT);
+CREATE TRIGGER update_sessions_updated_at
+AFTER UPDATE ON sessions
+BEGIN
+UPDATE sessions SET updated_at = strftime('%s', 'now')
+WHERE id = new.id;
+END;
+CREATE TABLE files (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  path TEXT NOT NULL,
+  content TEXT NOT NULL,
+  version INTEGER NOT NULL DEFAULT 0,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE,
+  UNIQUE(path, session_id, version)
+);
+CREATE INDEX idx_files_session_id ON files (session_id);
+CREATE INDEX idx_files_path ON files (path);
+CREATE TRIGGER update_files_updated_at
+AFTER UPDATE ON files
+BEGIN
+UPDATE files SET updated_at = strftime('%s', 'now')
+WHERE id = new.id;
+END;
+CREATE TABLE messages (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  parts TEXT NOT NULL default '[]',
+  model TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  finished_at INTEGER, provider TEXT, is_summary_message INTEGER DEFAULT 0 NOT NULL, prism_model_id TEXT, prism_model_name TEXT, prism_hypercredit_savings REAL, prism_dollar_savings REAL,
+  FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE
+);
+CREATE INDEX idx_messages_session_id ON messages (session_id);
+CREATE TRIGGER update_messages_updated_at
+AFTER UPDATE ON messages
+BEGIN
+UPDATE messages SET updated_at = strftime('%s', 'now')
+WHERE id = new.id;
+END;
+CREATE TRIGGER update_session_message_count_on_insert
+AFTER INSERT ON messages
+BEGIN
+UPDATE sessions SET
+  message_count = message_count + 1
+WHERE id = new.session_id;
+END;
+CREATE TRIGGER update_session_message_count_on_delete
+AFTER DELETE ON messages
+BEGIN
+UPDATE sessions SET
+  message_count = message_count - 1
+WHERE id = old.session_id;
+END;
+CREATE INDEX idx_sessions_created_at ON sessions (created_at);
+CREATE INDEX idx_messages_created_at ON messages (created_at);
+CREATE INDEX idx_files_created_at ON files (created_at);
+CREATE TABLE read_files (
+  session_id TEXT NOT NULL CHECK (session_id != ''),
+  path TEXT NOT NULL CHECK (path != ''),
+  read_at INTEGER NOT NULL,
+  FOREIGN KEY (session_id) REFERENCES sessions (id) ON DELETE CASCADE,
+  PRIMARY KEY (path, session_id)
+);
+CREATE INDEX idx_read_files_session_id ON read_files (session_id);
+CREATE INDEX idx_read_files_path ON read_files (path);
+CREATE INDEX idx_messages_role_created_at ON messages (role, created_at);
+CREATE TABLE mcp_disabled_servers (
+  name TEXT PRIMARY KEY
+);
+CREATE TABLE mcp_enabled_servers (
+  name TEXT PRIMARY KEY
+);
+`
+
+/** One stored part, as marshalParts writes it. */
+export interface Part {
+  type: "text" | "reasoning" | "tool_call" | "tool_result" | "finish" | "image_url" | "binary" | "shell_command" | "sub_agent_report"
+  data: Record<string, any>
+}
+
+/** A messages row before it is inserted. */
+export interface MessageRow {
+  id: string
+  role: "user" | "assistant" | "tool"
+  parts: Part[]
+  /** Crush stores "" for user and tool messages, the model id for assistant ones. */
+  model: string
+  provider: string | null
+  created_at: number
+  finished_at: number | null
+  is_summary_message: 0 | 1
+}

package/src/adapters/crush/writer.ts

@@ -0,0 +1,333 @@
+import { Database } from "bun:sqlite"
+import { randomUUID } from "node:crypto"
+import { copyFileSync, mkdirSync, writeFileSync } from "node:fs"
+import { basename, join, resolve } from "node:path"
+import { imageDataUrl, parseDataUrl } from "../../session/attachments.ts"
+import { toolLabel } from "../../brief.ts"
+import { exists, isDir, isRunning, readJson } from "../../fsutil.ts"
+import { withSnapshot } from "../../sqlite.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { countTurns, unpaired } from "../../session/util.ts"
+import { continuedNote } from "../opencode/note.ts"
+import { random62 } from "../opencode/ids.ts"
+import { CRUSH, mapCall } from "../opencode/tools.ts"
+import { continuedTitle, modelRef, sh } from "../opencode/writer.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { readCrush } from "./reader.ts"
+import { LABEL, MIGRATIONS, SCHEMA, TESTED_VERSIONS, TOOL, crushBin, crushVersion, dataDirFor, projectsFile, type MessageRow, type Part } from "./records.ts"
+
+// Continues a portable session in Crush as a new session of the project's own store, written as Crush's
+// message service writes one (message.Service.Create and Update, agent.go): the note as a hidden user text,
+// a user message per user turn, an assistant message per model response (reasoning, text and tool calls, then
+// a finish part), one "tool" message per result, and a compaction as Crush's summary message, an assistant
+// message flagged is_summary_message that sessions.summary_message_id points at; Crush sends the model only
+// the messages from it on. The project is registered in projects.json, as Crush does when it starts.
+//
+// The store is SQLite that Crush holds open while it runs, so this writes only with Crush closed and backs
+// the store up first. A project with no store yet gets the schema Crush v0.100.0 creates. Verified live with
+// the v0.100.0 release binary (temp home, no network): `crush session list --json` and `session show --json`.
+
+/** Crush's provider ids (catwalk) where they differ from the model family's. */
+const providerOf = (model: string | undefined) => {
+  const p = modelRef(model).providerID
+  return p === "google" ? "gemini" : p === "unknown" ? null : p
+}
+
+export interface CrushPlan {
+  id: string
+  title: string
+  messages: MessageRow[]
+  summaryId: string | null
+  lost: string[]
+  /** What a read-back must find. */
+  expect: { users: number; assistants: number; calls: number }
+}
+
+/** The rows of a new Crush session continuing `session`. Pure: writes nothing. */
+export function planCrush(session: Session, opts: { id: string; now: Date }): CrushPlan {
+  const drops = new Map<string, number>()
+  const drop = (what: string, n = 1) => drops.set(what, (drops.get(what) ?? 0) + n)
+  const mapped = { n: 0 }
+  const messages: MessageRow[] = []
+  const expect = { users: 0, assistants: 0, calls: 0 }
+  const nowSec = Math.floor(opts.now.getTime() / 1000)
+
+  // Crush orders a session's messages by created_at (whole seconds) alone, so every message gets its own second.
+  let clock = Math.floor((Date.parse(session.header.startedAt ?? "") || opts.now.getTime() - session.turns.length * 1000) / 1000) - 1
+  const tick = (at?: string) => {
+    const t = at ? Math.floor(Date.parse(at) / 1000) : NaN
+    clock = Number.isFinite(t) && t > clock ? t : clock + 1
+    return clock
+  }
+  const finish = (reason: string, time: number): Part => ({ type: "finish", data: { reason, time } })
+  const row = (role: MessageRow["role"], parts: Part[], at: number, extra: Partial<MessageRow> = {}): MessageRow => {
+    const m: MessageRow = { id: randomUUID(), role, parts, model: "", provider: null, created_at: at, finished_at: null, is_summary_message: 0, ...extra }
+    messages.push(m)
+    return m
+  }
+  // User and tool messages get the finish part Create gives every message that is not the assistant's.
+  const plain = (role: "user" | "tool", parts: Part[], at?: string) => row(role, [...parts, finish("stop", 0)], tick(at))
+
+  let model = session.header.models.at(-1)
+  let step: { m: MessageRow; text: string[]; thinking: string[]; calls: Part[]; results: boolean } | undefined
+  const pending: Part[] = []
+  const callIds = new Map<string, { id: string; name: string }>()
+  const answered = new Set<string>()
+  let summaryId: string | null = null
+
+  const openStep = (at?: string) => {
+    if (step && !step.results) return step
+    closeStep()
+    const m = row("assistant", [], tick(at), { model: model ?? "unknown", provider: providerOf(model) })
+    step = { m, text: [], thinking: [], calls: [], results: false }
+    return step
+  }
+  function closeStep() {
+    if (!step) return
+    const { m, text, thinking, calls } = step
+    const end = Math.max(m.created_at, clock)
+    m.parts = [
+      ...(thinking.length ? [{ type: "reasoning" as const, data: { thinking: thinking.join("\n\n"), signature: "", thought_signature: "", tool_id: "", responses_data: null, started_at: m.created_at, finished_at: m.created_at } }] : []),
+      ...(text.length ? [{ type: "text" as const, data: { text: text.join("\n\n") } }] : []),
+      ...calls,
+      finish(calls.length ? "tool_use" : "end_turn", end),
+    ]
+    m.finished_at = end
+    if (text.length) expect.assistants++
+    step = undefined
+    flushResults()
+  }
+  // Each result is its own message, after the response that asked for it.
+  const flushResults = () => {
+    for (const r of pending.splice(0)) plain("tool", [r])
+  }
+
+  plain("user", [{ type: "text", data: { text: continuedNote(toolLabel(session.header.tool), session.header.id, opts.now.toISOString().slice(0, 10)), hidden: true } }])
+
+  for (const t of session.turns as Turn[]) {
+    switch (t.kind) {
+      case "user": {
+        // Crush keeps an attachment as a "binary" part (Go BinaryContent: Path, MIMEType, Data as base64) after the text.
+        const bins: Part[] = []
+        let n = 0
+        for (const a of t.attachments ?? []) {
+          const d = a.kind === "image" ? parseDataUrl(imageDataUrl(a)) : undefined
+          if (d) bins.push({ type: "binary", data: { Path: a.name ?? (a.path ? basename(a.path) : "image"), MIMEType: d.mime, Data: d.base64 } })
+          else {
+            drop("attachments")
+            n++
+          }
+        }
+        const text = t.text.trim() ? t.text : n ? `(${n} attachment${n > 1 ? "s" : ""} not carried over)` : bins.length ? "(image)" : ""
+        if (!text) break
+        closeStep()
+        plain("user", [{ type: "text", data: { text } }, ...bins], t.at)
+        expect.users++
+        break
+      }
+      case "assistant": {
+        if (!t.text.trim()) break
+        if (t.model && t.model !== model) {
+          // A response belongs to one model: text from another starts a new one.
+          if (step) closeStep()
+          model = t.model
+        }
+        openStep(t.at).text.push(t.text)
+        break
+      }
+      case "reasoning":
+        openStep(t.at).thinking.push(t.text)
+        drop("reasoning: kept as text, without provider signatures")
+        break
+      case "tool_call": {
+        if (callIds.has(t.id)) {
+          drop("repeated tool call ids")
+          break
+        }
+        const st = openStep(t.at)
+        tick(t.at)
+        const call = mapCall(CRUSH, t.name, t.toolKind, t.input, mapped)
+        const id = `call_${random62(24)}`
+        callIds.set(t.id, { id, name: call.tool })
+        st.calls.push({ type: "tool_call", data: { id, name: call.tool, input: JSON.stringify(call.input), provider_executed: false, finished: true } })
+        expect.calls++
+        break
+      }
+      case "tool_result": {
+        const call = callIds.get(t.callId)
+        if (!call) {
+          drop("tool results without a call")
+          break
+        }
+        if (answered.has(t.callId)) {
+          drop("repeated tool results")
+          break
+        }
+        answered.add(t.callId)
+        pending.push({ type: "tool_result", data: { tool_call_id: call.id, name: call.name, content: t.output, data: "", mime_type: "", metadata: "", is_error: !t.ok } })
+        if (step) step.results = true
+        else flushResults()
+        break
+      }
+      case "compaction": {
+        closeStep()
+        const at = tick(t.at)
+        const m = row("assistant", [{ type: "text", data: { text: t.summary } }, finish("end_turn", at)], at, {
+          model: model ?? "unknown",
+          provider: providerOf(model),
+          finished_at: at,
+          is_summary_message: 1,
+        })
+        summaryId = m.id
+        break
+      }
+      case "file_edit":
+        if (!t.callId) drop("file edits not made by a tool call")
+        break
+      case "subagent":
+        drop("subagent sessions (their call and result are kept)")
+        break
+    }
+  }
+  // Calls that never got a result are closed as failed, as Crush closes an interrupted one.
+  for (const [src, call] of callIds)
+    if (!answered.has(src)) {
+      pending.push({ type: "tool_result", data: { tool_call_id: call.id, name: call.name, content: "No result was recorded for this call.", data: "", mime_type: "", metadata: "", is_error: true } })
+      drop("calls with no result, marked as failed")
+    }
+  closeStep()
+  flushResults()
+
+  // Nothing may sort after the next message Crush writes, which is stamped now.
+  const late = (messages.at(-1)?.created_at ?? 0) - nowSec
+  if (late > 0)
+    for (const m of messages) {
+      m.created_at -= late
+      if (m.finished_at !== null) m.finished_at -= late
+      for (const p of m.parts) if (p.type === "finish" && p.data.time) p.data.time -= late
+    }
+
+  const lost = [...drops].map(([what, n]) => `${what} (${n})`)
+  if (callIds.size) lost.push(`tool-call ids replaced (${callIds.size})`)
+  if (mapped.n) lost.push(`tool calls renamed to Crush's own tools (${mapped.n})`)
+  return { id: opts.id, title: continuedTitle(session), messages, summaryId, lost, expect }
+}
+
+/** The newest migration a store has applied, read from a copy. */
+function storeVersion(db: string): number {
+  return withSnapshot(db, (d) => (d.query("SELECT max(version_id) AS v FROM goose_db_version WHERE is_applied = 1").get() as { v: number | null }).v ?? 0)
+}
+
+const NEEDED = {
+  sessions: ["id", "parent_session_id", "title", "message_count", "prompt_tokens", "completion_tokens", "cost", "updated_at", "created_at", "summary_message_id"],
+  messages: ["id", "session_id", "role", "parts", "model", "created_at", "updated_at", "finished_at", "provider", "is_summary_message"],
+}
+
+export const crushWriter: Writer = {
+  tool: TOOL,
+  label: LABEL,
+  way: "native",
+
+  async ready(opts: WriteOptions): Promise<Readiness> {
+    const v = crushVersion(opts.home)
+    if (!v) return { ok: false, why: "Crush is not installed (no crush on PATH or in ~/go/bin)" }
+    if (!TESTED_VERSIONS.includes(v)) return { ok: false, why: `Crush ${v} is not a version this writer was checked against (${TESTED_VERSIONS.join(", ")})` }
+    if (!isDir(opts.cwd)) return { ok: false, why: `the folder to continue in does not exist: ${opts.cwd}` }
+    if (isRunning("crush")) return { ok: false, why: "Crush is running; close it first, since it holds the session store open" }
+    const db = join(dataDirFor(resolve(opts.cwd), opts.home), "crush.db")
+    if (exists(db)) {
+      const applied = storeVersion(db)
+      if (applied > MIGRATIONS.at(-1)!) return { ok: false, why: `the project's Crush store was migrated by a newer Crush (migration ${applied})` }
+    }
+    return { ok: true }
+  },
+
+  async write(session: Session, opts: WriteOptions): Promise<WriteResult> {
+    const cwd = resolve(opts.cwd)
+    const dataDir = dataDirFor(cwd, opts.home)
+    const dbPath = join(dataDir, "crush.db")
+    const now = new Date()
+    const plan = planCrush(session, { id: randomUUID(), now })
+    const backupDir = join(opts.home, ".brain", "backups", "crush", now.toISOString().replace(/[:.]/g, "-"))
+    const written = [dbPath, projectsFile(opts.home), backupDir]
+    if (!opts.dryRun) {
+      backup(dbPath, projectsFile(opts.home), backupDir)
+      insert(dbPath, dataDir, plan, cwd)
+      register(opts.home, cwd, dataDir, now)
+    }
+    return {
+      tool: TOOL,
+      way: "native",
+      sessionId: plan.id,
+      written,
+      open: `cd ${sh(cwd)} && ${sh(crushBin(opts.home).command)} --session ${plan.id}`,
+      lost: plan.lost,
+      dryRun: !!opts.dryRun,
+    }
+  },
+}
+
+/** Copies the store (with its write-ahead log) and the projects list before anything is changed. */
+function backup(dbPath: string, projects: string, dir: string) {
+  mkdirSync(dir, { recursive: true })
+  for (const f of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`, projects]) if (exists(f)) copyFileSync(f, join(dir, f.split("/").pop()!))
+}
+
+/** Writes the session in one transaction and reads it back before committing; a mismatch leaves the store as it was. */
+function insert(dbPath: string, dataDir: string, plan: CrushPlan, cwd: string) {
+  const fresh = !exists(dbPath)
+  if (fresh) {
+    mkdirSync(dataDir, { recursive: true, mode: 0o700 })
+    // Crush keeps its data folder out of git the same way.
+    if (!exists(join(dataDir, ".gitignore"))) writeFileSync(join(dataDir, ".gitignore"), "*\n")
+  }
+  const db = new Database(dbPath)
+  try {
+    db.exec("PRAGMA busy_timeout = 5000")
+    db.exec("PRAGMA foreign_keys = ON")
+    if (fresh) {
+      db.exec("PRAGMA journal_mode = WAL")
+      db.exec(SCHEMA)
+      const add = db.prepare("INSERT INTO goose_db_version (version_id, is_applied) VALUES (?, 1)")
+      for (const v of MIGRATIONS) add.run(v)
+    }
+    for (const [table, cols] of Object.entries(NEEDED)) {
+      const have = new Set((db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>).map((c) => c.name))
+      const missing = cols.filter((c) => !have.has(c))
+      if (missing.length) throw new Error(`the Crush store at ${dbPath} has no ${table}.${missing.join(", ")}; it is not a store this writer knows`)
+    }
+    const first = plan.messages[0]?.created_at ?? Math.floor(Date.now() / 1000)
+    db.transaction(() => {
+      db.prepare(
+        "INSERT INTO sessions (id, parent_session_id, title, message_count, prompt_tokens, completion_tokens, cost, summary_message_id, updated_at, created_at) VALUES (?, NULL, ?, 0, 0, 0, 0, ?, ?, ?)",
+      ).run(plan.id, plan.title, plan.summaryId, first, first)
+      const add = db.prepare(
+        "INSERT INTO messages (id, session_id, role, parts, model, provider, is_summary_message, created_at, updated_at, finished_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+      )
+      for (const m of plan.messages)
+        add.run(m.id, plan.id, m.role, JSON.stringify(m.parts), m.model, m.provider, m.is_summary_message, m.created_at, m.finished_at ?? m.created_at, m.finished_at)
+      // Read back as Crush's rows are read; throwing here rolls the transaction back.
+      const back = readCrush(db, plan.id, { path: dbPath, cwd })
+      const n = countTurns(back)
+      const pairs = unpaired(back)
+      if (n.user !== plan.expect.users || n.assistant !== plan.expect.assistants || n.tool_call !== plan.expect.calls || pairs.calls.length || pairs.results.length)
+        throw new Error(
+          `the Crush session did not read back as written (users ${n.user}/${plan.expect.users}, replies ${n.assistant}/${plan.expect.assistants}, tool calls ${n.tool_call}/${plan.expect.calls}, unpaired ${pairs.calls.length + pairs.results.length}); nothing was kept`,
+        )
+    })()
+    // Leave the store as Crush leaves it when it exits: everything in the main file.
+    db.exec("PRAGMA wal_checkpoint(TRUNCATE)")
+  } finally {
+    db.close()
+  }
+}
+
+/** Puts the project first in projects.json, as projects.Register does whenever Crush starts in a folder. */
+function register(home: string, cwd: string, dataDir: string, now: Date) {
+  const file = projectsFile(home)
+  const list = readJson<{ projects?: Array<Record<string, unknown>> }>(file) ?? {}
+  const projects = (Array.isArray(list.projects) ? list.projects : []).filter((p) => p.path !== cwd)
+  projects.unshift({ path: cwd, data_dir: dataDir, last_accessed: now.toISOString() })
+  mkdirSync(join(file, ".."), { recursive: true, mode: 0o700 })
+  writeFileSync(file, JSON.stringify({ ...list, projects }, null, 2), { mode: 0o600 })
+}