flint-agent 1.14.0

package/src/store/session-slice.js

@@ -0,0 +1,191 @@
+// Session slice: messages, sessionId, cost, tokens, model, provider, inputHistory, profile, plan
+
+import { resetSessionSpend } from "../agent/usage.js";
+import { resetVision, setModelSeesImages } from "../agent/vision.js";
+
+/**
+ * Rough size of a conversation in tokens (4 characters a token), for the
+ * context counter before the model has answered once. A loaded session used
+ * to show no context at all until the next reply (owner, 2026-10-02).
+ */
+export function estimateContextTokens(messages) {
+  let chars = 0;
+  for (const m of messages || []) {
+    if (typeof m?.content === "string") chars += m.content.length;
+    else if (m?.content != null) chars += JSON.stringify(m.content).length;
+    if (m?.tool_calls) chars += JSON.stringify(m.tool_calls).length;
+  }
+  return Math.ceil(chars / 4);
+}
+
+function mergeSource(bySource, source, entry) {
+  const prev = bySource[source] || {
+    calls: 0, promptTokens: 0, completionTokens: 0,
+    cachedTokens: 0, cacheWriteTokens: 0, cost: 0, estimated: false,
+  };
+  return {
+    ...bySource,
+    [source]: {
+      calls: prev.calls + (entry.calls || 0),
+      promptTokens: prev.promptTokens + (entry.promptTokens || 0),
+      completionTokens: prev.completionTokens + (entry.completionTokens || 0),
+      cachedTokens: prev.cachedTokens + (entry.cachedTokens || 0),
+      cacheWriteTokens: prev.cacheWriteTokens + (entry.cacheWriteTokens || 0),
+      cost: prev.cost + (entry.cost || 0),
+      estimated: prev.estimated || !!entry.estimated,
+    },
+  };
+}
+
+export const createSessionSlice = (set, get) => ({
+  sessionId: null,
+  messages: [],
+  model: null,
+  provider: null,
+  pricing: null,
+  contextLimit: null,
+  sessionCost: 0,
+  sessionPromptTokens: 0,
+  sessionCompletionTokens: 0,
+  // What the number is made of. sessionCost is the real charge when the
+  // provider reports one; sessionCostEstimated says when any part of it is a
+  // guess. Cached tokens are a subset of sessionPromptTokens.
+  sessionCachedTokens: 0,
+  sessionCacheWriteTokens: 0,
+  sessionCostEstimated: false,
+  // Per caller, so "what is even counted here" has an answer on screen:
+  // the main loop, the intent classifier, the judge, the reflection extractor.
+  sessionUsageBySource: {},
+  lastContextTokens: 0,
+  inputHistory: [],
+  profile: null,
+  lastSummary: null,
+  plan: null,
+  pastedImages: [],
+  userMessageCount: 0,
+
+  setSession(sessionId, messages, inputHistory) {
+    const userCount = messages ? messages.filter((m) => m.role === "user").length : 0;
+    // The ledger follows the session. Seven places clear the session; wiring
+    // each of them to also clear the ledger is how the two drift apart, and a
+    // session ceiling enforced against a stale total is worse than none.
+    resetSessionSpend();
+    set({
+      sessionId,
+      messages,
+      inputHistory: inputHistory || [],
+      userMessageCount: userCount,
+      // An estimate until the model answers and reports the real size.
+      lastContextTokens: (messages?.length || 0) > 1 ? estimateContextTokens(messages) : 0,
+      contextEstimated: (messages?.length || 0) > 1,
+      sessionCost: 0,
+      sessionPromptTokens: 0,
+      sessionCompletionTokens: 0,
+      sessionCachedTokens: 0,
+      sessionCacheWriteTokens: 0,
+      sessionCostEstimated: false,
+      sessionUsageBySource: {},
+    });
+  },
+
+  setModel(model) {
+    // What was learned about the old model's eyes says nothing about the new
+    // one. Every model switch passes here, and the provider's answer for the
+    // new model arrives through setPricing.
+    if (get().model !== model) resetVision();
+    set({ model });
+  },
+
+  setProvider(providerId) {
+    set({ provider: providerId });
+  },
+
+  setPricing(pricing) {
+    if (pricing && pricing.seesImages != null) setModelSeesImages(pricing.seesImages, "provider-metadata");
+    set({
+      pricing,
+      contextLimit: pricing?.contextLength || null,
+    });
+  },
+
+  pushMessage(msg) {
+    const s = get();
+    const newMessages = [...s.messages, msg];
+    const update = { messages: newMessages };
+    if (msg.role === "user") update.userMessageCount = s.userMessageCount + 1;
+    set(update);
+  },
+
+  /**
+   * Fold one drained ledger into the session totals, for display.
+   *
+   * There used to be two of these: addUsage(stats, cost) for the main loop and
+   * addSideUsage(bySource) for everything else, each with its own idea of what
+   * a call cost. The main loop is a source like any other now, so there is one
+   * way in.
+   *
+   * @param {object} bySource - map of source -> usage entry, from drainUsage()
+   */
+  addUsage(bySource) {
+    const s = get();
+    let promptTokens = 0, completionTokens = 0, cached = 0, cacheWrite = 0, cost = 0, estimated = false;
+    let merged = s.sessionUsageBySource;
+    for (const [source, entry] of Object.entries(bySource || {})) {
+      if (!entry || !entry.calls) continue;
+      promptTokens += entry.promptTokens || 0;
+      completionTokens += entry.completionTokens || 0;
+      cached += entry.cachedTokens || 0;
+      cacheWrite += entry.cacheWriteTokens || 0;
+      cost += entry.cost || 0;
+      if (entry.estimated) estimated = true;
+      merged = mergeSource(merged, source, entry);
+    }
+    if (merged === s.sessionUsageBySource) return;
+    set({
+      sessionPromptTokens: s.sessionPromptTokens + promptTokens,
+      sessionCompletionTokens: s.sessionCompletionTokens + completionTokens,
+      sessionCachedTokens: s.sessionCachedTokens + cached,
+      sessionCacheWriteTokens: s.sessionCacheWriteTokens + cacheWrite,
+      sessionCost: s.sessionCost + cost,
+      sessionCostEstimated: s.sessionCostEstimated || estimated,
+      sessionUsageBySource: merged,
+    });
+  },
+
+  pushInputHistory(input) {
+    const { inputHistory } = get();
+    set({ inputHistory: [...inputHistory, input] });
+  },
+
+  resetSession(sessionId, messages) {
+    resetSessionSpend();
+    set({
+      sessionId,
+      messages,
+      sessionCost: 0,
+      sessionPromptTokens: 0,
+      sessionCompletionTokens: 0,
+      sessionCachedTokens: 0,
+      sessionCacheWriteTokens: 0,
+      sessionCostEstimated: false,
+      sessionUsageBySource: {},
+      lastContextTokens: 0,
+      userMessageCount: 0,
+      plan: null,
+      lastSummary: null,
+      pastedImages: [],
+    });
+  },
+
+  setProfile(profile) {
+    set({ profile });
+  },
+
+  setPlan(plan) {
+    set({ plan });
+  },
+
+  setLastSummary(lastSummary) {
+    set({ lastSummary });
+  },
+});

package/src/store/ui-slice.js

@@ -0,0 +1,119 @@
+// UI slice: lines[], streamText, activeTab
+import { config } from "../config.js";
+import { createLogger } from "../logging/logger.js";
+
+const log = createLogger("ui-slice");
+
+export const createUiSlice = (set, get) => ({
+  lines: [],       // [{id, text}]
+  nextLineId: 1,
+  streamText: "",
+  processStreams: {},  // procId → text, one updating line per background process
+  activeTab: "chat", // "chat" | "toollog" | "processes" | "system"
+  headerPrinted: false, // guard: prevent duplicate header on tab-cycle
+
+  setActiveTab(tab) {
+    set({ activeTab: tab });
+  },
+
+  /**
+   * One history line. `replay: true` marks a line shown again from the
+   * session's chat log (ui/replay.js); the chat log follower skips it, so the
+   * log does not get its own lines a second time.
+   */
+  addLine(text, opts = {}) {
+    const { nextLineId, lines } = get();
+    const maxLines = config.maxDisplayLines || 1000;
+    const item = { id: nextLineId, text: String(text) || " " };
+    if (opts.replay) item.replay = true;
+    const updated = [...lines, item];
+    log.debug("addLine", { id: nextLineId, totalLines: updated.length, textLen: (text || "").length });
+    set({
+      lines: updated.length > maxLines ? updated.slice(-maxLines) : updated,
+      nextLineId: nextLineId + 1,
+    });
+  },
+
+  addTable({ columns, rows, title, footer }) {
+    const { nextLineId, lines } = get();
+    const maxLines = config.maxDisplayLines || 1000;
+    const item = { id: nextLineId, type: "table", columns, rows, title, footer };
+    const updated = [...lines, item];
+    set({
+      lines: updated.length > maxLines ? updated.slice(-maxLines) : updated,
+      nextLineId: nextLineId + 1,
+    });
+  },
+
+  // Messages the operator typed while the agent worked and it has not read
+  // yet: shown above the input, moved into the history when read (owner,
+  // 2026-10-01: printed lines cannot be marked read afterwards).
+  queuedInputs: [], // [{ id: busId, display }]
+  addQueuedInput(entry) {
+    set({ queuedInputs: [...get().queuedInputs, entry] });
+  },
+  /** Remove and return the entry for a bus message, or null. */
+  takeQueuedInput(id) {
+    const list = get().queuedInputs;
+    const entry = list.find((q) => q.id === id) || null;
+    if (entry) set({ queuedInputs: list.filter((q) => q !== entry) });
+    return entry;
+  },
+  clearQueuedInputs() {
+    set({ queuedInputs: [] });
+  },
+
+  setStreamText(text) {
+    log.debug("setStreamText", { len: (text || "").length, empty: !text });
+    set({ streamText: text });
+  },
+
+  setProcessStream(procId, text) {
+    const streams = { ...get().processStreams };
+    if (text) {
+      streams[procId] = text;
+    } else {
+      delete streams[procId];
+    }
+    set({ processStreams: streams });
+  },
+
+  // Overlay menu state
+  overlay: null,        // null | { type: "provider" | "model", title, items, index, parent }
+  openOverlay(type, title, items) {
+    set({ overlay: { type, title, items, index: 0, parent: null, loading: false, sortMode: "name" } });
+  },
+  overlayDrilldown(type, title, items, parent) {
+    set({ overlay: { type, title, items, index: 0, parent, loading: false, sortMode: "name" } });
+  },
+  overlayCycleSort() {
+    const o = get().overlay;
+    if (!o) return;
+    const modes = ["name", "price", "context"];
+    const next = modes[(modes.indexOf(o.sortMode || "name") + 1) % modes.length];
+    set({ overlay: { ...o, sortMode: next, index: 0 } });
+  },
+  overlaySetIndex(index) {
+    const o = get().overlay;
+    if (o) set({ overlay: { ...o, index } });
+  },
+  overlaySetLoading(loading) {
+    const o = get().overlay;
+    if (o) set({ overlay: { ...o, loading } });
+  },
+  closeOverlay() {
+    set({ overlay: null });
+  },
+
+  clearCounter: 0,
+
+  clearScreen() {
+    const { clearCounter, _inkClear } = get();
+    // 1. ANSI: clear scrollback + visible screen + move cursor home
+    process.stdout.write("\x1b[3J\x1b[2J\x1b[H");
+    // 2. Ink: reset internal output tracking so it doesn't re-render old Static lines
+    if (_inkClear) _inkClear();
+    // 3. Reset lines array so Static starts fresh
+    set({ lines: [], nextLineId: 1, streamText: "", activeTab: "chat", clearCounter: clearCounter + 1, headerPrinted: false });
+  },
+});

package/src/tasks/db.js

@@ -0,0 +1,184 @@
+// SQLite persistent task database for Flint
+// File: ~/.flint/tasks.db
+
+import Database from "better-sqlite3";
+import path from "node:path";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+
+// FLINT_DATA_DIR moves this database too, like sessions/ and memory/.
+// It holds the message bus, and the bus recovers stale "processing" messages
+// on startup: a bench instance killed mid-turn left its prompt here, and the
+// next instance, started for a different task, picked it up and worked on it
+// for fifteen minutes (SWE pilot, 2026-09-26). A subject with its own data
+// dir must not share a queue with anyone.
+const FLINT_DIR = process.env.FLINT_DATA_DIR
+  ? path.resolve(process.env.FLINT_DATA_DIR)
+  : path.join(homedir(), ".flint");
+const DB_PATH = path.join(FLINT_DIR, "tasks.db");
+
+/** Where the task and message-bus database lives, for isolation checks. */
+export function tasksDbPath() {
+  return DB_PATH;
+}
+
+let db = null;
+
+export function getDb() {
+  if (db) return db;
+
+  mkdirSync(FLINT_DIR, { recursive: true });
+  db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+
+  migrate(db);
+  return db;
+}
+
+function migrate(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS goals (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      project TEXT DEFAULT 'default',
+      status TEXT DEFAULT 'active' CHECK(status IN ('active', 'completed', 'abandoned')),
+      session_id TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      completed_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      goal_id INTEGER REFERENCES goals(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'done', 'skipped')),
+      priority INTEGER DEFAULT 0,
+      result TEXT,
+      next_run TEXT,
+      repeat TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS task_files (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      path TEXT NOT NULL,
+      role TEXT DEFAULT 'related' CHECK(role IN ('created', 'modified', 'related')),
+      added_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS task_notes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      note TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_goal ON tasks(goal_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_goals_status ON goals(status);
+    CREATE INDEX IF NOT EXISTS idx_goals_project ON goals(project);
+  `);
+
+  // Migration: add next_run and repeat columns to existing tables
+  try { db.exec("ALTER TABLE tasks ADD COLUMN next_run TEXT"); } catch {}
+  try { db.exec("ALTER TABLE tasks ADD COLUMN repeat TEXT"); } catch {}
+
+  // Migration: add assignee and agent_port for task-driven child agents
+  try { db.exec("ALTER TABLE tasks ADD COLUMN assignee TEXT"); } catch {}
+  try { db.exec("ALTER TABLE tasks ADD COLUMN agent_port INTEGER"); } catch {}
+
+  // Migration: scope (session/project/global) and parent_task_id
+  try { db.exec("ALTER TABLE tasks ADD COLUMN scope TEXT DEFAULT 'session'"); } catch {}
+  try { db.exec("ALTER TABLE tasks ADD COLUMN parent_task_id INTEGER REFERENCES tasks(id)"); } catch {}
+
+  // Migration: daily_focus date for day planning
+  try { db.exec("ALTER TABLE tasks ADD COLUMN daily_focus TEXT"); } catch {}
+
+  // Index on next_run (after migration ensures column exists)
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_next_run ON tasks(next_run)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON tasks(assignee)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_scope ON tasks(scope)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_task_id)");
+
+  // Migration: drop NOT NULL on tasks.goal_id for standalone reminders (#v1.0.1)
+  // Old schema had goal_id INTEGER NOT NULL — blocks add_task without a goal.
+  // SQLite can't ALTER COLUMN, so we rebuild the table if NOT NULL is detected.
+  try {
+    const tableSql = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='tasks'").get();
+    if (tableSql && /goal_id\s+INTEGER\s+NOT NULL/i.test(tableSql.sql)) {
+      const columns = db.prepare("PRAGMA table_info(tasks)").all();
+      const columnList = columns.map(c => c.name).join(", ");
+      db.exec("BEGIN");
+      db.exec(`CREATE TABLE tasks_new (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        goal_id INTEGER REFERENCES goals(id) ON DELETE CASCADE,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT DEFAULT 'pending' CHECK(status IN ('pending', 'in_progress', 'done', 'skipped')),
+        priority INTEGER DEFAULT 0,
+        result TEXT,
+        next_run TEXT,
+        repeat TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now'))
+      )`);
+      // Add any extra columns from prior ALTER TABLE migrations
+      const knownCols = new Set(["id","goal_id","title","description","status","priority","result","next_run","repeat","created_at","updated_at"]);
+      for (const col of columns) {
+        if (knownCols.has(col.name)) continue;
+        const typeDef = col.type || "TEXT";
+        const dflt = col.dflt_value != null ? ` DEFAULT ${col.dflt_value}` : "";
+        try { db.exec(`ALTER TABLE tasks_new ADD COLUMN ${col.name} ${typeDef}${dflt}`); } catch {}
+      }
+      db.exec(`INSERT INTO tasks_new (${columnList}) SELECT ${columnList} FROM tasks`);
+      db.exec("DROP TABLE tasks");
+      db.exec("ALTER TABLE tasks_new RENAME TO tasks");
+      db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_goal ON tasks(goal_id)");
+      db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status)");
+      db.exec("COMMIT");
+    }
+  } catch (e) {
+    try { db.exec("ROLLBACK"); } catch {}
+  }
+
+  // Sessions registry: track session lifecycle for GC
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      created_at TEXT DEFAULT (datetime('now')),
+      last_updated TEXT DEFAULT (datetime('now')),
+      focused_goal_id INTEGER REFERENCES goals(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(last_updated);
+  `);
+
+  // Message Bus: unified priority queue for all input channels
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS message_queue (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      channel TEXT NOT NULL,
+      content TEXT NOT NULL,
+      priority INTEGER DEFAULT 5,
+      source TEXT,
+      metadata TEXT,
+      status TEXT DEFAULT 'pending' CHECK(status IN ('pending', 'processing', 'done', 'failed')),
+      session_id TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      processed_at TEXT,
+      result TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_queue_drain ON message_queue(status, priority, created_at);
+    CREATE INDEX IF NOT EXISTS idx_queue_cleanup ON message_queue(status, processed_at);
+  `);
+}
+
+export function closeDb() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}