flint-agent 1.14.0

package/src/ui/replay.js

@@ -0,0 +1,94 @@
+// The end of a session as it was on screen, shown again when the session is
+// continued (/resume, /load, a restart, --session, --last).
+//
+// Owner, 2026-10-02: after a resume the screen was empty, and the only way to
+// see where the conversation had got to was to ask the agent. The session's
+// chat log has every line exactly as it was shown (answers, ledger lines,
+// receipts), so its last lines are put back. They are for the eyes only: the
+// model's context is the session's saved messages, which a resume restores
+// whether or not anything is shown.
+
+import { readFileSync, existsSync } from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { config } from "../config.js";
+
+/** How many lines of a continued session are shown again. */
+export const RESUME_TAIL_LINES = 80;
+
+const STAMP_RE = /^\[\d\d:\d\d:\d\d\] ?/;
+
+// Lines about the session rather than in it: leaving and loading it, and the
+// start banner a restart prints into the same log. Owner, 2026-10-02: the
+// first resume showed "> exit", "Session saved", "Bye!" and "Loaded
+// session" in the middle of the conversation.
+const HOUSEKEEPING_RE = [
+  /^\s*> (exit|quit)\s*$/,
+  /^\s*> \/\S*(\s.*)?$/,               // slash commands
+  /^Session saved: /,
+  /^Bye!\s*$/,
+  /^\s*Loaded session \S+ \(/,
+  /^\s*\\ \/\s*$/,                     // banner up to 1.13 (the mascot)
+  /FLINT AGENT v\d/,
+  /^\s*▀▀▀ █   ▀ █▄ █ ▀█▀\s*$/,          // banner since 1.14: the FLiNT mark
+  /^\s*█▀▀ █▄▄ █ █ ▀█  █\s+v\d/,
+  /^ (model|session|api|token|mcp):\s/,
+  /^ type \/help for commands/,
+  /^\s*mcp: \S+ (connected \(|-- )/,
+  /^\s*Restarting agent/,
+];
+
+/** A line the operator typed, as the chat log has it ("> text", "api@host > text"). */
+const USER_LINE_RE = /^\s*(\S+@\S+ )?> \S/;
+
+/**
+ * The conversation part of a chat log's lines: housekeeping dropped, runs of
+ * blank lines collapsed to one.
+ */
+export function conversationLines(lines) {
+  const out = [];
+  for (const line of lines) {
+    if (HOUSEKEEPING_RE.some((re) => re.test(line))) continue;
+    if (!line.trim() && (!out.length || !out[out.length - 1].trim())) continue;
+    out.push(line);
+  }
+  while (out.length && !out[out.length - 1].trim()) out.pop();
+  return out;
+}
+
+/**
+ * The last `n` lines of a session's chat log, without their time stamps or
+ * housekeeping, starting at a message the operator typed so the tail does not
+ * open in the middle of an answer. Empty when there is no log.
+ */
+export function chatLogTail(sessionId, n = RESUME_TAIL_LINES, dir = config.sessionsDir) {
+  if (!sessionId || !dir) return [];
+  const file = path.join(dir, `${sessionId}.chat.log`);
+  if (!existsSync(file)) return [];
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  const lines = conversationLines(text.split(/\r?\n/).map((l) => l.replace(STAMP_RE, "")));
+  const tail = lines.slice(-n);
+  // Open at the first message typed within the tail; a tail without one (a
+  // single long answer) is kept as it is.
+  const first = tail.findIndex((l) => USER_LINE_RE.test(l));
+  return first > 0 ? tail.slice(first) : tail;
+}
+
+/**
+ * Show the end of a continued session in the history, between two dim rules.
+ * Returns how many lines were shown.
+ */
+export function replaySessionTail(store, sessionId, n = RESUME_TAIL_LINES, dir = config.sessionsDir) {
+  const tail = chatLogTail(sessionId, n, dir);
+  if (!tail.length) return 0;
+  const add = (t) => store.getState().addLine(t, { replay: true });
+  add(chalk.dim(`  ── the end of session ${sessionId}, as it was (last ${tail.length} lines) ──`));
+  for (const line of tail) add(line);
+  add(chalk.dim("  ── resumed here ──"));
+  return tail.length;
+}

package/src/ui/splash.js

@@ -0,0 +1,49 @@
+import chalk from "chalk";
+import { readFileSync } from "node:fs";
+
+// The FLiNT mark (owner, 2026-10-02), after the designer's wordmark: an F
+// whose top bar stands apart, titanium letters, one yellow spark over the i, the
+// version beside it. It replaced the -[°^°]- mascot. Two text rows of half
+// blocks, so it renders in any monospace font.
+export const MARK = [
+  "▀▀▀ █   ▀ █▄ █ ▀█▀",
+  "█▀▀ █▄▄ █ █ ▀█  █",
+];
+const MARK_ACCENT = [[8], []]; // column of the dot over the i, per row
+
+// 256-colour codes, the same the launcher's loading line uses, so the mark
+// does not change colour between loading and the header: titanium 250,
+// spark yellow 220, grey 244. Yellow, not orange (owner and designer,
+// 2026-10-02): warm orange is Claude Code's colour.
+const SPARK = 220;
+const TITANIUM = 250;
+const DIM = 244;
+
+/** The mark's two rows, coloured; `tail` goes after the second row. */
+export function markLines(tail = "") {
+  return MARK.map((row, r) => {
+    let s = "";
+    for (let i = 0; i < row.length; i++) {
+      s += MARK_ACCENT[r].includes(i) ? chalk.ansi256(SPARK)(row[i]) : chalk.ansi256(TITANIUM)(row[i]);
+    }
+    return " " + s + (r === MARK.length - 1 && tail ? "   " + tail : "");
+  });
+}
+
+export function printSplash(version = "0.0.0", returnString = false) {
+  const lines = markLines(chalk.ansi256(DIM)(`v${version}`));
+  if (returnString) return lines.join("\n");
+  console.log("");
+  for (const l of lines) console.log(l);
+  console.log("");
+}
+
+if (process.argv[1]?.endsWith("splash.js")) {
+  // When run directly (node src/ui/splash.js), read the live version
+  // from package.json — previously hardcoded "0.9.3" which decayed.
+  let version = "0.0.0";
+  try {
+    version = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8")).version;
+  } catch {}
+  printSplash(version);
+}

package/src/ui/status-level.js

@@ -0,0 +1,36 @@
+// The security level, for the status bar.
+//
+// A level that is chosen and then invisible is a level the operator cannot
+// check themselves against. The onboarding question is asked exactly once, so
+// for the whole life of the install the only evidence of which posture Flint is
+// running at is this string — and when something asks that ought not to, the
+// first question is whether the level is set to a stranger value than they
+// think. It is not printed in the output stream (that is the conversation), it
+// is shown in the status bar, which is where the numbers live that get read
+// without being read on purpose.
+
+import { getOnboardingAnswer } from "../tools/permissions.js";
+
+/** The level, for display. Null when nobody has chosen one. */
+export function currentLevel() {
+  return getOnboardingAnswer();
+}
+
+/**
+ * The status-bar fragment naming the level.
+ *
+ * Says "not set" rather than defaulting silently. The spec's default level
+ * applies until the question is answered, and that is the right behaviour to
+ * have — but "the right behaviour" and "the operator chose this" are different
+ * claims, and a status bar that reports a default as if it were a choice is
+ * reporting something it does not know. Before the question is answered this
+ * says so, and the user can go and answer it.
+ *
+ * No chalk, deliberately: the status bar composes its own colouring, and this
+ * is a fragment rather than a line.
+ */
+export function formatStatusLevel() {
+  const level = currentLevel();
+  if (!level) return "care: not set (/allow-all or answer the question to choose)";
+  return `care: ${level}`;
+}

package/src/ui/tool-ledger.js

@@ -0,0 +1,203 @@
+// The tool ledger: one line per tool call in history, and the receipt that
+// closes a turn. Flint's own look (owner, 2026-10-01): a category tag, a verb,
+// the argument, and the measured result right-aligned, like a ledger:
+//
+//   fs   read    docs/guide.md                         24 KB    12ms
+//   sh   run     ping -n 5 127.0.0.1                  exit 0    4.1s
+//   web  search  node lts                              2 KB     0.8s
+//
+//   ── turn 7 · 4 tools · changed fib.js · 6.2s · $0.0000 ──
+
+import chalk from "chalk";
+import stringWidth from "string-width";
+
+// name -> [category, verb]. Anything else falls back by prefix, then "tool".
+const TOOLS = {
+  read_file: ["fs", "read"], write_file: ["fs", "write"], edit_file: ["fs", "edit"],
+  delete_file: ["fs", "delete"], copy_file: ["fs", "copy"], move_file: ["fs", "move"],
+  create_directory: ["fs", "mkdir"], list_directory: ["fs", "list"], glob: ["fs", "glob"],
+  search_in_files: ["fs", "grep"], view_image: ["fs", "view"],
+  run_command: ["sh", "run"], run_background_command: ["sh", "start"],
+  kill_process: ["sh", "kill"], list_processes: ["sh", "ps"], peek_process: ["sh", "peek"],
+  web_search: ["web", "search"], web_fetch: ["web", "fetch"],
+  memory_write: ["mem", "write"], memory_search: ["mem", "search"], memory_get: ["mem", "get"],
+  memory_delete: ["mem", "delete"], memory_expand: ["mem", "expand"],
+  skill_add: ["mem", "skill+"], skill_update: ["mem", "skill"], skill_remove: ["mem", "skill-"],
+  create_plan: ["plan", "create"], update_task: ["plan", "update"], add_task: ["plan", "add"],
+  list_tasks: ["plan", "list"], create_subtask: ["plan", "sub"], add_task_note: ["plan", "note"],
+  link_task_file: ["plan", "link"], list_goals: ["plan", "goals"], focus_goal: ["plan", "focus"],
+  task_stats: ["plan", "stats"], today: ["plan", "today"],
+  spawn_agent: ["agent", "spawn"], ask_agent: ["agent", "ask"], list_agents: ["agent", "list"],
+  wait_tasks: ["agent", "wait"],
+  mesh_search: ["mesh", "search"], mesh_add: ["mesh", "add"], mesh_recent: ["mesh", "recent"],
+};
+
+/** [category, verb] for a tool name. */
+export function toolCategory(name) {
+  const n = String(name || "");
+  if (TOOLS[n]) return TOOLS[n];
+  if (n.startsWith("mcp_") || n.includes("__")) {
+    // mcp_<server>_<tool>: the server is the useful part.
+    const parts = n.replace(/^mcp_/, "").split(/__|_/);
+    return ["mcp", parts[0] || "call"];
+  }
+  if (n.startsWith("desktop_")) return ["desk", n.slice(8)];
+  return ["sys", n.replace(/_/g, " ")];
+}
+
+/** The one argument worth showing, as a single line. */
+export function toolArgument(args) {
+  const a = args && typeof args === "object" ? args : {};
+  const v = a.command ?? a.path ?? a.file_path ?? a.pattern ?? a.query ?? a.url ?? a.content ?? a.name ?? a.goal ?? a.title ?? "";
+  return String(typeof v === "string" ? v : JSON.stringify(v)).replace(/\s+/g, " ").trim();
+}
+
+function bytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(n < 10240 ? 1 : 0)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+
+/** The measured result: exit code, size, error or denial. */
+const lineCount = (t) => (t ? String(t).split("\n").length : 0);
+
+export function toolOutcome(name, result, denied, args = {}) {
+  if (denied) return { text: "denied", bad: true };
+  const s = typeof result === "string" ? result : (result && result._table ? `${result.rows?.length || 0} rows` : String(result ?? ""));
+  if (result && result._table) return { text: s, bad: false };
+  const exit = s.match(/^Error \(exit (\d+)\)/);
+  if (exit) return { text: `exit ${exit[1]}`, bad: true };
+  if (/^Error\b/.test(s)) return { text: "error", bad: true };
+  if (name === "run_command") return { text: "exit 0", bad: false };
+  // A write or an edit is measured by what it put in the file, not by its
+  // one-line reply: "fs write ... 51 B" was the length of "File written:
+  // <path>" for a 7.8 KB document (owner, 2026-10-02).
+  if (name === "write_file" && typeof args?.content === "string") {
+    return { text: bytes(Buffer.byteLength(args.content, "utf8")), bad: false };
+  }
+  if (name === "edit_file" && typeof args?.new_text === "string") {
+    return { text: `-${lineCount(args.old_text)} +${lineCount(args.new_text)}`, bad: false };
+  }
+  // A started background process is named by its id, which /logs and /kill use.
+  const bg = s.match(/^Background process started \(id: (\d+)/);
+  if (bg) return { text: `bg ${bg[1]}`, bad: false };
+  return { text: bytes(Buffer.byteLength(s, "utf8")), bad: false };
+}
+
+export function formatDuration(ms) {
+  if (ms == null || ms < 0) return "";
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const m = Math.floor(ms / 60000);
+  return `${m}m${String(Math.round((ms % 60000) / 1000)).padStart(2, "0")}s`;
+}
+
+function fit(text, width) {
+  if (width <= 0) return "";
+  if (stringWidth(text) <= width) return text + " ".repeat(width - stringWidth(text));
+  let out = "";
+  for (const ch of text) {
+    if (stringWidth(out + ch) > width - 1) break;
+    out += ch;
+  }
+  return out + "…" + " ".repeat(Math.max(0, width - stringWidth(out) - 1));
+}
+
+/** Cut from the middle, so a path keeps its start and its file name. */
+export function fitMiddle(text, width) {
+  const s = String(text);
+  if (width <= 0) return "";
+  if (stringWidth(s) <= width) return s + " ".repeat(width - stringWidth(s));
+  const keepEnd = Math.max(1, Math.floor((width - 1) * 0.6));
+  const keepStart = Math.max(1, width - 1 - keepEnd);
+  const chars = [...s];
+  let head = "";
+  for (const ch of chars) {
+    if (stringWidth(head + ch) > keepStart) break;
+    head += ch;
+  }
+  let tail = "";
+  for (let i = chars.length - 1; i >= 0; i--) {
+    if (stringWidth(chars[i] + tail) > keepEnd) break;
+    tail = chars[i] + tail;
+  }
+  const out = `${head}…${tail}`;
+  return out + " ".repeat(Math.max(0, width - stringWidth(out)));
+}
+
+// The ledger is secondary to the conversation (owner, 2026-10-01): indented,
+// uncoloured, and no wider than 60% of the window, with fixed columns so the
+// result and the time sit in the same place on every line.
+const INDENT = "      ";
+const CAT_COL = 6;
+const VERB_COL = 8;
+const OUT_COL = 9;
+const DUR_COL = 7;
+
+/** The width the ledger and the receipt use: 60% of the window, within reason. */
+export function ledgerWidth(columns = process.stdout.columns || 80) {
+  return Math.min(columns - 1, Math.max(56, Math.floor(columns * 0.6)));
+}
+
+/** One ledger line, dim, left-aligned columns, fixed width. */
+export function ledgerLine({ name, args, result, denied, ms, columns = process.stdout.columns || 80 }) {
+  const [cat, verb] = toolCategory(name);
+  const outcome = toolOutcome(name, result, denied, args);
+  const width = ledgerWidth(columns);
+  const argCol = Math.max(10, width - INDENT.length - CAT_COL - VERB_COL - OUT_COL - DUR_COL - 1);
+  const line = INDENT
+    + fit(cat, CAT_COL)
+    + fit(verb, VERB_COL)
+    + fitMiddle(toolArgument(args), argCol) + " "
+    + fit(outcome.text, OUT_COL)
+    + formatDuration(ms);
+  return chalk.dim(line.trimEnd());
+}
+
+/**
+ * A background process ending, in the same columns as the ledger:
+ *   sh    done    ping -n 180 127.0.0.1             bg 6     3m 2s
+ * `verb` is done, killed or "exit N"; `elapsed` is already formatted.
+ */
+export function processLedgerLine({ verb, cmd, procId, elapsed, columns = process.stdout.columns || 80 }) {
+  const width = ledgerWidth(columns);
+  const argCol = Math.max(10, width - INDENT.length - CAT_COL - VERB_COL - OUT_COL - DUR_COL - 1);
+  const line = INDENT
+    + fit("sh", CAT_COL)
+    + fit(verb, VERB_COL)
+    + fitMiddle(String(cmd || ""), argCol) + " "
+    + fit(`bg ${procId}`, OUT_COL)
+    + String(elapsed || "");
+  return chalk.dim(line.trimEnd());
+}
+
+/**
+ * The line that closes a turn. `files` is the list the agent loop read off the
+ * disk (null when it could not tell), so the receipt never claims more than
+ * that.
+ */
+function tokenCount(n) {
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+}
+
+export function receiptLine({ turn, tools, files, ms, cost, tokensIn, tokensOut, sessionCost, estimated, stopped, columns = process.stdout.columns || 80 }) {
+  const parts = [`turn ${turn}`];
+  parts.push(`${tools} tool${tools === 1 ? "" : "s"}`);
+  if (Array.isArray(files) && files.length) {
+    const names = files.map((f) => String(f).split(/[\\/]/).pop());
+    const shown = names.slice(0, 3).join(", ") + (names.length > 3 ? ` +${names.length - 3}` : "");
+    parts.push(`changed ${shown}`);
+  }
+  if (stopped) parts.push(stopped);
+  // Tokens for the whole turn, every call counted (owner, 2026-10-01: on a
+  // free model the cost is always $0 and the token count is the real figure).
+  if (tokensIn || tokensOut) parts.push(`${tokenCount(tokensIn || 0)} in / ${tokenCount(tokensOut || 0)} out tok`);
+  parts.push(formatDuration(ms));
+  const money = `${estimated ? "~" : ""}$${(cost || 0).toFixed(4)}`;
+  parts.push(sessionCost != null ? `${money} (session $${sessionCost.toFixed(4)})` : money);
+  const body = ` ${parts.join(" · ")} `;
+  const width = ledgerWidth(columns);
+  const left = 2;
+  const right = Math.max(2, width - INDENT.length - left - stringWidth(body));
+  return chalk.dim(INDENT + "─".repeat(left) + body + "─".repeat(right));
+}

package/src/ui/window-title.js

@@ -0,0 +1,150 @@
+// Window title: the one place Flint is visible when the window is not in front.
+//
+// Backlog item 18, owner 2026-09-29 19:02: mid-build the console window title
+// just said "bash", so from another window, from the taskbar or an Alt+Tab list
+// there was no sign of anything running. The owner had to switch back to find
+// out whether Flint had died. The item asks for a spinner in the window title
+// while Flint works, so the entry you can see without focusing the window
+// carries the signal.
+//
+// The same reasoning as the attention bell in prompt-attention.js, extended from
+// "Flint needs you" to "Flint is working". This is the module that owns the
+// spinner; prompt-attention.js still owns the urgent case and reaches for it
+// through hold()/release() so a spinner cannot overwrite a prompt, and so the
+// turn-end cost line at the end of a turn is not wiped by the next tick.
+
+import { defaultSetTitle } from "./prompt-attention.js";
+
+/**
+ * Spinner frames: a gear and a spark, alternating (owner, 2026-10-02). The
+ * title bar is drawn in the system UI font, which has both; the console keeps
+ * braille dots, because several monospace fonts lack these two. The classic
+ * "|/-\" set reads as a blinking cursor at title-bar size, which looks like a
+ * crash.
+ */
+export const TITLE_FRAMES = ["⛭", "✲"];
+
+/**
+ * How often the title changes.
+ *
+ * The owner ruled out 200ms explicitly ("not every 200ms; something a person can
+ * read at a glance"). Faster than roughly a third of a second and the frames are
+ * indistinguishable, so the title bar flickers instead of animating — and a
+ * flicker in a peripheral position reads as noise rather than life. 500ms is
+ * two slow frames a second: readable, and still obviously moving.
+ */
+export const TITLE_INTERVAL_MS = 500;
+
+/** Shown when Flint is up and nothing is happening. */
+export const IDLE_TITLE = "Flint";
+
+/**
+ * Write the title to the terminal.
+ *
+ * Delegated to prompt-attention's defaultSetTitle rather than reimplemented, so
+ * there is exactly one place in Flint that knows how to set a window title. That
+ * function already prefers process.stdout.title where it exists — which on
+ * Windows is what makes the taskbar entry flash — and falls back to the OSC 0
+ * escape on POSIX terminals. A second OSC writer here would have been a second
+ * platform-specific guess at the same thing, and the two would disagree on
+ * Windows.
+ */
+export function writeTitle(title, stream = process.stdout) {
+  if (stream === process.stdout) {
+    defaultSetTitle(title);
+    return;
+  }
+  stream.write(`\x1b]0;${title}\x07`);
+}
+
+/**
+ * Start animating the window title.
+ *
+ * @param {object} [opts]
+ * @param {(title: string) => void} [opts.setTitle] injected for tests
+ * @param {boolean} [opts.isTTY] injected for tests; real runs read the stream
+ * @returns {{isRunning: boolean, hold: (t: string) => void, release: () => void, stop: () => void}}
+ */
+export function startAliveTitle({ setTitle = writeTitle, isTTY = process.stdout.isTTY } = {}) {
+  let frame = 0;
+  let timer = null;
+  let held = null;
+
+  // Not a terminal means no title: in a pipe, a log file or a test, an OSC 0
+  // sequence is a stray control character in captured output, which is worse
+  // than no title at all. Same guard the bell uses.
+  let running = isTTY !== false && typeof setTitle === "function";
+
+  const write = (title) => {
+    if (!running) return;
+    try {
+      setTitle(title);
+    } catch {
+      // A window title is decoration. A terminal that rejects the sequence, or a
+      // sink that throws, must not take the agent loop down with it — and the
+      // animation keeps trying, because the condition may be momentary.
+    }
+  };
+
+  const current = () => `${TITLE_FRAMES[frame]} ${IDLE_TITLE}`;
+
+  const tick = () => {
+    if (held !== null) return;
+    frame = (frame + 1) % TITLE_FRAMES.length;
+    write(current());
+  };
+
+  const begin = () => {
+    if (timer) return;
+    timer = setInterval(tick, TITLE_INTERVAL_MS);
+    timer.unref?.();
+  };
+
+  if (running) {
+    // Set something immediately: an Alt+Tab entry that is only correct after
+    // half a second is an entry that is briefly still wrong.
+    write(current());
+    begin();
+  }
+
+  return {
+    get isRunning() {
+      return running;
+    },
+
+    /**
+     * Show a title the operator has to read instead of the spinner, until
+     * release(). An approval prompt, or the cost line at the end of a turn.
+     */
+    hold(title) {
+      held = typeof title === "string" ? title : null;
+      if (held !== null) write(held);
+    },
+
+    /** Give the held title back to the animation. */
+    release() {
+      if (held === null) return;
+      held = null;
+      if (!running) return;
+      write(current());
+      begin();
+    },
+
+    /**
+     * Stop animating, leaving a title that does not claim to be busy. A stopped
+     * Flint that keeps spinning looks like a hung one.
+     */
+    stop() {
+      if (!running) return;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      // Written while `running` is still true, because write() refuses to emit
+      // once it is false. A stop that leaves the spinner in the title bar is a
+      // stopped Flint that still looks busy — which is what this is avoiding.
+      write(held !== null ? held : IDLE_TITLE);
+      running = false;
+    },
+  };
+}