archymedes-cli 2.2.0 → 2.3.0

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

@@ -1,18 +1,19 @@
 import {
-  CYAN,
-  DIM,
-  GREEN,
   GUTTER,
-  MAGENTA,
-  RED,
   clip,
-  paint
-} from "./archymedes-cdgejs3p.mjs";
+  panel
+} from "./archymedes-tsne2m7p.mjs";
 import {
-  UNICODE_GLYPHS
-} from "./archymedes-5zn4zp84.mjs";
+  BOLD,
+  DIM,
+  UNICODE_GLYPHS,
+  paint,
+  paintAll,
+  roleCode,
+  visibleWidth
+} from "./archymedes-a10k8yrk.mjs";
 
-// packages/archymedes-cli/src/code-view.ts
+// src/render/code-view.ts
 var MAX_DIFF_CELLS = 250000;
 function diffLines(before, after) {
   const left = before === "" ? [] : before.split(`
@@ -57,6 +58,12 @@ function diffLines(before, after) {
   }
   return result;
 }
+function diffStat(diff) {
+  return {
+    added: diff.filter((line) => line.kind === "add").length,
+    removed: diff.filter((line) => line.kind === "remove").length
+  };
+}
 function condenseDiff(diff, context = 2) {
   const keep = new Array(diff.length).fill(false);
   diff.forEach((line, index) => {
@@ -186,7 +193,7 @@ var KEYWORDS = new Set([
   "yield"
 ]);
 var LITERALS = new Set(["true", "false", "null", "nil", "None", "True", "False", "undefined", "self", "this"]);
-function highlightCode(line, depth) {
+function highlightCode(line, depth, palette) {
   if (depth === "none")
     return line;
   const commentAt = findCommentStart(line);
@@ -194,13 +201,13 @@ function highlightCode(line, depth) {
   const comment = commentAt === -1 ? "" : paint(line.slice(commentAt), DIM, depth);
   const painted = code.replace(/("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)|\b(\d+(?:\.\d+)?)\b|\b([A-Za-z_$][\w$]*)\b/g, (whole, text, numeric, word) => {
     if (text !== undefined)
-      return paint(text, GREEN, depth);
+      return paint(text, roleCode("success", palette, depth), depth);
     if (numeric !== undefined)
-      return paint(numeric, MAGENTA, depth);
+      return paint(numeric, roleCode("accent", palette, depth), depth);
     if (word !== undefined && KEYWORDS.has(word))
-      return paint(word, CYAN, depth);
+      return paint(word, roleCode("primary", palette, depth), depth);
     if (word !== undefined && LITERALS.has(word))
-      return paint(word, MAGENTA, depth);
+      return paint(word, roleCode("accent", palette, depth), depth);
     return whole;
   });
   return `${painted}${comment}`;
@@ -241,7 +248,7 @@ function renderCode(content, style, options = {}) {
   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);
+    const painted = options.highlight === false ? line : highlightCode(line, style.depth, style.palette);
     return `${number} ${clip(painted, bodyWidth, glyphs)}`;
   });
   const hidden = Math.max(0, lines.length - maxLines);
@@ -263,8 +270,8 @@ function renderDiff(diff, style, options = {}) {
     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" ? GREEN : line.kind === "remove" ? RED : DIM;
-    const body = line.kind === "context" ? paint(line.text, DIM, style.depth) : highlightCode(line.text, style.depth);
+    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);
     return `${paint(mark, code, style.depth)} ${clip(body, bodyWidth, glyphs)}`;
   };
   const rows = condensed.map(row);
@@ -277,8 +284,32 @@ function renderDiff(diff, style, options = {}) {
 `)
   };
 }
-function describeChange(stat, depth) {
-  return `${paint(`+${stat.added}`, GREEN, depth)} ${paint(`-${stat.removed}`, RED, depth)}`;
+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 badge = change.kind === "edit" ? (() => {
+    const stat = diffStat(diffLines(change.before ?? "", change.after ?? ""));
+    return `+${stat.added} -${stat.removed}`;
+  })() : `${(change.content ?? "").split(`
+`).length} lines · ${language}`;
+  const body = block.text.split(`
+`);
+  const foot = block.hidden > 0 && options.expandHint ? [paint(`${(style.glyphs ?? UNICODE_GLYPHS).collapsed} ${block.hidden} more line${block.hidden === 1 ? "" : "s"} — ${options.expandHint}`, DIM, style.depth)] : [];
+  return {
+    text: panel([...body, ...foot], style, { title: `${change.kind === "edit" ? "diff" : "new file"} · ${change.path}`, badge, tone: change.kind === "edit" ? "accent" : "good" }),
+    hidden: block.hidden,
+    full: panel(block.full.split(`
+`), style, { title: `${change.kind === "edit" ? "diff" : "new file"} · ${change.path}`, badge, tone: change.kind === "edit" ? "accent" : "good" })
+  };
+}
+function fenceHeader(language, style) {
+  const glyphs = style.glyphs ?? UNICODE_GLYPHS;
+  const label = language ? ` ${language} ` : glyphs.boxHorizontal.repeat(4);
+  const width = Math.max(0, style.width - GUTTER.length - visibleWidth(label) - 3);
+  return `${GUTTER}${paint(glyphs.boxTopLeft + glyphs.boxHorizontal, DIM, style.depth)}${paintAll(label, [roleCode("primary", style.palette, style.depth), BOLD], style.depth)}${paint(glyphs.boxHorizontal.repeat(Math.max(0, width)), DIM, style.depth)}`;
+}
+function describeChange(stat, depth, palette) {
+  return `${paint(`+${stat.added}`, roleCode("success", palette, depth), depth)} ${paint(`-${stat.removed}`, roleCode("error", palette, depth), depth)}`;
 }
 
-export { diffLines, languageOf, highlightCode, renderCode, renderDiff, describeChange };
+export { diffLines, diffStat, languageOf, highlightCode, renderCode, renderDiff, renderFileChange, fenceHeader, describeChange };

package/dist/{archymedes-r54qthg5.mjs → archymedes-g8y3rt6t.mjs}

@@ -1,15 +1,20 @@
 import {
+  ANSI_PALETTE,
   ASCII_GLYPHS,
+  BOLD,
+  DIM,
+  ITALIC,
+  STRIKE,
   UNICODE_GLYPHS,
   borderGlyphsFor,
-  newMarkdownState,
+  paint,
   rainbowText,
-  renderMarkdownLine,
   rgbTo256,
+  roleCode,
   visibleWidth
-} from "./archymedes-5zn4zp84.mjs";
+} from "./archymedes-a10k8yrk.mjs";
 
-// packages/archymedes-cli/src/output.ts
+// src/terminal/output.ts
 var terminalStream = {
   write(text) {
     process.stdout.write(text);
@@ -21,17 +26,246 @@ var terminalStream = {
     return process.stdout.rows;
   }
 };
+class OutputRouter {
+  target;
+  constructor(target = terminalStream) {
+    this.target = target;
+  }
+  get current() {
+    return this.target;
+  }
+  route(target) {
+    this.target = target;
+  }
+  write(text) {
+    this.target.write(text);
+  }
+  get columns() {
+    return this.target.columns;
+  }
+  get rows() {
+    return this.target.rows;
+  }
+}
+function replayLines(log, count) {
+  const lines = log.tail(count);
+  return { lines, dropped: log.dropped, omitted: Math.max(0, log.size - lines.length) };
+}
 
-// packages/archymedes-cli/src/tui.ts
-var RESET = "\x1B[0m";
-var DIM = "\x1B[2m";
-var CYAN = "\x1B[36m";
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var RED = "\x1B[31m";
-function paint(text, code, depth) {
-  return depth === "none" ? text : `${code}${text}${RESET}`;
+// src/render/markdown.ts
+var colour = (role, palette) => palette?.[role] || ANSI_PALETTE[role];
+var INLINE_PATTERN = /(?<!\\)(`[^`\n]+`)|(?<!\\)(\*\*[^*\n]+\*\*)|(?<!\\)(__[^_\n]+__)|(?<!\\)(~~[^~\n]+~~)|(?<!\\)(\*[^*\n]+\*)|(?<!\\)(_[^_\n]+_)|(!?\[([^\]\n]+)\]\((https?:\/\/[^\s)\n]+)\))|(<(https?:\/\/[^>\s]+)>)/g;
+var unescapeMarkdown = (text) => text.replace(/\\([\\`*_[\]{}()#+.!~>-])/g, "$1");
+function parseInline(line, palette) {
+  const tokens = [];
+  let lastIndex = 0;
+  INLINE_PATTERN.lastIndex = 0;
+  for (let match = INLINE_PATTERN.exec(line);match !== null; match = INLINE_PATTERN.exec(line)) {
+    if (match.index > lastIndex)
+      tokens.push({ text: unescapeMarkdown(line.slice(lastIndex, match.index)), code: "" });
+    const [whole, code, boldStars, boldUnderscores, strike, italicStars, italicUnderscores, link, linkLabel, linkUrl, autolink, autolinkUrl] = match;
+    if (code !== undefined)
+      tokens.push({ text: code.slice(1, -1), code: colour("primary", palette) });
+    else if (boldStars !== undefined)
+      tokens.push({ text: boldStars.slice(2, -2), code: BOLD });
+    else if (boldUnderscores !== undefined)
+      tokens.push({ text: boldUnderscores.slice(2, -2), code: BOLD });
+    else if (strike !== undefined)
+      tokens.push({ text: strike.slice(2, -2), code: STRIKE });
+    else if (italicStars !== undefined)
+      tokens.push({ text: italicStars.slice(1, -1), code: ITALIC });
+    else if (italicUnderscores !== undefined)
+      tokens.push({ text: italicUnderscores.slice(1, -1), code: ITALIC });
+    else if (link !== undefined)
+      tokens.push({ text: `${link.startsWith("!") ? `image: ${linkLabel}` : linkLabel} (${linkUrl})`, code: colour("primary", palette) });
+    else if (autolink !== undefined)
+      tokens.push({ text: autolinkUrl, code: colour("primary", palette) });
+    lastIndex = match.index + whole.length;
+  }
+  if (lastIndex < line.length)
+    tokens.push({ text: unescapeMarkdown(line.slice(lastIndex)), code: "" });
+  return tokens.filter((token) => token.text.length > 0);
+}
+function wrapTokens(tokens, width, options) {
+  const firstPrefix = options.firstPrefix ?? "";
+  const continuationPrefix = options.continuationPrefix ?? "";
+  const lines = [];
+  let current = "";
+  let currentWidth = 0;
+  let prefix = firstPrefix;
+  let prefixWidth = visibleWidth(firstPrefix);
+  const limit = Math.max(1, width);
+  const flush = () => {
+    lines.push(`${prefix}${current}`.replace(/[ \t]+$/, ""));
+    current = "";
+    currentWidth = 0;
+    prefix = continuationPrefix;
+    prefixWidth = visibleWidth(continuationPrefix);
+  };
+  for (const token of tokens) {
+    for (const word of token.text.split(/(\s+)/)) {
+      if (word === "")
+        continue;
+      const wordWidth = visibleWidth(word);
+      if (/^\s+$/.test(word)) {
+        if (currentWidth > 0 && prefixWidth + currentWidth + wordWidth <= limit) {
+          current += word;
+          currentWidth += wordWidth;
+        }
+        continue;
+      }
+      if (currentWidth > 0 && prefixWidth + currentWidth + wordWidth > limit)
+        flush();
+      if (prefixWidth + wordWidth > limit) {
+        let remaining = word;
+        while (remaining.length > 0) {
+          const available = Math.max(1, limit - prefixWidth - currentWidth);
+          if (visibleWidth(remaining) <= available)
+            break;
+          const head = [...remaining].slice(0, available).join("");
+          current += paint(head, token.code, options.depth);
+          remaining = [...remaining].slice(available).join("");
+          flush();
+        }
+        if (remaining.length > 0) {
+          current += paint(remaining, token.code, options.depth);
+          currentWidth += visibleWidth(remaining);
+        }
+        continue;
+      }
+      current += paint(word, token.code, options.depth);
+      currentWidth += wordWidth;
+    }
+  }
+  if (current !== "" || lines.length === 0)
+    lines.push(`${prefix}${current}`.replace(/[ \t]+$/, ""));
+  return lines;
+}
+function newMarkdownState() {
+  return { inFence: false, fenceLanguage: "" };
 }
+var HEADING = /^(#{1,6})\s+(.*)$/;
+var BULLET = /^(\s*)([-*+])\s+(.*)$/;
+var TASK = /^(\s*)[-*+]\s+\[([ xX])\]\s+(.*)$/;
+var NUMBERED = /^(\s*)(\d+[.)])\s+(.*)$/;
+var BLOCKQUOTE = /^>\s?(.*)$/;
+var RULE = /^\s*([-*_])\s*(?:\1\s*){2,}$/;
+var FENCE = /^\s*```(.*)$/;
+var TABLE_SEPARATOR_CELL = /^:?-{3,}:?$/;
+function tableCells(line) {
+  if (!line.includes("|"))
+    return null;
+  const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+  const cells = trimmed.split("|").map((cell) => cell.trim());
+  return cells.length >= 2 ? cells : null;
+}
+function fitCell(text, width, glyphs = UNICODE_GLYPHS) {
+  let result = "";
+  for (const character of text) {
+    if (visibleWidth(result + character) > width) {
+      while (visibleWidth(result) > Math.max(0, width - visibleWidth(glyphs.ellipsis)))
+        result = [...result].slice(0, -1).join("");
+      result += glyphs.ellipsis;
+      return result + " ".repeat(Math.max(0, width - visibleWidth(result)));
+    }
+    result += character;
+  }
+  return result + " ".repeat(Math.max(0, width - visibleWidth(result)));
+}
+function renderTableLine(cells, separator, width, depth, glyphs) {
+  const cellWidth = Math.max(3, Math.floor((Math.max(width, 12) - cells.length - 1) / cells.length));
+  if (separator)
+    return paint(`${glyphs.boxTeeLeft}${cells.map(() => glyphs.boxHorizontal.repeat(cellWidth)).join(glyphs.boxCross)}${glyphs.boxTeeRight}`, DIM, depth);
+  const contentWidth = Math.max(1, cellWidth - 2);
+  const rendered = cells.map((cell) => fitCell(parseInline(cell).map((token) => token.text).join(""), contentWidth, glyphs));
+  return `${glyphs.boxVertical}${rendered.map((cell) => ` ${cell} `).join(glyphs.boxVertical)}${glyphs.boxVertical}`;
+}
+function renderMarkdownLine(line, state, options) {
+  const { width, depth, palette } = options;
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const fence = FENCE.exec(line);
+  if (fence) {
+    const ruleWidth = Math.max(4, Math.min(width - 4, 40));
+    if (state.inFence) {
+      state.inFence = false;
+      state.fenceLanguage = "";
+      return [paint(`  ${glyphs.boxBottomLeft}${glyphs.boxHorizontal.repeat(ruleWidth)}`, DIM, depth)];
+    }
+    state.inFence = true;
+    state.fenceLanguage = fence[1].trim();
+    const label = state.fenceLanguage ? ` ${state.fenceLanguage} ` : "";
+    const drawn = 1 + visibleWidth(label);
+    return [paint(`  ${glyphs.boxTopLeft}${glyphs.boxHorizontal}${label}${glyphs.boxHorizontal.repeat(Math.max(0, ruleWidth - drawn))}`, DIM, depth)];
+  }
+  if (state.inFence) {
+    return [`${paint(`  ${glyphs.boxVertical} `, DIM, depth)}${paint(line, colour("success", palette), depth)}`];
+  }
+  const table = tableCells(line);
+  if (table) {
+    const separator = table.every((cell) => TABLE_SEPARATOR_CELL.test(cell));
+    return [renderTableLine(table, separator, width, depth, glyphs)];
+  }
+  if (RULE.test(line) && line.trim().length > 0) {
+    return [paint("  " + glyphs.boxHorizontal.repeat(Math.max(4, Math.min(width - 4, 40))), DIM, depth)];
+  }
+  const heading = HEADING.exec(line);
+  if (heading) {
+    const level = heading[1].length;
+    const code = level <= 2 ? `${BOLD}${colour("primary", palette)}` : BOLD;
+    const tokens = parseInline(heading[2]).map((token) => ({ text: token.text, code }));
+    return wrapTokens(tokens, width, { depth });
+  }
+  const task = TASK.exec(line);
+  if (task) {
+    return wrapTokens(parseInline(task[3], palette), width, {
+      firstPrefix: `${task[1]}${paint(task[2].trim() ? glyphs.checkboxDone : glyphs.checkbox, task[2].trim() ? colour("success", palette) : colour("secondary", palette), depth)} `,
+      continuationPrefix: `${task[1]}  `,
+      depth
+    });
+  }
+  const bullet = BULLET.exec(line);
+  if (bullet) {
+    const indent = bullet[1];
+    return wrapTokens(parseInline(bullet[3], palette), width, {
+      firstPrefix: `${indent}${paint(glyphs.bullet, colour("secondary", palette), depth)} `,
+      continuationPrefix: `${indent}  `,
+      depth
+    });
+  }
+  const numbered = NUMBERED.exec(line);
+  if (numbered) {
+    const indent = numbered[1];
+    const marker = numbered[2];
+    return wrapTokens(parseInline(numbered[3], palette), width, {
+      firstPrefix: `${indent}${paint(marker, colour("secondary", palette), depth)} `,
+      continuationPrefix: `${indent}${" ".repeat(marker.length + 1)}`,
+      depth
+    });
+  }
+  const quote = BLOCKQUOTE.exec(line);
+  if (quote) {
+    return wrapTokens([{ text: quote[1], code: DIM }], width, {
+      firstPrefix: paint(`${glyphs.boxVertical} `, colour("accent", palette), depth),
+      continuationPrefix: paint(`${glyphs.boxVertical} `, colour("accent", palette), depth),
+      depth
+    });
+  }
+  if (line.trim() === "")
+    return [""];
+  return wrapTokens(parseInline(line, palette), width, { depth });
+}
+function renderMarkdown(text, options) {
+  const state = newMarkdownState();
+  const glyphs = options.glyphs ?? UNICODE_GLYPHS;
+  const rendered = text.split(`
+`).flatMap((line) => renderMarkdownLine(line, state, options));
+  if (state.inFence)
+    rendered.push(paint(`  ${glyphs.boxBottomLeft}${glyphs.boxHorizontal.repeat(4)}`, DIM, options.depth));
+  return rendered.join(`
+`);
+}
+
+// src/render/tui.ts
 function archymedesSpinnerFrame(index, glyphs = UNICODE_GLYPHS) {
   const frames = glyphs.spinnerFrames;
   const normalized = Number.isFinite(index) ? Math.max(0, Math.floor(index)) : 0;
@@ -279,7 +513,7 @@ function stepProgress(done, total, options) {
   });
   return `${label}${counted} ${bar}`;
 }
-function formatStatusLine(fields, width, depth, glyphs = UNICODE_GLYPHS, accent = CYAN) {
+function formatStatusLine(fields, width, depth, glyphs = UNICODE_GLYPHS, accent = ANSI_PALETTE.primary) {
   const label = activityLabel(fields.phase ?? "thinking", fields.operation, fields.elapsedMs);
   const ellipsis = glyphs.ellipsis;
   const separator = ` ${glyphs.middot} `;
@@ -313,27 +547,115 @@ function formatStatusLine(fields, width, depth, glyphs = UNICODE_GLYPHS, accent
     kept = kept.slice(0, -1);
   }
 }
+
+class StatusBar {
+  stream;
+  linesDrawn = 0;
+  constructor(stream = terminalStream) {
+    this.stream = stream;
+  }
+  render(fields, depth, glyphs = UNICODE_GLYPHS, accent) {
+    this.clear();
+    const width = this.stream.columns ?? 80;
+    const line = formatStatusLine(fields, width, depth, glyphs, accent);
+    this.stream.write(`${line}
+`);
+    this.linesDrawn = 1;
+  }
+  renderLine(text) {
+    this.clear();
+    if (text === "")
+      return;
+    this.stream.write(`${text}
+`);
+    this.linesDrawn = 1;
+  }
+  clear() {
+    if (this.linesDrawn === 0)
+      return;
+    for (let index = 0;index < this.linesDrawn; index += 1) {
+      this.stream.write("\x1B[1A\x1B[2K");
+    }
+    this.linesDrawn = 0;
+  }
+}
 function rowsOccupied(text, columns) {
   const width = visibleWidth(text);
   if (width === 0)
     return 1;
   return Math.ceil(width / Math.max(1, columns));
 }
+
+class ReplaceableBlock {
+  stream;
+  columns;
+  entries = [];
+  rows = 0;
+  constructor(stream = terminalStream, columns = () => process.stdout.columns ?? 80) {
+    this.stream = stream;
+    this.columns = columns;
+  }
+  append(text) {
+    this.entries.push(text);
+    this.stream.write(`${text}
+`);
+    this.rows += rowsOccupied(text, this.columns());
+    return this.entries.length - 1;
+  }
+  update(index, text) {
+    if (index < 0 || index >= this.entries.length)
+      return false;
+    this.entries[index] = text;
+    for (let row = 0;row < this.rows; row += 1)
+      this.stream.write("\x1B[1A\x1B[2K");
+    this.stream.write("\r");
+    this.rows = 0;
+    for (const entry of this.entries) {
+      this.stream.write(`${entry}
+`);
+      this.rows += rowsOccupied(entry, this.columns());
+    }
+    return true;
+  }
+  updateAll(texts) {
+    for (let row = 0;row < this.rows; row += 1)
+      this.stream.write("\x1B[1A\x1B[2K");
+    this.stream.write("\r");
+    for (let index = 0;index < texts.length && index < this.entries.length; index += 1)
+      this.entries[index] = texts[index];
+    this.rows = 0;
+    for (const entry of this.entries) {
+      this.stream.write(`${entry}
+`);
+      this.rows += rowsOccupied(entry, this.columns());
+    }
+  }
+  forget() {
+    this.entries = [];
+    this.rows = 0;
+  }
+  get active() {
+    return this.entries.length > 0;
+  }
+}
+
 class MarkdownStream {
   stream;
   depth;
   columns;
   live;
   glyphs;
+  palette;
   pending = "";
   atLineStart = true;
   state = newMarkdownState();
-  constructor(stream = terminalStream, depth = "none", columns = () => process.stdout.columns ?? 80, live = true, glyphs = UNICODE_GLYPHS) {
+  constructor(stream = terminalStream, depth = "none", columns = () => process.stdout.columns ?? 80, live = true, glyphs = UNICODE_GLYPHS, palette) {
     this.stream = stream;
     this.depth = depth;
     this.columns = columns;
     this.live = live;
     this.glyphs = glyphs;
+    this.palette = palette;
   }
   get active() {
     return this.live ? this.pending !== "" : !this.atLineStart;
@@ -370,7 +692,7 @@ class MarkdownStream {
     if (this.pending !== "")
       this.finalizeLine();
     if (this.state.inFence) {
-      const rendered = renderMarkdownLine("```", this.state, { width: this.columns(), depth: this.depth, glyphs: this.glyphs });
+      const rendered = renderMarkdownLine("```", this.state, { width: this.columns(), depth: this.depth, glyphs: this.glyphs, palette: this.palette });
       this.stream.write(`${rendered.join(`
 `)}
 `);
@@ -383,7 +705,7 @@ class MarkdownStream {
   }
   finalizeLine() {
     this.erasePending();
-    const rendered = renderMarkdownLine(this.pending, this.state, { width: this.columns(), depth: this.depth, glyphs: this.glyphs });
+    const rendered = renderMarkdownLine(this.pending, this.state, { width: this.columns(), depth: this.depth, glyphs: this.glyphs, palette: this.palette });
     this.stream.write(`${rendered.join(`
 `)}
 `);
@@ -401,14 +723,14 @@ class MarkdownStream {
 function box(lines, options) {
   const terminalWidth = options.width ?? process.stdout.columns ?? 80;
   const glyphs = options.glyphs ?? UNICODE_GLYPHS;
-  const border = borderGlyphsFor(options.borderStyle ?? "round", glyphs);
+  const border = borderGlyphsFor(options.borderStyle ?? options.palette?.borderStyle ?? "round", glyphs);
   const titleWidth = options.title ? visibleWidth(options.title) : 0;
-  const titlePaint = TONE_CODES[options.titleColor ?? "cyan"];
+  const titlePaint = roleCode(TONE_ROLE[options.titleColor ?? "cyan"], options.palette, options.depth);
   const rainbowBorder = options.borderColor === "rainbow";
   const edge = (text, phase = 0) => {
     if (options.borderColor === undefined)
       return text;
-    return rainbowBorder ? rainbowText(text, options.depth, phase) : paint(text, TONE_CODES[options.borderColor], options.depth);
+    return rainbowBorder ? rainbowText(text, options.depth, phase) : paint(text, roleCode(TONE_ROLE[options.borderColor], options.palette, options.depth), options.depth);
   };
   const contentWidth = Math.min(Math.max(titleWidth, ...lines.map((line) => visibleWidth(line)), 1), Math.max(1, terminalWidth - 4));
   const horizontal = border.horizontal.repeat(contentWidth + 2);
@@ -454,16 +776,16 @@ function joinHorizontal(left, right, options) {
   const separator = options.separator ?? " ";
   return `${padToWidth(left, options.leftWidth, options.leftAlign)}${separator}${padToWidth(right, options.rightWidth, options.rightAlign)}`;
 }
-var TONE_CODES = { cyan: CYAN, green: GREEN, yellow: YELLOW, red: RED };
-var MODE_COLORS = { plan: YELLOW, auto: GREEN, build: CYAN, defender: RED };
+var TONE_ROLE = { cyan: "primary", green: "success", yellow: "warning", red: "error" };
+var MODE_ROLE = { plan: "warning", auto: "success", build: "primary", defender: "error" };
 var PROMPT_CHROME_COLUMNS = 6;
 function renderPromptBox(options) {
   const { mode, workspace, depth } = options;
   const glyphs = options.glyphs ?? UNICODE_GLYPHS;
   const border = borderGlyphsFor(options.palette?.borderStyle ?? options.borderStyle ?? "round", glyphs);
   const width = Math.max(12, options.width);
-  const primary = options.palette?.primary ?? CYAN;
-  const modeColor = options.palette ? { plan: options.palette.warning, auto: options.palette.success, build: primary, defender: options.palette.error }[mode] ?? primary : MODE_COLORS[mode] ?? CYAN;
+  const primary = roleCode("primary", options.palette, depth);
+  const modeColor = roleCode(MODE_ROLE[mode] ?? "primary", options.palette, depth);
   const horizontal = (count) => paint(border.horizontal.repeat(Math.max(0, count)), primary, depth);
   const CHROME = PROMPT_CHROME_COLUMNS;
   const status = options.status ?? "";
@@ -491,5 +813,34 @@ function renderPromptBox(options) {
   const bottom = `${paint(border.bottomLeft, primary, depth)}${horizontal(width - 2)}${paint(border.bottomRight, primary, depth)}`;
   return { top, prefix, bottom };
 }
+function wrapPlain(text, width) {
+  const lines = [];
+  let current = "";
+  for (const word of text.split(/\s+/)) {
+    if (word === "")
+      continue;
+    const candidate = current === "" ? word : `${current} ${word}`;
+    if (visibleWidth(candidate) <= width) {
+      current = candidate;
+      continue;
+    }
+    if (current !== "")
+      lines.push(current);
+    if (visibleWidth(word) > width) {
+      let rest = word;
+      while (visibleWidth(rest) > width) {
+        const chunk = sliceToWidth(rest, width);
+        lines.push(chunk);
+        rest = rest.slice(chunk.length);
+      }
+      current = rest;
+    } else {
+      current = word;
+    }
+  }
+  if (current !== "")
+    lines.push(current);
+  return lines.length === 0 ? [""] : lines;
+}
 
-export { terminalStream, archymedesSpinnerFrame, SpringAnimator, sparkline, progressBar, table, scrollPercent, scrollIndicator, paginator, stepProgress, formatStatusLine, rowsOccupied, box, sliceToWidth, padToWidth, joinHorizontal, renderPromptBox };
+export { terminalStream, OutputRouter, replayLines, newMarkdownState, renderMarkdownLine, renderMarkdown, archymedesSpinnerFrame, SpringAnimator, sparkline, progressBar, table, scrollPercent, scrollIndicator, paginator, stepProgress, formatStatusLine, StatusBar, rowsOccupied, ReplaceableBlock, MarkdownStream, box, sliceToWidth, padToWidth, joinHorizontal, renderPromptBox, wrapPlain };

package/dist/{archymedes-1g1y6q74.mjs → archymedes-h13ap0za.mjs}

@@ -1,4 +1,4 @@
-// packages/core/src/sandbox-policy.ts
+// ../core/src/sandbox-policy.ts
 var ALLOWED_SANDBOX_PROGRAMS = [
   "bun",
   "npm",