archymedes-cli 2.3.0 → 2.6.0

package/dist/{archymedes-twbks7g3.mjs → archymedes-t1jtzkmp.mjs}

@@ -1,15 +1,20 @@
 import {
   padToWidth,
   progressBar,
+  scrollIndicator,
+  scrollPercent,
   sliceToWidth
-} from "./archymedes-g8y3rt6t.mjs";
+} from "./archymedes-kn6wtq32.mjs";
+import {
+  clip
+} from "./archymedes-twanftqk.mjs";
 import {
   ASCII_GLYPHS,
   UNICODE_GLYPHS,
   visibleWidth
-} from "./archymedes-a10k8yrk.mjs";
+} from "./archymedes-s4qcy0q4.mjs";
 
-// src/render/canvas.ts
+// packages/archymedes-cli/src/render/canvas.ts
 var BRAILLE_DOTS = [
   [1, 2, 4, 64],
   [8, 16, 32, 128]
@@ -95,7 +100,7 @@ function seriesBounds(values) {
   return { low, high, span: high - low === 0 ? 1 : high - low };
 }
 
-// src/render/charts.ts
+// packages/archymedes-cli/src/render/charts.ts
 function barChart(data, options) {
   if (data.length === 0)
     return [];
@@ -253,4 +258,208 @@ function heatStrip(data, options) {
   });
 }
 
-export { barChart, lineChart, plotSeries, scatterChart, waveLine, StreamSeries, heatStrip };
+// packages/archymedes-cli/src/ui/workspace-model.ts
+function paneHeight(rows) {
+  return Math.max(1, rows - 4);
+}
+function selectedPane(snapshot) {
+  if (snapshot.panes.length === 0)
+    return;
+  const index = Math.max(0, Math.min(snapshot.selected, snapshot.panes.length - 1));
+  return snapshot.panes[index];
+}
+function visibleLines(pane, height, scroll) {
+  const clamped = Math.max(0, Math.min(scroll, Math.max(0, pane.lines.length - height)));
+  const end = pane.lines.length - clamped;
+  return pane.lines.slice(Math.max(0, end - height), end);
+}
+function atLiveEdge(pane, height, scroll) {
+  return Math.min(scroll, Math.max(0, pane.lines.length - height)) === 0;
+}
+function keyToAction(key, character) {
+  const name = key.name ?? "";
+  const isEscape = name === "escape" || name === "\x1B";
+  const isEnter = name === "return" || name === "enter" || name === "\r" || name === `
+`;
+  if (isEscape || name === "q" && !key.ctrl || key.ctrl && name === "c")
+    return { kind: "exit" };
+  if (isEnter)
+    return { kind: "focus" };
+  if (name === "tab")
+    return { kind: "cycle", step: key.shift ? -1 : 1 };
+  if (name === "left")
+    return { kind: "cycle", step: -1 };
+  if (name === "right")
+    return { kind: "cycle", step: 1 };
+  if (name === "up" || name === "k")
+    return { kind: "scroll", lines: 1 };
+  if (name === "down" || name === "j")
+    return { kind: "scroll", lines: -1 };
+  if (name === "pageup")
+    return { kind: "scroll", lines: 10 };
+  if (name === "pagedown")
+    return { kind: "scroll", lines: -10 };
+  if (name === "home" || character === "g")
+    return { kind: "top" };
+  if (name === "end" || character === "G")
+    return { kind: "bottom" };
+  const digit = character && /^[1-9]$/.test(character) ? Number(character) : undefined;
+  if (digit !== undefined)
+    return { kind: "select", index: digit - 1 };
+  return { kind: "none" };
+}
+function applyAction(snapshot, action) {
+  const count = snapshot.panes.length;
+  if (count === 0 || action.kind === "none" || action.kind === "exit" || action.kind === "focus")
+    return snapshot;
+  if (action.kind === "select") {
+    if (action.index < 0 || action.index >= count)
+      return snapshot;
+    return { ...snapshot, selected: action.index, scroll: 0 };
+  }
+  if (action.kind === "cycle") {
+    const next = ((snapshot.selected + action.step) % count + count) % count;
+    return { ...snapshot, selected: next, scroll: 0 };
+  }
+  const pane = selectedPane(snapshot);
+  const height = paneHeight(snapshot.rows);
+  const furthest = Math.max(0, (pane?.lines.length ?? 0) - height);
+  if (action.kind === "bottom")
+    return { ...snapshot, scroll: 0 };
+  if (action.kind === "top")
+    return { ...snapshot, scroll: furthest };
+  return { ...snapshot, scroll: Math.max(0, Math.min(snapshot.scroll + action.lines, furthest)) };
+}
+function paneTabs(snapshot) {
+  const selected = Math.max(0, Math.min(snapshot.selected, snapshot.panes.length - 1));
+  return snapshot.panes.map((pane, index) => ({
+    label: `${index + 1} ${pane.title}`,
+    active: index === selected,
+    status: pane.status
+  }));
+}
+
+class PaneActivity {
+  capacity;
+  series = new Map;
+  seen = new Map;
+  constructor(capacity = 48) {
+    this.capacity = capacity;
+  }
+  sample(panes) {
+    const live = new Set(panes.map((pane) => pane.key));
+    for (const key of [...this.series.keys()]) {
+      if (!live.has(key)) {
+        this.series.delete(key);
+        this.seen.delete(key);
+      }
+    }
+    const result = new Map;
+    for (const pane of panes) {
+      const produced = pane.lines.length + pane.dropped;
+      const previous = this.seen.get(pane.key);
+      this.seen.set(pane.key, produced);
+      const stream = this.series.get(pane.key) ?? new StreamSeries(this.capacity);
+      this.series.set(pane.key, stream);
+      if (previous !== undefined)
+        stream.push(Math.max(0, produced - previous));
+      result.set(pane.key, stream.values());
+    }
+    return result;
+  }
+}
+function tabPanes(views, linesFor) {
+  return views.map((view) => {
+    const record = linesFor(view.id);
+    const where = view.backend && view.backend !== "local" ? ` · ${view.backend}` : "";
+    return {
+      kind: "tab",
+      key: `${view.id}`,
+      title: view.title,
+      subtitle: `${view.model ?? "model unknown"}${where}${view.cost ? ` · ${view.cost}` : ""}`,
+      status: view.status,
+      lines: record.lines,
+      dropped: record.dropped
+    };
+  });
+}
+var STATUS_MARK = {
+  running: "●",
+  failed: "✕",
+  done: "✓",
+  idle: " "
+};
+var WORKSPACE_LEGEND = "1-9 pane · ←→ move · ↑↓ scroll · g/G ends · Esc back";
+function paneBar(snapshot, columns) {
+  const tabs = paneTabs(snapshot);
+  const cells = tabs.map((tab) => ` ${STATUS_MARK[tab.status] ?? " "}${tab.label} `);
+  const full = cells.join("");
+  if (full.length <= columns)
+    return full || " no panes ";
+  const selected = Math.max(0, Math.min(snapshot.selected, tabs.length - 1));
+  return `${selected > 0 ? "‹ " : ""}${cells[selected] ?? " no panes "}${selected < tabs.length - 1 ? " ›" : ""}`;
+}
+function composeFrame(snapshot) {
+  const rows = [];
+  const columns = Math.max(1, Math.floor(snapshot.columns));
+  const rowCount = Math.max(1, Math.floor(snapshot.rows));
+  const pane = selectedPane(snapshot);
+  const height = paneHeight(rowCount);
+  const theme = snapshot.palette.tokens;
+  const bar = paneBar(snapshot, columns);
+  rows.push({ text: bar || " no panes ", bold: true, color: theme.primary });
+  const scrolled = pane && !atLiveEdge(pane, height, snapshot.scroll);
+  const position = (() => {
+    if (!pane || !scrolled)
+      return "";
+    const maxOffset = Math.max(0, pane.lines.length - height);
+    const offsetFromTop = maxOffset - Math.min(snapshot.scroll, maxOffset);
+    return scrollIndicator(scrollPercent(offsetFromTop, pane.lines.length, height));
+  })();
+  const dropped = pane && pane.dropped > 0 ? `  (${pane.dropped} earlier lines dropped)` : "";
+  const header = pane ? `${pane.title}  ${pane.subtitle}${dropped}` : "nothing open";
+  const activityWidth = Math.min(24, Math.max(0, columns - visibleWidth(header) - 3));
+  const activity = pane?.activity && pane.activity.length > 1 && activityWidth >= 8 ? `  ${waveLine(pane.activity, { width: activityWidth })}` : "";
+  rows.push({
+    text: pane ? `${header}${activity}` : header,
+    bold: true,
+    color: pane?.status === "failed" ? theme.error : pane?.status === "running" ? theme.success : theme.accent
+  });
+  const body = pane ? visibleLines(pane, height, snapshot.scroll) : [];
+  for (let index = 0;index < height; index += 1)
+    rows.push({ text: body[index] ?? "" });
+  while (rows.length < rowCount - 1)
+    rows.push({ text: "" });
+  rows.length = Math.max(0, rowCount - 1);
+  rows.push({
+    text: `${WORKSPACE_LEGEND}${scrolled ? `   ▲ scrolled back  ${position}` : ""}`,
+    dim: true,
+    color: theme.textMuted
+  });
+  return rows.map((row) => ({ ...row, text: clip(row.text, columns) }));
+}
+function buildWorkspaceSnapshot(input) {
+  const panes = [
+    ...tabPanes(input.views, input.linesFor),
+    ...input.jobs.map((job) => ({
+      kind: "job",
+      key: job.id,
+      title: `job ${job.id.slice(-6)}`,
+      subtitle: job.objective,
+      status: job.done ? "done" : "running",
+      lines: job.lines,
+      dropped: job.dropped
+    }))
+  ];
+  const activity = input.activity.sample(panes);
+  return {
+    panes: panes.map((pane) => ({ ...pane, activity: activity.get(pane.key) })),
+    selected: Math.max(0, input.views.findIndex((view) => view.active)),
+    scroll: 0,
+    palette: input.palette,
+    columns: input.columns,
+    rows: input.rows
+  };
+}
+
+export { barChart, lineChart, plotSeries, scatterChart, waveLine, heatStrip, keyToAction, applyAction, PaneActivity, composeFrame, buildWorkspaceSnapshot };

package/dist/{archymedes-tsne2m7p.mjs → archymedes-twanftqk.mjs}

@@ -7,9 +7,9 @@ import {
   paintAll,
   roleCode,
   visibleWidth
-} from "./archymedes-a10k8yrk.mjs";
+} from "./archymedes-s4qcy0q4.mjs";
 
-// src/render/sections.ts
+// packages/archymedes-cli/src/render/sections.ts
 var TONE_ROLE = {
   good: "success",
   bad: "error",

package/dist/archymedes-w4bjfye7.mjs

@@ -0,0 +1,280 @@
+// packages/core/src/cli/protocol.ts
+import { createHash } from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
+
+// packages/core/src/cli/file-ownership.ts
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+class OwnershipHeldError extends Error {
+  pid;
+  constructor(pid) {
+    super(`Session is already owned by process ${pid}; close or detach the other writer first.`);
+    this.pid = pid;
+  }
+}
+async function processStart(pid) {
+  if (process.platform !== "linux")
+    return;
+  try {
+    const stat = await fs.readFile(`/proc/${pid}/stat`, "utf8");
+    const boot = await fs.readFile("/proc/sys/kernel/random/boot_id", "utf8");
+    return `${boot.trim()}:${stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]}`;
+  } catch {
+    return;
+  }
+}
+async function readOwner(file) {
+  try {
+    const owner = JSON.parse(await fs.readFile(file, "utf8"));
+    if (!owner || typeof owner.token !== "string" || !Number.isSafeInteger(owner.pid) || owner.pid < 1 || typeof owner.host !== "string") {
+      throw new Error(`Invalid ownership record: ${file}`);
+    }
+    return owner;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function isAlive(owner) {
+  if (owner.host !== os.hostname())
+    return true;
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+  const started = await processStart(owner.pid);
+  return !owner.started || !started || owner.started === started;
+}
+async function acquireFileOwnership(file, depth = 0) {
+  if (depth > 8)
+    throw new Error(`Ownership recovery requires inspection: ${file}`);
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const owner = { token: randomUUID(), pid: process.pid, host: os.hostname(), started: await processStart(process.pid) };
+  const candidate = `${file}.${owner.token}.tmp`;
+  const handle = await fs.open(candidate, "wx", 384);
+  try {
+    await handle.writeFile(JSON.stringify(owner));
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    for (let attempt = 0;attempt < 8; attempt++) {
+      try {
+        await fs.link(candidate, file);
+        return async () => {
+          if ((await readOwner(file))?.token === owner.token)
+            await fs.unlink(file);
+        };
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+      const current = await readOwner(file);
+      if (!current)
+        continue;
+      if (await isAlive(current))
+        throw new OwnershipHeldError(current.pid);
+      const release = await acquireFileOwnership(`${file}.reap`, depth + 1);
+      try {
+        if ((await readOwner(file))?.token === current.token)
+          await fs.unlink(file);
+      } finally {
+        await release();
+      }
+    }
+    throw new Error(`Could not acquire session ownership: ${file}`);
+  } finally {
+    await fs.unlink(candidate).catch(() => {
+      return;
+    });
+  }
+}
+
+// packages/core/src/cli/protocol.ts
+var ARCHYMEDES_PROTOCOL_VERSION = 1;
+var JOURNAL_GENESIS_HASH = "0".repeat(64);
+var TRANSITIONS = {
+  queued: ["running", "cancelled", "failed"],
+  running: ["waiting_approval", "completed", "blocked", "needs_verification", "cancelled", "failed", "iteration_limit"],
+  waiting_approval: ["running", "blocked", "cancelled", "failed"],
+  completed: [],
+  blocked: [],
+  needs_verification: [],
+  cancelled: [],
+  failed: [],
+  iteration_limit: []
+};
+function assertTurnTransition(from, to) {
+  if (!TRANSITIONS[from].includes(to))
+    throw new Error(`Illegal Archymedes turn transition: ${from} -> ${to}`);
+}
+var SENSITIVE_KEY = /(authorization|cookie|credential|password|private.?key|secret|token)/i;
+var SECRET_ASSIGNMENT = /((?:[A-Za-z0-9_]*(?:api[_-]?key|access[_-]?key(?:_id)?|authorization|credential|password|passwd|private[_-]?key|secret|token)[A-Za-z0-9_]*)\s*[:=]\s*)([^\s,;]+)/gi;
+var PRIVATE_KEY_BLOCK = /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g;
+var AUTHENTICATED_URL = /([a-z][a-z0-9+.-]*:\/\/)([^/\s:@]+):([^@\s/]+)@/gi;
+function redactJournalString(value) {
+  return value.replace(PRIVATE_KEY_BLOCK, "[REDACTED PRIVATE KEY]").replace(AUTHENTICATED_URL, "$1[REDACTED]@").replace(SECRET_ASSIGNMENT, "$1[REDACTED]");
+}
+function boundedJournalValue(value, key = "") {
+  if (SENSITIVE_KEY.test(key))
+    return "[REDACTED]";
+  if (typeof value === "string") {
+    const redacted = redactJournalString(value);
+    if (redacted.length <= 4000)
+      return redacted;
+    const digest = createHash("sha256").update(value).digest("hex");
+    return `${redacted.slice(0, 4000)}
+...[${redacted.length - 4000} chars omitted; original sha256=${digest}]`;
+  }
+  if (Array.isArray(value))
+    return value.map((item) => boundedJournalValue(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([childKey, item]) => [childKey, boundedJournalValue(item, childKey)]));
+  }
+  return value;
+}
+function runtimeEventForJournal(event) {
+  if (event.type === "tool_call")
+    return { ...event, arguments: boundedJournalValue(event.arguments) };
+  if (event.type === "tool_result") {
+    return {
+      ...event,
+      content: boundedJournalValue(event.content),
+      ...event.data ? { data: boundedJournalValue(event.data) } : {}
+    };
+  }
+  return event;
+}
+function hashEnvelope(envelope) {
+  return createHash("sha256").update(JSON.stringify(envelope)).digest("hex");
+}
+function eventJournalPath(root, sessionId) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(sessionId))
+    throw new Error("Session id contains unsafe characters");
+  return path2.join(root, ".archymedes", "events", `${sessionId}.jsonl`);
+}
+async function readEventJournal(root, sessionId) {
+  return (await readJournalFile(root, sessionId)).events;
+}
+async function readJournalFile(root, sessionId) {
+  const file = eventJournalPath(root, sessionId);
+  let text;
+  try {
+    text = await fs2.readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { events: [], text: "", completeText: "" };
+    throw error;
+  }
+  const completeText = text.endsWith(`
+`) ? text : text.slice(0, text.lastIndexOf(`
+`) + 1);
+  const events = completeText.split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+  let previousHash = JOURNAL_GENESIS_HASH;
+  for (let index = 0;index < events.length; index += 1) {
+    const event = events[index];
+    if (event.protocolVersion !== ARCHYMEDES_PROTOCOL_VERSION)
+      throw new Error(`Unsupported Archymedes protocol version ${event.protocolVersion}`);
+    if (event.sessionId !== sessionId || event.sequence !== index + 1 || event.previousHash !== previousHash) {
+      throw new Error(`Invalid Archymedes event chain at sequence ${event.sequence}`);
+    }
+    const { hash, ...withoutHash } = event;
+    if (hash !== hashEnvelope(withoutHash))
+      throw new Error(`Archymedes event integrity check failed at sequence ${event.sequence}`);
+    previousHash = hash;
+  }
+  return { events, text, completeText };
+}
+
+class EventJournal {
+  root;
+  sessionId;
+  handle = null;
+  releaseOwnership;
+  closed = false;
+  sequence = 0;
+  previousHash = JOURNAL_GENESIS_HASH;
+  initialized = null;
+  tail = Promise.resolve();
+  constructor(root, sessionId) {
+    this.root = root;
+    this.sessionId = sessionId;
+  }
+  async initialize() {
+    this.releaseOwnership = await acquireFileOwnership(`${eventJournalPath(this.root, this.sessionId)}.owner`);
+    try {
+      const { events, text, completeText } = await readJournalFile(this.root, this.sessionId);
+      this.sequence = events.length;
+      this.previousHash = events.at(-1)?.hash ?? JOURNAL_GENESIS_HASH;
+      const file = eventJournalPath(this.root, this.sessionId);
+      await fs2.mkdir(path2.dirname(file), { recursive: true });
+      if (text.length !== completeText.length)
+        await fs2.truncate(file, Buffer.byteLength(completeText, "utf8"));
+      this.handle = await fs2.open(file, "a", 384);
+    } catch (error) {
+      await this.releaseOwnership();
+      this.releaseOwnership = undefined;
+      throw error;
+    }
+  }
+  async open() {
+    if (this.closed)
+      throw new Error("Session journal is closed");
+    this.initialized ??= this.initialize();
+    await this.initialized;
+  }
+  append(payload, options = {}) {
+    if (this.closed)
+      return Promise.reject(new Error("Session journal is closed"));
+    let written;
+    const operation = this.tail.then(async () => {
+      await this.open();
+      const withoutHash = {
+        protocolVersion: ARCHYMEDES_PROTOCOL_VERSION,
+        sequence: this.sequence + 1,
+        sessionId: this.sessionId,
+        timestamp: new Date().toISOString(),
+        previousHash: this.previousHash,
+        payload
+      };
+      written = { ...withoutHash, hash: hashEnvelope(withoutHash) };
+      await this.handle.write(`${JSON.stringify(written)}
+`);
+      if (options.durable)
+        await this.handle.sync();
+      this.sequence = written.sequence;
+      this.previousHash = written.hash;
+    });
+    this.tail = operation;
+    return operation.then(() => written);
+  }
+  async flush() {
+    await this.tail;
+    await this.handle?.sync();
+  }
+  async close() {
+    try {
+      await this.initialized;
+      await this.flush();
+    } finally {
+      this.closed = true;
+      try {
+        await this.handle?.close();
+      } finally {
+        this.handle = null;
+        await this.releaseOwnership?.();
+        this.releaseOwnership = undefined;
+      }
+    }
+  }
+}
+
+export { OwnershipHeldError, acquireFileOwnership, assertTurnTransition, runtimeEventForJournal, eventJournalPath, readEventJournal, EventJournal };

package/dist/{archymedes-dz59nvw7.mjs → archymedes-zvcs68bv.mjs}

@@ -2,18 +2,21 @@ import {
   GUTTER,
   clip,
   panel
-} from "./archymedes-tsne2m7p.mjs";
+} from "./archymedes-twanftqk.mjs";
 import {
   BOLD,
   DIM,
   UNICODE_GLYPHS,
+  codeStyle,
+  highlightSyntax,
+  newSyntaxState,
   paint,
   paintAll,
   roleCode,
   visibleWidth
-} from "./archymedes-a10k8yrk.mjs";
+} from "./archymedes-s4qcy0q4.mjs";
 
-// src/render/code-view.ts
+// packages/archymedes-cli/src/render/code-view.ts
 var MAX_DIFF_CELLS = 250000;
 function diffLines(before, after) {
   const left = before === "" ? [] : before.split(`
@@ -193,7 +196,9 @@ var KEYWORDS = new Set([
   "yield"
 ]);
 var LITERALS = new Set(["true", "false", "null", "nil", "None", "True", "False", "undefined", "self", "this"]);
-function highlightCode(line, depth, palette) {
+function highlightCode(line, depth, palette, language, state) {
+  if (codeStyle().colors === "vscode")
+    return highlightSyntax(line, { depth, palette, ...language ? { language } : {}, ...state ? { state } : {} });
   if (depth === "none")
     return line;
   const commentAt = findCommentStart(line);
@@ -246,11 +251,14 @@ function renderCode(content, style, options = {}) {
   const start = options.startLine ?? 1;
   const numberWidth = String(start + lines.length - 1).length;
   const bodyWidth = Math.max(8, style.width - GUTTER.length - numberWidth - 4);
-  const render = (from, to) => lines.slice(from, to).map((line, index) => {
-    const number = paint(String(start + from + index).padStart(numberWidth), DIM, style.depth);
-    const painted = options.highlight === false ? line : highlightCode(line, style.depth, style.palette);
-    return `${number} ${clip(painted, bodyWidth, glyphs)}`;
-  });
+  const render = (from, to) => {
+    const syntax = newSyntaxState();
+    return lines.slice(from, to).map((line, index) => {
+      const number = paint(String(start + from + index).padStart(numberWidth), DIM, style.depth);
+      const painted = options.highlight === false ? line : highlightCode(line, style.depth, style.palette, options.language, syntax);
+      return `${number} ${clip(painted, bodyWidth, glyphs)}`;
+    });
+  };
   const hidden = Math.max(0, lines.length - maxLines);
   const shown = render(0, hidden > 0 ? maxLines : lines.length);
   return {
@@ -266,12 +274,14 @@ function renderDiff(diff, style, options = {}) {
   const maxLines = options.maxLines ?? 16;
   const condensed = condenseDiff(diff);
   const bodyWidth = Math.max(8, style.width - GUTTER.length - 4);
+  const vscode = codeStyle().colors === "vscode" && style.depth !== "none";
+  const bandWidth = Math.min(bodyWidth, Math.max(0, ...diff.map((line) => [...line.text].length)));
   const row = (line) => {
     if (line.kind === "gap")
       return paint(`${glyphs.middot.repeat(3)} ${line.text}`, DIM, style.depth);
     const mark = line.kind === "add" ? glyphs.plus : line.kind === "remove" ? glyphs.minus : " ";
     const code = line.kind === "add" ? roleCode("success", style.palette, style.depth) : line.kind === "remove" ? roleCode("error", style.palette, style.depth) : DIM;
-    const body = line.kind === "context" ? paint(line.text, DIM, style.depth) : highlightCode(line.text, style.depth, style.palette);
+    const body = line.kind === "context" ? vscode ? highlightCode(line.text, style.depth, style.palette, options.language) : paint(line.text, DIM, style.depth) : vscode ? highlightSyntax(line.text, { depth: style.depth, palette: style.palette, band: line.kind, padTo: bandWidth, ...options.language ? { language: options.language } : {} }) : highlightCode(line.text, style.depth, style.palette);
     return `${paint(mark, code, style.depth)} ${clip(body, bodyWidth, glyphs)}`;
   };
   const rows = condensed.map(row);
@@ -286,7 +296,7 @@ function renderDiff(diff, style, options = {}) {
 }
 function renderFileChange(change, style, options = {}) {
   const language = languageOf(change.path);
-  const block = change.kind === "edit" ? renderDiff(diffLines(change.before ?? "", change.after ?? ""), style, { maxLines: options.maxLines }) : renderCode(change.content ?? "", style, { maxLines: options.maxLines, language });
+  const block = change.kind === "edit" ? renderDiff(diffLines(change.before ?? "", change.after ?? ""), style, { maxLines: options.maxLines, language }) : renderCode(change.content ?? "", style, { maxLines: options.maxLines, language });
   const badge = change.kind === "edit" ? (() => {
     const stat = diffStat(diffLines(change.before ?? "", change.after ?? ""));
     return `+${stat.added} -${stat.removed}`;