spacecode 2.6.2 → 2.7.0

package/dist/repl.mjs

@@ -5705,9 +5705,9 @@ async function sha256(content) {
   const hashArray = new Uint8Array(hashBuffer);
   return Array.from(hashArray).map((b2) => b2.toString(16).padStart(2, "0")).join("");
 }
-async function computeLockfileHash(readFile7) {
+async function computeLockfileHash(readFile9) {
   for (const name of LOCKFILES) {
-    const content = await readFile7(name);
+    const content = await readFile9(name);
     if (content) {
       const hash = await sha256(content);
       return hash.slice(0, 12);
@@ -7772,7 +7772,7 @@ __export(api_key_exports, {
 });
 import { join } from "node:path";
 async function resolveApiKey(deps) {
-  const { env: env3, readFile: readFile7, homedir: homedir3 } = deps;
+  const { env: env3, readFile: readFile9, homedir: homedir3 } = deps;
   for (const name of ["SPACECODE_API_KEY", "ANTHROPIC_API_KEY"]) {
     const value = env3[name]?.trim();
     if (value) return value;
@@ -7781,7 +7781,7 @@ async function resolveApiKey(deps) {
   const file = join(dir, "auth.json");
   let raw;
   try {
-    raw = await readFile7(file);
+    raw = await readFile9(file);
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw new Error(`Cannot read ${file}: ${err instanceof Error ? err.message : String(err)}`);
@@ -35292,7 +35292,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes: randomBytes2, createHash: createHash2 } = __require("crypto");
+    var { randomBytes: randomBytes2, createHash: createHash5 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -35960,7 +35960,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -36329,7 +36329,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter3 = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash2 } = __require("crypto");
+    var { createHash: createHash5 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -36636,7 +36636,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash5("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -40378,12 +40378,12 @@ var init_WelcomeBanner = __esm({
 });
 
 // src/render/hints.ts
-function formatHints({ running, asking, columns }, sep2 = "\xB7") {
+function formatHints({ running, asking, columns }, sep3 = "\xB7") {
   columns = Math.min(columns, MAX_STATIC_LINE);
   const parts = asking ? ["1 2 3 answer", "esc refuse"] : running ? ["esc interrupt", "tab step", "shift+tab mode", "ctrl+o turns"] : ["enter send", "shift+tab mode", "/ commands", "@ file", "! shell", "ctrl+o turns"];
   const kept = [...parts];
-  while (kept.length > 1 && kept.join(` ${sep2} `).length > columns) kept.pop();
-  return kept.join(` ${sep2} `);
+  while (kept.length > 1 && kept.join(` ${sep3} `).length > columns) kept.pop();
+  return kept.join(` ${sep3} `);
 }
 var MAX_STATIC_LINE;
 var init_hints = __esm({
@@ -40398,13 +40398,13 @@ function formatDuration(ms) {
   const min = Math.floor(ms / 6e4);
   return min < 1 ? "<1 min" : min < 60 ? `${min} min` : `${Math.floor(min / 60)}h ${min % 60}m`;
 }
-function formatHeader({ project, git, otherSessions, turns, elapsedMs, columns: terminalColumns }, sep2 = "\xB7") {
+function formatHeader({ project, git, otherSessions, turns, elapsedMs, columns: terminalColumns }, sep3 = "\xB7") {
   const columns = Math.min(terminalColumns, MAX_STATIC_LINE);
   const optional = [];
   const branch = [];
   if (git?.kind === "ok") {
     branch.push({ text: git.branch });
-    if (git.dirty > 0) branch.push({ text: `${sep2 === "\xB7" ? "\xB1" : "+-"}${git.dirty}`, role: "needsYou" });
+    if (git.dirty > 0) branch.push({ text: `${sep3 === "\xB7" ? "\xB1" : "+-"}${git.dirty}`, role: "needsYou" });
   } else if (git?.kind === "unknown") {
     branch.push({ text: "git ?", role: "needsYou" });
   }
@@ -40413,7 +40413,7 @@ function formatHeader({ project, git, otherSessions, turns, elapsedMs, columns:
   optional.push({ text: formatDuration(elapsedMs), role: "secondary" });
   const base = [{ text: "spacecode", bold: true }, { text: project }];
   const all = [...base, ...branch, ...optional];
-  const width = (segs) => segs.reduce((n, s, i) => n + s.text.length + (i > 0 ? sep2.length + 2 : 0), 0);
+  const width = (segs) => segs.reduce((n, s, i) => n + s.text.length + (i > 0 ? sep3.length + 2 : 0), 0);
   const kept = [...all];
   while (kept.length > base.length && width(kept) > columns) kept.pop();
   return kept;
@@ -40451,9 +40451,9 @@ function truncatePath(target, max, ellipsis = "\u2026") {
   }
   return max <= e ? ellipsis.slice(0, max) : `${target.slice(0, max - e)}${ellipsis}`;
 }
-function fitStepLine({ verb, target, meta, columns, indent = 4, ellipsis = "\u2026", sep: sep2 = "\xB7" }) {
+function fitStepLine({ verb, target, meta, columns, indent = 4, ellipsis = "\u2026", sep: sep3 = "\xB7" }) {
   const room = Math.max(10, columns - indent);
-  const metaText = meta ? ` ${sep2} ${meta}` : "";
+  const metaText = meta ? ` ${sep3} ${meta}` : "";
   const fixed = verb.length + 1;
   if (fixed + target.length + metaText.length <= room) return { verb, target, meta };
   const targetRoom = room - fixed - metaText.length;
@@ -40480,10 +40480,10 @@ var init_rail = __esm({
 
 // src/components/Header.tsx
 function Header(props) {
-  const sep2 = activeGlyphs().sep;
-  const segments2 = formatHeader(props, sep2);
+  const sep3 = activeGlyphs().sep;
+  const segments2 = formatHeader(props, sep3);
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Box_default, { children: segments2.map((seg, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react22.default.Fragment, { children: [
-    i > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { ...paint("secondary"), children: ` ${sep2} ` }),
+    i > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { ...paint("secondary"), children: ` ${sep3} ` }),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Text, { bold: seg.bold, ...seg.role ? paint(seg.role) : {}, children: seg.text })
   ] }, i)) });
 }
@@ -44010,7 +44010,7 @@ var require_core = __commonJS({
       return match && match.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join10(regexps, separator = "|") {
+    function join12(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex2) => {
         numCaptures += 1;
@@ -44314,7 +44314,7 @@ var require_core = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join10(terminators), true);
+          this.matcherRe = langRe(join12(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -102807,8 +102807,8 @@ function formatTurnSummary({ toolCount, elapsedMs, inputTokens, outputTokens, in
   return `${head} ${bar} ${formatTokens(inputTokens)} ${arrow} ${formatTokens(outputTokens)} ${bar} ${formatCost(estimateCostUsd(inputTokens, outputTokens))}`;
 }
 function formatThinking(elapsedMs, approxTokens, unicode = true) {
-  const [mark, dots, sep2] = unicode ? ["\u273B", "\u2026", "\xB7"] : ["*", "...", "-"];
-  return `${mark} Thinking${dots} (${Math.floor(elapsedMs / 1e3)}s ${sep2} ~${formatTokens(approxTokens)} tokens ${sep2} esc to interrupt)`;
+  const [mark, dots, sep3] = unicode ? ["\u273B", "\u2026", "\xB7"] : ["*", "...", "-"];
+  return `${mark} Thinking${dots} (${Math.floor(elapsedMs / 1e3)}s ${sep3} ~${formatTokens(approxTokens)} tokens ${sep3} esc to interrupt)`;
 }
 var ESTIMATED_USD_PER_MTOK, MODEL_PLACEHOLDER, CONTEXT_WARN_PCT, CONTEXT_CRITICAL_PCT, BAR_CELLS, BAR_MIN_COLUMNS;
 var init_footer = __esm({
@@ -103121,6 +103121,7 @@ var init_slash_commands = __esm({
       { name: "cost", description: "Show session token usage and approximate cost" },
       { name: "context", description: "Show how much of the context window is used" },
       { name: "status", description: "Show project, session, mode, context and cost" },
+      { name: "record", description: "Session recording: /record off|on|status" },
       { name: "compact", description: "Summarize the conversation to free up context" },
       { name: "model", description: "List gateway models; /model <n|id> switches for this session" },
       { name: "turns", description: "Browse earlier turns and open their steps (shortcut: ctrl+o)" },
@@ -103970,6 +103971,439 @@ var init_node_mentions = __esm({
   }
 });
 
+// src/recording/message-diff.ts
+import { createHash as createHash2 } from "node:crypto";
+function stableStringify(v2) {
+  if (Array.isArray(v2)) return `[${v2.map((x2) => stableStringify(x2 === void 0 ? null : x2)).join(",")}]`;
+  if (v2 && typeof v2 === "object") {
+    const entries = Object.entries(v2).filter(([, x2]) => x2 !== void 0).sort(([a], [b2]) => a < b2 ? -1 : a > b2 ? 1 : 0).map(([k2, x2]) => `${JSON.stringify(k2)}:${stableStringify(x2)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(v2) ?? "null";
+}
+function messageHash(m2) {
+  return createHash2("sha256").update(stableStringify(m2)).digest("hex");
+}
+function diffMessages(prevHashes, messages) {
+  const hashes = messages.map(messageHash);
+  let p = 0;
+  while (p < prevHashes.length && p < hashes.length && prevHashes[p] === hashes[p]) p++;
+  if (p === prevHashes.length) {
+    return { events: messages.length === p ? [] : [{ type: "append", messages: messages.slice(p) }], hashes };
+  }
+  return { events: [{ type: "rewrite", messages }], hashes };
+}
+var init_message_diff = __esm({
+  "src/recording/message-diff.ts"() {
+    "use strict";
+  }
+});
+
+// src/recording/recording-chunks.ts
+import { createHash as createHash3 } from "node:crypto";
+function splitOversize(event, maxBytes) {
+  const s = JSON.stringify(event);
+  const size = Math.max(1, Math.floor(maxBytes / 8));
+  const pieces = [];
+  for (let i = 0; i < s.length; i += size) pieces.push(s.slice(i, i + size));
+  const id = createHash3("sha256").update(s).digest("hex");
+  return pieces.map((data, index) => ({ type: "part", id, index, of: pieces.length, data }));
+}
+function packEvents(events, maxBytes = DEFAULT_MAX_BYTES) {
+  const lines2 = [];
+  for (const event of events) {
+    const line = `${JSON.stringify(event)}
+`;
+    if (Buffer.byteLength(line) <= maxBytes) {
+      lines2.push(line);
+      continue;
+    }
+    for (const part2 of splitOversize(event, maxBytes)) {
+      const partLine = `${JSON.stringify(part2)}
+`;
+      if (Buffer.byteLength(partLine) > maxBytes) throw new Error(`maxBytes ${maxBytes} is too small to hold a recording part`);
+      lines2.push(partLine);
+    }
+  }
+  const chunks = [];
+  let current = "";
+  let currentBytes = 0;
+  for (const line of lines2) {
+    const bytes = Buffer.byteLength(line);
+    if (current !== "" && currentBytes + bytes > maxBytes) {
+      chunks.push(current);
+      current = "";
+      currentBytes = 0;
+    }
+    current += line;
+    currentBytes += bytes;
+  }
+  if (current !== "") chunks.push(current);
+  return chunks;
+}
+var DEFAULT_MAX_BYTES;
+var init_recording_chunks = __esm({
+  "src/recording/recording-chunks.ts"() {
+    "use strict";
+    DEFAULT_MAX_BYTES = 262144;
+  }
+});
+
+// src/recording/recorder.ts
+import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir4, readFile as readFile5, rename as rename4, rm as rm2, writeFile as writeFile4, readdir as readdir4, stat as stat3 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+function projectHash(root) {
+  return createHash4("sha256").update(root).digest("hex");
+}
+function createRecorder(deps) {
+  const states = /* @__PURE__ */ new Map();
+  let lastError = null;
+  let off2 = null;
+  let inflight = null;
+  let retryAttempt = 0;
+  let timerArmed = false;
+  const stateFile = (sessionId) => join7(deps.dir, `${sessionId}.json`);
+  async function save(sessionId, st) {
+    await mkdir4(deps.dir, { recursive: true, mode: 448 });
+    const tmp = `${stateFile(sessionId)}.${deps.randomId()}.tmp`;
+    await writeFile4(tmp, JSON.stringify(st), { mode: 384 });
+    await rename4(tmp, stateFile(sessionId));
+  }
+  async function load(sessionId) {
+    const cached = states.get(sessionId);
+    if (cached) return cached;
+    let st;
+    try {
+      st = JSON.parse(await readFile5(stateFile(sessionId), "utf8"));
+    } catch (e) {
+      if (e.code !== "ENOENT") {
+        const bad = join7(deps.dir, "bad");
+        await mkdir4(bad, { recursive: true, mode: 448 });
+        await rename4(stateFile(sessionId), join7(bad, `${sessionId}.${deps.now()}.json`)).catch((err) => deps.log(`recording: could not quarantine ${sessionId}: ${String(err)}`));
+        lastError = `recording state for ${sessionId} was unreadable and was quarantined`;
+        deps.log(`recording: ${lastError}`);
+      }
+      st = { recordingId: deps.randomId(), hashes: [], nextSeq: 1, queue: [], parentRecordingId: null, meta: null, stopped: null };
+    }
+    states.set(sessionId, st);
+    return st;
+  }
+  async function queuedBytes() {
+    let total = 0;
+    for (const st of states.values()) for (const q2 of st.queue) total += q2.text.length;
+    return total;
+  }
+  async function record(sessionId, messages, meta) {
+    try {
+      if (off2) return;
+      const st = await load(sessionId);
+      if (st.stopped) return;
+      if (st.hashes.length === 0 && st.nextSeq === 1 && meta.parentRecordingId) st.parentRecordingId = meta.parentRecordingId;
+      st.meta = meta;
+      const safe = redactCredentials(messages);
+      const { events, hashes } = diffMessages(st.hashes, safe);
+      if (events.length > 0) {
+        if (await queuedBytes() > MAX_QUEUE_BYTES) {
+          st.stopped = "local recording queue is full (100 MB); recording stopped for this session";
+          lastError = st.stopped;
+          await save(sessionId, st);
+          return;
+        }
+        const now = deps.now();
+        for (const text of packEvents(events)) st.queue.push({ seq: st.nextSeq++, text, queuedAt: now });
+        st.hashes = hashes;
+      }
+      await save(sessionId, st);
+      void flush();
+    } catch (e) {
+      lastError = `could not queue recording: ${e instanceof Error ? e.message : String(e)}`;
+      deps.log(`recording: ${lastError}`);
+    }
+  }
+  async function sendOne(st, item) {
+    const m2 = st.meta;
+    const meta = m2 ? encodeURIComponent(JSON.stringify({
+      sessionId: m2.sessionId,
+      parentRecordingId: st.parentRecordingId,
+      title: m2.title.slice(0, 200),
+      projectHash: projectHash(m2.projectRoot),
+      turns: m2.turns,
+      inputTokens: m2.tokens.input,
+      outputTokens: m2.tokens.output
+    })) : "";
+    let res;
+    try {
+      res = await deps.fetch(`${deps.baseUrl.replace(/\/$/, "")}/api/recordings/${st.recordingId}/chunks/${item.seq}`, {
+        method: "PUT",
+        headers: { authorization: `Bearer ${deps.apiKey}`, "content-type": "application/octet-stream", ...meta ? { "x-spacecode-recording-meta": meta } : {} },
+        body: item.text
+      });
+    } catch (e) {
+      lastError = `recording upload failed: ${e instanceof Error ? e.message : String(e)}`;
+      return "retry";
+    }
+    if (res.ok) return "ok";
+    const body = await res.text().catch(() => "");
+    if (res.status === 409) {
+      const lastSeq = (() => {
+        try {
+          return JSON.parse(body).last_seq ?? -1;
+        } catch {
+          return -1;
+        }
+      })();
+      if (lastSeq >= item.seq) return "ok";
+      lastError = `recording out of sync with the server (server has ${lastSeq}, next to send ${item.seq})`;
+      st.stopped = lastError;
+      return "stop";
+    }
+    if (res.status === 403) {
+      st.stopped = "not recording: no tenant or recording is not enabled for this account";
+      lastError = st.stopped;
+      return "stop";
+    }
+    if (res.status === 401) {
+      lastError = "not recording: sign in (spacecode login)";
+      return "retry";
+    }
+    if (res.status === 413) {
+      st.stopped = `not recording: server limit reached (${body.slice(0, 120)})`;
+      lastError = st.stopped;
+      return "stop";
+    }
+    lastError = `recording upload failed: HTTP ${res.status}`;
+    return "retry";
+  }
+  async function flushOnce() {
+    let allSent = true;
+    for (const [sessionId, st] of states) {
+      while (st.queue.length > 0 && !st.stopped) {
+        const item = st.queue[0];
+        const out = await sendOne(st, item);
+        if (out === "ok") {
+          st.queue.shift();
+          lastError = null;
+          await save(sessionId, st).catch((e) => deps.log(`recording: could not save state: ${String(e)}`));
+          continue;
+        }
+        if (out === "retry") allSent = false;
+        await save(sessionId, st).catch((e) => deps.log(`recording: could not save state: ${String(e)}`));
+        break;
+      }
+    }
+    return allSent;
+  }
+  function flush() {
+    if (inflight) return inflight;
+    inflight = (async () => {
+      try {
+        const done = await flushOnce();
+        if (done) retryAttempt = 0;
+        else scheduleRetry();
+      } catch (e) {
+        lastError = `recording flush failed: ${e instanceof Error ? e.message : String(e)}`;
+        deps.log(`recording: ${lastError}`);
+        scheduleRetry();
+      } finally {
+        inflight = null;
+      }
+    })();
+    return inflight;
+  }
+  function scheduleRetry() {
+    if (timerArmed) return;
+    timerArmed = true;
+    const ms = RETRY_MS[Math.min(retryAttempt++, RETRY_MS.length - 1)];
+    const arm = deps.setTimer ?? ((fn, t) => setTimeout(fn, t));
+    arm(() => {
+      timerArmed = false;
+      void flush();
+    }, ms).unref?.();
+  }
+  function status() {
+    if (off2) return { state: "off", detail: `not recording: ${off2}`, queued: 0, oldestAgeMs: null, lastError };
+    let queued = 0;
+    let oldest = null;
+    let stopped = null;
+    for (const st of states.values()) {
+      queued += st.queue.length;
+      for (const q2 of st.queue) oldest = oldest === null ? q2.queuedAt : Math.min(oldest, q2.queuedAt);
+      stopped ??= st.stopped;
+    }
+    if (stopped) return { state: "stopped", detail: stopped, queued, oldestAgeMs: null, lastError };
+    const age = oldest === null ? null : Math.max(0, deps.now() - oldest);
+    if (queued > 0) return { state: lastError ? "queued" : "uploading", detail: `${queued} queued${lastError ? `, last error: ${lastError}` : ""}`, queued, oldestAgeMs: age, lastError };
+    return { state: "idle", detail: "recording, all uploaded", queued: 0, oldestAgeMs: null, lastError };
+  }
+  function setOff(reason) {
+    off2 = reason;
+  }
+  async function resume() {
+    let names;
+    try {
+      names = await readdir4(deps.dir);
+    } catch (e) {
+      if (e.code === "ENOENT") return;
+      throw e;
+    }
+    for (const n of names) {
+      if (!n.endsWith(".json")) continue;
+      const id = n.slice(0, -5);
+      const st = await load(id);
+      if (st.queue.length === 0) states.delete(id);
+    }
+    if ([...states.values()].some((s) => s.queue.length > 0)) void flush();
+  }
+  return { record, flush, status, setOff, resume };
+}
+var MAX_QUEUE_BYTES, RETRY_MS;
+var init_recorder = __esm({
+  "src/recording/recorder.ts"() {
+    "use strict";
+    init_session_store();
+    init_message_diff();
+    init_recording_chunks();
+    MAX_QUEUE_BYTES = 100 * 1024 * 1024;
+    RETRY_MS = [2e3, 1e4, 3e4, 12e4, 3e5];
+  }
+});
+
+// src/recording/recording-runtime.ts
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5, stat as stat4 } from "node:fs/promises";
+import { join as join8, sep as sep2 } from "node:path";
+function matchesExclude(pattern, root) {
+  const re3 = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, `[^${sep2 === "\\" ? "\\\\" : "/"}]*`).replace(/\u0000/g, ".*");
+  return new RegExp(`^${re3}(?:[/\\\\].*)?$`).test(root);
+}
+async function exists(path12) {
+  try {
+    await stat4(path12);
+    return true;
+  } catch (e) {
+    if (e.code === "ENOENT") return false;
+    throw e;
+  }
+}
+function createRecordingRuntime(deps) {
+  const dir = join8(deps.configDir, "recordings");
+  const noticeFile = join8(dir, ".notice");
+  let recorder = null;
+  let standingOff;
+  let sessionOff = false;
+  async function decide() {
+    if (deps.env.SPACECODE_RECORD?.trim().toLowerCase() === "off") return "SPACECODE_RECORD=off";
+    let cfg = {};
+    try {
+      cfg = JSON.parse(await readFile6(join8(deps.configDir, "config.json"), "utf8"));
+    } catch (e) {
+      if (e.code !== "ENOENT") return `~/.spacecode/config.json is unreadable (${e instanceof Error ? e.message : String(e)}); fix it to record`;
+    }
+    if (cfg.recording?.enabled === false) return "turned off in ~/.spacecode/config.json (recording.enabled)";
+    const excludes = Array.isArray(cfg.recording?.exclude) ? cfg.recording.exclude.filter((x2) => typeof x2 === "string") : [];
+    const hit = excludes.find((p) => matchesExclude(p, deps.projectRoot));
+    if (hit) return `this folder matches recording.exclude (${hit})`;
+    if (await exists(join8(deps.projectRoot, ".spacecode", "norecord"))) return "this repo has .spacecode/norecord";
+    return null;
+  }
+  async function noticeShown() {
+    return exists(noticeFile);
+  }
+  async function ackNotice() {
+    await mkdir5(dir, { recursive: true, mode: 448 });
+    await writeFile5(noticeFile, new Date((deps.now ?? Date.now)()).toISOString(), { mode: 384 });
+  }
+  async function ensure() {
+    if (recorder) return recorder;
+    const apiKey = await deps.resolveApiKey();
+    if (!apiKey) return null;
+    recorder = createRecorder({
+      dir,
+      baseUrl: deps.baseUrl,
+      apiKey,
+      fetch: deps.fetch,
+      now: deps.now ?? Date.now,
+      randomId: () => `rec-${crypto.randomUUID()}`,
+      log: deps.log ?? (() => {
+      })
+    });
+    await recorder.resume();
+    return recorder;
+  }
+  return {
+    /**
+     * Called after a successful session save. Returns the notice text the first time (the caller must show it; uploads start
+     * on the next call, after it has been shown), otherwise null. Never throws.
+     */
+    async afterSave(sessionId, messages, meta) {
+      try {
+        if (sessionOff) return null;
+        standingOff ??= await decide();
+        if (standingOff) return null;
+        if (!await noticeShown()) {
+          await ackNotice();
+          return RECORDING_NOTICE;
+        }
+        const r = await ensure();
+        if (!r) return null;
+        await r.record(sessionId, messages, meta);
+        return null;
+      } catch (e) {
+        deps.log?.(`recording: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+      }
+    },
+    /** One status line for /status; always says why when nothing is being recorded. */
+    async statusLine() {
+      try {
+        if (sessionOff) return "recording: off for this session (/record on to resume)";
+        standingOff ??= await decide();
+        if (standingOff) return `recording: not recording: ${standingOff}`;
+        if (recorder) {
+          const s = recorder.status();
+          const age = s.oldestAgeMs !== null && s.queued > 0 ? `, oldest ${Math.round(s.oldestAgeMs / 1e3)}s` : "";
+          return `recording: ${s.detail}${age}`;
+        }
+        return await noticeShown() ? "recording: on (starts with your next saved turn)" : "recording: on, starts after the first notice (shown after your next turn)";
+      } catch (e) {
+        return `recording: status unavailable (${e instanceof Error ? e.message : String(e)})`;
+      }
+    },
+    /** `/record [on|off|status]`; returns the text to show. */
+    async command(arg) {
+      const a = arg.trim().toLowerCase();
+      if (a === "off") {
+        sessionOff = true;
+        recorder?.setOff("turned off with /record off");
+        return "Recording is off for this session. What was already uploaded stays until it expires (90 days).";
+      }
+      if (a === "on") {
+        sessionOff = false;
+        recorder?.setOff(null);
+        standingOff = void 0;
+        return `Recording resumes with your next saved turn.
+${await this.statusLine()}`;
+      }
+      if (a === "" || a === "status") return `${await this.statusLine()}
+${RECORDING_NOTICE}`;
+      return "Usage: /record [on|off|status]";
+    }
+  };
+}
+var RECORDING_NOTICE;
+var init_recording_runtime = __esm({
+  "src/recording/recording-runtime.ts"() {
+    "use strict";
+    init_recorder();
+    RECORDING_NOTICE = [
+      "Session recording is on for your account when your workspace has it enabled.",
+      "Your prompts, the assistant's replies and thinking, and tool calls and results are uploaded, encrypted at rest, kept 90 days, and visible only to your account.",
+      "Credential-shaped text is replaced before upload, but redaction is a best-effort net, not a guarantee.",
+      "Turn it off: /record off (this session), `SPACECODE_RECORD=off` (always), or add the folder to `recording.exclude` in ~/.spacecode/config.json or create `.spacecode/norecord` in the repo."
+    ].join("\n");
+  }
+});
+
 // src/skills-command.ts
 async function runSkillsCommand(args, deps) {
   const [sub, name, file] = args.trim().split(/\s+/);
@@ -104010,11 +104444,11 @@ var init_skills_command = __esm({
 });
 
 // src/permission-rules-loader.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join9 } from "node:path";
 async function readOrNull2(path12) {
   try {
-    return await readFile5(path12, "utf8");
+    return await readFile7(path12, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return null;
     throw err;
@@ -104022,7 +104456,7 @@ async function readOrNull2(path12) {
 }
 async function loadPermissionRules(deps) {
   const none = (line) => ({ rules: void 0, defaultMode: void 0, statusLines: [line] });
-  const configPath = join7(deps.configDir, "imports.json");
+  const configPath = join9(deps.configDir, "imports.json");
   try {
     const loaded = parseImportsConfig(await readOrNull2(configPath), configPath);
     if (loaded.error) return none("permission rules: off (imports.json unreadable)");
@@ -104031,13 +104465,13 @@ async function loadPermissionRules(deps) {
     return none(`permission rules: off (imports.json not read: ${err instanceof Error ? err.message : String(err)})`);
   }
   const lines2 = [];
-  const files = [{ scope: "user", path: join7(deps.homeDir, ".claude", "settings.json") }];
+  const files = [{ scope: "user", path: join9(deps.homeDir, ".claude", "settings.json") }];
   try {
     const sources2 = await readRepoSources(deps.cwd);
     if (sources2[".claude/settings.json"] !== void 0 || sources2[".claude/settings.local.json"] !== void 0) {
       const status = await createNodeTrustStore(deps.configDir).repoStatus(deps.cwd, sources2);
       if (status === "trusted" || status === "session") {
-        files.push({ scope: "repo", path: join7(deps.cwd, ".claude", "settings.json") }, { scope: "local", path: join7(deps.cwd, ".claude", "settings.local.json") });
+        files.push({ scope: "repo", path: join9(deps.cwd, ".claude", "settings.json") }, { scope: "local", path: join9(deps.cwd, ".claude", "settings.local.json") });
       } else lines2.push(`permission rules: repo settings NOT loaded (${status === "never" ? "marked never trust" : "untrusted repo"})`);
     }
   } catch (err) {
@@ -104079,7 +104513,7 @@ var init_permission_rules_loader = __esm({
 });
 
 // src/command-loader.ts
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 async function userCommands(deps, lines2) {
   try {
     const apiKey = await resolveApiKey({ env: deps.env, readFile: deps.readFile, homedir: deps.homedir });
@@ -104134,7 +104568,7 @@ async function repoCommands(deps, lines2) {
   }
 }
 async function loadCommands(deps) {
-  const configPath = join8(deps.configDir, "imports.json");
+  const configPath = join10(deps.configDir, "imports.json");
   try {
     const loaded = parseImportsConfig(await deps.readFile(configPath).catch((err) => {
       if (err.code === "ENOENT") return null;
@@ -104167,9 +104601,9 @@ var init_command_loader = __esm({
 });
 
 // src/useReplController.ts
-import { readFile as readFile6, writeFile as writeFile4, mkdir as mkdir4 } from "node:fs/promises";
+import { readFile as readFile8, writeFile as writeFile6, mkdir as mkdir6 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 import { execFile as execFile3 } from "node:child_process";
 function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mentionsOpt, sessions, resumeLatest: resumeLatest2, onViewTurns, onViewResume, isEscOwned }) {
   const { exit } = use_app_default();
@@ -104197,6 +104631,16 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
   const profilePromiseRef = (0, import_react30.useRef)(null);
   const profileRef = (0, import_react30.useRef)(null);
   const mcpRef = (0, import_react30.useRef)(null);
+  const recordingRef = (0, import_react30.useRef)(null);
+  const recording = () => recordingRef.current ??= createRecordingRuntime({
+    env: process.env,
+    configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join11(homedir2(), ".spacecode"),
+    projectRoot,
+    fetch,
+    baseUrl: backendUrl(process.env),
+    resolveApiKey: () => resolveApiKey({ env: process.env, readFile: (p) => readFile8(p, "utf-8"), homedir: homedir2 }).catch(() => null),
+    log: (m2) => console.error(`[agent-ui] ${m2}`)
+  });
   const resumeListRef = (0, import_react30.useRef)([]);
   const [model, setModel] = (0, import_react30.useState)(null);
   const [todos, setTodosState] = (0, import_react30.useState)([]);
@@ -104217,10 +104661,10 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
   (0, import_react30.useEffect)(() => {
     let live2 = true;
     loadCommands({
-      configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join9(homedir2(), ".spacecode"),
+      configDir: process.env.SPACECODE_CONFIG_DIR?.trim() || join11(homedir2(), ".spacecode"),
       cwd: process.cwd(),
       env: process.env,
-      readFile: (p) => readFile6(p, "utf-8"),
+      readFile: (p) => readFile8(p, "utf-8"),
       homedir: homedir2,
       fetch,
       builtins: SLASH_COMMANDS.map((c) => c.name)
@@ -104320,6 +104764,9 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
         const id = sessionIdRef.current ??= sessions.newId();
         const createdAt = sessionCreatedAtRef.current ??= (/* @__PURE__ */ new Date()).toISOString();
         await sessions.save({ meta: { v: 1, id, projectRoot, createdAt, updatedAt: createdAt, tokens, title: titleFromMessages(messages), turns: countTurns(messages), todos: todosRef.current }, messages });
+        void recording().afterSave(id, messages, { sessionId: id, projectRoot, title: titleFromMessages(messages), turns: countTurns(messages), tokens }).then((firstRunNotice) => {
+          if (firstRunNotice) notice(firstRunNotice);
+        });
       } catch (err) {
         noticeError(describeError("session-save", err instanceof Error ? err.message : String(err)));
       }
@@ -104434,7 +104881,11 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
         case "context":
           notice(formatContextReport({ contextTokens: estimateTotalTokens("", history), maxContextTokens: DEFAULT_MAX_CONTEXT_TOKENS }));
           return;
-        case "status":
+        case "record":
+          notice(await recording().command(slash.args));
+          return;
+        case "status": {
+          const recordingLine = await recording().statusLine();
           notice(formatStatusReport({
             mode: permissions.mode,
             sessionId: sessionIdRef.current,
@@ -104443,9 +104894,10 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
             maxContextTokens: DEFAULT_MAX_CONTEXT_TOKENS,
             tokens: sessionTokensRef.current,
             costUsd: estimateCostUsd(sessionTokensRef.current.input, sessionTokensRef.current.output),
-            profileLines: [...profileRef.current?.statusLines ?? ["profile: not loaded yet (loads on your first message)"], ...mcpRef.current?.statusLines() ?? [], ...commandsLoaded.statusLines]
+            profileLines: [...profileRef.current?.statusLines ?? ["profile: not loaded yet (loads on your first message)"], ...mcpRef.current?.statusLines() ?? [], ...commandsLoaded.statusLines, recordingLine]
           }));
           return;
+        }
         case "resume": {
           if (!sessions) {
             notice("Session storage is not available, so there is nothing to resume.");
@@ -104500,7 +104952,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
           }
           setIsRunning(true);
           try {
-            const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile6(p, "utf-8"), homedir: homedir2 });
+            const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile8(p, "utf-8"), homedir: homedir2 });
             if (!apiKey2) {
               notice(MISSING_KEY_MESSAGE);
               return;
@@ -104522,7 +104974,7 @@ function useReplController({ repoName: repoName2, yolo: yolo2, mentions: mention
         }
         case "model": {
           try {
-            const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile6(p, "utf-8"), homedir: homedir2 });
+            const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile8(p, "utf-8"), homedir: homedir2 });
             if (!apiKey2) {
               notice(MISSING_KEY_MESSAGE);
               return;
@@ -104557,7 +105009,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
         }
         case "skills": {
           const state = profileRef.current;
-          const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile6(p, "utf-8"), homedir: homedir2 }).catch(() => null);
+          const apiKey2 = await resolveApiKey({ env: process.env, readFile: (p) => readFile8(p, "utf-8"), homedir: homedir2 }).catch(() => null);
           const client = apiKey2 ? createProfileClient({ baseUrl: backendUrl(process.env), apiKey: apiKey2, fetch }) : null;
           notice(await runSkillsCommand(slash.args, { source: state?.skills ?? null, client, statusLines: state?.statusLines.filter((l) => l.startsWith("skills")) ?? ["skills: not loaded yet (loads on your first message)"] }));
           return;
@@ -104579,7 +105031,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
     try {
       apiKey = await resolveApiKey({
         env: process.env,
-        readFile: (p) => readFile6(p, "utf-8"),
+        readFile: (p) => readFile8(p, "utf-8"),
         homedir: homedir2
       });
     } catch (err) {
@@ -104616,17 +105068,17 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
     try {
       profilePromiseRef.current ??= prepareProfile({
         env: process.env,
-        readFile: (p) => readFile6(p, "utf-8"),
-        writeFile: (p, d) => writeFile4(p, d, { encoding: "utf-8", mode: 384 }),
+        readFile: (p) => readFile8(p, "utf-8"),
+        writeFile: (p, d) => writeFile6(p, d, { encoding: "utf-8", mode: 384 }),
         mkdir: async (p) => {
-          await mkdir4(p, { recursive: true });
+          await mkdir6(p, { recursive: true });
         },
         homedir: homedir2,
         fetch,
         cwd: process.cwd(),
         gitRoot: gitTopLevel,
         importGate: async () => {
-          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join9(homedir2(), ".spacecode");
+          const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join11(homedir2(), ".spacecode");
           const gate = await importGateStatus({ configDir, cwd: process.cwd(), interactive: Boolean(process.stdin.isTTY) });
           const loaded = await loadPermissionRules({ configDir, homeDir: homedir2(), cwd: process.cwd() });
           rulesRef.current = loaded.rules;
@@ -104636,7 +105088,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
       });
       profileRef.current = await profilePromiseRef.current;
       if (mcpRef.current === null && (profileRef.current?.mcpDefs?.length ?? 0) > 0) {
-        const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join9(homedir2(), ".spacecode");
+        const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || join11(homedir2(), ".spacecode");
         const trust = createNodeTrustStore(configDir);
         const manager = new McpManager({
           defs: profileRef.current.mcpDefs,
@@ -104646,7 +105098,7 @@ ${list2.map((c) => `  /${c.name}  (${c.scope})${c.description ? `  ${c.descripti
           ...rulesRef.current ? { rules: rulesRef.current } : {},
           permissions,
           confirm: askUser,
-          audit: new FileAuditLog(join9(homedir2(), ".spacecode", "audit.jsonl")),
+          audit: new FileAuditLog(join11(homedir2(), ".spacecode", "audit.jsonl")),
           clientVersion: process.env.SPACECODE_VERSION ?? "0"
         });
         mcpRef.current = manager;
@@ -104777,6 +105229,7 @@ var init_useReplController = __esm({
     init_node_mentions();
     init_api_key();
     init_profile_runtime();
+    init_recording_runtime();
     init_skills_command();
     init_src();
     init_mcp_manager();
@@ -104913,14 +105366,14 @@ import path9 from "node:path";
 function orderSessions(sessions, projectRoot) {
   return [...sessions.filter((s) => s.projectRoot === projectRoot), ...sessions.filter((s) => s.projectRoot !== projectRoot)];
 }
-function formatResumeRow(meta, now, columns, sep2 = "\xB7", ellipsis = "\u2026") {
+function formatResumeRow(meta, now, columns, sep3 = "\xB7", ellipsis = "\u2026") {
   const project = path9.basename(meta.projectRoot) || meta.projectRoot;
-  const tail = [meta.turns !== void 0 ? `${meta.turns} turn${meta.turns === 1 ? "" : "s"}` : null, formatCost(estimateCostUsd(meta.tokens.input, meta.tokens.output))].filter(Boolean).join(` ${sep2} `);
-  const head = `${formatAge(meta.updatedAt, now)} ${sep2} ${project} ${sep2} `;
-  const fixed = head.length + 2 + ` ${sep2} ${tail}`.length;
+  const tail = [meta.turns !== void 0 ? `${meta.turns} turn${meta.turns === 1 ? "" : "s"}` : null, formatCost(estimateCostUsd(meta.tokens.input, meta.tokens.output))].filter(Boolean).join(` ${sep3} `);
+  const head = `${formatAge(meta.updatedAt, now)} ${sep3} ${project} ${sep3} `;
+  const fixed = head.length + 2 + ` ${sep3} ${tail}`.length;
   const room = Math.max(8, columns - fixed);
   const title = meta.title.length > room ? `${meta.title.slice(0, Math.max(1, room - ellipsis.length))}${ellipsis}` : meta.title;
-  return `${head}"${title}" ${sep2} ${tail}`;
+  return `${head}"${title}" ${sep3} ${tail}`;
 }
 var init_resume_rows = __esm({
   "src/render/resume-rows.ts"() {
@@ -105367,7 +105820,7 @@ function clearOnResize(stdout) {
 var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
 if (process.argv[2] === "import-claude") {
   const { runImportClaude: runImportClaude2 } = await Promise.resolve().then(() => (init_import_claude(), import_claude_exports));
-  const { readFile: readFile7, readdir: readdir4 } = await import("node:fs/promises");
+  const { readFile: readFile9, readdir: readdir5 } = await import("node:fs/promises");
   const { execFile: execFile4 } = await import("node:child_process");
   const gitRoot = () => new Promise((resolve2) => {
     execFile4("git", ["rev-parse", "--show-toplevel"], { cwd: process.cwd() }, (err, stdout) => resolve2(err ? null : stdout.trim() || null));
@@ -105375,8 +105828,8 @@ if (process.argv[2] === "import-claude") {
   const code = await runImportClaude2({
     argv: process.argv.slice(2),
     env: process.env,
-    fs: { readFile: (p) => readFile7(p, "utf-8"), readdir: (p) => readdir4(p) },
-    readFile: (p) => readFile7(p, "utf-8"),
+    fs: { readFile: (p) => readFile9(p, "utf-8"), readdir: (p) => readdir5(p) },
+    readFile: (p) => readFile9(p, "utf-8"),
     homedir: os5.homedir,
     cwd: process.cwd(),
     gitRoot,
@@ -105401,9 +105854,9 @@ if (process.argv[2] === "approve-mcp") {
   const { resolveApiKey: resolveApiKey2 } = await Promise.resolve().then(() => (init_api_key(), api_key_exports));
   const { backendUrl: backendUrl2 } = await Promise.resolve().then(() => (init_profile_runtime(), profile_runtime_exports));
   const { createProfileClient: createProfileClient2 } = await Promise.resolve().then(() => (init_src(), src_exports));
-  const { readFile: readFile7 } = await import("node:fs/promises");
+  const { readFile: readFile9 } = await import("node:fs/promises");
   const configDir = process.env.SPACECODE_CONFIG_DIR?.trim() || path11.join(os5.homedir(), ".spacecode");
-  const apiKey = await resolveApiKey2({ env: process.env, readFile: (p) => readFile7(p, "utf-8"), homedir: os5.homedir }).catch(() => null);
+  const apiKey = await resolveApiKey2({ env: process.env, readFile: (p) => readFile9(p, "utf-8"), homedir: os5.homedir }).catch(() => null);
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const { createInterface } = interactive ? await import("node:readline/promises") : { createInterface: void 0 };
   const rl = createInterface ? createInterface({ input: process.stdin, output: process.stdout }) : void 0;
@@ -105411,7 +105864,7 @@ if (process.argv[2] === "approve-mcp") {
     const code = await runApproveMcp2({
       configDir,
       cwd: process.cwd(),
-      readFile: (p) => readFile7(p, "utf-8"),
+      readFile: (p) => readFile9(p, "utf-8"),
       client: apiKey ? createProfileClient2({ baseUrl: backendUrl2(process.env), apiKey, fetch }) : null,
       trust: createNodeTrustStore2(configDir),
       ...rl ? { ask: async (q2) => {