@ashx-j/lunr-dev 0.2.13-dev.7.1 → 0.2.16-dev.9.1

package/dist/node-runtime/chunk-PCGNAY2O.js

@@ -0,0 +1,1324 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  isPlanModeActive,
+  requestPlanApproval
+} from "./chunk-LZAW4ZX3.js";
+import {
+  typebox_exports
+} from "./chunk-PL6JKXWI.js";
+import {
+  ashxj_tui_default
+} from "./chunk-JHYKXIMM.js";
+import {
+  measureStartup
+} from "./chunk-PVCDKGR6.js";
+import {
+  keyText
+} from "./chunk-C4O2RSQQ.js";
+import {
+  getAgentDir
+} from "./chunk-PCIGF2XK.js";
+
+// packages/coding-agent/dist/builtin-extensions/simple-pi-memory.js
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+function baseDir() {
+  return join(dirname(getAgentDir()), "simple-memory");
+}
+function memoryFile() {
+  return join(baseDir(), "memory.md");
+}
+function configFile() {
+  return join(baseDir(), "config.json");
+}
+var DEFAULT_CHAR_CAP = 5e3, MIN_CHAR_CAP = 1, MAX_CHAR_CAP = 3e4;
+function getCapBridge() {
+  return globalThis[/* @__PURE__ */ Symbol.for("@lunr/memory-cap")];
+}
+function isMemoryEnabled() {
+  return getCapBridge()?.isEnabled() ?? !0;
+}
+function disabledResult() {
+  return { content: [{ type: "text", text: "Agent memory is disabled in /settings." }] };
+}
+function ensureDir() {
+  let dir = baseDir();
+  existsSync(dir) || mkdirSync(dir, { recursive: !0 });
+}
+function readMemory() {
+  let file = memoryFile();
+  return existsSync(file) ? readFileSync(file, "utf-8") : "";
+}
+function writeMemoryRaw(text2) {
+  ensureDir(), writeFileSync(memoryFile(), text2, "utf-8");
+}
+function memoryLines() {
+  let text2 = readMemory();
+  return text2.trim() ? text2.split(`
+`).filter((l) => l.trim().length > 0) : [];
+}
+function clampCap(n) {
+  return Number.isFinite(n) ? (n = Math.trunc(n), n < MIN_CHAR_CAP ? MIN_CHAR_CAP : n > MAX_CHAR_CAP ? MAX_CHAR_CAP : n) : DEFAULT_CHAR_CAP;
+}
+function readCap() {
+  let bridge = getCapBridge();
+  if (bridge)
+    return clampCap(bridge.getCharCap());
+  let file = configFile();
+  if (!existsSync(file))
+    return DEFAULT_CHAR_CAP;
+  try {
+    let cfg = JSON.parse(readFileSync(file, "utf-8"));
+    if (typeof cfg.charCap == "number" && Number.isFinite(cfg.charCap))
+      return clampCap(cfg.charCap);
+  } catch {
+  }
+  return DEFAULT_CHAR_CAP;
+}
+function writeCap(cap) {
+  let bridge = getCapBridge();
+  if (bridge) {
+    bridge.setCharCap(clampCap(cap));
+    return;
+  }
+  ensureDir(), writeFileSync(configFile(), JSON.stringify({ charCap: cap }, null, 2), "utf-8");
+}
+function todayStamp() {
+  let d = /* @__PURE__ */ new Date(), p = (x) => String(x).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+function stripDate(line) {
+  return line.replace(/^\[\d{4}-\d{2}-\d{2}\]\s*/, "");
+}
+function simple_pi_memory_default(pi) {
+  pi.on("before_agent_start", async (event) => {
+    if (!isMemoryEnabled())
+      return;
+    let mem = readMemory();
+    if (!mem.trim())
+      return;
+    let block = `
+
+## Memory (durable facts; apply these; change them only with the memory tools)
+` + mem.trimEnd();
+    return { systemPrompt: event.systemPrompt + block };
+  }), pi.registerTool({
+    name: "memory_add",
+    label: "Memory Add",
+    description: [
+      "Add one durable fact about the user or their environment.",
+      "Store only established facts and stable preferences, never behavior instructions, task state, transcripts, guesses, or secrets.",
+      "Each memory is a single line; a [YYYY-MM-DD] date prefix is added automatically.",
+      "An optional #tag improves readability (e.g. #preference).",
+      "Refuses if the content already exists (exact match) or if the file is at the character cap."
+    ].join(`
+`),
+    parameters: typebox_exports.Object({
+      content: typebox_exports.String({
+        description: "The memory text (one line). You may include a #tag."
+      })
+    }),
+    async execute(_id, params) {
+      if (!isMemoryEnabled())
+        return disabledResult();
+      let content = String(params.content ?? "").replace(/[\r\n]+/g, " ").trim();
+      if (!content)
+        return { content: [{ type: "text", text: "memory_add: content is empty." }] };
+      let lines = memoryLines();
+      if (lines.some((l) => stripDate(l) === content))
+        return { content: [{ type: "text", text: "Already in memory (not added)." }] };
+      let cap = readCap(), newLine = `[${todayStamp()}] ${content}`, sep = lines.length > 0 ? `
+` : "", prospective = lines.join(`
+`) + sep + newLine + `
+`;
+      return prospective.length > cap ? {
+        content: [
+          {
+            type: "text",
+            text: `Memory full: ${readMemory().length}/${cap} chars. Remove a memory first (memory_remove).`
+          }
+        ]
+      } : (writeMemoryRaw(prospective), {
+        content: [
+          { type: "text", text: `Added memory (${prospective.length}/${cap} chars): ${newLine}` }
+        ]
+      });
+    }
+  }), pi.registerTool({
+    name: "memory_remove",
+    label: "Memory Remove",
+    description: [
+      "Remove one memory by its exact line text, as shown by memory_load.",
+      "Deletes only an exact, full-line match (including the date prefix).",
+      "Returns 'not found' if no line matches exactly."
+    ].join(`
+`),
+    parameters: typebox_exports.Object({
+      line: typebox_exports.String({
+        description: "The exact memory line to remove (verbatim, including the date prefix)."
+      })
+    }),
+    async execute(_id, params) {
+      if (!isMemoryEnabled())
+        return disabledResult();
+      let target = String(params.line ?? "").trim();
+      if (!target)
+        return { content: [{ type: "text", text: "memory_remove: line is empty." }] };
+      let lines = memoryLines(), remaining = lines.filter((l) => l !== target);
+      return remaining.length === lines.length ? { content: [{ type: "text", text: `Not found (no exact match): ${target}` }] } : (writeMemoryRaw(remaining.length > 0 ? remaining.join(`
+`) + `
+` : ""), { content: [{ type: "text", text: `Removed memory: ${target}` }] });
+    }
+  }), pi.registerTool({
+    name: "memory_load",
+    label: "Memory Load",
+    description: [
+      "Read the current memory file and show all memories with the size/cap.",
+      "Use this to inspect durable facts before adding, correcting, or removing one."
+    ].join(`
+`),
+    parameters: typebox_exports.Object({}),
+    async execute() {
+      if (!isMemoryEnabled())
+        return disabledResult();
+      let raw = readMemory(), cap = readCap();
+      return raw.trim() ? {
+        content: [
+          { type: "text", text: `Memory (${raw.length}/${cap} chars):
+${raw.trimEnd()}` }
+        ]
+      } : { content: [{ type: "text", text: `Memory is empty (0/${cap} chars).` }] };
+    }
+  }), pi.registerCommand("memory-char-cap", {
+    description: "View or set the memory character cap (1..30000). Default 5000.",
+    handler(args, ctx) {
+      let trimmed = args.trim();
+      if (!trimmed) {
+        ctx.ui.notify(`Memory character cap: ${readCap()}`, "info");
+        return;
+      }
+      let n = Number(trimmed);
+      if (!Number.isFinite(n) || !Number.isInteger(n) || n < MIN_CHAR_CAP || n > MAX_CHAR_CAP) {
+        ctx.ui.notify(`Invalid cap. Must be an integer between ${MIN_CHAR_CAP} and ${MAX_CHAR_CAP}.`, "error");
+        return;
+      }
+      if (n < readMemory().length) {
+        ctx.ui.notify(`Your memory file already exceeds this character cap: ${memoryFile()}`, "warning");
+        return;
+      }
+      writeCap(n), ctx.ui.notify(`Memory character cap set to ${n}.`, "info");
+    }
+  });
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-tps.js
+var spinner = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"], spinnerIdx = 0, spinnerInterval = null, GREEN = "\x1B[32m", YELLOW = "\x1B[33m", RED = "\x1B[31m", RESET = "\x1B[0m";
+function colorForTps(tps) {
+  return tps >= 100 ? GREEN : tps >= 30 ? YELLOW : RED;
+}
+function formatTokens(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+}
+function pi_tps_default(pi) {
+  let messageStartTime = 0, lastAvgTps = 0, lastOutputTokens = 0, isStreaming = !1;
+  pi.on("agent_start", async (_event, ctx) => {
+    lastAvgTps = 0, lastOutputTokens = 0, ctx.hasUI && ctx.ui.setStatus("tps", "");
+  }), pi.on("message_start", (event) => {
+    event.message.role === "assistant" && (messageStartTime = Date.now(), isStreaming = !0, spinnerIdx = 0, spinnerInterval && clearInterval(spinnerInterval), spinnerInterval = setInterval(() => {
+      spinnerIdx = (spinnerIdx + 1) % spinner.length;
+    }, 80));
+  }), pi.on("message_update", (event, ctx) => {
+    if (event.message.role !== "assistant" || !ctx.hasUI)
+      return;
+    let usage = event.message.usage;
+    if (!usage)
+      return;
+    let outputTokens = usage.output;
+    if (outputTokens === 0)
+      return;
+    let elapsed = (Date.now() - messageStartTime) / 1e3, tps = outputTokens / elapsed, color = colorForTps(tps), frame = spinner[spinnerIdx % spinner.length];
+    ctx.ui.setStatus("tps", `${color}${frame} ${tps.toFixed(1)} t/s${RESET} \u2193 ${formatTokens(outputTokens)} tokens`);
+  }), pi.on("message_end", (event, ctx) => {
+    if (event.message.role !== "assistant" || !ctx.hasUI)
+      return;
+    let elapsed = (Date.now() - messageStartTime) / 1e3, outputTokens = event.message.usage?.output ?? 0;
+    elapsed > 0 && outputTokens > 0 && (lastAvgTps = outputTokens / elapsed, lastOutputTokens = outputTokens), isStreaming = !1, spinnerInterval && (clearInterval(spinnerInterval), spinnerInterval = null), setImmediate(() => {
+      let color = colorForTps(lastAvgTps);
+      ctx.ui.setStatus("tps", `${color}\u2713 ${lastAvgTps.toFixed(1)} t/s \xB7 ${formatTokens(lastOutputTokens)} tokens in ${elapsed.toFixed(1)}s${RESET}`);
+    });
+  });
+}
+
+// node_modules/unicode-animations/dist/chunk-F2BWZODB.js
+var BRAILLE_DOT_MAP = [
+  [1, 8],
+  // row 0
+  [2, 16],
+  // row 1
+  [4, 32],
+  // row 2
+  [64, 128]
+  // row 3
+];
+function gridToBraille(grid) {
+  let rows = grid.length, cols = grid[0] ? grid[0].length : 0, charCount = Math.ceil(cols / 2), result = "";
+  for (let c = 0; c < charCount; c++) {
+    let code = 10240;
+    for (let r = 0; r < 4 && r < rows; r++)
+      for (let d = 0; d < 2; d++) {
+        let col = c * 2 + d;
+        col < cols && grid[r] && grid[r][col] && (code |= BRAILLE_DOT_MAP[r][d]);
+      }
+    result += String.fromCodePoint(code);
+  }
+  return result;
+}
+function makeGrid(rows, cols) {
+  return rows <= 0 || cols <= 0 ? [] : Array.from({ length: rows }, () => Array(cols).fill(!1));
+}
+function genScan() {
+  let frames = [];
+  for (let pos = -1; pos < 9; pos++) {
+    let g = makeGrid(4, 8);
+    for (let r = 0; r < 4; r++)
+      for (let c = 0; c < 8; c++)
+        (c === pos || c === pos - 1) && (g[r][c] = !0);
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genRain() {
+  let frames = [], offsets = [0, 3, 1, 5, 2, 7, 4, 6];
+  for (let f = 0; f < 12; f++) {
+    let g = makeGrid(4, 8);
+    for (let c = 0; c < 8; c++) {
+      let row = (f + offsets[c]) % 6;
+      row < 4 && (g[row][c] = !0);
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genScanLine() {
+  let frames = [], positions = [0, 1, 2, 3, 2, 1];
+  for (let row of positions) {
+    let g = makeGrid(4, 6);
+    for (let c = 0; c < 6; c++)
+      g[row][c] = !0, row > 0 && (g[row - 1][c] = c % 2 === 0);
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genPulse() {
+  let frames = [], radii = [0.5, 1.2, 2, 3, 3.5];
+  for (let r of radii) {
+    let g = makeGrid(4, 6);
+    for (let row = 0; row < 4; row++)
+      for (let col = 0; col < 6; col++) {
+        let dist = Math.sqrt((col - 2.5) ** 2 + (row - 1.5) ** 2);
+        Math.abs(dist - r) < 0.9 && (g[row][col] = !0);
+      }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genSnake() {
+  let path = [];
+  for (let r = 0; r < 4; r++)
+    if (r % 2 === 0)
+      for (let c = 0; c < 4; c++) path.push([r, c]);
+    else
+      for (let c = 3; c >= 0; c--) path.push([r, c]);
+  let frames = [];
+  for (let i = 0; i < path.length; i++) {
+    let g = makeGrid(4, 4);
+    for (let t = 0; t < 4; t++) {
+      let idx = (i - t + path.length) % path.length;
+      g[path[idx][0]][path[idx][1]] = !0;
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genSparkle() {
+  let patterns = [
+    [1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0],
+    [0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0],
+    [0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1],
+    [1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0],
+    [0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1],
+    [0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0]
+  ], W = 8, H = 4, frames = [];
+  for (let pat of patterns) {
+    let g = makeGrid(H, W);
+    for (let r = 0; r < H; r++)
+      for (let c = 0; c < W; c++)
+        g[r][c] = !!pat[r * W + c];
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genCascade() {
+  let frames = [];
+  for (let offset = -2; offset < 12; offset++) {
+    let g = makeGrid(4, 8);
+    for (let r = 0; r < 4; r++)
+      for (let c = 0; c < 8; c++) {
+        let diag = c + r;
+        (diag === offset || diag === offset - 1) && (g[r][c] = !0);
+      }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genColumns() {
+  let frames = [];
+  for (let col = 0; col < 6; col++)
+    for (let fillTo = 3; fillTo >= 0; fillTo--) {
+      let g = makeGrid(4, 6);
+      for (let pc = 0; pc < col; pc++)
+        for (let r = 0; r < 4; r++) g[r][pc] = !0;
+      for (let r = fillTo; r < 4; r++) g[r][col] = !0;
+      frames.push(gridToBraille(g));
+    }
+  let full = makeGrid(4, 6);
+  for (let r = 0; r < 4; r++) for (let c = 0; c < 6; c++) full[r][c] = !0;
+  return frames.push(gridToBraille(full)), frames.push(gridToBraille(makeGrid(4, 6))), frames;
+}
+function genOrbit() {
+  let path = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [2, 1],
+    [3, 1],
+    [3, 0],
+    [2, 0],
+    [1, 0]
+  ], frames = [];
+  for (let i = 0; i < path.length; i++) {
+    let g = makeGrid(4, 2);
+    g[path[i][0]][path[i][1]] = !0;
+    let t1 = (i - 1 + path.length) % path.length;
+    g[path[t1][0]][path[t1][1]] = !0, frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genBreathe() {
+  let stages = [
+    [],
+    [[1, 0]],
+    [[0, 1], [2, 0]],
+    [[0, 0], [1, 1], [3, 0]],
+    [[0, 0], [1, 1], [2, 0], [3, 1]],
+    [[0, 0], [0, 1], [1, 1], [2, 0], [3, 1]],
+    [[0, 0], [0, 1], [1, 0], [2, 1], [3, 0], [3, 1]],
+    [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [3, 0], [3, 1]],
+    [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1], [3, 0], [3, 1]]
+  ], frames = [], sequence = [...stages, ...stages.slice().reverse().slice(1)];
+  for (let dots of sequence) {
+    let g = makeGrid(4, 2);
+    for (let [r, c] of dots) g[r][c] = !0;
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genWaveRows() {
+  let frames = [];
+  for (let f = 0; f < 16; f++) {
+    let g = makeGrid(4, 8);
+    for (let c = 0; c < 8; c++) {
+      let phase = f - c * 0.5, row = Math.round((Math.sin(phase * 0.8) + 1) / 2 * 3);
+      g[row][c] = !0, row > 0 && (g[row - 1][c] = (f + c) % 3 === 0);
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genCheckerboard() {
+  let frames = [];
+  for (let phase = 0; phase < 4; phase++) {
+    let g = makeGrid(4, 6);
+    for (let r = 0; r < 4; r++)
+      for (let c = 0; c < 6; c++)
+        phase < 2 ? g[r][c] = (r + c + phase) % 2 === 0 : g[r][c] = (r + c + phase) % 3 === 0;
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genHelix() {
+  let frames = [];
+  for (let f = 0; f < 16; f++) {
+    let g = makeGrid(4, 8);
+    for (let c = 0; c < 8; c++) {
+      let phase = (f + c) * (Math.PI / 4), y1 = Math.round((Math.sin(phase) + 1) / 2 * 3), y2 = Math.round((Math.sin(phase + Math.PI) + 1) / 2 * 3);
+      g[y1][c] = !0, g[y2][c] = !0;
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genFillSweep() {
+  let frames = [];
+  for (let row = 3; row >= 0; row--) {
+    let g = makeGrid(4, 4);
+    for (let r = row; r < 4; r++)
+      for (let c = 0; c < 4; c++) g[r][c] = !0;
+    frames.push(gridToBraille(g));
+  }
+  let full = makeGrid(4, 4);
+  for (let r = 0; r < 4; r++) for (let c = 0; c < 4; c++) full[r][c] = !0;
+  frames.push(gridToBraille(full)), frames.push(gridToBraille(full));
+  for (let row = 0; row < 4; row++) {
+    let g = makeGrid(4, 4);
+    for (let r = row + 1; r < 4; r++)
+      for (let c = 0; c < 4; c++) g[r][c] = !0;
+    frames.push(gridToBraille(g));
+  }
+  return frames.push(gridToBraille(makeGrid(4, 4))), frames;
+}
+function genDiagonalSwipe() {
+  let frames = [];
+  for (let d = 0; d <= 6; d++) {
+    let g = makeGrid(4, 4);
+    for (let r = 0; r < 4; r++)
+      for (let c = 0; c < 4; c++)
+        r + c <= d && (g[r][c] = !0);
+    frames.push(gridToBraille(g));
+  }
+  let full = makeGrid(4, 4);
+  for (let r = 0; r < 4; r++) for (let c = 0; c < 4; c++) full[r][c] = !0;
+  frames.push(gridToBraille(full));
+  for (let d = 0; d <= 6; d++) {
+    let g = makeGrid(4, 4);
+    for (let r = 0; r < 4; r++)
+      for (let c = 0; c < 4; c++)
+        r + c > d && (g[r][c] = !0);
+    frames.push(gridToBraille(g));
+  }
+  return frames.push(gridToBraille(makeGrid(4, 4))), frames;
+}
+var spinners = {
+  // === Classic braille single-char ===
+  braille: {
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+    interval: 80
+  },
+  braillewave: {
+    frames: [
+      "\u2801\u2802\u2804\u2840",
+      "\u2802\u2804\u2840\u2880",
+      "\u2804\u2840\u2880\u2820",
+      "\u2840\u2880\u2820\u2810",
+      "\u2880\u2820\u2810\u2808",
+      "\u2820\u2810\u2808\u2801",
+      "\u2810\u2808\u2801\u2802",
+      "\u2808\u2801\u2802\u2804"
+    ],
+    interval: 100
+  },
+  dna: {
+    frames: [
+      "\u280B\u2809\u2819\u281A",
+      "\u2809\u2819\u281A\u2812",
+      "\u2819\u281A\u2812\u2802",
+      "\u281A\u2812\u2802\u2802",
+      "\u2812\u2802\u2802\u2812",
+      "\u2802\u2802\u2812\u2832",
+      "\u2802\u2812\u2832\u2834",
+      "\u2812\u2832\u2834\u2824",
+      "\u2832\u2834\u2824\u2804",
+      "\u2834\u2824\u2804\u280B",
+      "\u2824\u2804\u280B\u2809",
+      "\u2804\u280B\u2809\u2819"
+    ],
+    interval: 80
+  },
+  // === Generated braille grid animations ===
+  scan: { frames: genScan(), interval: 70 },
+  rain: { frames: genRain(), interval: 100 },
+  scanline: { frames: genScanLine(), interval: 120 },
+  pulse: { frames: genPulse(), interval: 180 },
+  snake: { frames: genSnake(), interval: 80 },
+  sparkle: { frames: genSparkle(), interval: 150 },
+  cascade: { frames: genCascade(), interval: 60 },
+  columns: { frames: genColumns(), interval: 60 },
+  orbit: { frames: genOrbit(), interval: 100 },
+  breathe: { frames: genBreathe(), interval: 100 },
+  waverows: { frames: genWaveRows(), interval: 90 },
+  checkerboard: { frames: genCheckerboard(), interval: 250 },
+  helix: { frames: genHelix(), interval: 80 },
+  fillsweep: { frames: genFillSweep(), interval: 100 },
+  diagswipe: { frames: genDiagonalSwipe(), interval: 60 }
+};
+
+// packages/coding-agent/dist/builtin-extensions/ashxj-spinners.js
+var THINKING_TOOL_SPINNER_POOL = [
+  "rain",
+  "breathe",
+  "checkerboard",
+  "sparkle",
+  "braille",
+  "snake"
+], THINKING_TOOL_KAOMOJI_POOL = [
+  // formerly `thinking`
+  "(\u1D55\u2014\u1D17\u2014)",
+  // determined
+  "(\u02F5 \xAC\u1D17\xAC\u02F5)",
+  // clever
+  "(\u2E1D\u2E1D\u1D55\u1D17\u1D55\u2E1D\u2E1D)",
+  // admiring gaze
+  "\u2E1C(\uFF61\u02C3 \u1D55 \u02C2 )\u2E1D\u2661",
+  // blushing happy
+  "(\u02F6>\u2A4A<\u02F6)",
+  // cheerful
+  "\u0AEE\u2E1D\u2E1D> \u032B <\u2E1D\u2E1D \u10D0",
+  // pleading with worry
+  "(\u02F6  >   \u2083  < \u02F6)",
+  // licking lips
+  // formerly `toolRunning`
+  "(\u0E51\xB4>\u1391<)~*",
+  // reaching for hug, eager
+  // new
+  "\u208D^. .^\u208E\u27C6",
+  "(\u3145\xB4 \u02D8 `)",
+  "(\u201E\u2022 \u058A \u2022\u201E)",
+  "(\u02F6\u02C3 \u1D55 \u02C2\u02F6)",
+  "\u285E\u2833\u28C4\u28C0\u28E0\u281E\u28B7 \u05B9\u06EA",
+  "\uFF08\u02F6\u2022\u0300 \u1391-\u02F6\uFF09"
+], SPINNER_POOL_FOR_STATE = {
+  idle: [],
+  startup: [],
+  thinking: THINKING_TOOL_SPINNER_POOL,
+  searching: ["diagswipe", "scan", "cascade"],
+  editing: ["columns", "fillsweep"],
+  toolRunning: THINKING_TOOL_SPINNER_POOL,
+  complete: [],
+  error: ["pulse"]
+}, KAOMOJI_FOR_STATE = {
+  // idle, startup, complete are silent: no kaomoji.
+  idle: [],
+  startup: [],
+  thinking: THINKING_TOOL_KAOMOJI_POOL,
+  searching: [
+    "(\u2E1D\u2E1D\u2A4C \u2919 \u2A4C\u2E1D\u2E1D)",
+    // confused
+    "(\u2579 -\u2579)?"
+    // questioning
+  ],
+  editing: [
+    "(\u1D55 \u2022 \u1D17 \u2022)",
+    // content
+    "(\u02F6\u1D54 \u1D55 \u1D54\u02F6) \u2039\u{1D7F9}",
+    // warm with small heart
+    "(\u0E51\u1D54\u2919\u1D54\u0E51)"
+    // gleeful
+  ],
+  toolRunning: THINKING_TOOL_KAOMOJI_POOL,
+  complete: [],
+  error: [
+    "(,,>\uFE4F<,,)",
+    // crying
+    "(\u2E1D\u2E1D \u2661\uFE4F\u2661\u2E1D\u2E1D)",
+    // apologetic crying
+    '"\u0AEE\u208D \u02F6\u2022\u2919\u2022\u02F6 \u208E\u10D0',
+    // pleading paws
+    "(\u2565\uFE4F\u2565)",
+    // heavy crying
+    "(\u02F6\xB0\u3141\xB0)!!",
+    // shocked
+    "(,,\u2022\u1DC4\uFE4F\u200E\u2022\u1DC5,,)"
+    // distressed
+  ]
+}, SEARCH_RE = /(search|find|grep|list|ls|fuzzy|query)/i, EDIT_RE = /(^|[_\-\s])(write|edit|patch|create|delete|remove|replace|insert|update|apply_?patch|apply_?edit|str_?replace|str_?replace_?editor|create_?file|delete_?file|write_?file|edit_?file|insert_?content|append_?file|modify_?file)([_\-\s]|$)/i, TRANSIENT_MS = 3e3, STATE_TTL_MS = 3e3, STATES_WITH_TTL = /* @__PURE__ */ new Set([
+  "thinking",
+  "searching",
+  "editing",
+  "toolRunning",
+  "error"
+]), SILENT_STATES = /* @__PURE__ */ new Set([
+  "idle",
+  "startup",
+  "complete"
+]), KAOMOJI_REROLL_MS = 3e4;
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function pickOther(arr, current) {
+  if (arr.length <= 1)
+    return arr[0];
+  let v;
+  do
+    v = pick(arr);
+  while (v === current);
+  return v;
+}
+function ashxj_spinners_default(pi) {
+  let state = "idle", stateEnteredAt = 0, currentKaomoji = "", transientTimer, rerollTimer;
+  function publishWorkingMessage(ctx) {
+    ctx.ui.setWorkingMessage(currentKaomoji);
+  }
+  function clearTransient() {
+    transientTimer !== void 0 && (clearTimeout(transientTimer), transientTimer = void 0);
+  }
+  function clearReroll() {
+    rerollTimer !== void 0 && (clearInterval(rerollTimer), rerollTimer = void 0);
+  }
+  function doApplyState(next, ctx) {
+    state = next, stateEnteredAt = Date.now();
+    let spinnerPool = SPINNER_POOL_FOR_STATE[next];
+    if (spinnerPool.length > 0) {
+      let spinnerName = pick(spinnerPool), def = spinners[spinnerName], frames = def.frames.map((f) => ctx.ui.theme.fg("accent", f));
+      ctx.ui.setWorkingIndicator({ frames, intervalMs: def.interval });
+    } else
+      ctx.ui.setWorkingIndicator({ frames: [] });
+    let kaomojiPool = KAOMOJI_FOR_STATE[next];
+    currentKaomoji = kaomojiPool.length > 0 ? pick(kaomojiPool) : "", publishWorkingMessage(ctx), clearReroll(), clearTransient(), kaomojiPool.length > 1 && (rerollTimer = setInterval(() => rerollKaomoji(ctx), KAOMOJI_REROLL_MS)), (next === "complete" || next === "startup") && (transientTimer = setTimeout(() => doApplyState("idle", ctx), TRANSIENT_MS));
+  }
+  function rerollKaomoji(ctx) {
+    let pool = KAOMOJI_FOR_STATE[state];
+    pool.length <= 1 || (currentKaomoji = pickOther(pool, currentKaomoji), publishWorkingMessage(ctx));
+  }
+  function applyState(next, ctx, options = {}) {
+    ctx.mode === "tui" && (!options.force && !SILENT_STATES.has(next) && next !== "error" && STATES_WITH_TTL.has(state) && Date.now() - stateEnteredAt < STATE_TTL_MS || doApplyState(next, ctx));
+  }
+  pi.on("session_start", (event, ctx) => {
+    ctx.mode === "tui" && doApplyState(event.reason === "startup" ? "startup" : "idle", ctx);
+  }), pi.on("turn_start", (_event, ctx) => {
+    applyState("thinking", ctx);
+  }), pi.on("tool_execution_start", (event, ctx) => {
+    if (state === "error")
+      return;
+    let name = event.toolName, force = !0;
+    SEARCH_RE.test(name) ? applyState("searching", ctx, { force }) : EDIT_RE.test(name) ? applyState("editing", ctx, { force }) : applyState("toolRunning", ctx, { force });
+  }), pi.on("tool_execution_end", (event, ctx) => {
+    event.isError && applyState("error", ctx);
+  }), pi.on("turn_end", (_event, ctx) => {
+    (state === "searching" || state === "editing" || state === "toolRunning") && applyState("thinking", ctx, { force: !0 });
+  }), pi.on("agent_end", (event, ctx) => {
+    let last = event.messages.at(-1);
+    if (!last || last.role !== "assistant") {
+      applyState("idle", ctx);
+      return;
+    }
+    let stopReason = last.stopReason;
+    stopReason === "stop" || stopReason === "length" ? applyState("complete", ctx) : stopReason === "error" || stopReason === "aborted" ? applyState("error", ctx) : stopReason === "toolUse" || applyState("idle", ctx);
+  }), pi.on("session_shutdown", (_event, ctx) => {
+    clearTransient(), clearReroll(), ctx.mode === "tui" && (ctx.ui.setWorkingIndicator({ frames: [] }), ctx.ui.setWorkingMessage("")), state = "idle", stateEnteredAt = 0, currentKaomoji = "";
+  });
+}
+
+// packages/coding-agent/dist/builtin-extensions/ashxj-thinking.js
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, renameSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir } from "node:os";
+var ALL_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"], ALL_LEVELS_5 = ["off", "minimal", "low", "medium", "high"], THINKING_DESCRIPTIONS = {
+  off: "No reasoning",
+  minimal: "Very brief reasoning",
+  low: "Light reasoning",
+  medium: "Moderate reasoning",
+  high: "Deep reasoning",
+  xhigh: "Extra-high reasoning",
+  // lunr: added — mirrors settings-selector.ts.
+  max: "Maximum reasoning"
+};
+function availableLevelsFor(model) {
+  return model ? model.reasoning === !1 ? ["off"] : ALL_LEVELS.filter((level) => {
+    let mapped = model.thinkingLevelMap?.[level];
+    return mapped === null ? !1 : level === "xhigh" || level === "max" ? mapped !== void 0 : !0;
+  }) : ALL_LEVELS_5;
+}
+function formatLevelLabel(level) {
+  return `${level.padEnd(8)} \u2014 ${THINKING_DESCRIPTIONS[level]}`;
+}
+function agentSettingsPath() {
+  let envDir = process.env.PI_CODING_AGENT_DIR;
+  if (envDir) {
+    let home = homedir(), expanded = envDir === "~" ? home : envDir.startsWith("~/") || process.platform === "win32" && envDir.startsWith("~\\") ? join2(home, envDir.slice(2)) : envDir;
+    return join2(expanded, "settings.json");
+  }
+  return join2(homedir(), ".lunr", "agent", "settings.json");
+}
+function getCustomizeBridge() {
+  return globalThis[/* @__PURE__ */ Symbol.for("@lunr/customize")];
+}
+function readHideThinkingBlock() {
+  let bridge = getCustomizeBridge();
+  if (bridge)
+    return bridge.getHideThinkingBlock();
+  try {
+    let p = agentSettingsPath();
+    return existsSync2(p) ? JSON.parse(readFileSync2(p, "utf8")).hideThinkingBlock === !0 : !1;
+  } catch {
+    return !1;
+  }
+}
+function writeHideThinkingBlock(hide) {
+  let bridge = getCustomizeBridge();
+  if (bridge)
+    try {
+      return bridge.setHideThinkingBlock(hide), { ok: !0, createdFresh: !1 };
+    } catch {
+      return { ok: !1, createdFresh: !1 };
+    }
+  try {
+    let p = agentSettingsPath(), cfg = {}, createdFresh = !1;
+    if (existsSync2(p))
+      try {
+        cfg = JSON.parse(readFileSync2(p, "utf8"));
+      } catch {
+        try {
+          renameSync(p, `${p}.bak`);
+        } catch {
+        }
+        cfg = {}, createdFresh = !0;
+      }
+    else
+      createdFresh = !0;
+    return cfg.hideThinkingBlock = hide, writeFileSync2(p, JSON.stringify(cfg, null, 2) + `
+`, "utf8"), { ok: !0, createdFresh };
+  } catch {
+    return { ok: !1, createdFresh: !1 };
+  }
+}
+var THINKING_COMMAND_DESCRIPTION = "View or set the reasoning level for the current model, or toggle thinking-block visibility with show/hide/toggle";
+function ashxj_thinking_default(pi) {
+  let thinkingSpec = {
+    description: THINKING_COMMAND_DESCRIPTION,
+    getArgumentCompletions(prefix) {
+      let lower = prefix.toLowerCase(), visibility = [
+        { value: "show", label: "show", description: "Show thinking blocks (persisted to settings.json)" },
+        { value: "hide", label: "hide", description: "Hide thinking blocks (persisted to settings.json)" },
+        { value: "toggle", label: "toggle", description: "Toggle thinking blocks (persisted to settings.json)" }
+      ], levelItems = availableLevelsFor(currentModel(pi)).filter((lvl) => lvl.startsWith(lower)).map((lvl) => ({ value: lvl, label: lvl, description: THINKING_DESCRIPTIONS[lvl] }));
+      return [
+        ...visibility.filter((v) => v.value.startsWith(lower)),
+        ...levelItems
+      ];
+    },
+    handler: async (args, ctx) => {
+      let trimmed = args.trim(), lower = trimmed.toLowerCase();
+      if (lower === "show" || lower === "hide" || lower === "toggle") {
+        let current = readHideThinkingBlock(), next = lower === "toggle" ? !current : lower === "hide";
+        if (next === current) {
+          ctx.ui.notify(`Thinking blocks already ${current ? "hidden" : "shown"}.`, "info");
+          return;
+        }
+        let result = writeHideThinkingBlock(next);
+        if (!result.ok) {
+          ctx.ui.notify(`Failed to update ${agentSettingsPath()}`, "error");
+          return;
+        }
+        let verb = next ? "hidden" : "shown", note = result.createdFresh ? `Thinking blocks ${verb}. (Created ${agentSettingsPath()} with this setting.)` : `Thinking blocks ${verb}.`;
+        ctx.ui.notify(note, "info"), await ctx.reload();
+        return;
+      }
+      let levels = availableLevelsFor(ctx.model), currentLevel = pi.getThinkingLevel(), validSet = new Set(levels);
+      if (trimmed === "") {
+        if (ctx.mode !== "tui") {
+          ctx.ui.notify(`Thinking level: ${currentLevel}`, "info");
+          return;
+        }
+        if (levels.length === 0) {
+          ctx.ui.notify("No thinking levels available for this model.", "warning");
+          return;
+        }
+        let options = levels.map((lvl) => (lvl === currentLevel ? "\u25CF " : "  ") + formatLevelLabel(lvl)), chosen = await ctx.ui.select(`Thinking level (current: ${currentLevel})`, options);
+        if (chosen === void 0)
+          return;
+        let level = chosen.replace(/^[\u25CF ]\s?/, "").trimStart().split(/\s+/)[0];
+        if (!validSet.has(level)) {
+          ctx.ui.notify(`Unsupported thinking level: ${level}`, "error");
+          return;
+        }
+        if (level === currentLevel)
+          return;
+        pi.setThinkingLevel(level), ctx.ui.notify(`Thinking level: ${pi.getThinkingLevel()}`, "info");
+        return;
+      }
+      let requested = trimmed.toLowerCase();
+      if (!validSet.has(requested)) {
+        ctx.ui.notify(`Invalid thinking level: "${trimmed}". Valid: ${levels.join(", ")}`, "error");
+        return;
+      }
+      if (requested === currentLevel) {
+        ctx.ui.notify(`Thinking level: ${requested} (unchanged)`, "info");
+        return;
+      }
+      pi.setThinkingLevel(requested), ctx.ui.notify(`Thinking level: ${pi.getThinkingLevel()}`, "info");
+    }
+  };
+  pi.registerCommand("thinking", thinkingSpec), pi.registerCommand("effort", {
+    ...thinkingSpec,
+    description: `${THINKING_COMMAND_DESCRIPTION} (alias of /thinking)`
+  }), pi.registerCommand("reasoning", {
+    ...thinkingSpec,
+    description: `${THINKING_COMMAND_DESCRIPTION} (alias of /thinking)`
+  });
+}
+function currentModel(pi) {
+  let fn = pi.getModel;
+  if (typeof fn == "function")
+    return fn.call(pi);
+}
+
+// packages/coding-agent/dist/builtin-extensions/lunr-local-providers/local-servers.js
+var OLLAMA_ORIGIN = "http://127.0.0.1:11434", LM_STUDIO_ORIGIN = "http://127.0.0.1:1234", OLLAMA_LOCAL = {
+  providerId: "ollama-local",
+  displayName: "Ollama (local)",
+  productName: "Ollama",
+  port: 11434,
+  baseUrl: `${OLLAMA_ORIGIN}/v1`,
+  modelsUrl: `${OLLAMA_ORIGIN}/v1/models`,
+  tagsUrl: `${OLLAMA_ORIGIN}/api/tags`,
+  dummyKey: "ollama"
+}, LM_STUDIO = {
+  providerId: "lm-studio",
+  displayName: "LM Studio (local)",
+  productName: "LM Studio",
+  port: 1234,
+  baseUrl: `${LM_STUDIO_ORIGIN}/v1`,
+  modelsUrl: `${LM_STUDIO_ORIGIN}/v1/models`,
+  dummyKey: "local"
+}, LOCAL_SERVERS = [OLLAMA_LOCAL, LM_STUDIO];
+function extractModelIds(payload) {
+  let ids = [], push = (value) => {
+    typeof value == "string" && value.length > 0 && !ids.includes(value) && ids.push(value);
+  }, fromEntry = (entry) => {
+    if (typeof entry == "string") {
+      push(entry);
+      return;
+    }
+    if (entry !== null && typeof entry == "object") {
+      let record = entry;
+      push(record.id ?? record.name ?? record.model);
+    }
+  };
+  if (Array.isArray(payload)) {
+    for (let entry of payload)
+      fromEntry(entry);
+    return ids;
+  }
+  if (payload !== null && typeof payload == "object") {
+    let record = payload;
+    if (Array.isArray(record.data))
+      for (let entry of record.data)
+        fromEntry(entry);
+    if (Array.isArray(record.models))
+      for (let entry of record.models)
+        fromEntry(entry);
+  }
+  return ids;
+}
+async function fetchJson(url, timeoutMs, signal) {
+  let controller = new AbortController(), timer = setTimeout(() => controller.abort(), timeoutMs), onAbort = () => controller.abort();
+  signal?.addEventListener("abort", onAbort, { once: !0 });
+  try {
+    let response = await fetch(url, {
+      headers: { accept: "application/json" },
+      signal: controller.signal
+    });
+    return response.ok ? await response.json() : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer), signal?.removeEventListener("abort", onAbort);
+  }
+}
+async function fetchLocalModelIds(spec, timeoutMs, signal) {
+  let payload = await fetchJson(spec.modelsUrl, timeoutMs, signal);
+  if (payload !== null)
+    return extractModelIds(payload);
+  if (spec.tagsUrl) {
+    let fallback = await fetchJson(spec.tagsUrl, timeoutMs, signal);
+    if (fallback !== null)
+      return extractModelIds(fallback);
+  }
+  return null;
+}
+function toModelConfig(id) {
+  return {
+    id,
+    name: id,
+    reasoning: !1,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 32768,
+    maxTokens: 8192
+  };
+}
+
+// packages/coding-agent/dist/builtin-extensions/lunr-local-providers/index.js
+var LOGIN_PROBE_TIMEOUT_MS = 3e3, REFRESH_TIMEOUT_MS = 3e3, AUTO_SELECT_POLL_MS = 100, AUTO_SELECT_MAX_WAIT_MS = 5e3, NEVER_EXPIRES = 41024448e5;
+function isUnknownModel(model) {
+  return !!model && model.provider === "unknown" && model.id === "unknown" && model.api === "unknown";
+}
+function lunrLocalProviders(pi) {
+  let lastCtx;
+  pi.on("session_start", (_event, ctx) => {
+    lastCtx = ctx;
+  }), pi.on("model_select", (_event, ctx) => {
+    lastCtx = ctx;
+  });
+  for (let spec of LOCAL_SERVERS) {
+    let state = { spec, models: [], justLoggedIn: !1 }, scheduleAutoSelect = () => {
+      let started = Date.now(), timer = setInterval(() => {
+        let ctx = lastCtx;
+        if (!ctx) {
+          clearInterval(timer);
+          return;
+        }
+        let first = ctx.modelRegistry.getAvailable().find((model) => model.provider === spec.providerId);
+        if (!first) {
+          Date.now() - started > AUTO_SELECT_MAX_WAIT_MS && clearInterval(timer);
+          return;
+        }
+        clearInterval(timer);
+        let current = ctx.model;
+        current && !isUnknownModel(current) || pi.setModel(first);
+      }, AUTO_SELECT_POLL_MS);
+      timer.unref();
+    };
+    pi.registerProvider(spec.providerId, {
+      name: spec.displayName,
+      baseUrl: spec.baseUrl,
+      api: "openai-completions",
+      models: state.models,
+      refreshModels: async (context) => {
+        if (!context.allowNetwork) {
+          let stored = await context.store.read();
+          return stored?.models?.length && (state.models = stored.models.map((model) => toModelConfig(model.id))), state.models;
+        }
+        let ids = await fetchLocalModelIds(spec, REFRESH_TIMEOUT_MS, context.signal);
+        if (state.models = (ids ?? []).map(toModelConfig), state.models.length > 0)
+          try {
+            await context.store.write({
+              models: state.models.map((model) => ({
+                ...model,
+                api: "openai-completions",
+                provider: spec.providerId,
+                baseUrl: spec.baseUrl
+              })),
+              checkedAt: Date.now()
+            });
+          } catch {
+          }
+        return state.justLoggedIn && state.models.length > 0 && (state.justLoggedIn = !1, scheduleAutoSelect()), state.models;
+      },
+      oauth: {
+        name: spec.displayName,
+        login: async (callbacks) => {
+          callbacks.onProgress?.(`Looking for ${spec.productName} on localhost:${spec.port}...`);
+          let ids = await fetchLocalModelIds(spec, LOGIN_PROBE_TIMEOUT_MS, callbacks.signal);
+          if (ids === null)
+            throw new Error(`${spec.productName} not detected on localhost:${spec.port} \u2014 start it and retry.`);
+          if (ids.length === 0)
+            throw new Error(`${spec.productName} is running on localhost:${spec.port} but has no models. Load a model and retry.`);
+          return state.models = ids.map(toModelConfig), state.justLoggedIn = !0, { refresh: spec.dummyKey, access: spec.dummyKey, expires: NEVER_EXPIRES };
+        },
+        refreshToken: async (credentials) => credentials,
+        getApiKey: () => spec.dummyKey
+      }
+    });
+  }
+}
+
+// packages/coding-agent/dist/builtin-extensions/lunr-todos.js
+import { Text } from "@ashx-j/lunr-tui";
+var TODO_WIDGET_COLLAPSED_ROWS = 3, STATUS_GLYPHS = {
+  in_progress: "\u25CF",
+  pending: "\u25CB",
+  completed: "\u2713"
+};
+function summarizeTodos(todos) {
+  if (todos.length === 0)
+    return "No todos.";
+  let count = (s) => todos.filter((t) => t.status === s).length, parts = [], inProgress = count("in_progress"), pending = count("pending"), completed = count("completed");
+  return inProgress > 0 && parts.push(`${inProgress} in progress`), pending > 0 && parts.push(`${pending} pending`), completed > 0 && parts.push(`${completed} completed`), `${todos.length} todo${todos.length === 1 ? "" : "s"}: ${parts.join(", ")}`;
+}
+function buildTodoWidgetLines(todos, expanded, expandKey = "click") {
+  if (todos.length === 0)
+    return [];
+  let row = (t) => ({
+    kind: "todo",
+    status: t.status,
+    text: `${STATUS_GLYPHS[t.status]} ${t.content}`
+  }), active = [
+    ...todos.filter((t) => t.status === "in_progress"),
+    ...todos.filter((t) => t.status === "pending")
+  ], done = todos.filter((t) => t.status === "completed");
+  if (expanded)
+    return [...active.map(row), ...done.map(row)];
+  let lines = active.slice(0, TODO_WIDGET_COLLAPSED_ROWS).map(row), hidden = active.length - TODO_WIDGET_COLLAPSED_ROWS;
+  return hidden > 0 && lines.push({ kind: "hint", text: `+${hidden} more` }), lines;
+}
+var WIDGET_KEY = "todos", EXPANDED_BRIDGE_SYMBOL = /* @__PURE__ */ Symbol.for("@lunr/tools-expanded-changed");
+function lunr_todos_default(pi) {
+  let todos = [], expanded = !1, lastCtx = null;
+  function colorize(line, theme) {
+    return line.kind === "summary" || line.kind === "hint" ? theme.fg("muted", line.text) : line.status === "in_progress" ? theme.fg("accent", line.text) : line.status === "completed" ? theme.fg("dim", line.text) : line.text;
+  }
+  function refreshWidget() {
+    let ctx = lastCtx;
+    if (!ctx?.hasUI)
+      return;
+    let lines = buildTodoWidgetLines(todos, expanded, keyText("app.tools.expand"));
+    if (todos.length === 0 || lines.length === 0) {
+      ctx.ui.setWidget(WIDGET_KEY, void 0);
+      return;
+    }
+    ctx.ui.setWidget(WIDGET_KEY, (_tui, theme) => {
+      let text2 = new Text(lines.map((l) => colorize(l, theme)).join(`
+`), 1, 0);
+      return {
+        render: (width) => text2.render(width),
+        invalidate: () => text2.invalidate?.(),
+        handleClick: () => (expanded = !expanded, refreshWidget(), !0)
+      };
+    }, { placement: "aboveEditor" });
+  }
+  function pruneCompleted() {
+    let next = todos.filter((t) => t.status !== "completed");
+    next.length !== todos.length && (todos = next, refreshWidget());
+  }
+  function registerExpandedBridge() {
+    globalThis[EXPANDED_BRIDGE_SYMBOL] = (value) => {
+      expanded = !!value, refreshWidget();
+    };
+  }
+  registerExpandedBridge(), pi.on("session_start", (_event, ctx) => {
+    lastCtx = ctx, todos = [], expanded = ctx.hasUI ? ctx.ui.getToolsExpanded?.() ?? !1 : !1, registerExpandedBridge(), ctx.hasUI && ctx.ui.setWidget(WIDGET_KEY, void 0);
+  }), pi.on("message_start", (event, ctx) => {
+    event.message?.role === "user" && (lastCtx = ctx, pruneCompleted());
+  }), pi.on("session_shutdown", () => {
+    lastCtx?.hasUI && lastCtx.ui.setWidget(WIDGET_KEY, void 0), lastCtx = null, delete globalThis[EXPANDED_BRIDGE_SYMBOL];
+  }), pi.registerTool({
+    name: "todo",
+    label: "Todo",
+    description: [
+      "Manage the session todo list shown above the user's editor. Full-replace semantics:",
+      "every call must send the ENTIRE list; send an empty array to clear it.",
+      "Each item: { id, content, status: 'pending' | 'in_progress' | 'completed' }.",
+      "Use it to track multi-step work; keep exactly one item in_progress at a time."
+    ].join(`
+`),
+    parameters: typebox_exports.Object({
+      todos: typebox_exports.Array(typebox_exports.Object({
+        id: typebox_exports.String({ description: "Stable id for the item." }),
+        content: typebox_exports.String({ description: "Short description of the task." }),
+        status: typebox_exports.Union([
+          typebox_exports.Literal("pending"),
+          typebox_exports.Literal("in_progress"),
+          typebox_exports.Literal("completed")
+        ])
+      }))
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      let text2 = (t) => ({ content: [{ type: "text", text: t }] });
+      return todos = (Array.isArray(params?.todos) ? params.todos : []).filter((t) => t && typeof t.content == "string" && t.content.trim().length > 0).map((t, i) => ({
+        id: typeof t.id == "string" && t.id ? t.id : String(i + 1),
+        content: t.content.trim(),
+        status: t.status === "in_progress" || t.status === "completed" ? t.status : "pending"
+      })), lastCtx = ctx, refreshWidget(), text2(summarizeTodos(todos));
+    },
+    renderCall(args, theme) {
+      let n = Array.isArray(args?.todos) ? args.todos.length : 0, detail = n === 0 ? "clear" : `${n} item${n === 1 ? "" : "s"}`;
+      return new Text(theme.fg("toolTitle", theme.bold("todo ")) + theme.fg("dim", detail), 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text(theme.fg("warning", "Updating todos..."), 0, 0);
+      let first = result?.content?.[0], summary = first?.type === "text" ? first.text : "";
+      return new Text(theme.fg("dim", summary), 0, 0);
+    }
+  });
+}
+
+// packages/coding-agent/dist/builtin-extensions/lunr-plan-tools.js
+import { Text as Text2 } from "@ashx-j/lunr-tui";
+var PRESENT_PLAN_WRONG_MODE_TEXT = "present_plan is only available in plan mode.";
+async function runPresentPlan(summary) {
+  return isPlanModeActive() ? requestPlanApproval(summary) : PRESENT_PLAN_WRONG_MODE_TEXT;
+}
+function lunr_plan_tools_default(pi) {
+  pi.registerTool({
+    name: "present_plan",
+    label: "Plan",
+    description: [
+      "Present the finished plan for user approval. Only available in plan mode.",
+      "Call once with a concise, concrete summary of the plan; the user approves",
+      "or declines it in a dialog. The result text says whether to implement or revise."
+    ].join(`
+`),
+    parameters: typebox_exports.Object({
+      summary: typebox_exports.String({ description: "Concise summary of the plan to approve." })
+    }),
+    async execute(_toolCallId, params) {
+      let summary = typeof params?.summary == "string" ? params.summary.trim() : "";
+      return { content: [{ type: "text", text: await runPresentPlan(summary) }] };
+    },
+    renderCall(_args, theme) {
+      return new Text2(theme.fg("toolTitle", theme.bold("present_plan")), 0, 0);
+    },
+    renderResult(result, { isPartial }, theme) {
+      if (isPartial)
+        return new Text2(theme.fg("warning", "Presenting plan..."), 0, 0);
+      let first = result?.content?.[0], text2 = first?.type === "text" ? first.text : "";
+      return new Text2(theme.fg("dim", text2), 0, 0);
+    }
+  });
+}
+
+// packages/coding-agent/dist/builtin-extensions/lunr-skill-creator/index.js
+import { dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+var SKILLS_DIR = join3(dirname2(fileURLToPath(new URL("../builtin-extensions/lunr-skill-creator/index.js", import.meta.url).href)), "skills");
+function lunr_skill_creator_default(pi) {
+  pi.on("resources_discover", async () => ({ skillPaths: [SKILLS_DIR] }));
+}
+
+// packages/coding-agent/dist/builtin-extensions/lunr-settings-tools.js
+var SETTINGS_BRIDGE = /* @__PURE__ */ Symbol.for("@lunr/settings-tools"), MODEL_TIERS_BRIDGE = /* @__PURE__ */ Symbol.for("@lunr/model-tiers"), DETAILED_SETTINGS_TOOL_NAMES = [
+  "settings_model_tiers",
+  "settings_subscriptions",
+  "settings_rollback",
+  "settings_session_retention"
+];
+function settingsBridge() {
+  let bridge = globalThis[SETTINGS_BRIDGE];
+  if (!bridge)
+    throw new Error("Settings are unavailable in this runtime. Reload lunR and try again.");
+  return bridge;
+}
+function text(value, guidance) {
+  return {
+    content: [{ type: "text", text: `${JSON.stringify(value, null, 2)}
+
+${guidance}` }],
+    details: value
+  };
+}
+var thinking = typebox_exports.Union([
+  typebox_exports.Literal("off"),
+  typebox_exports.Literal("minimal"),
+  typebox_exports.Literal("low"),
+  typebox_exports.Literal("medium"),
+  typebox_exports.Literal("high"),
+  typebox_exports.Literal("xhigh"),
+  typebox_exports.Literal("max"),
+  typebox_exports.Null()
+], { description: "Per-tier thinking level. null inherits the parent session thinking level." });
+function lunrSettingsTools(pi) {
+  let loaded = !1, registerDetailedTools = () => {
+    loaded || (loaded = !0, pi.registerTool({
+      name: "settings_model_tiers",
+      label: "Model tiers",
+      description: "Read or partially update light, standard, and heavy subagent model routes and their thinking levels. Models use provider/model ids. Omitted fields are unchanged.",
+      parameters: typebox_exports.Object({
+        enabled: typebox_exports.Optional(typebox_exports.Boolean({ description: "Enable or disable tier-based child routing." })),
+        light: typebox_exports.Optional(typebox_exports.String({ minLength: 1, description: "Model route for light work." })),
+        standard: typebox_exports.Optional(typebox_exports.String({ minLength: 1, description: "Model route for standard work." })),
+        heavy: typebox_exports.Optional(typebox_exports.String({ minLength: 1, description: "Model route for heavy work." })),
+        lightThinking: typebox_exports.Optional(thinking),
+        standardThinking: typebox_exports.Optional(thinking),
+        heavyThinking: typebox_exports.Optional(thinking)
+      }, { additionalProperties: !1 }),
+      async execute(_id, params) {
+        let bridge = settingsBridge();
+        return Object.keys(params).length > 0 && (bridge.setModelTiers(params), globalThis[MODEL_TIERS_BRIDGE]?.refreshToolDescription?.()), text(bridge.getModelTiers(), Object.keys(params).length > 0 ? "Tier routes are saved and apply to the next child launch; the subagent schema guidance is refreshed now." : "Pass only the fields you want to change. Child launches still validate model availability and authentication.");
+      }
+    }), pi.registerTool({
+      name: "settings_subscriptions",
+      label: "Subscription management",
+      description: "Read or update automatic management of multiple stored provider subscriptions. Omit enabled to read without changing it.",
+      parameters: typebox_exports.Object({ enabled: typebox_exports.Optional(typebox_exports.Boolean()) }, { additionalProperties: !1 }),
+      async execute(_id, params) {
+        let bridge = settingsBridge();
+        return params.enabled !== void 0 && bridge.setAutoManageSubscriptions(params.enabled), text({ enabled: bridge.getAutoManageSubscriptions() }, params.enabled === void 0 ? "Set enabled to change automatic subscription selection." : "The setting is saved and applies to subsequent provider requests.");
+      }
+    }), pi.registerTool({
+      name: "settings_rollback",
+      label: "Rollback",
+      description: "Read or partially update rollback behavior: enabled, retained turns, capture strategy, and scope. Omitted fields are unchanged. Auto permission mode force-enables rollback for its current session.",
+      parameters: typebox_exports.Object({
+        enabled: typebox_exports.Optional(typebox_exports.Boolean()),
+        turns: typebox_exports.Optional(typebox_exports.Integer({ minimum: 1, maximum: 20 })),
+        capture: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("copies"), typebox_exports.Literal("shadow-git"), typebox_exports.Literal("hybrid")])),
+        scope: typebox_exports.Optional(typebox_exports.Union([typebox_exports.Literal("tools"), typebox_exports.Literal("tree")]))
+      }, { additionalProperties: !1 }),
+      async execute(_id, params) {
+        let bridge = settingsBridge();
+        Object.keys(params).length > 0 && bridge.setRollback(params);
+        let current = bridge.getRollback();
+        return text(current, current.forcedByAuto ? "Saved settings apply normally, but rollback remains force-enabled for this Auto-mode session." : Object.keys(params).length > 0 ? "Rollback settings are saved and live for subsequent tool calls." : "Pass only the fields you want to change.");
+      }
+    }), pi.registerTool({
+      name: "settings_session_retention",
+      label: "Session retention",
+      description: "Read or update how many days saved sessions are retained. Set days to 0 to keep sessions forever. Cleanup applies on a later launch, not retroactively in this turn.",
+      parameters: typebox_exports.Object({ days: typebox_exports.Optional(typebox_exports.Integer({ minimum: 0, maximum: 36500 })) }, { additionalProperties: !1 }),
+      async execute(_id, params) {
+        let bridge = settingsBridge();
+        return params.days !== void 0 && bridge.setSessionRetentionDays(params.days), text({ days: bridge.getSessionRetentionDays() }, params.days === void 0 ? "Set days to change retention; 0 keeps sessions forever." : "The setting is saved. Session cleanup uses it on a later launch.");
+      }
+    }));
+  };
+  pi.registerTool({
+    name: "settings_load",
+    label: "Settings",
+    description: "Load four narrow agent-managed settings tools for model tiers, subscription management, rollback, and session retention. Call only when the task requires inspecting or changing those settings.",
+    promptSnippet: "Load narrow settings controls on demand",
+    promptGuidelines: ["Call settings_load only when the user asks to inspect or change model tiers, subscription management, rollback, or session retention."],
+    parameters: typebox_exports.Object({}, { additionalProperties: !1 }),
+    async execute() {
+      let alreadyLoaded = loaded;
+      return registerDetailedTools(), pi.setActiveTools([.../* @__PURE__ */ new Set([...pi.getActiveTools(), ...DETAILED_SETTINGS_TOOL_NAMES])]), text({ activated: [...DETAILED_SETTINGS_TOOL_NAMES], alreadyLoaded }, "The four tools are active for the next model step and remain active in this runtime. A new runtime starts with only settings_load visible.");
+    }
+  });
+}
+
+// packages/coding-agent/dist/builtin-extensions/index.js
+function ext(name, factory) {
+  return { name, factory };
+}
+var lightBuiltinExtensions = [
+  ext("simple-pi-memory", simple_pi_memory_default),
+  ext("pi-tps", pi_tps_default),
+  ext("ashxj-tui", ashxj_tui_default),
+  ext("ashxj-spinners", ashxj_spinners_default),
+  ext("ashxj-thinking", ashxj_thinking_default),
+  ext("lunr-local-providers", lunrLocalProviders),
+  ext("lunr-todos", lunr_todos_default),
+  ext("lunr-plan-tools", lunr_plan_tools_default),
+  ext("lunr-skill-creator", lunr_skill_creator_default),
+  ext("lunr-settings-tools", lunrSettingsTools)
+], DEFERRED_BUILTIN_LOADERS = [
+  { name: "pi-ollama-cloud", load: () => import("./pi-ollama-cloud-4VZRMULP.js") },
+  { name: "narumiruna-pi-goal", load: () => import("./goal-CZQ7FFQJ.js") },
+  { name: "lunr-cron", load: () => import("./lunr-cron-YJ5UHYRD.js") },
+  { name: "pi-intercom", load: () => import("./pi-intercom-EEMBGQID.js") },
+  { name: "pi-prompt-template-model", load: () => import("./pi-prompt-template-model-4QT4LLXF.js") },
+  { name: "pi-subagents", load: () => import("./pi-subagents-7XJ4H53P.js") },
+  { name: "pi-web-access", load: () => import("./pi-web-access-DPGAVKOA.js") },
+  { name: "pi-lsp-extension", load: () => import("./src-Y7JSCK64.js") },
+  { name: "pi-mcp-adapter", load: () => import("./pi-mcp-adapter-QFB37AVN.js") }
+], DEFERRED_BUILTIN_EXTENSION_NAMES = DEFERRED_BUILTIN_LOADERS.map((entry) => entry.name), DEFERRED_BUILTIN_FLAGS = ["mcp-config"];
+async function loadDeferredBuiltinExtensions() {
+  return await Promise.all(DEFERRED_BUILTIN_LOADERS.map(async ({ name, load }) => {
+    let module = await measureStartup(name, load, "imports");
+    return ext(name, module.default);
+  }));
+}
+async function loadAllBuiltinExtensions() {
+  return [...lightBuiltinExtensions, ...await loadDeferredBuiltinExtensions()];
+}
+var builtinExtensions = lightBuiltinExtensions;
+
+export {
+  lightBuiltinExtensions,
+  DEFERRED_BUILTIN_EXTENSION_NAMES,
+  DEFERRED_BUILTIN_FLAGS,
+  loadDeferredBuiltinExtensions,
+  loadAllBuiltinExtensions,
+  builtinExtensions
+};