picocode 0.1.0

package/dist/pico.js

@@ -0,0 +1,3121 @@
+// src/main.jsx
+import { readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { mount } from "@trendr/core";
+
+// src/core/keys.js
+import { setKeys } from "@prsm/ai";
+var PROVIDERS = [
+  { id: "google", label: "Gemini", env: ["GEMINI_API_KEY", "GOOGLE_AI_API_KEY"] },
+  { id: "anthropic", label: "Claude", env: ["ANTHROPIC_API_KEY"] },
+  { id: "openai", label: "OpenAI", env: ["OPENAI_API_KEY"] },
+  { id: "xai", label: "Grok", env: ["XAI_API_KEY"] }
+];
+function discoverKeys(env = process.env) {
+  const keys2 = {};
+  for (const p of PROVIDERS) {
+    const name = p.env.find((n) => env[n]);
+    if (name) keys2[p.id] = env[name];
+  }
+  return keys2;
+}
+function applyKeys(keys2) {
+  setKeys(keys2);
+  return Object.keys(keys2);
+}
+
+// src/core/models.js
+var CATALOG = [
+  { name: "google/gemini-2.5-pro", provider: "google", desc: "Strong reasoning, long context", price: { in: 1.25, out: 10 }, effort: true },
+  { name: "google/gemini-2.5-flash", provider: "google", desc: "Fast and capable for everyday work", price: { in: 0.3, out: 2.5 }, effort: true },
+  { name: "google/gemini-2.5-flash-lite", provider: "google", desc: "Lowest latency and cost", price: { in: 0.1, out: 0.4 }, effort: true },
+  { name: "anthropic/claude-opus-4-8", provider: "anthropic", desc: "Frontier coding and agentic workflows", price: { in: 15, out: 75 }, effort: true },
+  { name: "anthropic/claude-sonnet-5", provider: "anthropic", desc: "Balanced speed and capability", price: { in: 3, out: 15 }, effort: true },
+  { name: "anthropic/claude-haiku-4-5", provider: "anthropic", desc: "Fastest, for light interactive tasks", price: { in: 1, out: 5 }, effort: true },
+  { name: "openai/gpt-5.2", provider: "openai", desc: "Strong general reasoning and tool use", price: { in: 10, out: 40 }, effort: true },
+  { name: "openai/gpt-5.2-mini", provider: "openai", desc: "Small and quick for everyday edits", price: { in: 0.6, out: 2.4 }, effort: true },
+  { name: "xai/grok-4", provider: "xai", desc: "Realtime knowledge, strong reasoning", price: { in: 5, out: 25 }, effort: false }
+];
+function availableModels(providerIds) {
+  return CATALOG.filter((m) => providerIds.includes(m.provider));
+}
+function findModel(name) {
+  return CATALOG.find((m) => m.name === name) || null;
+}
+function defaultModel(providerIds) {
+  return availableModels(providerIds)[0] || null;
+}
+function estimateCost(model2, usage) {
+  if (!model2?.price || !usage) return 0;
+  const inCost = (usage.promptTokens || 0) * model2.price.in;
+  const outCost = (usage.completionTokens || 0) * model2.price.out;
+  return (inCost + outCost) / 1e6;
+}
+
+// src/core/config.js
+import { readFile, writeFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// src/core/paths.js
+import { existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+function picoHome() {
+  return process.env.PICO_HOME || join(homedir(), ".pico");
+}
+function projectKey(root) {
+  return resolve(root).replace(/[/\\:]/g, "-");
+}
+function findProjectRoot(cwd) {
+  let dir = resolve(cwd);
+  const home2 = homedir();
+  while (true) {
+    if (existsSync(join(dir, ".git"))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir || dir === home2) return resolve(cwd);
+    dir = parent;
+  }
+}
+function projectDir(root) {
+  return join(picoHome(), "projects", projectKey(root));
+}
+function sessionsDir(root) {
+  return join(projectDir(root), "sessions");
+}
+function projectHistoryFile(root) {
+  return join(projectDir(root), "history.jsonl");
+}
+function projectMcpFile(root) {
+  return join(projectDir(root), "mcp.json");
+}
+function globalMcpFile() {
+  return join(picoHome(), "mcp.json");
+}
+function globalSkillsDir() {
+  return join(picoHome(), "skills");
+}
+function projectSkillsDir(root) {
+  return join(root, ".pico", "skills");
+}
+function globalAgentsFile() {
+  return join(picoHome(), "AGENTS.md");
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// src/core/config.js
+function configFile() {
+  return join2(picoHome(), "config.json");
+}
+async function readConfig() {
+  try {
+    return JSON.parse(await readFile(configFile(), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function writeConfig(patch) {
+  const config2 = { ...await readConfig(), ...patch };
+  ensureDir(picoHome());
+  await writeFile(configFile(), JSON.stringify(config2, null, 2) + "\n");
+  return config2;
+}
+
+// src/core/context.js
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+function readIfExists(path) {
+  try {
+    return existsSync2(path) ? readFileSync(path, "utf-8") : null;
+  } catch {
+    return null;
+  }
+}
+function contextStopDir(cwd) {
+  let dir = resolve2(cwd);
+  const home2 = homedir2();
+  while (true) {
+    if (existsSync2(join3(dir, ".git")) || dir === home2) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return resolve2(cwd);
+    dir = parent;
+  }
+}
+function ancestorDirs(cwd, stopDir) {
+  const dirs = [];
+  let dir = resolve2(cwd);
+  while (true) {
+    dirs.unshift(dir);
+    if (dir === stopDir) break;
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return dirs;
+}
+function loadStartupContext(cwd) {
+  const stopDir = contextStopDir(cwd);
+  const files = [];
+  const globalContent = readIfExists(globalAgentsFile());
+  if (globalContent) files.push({ path: globalAgentsFile(), content: globalContent });
+  for (const dir of ancestorDirs(cwd, stopDir)) {
+    const path = join3(dir, "AGENTS.md");
+    const content = readIfExists(path);
+    if (content) files.push({ path, content });
+  }
+  return { files, stopDir };
+}
+function createContextTracker({ stopDir, loaded }) {
+  return {
+    loaded,
+    check(filePath) {
+      const target = dirname2(resolve2(filePath));
+      if (!target.startsWith(stopDir)) return [];
+      const fresh = [];
+      for (const dir of ancestorDirs(target, stopDir)) {
+        const path = join3(dir, "AGENTS.md");
+        if (loaded.has(path)) continue;
+        const content = readIfExists(path);
+        if (content) {
+          loaded.add(path);
+          fresh.push({ path, content });
+        }
+      }
+      return fresh;
+    }
+  };
+}
+
+// src/core/skills.js
+import { readFile as readFile2, readdir } from "node:fs/promises";
+import { join as join4 } from "node:path";
+function parseFrontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!match) return { meta: {}, body: text };
+  const meta = {};
+  for (const line of match[1].split("\n")) {
+    const sep = line.indexOf(":");
+    if (sep === -1) continue;
+    meta[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
+  }
+  return { meta, body: text.slice(match[0].length) };
+}
+async function scanDir(dir, source) {
+  let names = [];
+  try {
+    names = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of names) {
+    if (!entry.isDirectory()) continue;
+    const file = join4(dir, entry.name, "SKILL.md");
+    try {
+      const { meta } = parseFrontmatter(await readFile2(file, "utf-8"));
+      skills.push({
+        name: meta.name || entry.name,
+        description: meta.description || "",
+        source,
+        file
+      });
+    } catch {
+    }
+  }
+  return skills;
+}
+async function createSkillIndex(root) {
+  const global = await scanDir(globalSkillsDir(), "global");
+  const project = await scanDir(projectSkillsDir(root), "project");
+  const byName = /* @__PURE__ */ new Map();
+  for (const skill of [...global, ...project]) byName.set(skill.name, skill);
+  const skills = [...byName.values()];
+  return {
+    list: () => skills,
+    async load(name) {
+      const skill = byName.get(name);
+      if (!skill) return null;
+      const { body } = parseFrontmatter(await readFile2(skill.file, "utf-8"));
+      return body;
+    }
+  };
+}
+
+// src/core/commands.js
+import { readFile as readFile3, readdir as readdir2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+function globalCommandsDir() {
+  return join5(picoHome(), "commands");
+}
+function projectCommandsDir(root) {
+  return join5(root, ".pico", "commands");
+}
+async function scanDir2(dir, source) {
+  let names = [];
+  try {
+    names = await readdir2(dir);
+  } catch {
+    return [];
+  }
+  const commands = [];
+  for (const file of names) {
+    if (!file.endsWith(".md")) continue;
+    try {
+      const { meta } = parseFrontmatter(await readFile3(join5(dir, file), "utf-8"));
+      commands.push({
+        name: file.slice(0, -3),
+        description: meta.description || "",
+        source,
+        file: join5(dir, file)
+      });
+    } catch {
+    }
+  }
+  return commands;
+}
+function expandCommand(body, args) {
+  return body.includes("$ARGUMENTS") ? body.replaceAll("$ARGUMENTS", args) : args ? `${body.trim()}
+
+${args}` : body;
+}
+async function createCommandIndex(root) {
+  const global = await scanDir2(globalCommandsDir(), "global");
+  const project = await scanDir2(projectCommandsDir(root), "project");
+  const byName = /* @__PURE__ */ new Map();
+  for (const command of [...global, ...project]) byName.set(command.name, command);
+  const commands = [...byName.values()];
+  return {
+    list: () => commands,
+    async load(name, args = "") {
+      const command = byName.get(name);
+      if (!command) return null;
+      const { body } = parseFrontmatter(await readFile3(command.file, "utf-8"));
+      return expandCommand(body.trim(), args.trim());
+    }
+  };
+}
+
+// src/core/mcp.js
+import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { connectMCP } from "@prsm/ai";
+function parseCommand(str) {
+  const tokens = [];
+  const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+  let m;
+  while (m = re.exec(str)) tokens.push(m[1] ?? m[2] ?? m[3]);
+  const env = {};
+  while (tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0])) {
+    const sep = tokens[0].indexOf("=");
+    env[tokens[0].slice(0, sep)] = tokens[0].slice(sep + 1);
+    tokens.shift();
+  }
+  if (!tokens.length) throw new Error("empty command");
+  return { command: tokens[0], args: tokens.slice(1), env };
+}
+async function readJson(file, fallback) {
+  try {
+    return JSON.parse(await readFile4(file, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function readRegistry() {
+  return readJson(globalMcpFile(), { servers: {} });
+}
+async function writeRegistry(registry) {
+  ensureDir(picoHome());
+  await writeFile2(globalMcpFile(), JSON.stringify(registry, null, 2) + "\n");
+}
+function readEnablement(root) {
+  return readJson(projectMcpFile(root), { disabled: {} });
+}
+async function writeEnablement(root, enablement) {
+  ensureDir(projectDir(root));
+  await writeFile2(projectMcpFile(root), JSON.stringify(enablement, null, 2) + "\n");
+}
+async function createMcpRuntime({ root, onChange = () => {
+} }) {
+  const registry = await readRegistry();
+  const enablement = await readEnablement(root);
+  const servers = /* @__PURE__ */ new Map();
+  for (const [name, command] of Object.entries(registry.servers)) {
+    servers.set(name, {
+      name,
+      command,
+      enabled: !enablement.disabled[name],
+      status: enablement.disabled[name] ? "disabled" : "idle",
+      error: null,
+      connection: null
+    });
+  }
+  let StdioClientTransport = null;
+  async function connect(name) {
+    const server = servers.get(name);
+    if (!server) return;
+    server.status = "connecting";
+    server.error = null;
+    onChange();
+    try {
+      if (!StdioClientTransport) {
+        ({ StdioClientTransport } = await import("@modelcontextprotocol/sdk/client/stdio.js"));
+      }
+      const parsed = parseCommand(server.command);
+      server.connection = await connectMCP({
+        name,
+        transport: () => new StdioClientTransport({
+          command: parsed.command,
+          args: parsed.args,
+          env: { ...process.env, ...parsed.env },
+          stderr: "pipe"
+        })
+      });
+      server.status = "connected";
+    } catch (err) {
+      server.status = "error";
+      server.error = String(err.message || err).slice(0, 300);
+      server.connection = null;
+    }
+    onChange();
+  }
+  async function disconnect(name) {
+    const server = servers.get(name);
+    if (server?.connection) {
+      await server.connection.close().catch(() => {
+      });
+      server.connection = null;
+    }
+  }
+  return {
+    connectAll() {
+      for (const server of servers.values()) {
+        if (server.enabled) connect(server.name);
+      }
+    },
+    async add(name, command) {
+      const registry2 = await readRegistry();
+      registry2.servers[name] = command;
+      await writeRegistry(registry2);
+      servers.set(name, { name, command, enabled: true, status: "idle", error: null, connection: null });
+      await connect(name);
+    },
+    async remove(name) {
+      const registry2 = await readRegistry();
+      delete registry2.servers[name];
+      await writeRegistry(registry2);
+      await disconnect(name);
+      servers.delete(name);
+      onChange();
+    },
+    async toggle(name) {
+      const server = servers.get(name);
+      if (!server) return;
+      const enablement2 = await readEnablement(root);
+      if (server.enabled) {
+        server.enabled = false;
+        server.status = "disabled";
+        enablement2.disabled[name] = true;
+        await writeEnablement(root, enablement2);
+        await disconnect(name);
+        onChange();
+      } else {
+        server.enabled = true;
+        delete enablement2.disabled[name];
+        await writeEnablement(root, enablement2);
+        await connect(name);
+      }
+    },
+    reconnect(name) {
+      return disconnect(name).then(() => connect(name));
+    },
+    list() {
+      return [...servers.values()].map((s) => ({
+        name: s.name,
+        command: s.command,
+        enabled: s.enabled,
+        status: s.status,
+        error: s.error,
+        toolCount: s.connection?.tools.length || 0,
+        tools: (s.connection?.tools || []).map((t) => ({ name: t.name, description: t.description || "" }))
+      }));
+    },
+    tools() {
+      return [...servers.values()].filter((s) => s.connection).flatMap((s) => s.connection.tools);
+    },
+    async closeAll() {
+      for (const name of servers.keys()) await disconnect(name);
+    }
+  };
+}
+
+// src/ui/app.jsx
+import { writeFile as writeFile6 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join8 } from "node:path";
+import { createSignal as createSignal4, Menu as Menu2, ScrollBox as ScrollBox3, Shimmer, TextArea, useFocus, useFocusTrap, useInput as useInput3, useSelection } from "@trendr/core";
+
+// src/core/events.js
+import { randomUUID } from "node:crypto";
+var SESSION_VERSION = 1;
+function makeEvent(type, data = {}) {
+  return { id: randomUUID(), at: Date.now(), type, data };
+}
+function makeHeader({ cwd, root }) {
+  return {
+    type: "session",
+    version: SESSION_VERSION,
+    id: randomUUID(),
+    cwd,
+    root,
+    createdAt: Date.now()
+  };
+}
+function serializeLine(event) {
+  return JSON.stringify(event) + "\n";
+}
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed && typeof parsed.type === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function parseLines(text) {
+  return text.split("\n").map(parseLine).filter(Boolean);
+}
+
+// src/core/session.js
+import { appendFile, readFile as readFile5, readdir as readdir3, stat } from "node:fs/promises";
+import { join as join6 } from "node:path";
+function createSession({ cwd, root }) {
+  const header = makeHeader({ cwd, root });
+  const file = join6(ensureDir(sessionsDir(root)), `${header.id}.jsonl`);
+  const session = openSession({ file, header });
+  session.append(header);
+  return session;
+}
+function openSession({ file, header }) {
+  let queue = Promise.resolve();
+  return {
+    id: header.id,
+    file,
+    header,
+    append(event) {
+      queue = queue.then(() => appendFile(file, serializeLine(event)));
+      return queue;
+    },
+    flush() {
+      return queue;
+    }
+  };
+}
+async function loadSession(file) {
+  const events = parseLines(await readFile5(file, "utf-8"));
+  const header = events[0]?.type === "session" ? events.shift() : null;
+  if (!header) throw new Error(`not a pico session file: ${file}`);
+  return { header, events };
+}
+async function sessionMeta(file) {
+  const [info, handle] = await Promise.all([stat(file), readFile5(file, "utf-8")]);
+  const lines = handle.split("\n");
+  const header = parseLine(lines[0]);
+  if (!header || header.type !== "session") return null;
+  let title = null;
+  let color = null;
+  let turns = 0;
+  for (const line of lines.slice(1)) {
+    const event = parseLine(line);
+    if (!event) continue;
+    if (event.type === "title") title = event.data.text;
+    if (event.type === "color") color = event.data.value;
+    if (event.type === "message" && event.data.message?.role === "user") {
+      turns++;
+      const content = event.data.message.content;
+      const text = Array.isArray(content) ? content.filter((p) => p.type === "text").map((p) => p.text).join(" ") : String(content);
+      if (!title && text.trim()) title = text.trim().slice(0, 200);
+    }
+  }
+  if (!title) return null;
+  return { file, header, title, color, turns, at: info.mtimeMs };
+}
+async function listDir(dir) {
+  try {
+    const names = await readdir3(dir);
+    return names.filter((n) => n.endsWith(".jsonl")).map((n) => join6(dir, n));
+  } catch {
+    return [];
+  }
+}
+async function listSessions({ scope: scope2, root }) {
+  let files = [];
+  if (scope2 === "everywhere") {
+    const projectsDir = join6(picoHome(), "projects");
+    let projects = [];
+    try {
+      projects = await readdir3(projectsDir);
+    } catch {
+    }
+    const nested = await Promise.all(
+      projects.map((p) => listDir(join6(projectsDir, p, "sessions")))
+    );
+    files = nested.flat();
+  } else {
+    files = await listDir(sessionsDir(root));
+  }
+  const metas = await Promise.all(files.map((f) => sessionMeta(f).catch(() => null)));
+  return metas.filter(Boolean).sort((a, b) => b.at - a.at);
+}
+
+// src/core/derive.js
+var DROPPING_MODES = ["both", "chat", "summary"];
+function activeRewinds(events) {
+  const canceled = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.type === "rewind_undo") canceled.add(e.data.rewindId);
+  }
+  return events.filter((e) => e.type === "rewind" && !canceled.has(e.id));
+}
+function droppedIds(events) {
+  const dropped = /* @__PURE__ */ new Set();
+  const index = new Map(events.map((e, i) => [e.id, i]));
+  for (const rewind of activeRewinds(events)) {
+    if (!DROPPING_MODES.includes(rewind.data.mode)) continue;
+    const from = index.get(rewind.data.target);
+    const to = index.get(rewind.id);
+    if (from === void 0 || to === void 0) continue;
+    for (let i = from; i < to; i++) dropped.add(events[i].id);
+  }
+  return dropped;
+}
+function addUsageInto(total, usage) {
+  total.promptTokens += usage.promptTokens || 0;
+  total.completionTokens += usage.completionTokens || 0;
+  total.totalTokens += usage.totalTokens || 0;
+  total.cachedTokens += usage.cachedTokens || 0;
+}
+function emptyUsage() {
+  return { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0 };
+}
+function parseArgs(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return { _raw: raw };
+  }
+}
+function foldMessage(state, event) {
+  const message = event.data.message;
+  if (!message || message.role === "system") return;
+  state.providerHistory.push(message);
+  if (message.role === "user") {
+    const text = Array.isArray(message.content) ? message.content.map((p) => p.type === "text" ? p.text : `[image: ${String(p.source?.path || "").split("/").pop() || "attached"}]`).join("") : String(message.content);
+    state.transcript.push({ kind: "user", text, eventId: event.id });
+    return;
+  }
+  if (message.role === "assistant") {
+    if (message.content) {
+      state.transcript.push({ kind: "assistant", text: message.content, model: state.model });
+    }
+    for (const call of message.tool_calls || []) {
+      const item = {
+        kind: "tool",
+        callId: call.id,
+        name: call.function.name,
+        args: parseArgs(call.function.arguments),
+        title: call.function.name,
+        status: "done",
+        eventId: event.id
+      };
+      state.transcript.push(item);
+      state.toolItems.set(call.id, item);
+    }
+    return;
+  }
+  if (message.role === "tool") {
+    const item = state.toolItems.get(message.tool_call_id);
+    if (item) item.resultText = String(message.content);
+  }
+}
+function foldRewind(state, event) {
+  const { mode, summaryText, reverted = [] } = event.data;
+  for (const callId of reverted) {
+    const item = state.toolItems.get(callId);
+    if (item) item.status = "reverted";
+  }
+  if (mode === "summary" && summaryText) {
+    state.transcript.push({ kind: "summary", text: summaryText });
+    state.providerHistory.push({
+      role: "assistant",
+      content: `[summary of the rewound conversation]
+${summaryText}`
+    });
+  }
+}
+function deriveState(events) {
+  const dropped = droppedIds(events);
+  const canceledUndoTargets = new Set(
+    events.filter((e) => e.type === "rewind_undo").map((e) => e.data.rewindId)
+  );
+  const state = {
+    transcript: [],
+    providerHistory: [],
+    model: null,
+    effort: void 0,
+    usage: emptyUsage(),
+    usageByModel: {},
+    loadedContext: /* @__PURE__ */ new Set(),
+    toolItems: /* @__PURE__ */ new Map()
+  };
+  for (const event of events) {
+    if (event.type === "usage") {
+      addUsageInto(state.usage, event.data.usage);
+      const byModel = state.usageByModel[event.data.model] ||= emptyUsage();
+      addUsageInto(byModel, event.data.usage);
+      continue;
+    }
+    if (dropped.has(event.id)) continue;
+    switch (event.type) {
+      case "message":
+        foldMessage(state, event);
+        break;
+      case "tool_meta": {
+        const item = state.toolItems.get(event.data.callId);
+        if (item) Object.assign(item, event.data, { kind: "tool", callId: item.callId });
+        break;
+      }
+      case "interrupt": {
+        const last = state.transcript.at(-1);
+        if (last?.kind === "assistant") last.interrupted = true;
+        if (last?.kind === "tool" && last.status === "running") last.status = "interrupted";
+        break;
+      }
+      case "model_switch":
+        state.model = event.data.to;
+        break;
+      case "effort":
+        state.effort = event.data.to;
+        break;
+      case "title":
+        state.title = event.data.text;
+        break;
+      case "color":
+        state.color = event.data.value;
+        break;
+      case "rewind":
+        if (!canceledUndoTargets.has(event.id)) foldRewind(state, event);
+        break;
+      case "compact":
+        state.providerHistory = [
+          { role: "user", content: `[conversation summary]
+${event.data.summary}` },
+          { role: "assistant", content: "Got it. Continuing from that summary." }
+        ];
+        state.transcript.push({ kind: "summary", text: event.data.summary });
+        break;
+      case "clear":
+        state.transcript = [];
+        state.providerHistory = [];
+        state.toolItems = /* @__PURE__ */ new Map();
+        break;
+      case "context_file":
+        state.loadedContext.add(event.data.path);
+        break;
+      case "skill":
+        state.transcript.push({ kind: "skill", name: event.data.name });
+        break;
+    }
+  }
+  return state;
+}
+function userEntries(state) {
+  const entries = [];
+  state.transcript.forEach((item, index) => {
+    if (item.kind === "user") entries.push({ text: item.text, index, eventId: item.eventId });
+  });
+  return entries;
+}
+function rewindStats(state, index) {
+  const tail = state.transcript.slice(index);
+  return {
+    msgs: tail.length,
+    edits: tail.filter((m) => m.kind === "tool" && m.revert && m.status !== "reverted")
+  };
+}
+
+// src/core/history.js
+import { appendFile as appendFile2, readFile as readFile6, readdir as readdir4 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+var MAX_PROMPTS_PER_SCOPE = 1e3;
+async function appendPrompt(root, text) {
+  ensureDir(projectDir(root));
+  await appendFile2(projectHistoryFile(root), JSON.stringify({ text, at: Date.now() }) + "\n");
+}
+function parsePromptLines(text) {
+  return text.split("\n").map((line) => {
+    try {
+      return line.trim() ? JSON.parse(line) : null;
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+async function readPrompts(file, scope2) {
+  try {
+    const entries = parsePromptLines(await readFile6(file, "utf-8"));
+    return entries.filter((e) => typeof e.text === "string" && e.text.trim()).slice(-MAX_PROMPTS_PER_SCOPE).map((e) => ({ text: e.text, at: e.at || 0, scope: scope2 }));
+  } catch {
+    return [];
+  }
+}
+function loadProjectPrompts(root) {
+  return readPrompts(projectHistoryFile(root), "project");
+}
+async function loadGlobalPrompts() {
+  const projectsDir = join7(picoHome(), "projects");
+  let projects = [];
+  try {
+    projects = await readdir4(projectsDir);
+  } catch {
+  }
+  const nested = await Promise.all(
+    projects.map((p) => readPrompts(join7(projectsDir, p, "history.jsonl"), "everywhere"))
+  );
+  return nested.flat().sort((a, b) => b.at - a.at).slice(0, MAX_PROMPTS_PER_SCOPE);
+}
+
+// src/core/agent.js
+import { readFile as readFile7 } from "node:fs/promises";
+import { compose, scope, model, noToolsCalled, Inherit, getText } from "@prsm/ai";
+async function hydratePart(part) {
+  if (part.type !== "image" || part.source?.kind !== "path") return part;
+  try {
+    const data = await readFile7(part.source.path);
+    return {
+      type: "image",
+      source: { kind: "base64", mediaType: part.source.mediaType, data: data.toString("base64") }
+    };
+  } catch {
+    return { type: "text", text: `[image unavailable: ${part.source.path}]` };
+  }
+}
+function hydrateImages(history) {
+  return Promise.all(
+    history.map(
+      async (message) => Array.isArray(message.content) ? { ...message, content: await Promise.all(message.content.map(hydratePart)) } : message
+    )
+  );
+}
+var STALL_MS = 9e4;
+async function summarizeText({ text, modelName }) {
+  const out = await compose(
+    model({
+      model: modelName,
+      system: "Summarize the following conversation excerpt in 2-4 dense sentences. Capture decisions, changes made, and open questions. Output only the summary."
+    })
+  )(text.slice(0, 3e4));
+  return getText(out.lastResponse?.content || "").trim();
+}
+async function runTurn({ history, tools, recorder, modelName, effort, system, signal, onStream, stallMs = STALL_MS }) {
+  const collected = [];
+  let roundText = "";
+  let usageSeen = null;
+  let stalled = false;
+  const internal = new AbortController();
+  const onUserAbort = () => internal.abort();
+  if (signal?.aborted) internal.abort();
+  else signal?.addEventListener("abort", onUserAbort, { once: true });
+  let watchdog = null;
+  const arm = () => {
+    clearTimeout(watchdog);
+    watchdog = setTimeout(() => {
+      stalled = true;
+      internal.abort();
+    }, stallMs);
+  };
+  const stream = (event) => {
+    arm();
+    if (event.type === "content") {
+      roundText += event.content;
+    } else if (event.type === "tool_calls_ready") {
+      collected.push({ role: "assistant", content: roundText, tool_calls: event.calls });
+      roundText = "";
+    } else if (event.type === "tool_executing") {
+      recorder.currentCall = event.call;
+    } else if (event.type === "tool_complete") {
+      collected.push({ role: "tool", tool_call_id: event.call.id, content: JSON.stringify(event.result) });
+    } else if (event.type === "tool_error") {
+      collected.push({ role: "tool", tool_call_id: event.call.id, content: JSON.stringify({ error: event.error }) });
+    } else if (event.type === "usage") {
+      usageSeen = event.usage;
+    }
+    onStream?.(event);
+  };
+  const base = history.length;
+  const step = compose(
+    scope(
+      { inherit: Inherit.Conversation, system, tools, until: noToolsCalled(), stream },
+      (ctx) => model({ model: modelName, ...effort && { effort } })({ ...ctx, abortSignal: internal.signal })
+    )
+  );
+  const partialMessages = () => {
+    const messages = [...collected];
+    if (roundText) messages.push({ role: "assistant", content: roundText });
+    return messages;
+  };
+  arm();
+  try {
+    const out = await step({ history: await hydrateImages(history), tools: [] });
+    const interrupted = !!signal?.aborted || stalled;
+    if (interrupted) {
+      return { messages: partialMessages(), usage: usageSeen, interrupted, stalled };
+    }
+    const messages = out.history.filter((m) => m.role !== "system").slice(base);
+    return { messages, usage: out.usage || null, interrupted: false, stalled: false };
+  } catch (err) {
+    if (err.name === "AbortError" || internal.signal.aborted) {
+      return { messages: partialMessages(), usage: usageSeen, interrupted: true, stalled };
+    }
+    throw err;
+  } finally {
+    clearTimeout(watchdog);
+    signal?.removeEventListener("abort", onUserAbort);
+  }
+}
+
+// src/core/tools/recorder.js
+function createRecorder() {
+  return {
+    currentCall: null,
+    entries: [],
+    pending: null,
+    begin(name) {
+      this.pending = {
+        callId: this.currentCall?.id ?? null,
+        name,
+        title: name,
+        status: "done",
+        startedAt: Date.now()
+      };
+    },
+    extra(fields) {
+      if (this.pending) Object.assign(this.pending, fields);
+    },
+    done(fields = {}) {
+      if (!this.pending) return;
+      Object.assign(this.pending, fields, {
+        durationMs: Date.now() - this.pending.startedAt
+      });
+      delete this.pending.startedAt;
+      if (this.pending.fullOutput?.length > 2e5) {
+        this.pending.fullOutput = this.pending.fullOutput.slice(0, 2e5) + "\n[truncated]";
+      }
+      this.entries.push(this.pending);
+      this.pending = null;
+    }
+  };
+}
+function recorded(recorder, name, fn) {
+  return async (args) => {
+    recorder.begin(name);
+    try {
+      const result = await fn(args);
+      recorder.done();
+      return result;
+    } catch (err) {
+      recorder.done({ status: "error", error: String(err.message || err) });
+      throw err;
+    }
+  };
+}
+
+// src/core/tools/read.js
+import { readFile as readFile8 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+var MAX_LINES = 2e3;
+var MAX_LINE_LENGTH = 2e3;
+function isBinary(buffer) {
+  const len = Math.min(buffer.length, 8e3);
+  for (let i = 0; i < len; i++) {
+    if (buffer[i] === 0) return true;
+  }
+  return false;
+}
+function createRead({ cwd, recorder, tracker }) {
+  return {
+    name: "read",
+    description: "Read a file. Returns line-numbered content. Use offset/limit for large files.",
+    schema: {
+      path: { type: "string", description: "file path, relative to the working directory or absolute" },
+      offset: { type: "number", description: "1-indexed line to start from", optional: true },
+      limit: { type: "number", description: "max lines to return", optional: true }
+    },
+    execute: async ({ path, offset = 1, limit = MAX_LINES }) => {
+      const full = resolve3(cwd, path);
+      recorder.extra({ title: path });
+      const buf = await readFile8(full);
+      if (isBinary(buf)) throw new Error(`${path} is a binary file`);
+      const lines = buf.toString("utf-8").split("\n");
+      const start = Math.max(0, offset - 1);
+      const count = Math.min(limit, MAX_LINES);
+      const sliced = lines.slice(start, start + count);
+      const numbered = sliced.map((line, i) => `${start + i + 1}	${line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + "\u2026" : line}`).join("\n");
+      recorder.extra({ fullOutput: sliced.join("\n") });
+      const result = { content: numbered, totalLines: lines.length };
+      if (start + count < lines.length) {
+        result.note = `showing lines ${start + 1}-${start + sliced.length} of ${lines.length}`;
+      }
+      const context = tracker.check(full);
+      if (context.length) result.context_from_agents_md = context;
+      return result;
+    }
+  };
+}
+
+// src/core/tools/write.js
+import { mkdir, readFile as readFile9, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, resolve as resolve4 } from "node:path";
+
+// src/core/tools/diff.js
+import { structuredPatch } from "diff";
+function makeDiff(path, oldText, newText, contextLines = 3) {
+  const patch = structuredPatch(path, path, oldText, newText, "", "", { context: contextLines });
+  let additions = 0;
+  let deletions = 0;
+  const hunks = patch.hunks.map((h) => ({
+    oldStart: h.oldStart,
+    newStart: h.newStart,
+    lines: h.lines.map((line) => {
+      const type = line[0] === "-" ? "remove" : line[0] === "+" ? "add" : "context";
+      if (type === "add") additions++;
+      if (type === "remove") deletions++;
+      return { type, text: line.slice(1) };
+    })
+  }));
+  return { path, hunks, additions, deletions };
+}
+
+// src/core/tools/write.js
+function createWrite({ cwd, recorder, tracker }) {
+  return {
+    name: "write",
+    description: "Write content to a file, creating it and any parent directories if needed. Overwrites existing content.",
+    schema: {
+      path: { type: "string", description: "file path, relative to the working directory or absolute" },
+      content: { type: "string", description: "the full file content to write" }
+    },
+    execute: async ({ path, content }) => {
+      const full = resolve4(cwd, path);
+      recorder.extra({ title: path });
+      await mkdir(dirname3(full), { recursive: true });
+      let before = null;
+      try {
+        before = await readFile9(full, "utf-8");
+      } catch {
+      }
+      await writeFile3(full, content, "utf-8");
+      const result = { ok: true, path };
+      if (before !== null) {
+        const diff = makeDiff(path, before, content);
+        recorder.extra({ diff, revert: { path: full, before, after: content } });
+        result.additions = diff.additions;
+        result.deletions = diff.deletions;
+      } else {
+        recorder.extra({ revert: { path: full, before: "", after: content }, created: true });
+        result.created = true;
+      }
+      const context = tracker.check(full);
+      if (context.length) result.context_from_agents_md = context;
+      return result;
+    }
+  };
+}
+
+// src/core/tools/edit.js
+import { readFile as readFile10, writeFile as writeFile4 } from "node:fs/promises";
+import { resolve as resolve5 } from "node:path";
+var normalize = (s) => s.replace(/\s+$/gm, "").replace(/[‘’]/g, "'").replace(/[“”]/g, '"').replace(/[–—]/g, "-");
+function locate(content, old, path) {
+  let index = content.indexOf(old);
+  if (index !== -1) {
+    if (content.indexOf(old, index + 1) !== -1) {
+      throw new Error(`string appears multiple times in ${path}, provide more surrounding context to make it unique`);
+    }
+    return { index, length: old.length, content };
+  }
+  const normedContent = normalize(content);
+  const normedOld = normalize(old);
+  index = normedContent.indexOf(normedOld);
+  if (index === -1) throw new Error(`string not found in ${path}`);
+  if (normedContent.indexOf(normedOld, index + 1) !== -1) {
+    throw new Error(`string appears multiple times in ${path}, provide more surrounding context to make it unique`);
+  }
+  return { index, length: normedOld.length, content: normedContent };
+}
+function createEdit({ cwd, recorder, tracker }) {
+  return {
+    name: "edit",
+    description: "Replace oldText with newText in a file. oldText must appear exactly once unless replaceAll is set.",
+    schema: {
+      path: { type: "string", description: "file path, relative to the working directory or absolute" },
+      oldText: { type: "string", description: "exact text to replace, must be unique in the file" },
+      newText: { type: "string", description: "replacement text" },
+      replaceAll: { type: "boolean", description: "replace every occurrence", optional: true }
+    },
+    execute: async ({ path, oldText, newText, replaceAll }) => {
+      const full = resolve5(cwd, path);
+      recorder.extra({ title: path });
+      const before = await readFile10(full, "utf-8");
+      let after;
+      if (replaceAll) {
+        if (!before.includes(oldText)) throw new Error(`string not found in ${path}`);
+        after = before.split(oldText).join(newText);
+      } else {
+        const { index, length, content } = locate(before, oldText, path);
+        after = content.slice(0, index) + newText + content.slice(index + length);
+      }
+      await writeFile4(full, after, "utf-8");
+      const diff = makeDiff(path, before, after);
+      recorder.extra({ diff, revert: { path: full, before, after } });
+      const result = { ok: true, path, additions: diff.additions, deletions: diff.deletions };
+      const context = tracker.check(full);
+      if (context.length) result.context_from_agents_md = context;
+      return result;
+    }
+  };
+}
+
+// src/core/tools/bash.js
+import { exec } from "node:child_process";
+var MAX_OUTPUT_CHARS = 3e4;
+function capped(text) {
+  if (text.length <= MAX_OUTPUT_CHARS) return text;
+  return text.slice(0, MAX_OUTPUT_CHARS) + `
+[output truncated at ${MAX_OUTPUT_CHARS} characters]`;
+}
+function createBash({ cwd, recorder, signal }) {
+  return {
+    name: "bash",
+    description: "Run a shell command in the working directory. Returns stdout, stderr, and exit code.",
+    schema: {
+      command: { type: "string", description: "the command to run" },
+      timeout: { type: "number", description: "timeout in milliseconds, default 120000", optional: true }
+    },
+    execute: ({ command, timeout }) => new Promise((resolve7) => {
+      recorder.extra({ title: command });
+      const child = exec(
+        command,
+        {
+          cwd,
+          timeout: timeout || 12e4,
+          maxBuffer: 10 * 1024 * 1024,
+          env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" }
+        },
+        (err, stdout, stderr) => {
+          const exitCode = err ? typeof err.code === "number" ? err.code : 1 : 0;
+          recorder.extra({ fullOutput: [stdout, stderr].filter(Boolean).join("\n") });
+          resolve7({ stdout: capped(stdout || ""), stderr: capped(stderr || ""), exitCode });
+        }
+      );
+      if (signal) {
+        if (signal.aborted) {
+          child.kill();
+          return;
+        }
+        signal.addEventListener("abort", () => child.kill(), { once: true });
+      }
+    })
+  };
+}
+
+// src/core/tools/glob.js
+import { execFile } from "node:child_process";
+import fg from "fast-glob";
+var MAX_RESULTS = 200;
+function ripgrepGlob(pattern, cwd) {
+  return new Promise((resolve7) => {
+    const args = ["--files", "--glob", pattern, "--glob", "!**/node_modules/**", "--glob", "!**/.git/**"];
+    execFile("rg", args, { cwd, maxBuffer: 50 * 1024 * 1024 }, (err, stdout) => {
+      if (err && err.code !== 1) resolve7(null);
+      else resolve7(stdout ? stdout.split("\n").filter(Boolean) : []);
+    });
+  });
+}
+function createGlob({ cwd, recorder }) {
+  return {
+    name: "glob",
+    description: "Find files matching a glob pattern, relative to the working directory. Respects .gitignore; use bash to look inside ignored paths.",
+    schema: {
+      pattern: { type: "string", description: "glob pattern, e.g. src/**/*.js" },
+      maxResults: { type: "number", description: "cap on returned paths, default 200", optional: true }
+    },
+    execute: async ({ pattern, maxResults = MAX_RESULTS }) => {
+      recorder.extra({ title: pattern });
+      let files = await ripgrepGlob(pattern, cwd);
+      if (files === null) {
+        files = await fg(pattern, {
+          cwd,
+          dot: false,
+          ignore: ["**/node_modules/**", "**/.git/**"]
+        });
+      }
+      recorder.extra({ fullOutput: files.join("\n") });
+      return {
+        files: files.slice(0, maxResults),
+        totalFound: files.length,
+        truncated: files.length > maxResults
+      };
+    }
+  };
+}
+
+// src/core/tools/grep.js
+import { execFile as execFile2 } from "node:child_process";
+import { relative, resolve as resolve6 } from "node:path";
+var MAX_RESULTS2 = 200;
+function runRipgrep(args, cwd) {
+  return new Promise((done) => {
+    execFile2("rg", args, { cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
+      done(err && !stdout ? "" : stdout || "");
+    });
+  });
+}
+function createGrep({ cwd, recorder }) {
+  return {
+    name: "grep",
+    description: 'Search file contents with a regex using ripgrep. mode "content" returns matching lines, "files" returns matching file paths, "count" returns per-file match counts.',
+    schema: {
+      pattern: { type: "string", description: "regex pattern" },
+      path: { type: "string", description: "file or directory to search, defaults to the working directory", optional: true },
+      mode: { type: "string", enum: ["content", "files", "count"], optional: true },
+      glob: { type: "string", description: "filter files by glob, e.g. *.js", optional: true },
+      ignoreCase: { type: "boolean", optional: true },
+      context: { type: "number", description: "lines of context around matches", optional: true },
+      multiline: { type: "boolean", description: "allow patterns to span lines", optional: true },
+      limit: { type: "number", description: "max results, default 200", optional: true }
+    },
+    execute: async ({ pattern, path, mode = "content", glob, ignoreCase, context, multiline, limit = MAX_RESULTS2 }) => {
+      recorder.extra({ title: pattern });
+      const args = ["--no-heading", "--color=never", "--max-columns", "500"];
+      if (mode === "files") args.push("--files-with-matches");
+      else if (mode === "count") args.push("--count");
+      else args.push("--line-number");
+      if (ignoreCase) args.push("--ignore-case");
+      if (multiline) args.push("--multiline", "--multiline-dotall");
+      if (glob) args.push("--glob", glob);
+      if (mode === "content" && context) args.push("-C", String(context));
+      args.push(pattern.startsWith("-") ? "-e" : "--", pattern);
+      args.push(path ? resolve6(cwd, path) : cwd);
+      const stdout = await runRipgrep(args, cwd);
+      const lines = stdout.split("\n").filter(Boolean);
+      recorder.extra({ fullOutput: lines.join("\n") });
+      const relativize = (line) => {
+        if (mode === "files") return relative(cwd, line);
+        const m = line.match(/^(\/[^:]+):(.*)$/);
+        return m ? `${relative(cwd, m[1])}:${m[2]}` : line;
+      };
+      const results = lines.map(relativize).slice(0, limit);
+      return { results, mode, totalMatches: lines.length, truncated: lines.length > limit };
+    }
+  };
+}
+
+// src/core/tools/index.js
+function createToolset({ cwd, tracker, skills, mcpTools = [], signal }) {
+  const recorder = createRecorder();
+  const deps = { cwd, recorder, tracker, signal };
+  const local = [
+    createRead(deps),
+    createWrite(deps),
+    createEdit(deps),
+    createBash(deps),
+    createGlob(deps),
+    createGrep(deps)
+  ];
+  if (skills?.list().length) {
+    local.push({
+      name: "skill",
+      description: `Load a skill by name and follow its instructions. Available skills:
+${skills.list().map((s) => `- ${s.name}: ${s.description}`).join("\n")}`,
+      schema: {
+        name: { type: "string", description: "skill name" }
+      },
+      execute: async ({ name }) => {
+        recorder.extra({ title: name });
+        const body = await skills.load(name);
+        if (!body) throw new Error(`no skill named ${name}`);
+        return { instructions: body };
+      }
+    });
+  }
+  const tools = [...local, ...mcpTools].map((tool) => ({
+    ...tool,
+    execute: recorded(recorder, tool.name, tool.execute)
+  }));
+  return { tools, recorder };
+}
+
+// src/core/rewind.js
+import { readFile as readFile11, writeFile as writeFile5 } from "node:fs/promises";
+async function readCurrent(path) {
+  try {
+    return await readFile11(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function revertEdits(edits) {
+  const reverted = [];
+  const skipped = [];
+  for (const edit of [...edits].reverse()) {
+    const { path, before, after } = edit.revert;
+    const current = await readCurrent(path);
+    if (current === after) {
+      await writeFile5(path, before, "utf-8");
+      reverted.push(edit.callId);
+    } else {
+      skipped.push({ path, callId: edit.callId, reason: "file changed since edit" });
+    }
+  }
+  return { reverted, skipped };
+}
+async function reapplyEdits(edits) {
+  const reapplied = [];
+  const skipped = [];
+  for (const edit of edits) {
+    const { path, before, after } = edit.revert;
+    const current = await readCurrent(path);
+    if (current === before) {
+      await writeFile5(path, after, "utf-8");
+      reapplied.push(edit.callId);
+    } else {
+      skipped.push({ path, callId: edit.callId, reason: "file changed since revert" });
+    }
+  }
+  return { reapplied, skipped };
+}
+
+// src/core/system-prompt.js
+import { platform } from "node:os";
+function buildSystemPrompt({ cwd, contextFiles = [], skills = [] }) {
+  const parts = [
+    `You are pico, a coding agent running in a terminal.`,
+    ``,
+    `Working directory: ${cwd}`,
+    `Platform: ${platform()}`,
+    `Date: ${(/* @__PURE__ */ new Date()).toDateString()}`,
+    ``,
+    `Use the available tools to read, search, and modify files, and to run commands.`,
+    `Prefer reading files before editing them. Keep edits minimal and precise.`,
+    `When a tool result includes context_from_agents_md, treat it as project instructions that apply from that point on.`,
+    `Be direct and concise. Use markdown. Never invent file contents you have not read.`
+  ];
+  if (skills.length) {
+    parts.push(
+      ``,
+      `Skills available via the skill tool (load one when its description matches the task):`,
+      ...skills.map((s) => `- ${s.name}: ${s.description}`)
+    );
+  }
+  for (const file of contextFiles) {
+    parts.push(``, `Project instructions from ${file.path}:`, ``, file.content.trim());
+  }
+  return parts.join("\n");
+}
+
+// src/core/export.js
+function transcriptToMarkdown(transcript, { title = "pico session" } = {}) {
+  const parts = [`# ${title}`, ""];
+  for (const item of transcript) {
+    if (item.kind === "user") {
+      parts.push("## You", "", item.text, "");
+    } else if (item.kind === "assistant") {
+      parts.push(item.interrupted ? `${item.text}
+
+*(interrupted)*` : item.text, "");
+    } else if (item.kind === "tool") {
+      const label = item.diff ? ` (+${item.diff.additions} -${item.diff.deletions})` : "";
+      parts.push(`> ${item.status === "reverted" ? "\u21A9" : "\u2713"} \`${item.name}\` ${item.title}${label}`, "");
+    } else if (item.kind === "summary") {
+      parts.push(`> summary: ${item.text}`, "");
+    }
+  }
+  return parts.join("\n");
+}
+
+// src/ui/fuzzy.js
+function fuzzyScore(query, path) {
+  const q = query.toLowerCase();
+  const s = path.toLowerCase();
+  if (!q) return 0;
+  let best = -1;
+  for (let start = s.indexOf(q[0]); start !== -1; start = s.indexOf(q[0], start + 1)) {
+    let score = 0;
+    let prev = -1;
+    let matched = true;
+    for (const ch of q) {
+      const i = s.indexOf(ch, prev === -1 ? start : prev + 1);
+      if (i === -1) {
+        matched = false;
+        break;
+      }
+      if (prev !== -1 && i === prev + 1) score += 3;
+      if (i === 0 || "/.-_".includes(s[i - 1])) score += 2;
+      score += 1;
+      prev = i;
+    }
+    if (matched && score > best) best = score;
+  }
+  if (best < 0) return -1;
+  const base = s.slice(s.lastIndexOf("/") + 1);
+  if (base.startsWith(q)) best += 8;
+  else if (base.includes(q)) best += 5;
+  else if (s.includes(q)) best += 3;
+  return best - s.length / 100;
+}
+
+// src/ui/completion.js
+function completionContext({ value, resolve: resolve7 }) {
+  if (value.includes("\n")) return null;
+  const m = value.match(/^\/(\S+) (.*)$/);
+  if (!m) return null;
+  const source = resolve7(m[1].toLowerCase());
+  if (!source || source.length === 0) return null;
+  const tokens = m[2].split(" ");
+  const partial = tokens[tokens.length - 1];
+  const matches = source.map((s) => [fuzzyScore(partial, s), s]).filter(([score]) => score >= 0).sort((a, b) => b[0] - a[0]).map(([, s]) => s);
+  return { partial, matches, start: value.length - partial.length };
+}
+function applyCompletion(value, ctx, candidate) {
+  return value.slice(0, ctx.start) + candidate + " ";
+}
+
+// src/ui/attachments.js
+import { existsSync as existsSync3 } from "node:fs";
+var MEDIA_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp"
+};
+function mediaTypeFor(path) {
+  return MEDIA_TYPES[path.split(".").pop().toLowerCase()] || null;
+}
+function unquote(token) {
+  if (/^'.*'$/.test(token) || /^".*"$/.test(token)) return token.slice(1, -1);
+  return token.replace(/\\ /g, " ");
+}
+function toPath(token) {
+  const raw = unquote(token.trim());
+  if (raw.startsWith("file://")) {
+    try {
+      return decodeURIComponent(raw.slice("file://".length));
+    } catch {
+      return null;
+    }
+  }
+  return raw;
+}
+function extractImagePaths(text, exists = existsSync3) {
+  const tokens = text.trim().match(/'[^']*'|"[^"]*"|(?:\\ |\S)+/g);
+  if (!tokens || tokens.length === 0) return [];
+  const paths = [];
+  for (const token of tokens) {
+    const path = toPath(token);
+    if (!path || !path.startsWith("/")) return [];
+    if (!mediaTypeFor(path) || !exists(path)) return [];
+    paths.push(path);
+  }
+  return paths;
+}
+function buildUserContent(text, attachments) {
+  const parts = [];
+  let last = 0;
+  const used = [];
+  for (const match of text.matchAll(/\[Image #\d+\]/g)) {
+    const attachment = attachments.get(match[0]);
+    if (!attachment) continue;
+    const before = text.slice(last, match.index);
+    if (before) parts.push({ type: "text", text: before });
+    parts.push({
+      type: "image",
+      source: { kind: "path", path: attachment.path, mediaType: attachment.mediaType }
+    });
+    used.push(match[0]);
+    last = match.index + match[0].length;
+  }
+  if (parts.length === 0) return { content: text, used };
+  const tail = text.slice(last);
+  if (tail) parts.push({ type: "text", text: tail });
+  return { content: parts, used };
+}
+
+// src/ui/files.js
+import { execFile as execFile3 } from "node:child_process";
+import fg2 from "fast-glob";
+var MAX_FILES = 5e3;
+var TTL = 5e3;
+var cached = { at: 0, cwd: null, files: [] };
+function ripgrepFiles(cwd) {
+  return new Promise((resolve7) => {
+    execFile3("rg", ["--files", "--sortr=modified"], { cwd, maxBuffer: 50 * 1024 * 1024 }, (err, stdout) => {
+      resolve7(err && !stdout ? null : stdout.split("\n").filter(Boolean));
+    });
+  });
+}
+async function listFiles(cwd) {
+  if (cached.cwd === cwd && Date.now() - cached.at < TTL) return cached.files;
+  let files = await ripgrepFiles(cwd);
+  if (!files) {
+    files = await fg2("**/*", {
+      cwd,
+      onlyFiles: true,
+      dot: false,
+      ignore: ["**/node_modules/**", "**/.git/**"]
+    }).catch(() => []);
+  }
+  cached = { at: Date.now(), cwd, files: files.slice(0, MAX_FILES) };
+  return cached.files;
+}
+
+// src/ui/highlight.js
+import { codeToANSI } from "@shikijs/cli";
+import { createSignal } from "@trendr/core";
+var LANGS = {
+  js: "js",
+  mjs: "js",
+  cjs: "js",
+  jsx: "jsx",
+  ts: "ts",
+  tsx: "tsx",
+  json: "json",
+  jsonl: "json",
+  md: "md",
+  py: "python",
+  rb: "ruby",
+  go: "go",
+  rs: "rust",
+  c: "c",
+  h: "c",
+  cpp: "cpp",
+  java: "java",
+  css: "css",
+  html: "html",
+  vue: "vue",
+  sh: "bash",
+  bash: "bash",
+  zsh: "bash",
+  yml: "yaml",
+  yaml: "yaml",
+  toml: "toml",
+  sql: "sql",
+  svelte: "svelte"
+};
+function langForPath(path) {
+  const ext = String(path).split(".").pop().toLowerCase();
+  return LANGS[ext] || "txt";
+}
+var cache = /* @__PURE__ */ new Map();
+var pending = /* @__PURE__ */ new Set();
+var failed = /* @__PURE__ */ new Set();
+var [version, setVersion] = createSignal(0);
+var highlightVersion = version;
+function highlight(code, lang) {
+  const safeLang = lang && !failed.has(lang) ? lang : "txt";
+  return code.split("\n").map((line) => {
+    const key = `${safeLang}
+${line}`;
+    if (cache.has(key)) return cache.get(key);
+    warm(line, safeLang, key);
+    return line;
+  }).join("\n");
+}
+function warm(line, lang, key) {
+  if (pending.has(key)) return;
+  pending.add(key);
+  codeToANSI(line, lang, "nord").then((ansi) => cache.set(key, ansi.replace(/\n$/, ""))).catch(() => {
+    failed.add(lang);
+    cache.set(key, line);
+  }).finally(() => {
+    pending.delete(key);
+    setVersion((v) => v + 1);
+  });
+}
+
+// src/ui/transcript.jsx
+import { Diff, Markdown, Spinner } from "@trendr/core";
+
+// src/ui/theme.js
+import { createSignal as createSignal2 } from "@trendr/core";
+var DEFAULT_ACCENT = "#6BE795";
+var [accentValue, setAccentValue] = createSignal2(DEFAULT_ACCENT);
+var accent = accentValue;
+function setAccent(color) {
+  setAccentValue(color || DEFAULT_ACCENT);
+}
+var FG = "#e5e7eb";
+var FG_SOFT = "#9ca3af";
+var MUTED = "#6b7280";
+var FAINT = "#4b5563";
+var PANEL_BG = "#1e1e22";
+var SELECT_BG = "#374151";
+var RED = "#f87171";
+
+// src/ui/transcript.jsx
+import { jsx, jsxs } from "@trendr/core/jsx-runtime";
+function uiTitle(name, args = {}) {
+  if (args.path) return args.path;
+  if (args.command) return args.command;
+  if (args.pattern) return args.pattern;
+  if (args.name) return args.name;
+  const raw = JSON.stringify(args);
+  return raw.length > 60 ? raw.slice(0, 60) + "\u2026" : raw;
+}
+function ToolCard({ name, title, status, diff, revert, fullOutput, error, verbose }) {
+  const running = status === "running";
+  const interrupted = status === "interrupted";
+  const reverted = status === "reverted";
+  const failed2 = status === "error";
+  const outLines = fullOutput ? fullOutput.split("\n") : null;
+  const info = running ? "running" : interrupted ? "interrupted" : reverted ? "reverted" : failed2 ? "failed" : diff ? `+${diff.additions} -${diff.deletions}` : outLines ? `${outLines.length} ${outLines.length === 1 ? "line" : "lines"} \xB7 ctrl+o` : "done";
+  return /* @__PURE__ */ jsxs("box", { style: { flexDirection: "column", paddingX: 2 }, children: [
+    /* @__PURE__ */ jsx("text", { children: " " }),
+    /* @__PURE__ */ jsxs("box", { style: { flexDirection: "row" }, children: [
+      running ? /* @__PURE__ */ jsx(Spinner, { color: accent() }) : /* @__PURE__ */ jsx("text", { style: { color: interrupted || failed2 ? RED : reverted ? MUTED : accent() }, children: interrupted ? "\u2717" : failed2 ? "\u2717" : reverted ? "\u21A9" : "\u2713" }),
+      /* @__PURE__ */ jsx("text", { children: " " }),
+      /* @__PURE__ */ jsx("text", { style: { color: MUTED }, children: `${name.padEnd(5)} ` }),
+      /* @__PURE__ */ jsx("box", { style: { flexGrow: 1, height: 1 }, children: /* @__PURE__ */ jsx("text", { style: { overflow: "truncate", color: FG }, children: title || name }) }),
+      /* @__PURE__ */ jsx("text", { style: { color: FAINT }, children: `  ${info}` })
+    ] }),
+    failed2 && error && /* @__PURE__ */ jsx("text", { style: { color: MUTED, overflow: "truncate" }, children: `  ${error}` }),
+    revert && !running && !reverted && /* @__PURE__ */ jsx("box", { style: { flexDirection: "column", height: Math.min((diff?.hunks || []).reduce((a, h) => a + h.lines.length, 2) + 1, 12), marginTop: 1 }, children: /* @__PURE__ */ jsx(
+      Diff,
+      {
+        before: revert.before,
+        after: revert.after,
+        language: langForPath(revert.path),
+        highlight,
+        focused: false,
+        scrollbar: false
+      }
+    ) }),
+    outLines && verbose && !running && /* @__PURE__ */ jsxs("box", { style: { flexDirection: "column", bg: PANEL_BG, paddingX: 1, marginTop: 1 }, children: [
+      /* @__PURE__ */ jsx("text", { style: { color: MUTED }, children: `$ ${title}` }),
+      outLines.slice(0, 200).map((line, i) => /* @__PURE__ */ jsx("text", { style: { color: FG_SOFT, overflow: "truncate" }, children: line || " " }, i)),
+      outLines.length > 200 && /* @__PURE__ */ jsx("text", { style: { color: FAINT }, children: `\u2026 ${outLines.length - 200} more lines` })
+    ] })
+  ] });
+}
+function Banner({ version: version2, cwd, modelName }) {
+  return /* @__PURE__ */ jsxs("box", { style: { flexDirection: "row", paddingX: 2, marginTop: 1 }, children: [
+    /* @__PURE__ */ jsxs("box", { style: { flexDirection: "column" }, children: [
+      /* @__PURE__ */ jsx("text", { style: { color: accent() }, children: "(\\_/)" }),
+      /* @__PURE__ */ jsx("text", { style: { color: accent() }, children: "(\u2022\u1D17\u2022)" })
+    ] }),
+    /* @__PURE__ */ jsxs("box", { style: { flexDirection: "column" }, children: [
+      /* @__PURE__ */ jsxs("box", { style: { flexDirection: "row" }, children: [
+        /* @__PURE__ */ jsx("text", { style: { bold: true, color: accent() }, children: "  pico" }),
+        /* @__PURE__ */ jsx("text", { style: { color: FAINT }, children: ` v${version2} \xB7 ${modelName}` })
+      ] }),
+      /* @__PURE__ */ jsx("text", { style: { color: MUTED }, children: `  ${cwd}` })
+    ] })
+  ] });
+}
+function Message({ item, verbose }) {
+  if (item.kind === "tool") {
+    return /* @__PURE__ */ jsx(ToolCard, { ...item, verbose });
+  }
+  if (item.kind === "summary") {
+    return /* @__PURE__ */ jsxs("box", { style: { flexDirection: "column", paddingX: 2 }, children: [
+      /* @__PURE__ */ jsx("text", { children: " " }),
+      /* @__PURE__ */ jsx("text", { style: { color: MUTED, italic: true }, children: `\u2726 summary: ${item.text.replace(/\n/g, " ").slice(0, 500)}` })
+    ] });
+  }
+  if (item.kind === "skill") {
+    return /* @__PURE__ */ jsxs("box", { style: { flexDirection: "column", paddingX: 2 }, children: [
+      /* @__PURE__ */ jsx("text", { children: " " }),
+      /* @__PURE__ */ jsx("text", { style: { color: MUTED, italic: true }, children: `\u2726 skill: ${item.name}` })
+    ] });
+  }
+  if (item.kind === "user") {
+    return /* @__PURE__ */ jsxs("box", { style: { flexDirection: "column" }, children: [
+      /* @__PURE__ */ jsx("text", { children: " " }),
+      /* @__PURE__ */ jsx("box", { style: { bg: PANEL_BG, flexDirection: "column", paddingX: 2, paddingY: 1 }, children: /* @__PURE__ */ jsx("text", { style: { color: "#f9fafb" }, children: item.text }) })
+    ] });
+  }
+  const text = item.interrupted ? `${item.text} *(interrupted)*` : item.text;
+  return /* @__PURE__ */ jsxs("box", { style: { flexDirection: "column", paddingX: 2 }, children: [
+    /* @__PURE__ */ jsx("text", { children: " " }),
+    /* @__PURE__ */ jsx(Markdown, { text, highlight, codeBg: null })
+  ] });
+}
+
+// src/ui/help.jsx
+import { Markdown as Markdown2, ScrollBox, useInput } from "@trendr/core";
+import { jsx as jsx2, jsxs as jsxs2 } from "@trendr/core/jsx-runtime";
+var HELP_TEXT = (commands) => `pico is a coding agent in your terminal. It reads, edits, and searches files, runs commands, and streams its work into this transcript.
+
+## Commands
+
+Type \`/\` in the composer to filter these as you type.
+
+${commands.map((c) => `- \`/${c.name}\` - ${c.desc}`).join("\n")}
+
+Two kinds of user-defined entries join this menu:
+
+- **commands** (\`~/.pico/commands/<name>.md\` or \`.pico/commands/<name>.md\`): prompt templates you invoke as \`/<name> [args]\`. \`$ARGUMENTS\` in the body is replaced with whatever follows the command; without a placeholder, args are appended. The model never sees these until you run one.
+- **skills** (\`~/.pico/skills/<name>/SKILL.md\` or \`.pico/skills/<name>/SKILL.md\`): capabilities with a name and description. You can invoke them like commands, and the agent can also discover and load them itself via the skill tool.
+
+In the MCP panel: space or enter toggles a server, \`t\` lists its tools, \`r\` reconnects, \`a\` adds, \`d\` removes. Unfiltered lists (effort, rewind options, MCP) also move with \`j\`/\`k\` and jump with \`g\`/\`G\`.
+
+## Composer
+
+- \`enter\` sends, \`shift+enter\` inserts a newline
+- \`@\` opens a fuzzy file picker; enter inserts the selected path
+- drag an image file into the terminal to attach it: it appears inline as \`[Image #N]\`, exactly where your cursor is, so images can sit between sentences; backspace after one removes the whole attachment
+- \`tab\` after a command argument completes it: \`/model fla<tab>\`, \`/color <tab>\`, \`/effort <tab>\`; skill and command arguments complete file paths. Keep typing to narrow, tab or enter inserts
+- \`up\` and \`down\` on an empty composer recall messages you already sent
+- \`ctrl+r\` fuzzy-searches your prompt history with a preview; enter puts the match back in the composer
+- \`ctrl+s\` opens the session picker (same as \`/resume\`); \`ctrl+t\` opens the model picker
+- \`ctrl+p\` switches projects: pick one and pico jumps to its most recent session, changing the working directory, tools, context, and MCP servers to match; \`/new\` starts a fresh session in the current project
+- \`ctrl+b\` cycles thinking effort (default, low, medium, high, max) on models that support it; \`/effort\` opens the full picker
+- inside a search panel, \`ctrl+s\` cycles the scope instead: this session, this project, or everywhere
+- \`/rewind\` restores the conversation to an earlier message; a rewind can be undone with \`ctrl+z\`
+- messages sent while the agent is responding queue up above the composer and are delivered as one message when the turn finishes; \`up\` pulls them back for editing
+- \`esc\` interrupts a streaming response, or clears the composer when idle
+
+## Moving around
+
+- \`tab\` switches focus between the transcript and the composer
+- with the transcript focused, \`up\`/\`down\`/\`j\`/\`k\` scroll and \`g\`/\`G\` jump to the ends
+- \`ctrl+o\` expands and collapses tool output in the transcript
+- the mouse wheel scrolls; click-drag selects text and copies it on release
+- \`ctrl+c\` twice exits
+
+## Context
+
+pico reads AGENTS.md files automatically: a global one from ~/.pico, then every ancestor of your working directory up to the git root. Deeper files win. AGENTS.md files in subdirectories load lazily the first time a tool touches that subtree.
+
+Sessions are stored under ~/.pico as jsonl event logs; \`/resume\` folds one back into exactly this view.
+
+---
+
+*esc takes you back to the conversation*`;
+function Help({ commands, onClose }) {
+  useInput((event) => {
+    if (event.key === "escape") {
+      onClose();
+      event.stopPropagation();
+    }
+  });
+  return /* @__PURE__ */ jsxs2("box", { style: { flexDirection: "column", height: "100%", paddingX: 2, paddingY: 1 }, children: [
+    /* @__PURE__ */ jsxs2("box", { style: { flexDirection: "row" }, children: [
+      /* @__PURE__ */ jsx2("text", { style: { color: accent(), bold: true }, children: "pico \xB7 help" }),
+      /* @__PURE__ */ jsx2("box", { style: { flexGrow: 1 } }),
+      /* @__PURE__ */ jsx2("text", { style: { color: FAINT }, children: "\u2191\u2193 scroll \xB7 esc back" })
+    ] }),
+    /* @__PURE__ */ jsx2("text", { children: " " }),
+    /* @__PURE__ */ jsx2(ScrollBox, { style: { flexGrow: 1 }, focused: true, scrollbar: true, children: /* @__PURE__ */ jsx2(Markdown2, { text: HELP_TEXT(commands), codeBg: null }) })
+  ] });
+}
+
+// src/ui/panels.jsx
+import { createSignal as createSignal3, Menu, PickList, ScrollBox as ScrollBox2, TextInput, useInput as useInput2 } from "@trendr/core";
+import { jsx as jsx3, jsxs as jsxs3 } from "@trendr/core/jsx-runtime";
+function timeAgo(at) {
+  const s = Math.max(0, Math.floor((Date.now() - at) / 1e3));
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+function PanelFrame({ title, hint, right, children }) {
+  return /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "column", paddingX: 2, marginTop: 1 }, children: [
+    /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row" }, children: [
+      /* @__PURE__ */ jsx3("text", { style: { color: accent(), bold: true }, children: title }),
+      /* @__PURE__ */ jsx3("box", { style: { flexGrow: 1 } }),
+      right
+    ] }),
+    /* @__PURE__ */ jsx3("text", { style: { color: MUTED }, children: hint }),
+    children
+  ] });
+}
+function ScopeTabs({ scopes, active }) {
+  return /* @__PURE__ */ jsx3("box", { style: { flexDirection: "row" }, children: scopes.map((s, i) => /* @__PURE__ */ jsx3("text", { style: { color: i === active ? accent() : FAINT, bold: i === active }, children: `${i > 0 ? "  " : ""}${s}` }, s)) });
+}
+function ModelPanel({ models: models2, current, defaultName, focused, onPick, onPickDefault, onClose }) {
+  const [cursor, setCursor] = createSignal3(models2[0] || null);
+  useInput2((event) => {
+    if (!focused) return;
+    if (event.ctrl && event.key === "s" && cursor()) {
+      onPickDefault(cursor());
+      event.stopPropagation();
+    }
+  });
+  return /* @__PURE__ */ jsx3(PanelFrame, { title: "Select model", hint: "type to filter \xB7 \u2191\u2193 to move \xB7 enter for this session \xB7 ctrl+s to make it the default \xB7 esc to keep current", children: /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", height: 12, marginTop: 1 }, children: /* @__PURE__ */ jsx3(
+    PickList,
+    {
+      items: models2,
+      focused,
+      placeholder: "filter models...",
+      filter: (q, m) => fuzzyScore(q, m.name) >= 0,
+      onCursorChange: setCursor,
+      onSubmit: onPick,
+      onCancel: onClose,
+      scrollbar: true,
+      gap: 1,
+      itemHeight: 2,
+      scrolloff: 1,
+      renderItem: (m, { selected, focused: f }) => /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "column", bg: selected ? f ? accent() : SELECT_BG : null, paddingX: 1 }, children: [
+        /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row" }, children: [
+          /* @__PURE__ */ jsx3("text", { style: { bold: true, color: selected ? "black" : FG }, children: m.name }),
+          m.name === current && /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : accent() }, children: " \u2713" }),
+          m.name === defaultName && /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : MUTED }, children: " \xB7 default" }),
+          /* @__PURE__ */ jsx3("box", { style: { flexGrow: 1 } }),
+          /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : MUTED }, children: `$${m.price.in} in \xB7 $${m.price.out} out` })
+        ] }),
+        /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : MUTED }, children: m.desc })
+      ] })
+    }
+  ) }) });
+}
+function HistoryPanel({ prompts, scopes, scopeIndex, focused, onPick, onClose }) {
+  const [preview, setPreview] = createSignal3(prompts[0] || null);
+  const [query, setQuery] = createSignal3("");
+  const anyMatch = prompts.some((p) => fuzzyScore(query(), p.text) >= 0);
+  return /* @__PURE__ */ jsx3(
+    PanelFrame,
+    {
+      title: "Search prompts",
+      hint: "type to filter \xB7 \u2191\u2193 to move \xB7 ctrl+s scope \xB7 enter to edit \xB7 esc to close",
+      right: /* @__PURE__ */ jsx3(ScopeTabs, { scopes, active: scopeIndex }),
+      children: /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row", height: 12, marginTop: 1, gap: 2 }, children: [
+        /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", width: "50%" }, children: /* @__PURE__ */ jsx3(
+          PickList,
+          {
+            items: prompts,
+            focused,
+            placeholder: "filter prompts...",
+            filter: (q, p) => fuzzyScore(q, p.text) >= 0,
+            onChange: setQuery,
+            onCursorChange: (p) => setPreview(p),
+            onSubmit: (p) => onPick(p.text),
+            onCancel: onClose,
+            scrollbar: true,
+            gap: 1,
+            renderItem: (p, { selected, focused: f }) => /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row", bg: selected ? f ? accent() : SELECT_BG : null, paddingX: 1 }, children: [
+              /* @__PURE__ */ jsx3("box", { style: { flexGrow: 1, height: 1 }, children: /* @__PURE__ */ jsx3("text", { style: { overflow: "truncate", color: selected ? "black" : FG }, children: p.text.replace(/\n/g, " ") }) }),
+              /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : FAINT, dim: !selected }, children: `  ${timeAgo(p.at)}` })
+            ] })
+          }
+        ) }),
+        /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", flexGrow: 1, bg: PANEL_BG, paddingX: 1 }, children: anyMatch && preview() ? /* @__PURE__ */ jsx3("text", { style: { color: FG }, children: preview().text.slice(0, 2e3) }) : /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "no matching prompts" }) })
+      ] })
+    }
+  );
+}
+function RewindPickPanel({ entries, stats, focused, onPick, onClose }) {
+  const [preview, setPreview] = createSignal3(entries[0] || null);
+  return /* @__PURE__ */ jsx3(PanelFrame, { title: "Rewind to a message", hint: "type to filter \xB7 \u2191\u2193 to move \xB7 enter to choose \xB7 esc to close", children: /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row", height: 12, marginTop: 1, gap: 2 }, children: [
+    /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", width: "50%" }, children: /* @__PURE__ */ jsx3(
+      PickList,
+      {
+        items: entries,
+        focused,
+        placeholder: "filter messages...",
+        filter: (q, m) => fuzzyScore(q, m.text) >= 0,
+        onCursorChange: (m) => setPreview(m),
+        onSubmit: onPick,
+        onCancel: onClose,
+        scrollbar: true,
+        gap: 1,
+        renderItem: (m, { selected, focused: f }) => /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row", bg: selected ? f ? accent() : SELECT_BG : null, paddingX: 1 }, children: [
+          /* @__PURE__ */ jsx3("box", { style: { flexGrow: 1, height: 1 }, children: /* @__PURE__ */ jsx3("text", { style: { overflow: "truncate", color: selected ? "black" : FG }, children: m.text.replace(/\n/g, " ") }) }),
+          /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : FAINT, dim: !selected }, children: `  ${stats(m.index).msgs} after` })
+        ] })
+      }
+    ) }),
+    /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", flexGrow: 1, bg: PANEL_BG, paddingX: 1 }, children: preview() ? /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "column" }, children: [
+      /* @__PURE__ */ jsx3("text", { style: { color: FG }, children: preview().text.slice(0, 2e3) }),
+      /* @__PURE__ */ jsx3("text", { children: " " }),
+      /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: `rewinding here drops ${stats(preview().index).msgs} entries` }),
+      stats(preview().index).edits.map((m, i) => /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: `  \u21A9 ${m.title}` }, i))
+    ] }) : /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "no matching messages" }) })
+  ] }) });
+}
+function RewindActionPanel({ target, options, focused, onSubmit, onBack }) {
+  return /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "column", paddingX: 2, marginTop: 1 }, children: [
+    /* @__PURE__ */ jsx3("text", { style: { color: accent(), bold: true }, children: "Rewind options" }),
+    /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row" }, children: [
+      /* @__PURE__ */ jsx3("text", { style: { color: MUTED }, children: "to: " }),
+      /* @__PURE__ */ jsx3("box", { style: { flexGrow: 1, height: 1 }, children: /* @__PURE__ */ jsx3("text", { style: { overflow: "truncate", color: FG_SOFT }, children: target.text.replace(/\n/g, " ") }) })
+    ] }),
+    /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", marginTop: 1 }, children: /* @__PURE__ */ jsx3(
+      Menu,
+      {
+        items: options,
+        focused,
+        maxVisible: 4,
+        itemHeight: 2,
+        gap: 1,
+        vimKeys: true,
+        onSubmit,
+        onCancel: onBack,
+        renderItem: (o, { active }) => /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "column" }, children: [
+          /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row" }, children: [
+            /* @__PURE__ */ jsx3("text", { style: { color: accent() }, children: active ? "\u203A " : "  " }),
+            /* @__PURE__ */ jsx3("text", { style: { color: active ? accent() : FG }, children: o.label })
+          ] }),
+          /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: `  ${o.desc}` })
+        ] })
+      }
+    ) }),
+    /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "enter to confirm \xB7 esc to pick a different message" })
+  ] });
+}
+function useEscape(focused, onClose) {
+  useInput2((event) => {
+    if (!focused()) return;
+    if (event.key === "escape") {
+      onClose();
+      event.stopPropagation();
+    }
+  });
+}
+function ResumePanel({ sessions, scopes, scopeIndex, loading, focused, onPick, onClose }) {
+  const [preview, setPreview] = createSignal3(sessions[0] || null);
+  useEscape(() => focused, onClose);
+  return /* @__PURE__ */ jsx3(
+    PanelFrame,
+    {
+      title: "Resume a session",
+      hint: "type to filter \xB7 \u2191\u2193 to move \xB7 ctrl+s scope \xB7 enter to resume \xB7 esc to close",
+      right: /* @__PURE__ */ jsx3(ScopeTabs, { scopes, active: scopeIndex }),
+      children: /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row", height: 12, marginTop: 1, gap: 2 }, children: [
+        /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", width: "50%" }, children: loading ? /* @__PURE__ */ jsx3("text", { style: { color: MUTED }, children: "loading sessions..." }) : sessions.length === 0 ? /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "no sessions here yet" }) : /* @__PURE__ */ jsx3(
+          PickList,
+          {
+            items: sessions,
+            focused: focused && !loading,
+            placeholder: "filter sessions...",
+            filter: (q, s) => fuzzyScore(q, s.title) >= 0,
+            onCursorChange: (s) => setPreview(s),
+            onSubmit: onPick,
+            onCancel: onClose,
+            scrollbar: true,
+            gap: 1,
+            renderItem: (s, { selected, focused: f }) => /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row", bg: selected ? f ? accent() : SELECT_BG : null, paddingX: 1 }, children: [
+              s.color && /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : s.color }, children: "\u25AA " }),
+              /* @__PURE__ */ jsx3("box", { style: { flexGrow: 1, height: 1 }, children: /* @__PURE__ */ jsx3("text", { style: { overflow: "truncate", color: selected ? "black" : FG }, children: s.title.replace(/\n/g, " ") }) }),
+              /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : FAINT, dim: !selected }, children: `  ${timeAgo(s.at)}` })
+            ] })
+          }
+        ) }),
+        /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", flexGrow: 1, bg: PANEL_BG, paddingX: 1 }, children: preview() ? /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "column" }, children: [
+          /* @__PURE__ */ jsx3("text", { style: { color: FG }, children: preview().title.slice(0, 500) }),
+          /* @__PURE__ */ jsx3("text", { children: " " }),
+          /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: `${preview().turns} ${preview().turns === 1 ? "turn" : "turns"} \xB7 ${timeAgo(preview().at)}` }),
+          /* @__PURE__ */ jsx3("text", { style: { color: FAINT, overflow: "truncate" }, children: preview().header.root })
+        ] }) : /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "no sessions" }) })
+      ] })
+    }
+  );
+}
+function EffortPanel({ levels, current, defaultLevel, focused, onPick, onPickDefault, onClose }) {
+  const [cursor, setCursor] = createSignal3(0);
+  const items = levels;
+  useInput2((event) => {
+    if (!focused) return;
+    if (event.ctrl && event.key === "s") {
+      onPickDefault(items[cursor()]);
+      event.stopPropagation();
+    }
+  });
+  const label = (l) => l.key === null ? "default" : l.key;
+  return /* @__PURE__ */ jsx3(PanelFrame, { title: "Thinking effort", hint: "j/k or \u2191\u2193 to move \xB7 enter for this session \xB7 ctrl+s to make it the default \xB7 esc to keep current", children: /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", marginTop: 1 }, children: /* @__PURE__ */ jsx3(
+    Menu,
+    {
+      items,
+      selected: cursor(),
+      onSelect: setCursor,
+      focused,
+      maxVisible: 5,
+      vimKeys: true,
+      onSubmit: onPick,
+      onCancel: onClose,
+      renderItem: (l, { active }) => /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row" }, children: [
+        /* @__PURE__ */ jsx3("text", { style: { color: accent() }, children: active ? "\u203A " : "  " }),
+        /* @__PURE__ */ jsx3("text", { style: { color: active ? accent() : FG }, children: label(l).padEnd(10) }),
+        /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: l.desc }),
+        l.key === current && /* @__PURE__ */ jsx3("text", { style: { color: active ? accent() : MUTED }, children: "  \u2713" }),
+        l.key === defaultLevel && /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "  \xB7 default" })
+      ] })
+    }
+  ) }) });
+}
+function ProjectPanel({ projects, loading, focused, onPick, onClose }) {
+  const [preview, setPreview] = createSignal3(projects[0] || null);
+  useEscape(() => focused, onClose);
+  return /* @__PURE__ */ jsx3(PanelFrame, { title: "Switch project", hint: "type to filter \xB7 \u2191\u2193 to move \xB7 enter to jump to its last session \xB7 esc to close", children: /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row", height: 12, marginTop: 1, gap: 2 }, children: [
+    /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", width: "50%" }, children: loading ? /* @__PURE__ */ jsx3("text", { style: { color: MUTED }, children: "loading projects..." }) : projects.length === 0 ? /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "no known projects yet" }) : /* @__PURE__ */ jsx3(
+      PickList,
+      {
+        items: projects,
+        focused: focused && !loading,
+        placeholder: "filter projects...",
+        filter: (q, p) => fuzzyScore(q, p.path) >= 0,
+        onCursorChange: (p) => setPreview(p),
+        onSubmit: onPick,
+        onCancel: onClose,
+        scrollbar: true,
+        gap: 1,
+        renderItem: (p, { selected, focused: f }) => /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row", bg: selected ? f ? accent() : SELECT_BG : null, paddingX: 1 }, children: [
+          p.latest.color && /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : p.latest.color }, children: "\u25AA " }),
+          /* @__PURE__ */ jsx3("box", { style: { flexGrow: 1, height: 1 }, children: /* @__PURE__ */ jsx3("text", { style: { overflow: "truncate", color: selected ? "black" : FG }, children: p.path }) }),
+          /* @__PURE__ */ jsx3("text", { style: { color: selected ? "black" : FAINT, dim: !selected }, children: `  ${p.current ? "current \xB7 " : ""}${timeAgo(p.latest.at)}` })
+        ] })
+      }
+    ) }),
+    /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", flexGrow: 1, bg: PANEL_BG, paddingX: 1 }, children: preview() ? /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "column" }, children: [
+      /* @__PURE__ */ jsx3("text", { style: { color: FG, overflow: "truncate" }, children: preview().path }),
+      /* @__PURE__ */ jsx3("text", { children: " " }),
+      /* @__PURE__ */ jsx3("text", { style: { color: FG_SOFT, overflow: "truncate" }, children: `last: ${preview().latest.title.replace(/\n/g, " ")}` }),
+      /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: `${preview().count} ${preview().count === 1 ? "session" : "sessions"} \xB7 ${timeAgo(preview().latest.at)}` })
+    ] }) : /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "no projects" }) })
+  ] }) });
+}
+var MCP_STATUS = {
+  connected: { icon: "\u25AA", color: accent() },
+  connecting: { icon: "\u25CC", color: "#fbbf24" },
+  error: { icon: "\u2717", color: RED },
+  disabled: { icon: "\u25AB", color: FAINT },
+  idle: { icon: "\u25AB", color: MUTED }
+};
+function McpPanel({ servers, focused, onToggle, onReconnect, onRemove, onAdd, onClose }) {
+  const [adding, setAdding] = createSignal3(false);
+  const [index, setIndex] = createSignal3(0);
+  const [viewing, setViewing] = createSignal3(null);
+  useEscape(() => focused && !adding(), () => viewing() ? setViewing(null) : onClose());
+  const selected = () => servers[Math.min(index(), servers.length - 1)] || null;
+  const viewed = () => servers.find((s) => s.name === viewing()) || null;
+  if (viewing() && viewed()) {
+    const server = viewed();
+    const describe = (t) => t.description.replace(/^\[[^\]]*\]\s*/, "").trim() || "no description";
+    return /* @__PURE__ */ jsx3(
+      PanelFrame,
+      {
+        title: `MCP servers \xB7 ${server.name} \xB7 ${server.tools.length} ${server.tools.length === 1 ? "tool" : "tools"}`,
+        hint: "j/k or \u2191\u2193 to scroll \xB7 esc back to servers",
+        children: /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", height: 14, marginTop: 1 }, children: server.tools.length === 0 ? /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "no tools reported \xB7 is the server connected?" }) : /* @__PURE__ */ jsx3(ScrollBox2, { style: { flexGrow: 1 }, focused, scrollbar: true, children: server.tools.map((t, i) => /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "column", marginTop: i === 0 ? 0 : 1 }, children: [
+          /* @__PURE__ */ jsx3("text", { style: { color: accent() }, children: t.name }),
+          /* @__PURE__ */ jsx3("text", { style: { color: MUTED }, children: describe(t) })
+        ] }, t.name)) }) })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs3(
+    PanelFrame,
+    {
+      title: "MCP servers",
+      hint: adding() ? "format: <name> <command...>   e.g. fs npx -y @modelcontextprotocol/server-filesystem /tmp" : "space/enter toggle \xB7 t tools \xB7 r reconnect \xB7 a add \xB7 d remove \xB7 esc close",
+      children: [
+        /* @__PURE__ */ jsx3("box", { style: { flexDirection: "column", marginTop: 1 }, children: adding() ? /* @__PURE__ */ jsxs3("box", { style: { bg: PANEL_BG, flexDirection: "row", paddingX: 1 }, children: [
+          /* @__PURE__ */ jsx3("text", { style: { color: accent() }, children: "+ " }),
+          /* @__PURE__ */ jsx3(
+            TextInput,
+            {
+              focused,
+              placeholder: "name command args...",
+              clearOnSubmit: true,
+              onSubmit: (value) => {
+                const trimmed = value.trim();
+                const sep = trimmed.indexOf(" ");
+                if (sep > 0) {
+                  onAdd(trimmed.slice(0, sep), trimmed.slice(sep + 1).trim());
+                  setAdding(false);
+                }
+              },
+              onCancel: () => setAdding(false)
+            }
+          )
+        ] }) : servers.length === 0 ? /* @__PURE__ */ jsx3("text", { style: { color: FAINT }, children: "no MCP servers configured \xB7 press a to add one" }) : /* @__PURE__ */ jsx3(
+          Menu,
+          {
+            items: servers,
+            selected: index(),
+            onSelect: setIndex,
+            focused,
+            maxVisible: 6,
+            vimKeys: true,
+            onSubmit: (s) => onToggle(s.name),
+            onCancel: onClose,
+            renderItem: (s, { active }) => {
+              const st = MCP_STATUS[s.status] || MCP_STATUS.idle;
+              return /* @__PURE__ */ jsxs3("box", { style: { flexDirection: "row" }, children: [
+                /* @__PURE__ */ jsx3("text", { style: { color: accent() }, children: active ? "\u203A " : "  " }),
+                /* @__PURE__ */ jsx3("text", { style: { color: st.color }, children: st.icon }),
+                /* @__PURE__ */ jsx3("text", { style: { color: active ? accent() : FG }, children: ` ${s.name.padEnd(14)}` }),
+                /* @__PURE__ */ jsx3("box", { style: { flexGrow: 1, height: 1 }, children: /* @__PURE__ */ jsx3("text", { style: { overflow: "truncate", color: s.status === "error" ? RED : MUTED }, children: s.status === "error" ? s.error : s.status === "connected" ? `${s.toolCount} tools` : s.status }) }),
+                /* @__PURE__ */ jsx3("text", { style: { color: FAINT, overflow: "truncate" }, children: `  ${s.command.slice(0, 40)}` })
+              ] });
+            }
+          }
+        ) }),
+        !adding() && /* @__PURE__ */ jsx3(
+          McpKeys,
+          {
+            focused,
+            onKey: (key) => {
+              const s = selected();
+              if (key === "a") setAdding(true);
+              else if (s && key === " ") onToggle(s.name);
+              else if (s && key === "r") onReconnect(s.name);
+              else if (s && key === "d") onRemove(s.name);
+              else if (s && key === "t") setViewing(s.name);
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+function McpKeys({ focused, onKey }) {
+  useInput2((event) => {
+    if (!focused) return;
+    if ([" ", "a", "r", "d", "t"].includes(event.key)) {
+      onKey(event.key);
+      event.stopPropagation();
+    }
+  });
+  return null;
+}
+
+// src/ui/app.jsx
+import { jsx as jsx4, jsxs as jsxs4 } from "@trendr/core/jsx-runtime";
+var EFFORT_LEVELS = [
+  { key: null, desc: "let the provider decide how much to think" },
+  { key: "low", desc: "quick answers, minimal thinking" },
+  { key: "medium", desc: "moderate thinking budget" },
+  { key: "high", desc: "generous thinking budget" },
+  { key: "max", desc: "maximum thinking budget" }
+];
+var COMMANDS = [
+  { name: "model", desc: "Switch the active model for this session" },
+  { name: "effort", desc: "Set the thinking effort for this session" },
+  { name: "resume", desc: "Pick up a previous session where you left off" },
+  { name: "new", desc: "Start a new session in this project" },
+  { name: "rewind", desc: "Restore the conversation to a previous message" },
+  { name: "rename", desc: "Name this session: /rename <name>" },
+  { name: "color", desc: "Color this session: /color <name or #hex>" },
+  { name: "mcp", desc: "Manage MCP servers: add, toggle, reconnect" },
+  { name: "compact", desc: "Summarize the conversation to free the context window" },
+  { name: "clear", desc: "Clear the conversation and free the context window" },
+  { name: "cost", desc: "Show token usage and estimated cost so far" },
+  { name: "export", desc: "Save the current conversation to a markdown file" },
+  { name: "help", desc: "List every command and what it does" }
+];
+var SESSION_COLORS = {
+  red: "#f87171",
+  orange: "#fb923c",
+  yellow: "#facc15",
+  green: "#6BE795",
+  teal: "#2dd4bf",
+  cyan: "#22d3ee",
+  blue: "#60a5fa",
+  purple: "#a78bfa",
+  pink: "#f472b6",
+  gray: "#9ca3af"
+};
+var HISTORY_SCOPES = ["session", "project", "everywhere"];
+var RESUME_SCOPES = ["project", "everywhere"];
+function App({ boot: boot2 }) {
+  const { cwd, root, version: version2, models: models2, skills, mcp, tracker, startupContext } = boot2;
+  const [derived, setDerived] = createSignal4(deriveState([]));
+  const [overlay, setOverlay] = createSignal4([]);
+  const [streaming, setStreaming] = createSignal4(null);
+  const [busy, setBusy] = createSignal4(false);
+  const [startedAt, setStartedAt] = createSignal4(0);
+  const [input, setInput] = createSignal4("");
+  const [notice, setNotice] = createSignal4("");
+  const [model2, setModel] = createSignal4(boot2.initialModel);
+  const [defaultModel2, setDefaultModel] = createSignal4(boot2.initialModel);
+  const [effort, setEffort] = createSignal4(boot2.initialEffort);
+  const [defaultEffort, setDefaultEffort] = createSignal4(boot2.initialEffort);
+  const [showEffortPanel, setShowEffortPanel] = createSignal4(false);
+  const [queued, setQueued] = createSignal4([]);
+  const [sent, setSent] = createSignal4([]);
+  const [histIdx, setHistIdx] = createSignal4(-1);
+  const [cmdIndex, setCmdIndex] = createSignal4(0);
+  const [fileIndex, setFileIndex] = createSignal4(0);
+  const [fileList, setFileList] = createSignal4([]);
+  const [filesDismissed, setFilesDismissed] = createSignal4(false);
+  const [view, setView] = createSignal4("chat");
+  const [verbose, setVerbose] = createSignal4(false);
+  const [showModelPanel, setShowModelPanel] = createSignal4(false);
+  const [showHistoryPanel, setShowHistoryPanel] = createSignal4(false);
+  const [histScope, setHistScope] = createSignal4(0);
+  const [histPrompts, setHistPrompts] = createSignal4([]);
+  const [showResumePanel, setShowResumePanel] = createSignal4(false);
+  const [resumeScope, setResumeScope] = createSignal4(0);
+  const [resumeSessions, setResumeSessions] = createSignal4([]);
+  const [resumeLoading, setResumeLoading] = createSignal4(false);
+  const [showMcpPanel, setShowMcpPanel] = createSignal4(false);
+  const [showProjectPanel, setShowProjectPanel] = createSignal4(false);
+  const [projects, setProjects] = createSignal4([]);
+  const [projectsLoading, setProjectsLoading] = createSignal4(false);
+  const [mcpServers, setMcpServers] = createSignal4(mcp.list());
+  const [completing, setCompleting] = createSignal4(false);
+  const [compIndex, setCompIndex] = createSignal4(0);
+  const [rewindStep, setRewindStep] = createSignal4(null);
+  const [rewindTarget, setRewindTarget] = createSignal4(null);
+  const [offset, setOffset] = createSignal4(0);
+  const [follow, setFollow] = createSignal4(true);
+  const refs = boot2.refs;
+  refs.session ??= null;
+  refs.allEvents ??= [];
+  refs.persisted ??= 0;
+  refs.abort = refs.abort || null;
+  refs.rewindUndo = refs.rewindUndo || null;
+  refs.quitAt ??= 0;
+  refs.attachments ??= /* @__PURE__ */ new Map();
+  refs.imageCount ??= 0;
+  boot2.setMcpNotify(() => setMcpServers(boot2.mcp.list()));
+  const skillCommands = skills.list().map((s) => ({ name: s.name, desc: `skill \xB7 ${s.description || s.source}`, skill: true }));
+  const userCommands = boot2.commands.list().map((c) => ({ name: c.name, desc: `command \xB7 ${c.description || c.source}`, command: true }));
+  const byName = /* @__PURE__ */ new Map();
+  const shadowed = [];
+  for (const c of [...COMMANDS, ...skillCommands, ...userCommands]) {
+    if (byName.has(c.name)) shadowed.push(`${c.skill ? "skill" : "command"} "${c.name}"`);
+    else byName.set(c.name, c);
+  }
+  const allCommands = [...byName.values()];
+  if (shadowed.length && !refs.warnedShadowed) {
+    refs.warnedShadowed = true;
+    setTimeout(() => flash(`shadowed by an earlier name, rename to use: ${shadowed.join(", ")}`), 0);
+  }
+  function flash(msg) {
+    setNotice(msg);
+    setTimeout(() => setNotice((n) => n === msg ? "" : n), 2500);
+  }
+  function ensureSession() {
+    if (!refs.session) refs.session = createSession({ cwd, root });
+    while (refs.persisted < refs.allEvents.length) {
+      refs.session.append(refs.allEvents[refs.persisted]);
+      refs.persisted++;
+    }
+  }
+  function persist(event) {
+    refs.allEvents.push(event);
+    if (refs.session) {
+      refs.session.append(event);
+      refs.persisted = refs.allEvents.length;
+    }
+  }
+  function reDerive() {
+    const state = deriveState(refs.allEvents);
+    setDerived(state);
+    setAccent(state.color);
+    boot2.setTheme?.({ accent: state.color || DEFAULT_ACCENT });
+  }
+  function flushStream(items2) {
+    const text = streaming();
+    if (text) items2.push({ kind: "assistant", text });
+    setStreaming(null);
+  }
+  async function executeTurn(text) {
+    const { content, used } = buildUserContent(text, refs.attachments);
+    for (const placeholder of used) refs.attachments.delete(placeholder);
+    persist(makeEvent("message", { message: { role: "user", content } }));
+    ensureSession();
+    reDerive();
+    setFollow(true);
+    setBusy(true);
+    setStartedAt(Date.now());
+    const controller = new AbortController();
+    refs.abort = controller;
+    const loadedBefore = new Set(tracker.loaded);
+    const { tools, recorder } = createToolset({
+      cwd,
+      tracker,
+      skills,
+      mcpTools: mcp.tools(),
+      signal: controller.signal
+    });
+    const onStream = (event) => {
+      if (event.type === "content") {
+        setStreaming((s) => (s || "") + event.content);
+      } else if (event.type === "tool_calls_ready") {
+        setOverlay((o) => {
+          const next = [...o];
+          flushStream(next);
+          return next;
+        });
+      } else if (event.type === "tool_executing") {
+        setOverlay((o) => {
+          const next = [...o];
+          flushStream(next);
+          let args = {};
+          try {
+            args = JSON.parse(event.call.function.arguments);
+          } catch {
+          }
+          next.push({
+            kind: "tool",
+            callId: event.call.id,
+            name: event.call.function.name,
+            title: uiTitle(event.call.function.name, args),
+            status: "running"
+          });
+          return next;
+        });
+      } else if (event.type === "tool_complete" || event.type === "tool_error") {
+        const entry = recorder.entries.at(-1);
+        setOverlay(
+          (o) => o.map(
+            (item) => item.kind === "tool" && item.callId === event.call.id ? { ...item, ...entry?.callId === event.call.id ? entry : {}, kind: "tool", status: entry?.status || "done" } : item
+          )
+        );
+      }
+    };
+    let result;
+    try {
+      result = await runTurn({
+        history: derived().providerHistory,
+        tools,
+        recorder,
+        modelName: model2().name,
+        effort: effortApplies() ? effort() : null,
+        system: buildSystemPrompt({ cwd, contextFiles: startupContext.files, skills: skills.list() }),
+        signal: controller.signal,
+        onStream
+      });
+    } catch (err) {
+      setOverlay([]);
+      setStreaming(null);
+      setBusy(false);
+      refs.abort = null;
+      flash(`error: ${String(err.message || err).slice(0, 120)}`);
+      return;
+    }
+    for (const message of result.messages) persist(makeEvent("message", { message }));
+    for (const entry of recorder.entries) persist(makeEvent("tool_meta", entry));
+    for (const path of tracker.loaded) {
+      if (!loadedBefore.has(path)) persist(makeEvent("context_file", { path }));
+    }
+    if (result.usage) persist(makeEvent("usage", { model: model2().name, usage: result.usage }));
+    if (result.interrupted) persist(makeEvent("interrupt", {}));
+    setOverlay([]);
+    setStreaming(null);
+    reDerive();
+    setBusy(false);
+    refs.abort = null;
+    if (result.stalled) flash("model stalled \xB7 turn interrupted");
+    const q = queued();
+    if (q.length > 0) {
+      setQueued([]);
+      if (result.interrupted) setInput(q.join("\n"));
+      else executeTurn(q.join("\n"));
+    }
+  }
+  function completionSource(name) {
+    if (name === "color") return Object.keys(SESSION_COLORS);
+    if (name === "effort") return ["default", "low", "medium", "high", "max"];
+    if (name === "model") return models2.map((m) => m.name);
+    const cmd = allCommands.find((c) => c.name === name);
+    if (cmd?.skill || cmd?.command) return fileList();
+    return null;
+  }
+  function dismissCompletion() {
+    setCompleting(false);
+    setCompIndex(0);
+  }
+  function acceptCompletion(value, ctx, candidate) {
+    setInput(applyCompletion(value, ctx, candidate));
+    dismissCompletion();
+  }
+  function send(text) {
+    const value = text.trim();
+    if (!value) return;
+    dismissCompletion();
+    if (value.startsWith("/")) {
+      const [name, ...rest] = value.slice(1).split(/\s+/);
+      const match = allCommands.find((c) => c.name === name.toLowerCase());
+      if (match) {
+        setInput("");
+        runCommand(match, rest.join(" "));
+        return;
+      }
+    }
+    setSent((s) => [...s, { text: value, at: Date.now() }]);
+    setHistIdx(-1);
+    appendPrompt(root, value).catch(() => {
+    });
+    if (busy()) {
+      setQueued((q) => [...q, value]);
+      return;
+    }
+    executeTurn(value);
+  }
+  function interrupt() {
+    if (!busy()) return;
+    refs.abort?.abort();
+  }
+  async function runCommand(c, args = "") {
+    setInput("");
+    if (c.name === "rename") {
+      if (!args) return flash("usage: /rename <new name>");
+      persist(makeEvent("title", { text: args }));
+      ensureSession();
+      reDerive();
+      flash(`session renamed to "${args}"`);
+      return;
+    }
+    if (c.name === "color") {
+      const names = Object.keys(SESSION_COLORS);
+      const values = Object.values(SESSION_COLORS);
+      let value;
+      if (!args) {
+        const next = (values.indexOf(derived().color) + 1) % values.length;
+        value = values[next];
+      } else {
+        value = SESSION_COLORS[args.toLowerCase()] || (/^#[0-9a-fA-F]{6}$/.test(args) ? args : null);
+        if (!value) return flash(`usage: /color to cycle, or /color <${names.join("|")}|#hex>`);
+      }
+      persist(makeEvent("color", { value }));
+      ensureSession();
+      reDerive();
+      const name = names[values.indexOf(value)];
+      flash(`session color: ${name || value}`);
+      return;
+    }
+    if (c.skill) {
+      const body = await skills.load(c.name);
+      if (!body) return flash(`could not load skill ${c.name}`);
+      persist(makeEvent("skill", { name: c.name, source: "user" }));
+      send(`Follow these skill instructions now.
+
+${body}`);
+      return;
+    }
+    if (c.command) {
+      const text = await boot2.commands.load(c.name, args);
+      if (!text) return flash(`could not load command ${c.name}`);
+      send(text);
+      return;
+    }
+    if (c.name === "model") {
+      if (!args) return setShowModelPanel(true);
+      const exact = models2.find((m) => m.name === args);
+      const scored = models2.map((m) => [fuzzyScore(args, m.name), m]).filter(([score]) => score >= 0).sort((a, b) => b[0] - a[0]);
+      const pick = exact || scored[0]?.[1];
+      if (!pick) return flash(`no available model matches "${args}"`);
+      persist(makeEvent("model_switch", { from: model2().name, to: pick.name }));
+      setModel(pick);
+      flash(`model set to ${pick.name}`);
+      return;
+    }
+    if (c.name === "effort") {
+      if (!effortApplies()) return flash(`${model2().name} does not support effort control`);
+      if (!args) return setShowEffortPanel(true);
+      const level = args.toLowerCase();
+      if (level === "default") return setSessionEffort(null);
+      if (!EFFORT_LEVELS.some((l) => l.key === level)) return flash("usage: /effort <default|low|medium|high|max>");
+      return setSessionEffort(level);
+    }
+    if (c.name === "help") return setView("help");
+    if (c.name === "mcp") return setShowMcpPanel(true);
+    if (c.name === "resume") {
+      setShowResumePanel(true);
+      refreshSessions(resumeScope());
+      return;
+    }
+    if (c.name === "new") {
+      if (busy()) return flash("finish or interrupt the current turn first");
+      refs.session = null;
+      refs.allEvents = [];
+      refs.persisted = 0;
+      refs.rewindUndo = null;
+      setQueued([]);
+      setSent([]);
+      setModel(defaultModel2());
+      setEffort(defaultEffort());
+      reDerive();
+      flash("new session");
+      return;
+    }
+    if (c.name === "rewind") {
+      if (busy()) return flash("finish or interrupt the current turn first");
+      if (userEntries(derived()).length === 0) return flash("nothing to rewind yet");
+      setRewindStep("pick");
+      return;
+    }
+    if (c.name === "clear") {
+      if (busy()) return flash("finish or interrupt the current turn first");
+      persist(makeEvent("clear", {}));
+      reDerive();
+      flash("conversation cleared");
+      return;
+    }
+    if (c.name === "compact") {
+      if (busy()) return flash("finish or interrupt the current turn first");
+      const history = derived().providerHistory;
+      if (history.length === 0) return flash("nothing to compact yet");
+      flash("compacting...");
+      try {
+        const text = history.map((m) => `${m.role}: ${typeof m.content === "string" ? m.content : ""}`).join("\n");
+        const summary = await summarizeText({ text, modelName: model2().name });
+        persist(makeEvent("compact", { summary }));
+        reDerive();
+        flash("conversation compacted");
+      } catch (err) {
+        flash(`compact failed: ${String(err.message || err).slice(0, 80)}`);
+      }
+      return;
+    }
+    if (c.name === "cost") {
+      const byModel = derived().usageByModel;
+      const entries = Object.entries(byModel);
+      if (entries.length === 0) return flash("no usage yet");
+      const total = entries.reduce((sum, [name, usage2]) => sum + estimateCost(findModel(name), usage2), 0);
+      const { promptTokens, completionTokens } = derived().usage;
+      flash(`$${total.toFixed(4)} \xB7 ${promptTokens.toLocaleString()} in \xB7 ${completionTokens.toLocaleString()} out`);
+      return;
+    }
+    if (c.name === "export") {
+      const file = join8(cwd, `pico-export-${Date.now()}.md`);
+      await writeFile6(file, transcriptToMarkdown(derived().transcript, { title: `pico session \xB7 ${cwd}` }));
+      flash(`exported to ${file}`);
+      return;
+    }
+  }
+  function refreshSessions(scopeIndex) {
+    setResumeLoading(true);
+    listSessions({ scope: RESUME_SCOPES[scopeIndex], root }).then((sessions) => setResumeSessions(sessions.filter((s) => s.header.id !== refs.session?.id))).finally(() => setResumeLoading(false));
+  }
+  function shortenPath(path) {
+    const home2 = homedir3();
+    return path.startsWith(home2) ? path.replace(home2, "~") : path;
+  }
+  function openProjectPanel() {
+    setShowProjectPanel(true);
+    setProjectsLoading(true);
+    listSessions({ scope: "everywhere", root }).then((metas) => {
+      const byRoot = /* @__PURE__ */ new Map();
+      for (const m of metas) {
+        const entry = byRoot.get(m.header.root);
+        if (!entry) {
+          byRoot.set(m.header.root, {
+            root: m.header.root,
+            path: shortenPath(m.header.root),
+            latest: m,
+            count: 1,
+            current: m.header.root === boot2.root
+          });
+        } else {
+          entry.count++;
+        }
+      }
+      setProjects([...byRoot.values()]);
+    }).finally(() => setProjectsLoading(false));
+  }
+  async function switchProject(meta) {
+    if (busy()) return flash("finish or interrupt the current turn first");
+    try {
+      const previousMcp = boot2.mcp;
+      const next = await boot2.rebuild(meta.header.root);
+      previousMcp.closeAll().catch(() => {
+      });
+      process.chdir(next.cwd);
+      Object.assign(boot2, next);
+      next.mcp.connectAll();
+      setMcpServers(next.mcp.list());
+      setQueued([]);
+      setFileList([]);
+      await resumeSession(meta);
+      flash(`switched to ${next.displayCwd}`);
+    } catch (err) {
+      flash(`switch failed: ${String(err.message || err).slice(0, 80)}`);
+    }
+  }
+  async function resumeSession(meta) {
+    setShowResumePanel(false);
+    setShowProjectPanel(false);
+    if (meta.header.root !== boot2.root) return switchProject(meta);
+    try {
+      const { header, events } = await loadSession(meta.file);
+      refs.session = openSession({ file: meta.file, header });
+      refs.allEvents = [...events];
+      refs.persisted = events.length;
+      refs.rewindUndo = null;
+      reDerive();
+      const restored = derived().model && models2.find((m) => m.name === derived().model);
+      if (restored) {
+        setModel(restored);
+      } else {
+        setModel(defaultModel2());
+        if (derived().model) flash(`model ${derived().model} unavailable, using ${defaultModel2().name}`);
+      }
+      setEffort(derived().effort === void 0 ? defaultEffort() : derived().effort);
+      setSent(userEntries(derived()).map((e) => ({ text: e.text, at: header.createdAt })));
+      setFollow(true);
+      flash(`resumed \xB7 ${meta.turns} ${meta.turns === 1 ? "turn" : "turns"} \xB7 ${timeAgo(meta.at)}`);
+    } catch (err) {
+      flash(`resume failed: ${String(err.message || err).slice(0, 80)}`);
+    }
+  }
+  function openHistorySearch() {
+    const session = sent();
+    setHistPrompts(dedupePrompts(session));
+    setShowHistoryPanel(true);
+    setHistScope(0);
+  }
+  function dedupePrompts(pool) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const entry of [...pool].sort((a, b) => b.at - a.at)) {
+      if (seen.has(entry.text)) continue;
+      seen.add(entry.text);
+      out.push(entry);
+    }
+    return out;
+  }
+  async function switchHistScope(next) {
+    setHistScope(next);
+    if (next === 0) return setHistPrompts(dedupePrompts(sent()));
+    const project = await loadProjectPrompts(root);
+    if (next === 1) return setHistPrompts(dedupePrompts([...sent(), ...project]));
+    const global = await loadGlobalPrompts();
+    setHistPrompts(dedupePrompts([...sent(), ...project, ...global]));
+  }
+  async function performRewind(opt) {
+    const target = rewindTarget();
+    const state = derived();
+    const { edits } = rewindStats(state, target.index);
+    const editsLabel = `${edits.length} ${edits.length === 1 ? "edit" : "edits"}`;
+    let reverted = [];
+    let skipped = [];
+    if (opt.key === "both" || opt.key === "code") {
+      const result = await revertEdits(edits);
+      reverted = result.reverted;
+      skipped = result.skipped;
+    }
+    let summaryText = null;
+    if (opt.key === "summary") {
+      const tail = state.transcript.slice(target.index);
+      const text = tail.filter((m) => m.text).map((m) => `${m.kind}: ${m.text}`).join("\n");
+      flash("summarizing...");
+      summaryText = await summarizeText({ text, modelName: model2().name }).catch(
+        () => tail.filter((m) => m.text).slice(0, 3).map((m) => m.text.split(/\s+/).slice(0, 6).join(" ")).join(" \xB7 ")
+      );
+    }
+    const event = makeEvent("rewind", { target: target.eventId, mode: opt.key, summaryText, reverted, skipped });
+    persist(event);
+    refs.rewindUndo = { rewindId: event.id, edits: edits.filter((e) => reverted.includes(e.callId)) };
+    reDerive();
+    if (opt.key !== "code") setInput(target.text);
+    const skippedNote = skipped.length ? ` \xB7 skipped ${skipped.length} drifted` : "";
+    if (opt.key === "code") flash(`reverted ${editsLabel}, conversation kept${skippedNote} \xB7 ctrl+z to undo`);
+    else if (opt.key === "summary") flash(`rewound and summarized${skippedNote} \xB7 ctrl+z to undo`);
+    else if (opt.key === "both") flash(`rewound, ${editsLabel} reverted${skippedNote} \xB7 ctrl+z to undo`);
+    else flash(`rewound, file changes kept \xB7 ctrl+z to undo`);
+    setRewindStep(null);
+    setRewindTarget(null);
+  }
+  async function undoRewind() {
+    const undo = refs.rewindUndo;
+    if (!undo) return;
+    const { skipped } = await reapplyEdits(undo.edits);
+    persist(makeEvent("rewind_undo", { rewindId: undo.rewindId }));
+    refs.rewindUndo = null;
+    reDerive();
+    flash(skipped.length ? `rewind undone \xB7 ${skipped.length} file(s) drifted` : "rewind undone");
+  }
+  const anyPanel = () => showModelPanel() || showEffortPanel() || showHistoryPanel() || showResumePanel() || showMcpPanel() || showProjectPanel() || rewindStep() !== null;
+  const effortApplies = () => !!model2().effort;
+  function setSessionEffort(next, { asDefault = false } = {}) {
+    persist(makeEvent("effort", { to: next }));
+    setEffort(next);
+    if (asDefault) {
+      setDefaultEffort(next);
+      writeConfig({ defaultEffort: next }).catch(() => {
+      });
+    }
+    flash(`effort: ${next ?? "default"}${asDefault ? " \xB7 saved as default" : ""}`);
+  }
+  const fm = useFocus({ initial: "input" });
+  fm.item("feed");
+  fm.item("input");
+  useFocusTrap(anyPanel() || view() === "help");
+  useSelection({
+    onCopy: (text) => flash(`copied ${text.length} ${text.length === 1 ? "character" : "characters"}`)
+  });
+  useInput3((event) => {
+    if (event.key === "escape" && busy() && !anyPanel()) {
+      interrupt();
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "c") {
+      const now = Date.now();
+      if (now - refs.quitAt < 1500) {
+        mcp.closeAll().catch(() => {
+        }).finally(() => process.exit(0));
+      } else {
+        refs.quitAt = now;
+        flash("ctrl+c again to exit");
+      }
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "o") {
+      setVerbose((v) => !v);
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "r" && view() === "chat" && !anyPanel()) {
+      openHistorySearch();
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "s" && view() === "chat" && !anyPanel()) {
+      setShowResumePanel(true);
+      refreshSessions(resumeScope());
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "t" && view() === "chat" && !anyPanel()) {
+      setShowModelPanel(true);
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "p" && view() === "chat" && !anyPanel()) {
+      openProjectPanel();
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "b" && view() === "chat" && !anyPanel()) {
+      if (!effortApplies()) flash(`${model2().name} does not support effort control`);
+      else {
+        const order = [null, "low", "medium", "high", "max"];
+        const next = order[(order.indexOf(effort() ?? null) + 1) % order.length];
+        setSessionEffort(next);
+      }
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "s" && showHistoryPanel()) {
+      switchHistScope((histScope() + 1) % HISTORY_SCOPES.length);
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "s" && showResumePanel()) {
+      const next = (resumeScope() + 1) % RESUME_SCOPES.length;
+      setResumeScope(next);
+      refreshSessions(next);
+      event.stopPropagation();
+      return;
+    }
+    if (event.ctrl && event.key === "z" && refs.rewindUndo && !busy() && view() === "chat") {
+      undoRewind();
+      event.stopPropagation();
+    }
+  });
+  const elapsed = busy() ? Math.max(0, Math.floor((Date.now() - startedAt()) / 1e3)) : 0;
+  const slashQuery = input().startsWith("/") ? input().slice(1) : null;
+  const showCommands = slashQuery !== null && !slashQuery.includes(" ") && !anyPanel();
+  const matchedCommands = showCommands ? allCommands.filter((c) => c.name.toLowerCase().startsWith(slashQuery.toLowerCase())) : [];
+  const atMatch = input().match(/(^|[\s(])@([^\s@]*)$/);
+  const showFiles = atMatch !== null && !showCommands && !filesDismissed() && !anyPanel();
+  if (showFiles) {
+    listFiles(cwd).then((files) => {
+      if (files !== fileList()) setFileList(files);
+    });
+  }
+  const matchedFiles = showFiles ? fileList().map((f) => [fuzzyScore(atMatch[2], f), f]).filter(([score]) => score >= 0).sort((a, b) => b[0] - a[0]).map(([, f]) => f) : [];
+  function pickFile(f) {
+    const v = input();
+    const at = v.lastIndexOf("@");
+    setInput(v.slice(0, at + 1) + f + " ");
+    setFileIndex(0);
+  }
+  const compCtx = completing() ? completionContext({ value: input(), resolve: completionSource }) : null;
+  const showCompletion = !!compCtx && compCtx.matches.length > 0 && !showCommands && !showFiles && !anyPanel();
+  const rewindEntries = () => userEntries(derived());
+  const rewindOptions = (() => {
+    const target = rewindTarget();
+    if (!target) return [];
+    const { msgs, edits } = rewindStats(derived(), target.index);
+    const e = edits.length;
+    const editsLabel = `${e} ${e === 1 ? "edit" : "edits"}`;
+    const opts = [];
+    if (e > 0) opts.push({ key: "both", label: "restore code and conversation", desc: `chat returns to this message \xB7 ${editsLabel} reverted` });
+    opts.push({
+      key: "chat",
+      label: e > 0 ? "restore conversation only" : "restore conversation",
+      desc: e > 0 ? "chat returns to this message \xB7 file changes kept" : `chat returns to this message \xB7 drops ${msgs} entries`
+    });
+    if (e > 0) opts.push({ key: "code", label: "restore code only", desc: `conversation kept \xB7 ${editsLabel} reverted` });
+    opts.push({ key: "summary", label: "rewind and keep a summary", desc: "dropped entries collapse into a one-line note" });
+    return opts;
+  })();
+  const { usage } = derived();
+  if (view() === "help") {
+    return /* @__PURE__ */ jsx4(Help, { commands: COMMANDS, onClose: () => setView("chat") });
+  }
+  highlightVersion();
+  const items = [...derived().transcript, ...overlay()];
+  return /* @__PURE__ */ jsxs4("box", { style: { flexDirection: "column", height: "100%" }, children: [
+    /* @__PURE__ */ jsxs4(
+      ScrollBox3,
+      {
+        style: { flexGrow: 1 },
+        focused: fm.is("feed"),
+        scrollOffset: follow() ? 1e9 : offset(),
+        onScroll: (next) => {
+          setFollow(false);
+          setOffset(next);
+        },
+        scrollbar: true,
+        children: [
+          items.length === 0 && /* @__PURE__ */ jsx4(Banner, { version: version2, cwd: boot2.displayCwd, modelName: model2().name }),
+          items.map((item, i) => /* @__PURE__ */ jsx4(Message, { item, verbose: verbose() }, i)),
+          streaming() !== null && streaming() !== "" && /* @__PURE__ */ jsx4(Message, { item: { kind: "assistant", text: `${streaming()}\u258B` } }, "streaming")
+        ]
+      }
+    ),
+    queued().length > 0 && /* @__PURE__ */ jsx4("box", { style: { flexDirection: "column", paddingX: 2, marginTop: 1 }, children: queued().map((q, i) => /* @__PURE__ */ jsxs4("box", { style: { flexDirection: "row" }, children: [
+      /* @__PURE__ */ jsx4("text", { style: { color: FAINT }, children: "\u203A " }),
+      /* @__PURE__ */ jsx4("box", { style: { flexGrow: 1, height: 1 }, children: /* @__PURE__ */ jsx4("text", { style: { overflow: "truncate", color: MUTED }, children: q.replace(/\n/g, " ") }) }),
+      i === 0 && /* @__PURE__ */ jsx4("text", { style: { color: FAINT, dim: true }, children: "  pending \xB7 \u2191 to edit" })
+    ] }, i)) }),
+    /* @__PURE__ */ jsxs4("box", { style: { bg: PANEL_BG, flexDirection: "row", paddingX: 2, paddingY: 1, marginTop: 1 }, children: [
+      /* @__PURE__ */ jsx4("text", { style: { color: accent(), bold: true }, children: "\u276F" }),
+      /* @__PURE__ */ jsx4("text", { children: " " }),
+      derived().title && /* @__PURE__ */ jsx4("box", { style: { position: "absolute", top: 0, right: 0 }, children: /* @__PURE__ */ jsx4("text", { style: { bg: accent(), color: "black", bold: true }, children: ` ${derived().title} ` }) }),
+      /* @__PURE__ */ jsx4(
+        TextArea,
+        {
+          value: input(),
+          onChange: (v) => {
+            setInput(v);
+            setCmdIndex(0);
+            setFileIndex(0);
+            setHistIdx(-1);
+            setFilesDismissed(false);
+          },
+          onCancel: () => {
+            if (busy()) interrupt();
+            else setInput("");
+          },
+          onSubmit: send,
+          onKeyDown: (e) => {
+            if (e.key === "paste" && e.text) {
+              const paths = extractImagePaths(e.text);
+              if (paths.length > 0) {
+                const placeholders = paths.map((path) => {
+                  const placeholder = `[Image #${++refs.imageCount}]`;
+                  refs.attachments.set(placeholder, { path, mediaType: mediaTypeFor(path) });
+                  return placeholder;
+                });
+                const at = e.cursor ?? e.value.length;
+                setInput(e.value.slice(0, at) + placeholders.join(" ") + e.value.slice(at));
+                return true;
+              }
+              return false;
+            }
+            if (e.key === "backspace" && e.cursor > 0) {
+              const match = e.value.slice(0, e.cursor).match(/\[Image #\d+\]$/);
+              if (match) {
+                refs.attachments.delete(match[0]);
+                setInput(e.value.slice(0, e.cursor - match[0].length) + e.value.slice(e.cursor));
+                return true;
+              }
+            }
+            if (e.key === "tab" && !e.ctrl && !e.meta) {
+              const ctx = completionContext({ value: e.value, resolve: completionSource });
+              if (!ctx) return false;
+              if (!completing()) {
+                setCompleting(true);
+                setCompIndex(0);
+                listFiles(cwd).then((files) => {
+                  if (files !== fileList()) setFileList(files);
+                });
+              } else if (ctx.matches.length > 0) {
+                acceptCompletion(e.value, ctx, ctx.matches[Math.min(compIndex(), ctx.matches.length - 1)]);
+              }
+              return true;
+            }
+            if (e.ctrl || e.meta || showCommands || showFiles) return false;
+            if (e.key === "up" && e.value === "" && queued().length > 0) {
+              setInput(queued().join("\n"));
+              setQueued([]);
+              return true;
+            }
+            const browsing = histIdx() >= 0;
+            if (e.key === "up" && (browsing || e.value === "") && histIdx() < sent().length - 1) {
+              const n = histIdx() + 1;
+              setHistIdx(n);
+              setInput(sent()[sent().length - 1 - n].text);
+              return true;
+            }
+            if (e.key === "down" && browsing) {
+              const n = histIdx() - 1;
+              setHistIdx(n);
+              setInput(n < 0 ? "" : sent()[sent().length - 1 - n].text);
+              return true;
+            }
+            return false;
+          },
+          submitOnEnter: true,
+          clearOnSubmit: true,
+          focused: fm.is("input") && !anyPanel(),
+          maxHeight: 8,
+          placeholder: "enter to send \xB7 / commands \xB7 @ files \xB7 tab to scroll",
+          cursor: { blink: true, bg: accent(), color: "black" }
+        }
+      )
+    ] }),
+    showCommands && /* @__PURE__ */ jsx4("box", { style: { flexDirection: "column", paddingX: 2, marginTop: 1 }, children: matchedCommands.length === 0 ? /* @__PURE__ */ jsx4("text", { style: { color: FAINT }, children: "no matching commands" }) : /* @__PURE__ */ jsx4(
+      Menu2,
+      {
+        items: matchedCommands,
+        selected: cmdIndex(),
+        onSelect: setCmdIndex,
+        onSubmit: runCommand,
+        focused: showCommands,
+        maxVisible: 5,
+        scrolloff: 2,
+        renderItem: (c, { active }) => /* @__PURE__ */ jsxs4("box", { style: { flexDirection: "row" }, children: [
+          /* @__PURE__ */ jsx4("text", { style: { color: accent() }, children: active ? "\u203A " : "  " }),
+          /* @__PURE__ */ jsx4("text", { style: { color: active ? accent() : MUTED }, children: `/${c.name}`.padEnd(12) }),
+          /* @__PURE__ */ jsx4("text", { style: { color: active ? "#cbd5e1" : FAINT }, children: c.desc })
+        ] })
+      }
+    ) }),
+    showFiles && matchedFiles.length > 0 && /* @__PURE__ */ jsx4("box", { style: { flexDirection: "column", paddingX: 2, marginTop: 1 }, children: /* @__PURE__ */ jsx4(
+      Menu2,
+      {
+        items: matchedFiles,
+        selected: fileIndex(),
+        onSelect: setFileIndex,
+        onSubmit: pickFile,
+        onCancel: () => setFilesDismissed(true),
+        focused: showFiles,
+        maxVisible: 5,
+        scrolloff: 2,
+        renderItem: (f, { active }) => /* @__PURE__ */ jsxs4("box", { style: { flexDirection: "row" }, children: [
+          /* @__PURE__ */ jsx4("text", { style: { color: accent() }, children: active ? "\u203A " : "  " }),
+          /* @__PURE__ */ jsx4("text", { style: { color: active ? accent() : FG_SOFT }, children: f })
+        ] })
+      }
+    ) }),
+    showCompletion && /* @__PURE__ */ jsx4("box", { style: { flexDirection: "column", paddingX: 2, marginTop: 1 }, children: /* @__PURE__ */ jsx4(
+      Menu2,
+      {
+        items: compCtx.matches,
+        selected: compIndex(),
+        onSelect: setCompIndex,
+        onSubmit: (candidate) => acceptCompletion(input(), compCtx, candidate),
+        onCancel: dismissCompletion,
+        focused: showCompletion,
+        maxVisible: 5,
+        scrolloff: 2,
+        renderItem: (candidate, { active }) => /* @__PURE__ */ jsxs4("box", { style: { flexDirection: "row" }, children: [
+          /* @__PURE__ */ jsx4("text", { style: { color: accent() }, children: active ? "\u203A " : "  " }),
+          /* @__PURE__ */ jsx4("text", { style: { color: active ? accent() : FG_SOFT }, children: candidate })
+        ] })
+      }
+    ) }),
+    showModelPanel() && /* @__PURE__ */ jsx4(
+      ModelPanel,
+      {
+        models: models2,
+        current: model2().name,
+        defaultName: defaultModel2().name,
+        focused: showModelPanel(),
+        onPick: (m) => {
+          persist(makeEvent("model_switch", { from: model2().name, to: m.name }));
+          setModel(m);
+          setShowModelPanel(false);
+          flash(`model set to ${m.name}`);
+        },
+        onPickDefault: (m) => {
+          persist(makeEvent("model_switch", { from: model2().name, to: m.name }));
+          setModel(m);
+          setDefaultModel(m);
+          writeConfig({ defaultModel: m.name }).catch(() => {
+          });
+          setShowModelPanel(false);
+          flash(`model set to ${m.name} \xB7 saved as default`);
+        },
+        onClose: () => setShowModelPanel(false)
+      }
+    ),
+    showEffortPanel() && /* @__PURE__ */ jsx4(
+      EffortPanel,
+      {
+        levels: EFFORT_LEVELS,
+        current: effort() ?? null,
+        defaultLevel: defaultEffort() ?? null,
+        focused: showEffortPanel(),
+        onPick: (l) => {
+          setSessionEffort(l.key);
+          setShowEffortPanel(false);
+        },
+        onPickDefault: (l) => {
+          setSessionEffort(l.key, { asDefault: true });
+          setShowEffortPanel(false);
+        },
+        onClose: () => setShowEffortPanel(false)
+      }
+    ),
+    showHistoryPanel() && /* @__PURE__ */ jsx4(
+      HistoryPanel,
+      {
+        prompts: histPrompts(),
+        scopes: HISTORY_SCOPES,
+        scopeIndex: histScope(),
+        focused: showHistoryPanel(),
+        onPick: (text) => {
+          setInput(text);
+          setShowHistoryPanel(false);
+        },
+        onClose: () => setShowHistoryPanel(false)
+      }
+    ),
+    showResumePanel() && /* @__PURE__ */ jsx4(
+      ResumePanel,
+      {
+        sessions: resumeSessions(),
+        scopes: RESUME_SCOPES,
+        scopeIndex: resumeScope(),
+        loading: resumeLoading(),
+        focused: showResumePanel(),
+        onPick: resumeSession,
+        onClose: () => setShowResumePanel(false)
+      }
+    ),
+    showProjectPanel() && /* @__PURE__ */ jsx4(
+      ProjectPanel,
+      {
+        projects: projects(),
+        loading: projectsLoading(),
+        focused: showProjectPanel(),
+        onPick: (p) => resumeSession(p.latest),
+        onClose: () => setShowProjectPanel(false)
+      }
+    ),
+    showMcpPanel() && /* @__PURE__ */ jsx4(
+      McpPanel,
+      {
+        servers: mcpServers(),
+        focused: showMcpPanel(),
+        onToggle: (name) => mcp.toggle(name),
+        onReconnect: (name) => mcp.reconnect(name),
+        onRemove: (name) => mcp.remove(name),
+        onAdd: (name, command) => {
+          mcp.add(name, command);
+          flash(`added ${name}`);
+        },
+        onClose: () => setShowMcpPanel(false)
+      }
+    ),
+    rewindStep() === "pick" && /* @__PURE__ */ jsx4(
+      RewindPickPanel,
+      {
+        entries: [...rewindEntries()].reverse(),
+        stats: (index) => rewindStats(derived(), index),
+        focused: rewindStep() === "pick",
+        onPick: (entry) => {
+          setRewindTarget(entry);
+          setRewindStep("action");
+        },
+        onClose: () => setRewindStep(null)
+      }
+    ),
+    rewindStep() === "action" && rewindTarget() && /* @__PURE__ */ jsx4(
+      RewindActionPanel,
+      {
+        target: rewindTarget(),
+        options: rewindOptions,
+        focused: rewindStep() === "action",
+        onSubmit: performRewind,
+        onBack: () => setRewindStep("pick")
+      }
+    ),
+    /* @__PURE__ */ jsxs4("box", { style: { flexDirection: "row", paddingX: 2, gap: 1, marginTop: 1 }, children: [
+      notice() ? /* @__PURE__ */ jsx4("text", { style: { color: accent() }, children: notice() }) : busy() ? /* @__PURE__ */ jsxs4("box", { style: { flexDirection: "row" }, children: [
+        /* @__PURE__ */ jsx4(Shimmer, { color: accent(), highlight: "white", duration: 1500, reverse: true, children: "Responding" }),
+        /* @__PURE__ */ jsx4("text", { style: { color: FAINT }, children: ` (${elapsed}s) \xB7 esc to interrupt` })
+      ] }) : null,
+      /* @__PURE__ */ jsx4("box", { style: { flexGrow: 1 } }),
+      /* @__PURE__ */ jsx4("text", { style: { color: accent() }, children: model2().name }),
+      effortApplies() && effort() && /* @__PURE__ */ jsx4("text", { style: { color: MUTED }, children: `\xB7 ${effort()}` }),
+      /* @__PURE__ */ jsx4("text", { style: { color: FAINT }, children: "\u2191" }),
+      /* @__PURE__ */ jsx4("text", { style: { color: MUTED }, children: `${usage.promptTokens.toLocaleString()} in` }),
+      /* @__PURE__ */ jsx4("text", { style: { color: FAINT }, children: "\u2193" }),
+      /* @__PURE__ */ jsx4("text", { style: { color: MUTED }, children: `${usage.completionTokens.toLocaleString()} out` })
+    ] })
+  ] });
+}
+
+// src/main.jsx
+import { jsx as jsx5 } from "@trendr/core/jsx-runtime";
+var pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf-8"));
+var keys = discoverKeys();
+var providers = applyKeys(keys);
+var models = availableModels(providers);
+if (models.length === 0) {
+  console.error("pico: no API keys found in the environment.");
+  console.error("set one of: GEMINI_API_KEY, ANTHROPIC_API_KEY, OPENAI_API_KEY, XAI_API_KEY");
+  process.exit(1);
+}
+var home = homedir4();
+var mcpNotify = () => {
+};
+async function buildProjectBoot(cwd) {
+  const root = findProjectRoot(cwd);
+  const startupContext = loadStartupContext(cwd);
+  const tracker = createContextTracker({
+    stopDir: startupContext.stopDir,
+    loaded: new Set(startupContext.files.map((f) => f.path))
+  });
+  return {
+    cwd,
+    root,
+    displayCwd: cwd.startsWith(home) ? cwd.replace(home, "~") : cwd,
+    startupContext,
+    tracker,
+    skills: await createSkillIndex(root),
+    commands: await createCommandIndex(root),
+    mcp: await createMcpRuntime({ root, onChange: () => mcpNotify() })
+  };
+}
+var config = await readConfig();
+var configuredDefault = config.defaultModel && models.find((m) => m.name === config.defaultModel);
+var theme = { accent: DEFAULT_ACCENT };
+var boot = {
+  ...await buildProjectBoot(process.cwd()),
+  theme,
+  version: pkg.version,
+  models,
+  initialModel: configuredDefault || defaultModel(providers),
+  initialEffort: ["low", "medium", "high", "max"].includes(config.defaultEffort) ? config.defaultEffort : null,
+  refs: {},
+  setMcpNotify: (fn) => {
+    mcpNotify = fn;
+  },
+  rebuild: buildProjectBoot
+};
+var app = mount(() => /* @__PURE__ */ jsx5(App, { boot }), { title: "pico", theme });
+boot.setTheme = app.setTheme;
+boot.mcp.connectAll();
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/main.jsx", "../src/core/keys.js", "../src/core/models.js", "../src/core/config.js", "../src/core/paths.js", "../src/core/context.js", "../src/core/skills.js", "../src/core/commands.js", "../src/core/mcp.js", "../src/ui/app.jsx", "../src/core/events.js", "../src/core/session.js", "../src/core/derive.js", "../src/core/history.js", "../src/core/agent.js", "../src/core/tools/recorder.js", "../src/core/tools/read.js", "../src/core/tools/write.js", "../src/core/tools/diff.js", "../src/core/tools/edit.js", "../src/core/tools/bash.js", "../src/core/tools/glob.js", "../src/core/tools/grep.js", "../src/core/tools/index.js", "../src/core/rewind.js", "../src/core/system-prompt.js", "../src/core/export.js", "../src/ui/fuzzy.js", "../src/ui/completion.js", "../src/ui/attachments.js", "../src/ui/files.js", "../src/ui/highlight.js", "../src/ui/transcript.jsx", "../src/ui/theme.js", "../src/ui/help.jsx", "../src/ui/panels.jsx"],
  "sourcesContent": ["import { readFileSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { mount } from '@trendr/core'\nimport { discoverKeys, applyKeys } from './core/keys.js'\nimport { availableModels, defaultModel } from './core/models.js'\nimport { readConfig } from './core/config.js'\nimport { findProjectRoot } from './core/paths.js'\nimport { loadStartupContext, createContextTracker } from './core/context.js'\nimport { createSkillIndex } from './core/skills.js'\nimport { createCommandIndex } from './core/commands.js'\nimport { createMcpRuntime } from './core/mcp.js'\nimport { App } from './ui/app.jsx'\nimport { DEFAULT_ACCENT } from './ui/theme.js'\n\nconst pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))\n\nconst keys = discoverKeys()\nconst providers = applyKeys(keys)\nconst models = availableModels(providers)\n\nif (models.length === 0) {\n  console.error('pico: no API keys found in the environment.')\n  console.error('set one of: GEMINI_API_KEY, ANTHROPIC_API_KEY, OPENAI_API_KEY, XAI_API_KEY')\n  process.exit(1)\n}\n\nconst home = homedir()\nlet mcpNotify = () => {}\n\nasync function buildProjectBoot(cwd) {\n  const root = findProjectRoot(cwd)\n  const startupContext = loadStartupContext(cwd)\n  const tracker = createContextTracker({\n    stopDir: startupContext.stopDir,\n    loaded: new Set(startupContext.files.map((f) => f.path)),\n  })\n  return {\n    cwd,\n    root,\n    displayCwd: cwd.startsWith(home) ? cwd.replace(home, '~') : cwd,\n    startupContext,\n    tracker,\n    skills: await createSkillIndex(root),\n    commands: await createCommandIndex(root),\n    mcp: await createMcpRuntime({ root, onChange: () => mcpNotify() }),\n  }\n}\n\nconst config = await readConfig()\nconst configuredDefault = config.defaultModel && models.find((m) => m.name === config.defaultModel)\n\nconst theme = { accent: DEFAULT_ACCENT }\n\nconst boot = {\n  ...(await buildProjectBoot(process.cwd())),\n  theme,\n  version: pkg.version,\n  models,\n  initialModel: configuredDefault || defaultModel(providers),\n  initialEffort: ['low', 'medium', 'high', 'max'].includes(config.defaultEffort) ? config.defaultEffort : null,\n  refs: {},\n  setMcpNotify: (fn) => { mcpNotify = fn },\n  rebuild: buildProjectBoot,\n}\n\nconst app = mount(() => <App boot={boot} />, { title: 'pico', theme })\nboot.setTheme = app.setTheme\nboot.mcp.connectAll()\n", "import { setKeys } from '@prsm/ai'\n\nconst PROVIDERS = [\n  { id: 'google', label: 'Gemini', env: ['GEMINI_API_KEY', 'GOOGLE_AI_API_KEY'] },\n  { id: 'anthropic', label: 'Claude', env: ['ANTHROPIC_API_KEY'] },\n  { id: 'openai', label: 'OpenAI', env: ['OPENAI_API_KEY'] },\n  { id: 'xai', label: 'Grok', env: ['XAI_API_KEY'] },\n]\n\nexport function discoverKeys(env = process.env) {\n  const keys = {}\n  for (const p of PROVIDERS) {\n    const name = p.env.find((n) => env[n])\n    if (name) keys[p.id] = env[name]\n  }\n  return keys\n}\n\nexport function applyKeys(keys) {\n  setKeys(keys)\n  return Object.keys(keys)\n}\n", "const CATALOG = [\n  { name: 'google/gemini-2.5-pro', provider: 'google', desc: 'Strong reasoning, long context', price: { in: 1.25, out: 10 }, effort: true },\n  { name: 'google/gemini-2.5-flash', provider: 'google', desc: 'Fast and capable for everyday work', price: { in: 0.3, out: 2.5 }, effort: true },\n  { name: 'google/gemini-2.5-flash-lite', provider: 'google', desc: 'Lowest latency and cost', price: { in: 0.1, out: 0.4 }, effort: true },\n  { name: 'anthropic/claude-opus-4-8', provider: 'anthropic', desc: 'Frontier coding and agentic workflows', price: { in: 15, out: 75 }, effort: true },\n  { name: 'anthropic/claude-sonnet-5', provider: 'anthropic', desc: 'Balanced speed and capability', price: { in: 3, out: 15 }, effort: true },\n  { name: 'anthropic/claude-haiku-4-5', provider: 'anthropic', desc: 'Fastest, for light interactive tasks', price: { in: 1, out: 5 }, effort: true },\n  { name: 'openai/gpt-5.2', provider: 'openai', desc: 'Strong general reasoning and tool use', price: { in: 10, out: 40 }, effort: true },\n  { name: 'openai/gpt-5.2-mini', provider: 'openai', desc: 'Small and quick for everyday edits', price: { in: 0.6, out: 2.4 }, effort: true },\n  { name: 'xai/grok-4', provider: 'xai', desc: 'Realtime knowledge, strong reasoning', price: { in: 5, out: 25 }, effort: false },\n]\n\nexport function availableModels(providerIds) {\n  return CATALOG.filter((m) => providerIds.includes(m.provider))\n}\n\nexport function findModel(name) {\n  return CATALOG.find((m) => m.name === name) || null\n}\n\nexport function defaultModel(providerIds) {\n  return availableModels(providerIds)[0] || null\n}\n\nexport function estimateCost(model, usage) {\n  if (!model?.price || !usage) return 0\n  const inCost = (usage.promptTokens || 0) * model.price.in\n  const outCost = (usage.completionTokens || 0) * model.price.out\n  return (inCost + outCost) / 1e6\n}\n", "import { readFile, writeFile } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { picoHome, ensureDir } from './paths.js'\n\nfunction configFile() {\n  return join(picoHome(), 'config.json')\n}\n\nexport async function readConfig() {\n  try {\n    return JSON.parse(await readFile(configFile(), 'utf-8'))\n  } catch {\n    return {}\n  }\n}\n\nexport async function writeConfig(patch) {\n  const config = { ...(await readConfig()), ...patch }\n  ensureDir(picoHome())\n  await writeFile(configFile(), JSON.stringify(config, null, 2) + '\\n')\n  return config\n}\n", "import { existsSync, mkdirSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { dirname, join, resolve } from 'node:path'\n\nexport function picoHome() {\n  return process.env.PICO_HOME || join(homedir(), '.pico')\n}\n\nexport function projectKey(root) {\n  return resolve(root).replace(/[/\\\\:]/g, '-')\n}\n\nexport function findProjectRoot(cwd) {\n  let dir = resolve(cwd)\n  const home = homedir()\n  while (true) {\n    if (existsSync(join(dir, '.git'))) return dir\n    const parent = dirname(dir)\n    if (parent === dir || dir === home) return resolve(cwd)\n    dir = parent\n  }\n}\n\nexport function projectDir(root) {\n  return join(picoHome(), 'projects', projectKey(root))\n}\n\nexport function sessionsDir(root) {\n  return join(projectDir(root), 'sessions')\n}\n\nexport function projectHistoryFile(root) {\n  return join(projectDir(root), 'history.jsonl')\n}\n\nexport function projectMcpFile(root) {\n  return join(projectDir(root), 'mcp.json')\n}\n\nexport function globalMcpFile() {\n  return join(picoHome(), 'mcp.json')\n}\n\nexport function globalSkillsDir() {\n  return join(picoHome(), 'skills')\n}\n\nexport function projectSkillsDir(root) {\n  return join(root, '.pico', 'skills')\n}\n\nexport function globalAgentsFile() {\n  return join(picoHome(), 'AGENTS.md')\n}\n\nexport function ensureDir(dir) {\n  mkdirSync(dir, { recursive: true })\n  return dir\n}\n", "import { existsSync, readFileSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { dirname, join, resolve } from 'node:path'\nimport { globalAgentsFile } from './paths.js'\n\nfunction readIfExists(path) {\n  try {\n    return existsSync(path) ? readFileSync(path, 'utf-8') : null\n  } catch {\n    return null\n  }\n}\n\nexport function contextStopDir(cwd) {\n  let dir = resolve(cwd)\n  const home = homedir()\n  while (true) {\n    if (existsSync(join(dir, '.git')) || dir === home) return dir\n    const parent = dirname(dir)\n    if (parent === dir) return resolve(cwd)\n    dir = parent\n  }\n}\n\nfunction ancestorDirs(cwd, stopDir) {\n  const dirs = []\n  let dir = resolve(cwd)\n  while (true) {\n    dirs.unshift(dir)\n    if (dir === stopDir) break\n    const parent = dirname(dir)\n    if (parent === dir) break\n    dir = parent\n  }\n  return dirs\n}\n\nexport function loadStartupContext(cwd) {\n  const stopDir = contextStopDir(cwd)\n  const files = []\n  const globalContent = readIfExists(globalAgentsFile())\n  if (globalContent) files.push({ path: globalAgentsFile(), content: globalContent })\n  for (const dir of ancestorDirs(cwd, stopDir)) {\n    const path = join(dir, 'AGENTS.md')\n    const content = readIfExists(path)\n    if (content) files.push({ path, content })\n  }\n  return { files, stopDir }\n}\n\nexport function createContextTracker({ stopDir, loaded }) {\n  return {\n    loaded,\n    check(filePath) {\n      const target = dirname(resolve(filePath))\n      if (!target.startsWith(stopDir)) return []\n      const fresh = []\n      for (const dir of ancestorDirs(target, stopDir)) {\n        const path = join(dir, 'AGENTS.md')\n        if (loaded.has(path)) continue\n        const content = readIfExists(path)\n        if (content) {\n          loaded.add(path)\n          fresh.push({ path, content })\n        }\n      }\n      return fresh\n    },\n  }\n}\n", "import { readFile, readdir } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { globalSkillsDir, projectSkillsDir } from './paths.js'\n\nexport function parseFrontmatter(text) {\n  const match = text.match(/^---\\n([\\s\\S]*?)\\n---\\n?/)\n  if (!match) return { meta: {}, body: text }\n  const meta = {}\n  for (const line of match[1].split('\\n')) {\n    const sep = line.indexOf(':')\n    if (sep === -1) continue\n    meta[line.slice(0, sep).trim()] = line.slice(sep + 1).trim()\n  }\n  return { meta, body: text.slice(match[0].length) }\n}\n\nasync function scanDir(dir, source) {\n  let names = []\n  try {\n    names = await readdir(dir, { withFileTypes: true })\n  } catch {\n    return []\n  }\n  const skills = []\n  for (const entry of names) {\n    if (!entry.isDirectory()) continue\n    const file = join(dir, entry.name, 'SKILL.md')\n    try {\n      const { meta } = parseFrontmatter(await readFile(file, 'utf-8'))\n      skills.push({\n        name: meta.name || entry.name,\n        description: meta.description || '',\n        source,\n        file,\n      })\n    } catch {}\n  }\n  return skills\n}\n\nexport async function createSkillIndex(root) {\n  const global = await scanDir(globalSkillsDir(), 'global')\n  const project = await scanDir(projectSkillsDir(root), 'project')\n  const byName = new Map()\n  for (const skill of [...global, ...project]) byName.set(skill.name, skill)\n  const skills = [...byName.values()]\n\n  return {\n    list: () => skills,\n    async load(name) {\n      const skill = byName.get(name)\n      if (!skill) return null\n      const { body } = parseFrontmatter(await readFile(skill.file, 'utf-8'))\n      return body\n    },\n  }\n}\n", "import { readFile, readdir } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { picoHome } from './paths.js'\nimport { parseFrontmatter } from './skills.js'\n\nexport function globalCommandsDir() {\n  return join(picoHome(), 'commands')\n}\n\nexport function projectCommandsDir(root) {\n  return join(root, '.pico', 'commands')\n}\n\nasync function scanDir(dir, source) {\n  let names = []\n  try {\n    names = await readdir(dir)\n  } catch {\n    return []\n  }\n  const commands = []\n  for (const file of names) {\n    if (!file.endsWith('.md')) continue\n    try {\n      const { meta } = parseFrontmatter(await readFile(join(dir, file), 'utf-8'))\n      commands.push({\n        name: file.slice(0, -3),\n        description: meta.description || '',\n        source,\n        file: join(dir, file),\n      })\n    } catch {}\n  }\n  return commands\n}\n\nexport function expandCommand(body, args) {\n  return body.includes('$ARGUMENTS')\n    ? body.replaceAll('$ARGUMENTS', args)\n    : args\n      ? `${body.trim()}\\n\\n${args}`\n      : body\n}\n\nexport async function createCommandIndex(root) {\n  const global = await scanDir(globalCommandsDir(), 'global')\n  const project = await scanDir(projectCommandsDir(root), 'project')\n  const byName = new Map()\n  for (const command of [...global, ...project]) byName.set(command.name, command)\n  const commands = [...byName.values()]\n\n  return {\n    list: () => commands,\n    async load(name, args = '') {\n      const command = byName.get(name)\n      if (!command) return null\n      const { body } = parseFrontmatter(await readFile(command.file, 'utf-8'))\n      return expandCommand(body.trim(), args.trim())\n    },\n  }\n}\n", "import { readFile, writeFile } from 'node:fs/promises'\nimport { connectMCP } from '@prsm/ai'\nimport { globalMcpFile, projectMcpFile, projectDir, ensureDir, picoHome } from './paths.js'\n\nexport function parseCommand(str) {\n  const tokens = []\n  const re = /\"([^\"]*)\"|'([^']*)'|(\\S+)/g\n  let m\n  while ((m = re.exec(str))) tokens.push(m[1] ?? m[2] ?? m[3])\n\n  const env = {}\n  while (tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0])) {\n    const sep = tokens[0].indexOf('=')\n    env[tokens[0].slice(0, sep)] = tokens[0].slice(sep + 1)\n    tokens.shift()\n  }\n  if (!tokens.length) throw new Error('empty command')\n  return { command: tokens[0], args: tokens.slice(1), env }\n}\n\nasync function readJson(file, fallback) {\n  try {\n    return JSON.parse(await readFile(file, 'utf-8'))\n  } catch {\n    return fallback\n  }\n}\n\nexport function readRegistry() {\n  return readJson(globalMcpFile(), { servers: {} })\n}\n\nexport async function writeRegistry(registry) {\n  ensureDir(picoHome())\n  await writeFile(globalMcpFile(), JSON.stringify(registry, null, 2) + '\\n')\n}\n\nexport function readEnablement(root) {\n  return readJson(projectMcpFile(root), { disabled: {} })\n}\n\nexport async function writeEnablement(root, enablement) {\n  ensureDir(projectDir(root))\n  await writeFile(projectMcpFile(root), JSON.stringify(enablement, null, 2) + '\\n')\n}\n\nexport async function createMcpRuntime({ root, onChange = () => {} }) {\n  const registry = await readRegistry()\n  const enablement = await readEnablement(root)\n  const servers = new Map()\n\n  for (const [name, command] of Object.entries(registry.servers)) {\n    servers.set(name, {\n      name,\n      command,\n      enabled: !enablement.disabled[name],\n      status: enablement.disabled[name] ? 'disabled' : 'idle',\n      error: null,\n      connection: null,\n    })\n  }\n\n  let StdioClientTransport = null\n\n  async function connect(name) {\n    const server = servers.get(name)\n    if (!server) return\n    server.status = 'connecting'\n    server.error = null\n    onChange()\n    try {\n      if (!StdioClientTransport) {\n        ({ StdioClientTransport } = await import('@modelcontextprotocol/sdk/client/stdio.js'))\n      }\n      const parsed = parseCommand(server.command)\n      server.connection = await connectMCP({\n        name,\n        transport: () =>\n          new StdioClientTransport({\n            command: parsed.command,\n            args: parsed.args,\n            env: { ...process.env, ...parsed.env },\n            stderr: 'pipe',\n          }),\n      })\n      server.status = 'connected'\n    } catch (err) {\n      server.status = 'error'\n      server.error = String(err.message || err).slice(0, 300)\n      server.connection = null\n    }\n    onChange()\n  }\n\n  async function disconnect(name) {\n    const server = servers.get(name)\n    if (server?.connection) {\n      await server.connection.close().catch(() => {})\n      server.connection = null\n    }\n  }\n\n  return {\n    connectAll() {\n      for (const server of servers.values()) {\n        if (server.enabled) connect(server.name)\n      }\n    },\n    async add(name, command) {\n      const registry = await readRegistry()\n      registry.servers[name] = command\n      await writeRegistry(registry)\n      servers.set(name, { name, command, enabled: true, status: 'idle', error: null, connection: null })\n      await connect(name)\n    },\n    async remove(name) {\n      const registry = await readRegistry()\n      delete registry.servers[name]\n      await writeRegistry(registry)\n      await disconnect(name)\n      servers.delete(name)\n      onChange()\n    },\n    async toggle(name) {\n      const server = servers.get(name)\n      if (!server) return\n      const enablement = await readEnablement(root)\n      if (server.enabled) {\n        server.enabled = false\n        server.status = 'disabled'\n        enablement.disabled[name] = true\n        await writeEnablement(root, enablement)\n        await disconnect(name)\n        onChange()\n      } else {\n        server.enabled = true\n        delete enablement.disabled[name]\n        await writeEnablement(root, enablement)\n        await connect(name)\n      }\n    },\n    reconnect(name) {\n      return disconnect(name).then(() => connect(name))\n    },\n    list() {\n      return [...servers.values()].map((s) => ({\n        name: s.name,\n        command: s.command,\n        enabled: s.enabled,\n        status: s.status,\n        error: s.error,\n        toolCount: s.connection?.tools.length || 0,\n        tools: (s.connection?.tools || []).map((t) => ({ name: t.name, description: t.description || '' })),\n      }))\n    },\n    tools() {\n      return [...servers.values()]\n        .filter((s) => s.connection)\n        .flatMap((s) => s.connection.tools)\n    },\n    async closeAll() {\n      for (const name of servers.keys()) await disconnect(name)\n    },\n  }\n}\n", "import { writeFile } from 'node:fs/promises'\nimport { homedir } from 'node:os'\nimport { join } from 'node:path'\nimport { createSignal, Menu, ScrollBox, Shimmer, TextArea, useFocus, useFocusTrap, useInput, useSelection } from '@trendr/core'\nimport { makeEvent } from '../core/events.js'\nimport { createSession, openSession, loadSession, listSessions } from '../core/session.js'\nimport { deriveState, userEntries, rewindStats } from '../core/derive.js'\nimport { appendPrompt, loadProjectPrompts, loadGlobalPrompts } from '../core/history.js'\nimport { runTurn, summarizeText } from '../core/agent.js'\nimport { createToolset } from '../core/tools/index.js'\nimport { revertEdits, reapplyEdits } from '../core/rewind.js'\nimport { buildSystemPrompt } from '../core/system-prompt.js'\nimport { transcriptToMarkdown } from '../core/export.js'\nimport { findModel, estimateCost } from '../core/models.js'\nimport { writeConfig } from '../core/config.js'\nimport { fuzzyScore } from './fuzzy.js'\nimport { completionContext, applyCompletion } from './completion.js'\nimport { extractImagePaths, mediaTypeFor, buildUserContent } from './attachments.js'\nimport { listFiles } from './files.js'\nimport { highlightVersion } from './highlight.js'\nimport { Message, Banner, uiTitle } from './transcript.jsx'\nimport { Help } from './help.jsx'\nimport { ModelPanel, EffortPanel, HistoryPanel, RewindPickPanel, RewindActionPanel, ResumePanel, ProjectPanel, McpPanel, timeAgo } from './panels.jsx'\nimport { accent, setAccent, DEFAULT_ACCENT, FG, FG_SOFT, MUTED, FAINT, PANEL_BG } from './theme.js'\n\nconst EFFORT_LEVELS = [\n  { key: null, desc: 'let the provider decide how much to think' },\n  { key: 'low', desc: 'quick answers, minimal thinking' },\n  { key: 'medium', desc: 'moderate thinking budget' },\n  { key: 'high', desc: 'generous thinking budget' },\n  { key: 'max', desc: 'maximum thinking budget' },\n]\n\nconst COMMANDS = [\n  { name: 'model', desc: 'Switch the active model for this session' },\n  { name: 'effort', desc: 'Set the thinking effort for this session' },\n  { name: 'resume', desc: 'Pick up a previous session where you left off' },\n  { name: 'new', desc: 'Start a new session in this project' },\n  { name: 'rewind', desc: 'Restore the conversation to a previous message' },\n  { name: 'rename', desc: 'Name this session: /rename <name>' },\n  { name: 'color', desc: 'Color this session: /color <name or #hex>' },\n  { name: 'mcp', desc: 'Manage MCP servers: add, toggle, reconnect' },\n  { name: 'compact', desc: 'Summarize the conversation to free the context window' },\n  { name: 'clear', desc: 'Clear the conversation and free the context window' },\n  { name: 'cost', desc: 'Show token usage and estimated cost so far' },\n  { name: 'export', desc: 'Save the current conversation to a markdown file' },\n  { name: 'help', desc: 'List every command and what it does' },\n]\n\nconst SESSION_COLORS = {\n  red: '#f87171',\n  orange: '#fb923c',\n  yellow: '#facc15',\n  green: '#6BE795',\n  teal: '#2dd4bf',\n  cyan: '#22d3ee',\n  blue: '#60a5fa',\n  purple: '#a78bfa',\n  pink: '#f472b6',\n  gray: '#9ca3af',\n}\n\nconst HISTORY_SCOPES = ['session', 'project', 'everywhere']\nconst RESUME_SCOPES = ['project', 'everywhere']\n\nexport function App({ boot }) {\n  const { cwd, root, version, models, skills, mcp, tracker, startupContext } = boot\n\n  const [derived, setDerived] = createSignal(deriveState([]))\n  const [overlay, setOverlay] = createSignal([])\n  const [streaming, setStreaming] = createSignal(null)\n  const [busy, setBusy] = createSignal(false)\n  const [startedAt, setStartedAt] = createSignal(0)\n  const [input, setInput] = createSignal('')\n  const [notice, setNotice] = createSignal('')\n  const [model, setModel] = createSignal(boot.initialModel)\n  const [defaultModel, setDefaultModel] = createSignal(boot.initialModel)\n  const [effort, setEffort] = createSignal(boot.initialEffort)\n  const [defaultEffort, setDefaultEffort] = createSignal(boot.initialEffort)\n  const [showEffortPanel, setShowEffortPanel] = createSignal(false)\n  const [queued, setQueued] = createSignal([])\n  const [sent, setSent] = createSignal([])\n  const [histIdx, setHistIdx] = createSignal(-1)\n  const [cmdIndex, setCmdIndex] = createSignal(0)\n  const [fileIndex, setFileIndex] = createSignal(0)\n  const [fileList, setFileList] = createSignal([])\n  const [filesDismissed, setFilesDismissed] = createSignal(false)\n  const [view, setView] = createSignal('chat')\n  const [verbose, setVerbose] = createSignal(false)\n  const [showModelPanel, setShowModelPanel] = createSignal(false)\n  const [showHistoryPanel, setShowHistoryPanel] = createSignal(false)\n  const [histScope, setHistScope] = createSignal(0)\n  const [histPrompts, setHistPrompts] = createSignal([])\n  const [showResumePanel, setShowResumePanel] = createSignal(false)\n  const [resumeScope, setResumeScope] = createSignal(0)\n  const [resumeSessions, setResumeSessions] = createSignal([])\n  const [resumeLoading, setResumeLoading] = createSignal(false)\n  const [showMcpPanel, setShowMcpPanel] = createSignal(false)\n  const [showProjectPanel, setShowProjectPanel] = createSignal(false)\n  const [projects, setProjects] = createSignal([])\n  const [projectsLoading, setProjectsLoading] = createSignal(false)\n  const [mcpServers, setMcpServers] = createSignal(mcp.list())\n  const [completing, setCompleting] = createSignal(false)\n  const [compIndex, setCompIndex] = createSignal(0)\n  const [rewindStep, setRewindStep] = createSignal(null)\n  const [rewindTarget, setRewindTarget] = createSignal(null)\n  const [offset, setOffset] = createSignal(0)\n  const [follow, setFollow] = createSignal(true)\n\n  const refs = boot.refs\n  refs.session ??= null\n  refs.allEvents ??= []\n  refs.persisted ??= 0\n  refs.abort = refs.abort || null\n  refs.rewindUndo = refs.rewindUndo || null\n  refs.quitAt ??= 0\n  refs.attachments ??= new Map()\n  refs.imageCount ??= 0\n\n  boot.setMcpNotify(() => setMcpServers(boot.mcp.list()))\n\n  const skillCommands = skills.list().map((s) => ({ name: s.name, desc: `skill \u00B7 ${s.description || s.source}`, skill: true }))\n  const userCommands = boot.commands.list().map((c) => ({ name: c.name, desc: `command \u00B7 ${c.description || c.source}`, command: true }))\n  const byName = new Map()\n  const shadowed = []\n  for (const c of [...COMMANDS, ...skillCommands, ...userCommands]) {\n    if (byName.has(c.name)) shadowed.push(`${c.skill ? 'skill' : 'command'} \"${c.name}\"`)\n    else byName.set(c.name, c)\n  }\n  const allCommands = [...byName.values()]\n  if (shadowed.length && !refs.warnedShadowed) {\n    refs.warnedShadowed = true\n    setTimeout(() => flash(`shadowed by an earlier name, rename to use: ${shadowed.join(', ')}`), 0)\n  }\n\n  function flash(msg) {\n    setNotice(msg)\n    setTimeout(() => setNotice((n) => (n === msg ? '' : n)), 2500)\n  }\n\n  function ensureSession() {\n    if (!refs.session) refs.session = createSession({ cwd, root })\n    while (refs.persisted < refs.allEvents.length) {\n      refs.session.append(refs.allEvents[refs.persisted])\n      refs.persisted++\n    }\n  }\n\n  function persist(event) {\n    refs.allEvents.push(event)\n    if (refs.session) {\n      refs.session.append(event)\n      refs.persisted = refs.allEvents.length\n    }\n  }\n\n  function reDerive() {\n    const state = deriveState(refs.allEvents)\n    setDerived(state)\n    setAccent(state.color)\n    boot.setTheme?.({ accent: state.color || DEFAULT_ACCENT })\n  }\n\n  function flushStream(items) {\n    const text = streaming()\n    if (text) items.push({ kind: 'assistant', text })\n    setStreaming(null)\n  }\n\n  async function executeTurn(text) {\n    const { content, used } = buildUserContent(text, refs.attachments)\n    for (const placeholder of used) refs.attachments.delete(placeholder)\n    persist(makeEvent('message', { message: { role: 'user', content } }))\n    ensureSession()\n    reDerive()\n    setFollow(true)\n    setBusy(true)\n    setStartedAt(Date.now())\n\n    const controller = new AbortController()\n    refs.abort = controller\n    const loadedBefore = new Set(tracker.loaded)\n    const { tools, recorder } = createToolset({\n      cwd,\n      tracker,\n      skills,\n      mcpTools: mcp.tools(),\n      signal: controller.signal,\n    })\n\n    const onStream = (event) => {\n      if (event.type === 'content') {\n        setStreaming((s) => (s || '') + event.content)\n      } else if (event.type === 'tool_calls_ready') {\n        setOverlay((o) => {\n          const next = [...o]\n          flushStream(next)\n          return next\n        })\n      } else if (event.type === 'tool_executing') {\n        setOverlay((o) => {\n          const next = [...o]\n          flushStream(next)\n          let args = {}\n          try {\n            args = JSON.parse(event.call.function.arguments)\n          } catch {}\n          next.push({\n            kind: 'tool',\n            callId: event.call.id,\n            name: event.call.function.name,\n            title: uiTitle(event.call.function.name, args),\n            status: 'running',\n          })\n          return next\n        })\n      } else if (event.type === 'tool_complete' || event.type === 'tool_error') {\n        const entry = recorder.entries.at(-1)\n        setOverlay((o) =>\n          o.map((item) =>\n            item.kind === 'tool' && item.callId === event.call.id\n              ? { ...item, ...(entry?.callId === event.call.id ? entry : {}), kind: 'tool', status: entry?.status || 'done' }\n              : item,\n          ),\n        )\n      }\n    }\n\n    let result\n    try {\n      result = await runTurn({\n        history: derived().providerHistory,\n        tools,\n        recorder,\n        modelName: model().name,\n        effort: effortApplies() ? effort() : null,\n        system: buildSystemPrompt({ cwd, contextFiles: startupContext.files, skills: skills.list() }),\n        signal: controller.signal,\n        onStream,\n      })\n    } catch (err) {\n      setOverlay([])\n      setStreaming(null)\n      setBusy(false)\n      refs.abort = null\n      flash(`error: ${String(err.message || err).slice(0, 120)}`)\n      return\n    }\n\n    for (const message of result.messages) persist(makeEvent('message', { message }))\n    for (const entry of recorder.entries) persist(makeEvent('tool_meta', entry))\n    for (const path of tracker.loaded) {\n      if (!loadedBefore.has(path)) persist(makeEvent('context_file', { path }))\n    }\n    if (result.usage) persist(makeEvent('usage', { model: model().name, usage: result.usage }))\n    if (result.interrupted) persist(makeEvent('interrupt', {}))\n\n    setOverlay([])\n    setStreaming(null)\n    reDerive()\n    setBusy(false)\n    refs.abort = null\n    if (result.stalled) flash('model stalled \u00B7 turn interrupted')\n\n    const q = queued()\n    if (q.length > 0) {\n      setQueued([])\n      if (result.interrupted) setInput(q.join('\\n'))\n      else executeTurn(q.join('\\n'))\n    }\n  }\n\n  function completionSource(name) {\n    if (name === 'color') return Object.keys(SESSION_COLORS)\n    if (name === 'effort') return ['default', 'low', 'medium', 'high', 'max']\n    if (name === 'model') return models.map((m) => m.name)\n    const cmd = allCommands.find((c) => c.name === name)\n    if (cmd?.skill || cmd?.command) return fileList()\n    return null\n  }\n\n  function dismissCompletion() {\n    setCompleting(false)\n    setCompIndex(0)\n  }\n\n  function acceptCompletion(value, ctx, candidate) {\n    setInput(applyCompletion(value, ctx, candidate))\n    dismissCompletion()\n  }\n\n  function send(text) {\n    const value = text.trim()\n    if (!value) return\n    dismissCompletion()\n    if (value.startsWith('/')) {\n      const [name, ...rest] = value.slice(1).split(/\\s+/)\n      const match = allCommands.find((c) => c.name === name.toLowerCase())\n      if (match) {\n        setInput('')\n        runCommand(match, rest.join(' '))\n        return\n      }\n    }\n    setSent((s) => [...s, { text: value, at: Date.now() }])\n    setHistIdx(-1)\n    appendPrompt(root, value).catch(() => {})\n    if (busy()) {\n      setQueued((q) => [...q, value])\n      return\n    }\n    executeTurn(value)\n  }\n\n  function interrupt() {\n    if (!busy()) return\n    refs.abort?.abort()\n  }\n\n  async function runCommand(c, args = '') {\n    setInput('')\n    if (c.name === 'rename') {\n      if (!args) return flash('usage: /rename <new name>')\n      persist(makeEvent('title', { text: args }))\n      ensureSession()\n      reDerive()\n      flash(`session renamed to \"${args}\"`)\n      return\n    }\n    if (c.name === 'color') {\n      const names = Object.keys(SESSION_COLORS)\n      const values = Object.values(SESSION_COLORS)\n      let value\n      if (!args) {\n        const next = (values.indexOf(derived().color) + 1) % values.length\n        value = values[next]\n      } else {\n        value = SESSION_COLORS[args.toLowerCase()] || (/^#[0-9a-fA-F]{6}$/.test(args) ? args : null)\n        if (!value) return flash(`usage: /color to cycle, or /color <${names.join('|')}|#hex>`)\n      }\n      persist(makeEvent('color', { value }))\n      ensureSession()\n      reDerive()\n      const name = names[values.indexOf(value)]\n      flash(`session color: ${name || value}`)\n      return\n    }\n    if (c.skill) {\n      const body = await skills.load(c.name)\n      if (!body) return flash(`could not load skill ${c.name}`)\n      persist(makeEvent('skill', { name: c.name, source: 'user' }))\n      send(`Follow these skill instructions now.\\n\\n${body}`)\n      return\n    }\n    if (c.command) {\n      const text = await boot.commands.load(c.name, args)\n      if (!text) return flash(`could not load command ${c.name}`)\n      send(text)\n      return\n    }\n    if (c.name === 'model') {\n      if (!args) return setShowModelPanel(true)\n      const exact = models.find((m) => m.name === args)\n      const scored = models\n        .map((m) => [fuzzyScore(args, m.name), m])\n        .filter(([score]) => score >= 0)\n        .sort((a, b) => b[0] - a[0])\n      const pick = exact || scored[0]?.[1]\n      if (!pick) return flash(`no available model matches \"${args}\"`)\n      persist(makeEvent('model_switch', { from: model().name, to: pick.name }))\n      setModel(pick)\n      flash(`model set to ${pick.name}`)\n      return\n    }\n    if (c.name === 'effort') {\n      if (!effortApplies()) return flash(`${model().name} does not support effort control`)\n      if (!args) return setShowEffortPanel(true)\n      const level = args.toLowerCase()\n      if (level === 'default') return setSessionEffort(null)\n      if (!EFFORT_LEVELS.some((l) => l.key === level)) return flash('usage: /effort <default|low|medium|high|max>')\n      return setSessionEffort(level)\n    }\n    if (c.name === 'help') return setView('help')\n    if (c.name === 'mcp') return setShowMcpPanel(true)\n    if (c.name === 'resume') {\n      setShowResumePanel(true)\n      refreshSessions(resumeScope())\n      return\n    }\n    if (c.name === 'new') {\n      if (busy()) return flash('finish or interrupt the current turn first')\n      refs.session = null\n      refs.allEvents = []\n      refs.persisted = 0\n      refs.rewindUndo = null\n      setQueued([])\n      setSent([])\n      setModel(defaultModel())\n      setEffort(defaultEffort())\n      reDerive()\n      flash('new session')\n      return\n    }\n    if (c.name === 'rewind') {\n      if (busy()) return flash('finish or interrupt the current turn first')\n      if (userEntries(derived()).length === 0) return flash('nothing to rewind yet')\n      setRewindStep('pick')\n      return\n    }\n    if (c.name === 'clear') {\n      if (busy()) return flash('finish or interrupt the current turn first')\n      persist(makeEvent('clear', {}))\n      reDerive()\n      flash('conversation cleared')\n      return\n    }\n    if (c.name === 'compact') {\n      if (busy()) return flash('finish or interrupt the current turn first')\n      const history = derived().providerHistory\n      if (history.length === 0) return flash('nothing to compact yet')\n      flash('compacting...')\n      try {\n        const text = history.map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : ''}`).join('\\n')\n        const summary = await summarizeText({ text, modelName: model().name })\n        persist(makeEvent('compact', { summary }))\n        reDerive()\n        flash('conversation compacted')\n      } catch (err) {\n        flash(`compact failed: ${String(err.message || err).slice(0, 80)}`)\n      }\n      return\n    }\n    if (c.name === 'cost') {\n      const byModel = derived().usageByModel\n      const entries = Object.entries(byModel)\n      if (entries.length === 0) return flash('no usage yet')\n      const total = entries.reduce((sum, [name, usage]) => sum + estimateCost(findModel(name), usage), 0)\n      const { promptTokens, completionTokens } = derived().usage\n      flash(`$${total.toFixed(4)} \u00B7 ${promptTokens.toLocaleString()} in \u00B7 ${completionTokens.toLocaleString()} out`)\n      return\n    }\n    if (c.name === 'export') {\n      const file = join(cwd, `pico-export-${Date.now()}.md`)\n      await writeFile(file, transcriptToMarkdown(derived().transcript, { title: `pico session \u00B7 ${cwd}` }))\n      flash(`exported to ${file}`)\n      return\n    }\n  }\n\n  function refreshSessions(scopeIndex) {\n    setResumeLoading(true)\n    listSessions({ scope: RESUME_SCOPES[scopeIndex], root })\n      .then((sessions) => setResumeSessions(sessions.filter((s) => s.header.id !== refs.session?.id)))\n      .finally(() => setResumeLoading(false))\n  }\n\n  function shortenPath(path) {\n    const home = homedir()\n    return path.startsWith(home) ? path.replace(home, '~') : path\n  }\n\n  function openProjectPanel() {\n    setShowProjectPanel(true)\n    setProjectsLoading(true)\n    listSessions({ scope: 'everywhere', root })\n      .then((metas) => {\n        const byRoot = new Map()\n        for (const m of metas) {\n          const entry = byRoot.get(m.header.root)\n          if (!entry) {\n            byRoot.set(m.header.root, {\n              root: m.header.root,\n              path: shortenPath(m.header.root),\n              latest: m,\n              count: 1,\n              current: m.header.root === boot.root,\n            })\n          } else {\n            entry.count++\n          }\n        }\n        setProjects([...byRoot.values()])\n      })\n      .finally(() => setProjectsLoading(false))\n  }\n\n  async function switchProject(meta) {\n    if (busy()) return flash('finish or interrupt the current turn first')\n    try {\n      const previousMcp = boot.mcp\n      const next = await boot.rebuild(meta.header.root)\n      previousMcp.closeAll().catch(() => {})\n      process.chdir(next.cwd)\n      Object.assign(boot, next)\n      next.mcp.connectAll()\n      setMcpServers(next.mcp.list())\n      setQueued([])\n      setFileList([])\n      await resumeSession(meta)\n      flash(`switched to ${next.displayCwd}`)\n    } catch (err) {\n      flash(`switch failed: ${String(err.message || err).slice(0, 80)}`)\n    }\n  }\n\n  async function resumeSession(meta) {\n    setShowResumePanel(false)\n    setShowProjectPanel(false)\n    if (meta.header.root !== boot.root) return switchProject(meta)\n    try {\n      const { header, events } = await loadSession(meta.file)\n      refs.session = openSession({ file: meta.file, header })\n      refs.allEvents = [...events]\n      refs.persisted = events.length\n      refs.rewindUndo = null\n      reDerive()\n      const restored = derived().model && models.find((m) => m.name === derived().model)\n      if (restored) {\n        setModel(restored)\n      } else {\n        setModel(defaultModel())\n        if (derived().model) flash(`model ${derived().model} unavailable, using ${defaultModel().name}`)\n      }\n      setEffort(derived().effort === undefined ? defaultEffort() : derived().effort)\n      setSent(userEntries(derived()).map((e) => ({ text: e.text, at: header.createdAt })))\n      setFollow(true)\n      flash(`resumed \u00B7 ${meta.turns} ${meta.turns === 1 ? 'turn' : 'turns'} \u00B7 ${timeAgo(meta.at)}`)\n    } catch (err) {\n      flash(`resume failed: ${String(err.message || err).slice(0, 80)}`)\n    }\n  }\n\n  function openHistorySearch() {\n    const session = sent()\n    setHistPrompts(dedupePrompts(session))\n    setShowHistoryPanel(true)\n    setHistScope(0)\n  }\n\n  function dedupePrompts(pool) {\n    const seen = new Set()\n    const out = []\n    for (const entry of [...pool].sort((a, b) => b.at - a.at)) {\n      if (seen.has(entry.text)) continue\n      seen.add(entry.text)\n      out.push(entry)\n    }\n    return out\n  }\n\n  async function switchHistScope(next) {\n    setHistScope(next)\n    if (next === 0) return setHistPrompts(dedupePrompts(sent()))\n    const project = await loadProjectPrompts(root)\n    if (next === 1) return setHistPrompts(dedupePrompts([...sent(), ...project]))\n    const global = await loadGlobalPrompts()\n    setHistPrompts(dedupePrompts([...sent(), ...project, ...global]))\n  }\n\n  async function performRewind(opt) {\n    const target = rewindTarget()\n    const state = derived()\n    const { edits } = rewindStats(state, target.index)\n    const editsLabel = `${edits.length} ${edits.length === 1 ? 'edit' : 'edits'}`\n    let reverted = []\n    let skipped = []\n\n    if (opt.key === 'both' || opt.key === 'code') {\n      const result = await revertEdits(edits)\n      reverted = result.reverted\n      skipped = result.skipped\n    }\n\n    let summaryText = null\n    if (opt.key === 'summary') {\n      const tail = state.transcript.slice(target.index)\n      const text = tail.filter((m) => m.text).map((m) => `${m.kind}: ${m.text}`).join('\\n')\n      flash('summarizing...')\n      summaryText = await summarizeText({ text, modelName: model().name }).catch(() =>\n        tail.filter((m) => m.text).slice(0, 3).map((m) => m.text.split(/\\s+/).slice(0, 6).join(' ')).join(' \u00B7 '),\n      )\n    }\n\n    const event = makeEvent('rewind', { target: target.eventId, mode: opt.key, summaryText, reverted, skipped })\n    persist(event)\n    refs.rewindUndo = { rewindId: event.id, edits: edits.filter((e) => reverted.includes(e.callId)) }\n    reDerive()\n    if (opt.key !== 'code') setInput(target.text)\n\n    const skippedNote = skipped.length ? ` \u00B7 skipped ${skipped.length} drifted` : ''\n    if (opt.key === 'code') flash(`reverted ${editsLabel}, conversation kept${skippedNote} \u00B7 ctrl+z to undo`)\n    else if (opt.key === 'summary') flash(`rewound and summarized${skippedNote} \u00B7 ctrl+z to undo`)\n    else if (opt.key === 'both') flash(`rewound, ${editsLabel} reverted${skippedNote} \u00B7 ctrl+z to undo`)\n    else flash(`rewound, file changes kept \u00B7 ctrl+z to undo`)\n    setRewindStep(null)\n    setRewindTarget(null)\n  }\n\n  async function undoRewind() {\n    const undo = refs.rewindUndo\n    if (!undo) return\n    const { skipped } = await reapplyEdits(undo.edits)\n    persist(makeEvent('rewind_undo', { rewindId: undo.rewindId }))\n    refs.rewindUndo = null\n    reDerive()\n    flash(skipped.length ? `rewind undone \u00B7 ${skipped.length} file(s) drifted` : 'rewind undone')\n  }\n\n  const anyPanel = () =>\n    showModelPanel() || showEffortPanel() || showHistoryPanel() || showResumePanel() || showMcpPanel() ||\n    showProjectPanel() || rewindStep() !== null\n\n  const effortApplies = () => !!model().effort\n\n  function setSessionEffort(next, { asDefault = false } = {}) {\n    persist(makeEvent('effort', { to: next }))\n    setEffort(next)\n    if (asDefault) {\n      setDefaultEffort(next)\n      writeConfig({ defaultEffort: next }).catch(() => {})\n    }\n    flash(`effort: ${next ?? 'default'}${asDefault ? ' \u00B7 saved as default' : ''}`)\n  }\n\n  const fm = useFocus({ initial: 'input' })\n  fm.item('feed')\n  fm.item('input')\n  useFocusTrap(anyPanel() || view() === 'help')\n  useSelection({\n    onCopy: (text) => flash(`copied ${text.length} ${text.length === 1 ? 'character' : 'characters'}`),\n  })\n\n  useInput((event) => {\n    if (event.key === 'escape' && busy() && !anyPanel()) {\n      interrupt()\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 'c') {\n      const now = Date.now()\n      if (now - refs.quitAt < 1500) {\n        mcp.closeAll().catch(() => {}).finally(() => process.exit(0))\n      } else {\n        refs.quitAt = now\n        flash('ctrl+c again to exit')\n      }\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 'o') {\n      setVerbose((v) => !v)\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 'r' && view() === 'chat' && !anyPanel()) {\n      openHistorySearch()\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 's' && view() === 'chat' && !anyPanel()) {\n      setShowResumePanel(true)\n      refreshSessions(resumeScope())\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 't' && view() === 'chat' && !anyPanel()) {\n      setShowModelPanel(true)\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 'p' && view() === 'chat' && !anyPanel()) {\n      openProjectPanel()\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 'b' && view() === 'chat' && !anyPanel()) {\n      if (!effortApplies()) flash(`${model().name} does not support effort control`)\n      else {\n        const order = [null, 'low', 'medium', 'high', 'max']\n        const next = order[(order.indexOf(effort() ?? null) + 1) % order.length]\n        setSessionEffort(next)\n      }\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 's' && showHistoryPanel()) {\n      switchHistScope((histScope() + 1) % HISTORY_SCOPES.length)\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 's' && showResumePanel()) {\n      const next = (resumeScope() + 1) % RESUME_SCOPES.length\n      setResumeScope(next)\n      refreshSessions(next)\n      event.stopPropagation()\n      return\n    }\n    if (event.ctrl && event.key === 'z' && refs.rewindUndo && !busy() && view() === 'chat') {\n      undoRewind()\n      event.stopPropagation()\n    }\n  })\n\n  const elapsed = busy() ? Math.max(0, Math.floor((Date.now() - startedAt()) / 1000)) : 0\n\n  const slashQuery = input().startsWith('/') ? input().slice(1) : null\n  const showCommands = slashQuery !== null && !slashQuery.includes(' ') && !anyPanel()\n  const matchedCommands = showCommands\n    ? allCommands.filter((c) => c.name.toLowerCase().startsWith(slashQuery.toLowerCase()))\n    : []\n\n  const atMatch = input().match(/(^|[\\s(])@([^\\s@]*)$/)\n  const showFiles = atMatch !== null && !showCommands && !filesDismissed() && !anyPanel()\n  if (showFiles) {\n    listFiles(cwd).then((files) => {\n      if (files !== fileList()) setFileList(files)\n    })\n  }\n  const matchedFiles = showFiles\n    ? fileList()\n        .map((f) => [fuzzyScore(atMatch[2], f), f])\n        .filter(([score]) => score >= 0)\n        .sort((a, b) => b[0] - a[0])\n        .map(([, f]) => f)\n    : []\n\n  function pickFile(f) {\n    const v = input()\n    const at = v.lastIndexOf('@')\n    setInput(v.slice(0, at + 1) + f + ' ')\n    setFileIndex(0)\n  }\n\n  const compCtx = completing() ? completionContext({ value: input(), resolve: completionSource }) : null\n  const showCompletion = !!compCtx && compCtx.matches.length > 0 && !showCommands && !showFiles && !anyPanel()\n\n  const rewindEntries = () => userEntries(derived())\n  const rewindOptions = (() => {\n    const target = rewindTarget()\n    if (!target) return []\n    const { msgs, edits } = rewindStats(derived(), target.index)\n    const e = edits.length\n    const editsLabel = `${e} ${e === 1 ? 'edit' : 'edits'}`\n    const opts = []\n    if (e > 0) opts.push({ key: 'both', label: 'restore code and conversation', desc: `chat returns to this message \u00B7 ${editsLabel} reverted` })\n    opts.push({\n      key: 'chat',\n      label: e > 0 ? 'restore conversation only' : 'restore conversation',\n      desc: e > 0 ? 'chat returns to this message \u00B7 file changes kept' : `chat returns to this message \u00B7 drops ${msgs} entries`,\n    })\n    if (e > 0) opts.push({ key: 'code', label: 'restore code only', desc: `conversation kept \u00B7 ${editsLabel} reverted` })\n    opts.push({ key: 'summary', label: 'rewind and keep a summary', desc: 'dropped entries collapse into a one-line note' })\n    return opts\n  })()\n\n  const { usage } = derived()\n\n  if (view() === 'help') {\n    return <Help commands={COMMANDS} onClose={() => setView('chat')} />\n  }\n\n  highlightVersion()\n\n  const items = [...derived().transcript, ...overlay()]\n\n  return (\n    <box style={{ flexDirection: 'column', height: '100%' }}>\n      <ScrollBox\n        style={{ flexGrow: 1 }}\n        focused={fm.is('feed')}\n        scrollOffset={follow() ? 1e9 : offset()}\n        onScroll={(next) => { setFollow(false); setOffset(next) }}\n        scrollbar\n      >\n        {items.length === 0 && <Banner version={version} cwd={boot.displayCwd} modelName={model().name} />}\n        {items.map((item, i) => <Message key={i} item={item} verbose={verbose()} />)}\n        {streaming() !== null && streaming() !== '' && (\n          <Message key=\"streaming\" item={{ kind: 'assistant', text: `${streaming()}\u258B` }} />\n        )}\n      </ScrollBox>\n\n      {queued().length > 0 && (\n        <box style={{ flexDirection: 'column', paddingX: 2, marginTop: 1 }}>\n          {queued().map((q, i) => (\n            <box key={i} style={{ flexDirection: 'row' }}>\n              <text style={{ color: FAINT }}>{'\u203A '}</text>\n              <box style={{ flexGrow: 1, height: 1 }}>\n                <text style={{ overflow: 'truncate', color: MUTED }}>{q.replace(/\\n/g, ' ')}</text>\n              </box>\n              {i === 0 && <text style={{ color: FAINT, dim: true }}>{'  pending \u00B7 \u2191 to edit'}</text>}\n            </box>\n          ))}\n        </box>\n      )}\n\n      <box style={{ bg: PANEL_BG, flexDirection: 'row', paddingX: 2, paddingY: 1, marginTop: 1 }}>\n        <text style={{ color: accent(), bold: true }}>{'\u276F'}</text>\n        <text> </text>\n        {derived().title && (\n          <box style={{ position: 'absolute', top: 0, right: 0 }}>\n            <text style={{ bg: accent(), color: 'black', bold: true }}>{` ${derived().title} `}</text>\n          </box>\n        )}\n        <TextArea\n          value={input()}\n          onChange={(v) => { setInput(v); setCmdIndex(0); setFileIndex(0); setHistIdx(-1); setFilesDismissed(false) }}\n          onCancel={() => { if (busy()) interrupt(); else setInput('') }}\n          onSubmit={send}\n          onKeyDown={(e) => {\n            if (e.key === 'paste' && e.text) {\n              const paths = extractImagePaths(e.text)\n              if (paths.length > 0) {\n                const placeholders = paths.map((path) => {\n                  const placeholder = `[Image #${++refs.imageCount}]`\n                  refs.attachments.set(placeholder, { path, mediaType: mediaTypeFor(path) })\n                  return placeholder\n                })\n                const at = e.cursor ?? e.value.length\n                setInput(e.value.slice(0, at) + placeholders.join(' ') + e.value.slice(at))\n                return true\n              }\n              return false\n            }\n            if (e.key === 'backspace' && e.cursor > 0) {\n              const match = e.value.slice(0, e.cursor).match(/\\[Image #\\d+\\]$/)\n              if (match) {\n                refs.attachments.delete(match[0])\n                setInput(e.value.slice(0, e.cursor - match[0].length) + e.value.slice(e.cursor))\n                return true\n              }\n            }\n            if (e.key === 'tab' && !e.ctrl && !e.meta) {\n              const ctx = completionContext({ value: e.value, resolve: completionSource })\n              if (!ctx) return false\n              if (!completing()) {\n                setCompleting(true)\n                setCompIndex(0)\n                listFiles(cwd).then((files) => {\n                  if (files !== fileList()) setFileList(files)\n                })\n              } else if (ctx.matches.length > 0) {\n                acceptCompletion(e.value, ctx, ctx.matches[Math.min(compIndex(), ctx.matches.length - 1)])\n              }\n              return true\n            }\n            if (e.ctrl || e.meta || showCommands || showFiles) return false\n            if (e.key === 'up' && e.value === '' && queued().length > 0) {\n              setInput(queued().join('\\n'))\n              setQueued([])\n              return true\n            }\n            const browsing = histIdx() >= 0\n            if (e.key === 'up' && (browsing || e.value === '') && histIdx() < sent().length - 1) {\n              const n = histIdx() + 1\n              setHistIdx(n)\n              setInput(sent()[sent().length - 1 - n].text)\n              return true\n            }\n            if (e.key === 'down' && browsing) {\n              const n = histIdx() - 1\n              setHistIdx(n)\n              setInput(n < 0 ? '' : sent()[sent().length - 1 - n].text)\n              return true\n            }\n            return false\n          }}\n          submitOnEnter\n          clearOnSubmit\n          focused={fm.is('input') && !anyPanel()}\n          maxHeight={8}\n          placeholder=\"enter to send \u00B7 / commands \u00B7 @ files \u00B7 tab to scroll\"\n          cursor={{ blink: true, bg: accent(), color: 'black' }}\n        />\n      </box>\n\n      {showCommands && (\n        <box style={{ flexDirection: 'column', paddingX: 2, marginTop: 1 }}>\n          {matchedCommands.length === 0 ? (\n            <text style={{ color: FAINT }}>no matching commands</text>\n          ) : (\n            <Menu\n              items={matchedCommands}\n              selected={cmdIndex()}\n              onSelect={setCmdIndex}\n              onSubmit={runCommand}\n              focused={showCommands}\n              maxVisible={5}\n              scrolloff={2}\n              renderItem={(c, { active }) => (\n                <box style={{ flexDirection: 'row' }}>\n                  <text style={{ color: accent() }}>{active ? '\u203A ' : '  '}</text>\n                  <text style={{ color: active ? accent() : MUTED }}>{`/${c.name}`.padEnd(12)}</text>\n                  <text style={{ color: active ? '#cbd5e1' : FAINT }}>{c.desc}</text>\n                </box>\n              )}\n            />\n          )}\n        </box>\n      )}\n\n      {showFiles && matchedFiles.length > 0 && (\n        <box style={{ flexDirection: 'column', paddingX: 2, marginTop: 1 }}>\n          <Menu\n            items={matchedFiles}\n            selected={fileIndex()}\n            onSelect={setFileIndex}\n            onSubmit={pickFile}\n            onCancel={() => setFilesDismissed(true)}\n            focused={showFiles}\n            maxVisible={5}\n            scrolloff={2}\n            renderItem={(f, { active }) => (\n              <box style={{ flexDirection: 'row' }}>\n                <text style={{ color: accent() }}>{active ? '\u203A ' : '  '}</text>\n                <text style={{ color: active ? accent() : FG_SOFT }}>{f}</text>\n              </box>\n            )}\n          />\n        </box>\n      )}\n\n      {showCompletion && (\n        <box style={{ flexDirection: 'column', paddingX: 2, marginTop: 1 }}>\n          <Menu\n            items={compCtx.matches}\n            selected={compIndex()}\n            onSelect={setCompIndex}\n            onSubmit={(candidate) => acceptCompletion(input(), compCtx, candidate)}\n            onCancel={dismissCompletion}\n            focused={showCompletion}\n            maxVisible={5}\n            scrolloff={2}\n            renderItem={(candidate, { active }) => (\n              <box style={{ flexDirection: 'row' }}>\n                <text style={{ color: accent() }}>{active ? '\u203A ' : '  '}</text>\n                <text style={{ color: active ? accent() : FG_SOFT }}>{candidate}</text>\n              </box>\n            )}\n          />\n        </box>\n      )}\n\n      {showModelPanel() && (\n        <ModelPanel\n          models={models}\n          current={model().name}\n          defaultName={defaultModel().name}\n          focused={showModelPanel()}\n          onPick={(m) => {\n            persist(makeEvent('model_switch', { from: model().name, to: m.name }))\n            setModel(m)\n            setShowModelPanel(false)\n            flash(`model set to ${m.name}`)\n          }}\n          onPickDefault={(m) => {\n            persist(makeEvent('model_switch', { from: model().name, to: m.name }))\n            setModel(m)\n            setDefaultModel(m)\n            writeConfig({ defaultModel: m.name }).catch(() => {})\n            setShowModelPanel(false)\n            flash(`model set to ${m.name} \u00B7 saved as default`)\n          }}\n          onClose={() => setShowModelPanel(false)}\n        />\n      )}\n\n      {showEffortPanel() && (\n        <EffortPanel\n          levels={EFFORT_LEVELS}\n          current={effort() ?? null}\n          defaultLevel={defaultEffort() ?? null}\n          focused={showEffortPanel()}\n          onPick={(l) => {\n            setSessionEffort(l.key)\n            setShowEffortPanel(false)\n          }}\n          onPickDefault={(l) => {\n            setSessionEffort(l.key, { asDefault: true })\n            setShowEffortPanel(false)\n          }}\n          onClose={() => setShowEffortPanel(false)}\n        />\n      )}\n\n      {showHistoryPanel() && (\n        <HistoryPanel\n          prompts={histPrompts()}\n          scopes={HISTORY_SCOPES}\n          scopeIndex={histScope()}\n          focused={showHistoryPanel()}\n          onPick={(text) => { setInput(text); setShowHistoryPanel(false) }}\n          onClose={() => setShowHistoryPanel(false)}\n        />\n      )}\n\n      {showResumePanel() && (\n        <ResumePanel\n          sessions={resumeSessions()}\n          scopes={RESUME_SCOPES}\n          scopeIndex={resumeScope()}\n          loading={resumeLoading()}\n          focused={showResumePanel()}\n          onPick={resumeSession}\n          onClose={() => setShowResumePanel(false)}\n        />\n      )}\n\n      {showProjectPanel() && (\n        <ProjectPanel\n          projects={projects()}\n          loading={projectsLoading()}\n          focused={showProjectPanel()}\n          onPick={(p) => resumeSession(p.latest)}\n          onClose={() => setShowProjectPanel(false)}\n        />\n      )}\n\n      {showMcpPanel() && (\n        <McpPanel\n          servers={mcpServers()}\n          focused={showMcpPanel()}\n          onToggle={(name) => mcp.toggle(name)}\n          onReconnect={(name) => mcp.reconnect(name)}\n          onRemove={(name) => mcp.remove(name)}\n          onAdd={(name, command) => {\n            mcp.add(name, command)\n            flash(`added ${name}`)\n          }}\n          onClose={() => setShowMcpPanel(false)}\n        />\n      )}\n\n      {rewindStep() === 'pick' && (\n        <RewindPickPanel\n          entries={[...rewindEntries()].reverse()}\n          stats={(index) => rewindStats(derived(), index)}\n          focused={rewindStep() === 'pick'}\n          onPick={(entry) => { setRewindTarget(entry); setRewindStep('action') }}\n          onClose={() => setRewindStep(null)}\n        />\n      )}\n\n      {rewindStep() === 'action' && rewindTarget() && (\n        <RewindActionPanel\n          target={rewindTarget()}\n          options={rewindOptions}\n          focused={rewindStep() === 'action'}\n          onSubmit={performRewind}\n          onBack={() => setRewindStep('pick')}\n        />\n      )}\n\n      <box style={{ flexDirection: 'row', paddingX: 2, gap: 1, marginTop: 1 }}>\n        {notice()\n          ? <text style={{ color: accent() }}>{notice()}</text>\n          : busy()\n            ? (\n              <box style={{ flexDirection: 'row' }}>\n                <Shimmer color={accent()} highlight=\"white\" duration={1500} reverse>Responding</Shimmer>\n                <text style={{ color: FAINT }}>{` (${elapsed}s) \u00B7 esc to interrupt`}</text>\n              </box>\n            )\n            : null}\n        <box style={{ flexGrow: 1 }} />\n        <text style={{ color: accent() }}>{model().name}</text>\n        {effortApplies() && effort() && <text style={{ color: MUTED }}>{`\u00B7 ${effort()}`}</text>}\n        <text style={{ color: FAINT }}>\u2191</text>\n        <text style={{ color: MUTED }}>{`${usage.promptTokens.toLocaleString()} in`}</text>\n        <text style={{ color: FAINT }}>\u2193</text>\n        <text style={{ color: MUTED }}>{`${usage.completionTokens.toLocaleString()} out`}</text>\n      </box>\n    </box>\n  )\n}\n", "import { randomUUID } from 'node:crypto'\n\nexport const SESSION_VERSION = 1\n\nexport function makeEvent(type, data = {}) {\n  return { id: randomUUID(), at: Date.now(), type, data }\n}\n\nexport function makeHeader({ cwd, root }) {\n  return {\n    type: 'session',\n    version: SESSION_VERSION,\n    id: randomUUID(),\n    cwd,\n    root,\n    createdAt: Date.now(),\n  }\n}\n\nexport function serializeLine(event) {\n  return JSON.stringify(event) + '\\n'\n}\n\nexport function parseLine(line) {\n  const trimmed = line.trim()\n  if (!trimmed) return null\n  try {\n    const parsed = JSON.parse(trimmed)\n    return parsed && typeof parsed.type === 'string' ? parsed : null\n  } catch {\n    return null\n  }\n}\n\nexport function parseLines(text) {\n  return text.split('\\n').map(parseLine).filter(Boolean)\n}\n", "import { appendFile, readFile, readdir, stat } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { picoHome, sessionsDir, ensureDir } from './paths.js'\nimport { makeHeader, serializeLine, parseLines, parseLine } from './events.js'\n\nexport function createSession({ cwd, root }) {\n  const header = makeHeader({ cwd, root })\n  const file = join(ensureDir(sessionsDir(root)), `${header.id}.jsonl`)\n  const session = openSession({ file, header })\n  session.append(header)\n  return session\n}\n\nexport function openSession({ file, header }) {\n  let queue = Promise.resolve()\n  return {\n    id: header.id,\n    file,\n    header,\n    append(event) {\n      queue = queue.then(() => appendFile(file, serializeLine(event)))\n      return queue\n    },\n    flush() {\n      return queue\n    },\n  }\n}\n\nexport async function loadSession(file) {\n  const events = parseLines(await readFile(file, 'utf-8'))\n  const header = events[0]?.type === 'session' ? events.shift() : null\n  if (!header) throw new Error(`not a pico session file: ${file}`)\n  return { header, events }\n}\n\nasync function sessionMeta(file) {\n  const [info, handle] = await Promise.all([stat(file), readFile(file, 'utf-8')])\n  const lines = handle.split('\\n')\n  const header = parseLine(lines[0])\n  if (!header || header.type !== 'session') return null\n  let title = null\n  let color = null\n  let turns = 0\n  for (const line of lines.slice(1)) {\n    const event = parseLine(line)\n    if (!event) continue\n    if (event.type === 'title') title = event.data.text\n    if (event.type === 'color') color = event.data.value\n    if (event.type === 'message' && event.data.message?.role === 'user') {\n      turns++\n      const content = event.data.message.content\n      const text = Array.isArray(content)\n        ? content.filter((p) => p.type === 'text').map((p) => p.text).join(' ')\n        : String(content)\n      if (!title && text.trim()) title = text.trim().slice(0, 200)\n    }\n  }\n  if (!title) return null\n  return { file, header, title, color, turns, at: info.mtimeMs }\n}\n\nasync function listDir(dir) {\n  try {\n    const names = await readdir(dir)\n    return names.filter((n) => n.endsWith('.jsonl')).map((n) => join(dir, n))\n  } catch {\n    return []\n  }\n}\n\nexport async function listSessions({ scope, root }) {\n  let files = []\n  if (scope === 'everywhere') {\n    const projectsDir = join(picoHome(), 'projects')\n    let projects = []\n    try {\n      projects = await readdir(projectsDir)\n    } catch {}\n    const nested = await Promise.all(\n      projects.map((p) => listDir(join(projectsDir, p, 'sessions'))),\n    )\n    files = nested.flat()\n  } else {\n    files = await listDir(sessionsDir(root))\n  }\n  const metas = await Promise.all(files.map((f) => sessionMeta(f).catch(() => null)))\n  return metas.filter(Boolean).sort((a, b) => b.at - a.at)\n}\n", "const DROPPING_MODES = ['both', 'chat', 'summary']\n\nfunction activeRewinds(events) {\n  const canceled = new Set()\n  for (const e of events) {\n    if (e.type === 'rewind_undo') canceled.add(e.data.rewindId)\n  }\n  return events.filter((e) => e.type === 'rewind' && !canceled.has(e.id))\n}\n\nfunction droppedIds(events) {\n  const dropped = new Set()\n  const index = new Map(events.map((e, i) => [e.id, i]))\n  for (const rewind of activeRewinds(events)) {\n    if (!DROPPING_MODES.includes(rewind.data.mode)) continue\n    const from = index.get(rewind.data.target)\n    const to = index.get(rewind.id)\n    if (from === undefined || to === undefined) continue\n    for (let i = from; i < to; i++) dropped.add(events[i].id)\n  }\n  return dropped\n}\n\nfunction addUsageInto(total, usage) {\n  total.promptTokens += usage.promptTokens || 0\n  total.completionTokens += usage.completionTokens || 0\n  total.totalTokens += usage.totalTokens || 0\n  total.cachedTokens += usage.cachedTokens || 0\n}\n\nfunction emptyUsage() {\n  return { promptTokens: 0, completionTokens: 0, totalTokens: 0, cachedTokens: 0 }\n}\n\nfunction parseArgs(raw) {\n  try {\n    return JSON.parse(raw)\n  } catch {\n    return { _raw: raw }\n  }\n}\n\nfunction foldMessage(state, event) {\n  const message = event.data.message\n  if (!message || message.role === 'system') return\n  state.providerHistory.push(message)\n\n  if (message.role === 'user') {\n    const text = Array.isArray(message.content)\n      ? message.content\n          .map((p) => (p.type === 'text' ? p.text : `[image: ${String(p.source?.path || '').split('/').pop() || 'attached'}]`))\n          .join('')\n      : String(message.content)\n    state.transcript.push({ kind: 'user', text, eventId: event.id })\n    return\n  }\n  if (message.role === 'assistant') {\n    if (message.content) {\n      state.transcript.push({ kind: 'assistant', text: message.content, model: state.model })\n    }\n    for (const call of message.tool_calls || []) {\n      const item = {\n        kind: 'tool',\n        callId: call.id,\n        name: call.function.name,\n        args: parseArgs(call.function.arguments),\n        title: call.function.name,\n        status: 'done',\n        eventId: event.id,\n      }\n      state.transcript.push(item)\n      state.toolItems.set(call.id, item)\n    }\n    return\n  }\n  if (message.role === 'tool') {\n    const item = state.toolItems.get(message.tool_call_id)\n    if (item) item.resultText = String(message.content)\n  }\n}\n\nfunction foldRewind(state, event) {\n  const { mode, summaryText, reverted = [] } = event.data\n  for (const callId of reverted) {\n    const item = state.toolItems.get(callId)\n    if (item) item.status = 'reverted'\n  }\n  if (mode === 'summary' && summaryText) {\n    state.transcript.push({ kind: 'summary', text: summaryText })\n    state.providerHistory.push({\n      role: 'assistant',\n      content: `[summary of the rewound conversation]\\n${summaryText}`,\n    })\n  }\n}\n\nexport function deriveState(events) {\n  const dropped = droppedIds(events)\n  const canceledUndoTargets = new Set(\n    events.filter((e) => e.type === 'rewind_undo').map((e) => e.data.rewindId),\n  )\n\n  const state = {\n    transcript: [],\n    providerHistory: [],\n    model: null,\n    effort: undefined,\n    usage: emptyUsage(),\n    usageByModel: {},\n    loadedContext: new Set(),\n    toolItems: new Map(),\n  }\n\n  for (const event of events) {\n    if (event.type === 'usage') {\n      addUsageInto(state.usage, event.data.usage)\n      const byModel = (state.usageByModel[event.data.model] ||= emptyUsage())\n      addUsageInto(byModel, event.data.usage)\n      continue\n    }\n    if (dropped.has(event.id)) continue\n\n    switch (event.type) {\n      case 'message':\n        foldMessage(state, event)\n        break\n      case 'tool_meta': {\n        const item = state.toolItems.get(event.data.callId)\n        if (item) Object.assign(item, event.data, { kind: 'tool', callId: item.callId })\n        break\n      }\n      case 'interrupt': {\n        const last = state.transcript.at(-1)\n        if (last?.kind === 'assistant') last.interrupted = true\n        if (last?.kind === 'tool' && last.status === 'running') last.status = 'interrupted'\n        break\n      }\n      case 'model_switch':\n        state.model = event.data.to\n        break\n      case 'effort':\n        state.effort = event.data.to\n        break\n      case 'title':\n        state.title = event.data.text\n        break\n      case 'color':\n        state.color = event.data.value\n        break\n      case 'rewind':\n        if (!canceledUndoTargets.has(event.id)) foldRewind(state, event)\n        break\n      case 'compact':\n        state.providerHistory = [\n          { role: 'user', content: `[conversation summary]\\n${event.data.summary}` },\n          { role: 'assistant', content: 'Got it. Continuing from that summary.' },\n        ]\n        state.transcript.push({ kind: 'summary', text: event.data.summary })\n        break\n      case 'clear':\n        state.transcript = []\n        state.providerHistory = []\n        state.toolItems = new Map()\n        break\n      case 'context_file':\n        state.loadedContext.add(event.data.path)\n        break\n      case 'skill':\n        state.transcript.push({ kind: 'skill', name: event.data.name })\n        break\n    }\n  }\n\n  return state\n}\n\nexport function userEntries(state) {\n  const entries = []\n  state.transcript.forEach((item, index) => {\n    if (item.kind === 'user') entries.push({ text: item.text, index, eventId: item.eventId })\n  })\n  return entries\n}\n\nexport function rewindStats(state, index) {\n  const tail = state.transcript.slice(index)\n  return {\n    msgs: tail.length,\n    edits: tail.filter((m) => m.kind === 'tool' && m.revert && m.status !== 'reverted'),\n  }\n}\n", "import { appendFile, readFile, readdir } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { picoHome, projectDir, projectHistoryFile, ensureDir } from './paths.js'\n\nconst MAX_PROMPTS_PER_SCOPE = 1000\n\nexport async function appendPrompt(root, text) {\n  ensureDir(projectDir(root))\n  await appendFile(projectHistoryFile(root), JSON.stringify({ text, at: Date.now() }) + '\\n')\n}\n\nfunction parsePromptLines(text) {\n  return text\n    .split('\\n')\n    .map((line) => {\n      try {\n        return line.trim() ? JSON.parse(line) : null\n      } catch {\n        return null\n      }\n    })\n    .filter(Boolean)\n}\n\nasync function readPrompts(file, scope) {\n  try {\n    const entries = parsePromptLines(await readFile(file, 'utf-8'))\n    return entries\n      .filter((e) => typeof e.text === 'string' && e.text.trim())\n      .slice(-MAX_PROMPTS_PER_SCOPE)\n      .map((e) => ({ text: e.text, at: e.at || 0, scope }))\n  } catch {\n    return []\n  }\n}\n\nexport function loadProjectPrompts(root) {\n  return readPrompts(projectHistoryFile(root), 'project')\n}\n\nexport async function loadGlobalPrompts() {\n  const projectsDir = join(picoHome(), 'projects')\n  let projects = []\n  try {\n    projects = await readdir(projectsDir)\n  } catch {}\n  const nested = await Promise.all(\n    projects.map((p) => readPrompts(join(projectsDir, p, 'history.jsonl'), 'everywhere')),\n  )\n  return nested.flat().sort((a, b) => b.at - a.at).slice(0, MAX_PROMPTS_PER_SCOPE)\n}\n", "import { readFile } from 'node:fs/promises'\nimport { compose, scope, model, noToolsCalled, Inherit, getText } from '@prsm/ai'\n\nasync function hydratePart(part) {\n  if (part.type !== 'image' || part.source?.kind !== 'path') return part\n  try {\n    const data = await readFile(part.source.path)\n    return {\n      type: 'image',\n      source: { kind: 'base64', mediaType: part.source.mediaType, data: data.toString('base64') },\n    }\n  } catch {\n    return { type: 'text', text: `[image unavailable: ${part.source.path}]` }\n  }\n}\n\nexport function hydrateImages(history) {\n  return Promise.all(\n    history.map(async (message) =>\n      Array.isArray(message.content)\n        ? { ...message, content: await Promise.all(message.content.map(hydratePart)) }\n        : message,\n    ),\n  )\n}\n\nconst STALL_MS = 90000\n\nexport async function summarizeText({ text, modelName }) {\n  const out = await compose(\n    model({\n      model: modelName,\n      system: 'Summarize the following conversation excerpt in 2-4 dense sentences. Capture decisions, changes made, and open questions. Output only the summary.',\n    }),\n  )(text.slice(0, 30000))\n  return getText(out.lastResponse?.content || '').trim()\n}\n\nexport async function runTurn({ history, tools, recorder, modelName, effort, system, signal, onStream, stallMs = STALL_MS }) {\n  const collected = []\n  let roundText = ''\n  let usageSeen = null\n  let stalled = false\n\n  const internal = new AbortController()\n  const onUserAbort = () => internal.abort()\n  if (signal?.aborted) internal.abort()\n  else signal?.addEventListener('abort', onUserAbort, { once: true })\n\n  let watchdog = null\n  const arm = () => {\n    clearTimeout(watchdog)\n    watchdog = setTimeout(() => {\n      stalled = true\n      internal.abort()\n    }, stallMs)\n  }\n\n  const stream = (event) => {\n    arm()\n    if (event.type === 'content') {\n      roundText += event.content\n    } else if (event.type === 'tool_calls_ready') {\n      collected.push({ role: 'assistant', content: roundText, tool_calls: event.calls })\n      roundText = ''\n    } else if (event.type === 'tool_executing') {\n      recorder.currentCall = event.call\n    } else if (event.type === 'tool_complete') {\n      collected.push({ role: 'tool', tool_call_id: event.call.id, content: JSON.stringify(event.result) })\n    } else if (event.type === 'tool_error') {\n      collected.push({ role: 'tool', tool_call_id: event.call.id, content: JSON.stringify({ error: event.error }) })\n    } else if (event.type === 'usage') {\n      usageSeen = event.usage\n    }\n    onStream?.(event)\n  }\n\n  const base = history.length\n  const step = compose(\n    scope(\n      { inherit: Inherit.Conversation, system, tools, until: noToolsCalled(), stream },\n      (ctx) => model({ model: modelName, ...(effort && { effort }) })({ ...ctx, abortSignal: internal.signal }),\n    ),\n  )\n\n  const partialMessages = () => {\n    const messages = [...collected]\n    if (roundText) messages.push({ role: 'assistant', content: roundText })\n    return messages\n  }\n\n  arm()\n  try {\n    const out = await step({ history: await hydrateImages(history), tools: [] })\n    const interrupted = !!signal?.aborted || stalled\n    if (interrupted) {\n      return { messages: partialMessages(), usage: usageSeen, interrupted, stalled }\n    }\n    const messages = out.history.filter((m) => m.role !== 'system').slice(base)\n    return { messages, usage: out.usage || null, interrupted: false, stalled: false }\n  } catch (err) {\n    if (err.name === 'AbortError' || internal.signal.aborted) {\n      return { messages: partialMessages(), usage: usageSeen, interrupted: true, stalled }\n    }\n    throw err\n  } finally {\n    clearTimeout(watchdog)\n    signal?.removeEventListener('abort', onUserAbort)\n  }\n}\n", "export function createRecorder() {\n  return {\n    currentCall: null,\n    entries: [],\n    pending: null,\n    begin(name) {\n      this.pending = {\n        callId: this.currentCall?.id ?? null,\n        name,\n        title: name,\n        status: 'done',\n        startedAt: Date.now(),\n      }\n    },\n    extra(fields) {\n      if (this.pending) Object.assign(this.pending, fields)\n    },\n    done(fields = {}) {\n      if (!this.pending) return\n      Object.assign(this.pending, fields, {\n        durationMs: Date.now() - this.pending.startedAt,\n      })\n      delete this.pending.startedAt\n      if (this.pending.fullOutput?.length > 200000) {\n        this.pending.fullOutput = this.pending.fullOutput.slice(0, 200000) + '\\n[truncated]'\n      }\n      this.entries.push(this.pending)\n      this.pending = null\n    },\n  }\n}\n\nexport function recorded(recorder, name, fn) {\n  return async (args) => {\n    recorder.begin(name)\n    try {\n      const result = await fn(args)\n      recorder.done()\n      return result\n    } catch (err) {\n      recorder.done({ status: 'error', error: String(err.message || err) })\n      throw err\n    }\n  }\n}\n", "import { readFile } from 'node:fs/promises'\nimport { resolve } from 'node:path'\n\nconst MAX_LINES = 2000\nconst MAX_LINE_LENGTH = 2000\n\nfunction isBinary(buffer) {\n  const len = Math.min(buffer.length, 8000)\n  for (let i = 0; i < len; i++) {\n    if (buffer[i] === 0) return true\n  }\n  return false\n}\n\nexport function createRead({ cwd, recorder, tracker }) {\n  return {\n    name: 'read',\n    description: 'Read a file. Returns line-numbered content. Use offset/limit for large files.',\n    schema: {\n      path: { type: 'string', description: 'file path, relative to the working directory or absolute' },\n      offset: { type: 'number', description: '1-indexed line to start from', optional: true },\n      limit: { type: 'number', description: 'max lines to return', optional: true },\n    },\n    execute: async ({ path, offset = 1, limit = MAX_LINES }) => {\n      const full = resolve(cwd, path)\n      recorder.extra({ title: path })\n      const buf = await readFile(full)\n      if (isBinary(buf)) throw new Error(`${path} is a binary file`)\n      const lines = buf.toString('utf-8').split('\\n')\n\n      const start = Math.max(0, offset - 1)\n      const count = Math.min(limit, MAX_LINES)\n      const sliced = lines.slice(start, start + count)\n      const numbered = sliced\n        .map((line, i) => `${start + i + 1}\\t${line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + '\u2026' : line}`)\n        .join('\\n')\n\n      recorder.extra({ fullOutput: sliced.join('\\n') })\n      const result = { content: numbered, totalLines: lines.length }\n      if (start + count < lines.length) {\n        result.note = `showing lines ${start + 1}-${start + sliced.length} of ${lines.length}`\n      }\n      const context = tracker.check(full)\n      if (context.length) result.context_from_agents_md = context\n      return result\n    },\n  }\n}\n", "import { mkdir, readFile, writeFile } from 'node:fs/promises'\nimport { dirname, resolve } from 'node:path'\nimport { makeDiff } from './diff.js'\n\nexport function createWrite({ cwd, recorder, tracker }) {\n  return {\n    name: 'write',\n    description: 'Write content to a file, creating it and any parent directories if needed. Overwrites existing content.',\n    schema: {\n      path: { type: 'string', description: 'file path, relative to the working directory or absolute' },\n      content: { type: 'string', description: 'the full file content to write' },\n    },\n    execute: async ({ path, content }) => {\n      const full = resolve(cwd, path)\n      recorder.extra({ title: path })\n      await mkdir(dirname(full), { recursive: true })\n      let before = null\n      try {\n        before = await readFile(full, 'utf-8')\n      } catch {}\n      await writeFile(full, content, 'utf-8')\n\n      const result = { ok: true, path }\n      if (before !== null) {\n        const diff = makeDiff(path, before, content)\n        recorder.extra({ diff, revert: { path: full, before, after: content } })\n        result.additions = diff.additions\n        result.deletions = diff.deletions\n      } else {\n        recorder.extra({ revert: { path: full, before: '', after: content }, created: true })\n        result.created = true\n      }\n      const context = tracker.check(full)\n      if (context.length) result.context_from_agents_md = context\n      return result\n    },\n  }\n}\n", "import { structuredPatch } from 'diff'\n\nexport function makeDiff(path, oldText, newText, contextLines = 3) {\n  const patch = structuredPatch(path, path, oldText, newText, '', '', { context: contextLines })\n  let additions = 0\n  let deletions = 0\n  const hunks = patch.hunks.map((h) => ({\n    oldStart: h.oldStart,\n    newStart: h.newStart,\n    lines: h.lines.map((line) => {\n      const type = line[0] === '-' ? 'remove' : line[0] === '+' ? 'add' : 'context'\n      if (type === 'add') additions++\n      if (type === 'remove') deletions++\n      return { type, text: line.slice(1) }\n    }),\n  }))\n  return { path, hunks, additions, deletions }\n}\n", "import { readFile, writeFile } from 'node:fs/promises'\nimport { resolve } from 'node:path'\nimport { makeDiff } from './diff.js'\n\nconst normalize = (s) =>\n  s\n    .replace(/\\s+$/gm, '')\n    .replace(/[\u2018\u2019]/g, \"'\")\n    .replace(/[\u201C\u201D]/g, '\"')\n    .replace(/[\u2013\u2014]/g, '-')\n\nfunction locate(content, old, path) {\n  let index = content.indexOf(old)\n  if (index !== -1) {\n    if (content.indexOf(old, index + 1) !== -1) {\n      throw new Error(`string appears multiple times in ${path}, provide more surrounding context to make it unique`)\n    }\n    return { index, length: old.length, content }\n  }\n\n  const normedContent = normalize(content)\n  const normedOld = normalize(old)\n  index = normedContent.indexOf(normedOld)\n  if (index === -1) throw new Error(`string not found in ${path}`)\n  if (normedContent.indexOf(normedOld, index + 1) !== -1) {\n    throw new Error(`string appears multiple times in ${path}, provide more surrounding context to make it unique`)\n  }\n  return { index, length: normedOld.length, content: normedContent }\n}\n\nexport function createEdit({ cwd, recorder, tracker }) {\n  return {\n    name: 'edit',\n    description: 'Replace oldText with newText in a file. oldText must appear exactly once unless replaceAll is set.',\n    schema: {\n      path: { type: 'string', description: 'file path, relative to the working directory or absolute' },\n      oldText: { type: 'string', description: 'exact text to replace, must be unique in the file' },\n      newText: { type: 'string', description: 'replacement text' },\n      replaceAll: { type: 'boolean', description: 'replace every occurrence', optional: true },\n    },\n    execute: async ({ path, oldText, newText, replaceAll }) => {\n      const full = resolve(cwd, path)\n      recorder.extra({ title: path })\n      const before = await readFile(full, 'utf-8')\n\n      let after\n      if (replaceAll) {\n        if (!before.includes(oldText)) throw new Error(`string not found in ${path}`)\n        after = before.split(oldText).join(newText)\n      } else {\n        const { index, length, content } = locate(before, oldText, path)\n        after = content.slice(0, index) + newText + content.slice(index + length)\n      }\n\n      await writeFile(full, after, 'utf-8')\n      const diff = makeDiff(path, before, after)\n      recorder.extra({ diff, revert: { path: full, before, after } })\n\n      const result = { ok: true, path, additions: diff.additions, deletions: diff.deletions }\n      const context = tracker.check(full)\n      if (context.length) result.context_from_agents_md = context\n      return result\n    },\n  }\n}\n", "import { exec } from 'node:child_process'\n\nconst MAX_OUTPUT_CHARS = 30000\n\nfunction capped(text) {\n  if (text.length <= MAX_OUTPUT_CHARS) return text\n  return text.slice(0, MAX_OUTPUT_CHARS) + `\\n[output truncated at ${MAX_OUTPUT_CHARS} characters]`\n}\n\nexport function createBash({ cwd, recorder, signal }) {\n  return {\n    name: 'bash',\n    description: 'Run a shell command in the working directory. Returns stdout, stderr, and exit code.',\n    schema: {\n      command: { type: 'string', description: 'the command to run' },\n      timeout: { type: 'number', description: 'timeout in milliseconds, default 120000', optional: true },\n    },\n    execute: ({ command, timeout }) =>\n      new Promise((resolve) => {\n        recorder.extra({ title: command })\n        const child = exec(\n          command,\n          {\n            cwd,\n            timeout: timeout || 120000,\n            maxBuffer: 10 * 1024 * 1024,\n            env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },\n          },\n          (err, stdout, stderr) => {\n            const exitCode = err ? (typeof err.code === 'number' ? err.code : 1) : 0\n            recorder.extra({ fullOutput: [stdout, stderr].filter(Boolean).join('\\n') })\n            resolve({ stdout: capped(stdout || ''), stderr: capped(stderr || ''), exitCode })\n          },\n        )\n        if (signal) {\n          if (signal.aborted) {\n            child.kill()\n            return\n          }\n          signal.addEventListener('abort', () => child.kill(), { once: true })\n        }\n      }),\n  }\n}\n", "import { execFile } from 'node:child_process'\nimport fg from 'fast-glob'\n\nconst MAX_RESULTS = 200\n\nfunction ripgrepGlob(pattern, cwd) {\n  return new Promise((resolve) => {\n    const args = ['--files', '--glob', pattern, '--glob', '!**/node_modules/**', '--glob', '!**/.git/**']\n    execFile('rg', args, { cwd, maxBuffer: 50 * 1024 * 1024 }, (err, stdout) => {\n      if (err && err.code !== 1) resolve(null)\n      else resolve(stdout ? stdout.split('\\n').filter(Boolean) : [])\n    })\n  })\n}\n\nexport function createGlob({ cwd, recorder }) {\n  return {\n    name: 'glob',\n    description: 'Find files matching a glob pattern, relative to the working directory. Respects .gitignore; use bash to look inside ignored paths.',\n    schema: {\n      pattern: { type: 'string', description: 'glob pattern, e.g. src/**/*.js' },\n      maxResults: { type: 'number', description: 'cap on returned paths, default 200', optional: true },\n    },\n    execute: async ({ pattern, maxResults = MAX_RESULTS }) => {\n      recorder.extra({ title: pattern })\n      let files = await ripgrepGlob(pattern, cwd)\n      if (files === null) {\n        files = await fg(pattern, {\n          cwd,\n          dot: false,\n          ignore: ['**/node_modules/**', '**/.git/**'],\n        })\n      }\n      recorder.extra({ fullOutput: files.join('\\n') })\n      return {\n        files: files.slice(0, maxResults),\n        totalFound: files.length,\n        truncated: files.length > maxResults,\n      }\n    },\n  }\n}\n", "import { execFile } from 'node:child_process'\nimport { relative, resolve } from 'node:path'\n\nconst MAX_RESULTS = 200\n\nfunction runRipgrep(args, cwd) {\n  return new Promise((done) => {\n    execFile('rg', args, { cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {\n      done(err && !stdout ? '' : stdout || '')\n    })\n  })\n}\n\nexport function createGrep({ cwd, recorder }) {\n  return {\n    name: 'grep',\n    description: 'Search file contents with a regex using ripgrep. mode \"content\" returns matching lines, \"files\" returns matching file paths, \"count\" returns per-file match counts.',\n    schema: {\n      pattern: { type: 'string', description: 'regex pattern' },\n      path: { type: 'string', description: 'file or directory to search, defaults to the working directory', optional: true },\n      mode: { type: 'string', enum: ['content', 'files', 'count'], optional: true },\n      glob: { type: 'string', description: 'filter files by glob, e.g. *.js', optional: true },\n      ignoreCase: { type: 'boolean', optional: true },\n      context: { type: 'number', description: 'lines of context around matches', optional: true },\n      multiline: { type: 'boolean', description: 'allow patterns to span lines', optional: true },\n      limit: { type: 'number', description: 'max results, default 200', optional: true },\n    },\n    execute: async ({ pattern, path, mode = 'content', glob, ignoreCase, context, multiline, limit = MAX_RESULTS }) => {\n      recorder.extra({ title: pattern })\n      const args = ['--no-heading', '--color=never', '--max-columns', '500']\n\n      if (mode === 'files') args.push('--files-with-matches')\n      else if (mode === 'count') args.push('--count')\n      else args.push('--line-number')\n\n      if (ignoreCase) args.push('--ignore-case')\n      if (multiline) args.push('--multiline', '--multiline-dotall')\n      if (glob) args.push('--glob', glob)\n      if (mode === 'content' && context) args.push('-C', String(context))\n\n      args.push(pattern.startsWith('-') ? '-e' : '--', pattern)\n      args.push(path ? resolve(cwd, path) : cwd)\n\n      const stdout = await runRipgrep(args, cwd)\n      const lines = stdout.split('\\n').filter(Boolean)\n      recorder.extra({ fullOutput: lines.join('\\n') })\n\n      const relativize = (line) => {\n        if (mode === 'files') return relative(cwd, line)\n        const m = line.match(/^(\\/[^:]+):(.*)$/)\n        return m ? `${relative(cwd, m[1])}:${m[2]}` : line\n      }\n      const results = lines.map(relativize).slice(0, limit)\n      return { results, mode, totalMatches: lines.length, truncated: lines.length > limit }\n    },\n  }\n}\n", "import { createRecorder, recorded } from './recorder.js'\nimport { createRead } from './read.js'\nimport { createWrite } from './write.js'\nimport { createEdit } from './edit.js'\nimport { createBash } from './bash.js'\nimport { createGlob } from './glob.js'\nimport { createGrep } from './grep.js'\n\nexport function createToolset({ cwd, tracker, skills, mcpTools = [], signal }) {\n  const recorder = createRecorder()\n  const deps = { cwd, recorder, tracker, signal }\n\n  const local = [\n    createRead(deps),\n    createWrite(deps),\n    createEdit(deps),\n    createBash(deps),\n    createGlob(deps),\n    createGrep(deps),\n  ]\n\n  if (skills?.list().length) {\n    local.push({\n      name: 'skill',\n      description: `Load a skill by name and follow its instructions. Available skills:\\n${skills\n        .list()\n        .map((s) => `- ${s.name}: ${s.description}`)\n        .join('\\n')}`,\n      schema: {\n        name: { type: 'string', description: 'skill name' },\n      },\n      execute: async ({ name }) => {\n        recorder.extra({ title: name })\n        const body = await skills.load(name)\n        if (!body) throw new Error(`no skill named ${name}`)\n        return { instructions: body }\n      },\n    })\n  }\n\n  const tools = [...local, ...mcpTools].map((tool) => ({\n    ...tool,\n    execute: recorded(recorder, tool.name, tool.execute),\n  }))\n\n  return { tools, recorder }\n}\n", "import { readFile, writeFile } from 'node:fs/promises'\n\nasync function readCurrent(path) {\n  try {\n    return await readFile(path, 'utf-8')\n  } catch {\n    return null\n  }\n}\n\nexport async function revertEdits(edits) {\n  const reverted = []\n  const skipped = []\n  for (const edit of [...edits].reverse()) {\n    const { path, before, after } = edit.revert\n    const current = await readCurrent(path)\n    if (current === after) {\n      await writeFile(path, before, 'utf-8')\n      reverted.push(edit.callId)\n    } else {\n      skipped.push({ path, callId: edit.callId, reason: 'file changed since edit' })\n    }\n  }\n  return { reverted, skipped }\n}\n\nexport async function reapplyEdits(edits) {\n  const reapplied = []\n  const skipped = []\n  for (const edit of edits) {\n    const { path, before, after } = edit.revert\n    const current = await readCurrent(path)\n    if (current === before) {\n      await writeFile(path, after, 'utf-8')\n      reapplied.push(edit.callId)\n    } else {\n      skipped.push({ path, callId: edit.callId, reason: 'file changed since revert' })\n    }\n  }\n  return { reapplied, skipped }\n}\n", "import { platform } from 'node:os'\n\nexport function buildSystemPrompt({ cwd, contextFiles = [], skills = [] }) {\n  const parts = [\n    `You are pico, a coding agent running in a terminal.`,\n    ``,\n    `Working directory: ${cwd}`,\n    `Platform: ${platform()}`,\n    `Date: ${new Date().toDateString()}`,\n    ``,\n    `Use the available tools to read, search, and modify files, and to run commands.`,\n    `Prefer reading files before editing them. Keep edits minimal and precise.`,\n    `When a tool result includes context_from_agents_md, treat it as project instructions that apply from that point on.`,\n    `Be direct and concise. Use markdown. Never invent file contents you have not read.`,\n  ]\n\n  if (skills.length) {\n    parts.push(\n      ``,\n      `Skills available via the skill tool (load one when its description matches the task):`,\n      ...skills.map((s) => `- ${s.name}: ${s.description}`),\n    )\n  }\n\n  for (const file of contextFiles) {\n    parts.push(``, `Project instructions from ${file.path}:`, ``, file.content.trim())\n  }\n\n  return parts.join('\\n')\n}\n", "export function transcriptToMarkdown(transcript, { title = 'pico session' } = {}) {\n  const parts = [`# ${title}`, '']\n  for (const item of transcript) {\n    if (item.kind === 'user') {\n      parts.push('## You', '', item.text, '')\n    } else if (item.kind === 'assistant') {\n      parts.push(item.interrupted ? `${item.text}\\n\\n*(interrupted)*` : item.text, '')\n    } else if (item.kind === 'tool') {\n      const label = item.diff ? ` (+${item.diff.additions} -${item.diff.deletions})` : ''\n      parts.push(`> ${item.status === 'reverted' ? '\u21A9' : '\u2713'} \\`${item.name}\\` ${item.title}${label}`, '')\n    } else if (item.kind === 'summary') {\n      parts.push(`> summary: ${item.text}`, '')\n    }\n  }\n  return parts.join('\\n')\n}\n", "export function fuzzyScore(query, path) {\n  const q = query.toLowerCase()\n  const s = path.toLowerCase()\n  if (!q) return 0\n  let best = -1\n  for (let start = s.indexOf(q[0]); start !== -1; start = s.indexOf(q[0], start + 1)) {\n    let score = 0\n    let prev = -1\n    let matched = true\n    for (const ch of q) {\n      const i = s.indexOf(ch, prev === -1 ? start : prev + 1)\n      if (i === -1) {\n        matched = false\n        break\n      }\n      if (prev !== -1 && i === prev + 1) score += 3\n      if (i === 0 || '/.-_'.includes(s[i - 1])) score += 2\n      score += 1\n      prev = i\n    }\n    if (matched && score > best) best = score\n  }\n  if (best < 0) return -1\n  const base = s.slice(s.lastIndexOf('/') + 1)\n  if (base.startsWith(q)) best += 8\n  else if (base.includes(q)) best += 5\n  else if (s.includes(q)) best += 3\n  return best - s.length / 100\n}\n", "import { fuzzyScore } from './fuzzy.js'\n\nexport function completionContext({ value, resolve }) {\n  if (value.includes('\\n')) return null\n  const m = value.match(/^\\/(\\S+) (.*)$/)\n  if (!m) return null\n  const source = resolve(m[1].toLowerCase())\n  if (!source || source.length === 0) return null\n  const tokens = m[2].split(' ')\n  const partial = tokens[tokens.length - 1]\n  const matches = source\n    .map((s) => [fuzzyScore(partial, s), s])\n    .filter(([score]) => score >= 0)\n    .sort((a, b) => b[0] - a[0])\n    .map(([, s]) => s)\n  return { partial, matches, start: value.length - partial.length }\n}\n\nexport function applyCompletion(value, ctx, candidate) {\n  return value.slice(0, ctx.start) + candidate + ' '\n}\n", "import { existsSync } from 'node:fs'\nimport { basename } from 'node:path'\n\nconst MEDIA_TYPES = {\n  png: 'image/png',\n  jpg: 'image/jpeg',\n  jpeg: 'image/jpeg',\n  gif: 'image/gif',\n  webp: 'image/webp',\n  bmp: 'image/bmp',\n}\n\nexport function mediaTypeFor(path) {\n  return MEDIA_TYPES[path.split('.').pop().toLowerCase()] || null\n}\n\nfunction unquote(token) {\n  if (/^'.*'$/.test(token) || /^\".*\"$/.test(token)) return token.slice(1, -1)\n  return token.replace(/\\\\ /g, ' ')\n}\n\nfunction toPath(token) {\n  const raw = unquote(token.trim())\n  if (raw.startsWith('file://')) {\n    try {\n      return decodeURIComponent(raw.slice('file://'.length))\n    } catch {\n      return null\n    }\n  }\n  return raw\n}\n\nexport function extractImagePaths(text, exists = existsSync) {\n  const tokens = text.trim().match(/'[^']*'|\"[^\"]*\"|(?:\\\\ |\\S)+/g)\n  if (!tokens || tokens.length === 0) return []\n  const paths = []\n  for (const token of tokens) {\n    const path = toPath(token)\n    if (!path || !path.startsWith('/')) return []\n    if (!mediaTypeFor(path) || !exists(path)) return []\n    paths.push(path)\n  }\n  return paths\n}\n\nexport function imageLabel(part) {\n  if (part.source?.path) return `[image: ${basename(part.source.path)}]`\n  return '[image]'\n}\n\nexport function buildUserContent(text, attachments) {\n  const parts = []\n  let last = 0\n  const used = []\n  for (const match of text.matchAll(/\\[Image #\\d+\\]/g)) {\n    const attachment = attachments.get(match[0])\n    if (!attachment) continue\n    const before = text.slice(last, match.index)\n    if (before) parts.push({ type: 'text', text: before })\n    parts.push({\n      type: 'image',\n      source: { kind: 'path', path: attachment.path, mediaType: attachment.mediaType },\n    })\n    used.push(match[0])\n    last = match.index + match[0].length\n  }\n  if (parts.length === 0) return { content: text, used }\n  const tail = text.slice(last)\n  if (tail) parts.push({ type: 'text', text: tail })\n  return { content: parts, used }\n}\n", "import { execFile } from 'node:child_process'\nimport fg from 'fast-glob'\n\nconst MAX_FILES = 5000\nconst TTL = 5000\n\nlet cached = { at: 0, cwd: null, files: [] }\n\nfunction ripgrepFiles(cwd) {\n  return new Promise((resolve) => {\n    execFile('rg', ['--files', '--sortr=modified'], { cwd, maxBuffer: 50 * 1024 * 1024 }, (err, stdout) => {\n      resolve(err && !stdout ? null : stdout.split('\\n').filter(Boolean))\n    })\n  })\n}\n\nexport async function listFiles(cwd) {\n  if (cached.cwd === cwd && Date.now() - cached.at < TTL) return cached.files\n  let files = await ripgrepFiles(cwd)\n  if (!files) {\n    files = await fg('**/*', {\n      cwd,\n      onlyFiles: true,\n      dot: false,\n      ignore: ['**/node_modules/**', '**/.git/**'],\n    }).catch(() => [])\n  }\n  cached = { at: Date.now(), cwd, files: files.slice(0, MAX_FILES) }\n  return cached.files\n}\n", "import { codeToANSI } from '@shikijs/cli'\nimport { createSignal } from '@trendr/core'\n\nconst LANGS = {\n  js: 'js', mjs: 'js', cjs: 'js', jsx: 'jsx', ts: 'ts', tsx: 'tsx',\n  json: 'json', jsonl: 'json', md: 'md', py: 'python', rb: 'ruby', go: 'go',\n  rs: 'rust', c: 'c', h: 'c', cpp: 'cpp', java: 'java', css: 'css',\n  html: 'html', vue: 'vue', sh: 'bash', bash: 'bash', zsh: 'bash',\n  yml: 'yaml', yaml: 'yaml', toml: 'toml', sql: 'sql', svelte: 'svelte',\n}\n\nexport function langForPath(path) {\n  const ext = String(path).split('.').pop().toLowerCase()\n  return LANGS[ext] || 'txt'\n}\n\nconst cache = new Map()\nconst pending = new Set()\nconst failed = new Set()\nconst [version, setVersion] = createSignal(0)\n\nexport const highlightVersion = version\n\nexport function highlight(code, lang) {\n  const safeLang = lang && !failed.has(lang) ? lang : 'txt'\n  return code\n    .split('\\n')\n    .map((line) => {\n      const key = `${safeLang}\\n${line}`\n      if (cache.has(key)) return cache.get(key)\n      warm(line, safeLang, key)\n      return line\n    })\n    .join('\\n')\n}\n\nfunction warm(line, lang, key) {\n  if (pending.has(key)) return\n  pending.add(key)\n  codeToANSI(line, lang, 'nord')\n    .then((ansi) => cache.set(key, ansi.replace(/\\n$/, '')))\n    .catch(() => {\n      failed.add(lang)\n      cache.set(key, line)\n    })\n    .finally(() => {\n      pending.delete(key)\n      setVersion((v) => v + 1)\n    })\n}\n", "import { Diff, Markdown, Spinner } from '@trendr/core'\nimport { accent, FG, FG_SOFT, MUTED, FAINT, PANEL_BG, RED } from './theme.js'\nimport { highlight, langForPath } from './highlight.js'\n\nexport function uiTitle(name, args = {}) {\n  if (args.path) return args.path\n  if (args.command) return args.command\n  if (args.pattern) return args.pattern\n  if (args.name) return args.name\n  const raw = JSON.stringify(args)\n  return raw.length > 60 ? raw.slice(0, 60) + '\u2026' : raw\n}\n\nfunction ToolCard({ name, title, status, diff, revert, fullOutput, error, verbose }) {\n  const running = status === 'running'\n  const interrupted = status === 'interrupted'\n  const reverted = status === 'reverted'\n  const failed = status === 'error'\n  const outLines = fullOutput ? fullOutput.split('\\n') : null\n\n  const info = running ? 'running'\n    : interrupted ? 'interrupted'\n    : reverted ? 'reverted'\n    : failed ? 'failed'\n    : diff ? `+${diff.additions} -${diff.deletions}`\n    : outLines ? `${outLines.length} ${outLines.length === 1 ? 'line' : 'lines'} \u00B7 ctrl+o`\n    : 'done'\n\n  return (\n    <box style={{ flexDirection: 'column', paddingX: 2 }}>\n      <text> </text>\n      <box style={{ flexDirection: 'row' }}>\n        {running\n          ? <Spinner color={accent()} />\n          : <text style={{ color: interrupted || failed ? RED : reverted ? MUTED : accent() }}>{interrupted ? '\u2717' : failed ? '\u2717' : reverted ? '\u21A9' : '\u2713'}</text>}\n        <text> </text>\n        <text style={{ color: MUTED }}>{`${name.padEnd(5)} `}</text>\n        <box style={{ flexGrow: 1, height: 1 }}>\n          <text style={{ overflow: 'truncate', color: FG }}>{title || name}</text>\n        </box>\n        <text style={{ color: FAINT }}>{`  ${info}`}</text>\n      </box>\n      {failed && error && (\n        <text style={{ color: MUTED, overflow: 'truncate' }}>{`  ${error}`}</text>\n      )}\n      {revert && !running && !reverted && (\n        <box style={{ flexDirection: 'column', height: Math.min((diff?.hunks || []).reduce((a, h) => a + h.lines.length, 2) + 1, 12), marginTop: 1 }}>\n          <Diff\n            before={revert.before}\n            after={revert.after}\n            language={langForPath(revert.path)}\n            highlight={highlight}\n            focused={false}\n            scrollbar={false}\n          />\n        </box>\n      )}\n      {outLines && verbose && !running && (\n        <box style={{ flexDirection: 'column', bg: PANEL_BG, paddingX: 1, marginTop: 1 }}>\n          <text style={{ color: MUTED }}>{`$ ${title}`}</text>\n          {outLines.slice(0, 200).map((line, i) => (\n            <text key={i} style={{ color: FG_SOFT, overflow: 'truncate' }}>{line || ' '}</text>\n          ))}\n          {outLines.length > 200 && <text style={{ color: FAINT }}>{`\u2026 ${outLines.length - 200} more lines`}</text>}\n        </box>\n      )}\n    </box>\n  )\n}\n\nexport function Banner({ version, cwd, modelName }) {\n  return (\n    <box style={{ flexDirection: 'row', paddingX: 2, marginTop: 1 }}>\n      <box style={{ flexDirection: 'column' }}>\n        <text style={{ color: accent() }}>{'(\\\\_/)'}</text>\n        <text style={{ color: accent() }}>{'(\u2022\u1D17\u2022)'}</text>\n      </box>\n      <box style={{ flexDirection: 'column' }}>\n        <box style={{ flexDirection: 'row' }}>\n          <text style={{ bold: true, color: accent() }}>{'  pico'}</text>\n          <text style={{ color: FAINT }}>{` v${version} \u00B7 ${modelName}`}</text>\n        </box>\n        <text style={{ color: MUTED }}>{`  ${cwd}`}</text>\n      </box>\n    </box>\n  )\n}\n\nexport function Message({ item, verbose }) {\n  if (item.kind === 'tool') {\n    return <ToolCard {...item} verbose={verbose} />\n  }\n\n  if (item.kind === 'summary') {\n    return (\n      <box style={{ flexDirection: 'column', paddingX: 2 }}>\n        <text> </text>\n        <text style={{ color: MUTED, italic: true }}>{`\u2726 summary: ${item.text.replace(/\\n/g, ' ').slice(0, 500)}`}</text>\n      </box>\n    )\n  }\n\n  if (item.kind === 'skill') {\n    return (\n      <box style={{ flexDirection: 'column', paddingX: 2 }}>\n        <text> </text>\n        <text style={{ color: MUTED, italic: true }}>{`\u2726 skill: ${item.name}`}</text>\n      </box>\n    )\n  }\n\n  if (item.kind === 'user') {\n    return (\n      <box style={{ flexDirection: 'column' }}>\n        <text> </text>\n        <box style={{ bg: PANEL_BG, flexDirection: 'column', paddingX: 2, paddingY: 1 }}>\n          <text style={{ color: '#f9fafb' }}>{item.text}</text>\n        </box>\n      </box>\n    )\n  }\n\n  const text = item.interrupted ? `${item.text} *(interrupted)*` : item.text\n  return (\n    <box style={{ flexDirection: 'column', paddingX: 2 }}>\n      <text> </text>\n      <Markdown text={text} highlight={highlight} codeBg={null} />\n    </box>\n  )\n}\n", "import { createSignal } from '@trendr/core'\n\nexport const DEFAULT_ACCENT = '#6BE795'\n\nconst [accentValue, setAccentValue] = createSignal(DEFAULT_ACCENT)\n\nexport const accent = accentValue\n\nexport function setAccent(color) {\n  setAccentValue(color || DEFAULT_ACCENT)\n}\n\nexport const FG = '#e5e7eb'\nexport const FG_SOFT = '#9ca3af'\nexport const MUTED = '#6b7280'\nexport const FAINT = '#4b5563'\nexport const PANEL_BG = '#1e1e22'\nexport const SELECT_BG = '#374151'\nexport const RED = '#f87171'\n", "import { Markdown, ScrollBox, useInput } from '@trendr/core'\nimport { accent, FAINT } from './theme.js'\n\nconst HELP_TEXT = (commands) => `pico is a coding agent in your terminal. It reads, edits, and searches files, runs commands, and streams its work into this transcript.\n\n## Commands\n\nType \\`/\\` in the composer to filter these as you type.\n\n${commands.map((c) => `- \\`/${c.name}\\` - ${c.desc}`).join('\\n')}\n\nTwo kinds of user-defined entries join this menu:\n\n- **commands** (\\`~/.pico/commands/<name>.md\\` or \\`.pico/commands/<name>.md\\`): prompt templates you invoke as \\`/<name> [args]\\`. \\`$ARGUMENTS\\` in the body is replaced with whatever follows the command; without a placeholder, args are appended. The model never sees these until you run one.\n- **skills** (\\`~/.pico/skills/<name>/SKILL.md\\` or \\`.pico/skills/<name>/SKILL.md\\`): capabilities with a name and description. You can invoke them like commands, and the agent can also discover and load them itself via the skill tool.\n\nIn the MCP panel: space or enter toggles a server, \\`t\\` lists its tools, \\`r\\` reconnects, \\`a\\` adds, \\`d\\` removes. Unfiltered lists (effort, rewind options, MCP) also move with \\`j\\`/\\`k\\` and jump with \\`g\\`/\\`G\\`.\n\n## Composer\n\n- \\`enter\\` sends, \\`shift+enter\\` inserts a newline\n- \\`@\\` opens a fuzzy file picker; enter inserts the selected path\n- drag an image file into the terminal to attach it: it appears inline as \\`[Image #N]\\`, exactly where your cursor is, so images can sit between sentences; backspace after one removes the whole attachment\n- \\`tab\\` after a command argument completes it: \\`/model fla<tab>\\`, \\`/color <tab>\\`, \\`/effort <tab>\\`; skill and command arguments complete file paths. Keep typing to narrow, tab or enter inserts\n- \\`up\\` and \\`down\\` on an empty composer recall messages you already sent\n- \\`ctrl+r\\` fuzzy-searches your prompt history with a preview; enter puts the match back in the composer\n- \\`ctrl+s\\` opens the session picker (same as \\`/resume\\`); \\`ctrl+t\\` opens the model picker\n- \\`ctrl+p\\` switches projects: pick one and pico jumps to its most recent session, changing the working directory, tools, context, and MCP servers to match; \\`/new\\` starts a fresh session in the current project\n- \\`ctrl+b\\` cycles thinking effort (default, low, medium, high, max) on models that support it; \\`/effort\\` opens the full picker\n- inside a search panel, \\`ctrl+s\\` cycles the scope instead: this session, this project, or everywhere\n- \\`/rewind\\` restores the conversation to an earlier message; a rewind can be undone with \\`ctrl+z\\`\n- messages sent while the agent is responding queue up above the composer and are delivered as one message when the turn finishes; \\`up\\` pulls them back for editing\n- \\`esc\\` interrupts a streaming response, or clears the composer when idle\n\n## Moving around\n\n- \\`tab\\` switches focus between the transcript and the composer\n- with the transcript focused, \\`up\\`/\\`down\\`/\\`j\\`/\\`k\\` scroll and \\`g\\`/\\`G\\` jump to the ends\n- \\`ctrl+o\\` expands and collapses tool output in the transcript\n- the mouse wheel scrolls; click-drag selects text and copies it on release\n- \\`ctrl+c\\` twice exits\n\n## Context\n\npico reads AGENTS.md files automatically: a global one from ~/.pico, then every ancestor of your working directory up to the git root. Deeper files win. AGENTS.md files in subdirectories load lazily the first time a tool touches that subtree.\n\nSessions are stored under ~/.pico as jsonl event logs; \\`/resume\\` folds one back into exactly this view.\n\n---\n\n*esc takes you back to the conversation*`\n\nexport function Help({ commands, onClose }) {\n  useInput((event) => {\n    if (event.key === 'escape') {\n      onClose()\n      event.stopPropagation()\n    }\n  })\n\n  return (\n    <box style={{ flexDirection: 'column', height: '100%', paddingX: 2, paddingY: 1 }}>\n      <box style={{ flexDirection: 'row' }}>\n        <text style={{ color: accent(), bold: true }}>pico \u00B7 help</text>\n        <box style={{ flexGrow: 1 }} />\n        <text style={{ color: FAINT }}>\u2191\u2193 scroll \u00B7 esc back</text>\n      </box>\n      <text> </text>\n      <ScrollBox style={{ flexGrow: 1 }} focused scrollbar>\n        <Markdown text={HELP_TEXT(commands)} codeBg={null} />\n      </ScrollBox>\n    </box>\n  )\n}\n", "import { createSignal, Menu, PickList, ScrollBox, TextInput, useInput } from '@trendr/core'\nimport { accent, FG, FG_SOFT, MUTED, FAINT, PANEL_BG, SELECT_BG, RED } from './theme.js'\nimport { fuzzyScore } from './fuzzy.js'\n\nexport function timeAgo(at) {\n  const s = Math.max(0, Math.floor((Date.now() - at) / 1000))\n  if (s < 60) return `${s}s ago`\n  const m = Math.floor(s / 60)\n  if (m < 60) return `${m}m ago`\n  const h = Math.floor(m / 60)\n  if (h < 24) return `${h}h ago`\n  return `${Math.floor(h / 24)}d ago`\n}\n\nfunction PanelFrame({ title, hint, right, children }) {\n  return (\n    <box style={{ flexDirection: 'column', paddingX: 2, marginTop: 1 }}>\n      <box style={{ flexDirection: 'row' }}>\n        <text style={{ color: accent(), bold: true }}>{title}</text>\n        <box style={{ flexGrow: 1 }} />\n        {right}\n      </box>\n      <text style={{ color: MUTED }}>{hint}</text>\n      {children}\n    </box>\n  )\n}\n\nexport function ScopeTabs({ scopes, active }) {\n  return (\n    <box style={{ flexDirection: 'row' }}>\n      {scopes.map((s, i) => (\n        <text key={s} style={{ color: i === active ? accent() : FAINT, bold: i === active }}>{`${i > 0 ? '  ' : ''}${s}`}</text>\n      ))}\n    </box>\n  )\n}\n\nexport function ModelPanel({ models, current, defaultName, focused, onPick, onPickDefault, onClose }) {\n  const [cursor, setCursor] = createSignal(models[0] || null)\n\n  useInput((event) => {\n    if (!focused) return\n    if (event.ctrl && event.key === 's' && cursor()) {\n      onPickDefault(cursor())\n      event.stopPropagation()\n    }\n  })\n\n  return (\n    <PanelFrame title=\"Select model\" hint=\"type to filter \u00B7 \u2191\u2193 to move \u00B7 enter for this session \u00B7 ctrl+s to make it the default \u00B7 esc to keep current\">\n      <box style={{ flexDirection: 'column', height: 12, marginTop: 1 }}>\n        <PickList\n          items={models}\n          focused={focused}\n          placeholder=\"filter models...\"\n          filter={(q, m) => fuzzyScore(q, m.name) >= 0}\n          onCursorChange={setCursor}\n          onSubmit={onPick}\n          onCancel={onClose}\n          scrollbar\n          gap={1}\n          itemHeight={2}\n          scrolloff={1}\n          renderItem={(m, { selected, focused: f }) => (\n            <box style={{ flexDirection: 'column', bg: selected ? (f ? accent() : SELECT_BG) : null, paddingX: 1 }}>\n              <box style={{ flexDirection: 'row' }}>\n                <text style={{ bold: true, color: selected ? 'black' : FG }}>{m.name}</text>\n                {m.name === current && <text style={{ color: selected ? 'black' : accent() }}>{' \u2713'}</text>}\n                {m.name === defaultName && <text style={{ color: selected ? 'black' : MUTED }}>{' \u00B7 default'}</text>}\n                <box style={{ flexGrow: 1 }} />\n                <text style={{ color: selected ? 'black' : MUTED }}>{`$${m.price.in} in \u00B7 $${m.price.out} out`}</text>\n              </box>\n              <text style={{ color: selected ? 'black' : MUTED }}>{m.desc}</text>\n            </box>\n          )}\n        />\n      </box>\n    </PanelFrame>\n  )\n}\n\nexport function HistoryPanel({ prompts, scopes, scopeIndex, focused, onPick, onClose }) {\n  const [preview, setPreview] = createSignal(prompts[0] || null)\n  const [query, setQuery] = createSignal('')\n  const anyMatch = prompts.some((p) => fuzzyScore(query(), p.text) >= 0)\n\n  return (\n    <PanelFrame\n      title=\"Search prompts\"\n      hint=\"type to filter \u00B7 \u2191\u2193 to move \u00B7 ctrl+s scope \u00B7 enter to edit \u00B7 esc to close\"\n      right={<ScopeTabs scopes={scopes} active={scopeIndex} />}\n    >\n      <box style={{ flexDirection: 'row', height: 12, marginTop: 1, gap: 2 }}>\n        <box style={{ flexDirection: 'column', width: '50%' }}>\n          <PickList\n            items={prompts}\n            focused={focused}\n            placeholder=\"filter prompts...\"\n            filter={(q, p) => fuzzyScore(q, p.text) >= 0}\n            onChange={setQuery}\n            onCursorChange={(p) => setPreview(p)}\n            onSubmit={(p) => onPick(p.text)}\n            onCancel={onClose}\n            scrollbar\n            gap={1}\n            renderItem={(p, { selected, focused: f }) => (\n              <box style={{ flexDirection: 'row', bg: selected ? (f ? accent() : SELECT_BG) : null, paddingX: 1 }}>\n                <box style={{ flexGrow: 1, height: 1 }}>\n                  <text style={{ overflow: 'truncate', color: selected ? 'black' : FG }}>{p.text.replace(/\\n/g, ' ')}</text>\n                </box>\n                <text style={{ color: selected ? 'black' : FAINT, dim: !selected }}>{`  ${timeAgo(p.at)}`}</text>\n              </box>\n            )}\n          />\n        </box>\n        <box style={{ flexDirection: 'column', flexGrow: 1, bg: PANEL_BG, paddingX: 1 }}>\n          {anyMatch && preview() ? (\n            <text style={{ color: FG }}>{preview().text.slice(0, 2000)}</text>\n          ) : (\n            <text style={{ color: FAINT }}>no matching prompts</text>\n          )}\n        </box>\n      </box>\n    </PanelFrame>\n  )\n}\n\nexport function RewindPickPanel({ entries, stats, focused, onPick, onClose }) {\n  const [preview, setPreview] = createSignal(entries[0] || null)\n\n  return (\n    <PanelFrame title=\"Rewind to a message\" hint=\"type to filter \u00B7 \u2191\u2193 to move \u00B7 enter to choose \u00B7 esc to close\">\n      <box style={{ flexDirection: 'row', height: 12, marginTop: 1, gap: 2 }}>\n        <box style={{ flexDirection: 'column', width: '50%' }}>\n          <PickList\n            items={entries}\n            focused={focused}\n            placeholder=\"filter messages...\"\n            filter={(q, m) => fuzzyScore(q, m.text) >= 0}\n            onCursorChange={(m) => setPreview(m)}\n            onSubmit={onPick}\n            onCancel={onClose}\n            scrollbar\n            gap={1}\n            renderItem={(m, { selected, focused: f }) => (\n              <box style={{ flexDirection: 'row', bg: selected ? (f ? accent() : SELECT_BG) : null, paddingX: 1 }}>\n                <box style={{ flexGrow: 1, height: 1 }}>\n                  <text style={{ overflow: 'truncate', color: selected ? 'black' : FG }}>{m.text.replace(/\\n/g, ' ')}</text>\n                </box>\n                <text style={{ color: selected ? 'black' : FAINT, dim: !selected }}>{`  ${stats(m.index).msgs} after`}</text>\n              </box>\n            )}\n          />\n        </box>\n        <box style={{ flexDirection: 'column', flexGrow: 1, bg: PANEL_BG, paddingX: 1 }}>\n          {preview() ? (\n            <box style={{ flexDirection: 'column' }}>\n              <text style={{ color: FG }}>{preview().text.slice(0, 2000)}</text>\n              <text> </text>\n              <text style={{ color: FAINT }}>{`rewinding here drops ${stats(preview().index).msgs} entries`}</text>\n              {stats(preview().index).edits.map((m, i) => (\n                <text key={i} style={{ color: FAINT }}>{`  \u21A9 ${m.title}`}</text>\n              ))}\n            </box>\n          ) : (\n            <text style={{ color: FAINT }}>no matching messages</text>\n          )}\n        </box>\n      </box>\n    </PanelFrame>\n  )\n}\n\nexport function RewindActionPanel({ target, options, focused, onSubmit, onBack }) {\n  return (\n    <box style={{ flexDirection: 'column', paddingX: 2, marginTop: 1 }}>\n      <text style={{ color: accent(), bold: true }}>Rewind options</text>\n      <box style={{ flexDirection: 'row' }}>\n        <text style={{ color: MUTED }}>{'to: '}</text>\n        <box style={{ flexGrow: 1, height: 1 }}>\n          <text style={{ overflow: 'truncate', color: FG_SOFT }}>{target.text.replace(/\\n/g, ' ')}</text>\n        </box>\n      </box>\n      <box style={{ flexDirection: 'column', marginTop: 1 }}>\n        <Menu\n          items={options}\n          focused={focused}\n          maxVisible={4}\n          itemHeight={2}\n          gap={1}\n          vimKeys\n          onSubmit={onSubmit}\n          onCancel={onBack}\n          renderItem={(o, { active }) => (\n            <box style={{ flexDirection: 'column' }}>\n              <box style={{ flexDirection: 'row' }}>\n                <text style={{ color: accent() }}>{active ? '\u203A ' : '  '}</text>\n                <text style={{ color: active ? accent() : FG }}>{o.label}</text>\n              </box>\n              <text style={{ color: FAINT }}>{`  ${o.desc}`}</text>\n            </box>\n          )}\n        />\n      </box>\n      <text style={{ color: FAINT }}>enter to confirm \u00B7 esc to pick a different message</text>\n    </box>\n  )\n}\n\nfunction useEscape(focused, onClose) {\n  useInput((event) => {\n    if (!focused()) return\n    if (event.key === 'escape') {\n      onClose()\n      event.stopPropagation()\n    }\n  })\n}\n\nexport function ResumePanel({ sessions, scopes, scopeIndex, loading, focused, onPick, onClose }) {\n  const [preview, setPreview] = createSignal(sessions[0] || null)\n  useEscape(() => focused, onClose)\n\n  return (\n    <PanelFrame\n      title=\"Resume a session\"\n      hint=\"type to filter \u00B7 \u2191\u2193 to move \u00B7 ctrl+s scope \u00B7 enter to resume \u00B7 esc to close\"\n      right={<ScopeTabs scopes={scopes} active={scopeIndex} />}\n    >\n      <box style={{ flexDirection: 'row', height: 12, marginTop: 1, gap: 2 }}>\n        <box style={{ flexDirection: 'column', width: '50%' }}>\n          {loading ? (\n            <text style={{ color: MUTED }}>loading sessions...</text>\n          ) : sessions.length === 0 ? (\n            <text style={{ color: FAINT }}>no sessions here yet</text>\n          ) : (\n            <PickList\n              items={sessions}\n              focused={focused && !loading}\n              placeholder=\"filter sessions...\"\n              filter={(q, s) => fuzzyScore(q, s.title) >= 0}\n              onCursorChange={(s) => setPreview(s)}\n              onSubmit={onPick}\n              onCancel={onClose}\n              scrollbar\n              gap={1}\n              renderItem={(s, { selected, focused: f }) => (\n                <box style={{ flexDirection: 'row', bg: selected ? (f ? accent() : SELECT_BG) : null, paddingX: 1 }}>\n                  {s.color && <text style={{ color: selected ? 'black' : s.color }}>{'\u25AA '}</text>}\n                  <box style={{ flexGrow: 1, height: 1 }}>\n                    <text style={{ overflow: 'truncate', color: selected ? 'black' : FG }}>{s.title.replace(/\\n/g, ' ')}</text>\n                  </box>\n                  <text style={{ color: selected ? 'black' : FAINT, dim: !selected }}>{`  ${timeAgo(s.at)}`}</text>\n                </box>\n              )}\n            />\n          )}\n        </box>\n        <box style={{ flexDirection: 'column', flexGrow: 1, bg: PANEL_BG, paddingX: 1 }}>\n          {preview() ? (\n            <box style={{ flexDirection: 'column' }}>\n              <text style={{ color: FG }}>{preview().title.slice(0, 500)}</text>\n              <text> </text>\n              <text style={{ color: FAINT }}>{`${preview().turns} ${preview().turns === 1 ? 'turn' : 'turns'} \u00B7 ${timeAgo(preview().at)}`}</text>\n              <text style={{ color: FAINT, overflow: 'truncate' }}>{preview().header.root}</text>\n            </box>\n          ) : (\n            <text style={{ color: FAINT }}>no sessions</text>\n          )}\n        </box>\n      </box>\n    </PanelFrame>\n  )\n}\n\nexport function EffortPanel({ levels, current, defaultLevel, focused, onPick, onPickDefault, onClose }) {\n  const [cursor, setCursor] = createSignal(0)\n  const items = levels\n\n  useInput((event) => {\n    if (!focused) return\n    if (event.ctrl && event.key === 's') {\n      onPickDefault(items[cursor()])\n      event.stopPropagation()\n    }\n  })\n\n  const label = (l) => (l.key === null ? 'default' : l.key)\n\n  return (\n    <PanelFrame title=\"Thinking effort\" hint=\"j/k or \u2191\u2193 to move \u00B7 enter for this session \u00B7 ctrl+s to make it the default \u00B7 esc to keep current\">\n      <box style={{ flexDirection: 'column', marginTop: 1 }}>\n        <Menu\n          items={items}\n          selected={cursor()}\n          onSelect={setCursor}\n          focused={focused}\n          maxVisible={5}\n          vimKeys\n          onSubmit={onPick}\n          onCancel={onClose}\n          renderItem={(l, { active }) => (\n            <box style={{ flexDirection: 'row' }}>\n              <text style={{ color: accent() }}>{active ? '\u203A ' : '  '}</text>\n              <text style={{ color: active ? accent() : FG }}>{label(l).padEnd(10)}</text>\n              <text style={{ color: FAINT }}>{l.desc}</text>\n              {l.key === current && <text style={{ color: active ? accent() : MUTED }}>{'  \u2713'}</text>}\n              {l.key === defaultLevel && <text style={{ color: FAINT }}>{'  \u00B7 default'}</text>}\n            </box>\n          )}\n        />\n      </box>\n    </PanelFrame>\n  )\n}\n\nexport function ProjectPanel({ projects, loading, focused, onPick, onClose }) {\n  const [preview, setPreview] = createSignal(projects[0] || null)\n  useEscape(() => focused, onClose)\n\n  return (\n    <PanelFrame title=\"Switch project\" hint=\"type to filter \u00B7 \u2191\u2193 to move \u00B7 enter to jump to its last session \u00B7 esc to close\">\n      <box style={{ flexDirection: 'row', height: 12, marginTop: 1, gap: 2 }}>\n        <box style={{ flexDirection: 'column', width: '50%' }}>\n          {loading ? (\n            <text style={{ color: MUTED }}>loading projects...</text>\n          ) : projects.length === 0 ? (\n            <text style={{ color: FAINT }}>no known projects yet</text>\n          ) : (\n            <PickList\n              items={projects}\n              focused={focused && !loading}\n              placeholder=\"filter projects...\"\n              filter={(q, p) => fuzzyScore(q, p.path) >= 0}\n              onCursorChange={(p) => setPreview(p)}\n              onSubmit={onPick}\n              onCancel={onClose}\n              scrollbar\n              gap={1}\n              renderItem={(p, { selected, focused: f }) => (\n                <box style={{ flexDirection: 'row', bg: selected ? (f ? accent() : SELECT_BG) : null, paddingX: 1 }}>\n                  {p.latest.color && <text style={{ color: selected ? 'black' : p.latest.color }}>{'\u25AA '}</text>}\n                  <box style={{ flexGrow: 1, height: 1 }}>\n                    <text style={{ overflow: 'truncate', color: selected ? 'black' : FG }}>{p.path}</text>\n                  </box>\n                  <text style={{ color: selected ? 'black' : FAINT, dim: !selected }}>{`  ${p.current ? 'current \u00B7 ' : ''}${timeAgo(p.latest.at)}`}</text>\n                </box>\n              )}\n            />\n          )}\n        </box>\n        <box style={{ flexDirection: 'column', flexGrow: 1, bg: PANEL_BG, paddingX: 1 }}>\n          {preview() ? (\n            <box style={{ flexDirection: 'column' }}>\n              <text style={{ color: FG, overflow: 'truncate' }}>{preview().path}</text>\n              <text> </text>\n              <text style={{ color: FG_SOFT, overflow: 'truncate' }}>{`last: ${preview().latest.title.replace(/\\n/g, ' ')}`}</text>\n              <text style={{ color: FAINT }}>{`${preview().count} ${preview().count === 1 ? 'session' : 'sessions'} \u00B7 ${timeAgo(preview().latest.at)}`}</text>\n            </box>\n          ) : (\n            <text style={{ color: FAINT }}>no projects</text>\n          )}\n        </box>\n      </box>\n    </PanelFrame>\n  )\n}\n\nconst MCP_STATUS = {\n  connected: { icon: '\u25AA', color: accent() },\n  connecting: { icon: '\u25CC', color: '#fbbf24' },\n  error: { icon: '\u2717', color: RED },\n  disabled: { icon: '\u25AB', color: FAINT },\n  idle: { icon: '\u25AB', color: MUTED },\n}\n\nexport function McpPanel({ servers, focused, onToggle, onReconnect, onRemove, onAdd, onClose }) {\n  const [adding, setAdding] = createSignal(false)\n  const [index, setIndex] = createSignal(0)\n  const [viewing, setViewing] = createSignal(null)\n  useEscape(() => focused && !adding(), () => (viewing() ? setViewing(null) : onClose()))\n\n  const selected = () => servers[Math.min(index(), servers.length - 1)] || null\n  const viewed = () => servers.find((s) => s.name === viewing()) || null\n\n  if (viewing() && viewed()) {\n    const server = viewed()\n    const describe = (t) => t.description.replace(/^\\[[^\\]]*\\]\\s*/, '').trim() || 'no description'\n    return (\n      <PanelFrame\n        title={`MCP servers \u00B7 ${server.name} \u00B7 ${server.tools.length} ${server.tools.length === 1 ? 'tool' : 'tools'}`}\n        hint=\"j/k or \u2191\u2193 to scroll \u00B7 esc back to servers\"\n      >\n        <box style={{ flexDirection: 'column', height: 14, marginTop: 1 }}>\n          {server.tools.length === 0 ? (\n            <text style={{ color: FAINT }}>no tools reported \u00B7 is the server connected?</text>\n          ) : (\n            <ScrollBox style={{ flexGrow: 1 }} focused={focused} scrollbar>\n              {server.tools.map((t, i) => (\n                <box key={t.name} style={{ flexDirection: 'column', marginTop: i === 0 ? 0 : 1 }}>\n                  <text style={{ color: accent() }}>{t.name}</text>\n                  <text style={{ color: MUTED }}>{describe(t)}</text>\n                </box>\n              ))}\n            </ScrollBox>\n          )}\n        </box>\n      </PanelFrame>\n    )\n  }\n\n  return (\n    <PanelFrame\n      title=\"MCP servers\"\n      hint={adding()\n        ? 'format: <name> <command...>   e.g. fs npx -y @modelcontextprotocol/server-filesystem /tmp'\n        : 'space/enter toggle \u00B7 t tools \u00B7 r reconnect \u00B7 a add \u00B7 d remove \u00B7 esc close'}\n    >\n      <box style={{ flexDirection: 'column', marginTop: 1 }}>\n        {adding() ? (\n          <box style={{ bg: PANEL_BG, flexDirection: 'row', paddingX: 1 }}>\n            <text style={{ color: accent() }}>{'+ '}</text>\n            <TextInput\n              focused={focused}\n              placeholder=\"name command args...\"\n              clearOnSubmit\n              onSubmit={(value) => {\n                const trimmed = value.trim()\n                const sep = trimmed.indexOf(' ')\n                if (sep > 0) {\n                  onAdd(trimmed.slice(0, sep), trimmed.slice(sep + 1).trim())\n                  setAdding(false)\n                }\n              }}\n              onCancel={() => setAdding(false)}\n            />\n          </box>\n        ) : servers.length === 0 ? (\n          <text style={{ color: FAINT }}>no MCP servers configured \u00B7 press a to add one</text>\n        ) : (\n          <Menu\n            items={servers}\n            selected={index()}\n            onSelect={setIndex}\n            focused={focused}\n            maxVisible={6}\n            vimKeys\n            onSubmit={(s) => onToggle(s.name)}\n            onCancel={onClose}\n            renderItem={(s, { active }) => {\n              const st = MCP_STATUS[s.status] || MCP_STATUS.idle\n              return (\n                <box style={{ flexDirection: 'row' }}>\n                  <text style={{ color: accent() }}>{active ? '\u203A ' : '  '}</text>\n                  <text style={{ color: st.color }}>{st.icon}</text>\n                  <text style={{ color: active ? accent() : FG }}>{` ${s.name.padEnd(14)}`}</text>\n                  <box style={{ flexGrow: 1, height: 1 }}>\n                    <text style={{ overflow: 'truncate', color: s.status === 'error' ? RED : MUTED }}>\n                      {s.status === 'error' ? s.error : s.status === 'connected' ? `${s.toolCount} tools` : s.status}\n                    </text>\n                  </box>\n                  <text style={{ color: FAINT, overflow: 'truncate' }}>{`  ${s.command.slice(0, 40)}`}</text>\n                </box>\n              )\n            }}\n          />\n        )}\n      </box>\n      {!adding() && (\n        <McpKeys\n          focused={focused}\n          onKey={(key) => {\n            const s = selected()\n            if (key === 'a') setAdding(true)\n            else if (s && key === ' ') onToggle(s.name)\n            else if (s && key === 'r') onReconnect(s.name)\n            else if (s && key === 'd') onRemove(s.name)\n            else if (s && key === 't') setViewing(s.name)\n          }}\n        />\n      )}\n    </PanelFrame>\n  )\n}\n\nfunction McpKeys({ focused, onKey }) {\n  useInput((event) => {\n    if (!focused) return\n    if ([' ', 'a', 'r', 'd', 't'].includes(event.key)) {\n      onKey(event.key)\n      event.stopPropagation()\n    }\n  })\n  return null\n}\n"],
  "mappings": "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",
  "names": ["readFileSync", "homedir", "keys", "model", "join", "home", "join", "config", "existsSync", "homedir", "dirname", "join", "resolve", "existsSync", "resolve", "home", "homedir", "join", "dirname", "readFile", "join", "join", "readFile", "readFile", "readdir", "join", "join", "scanDir", "readdir", "readFile", "readFile", "writeFile", "readFile", "writeFile", "registry", "enablement", "writeFile", "homedir", "join", "createSignal", "Menu", "ScrollBox", "useInput", "readFile", "readdir", "join", "join", "readFile", "readdir", "scope", "appendFile", "readFile", "readdir", "join", "appendFile", "scope", "readFile", "join", "readdir", "readFile", "readFile", "resolve", "readFile", "writeFile", "dirname", "resolve", "resolve", "dirname", "readFile", "writeFile", "readFile", "writeFile", "resolve", "resolve", "readFile", "writeFile", "resolve", "resolve", "execFile", "resolve", "MAX_RESULTS", "readFile", "writeFile", "resolve", "existsSync", "existsSync", "execFile", "fg", "resolve", "createSignal", "failed", "version", "Markdown", "jsx", "jsxs", "Markdown", "createSignal", "ScrollBox", "useInput", "jsx", "jsxs", "models", "createSignal", "useInput", "ScrollBox", "jsx", "jsxs", "boot", "version", "models", "createSignal", "model", "defaultModel", "items", "usage", "join", "writeFile", "home", "homedir", "useInput", "ScrollBox", "Menu", "jsx", "readFileSync", "homedir"]
}
