lazyclaw 5.4.3 → 6.0.0

package/scripts/loop-worker.mjs

@@ -85,7 +85,13 @@ const max = Number(args.max) || loopEngine.LOOP_MAX_DEFAULT;
 loops.patchMeta(loopId, { status: 'running', startedAt: new Date().toISOString() }, cfgDir);
 
 const ac = new AbortController();
+// When a signal arrives, onTerm writes the authoritative 'killed' result and
+// owns the exit. `terminating` stops the normal-completion path (which the
+// aborted runLoop returns into within the same ~50ms window) from racing a
+// second writeResult onto the same file.
+let terminating = false;
 function onTerm(sig) {
+  terminating = true;
   ac.abort();
   loops.patchMeta(loopId, { status: 'killed', finishedAt: new Date().toISOString(), signal: sig }, cfgDir);
   loops.writeResult(loopId, { stoppedBy: 'kill', signal: sig }, cfgDir);
@@ -149,12 +155,17 @@ try {
     onIteration,
     signal: ac.signal,
   });
-  const finalStatus = result.stoppedBy === 'abort' ? 'killed' : 'completed';
-  loops.patchMeta(loopId, { status: finalStatus, finishedAt: new Date().toISOString() }, cfgDir);
-  loops.writeResult(loopId, result, cfgDir);
-  process.exit(0);
+  if (!terminating) {
+    const finalStatus = result.stoppedBy === 'abort' ? 'killed' : 'completed';
+    loops.patchMeta(loopId, { status: finalStatus, finishedAt: new Date().toISOString() }, cfgDir);
+    loops.writeResult(loopId, result, cfgDir);
+    process.exit(0);
+  }
+  // else: a signal is terminating us — onTerm wrote the result and owns exit.
 } catch (err) {
-  loops.patchMeta(loopId, { status: 'failed', finishedAt: new Date().toISOString() }, cfgDir);
-  loops.writeResult(loopId, { error: err?.message || String(err), stack: err?.stack }, cfgDir);
-  process.exit(1);
+  if (!terminating) {
+    loops.patchMeta(loopId, { status: 'failed', finishedAt: new Date().toISOString() }, cfgDir);
+    loops.writeResult(loopId, { error: err?.message || String(err), stack: err?.stack }, cfgDir);
+    process.exit(1);
+  }
 }

package/scripts/migrate-v5.mjs

@@ -20,7 +20,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { openIndex, rebuild, indexSessionTurn, indexSkill, indexMemory } from '../mas/index_db.mjs';
+import { reindexAll } from '../mas/index_db.mjs';
 import { parseFrontmatter } from '../skills.mjs';
 
 function defaultConfigDir() {
@@ -96,67 +96,11 @@ function upgradeAllSkills(configDir) {
   return { upgraded: n };
 }
 
+// Rebuild + repopulate the FTS index. The walk now lives in index_db.reindexAll
+// (shared with the daemon POST /index/rebuild route) so a "rebuild" is always a
+// repopulate, never a silent zeroing.
 function rebuildIndex(configDir) {
-  rebuild(configDir);
-  openIndex(configDir);
-
-  // Sessions.
-  const sessDir = path.join(configDir, 'sessions');
-  if (fs.existsSync(sessDir)) {
-    for (const f of fs.readdirSync(sessDir)) {
-      if (!f.endsWith('.jsonl')) continue;
-      const id = f.slice(0, -'.jsonl'.length);
-      const raw = fs.readFileSync(path.join(sessDir, f), 'utf8');
-      let idx = 0;
-      for (const line of raw.split('\n')) {
-        if (!line) continue;
-        try {
-          const obj = JSON.parse(line);
-          indexSessionTurn({
-            session_id: id, turn_idx: idx++, role: obj.role || 'user',
-            ts: obj.ts || 0, content: obj.content || '',
-          }, configDir);
-        } catch { /* skip malformed */ }
-      }
-    }
-  }
-
-  // Skills.
-  const skillsDir = path.join(configDir, 'skills');
-  if (fs.existsSync(skillsDir)) {
-    for (const f of fs.readdirSync(skillsDir)) {
-      if (!f.endsWith('.md')) continue;
-      const name = f.slice(0, -'.md'.length);
-      const raw = fs.readFileSync(path.join(skillsDir, f), 'utf8');
-      const { meta, body } = parseFrontmatter(raw);
-      indexSkill({
-        skill_name: name,
-        trained_by: meta.trained_by || 'legacy',
-        group_name: meta.group || (name.includes('-') ? name.split('-')[0] : 'legacy'),
-        content: body,
-      }, configDir);
-    }
-  }
-
-  // Memory (core + episodic).
-  const memDir = path.join(configDir, 'memory');
-  if (fs.existsSync(memDir)) {
-    const corePath = path.join(memDir, 'core.md');
-    if (fs.existsSync(corePath)) {
-      indexMemory({ topic: 'core', kind: 'core',
-        content: fs.readFileSync(corePath, 'utf8') }, configDir);
-    }
-    const epi = path.join(memDir, 'episodic');
-    if (fs.existsSync(epi)) {
-      for (const f of fs.readdirSync(epi)) {
-        if (!f.endsWith('.md')) continue;
-        indexMemory({
-          topic: f.slice(0, -'.md'.length), kind: 'episodic',
-          content: fs.readFileSync(path.join(epi, f), 'utf8'),
-        }, configDir);
-      }
-    }
-  }
+  reindexAll(configDir);
 }
 
 export async function migrateV5(opts = {}) {

package/tui/editor.mjs

@@ -50,6 +50,48 @@ export function displayWidth(text) {
   return stringWidth(String(text));
 }
 
+// ─── IME cursor anchor (v5.4.4) ─────────────────────────────────────
+//
+// v5.4.3 shipped an anchor that moved the cursor inside the editor
+// after every render so IME pre-edit composition appeared in the
+// editor box. It also caused visible flicker because Ink's log-update
+// (node_modules/ink/build/log-update.js) emits an eraseLines sequence
+// (`\x1b[2K\x1b[1A...`) on every redraw — and that sequence walks UP
+// from the CURRENT cursor position. With our anchor up inside the
+// editor, eraseLines erased rows ABOVE the frame, then wrote the new
+// frame starting one editor-height higher than the previous one.
+//
+// v5.4.4 fix — monkey-patch process.stdout.write the first time the
+// anchor fires. When the patched writer sees a chunk that BEGINS with
+// `\x1b[2K` (the start of log-update's eraseLines) AND the anchor
+// offset is non-zero, it prepends `\x1b[<offset>B\r` to move the
+// cursor BACK DOWN to the row log-update expects (one below the
+// previous frame's last line). The user sees no flicker; IME still
+// reads the editor cursor position because the anchor lives across
+// the gap between renders.
+const _anchorState = { offset: 0, shimmed: false };
+
+function _installAnchorShim() {
+  if (_anchorState.shimmed) return;
+  if (!(process.stdout && typeof process.stdout.write === 'function')) return;
+  const orig = process.stdout.write.bind(process.stdout);
+  process.stdout.write = function patchedWrite(chunk, ...rest) {
+    try {
+      if (
+        _anchorState.offset > 0 &&
+        typeof chunk === 'string' &&
+        chunk.startsWith('\x1b[2K')
+      ) {
+        const off = _anchorState.offset;
+        _anchorState.offset = 0;
+        return orig.call(this, `\x1b[${off}B\r` + chunk, ...rest);
+      }
+    } catch { /* fall through to unmodified write */ }
+    return orig.call(this, chunk, ...rest);
+  };
+  _anchorState.shimmed = true;
+}
+
 // Cell-aware soft-wrap. Returns an array of visual rows whose width
 // respects the budget (first row uses `firstBudget`, subsequent rows
 // use `contBudget`). Hoisted to module level (was inner-fn) so the
@@ -359,6 +401,8 @@ export function Editor({
     // starts at col 3. Cursor sits one cell past the typed content.
     const prefixWidth = rowInEditor === 0 ? PROMPT_WIDTH : CONTINUATION_WIDTH;
     const colTarget = 3 + prefixWidth + colInLine;
+    _installAnchorShim();
+    _anchorState.offset = rowsUp;
     try {
       process.stdout.write(`\x1b[${rowsUp}A\x1b[${colTarget}G\x1b[?25h`);
     } catch { /* stdout closed — swallow */ }

package/tui/modal_filter.mjs

@@ -0,0 +1,59 @@
+// tui/modal_filter.mjs — pure (react-free) primitives for the Ink modal
+// picker. Split out from modal_picker.mjs so the filtering / windowing /
+// pick-resolution logic is unit-testable without pulling in react + ink
+// (which are only present in the running TUI). modal_picker.mjs re-exports
+// these for back-compat.
+
+// Pure filter — prefix > substring > subsequence. Stable order within each
+// tier (original list order is the tiebreaker).
+//
+// `pinned` rows bypass the filter entirely and are always appended after
+// the matches. This keeps sentinel rows (e.g. "↻ fetch live models",
+// "… type a custom model id") on screen while the user types an id that
+// matches no listed model — the typed filter doubles as the custom-id
+// buffer for the free-text row.
+export function filterModalItems(query, items) {
+  const q = String(query || '').trim().toLowerCase();
+  const list = Array.isArray(items) ? items : [];
+  if (!q) return list.slice();
+  const prefix = [], substr = [], subseq = [], pinned = [];
+  for (const it of list) {
+    if (it && it.pinned) { pinned.push(it); continue; }
+    const hay = `${it.label || it.id || ''} ${it.desc || ''}`.toLowerCase();
+    if (hay.startsWith(q)) prefix.push(it);
+    else if (hay.includes(q)) substr.push(it);
+    else if (_isSubseq(q, hay)) subseq.push(it);
+  }
+  return [...prefix, ...substr, ...subseq, ...pinned];
+}
+
+function _isSubseq(needle, hay) {
+  let i = 0;
+  for (const ch of hay) {
+    if (ch === needle[i]) i++;
+    if (i === needle.length) return true;
+  }
+  return false;
+}
+
+// Pure window computation — slide a window of `maxRows` items so that
+// `selectedIndex` is always visible. Mirrors the pattern in
+// tui/slash_popup.mjs._computeWindow.
+export function _computeWindow(idx, total, maxRows) {
+  const n = Math.max(0, total);
+  const m = Math.max(1, maxRows);
+  if (n <= m) return { start: 0, end: n };
+  let start = Math.max(0, Math.min(n - m, idx - Math.floor(m / 2)));
+  return { start, end: start + m };
+}
+
+// Pure pick resolver — maps the highlighted row + current filter buffer to
+// what openPicker resolves with. A `freeText` row resolves to
+// `{ id, query }` so the caller can use the typed filter as a custom value
+// (e.g. an unlisted model id); every other row resolves to its plain id.
+// No selection resolves to null (caller treats as cancel).
+export function resolveModalPick(pickedItem, query) {
+  if (!pickedItem) return null;
+  if (pickedItem.freeText) return { id: pickedItem.id, query: String(query || '') };
+  return pickedItem.id;
+}

package/tui/modal_picker.mjs

@@ -15,44 +15,14 @@ import React from 'react';
 import { Box, Text } from 'ink';
 import stringWidth from 'string-width';
 import { theme } from './theme.mjs';
+// Pure (react-free) primitives live in modal_filter.mjs so they can be unit
+// tested without the Ink runtime. Re-exported here for back-compat with
+// existing importers (tui/repl.mjs).
+import { filterModalItems, _computeWindow, resolveModalPick } from './modal_filter.mjs';
 
-const DEFAULT_MAX_ROWS = 12;
-
-// Pure filter — prefix > substring > subsequence. Stable order within
-// each tier (original list order is the tiebreaker).
-export function filterModalItems(query, items) {
-  const q = String(query || '').trim().toLowerCase();
-  const list = Array.isArray(items) ? items : [];
-  if (!q) return list.slice();
-  const prefix = [], substr = [], subseq = [];
-  for (const it of list) {
-    const hay = `${it.label || it.id || ''} ${it.desc || ''}`.toLowerCase();
-    if (hay.startsWith(q)) prefix.push(it);
-    else if (hay.includes(q)) substr.push(it);
-    else if (_isSubseq(q, hay)) subseq.push(it);
-  }
-  return [...prefix, ...substr, ...subseq];
-}
+export { filterModalItems, _computeWindow, resolveModalPick };
 
-function _isSubseq(needle, hay) {
-  let i = 0;
-  for (const ch of hay) {
-    if (ch === needle[i]) i++;
-    if (i === needle.length) return true;
-  }
-  return false;
-}
-
-// Pure window computation — slide a window of `maxRows` items so that
-// `selectedIndex` is always visible. Mirrors the pattern in
-// tui/slash_popup.mjs._computeWindow.
-export function _computeWindow(idx, total, maxRows) {
-  const n = Math.max(0, total);
-  const m = Math.max(1, maxRows);
-  if (n <= m) return { start: 0, end: n };
-  let start = Math.max(0, Math.min(n - m, idx - Math.floor(m / 2)));
-  return { start, end: start + m };
-}
+const DEFAULT_MAX_ROWS = 12;
 
 // Presentational component.
 //
@@ -126,11 +96,16 @@ export function ModalPicker({
       const marker = selected ? '❯ ' : '  ';
       const label = String(it.label || it.id || '').padEnd(labelW);
       const desc = it.desc ? `  ${it.desc}` : '';
-      // Render selected row inverse-bold for contrast.
+      // Render selected row inverse-bold for contrast. A row `tag` (e.g.
+      // "api key" / "no key" / "custom") renders as a dim trailing pill so
+      // the picker signals at a glance which providers need a key.
       rows.push(React.createElement(
         Text,
         { key: `it-${absoluteIdx}`, bold: selected, inverse: selected },
         `${marker}${label}${desc}`,
+        it.tag
+          ? React.createElement(Text, { key: 'tag', dimColor: true }, `  [${it.tag}]`)
+          : null,
       ));
     }
     if (end < total) {