quilltap 4.5.1 → 4.6.0-dev.105

package/bin/quilltap.js

@@ -13,6 +13,7 @@ const {
   loadDbKey,
 } = require('../lib/db-helpers');
 const { resolveInstance } = require('../lib/instances');
+const { resolveModuleDir, ensureNativeModules } = require('../lib/native-modules');
 
 const PACKAGE_DIR = path.resolve(__dirname, '..');
 
@@ -137,85 +138,6 @@ function openBrowser(url) {
   });
 }
 
-// Resolve a native module's directory, handling npm hoisting.
-// Returns the directory containing package.json, or null if not found.
-function resolveModuleDir(moduleName) {
-  try {
-    const pkgJson = require.resolve(moduleName + '/package.json');
-    return path.dirname(pkgJson);
-  } catch {
-    return null;
-  }
-}
-
-// Check if native modules are compiled for the current Node.js version.
-// This handles the case where npx caches the package but the user upgrades
-// Node.js — the cached native modules will have a stale NODE_MODULE_VERSION.
-function ensureNativeModules() {
-  const needsRebuild = [];
-
-  // Check better-sqlite3-multiple-ciphers (provides SQLCipher encryption support).
-  // The main app depends on this via an npm alias as 'better-sqlite3', so we must
-  // ensure the SQLCipher-capable version is available and link it as 'better-sqlite3'.
-  // We must load the native binding directly to detect NODE_MODULE_VERSION mismatches.
-  try {
-    const modDir = resolveModuleDir('better-sqlite3-multiple-ciphers')
-                || resolveModuleDir('better-sqlite3');
-    if (!modDir) throw Object.assign(new Error('not found'), { code: 'MODULE_NOT_FOUND' });
-    const bindingsPath = path.join(modDir, 'build', 'Release', 'better_sqlite3.node');
-    require(bindingsPath);
-  } catch (err) {
-    if (err.message && err.message.includes('NODE_MODULE_VERSION')) {
-      needsRebuild.push('better-sqlite3-multiple-ciphers');
-    } else if (err.code === 'MODULE_NOT_FOUND') {
-      needsRebuild.push('better-sqlite3-multiple-ciphers');
-    }
-  }
-
-  // Check sharp: loads its native binding eagerly on require, but we use
-  // the same explicit-path approach for consistency and reliability.
-  try {
-    require('sharp');
-  } catch (err) {
-    if (err.message && err.message.includes('NODE_MODULE_VERSION')) {
-      needsRebuild.push('sharp');
-    } else if (err.code === 'MODULE_NOT_FOUND') {
-      needsRebuild.push('sharp');
-    }
-  }
-
-  // Check node-pty: backs the Ariel terminal feature. Loaded dynamically by
-  // pty-manager in the standalone server, so resolution must succeed and the
-  // native binding's NODE_MODULE_VERSION must match the runtime.
-  try {
-    require('node-pty');
-  } catch (err) {
-    if (err.message && err.message.includes('NODE_MODULE_VERSION')) {
-      needsRebuild.push('node-pty');
-    } else if (err.code === 'MODULE_NOT_FOUND') {
-      needsRebuild.push('node-pty');
-    }
-  }
-
-  if (needsRebuild.length === 0) return;
-
-  console.log(`  Rebuilding native modules for Node.js ${process.version}...`);
-
-  try {
-    execSync(`npm rebuild ${needsRebuild.join(' ')}`, {
-      cwd: PACKAGE_DIR,
-      stdio: 'inherit',
-    });
-    console.log('  Done.');
-    console.log('');
-  } catch (err) {
-    console.error('');
-    console.error(`  Warning: Failed to rebuild native modules: ${err.message}`);
-    console.error('  Try running: npm rebuild --prefix ' + PACKAGE_DIR);
-    console.error('');
-  }
-}
-
 // Symlink native modules into the standalone directory's node_modules
 // so that standard Node.js resolution finds them without relying on NODE_PATH.
 function linkNativeModules(standaloneDir) {
@@ -266,25 +188,67 @@ function linkNativeModules(standaloneDir) {
                         || resolveModuleDir('better-sqlite3');
   linkModule('better-sqlite3', betterSqlite3Dir);
 
-  // Link node-pty — the standalone tarball strips it (platform-specific),
-  // and pty-manager loads it via a dynamic require, so it needs to resolve
-  // from standaloneDir/node_modules.
-  const nodePtyDir = resolveModuleDir('node-pty');
-  linkModule('node-pty', nodePtyDir);
-  if (nodePtyDir) {
-    // Some npm cache extractions strip the executable bit on spawn-helper,
-    // causing pty.spawn() to fail with `posix_spawnp failed`. Restore it.
-    const prebuildsDir = path.join(nodePtyDir, 'prebuilds');
-    if (fs.existsSync(prebuildsDir)) {
-      try {
-        for (const entry of fs.readdirSync(prebuildsDir, { withFileTypes: true })) {
-          if (!entry.isDirectory()) continue;
-          const helper = path.join(prebuildsDir, entry.name, 'spawn-helper');
-          if (fs.existsSync(helper)) {
-            try { fs.chmodSync(helper, 0o755); } catch { /* best-effort */ }
+  // Link node-pty — but only when we have to. The standalone tarball ships
+  // node-pty intact with cross-platform prebuilds (darwin-arm64, darwin-x64,
+  // win32-arm64, win32-x64). On those platforms the tarball-shipped copy is
+  // already correct, and we MUST NOT replace it with a symlink to the
+  // npm-installed copy: `sudo npm install -g quilltap` on macOS can strip the
+  // executable bit off `spawn-helper`, and we can't chmod a root-owned file
+  // back as a non-root runtime user — pty.spawn() then fails with
+  // `posix_spawnp failed`. Only Linux (which has no node-pty prebuild) and
+  // rebuild-failure cases need the symlink.
+  const standaloneNodePtyPath = path.join(standaloneNodeModules, 'node-pty');
+  const standaloneHasUsablePty = (() => {
+    try {
+      const stat = fs.lstatSync(standaloneNodePtyPath);
+      if (stat.isSymbolicLink()) return false; // prior broken-symlink state — replace it
+      if (!stat.isDirectory()) return false;
+    } catch {
+      return false;
+    }
+    const platformPrebuildDir = path.join(
+      standaloneNodePtyPath,
+      'prebuilds',
+      `${process.platform}-${process.arch}`,
+    );
+    return fs.existsSync(platformPrebuildDir);
+  })();
+
+  if (!standaloneHasUsablePty) {
+    const nodePtyDir = resolveModuleDir('node-pty');
+    linkModule('node-pty', nodePtyDir);
+    if (nodePtyDir) {
+      // Some npm cache extractions (notably `sudo npm install -g`) strip the
+      // executable bit on spawn-helper. Restore it where we can. If chmod
+      // fails because we don't own the file (typical when the CLI was
+      // installed with sudo and is run as a non-root user), warn loudly —
+      // silent failure here produces the `posix_spawnp failed` runtime error
+      // with no actionable hint.
+      const prebuildsDir = path.join(nodePtyDir, 'prebuilds');
+      if (fs.existsSync(prebuildsDir)) {
+        try {
+          for (const entry of fs.readdirSync(prebuildsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory()) continue;
+            const helper = path.join(prebuildsDir, entry.name, 'spawn-helper');
+            if (!fs.existsSync(helper)) continue;
+            try {
+              fs.chmodSync(helper, 0o755);
+            } catch (err) {
+              if (err && err.code === 'EPERM') {
+                console.error('');
+                console.error(`  Warning: Could not make node-pty spawn-helper executable:`);
+                console.error(`    ${helper}`);
+                console.error(`  The file is owned by another user (likely root from a sudo'd`);
+                console.error(`  global install). Terminal sessions will fail to spawn with`);
+                console.error(`  "posix_spawnp failed" until this is fixed. Run:`);
+                console.error(`    sudo chmod 755 "${helper}"`);
+                console.error('');
+              }
+              // Other errors are non-fatal — node-pty may still work if the bit was already set.
+            }
           }
-        }
-      } catch { /* best-effort */ }
+        } catch { /* best-effort */ }
+      }
     }
   }
 
@@ -740,6 +704,11 @@ Subcommands (high-level shortcuts; auto-pick the right database):
   log <id>                    Full request/response of a single LLM log
   memories --character <id>   Memories held by a character
                               (flags: --about <id|name> --source AUTO|MANUAL)
+  characters status           Per-character vault readiness report:
+                              flag value, vault present, single-file count,
+                              Prompts/ and Scenarios/ folder counts, and any
+                              divergence between DB columns and vault content.
+                              (flags: --id <id|name> --diverged --blocked --limit N)
   optimize [target...]        Run maintenance (VACUUM + ANALYZE + PRAGMA optimize)
                               on the named databases, or all of them if no
                               target is given. Targets: main, llm-logs,
@@ -762,6 +731,8 @@ Low-level options (legacy; still supported):
   --tables              List all tables in the active database
   --count <table>       Show row count for a table
   --repl                Interactive SQL prompt (extras: .cols, .find)
+  --json                Emit machine-readable JSON instead of a table
+                        (works with --tables, --count, and raw SQL)
   --llm-logs            Target the LLM logs database
   --mount-points        Target the document mount-index database
   --data-dir <path>     Override data directory (pass instance root)
@@ -869,6 +840,7 @@ async function dbCommand(args) {
   let lockStatus = false;
   let lockClean = false;
   let lockOverride = false;
+  let asJson = false;
 
   let i = 0;
   while (i < cleaned.length) {
@@ -878,6 +850,7 @@ async function dbCommand(args) {
       case '--tables': showTables = true; break;
       case '--count': countTable = cleaned[++i]; break;
       case '--repl': repl = true; break;
+      case '--json': asJson = true; break;
       case '--help': case '-h': showHelp = true; break;
       case '--lock-status': lockStatus = true; break;
       case '--lock-clean': lockClean = true; break;
@@ -971,22 +944,27 @@ async function dbCommand(args) {
   try {
     if (showTables) {
       const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all();
-      for (const t of tables) console.log(t.name);
+      if (asJson) console.log(JSON.stringify(tables.map(t => t.name), null, 2));
+      else for (const t of tables) console.log(t.name);
     } else if (countTable) {
       const row = db.prepare(`SELECT count(*) as count FROM "${countTable}"`).get();
-      console.log(row.count);
+      if (asJson) console.log(JSON.stringify({ table: countTable, count: row.count }, null, 2));
+      else console.log(row.count);
     } else if (sql) {
       const stmt = db.prepare(sql);
       if (stmt.reader) {
         const rows = stmt.all();
-        if (rows.length === 0) {
+        if (asJson) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
           console.log('(no results)');
         } else {
           console.table(rows);
         }
       } else {
         const info = stmt.run();
-        console.log(`Changes: ${info.changes}`);
+        if (asJson) console.log(JSON.stringify({ changes: info.changes, lastInsertRowid: Number(info.lastInsertRowid) }, null, 2));
+        else console.log(`Changes: ${info.changes}`);
       }
     } else if (repl) {
       const readline = require('readline');

package/lib/db-commands.js

@@ -10,6 +10,8 @@ const {
   UUID_RE,
   ambiguous,
   resolveCharacter,
+  resolveCharactersByAlias,
+  readVaultAliases,
   resolveChat,
   resolveProject,
 } = require('./db-helpers');
@@ -318,21 +320,56 @@ function cmdFind(args, ctx) {
 }
 
 function findCharacters(query, { json, limit, ctx }) {
+  // Aliases live in each character's vault `properties.json` post-4.6, not on
+  // the `characters` row, so name matching comes from the main DB and alias
+  // matching/display comes from the mount-index DB.
   const db = ctx.openMain();
+  let mounts = null;
   try {
+    mounts = ctx.openMounts();
+  } catch {
+    mounts = null; // mount-index DB absent — name-only matching, no aliases
+  }
+  try {
+    const SELECT_COLS =
+      'SELECT id, name, npc, isFavorite, controlledBy, characterDocumentMountPointId AS mp FROM characters';
     let rows;
     if (!query) {
-      rows = db.prepare('SELECT id, name, npc, isFavorite, controlledBy FROM characters ORDER BY name LIMIT ?').all(limit);
+      rows = db.prepare(`${SELECT_COLS} ORDER BY name LIMIT ?`).all(limit);
     } else if (UUID_RE.test(query)) {
-      rows = db.prepare('SELECT id, name, npc, isFavorite, controlledBy, aliases FROM characters WHERE id = ?').all(query);
+      rows = db.prepare(`${SELECT_COLS} WHERE id = ?`).all(query);
     } else {
-      rows = db.prepare(
-        'SELECT id, name, npc, isFavorite, controlledBy, aliases FROM characters WHERE LOWER(name) LIKE LOWER(?) OR LOWER(aliases) LIKE LOWER(?) ORDER BY name LIMIT ?'
-      ).all(`%${query}%`, `%${query}%`, limit);
+      const byName = db
+        .prepare(`${SELECT_COLS} WHERE LOWER(name) LIKE LOWER(?) ORDER BY name`)
+        .all(`%${query}%`);
+      const seen = new Set(byName.map((r) => r.id));
+      rows = [...byName];
+      // Fold in alias matches from the vault, then re-fetch their rows so the
+      // output columns stay uniform.
+      for (const m of resolveCharactersByAlias(db, mounts, query)) {
+        if (seen.has(m.id)) continue;
+        seen.add(m.id);
+        const r = db.prepare(`${SELECT_COLS} WHERE id = ?`).get(m.id);
+        if (r) rows.push(r);
+      }
+      rows = rows.slice(0, limit);
     }
-    if (json) return printJson(rows);
-    printTable(rows);
+
+    // Attach vault-sourced aliases for display and drop the internal mount id.
+    const enriched = rows.map(({ mp, ...rest }) => ({
+      ...rest,
+      aliases: readVaultAliases(mounts, mp),
+    }));
+
+    if (json) return printJson(enriched);
+    printTable(
+      enriched.map((r) => ({
+        ...r,
+        aliases: r.aliases.length ? r.aliases.join(', ') : '',
+      })),
+    );
   } finally {
+    if (mounts) { try { mounts.close(); } catch {} }
     db.close();
   }
 }
@@ -388,7 +425,7 @@ function cmdChats(args, ctx) {
   try {
     let rows;
     if (flags.character) {
-      const c = resolveCharacter(db, String(flags.character));
+      const c = resolveCharacter(db, String(flags.character), ctx.openMounts);
       rows = db.prepare(
         "SELECT id, title, chatType, messageCount, lastMessageAt, projectId " +
         "FROM chats WHERE participants LIKE ? ORDER BY lastMessageAt DESC LIMIT ?"
@@ -488,7 +525,7 @@ function cmdLogs(args, ctx) {
     } else if (flags.character) {
       const main = ctx.openMain();
       let c;
-      try { c = resolveCharacter(main, String(flags.character)); } finally { main.close(); }
+      try { c = resolveCharacter(main, String(flags.character), ctx.openMounts); } finally { main.close(); }
       rows = logsDb.prepare(
         'SELECT id, createdAt, type, provider, modelName, chatId, messageId, durationMs FROM llm_logs WHERE characterId = ? ORDER BY createdAt DESC LIMIT ?'
       ).all(c.id, limit);
@@ -561,6 +598,12 @@ function cmdLog(args, ctx) {
     if (!row) throw new Error(`No llm_log with id ${id}`);
     if (json) return printJson(row);
 
+    let finishReason = null;
+    try {
+      const parsed = typeof row.response === 'string' ? JSON.parse(row.response) : row.response;
+      if (parsed && typeof parsed.finishReason === 'string') finishReason = parsed.finishReason;
+    } catch { /* leave null */ }
+
     printRecord(`LLM log ${row.id}`, {
       createdAt: row.createdAt,
       type: row.type,
@@ -570,6 +613,7 @@ function cmdLog(args, ctx) {
       messageId: row.messageId,
       characterId: row.characterId,
       durationMs: row.durationMs,
+      finishReason,
       usage: row.usage,
       cacheUsage: row.cacheUsage,
     });
@@ -598,11 +642,11 @@ function cmdMemories(args, ctx) {
 
   const db = ctx.openMain();
   try {
-    const holder = resolveCharacter(db, String(flags.character));
+    const holder = resolveCharacter(db, String(flags.character), ctx.openMounts);
     const conditions = ['characterId = ?'];
     const params = [holder.id];
     if (flags.about) {
-      const a = resolveCharacter(db, String(flags.about));
+      const a = resolveCharacter(db, String(flags.about), ctx.openMounts);
       conditions.push('aboutCharacterId = ?');
       params.push(a.id);
     }
@@ -636,6 +680,368 @@ function cmdMemories(args, ctx) {
   }
 }
 
+// ---------- verb: characters ----------
+
+// Single-file vault documents the character-properties overlay manages. Must
+// stay in sync with `CHARACTER_VAULT_DESCRIPTORS` in
+// lib/database/repositories/vault-overlay/. Post-4.6-cutover the vault is the
+// only home for these fields.
+//
+// REQUIRED files are written unconditionally by `writeCharacterVaultManagedFields`
+// (empty string when the field is blank), so a healthy character always has all
+// of them. The physical-* pair is OPTIONAL: the writer skips both when the
+// character has no physicalDescription. It writes them as a pair, so having
+// exactly one of the two is an inconsistency worth flagging.
+const REQUIRED_VAULT_SINGLE_FILES = [
+  'properties.json',
+  'identity.md',
+  'description.md',
+  'personality.md',
+  'example-dialogues.md',
+];
+// manifesto is nullable/optional. The full-projection writer writes an empty
+// manifesto.md when the field is blank, but the patch-level write overlay only
+// writes it when a patch carries a `manifesto` key — so a perfectly valid
+// character can simply lack the file. On read, absent == empty == null, so we
+// report manifesto's presence but never count its absence as "missing" or let
+// it block. (Treated like the physical-* pair: optional, surfaced, not required.)
+const OPTIONAL_VAULT_SINGLE_FILES = [
+  'manifesto.md',
+];
+const PHYSICAL_VAULT_FILES = [
+  'physical-description.md',
+  'physical-prompts.json',
+];
+
+function safeJsonArray(raw) {
+  if (raw == null || raw === '') return [];
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v : [];
+  } catch {
+    return [];
+  }
+}
+
+function normalizeEmpty(v) {
+  if (v == null) return '';
+  return v;
+}
+
+function inspectCharacterVault(row, mounts) {
+  // `flag` / `*Db` / divergence reporting only make sense before the 4.6
+  // vault cutover, when the DB still carried the content columns. After
+  // the cutover the columns are gone and the vault is the only source of
+  // truth — `row` won't carry them. Treat them as null and skip the
+  // divergence check; the file-presence count is still useful.
+  const preCutover = row.identity !== undefined
+    || row.description !== undefined
+    || row.systemPrompts !== undefined;
+
+  const status = {
+    id: row.id,
+    name: row.name,
+    flag: row.readPropertiesFromDocumentStore == null
+      ? null
+      : Number(row.readPropertiesFromDocumentStore),
+    mountPointId: row.characterDocumentMountPointId || null,
+    vault: 'missing',
+    presentSingleFiles: 0,
+    expectedSingleFiles: REQUIRED_VAULT_SINGLE_FILES.length,
+    missingSingleFiles: [],
+    manifestoPresent: false,   // optional single file: present or not, both valid
+    physicalFilesPresent: 0,   // 0, 1, or 2 of the optional physical-* pair
+    physicalInconsistent: false,
+    promptsVault: 0,
+    promptsDb: 0,
+    scenariosVault: 0,
+    scenariosDb: 0,
+    wardrobeVault: 0,
+    diverged: [],
+    issue: null,
+    preCutover,
+  };
+
+  if (preCutover) {
+    status.promptsDb = safeJsonArray(row.systemPrompts).length;
+    status.scenariosDb = safeJsonArray(row.scenarios).length;
+  }
+
+  if (!row.characterDocumentMountPointId) {
+    status.issue = 'no vault';
+    return status;
+  }
+
+  status.vault = 'present';
+  const mountPointId = row.characterDocumentMountPointId;
+
+  // One-shot listing of every link for this vault; the rest is just lookups.
+  const links = mounts.prepare(
+    'SELECT relativePath, fileId FROM doc_mount_file_links WHERE mountPointId = ?'
+  ).all(mountPointId);
+  const byPath = new Map();
+  for (const link of links) {
+    byPath.set(link.relativePath.toLowerCase(), link);
+  }
+
+  for (const p of REQUIRED_VAULT_SINGLE_FILES) {
+    if (byPath.has(p)) {
+      status.presentSingleFiles++;
+    } else {
+      status.missingSingleFiles.push(p);
+    }
+  }
+
+  // Manifesto is optional: report presence, never require it.
+  status.manifestoPresent = OPTIONAL_VAULT_SINGLE_FILES.every((p) => byPath.has(p));
+
+  // Physical-* files are optional (a character may legitimately have no
+  // physical description). Both-or-neither is healthy; exactly one is not.
+  status.physicalFilesPresent = PHYSICAL_VAULT_FILES.filter((p) => byPath.has(p)).length;
+  status.physicalInconsistent = status.physicalFilesPresent === 1;
+
+  for (const [p] of byPath) {
+    if (p.startsWith('prompts/') && p.endsWith('.md')) status.promptsVault++;
+    else if (p.startsWith('scenarios/') && p.endsWith('.md')) status.scenariosVault++;
+    else if (p.startsWith('wardrobe/') && p.endsWith('.md')) status.wardrobeVault++;
+  }
+
+  // Compare vault contents to DB row for each managed field where the
+  // corresponding file is actually present. Only meaningful pre-cutover;
+  // post-cutover the DB no longer carries the columns to compare against.
+  if (preCutover) {
+    const docStmt = mounts.prepare(
+      'SELECT content FROM doc_mount_documents WHERE fileId = ?'
+    );
+    const readVault = (relPath) => {
+      const link = byPath.get(relPath);
+      if (!link) return null;
+      const doc = docStmt.get(link.fileId);
+      return doc ? doc.content : null;
+    };
+
+    const mdFields = [
+      ['identity.md', 'identity'],
+      ['description.md', 'description'],
+      ['manifesto.md', 'manifesto'],
+      ['personality.md', 'personality'],
+      ['example-dialogues.md', 'exampleDialogues'],
+    ];
+    for (const [vaultPath, dbField] of mdFields) {
+      const vault = readVault(vaultPath);
+      if (vault === null) continue;
+      const db = row[dbField] ?? '';
+      if (vault !== db) status.diverged.push(dbField);
+    }
+
+    const propsRaw = readVault('properties.json');
+    if (propsRaw !== null) {
+      try {
+        const props = JSON.parse(propsRaw);
+        const scalarChecks = [
+          ['pronouns', row.pronouns],
+          ['title', row.title],
+          ['firstMessage', row.firstMessage],
+          ['talkativeness', row.talkativeness],
+        ];
+        for (const [k, dbVal] of scalarChecks) {
+          if (normalizeEmpty(props[k]) !== normalizeEmpty(dbVal)) {
+            status.diverged.push(k);
+          }
+        }
+        const vaultAliases = JSON.stringify(Array.isArray(props.aliases) ? props.aliases : []);
+        const dbAliases = JSON.stringify(safeJsonArray(row.aliases));
+        if (vaultAliases !== dbAliases) status.diverged.push('aliases');
+        // systemTransparency: tristate (0 / 1 / null), only reported if vault has it
+        if (props.systemTransparency !== undefined) {
+          if ((props.systemTransparency ?? null) !== (row.systemTransparency ?? null)) {
+            status.diverged.push('systemTransparency');
+          }
+        }
+      } catch {
+        status.diverged.push('properties.json:unparseable');
+      }
+    }
+
+    const physArr = safeJsonArray(row.physicalDescriptions);
+    const primary = physArr[0] || null;
+    const physMd = readVault('physical-description.md');
+    if (physMd !== null) {
+      const dbVal = primary && primary.fullDescription != null ? primary.fullDescription : '';
+      if (physMd !== dbVal) status.diverged.push('physicalDescription.fullDescription');
+    }
+    const physJsonRaw = readVault('physical-prompts.json');
+    if (physJsonRaw !== null) {
+      try {
+        const physJson = JSON.parse(physJsonRaw);
+        const promptChecks = [
+          ['short', primary?.shortPrompt],
+          ['medium', primary?.mediumPrompt],
+          ['long', primary?.longPrompt],
+          ['complete', primary?.completePrompt],
+        ];
+        for (const [k, dbVal] of promptChecks) {
+          if (normalizeEmpty(physJson[k]) !== normalizeEmpty(dbVal)) {
+            status.diverged.push(`physical.${k}Prompt`);
+          }
+        }
+      } catch {
+        status.diverged.push('physical-prompts.json:unparseable');
+      }
+    }
+
+    if (status.promptsVault !== status.promptsDb) {
+      status.diverged.push(`systemPrompts:count(vault=${status.promptsVault},db=${status.promptsDb})`);
+    }
+    if (status.scenariosVault !== status.scenariosDb) {
+      status.diverged.push(`scenarios:count(vault=${status.scenariosVault},db=${status.scenariosDb})`);
+    }
+  }
+
+  const anyContent = status.presentSingleFiles > 0
+    || status.manifestoPresent
+    || status.physicalFilesPresent > 0
+    || status.promptsVault > 0
+    || status.scenariosVault > 0
+    || status.wardrobeVault > 0;
+  if (!anyContent) {
+    status.issue = 'vault empty';
+  } else if (status.missingSingleFiles.length > 0) {
+    status.issue = `${status.missingSingleFiles.length} required files missing`;
+  } else if (status.physicalInconsistent) {
+    status.issue = 'physical files incomplete (1 of 2)';
+  } else if (status.diverged.length > 0) {
+    status.issue = `diverged (${status.diverged.length})`;
+  } else if (!preCutover) {
+    status.issue = 'ok (post-cutover, vault is canonical)';
+  } else if (status.flag === 1) {
+    status.issue = 'ok (vault authoritative)';
+  } else {
+    status.issue = 'ok (db matches vault)';
+  }
+  return status;
+}
+
+function cmdCharacters(args, ctx) {
+  const { flags, positional } = parseSubArgs(args);
+  const sub = positional[0] || 'status';
+  if (sub !== 'status') {
+    throw new Error(`Unknown characters subcommand: ${sub}. Try: status`);
+  }
+
+  const json = asBool(flags.json);
+  const limit = asInt(flags.limit, 0);
+  const onlyDiverged = asBool(flags.diverged);
+  const onlyBlocked = asBool(flags.blocked);
+  const idQuery = flags.id ? String(flags.id) : null;
+
+  const main = ctx.openMain();
+  const mounts = ctx.openMounts();
+  try {
+    // Probe the schema so this verb works both pre- and post-cutover: after
+    // the 4.6 migration the content columns are gone, so we can only ask
+    // for what's there.
+    const existing = new Set(
+      main.prepare('PRAGMA table_info(characters)')
+        .all()
+        .map(r => r.name)
+    );
+    const wanted = [
+      'id', 'name', 'characterDocumentMountPointId', 'systemTransparency',
+      'readPropertiesFromDocumentStore',
+      'identity', 'description', 'manifesto', 'personality', 'exampleDialogues',
+      'pronouns', 'aliases', 'title', 'firstMessage', 'talkativeness',
+      'physicalDescriptions', 'systemPrompts', 'scenarios',
+    ];
+    const cols = wanted.filter(c => existing.has(c));
+    let sql = `SELECT ${cols.join(', ')} FROM characters`;
+    const params = [];
+    if (idQuery) {
+      const c = resolveCharacter(main, idQuery, ctx.openMounts);
+      sql += ' WHERE id = ?';
+      params.push(c.id);
+    } else {
+      sql += ' ORDER BY name';
+      if (limit > 0) {
+        sql += ' LIMIT ?';
+        params.push(limit);
+      }
+    }
+    const rows = main.prepare(sql).all(...params);
+
+    const all = rows.map(r => inspectCharacterVault(r, mounts));
+    const filtered = all.filter(s => {
+      if (onlyBlocked && !(s.issue && (s.issue === 'no vault' || s.issue === 'vault empty' || s.issue.endsWith(' files missing')))) {
+        return false;
+      }
+      if (onlyDiverged && s.diverged.length === 0 && (!s.missingSingleFiles || s.missingSingleFiles.length === 0)) {
+        return false;
+      }
+      return true;
+    });
+
+    if (json) {
+      const summary = {
+        totalScanned: all.length,
+        returned: filtered.length,
+        counts: summarizeCharacterStatuses(all),
+        characters: filtered,
+      };
+      return printJson(summary);
+    }
+
+    const summary = summarizeCharacterStatuses(all);
+    let headline = `Scanned ${all.length} character${all.length === 1 ? '' : 's'}: ` +
+      `${summary.ok} ok, ${summary.diverged} diverged, ${summary.missingFiles} with missing files, ` +
+      `${summary.noVault} with no vault, ${summary.empty} empty`;
+    if (summary.physIncomplete > 0) headline += `, ${summary.physIncomplete} with incomplete physical files`;
+    headline += '.';
+    console.log(headline);
+    console.log('');
+    // The readPropertiesFromDocumentStore flag and the DB side of the
+    // prompts/scenarios counts only exist before the 4.6 cutover. Post-cutover
+    // (the normal case now) the vault is canonical, so drop the dead `flag`
+    // column and show vault-only counts instead of misleading `vault/db`.
+    const anyPreCutover = all.some(s => s.preCutover);
+    printTable(filtered.map(s => {
+      const missing = s.vault === 'missing';
+      const row = { id: s.id.slice(0, 8), name: truncate(s.name, 28) };
+      if (anyPreCutover) row.flag = s.flag == null ? '-' : s.flag;
+      row.vault = s.vault;
+      row.files = missing ? '-' : `${s.presentSingleFiles}/${s.expectedSingleFiles}`;
+      row.manifesto = missing ? '-' : (s.manifestoPresent ? 'yes' : 'no');
+      row.phys = missing ? '-' : `${s.physicalFilesPresent}/2`;
+      row.prompts = missing ? '-' : (anyPreCutover ? `${s.promptsVault}/${s.promptsDb}` : String(s.promptsVault));
+      row.scenarios = missing ? '-' : (anyPreCutover ? `${s.scenariosVault}/${s.scenariosDb}` : String(s.scenariosVault));
+      row.wardrobe = missing ? '-' : s.wardrobeVault;
+      row.status = truncate(s.issue, 60);
+      return row;
+    }));
+
+    if (filtered.length > 0 && filtered.some(s => s.diverged.length > 0)) {
+      console.log('');
+      console.log('Run with --json to see the full diverged-field list per character.');
+    }
+  } finally {
+    try { mounts.close(); } catch {}
+    try { main.close(); } catch {}
+  }
+}
+
+function summarizeCharacterStatuses(all) {
+  let ok = 0, diverged = 0, missingFiles = 0, noVault = 0, empty = 0, physIncomplete = 0;
+  for (const s of all) {
+    if (!s.issue) continue;
+    if (s.issue.startsWith('ok')) ok++;
+    else if (s.issue === 'no vault') noVault++;
+    else if (s.issue === 'vault empty') empty++;
+    else if (s.issue.endsWith(' files missing')) missingFiles++;
+    else if (s.issue.startsWith('physical files incomplete')) physIncomplete++;
+    else if (s.issue.startsWith('diverged')) diverged++;
+  }
+  return { ok, diverged, missingFiles, noVault, empty, physIncomplete };
+}
+
 // ---------- verb: optimize ----------
 
 const OPTIMIZE_TARGETS = {
@@ -1105,6 +1511,7 @@ const VERBS = {
   message: cmdMessage,
   log: cmdLog,
   memories: cmdMemories,
+  characters: cmdCharacters,
   optimize: cmdOptimize,
   backup: cmdBackup,
   integrity: cmdIntegrity,

package/lib/db-helpers.js

@@ -255,25 +255,104 @@ function ambiguous(kind, rows) {
   return err;
 }
 
-function resolveCharacter(db, query) {
+// Read the `aliases` array out of a character vault's `properties.json`.
+// The 4.6 vault cutover dropped the `aliases` (and `pronouns`) columns from
+// the `characters` table — they now live only in the per-character vault — so
+// any alias lookup has to go through the mount-index DB. `mounts` is that
+// handle; `mountPointId` is `characters.characterDocumentMountPointId`.
+// Returns [] for a missing/empty/unparseable vault so callers can treat the
+// absence of aliases as "no match" rather than an error.
+function readVaultAliases(mounts, mountPointId) {
+  if (!mounts || !mountPointId) return [];
+  const rec = mounts.prepare(
+    `SELECT d.content AS content
+       FROM doc_mount_file_links l
+       JOIN doc_mount_documents d ON d.fileId = l.fileId
+      WHERE l.mountPointId = ? AND LOWER(l.relativePath) = 'properties.json'
+      LIMIT 1`
+  ).get(mountPointId);
+  if (!rec || !rec.content) return [];
+  try {
+    const props = JSON.parse(rec.content);
+    return Array.isArray(props.aliases)
+      ? props.aliases.filter((a) => typeof a === 'string')
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+// Find characters whose vault aliases contain `query` (case-insensitive
+// substring). Requires a mount-index DB handle; returns [{ id, name }].
+// Scans every vaulted character's `properties.json` — fine for a CLI, and only
+// reached on the fuzzy-resolution fallback (a clean name match returns first).
+function resolveCharactersByAlias(db, mounts, query) {
+  if (!mounts) return [];
+  const needle = query.toLowerCase();
+  const chars = db.prepare(
+    'SELECT id, name, characterDocumentMountPointId AS mp FROM characters WHERE characterDocumentMountPointId IS NOT NULL'
+  ).all();
+  const matches = [];
+  for (const c of chars) {
+    const aliases = readVaultAliases(mounts, c.mp);
+    if (aliases.some((a) => a.toLowerCase().includes(needle))) {
+      matches.push({ id: c.id, name: c.name });
+    }
+  }
+  return matches;
+}
+
+// Resolve a UUID / name / alias to a single { id, name } row.
+//
+// `openMounts` (optional) is a zero-arg function that returns a mount-index DB
+// handle (e.g. `ctx.openMounts`). When supplied, the fuzzy fallback also
+// matches against vault-stored aliases; when omitted (or if the mount-index DB
+// can't be opened), resolution degrades gracefully to UUID + name only.
+function resolveCharacter(db, query, openMounts = null) {
   if (UUID_RE.test(query)) {
-    const row = db.prepare('SELECT id, name, aliases FROM characters WHERE id = ?').get(query);
+    const row = db.prepare('SELECT id, name FROM characters WHERE id = ?').get(query);
     if (!row) throw new Error(`No character with id ${query}`);
     return row;
   }
   const exact = db.prepare(
-    'SELECT id, name, aliases FROM characters WHERE LOWER(name) = LOWER(?)'
+    'SELECT id, name FROM characters WHERE LOWER(name) = LOWER(?)'
   ).all(query);
   if (exact.length === 1) return exact[0];
   if (exact.length > 1) {
     throw ambiguous('character', exact);
   }
-  const fuzzy = db.prepare(
-    'SELECT id, name, aliases FROM characters WHERE LOWER(name) LIKE LOWER(?) OR LOWER(aliases) LIKE LOWER(?) ORDER BY name'
-  ).all(`%${query}%`, `%${query}%`);
-  if (fuzzy.length === 0) throw new Error(`No character matching '${query}'`);
-  if (fuzzy.length > 1) throw ambiguous('character', fuzzy);
-  return fuzzy[0];
+
+  const candidates = db.prepare(
+    'SELECT id, name FROM characters WHERE LOWER(name) LIKE LOWER(?) ORDER BY name'
+  ).all(`%${query}%`);
+
+  // Fold in alias matches from the vault when the caller gave us a way to
+  // reach the mount-index DB. Aliases moved into properties.json in 4.6.
+  if (openMounts) {
+    let mounts = null;
+    try {
+      mounts = openMounts();
+    } catch {
+      mounts = null; // mount-index DB absent on this instance — skip aliases
+    }
+    if (mounts) {
+      try {
+        const seen = new Set(candidates.map((r) => r.id));
+        for (const m of resolveCharactersByAlias(db, mounts, query)) {
+          if (!seen.has(m.id)) {
+            seen.add(m.id);
+            candidates.push(m);
+          }
+        }
+      } finally {
+        try { mounts.close(); } catch {}
+      }
+    }
+  }
+
+  if (candidates.length === 0) throw new Error(`No character matching '${query}'`);
+  if (candidates.length > 1) throw ambiguous('character', candidates);
+  return candidates[0];
 }
 
 function resolveChat(db, query) {
@@ -317,6 +396,8 @@ module.exports = {
   UUID_RE,
   ambiguous,
   resolveCharacter,
+  resolveCharactersByAlias,
+  readVaultAliases,
   resolveChat,
   resolveProject,
 };

package/lib/memories-commands.js

@@ -5,6 +5,7 @@ const {
   printDefaultInstanceHint,
   loadDbKey,
   openMainDb,
+  openMountIndexDb,
   UUID_RE,
   resolveCharacter,
   resolveChat,
@@ -179,7 +180,10 @@ async function openDb(flags) {
   const { dataDir, passphrase } = resolved;
   const pepper = await loadDbKey(dataDir, passphrase);
   const db = openMainDb(dataDir, pepper, { readonly: true });
-  return { db, dataDir };
+  // Lazy opener for the mount-index DB so `resolveCharacter` can match
+  // vault-stored aliases (4.6 cutover moved them out of the `characters` row).
+  const openMounts = () => openMountIndexDb(dataDir, pepper, { readonly: true });
+  return { db, dataDir, openMounts };
 }
 
 // ---------- filter / sort builders ----------
@@ -188,13 +192,13 @@ async function openDb(flags) {
 // `{ where: 'WHERE m.x = ? AND ...', params: [...], meta: { characterId, ... } }`.
 // `meta` exposes resolved IDs so callers can decide e.g. whether to show a
 // per-row holder column.
-function buildWhereClause(db, flags) {
+function buildWhereClause(db, flags, openMounts = null) {
   const clauses = [];
   const params = [];
   const meta = { characterId: null, aboutId: null, chatId: null, projectId: null, allCharacters: true };
 
   if (flags.character && flags.character !== 'all') {
-    const c = resolveCharacter(db, flags.character);
+    const c = resolveCharacter(db, flags.character, openMounts);
     clauses.push('m.characterId = ?');
     params.push(c.id);
     meta.characterId = c.id;
@@ -207,7 +211,7 @@ function buildWhereClause(db, flags) {
     } else if (flags.about === 'none') {
       clauses.push('m.aboutCharacterId IS NULL');
     } else {
-      const a = resolveCharacter(db, flags.about);
+      const a = resolveCharacter(db, flags.about, openMounts);
       clauses.push('m.aboutCharacterId = ?');
       params.push(a.id);
       meta.aboutId = a.id;
@@ -395,9 +399,9 @@ function renderJson(obj) {
 // ---------- ls ----------
 
 async function cmdLs(flags) {
-  const { db } = await openDb(flags);
+  const { db, openMounts } = await openDb(flags);
   try {
-    const { where, params, meta } = buildWhereClause(db, flags);
+    const { where, params, meta } = buildWhereClause(db, flags, openMounts);
     const { order, impField } = buildOrderBy(flags.sort, flags.reverse);
     const limit = flags.limit > 0 ? flags.limit : 50;
     const sql = `${SELECT_BASE} ${where} ORDER BY ${order} LIMIT ?`;
@@ -512,9 +516,9 @@ async function cmdFind(flags, positional) {
   if (!['summary', 'content', 'both'].includes(inWhere)) {
     throw new Error(`--in must be one of: summary, content, both (got '${inWhere}')`);
   }
-  const { db } = await openDb(flags);
+  const { db, openMounts } = await openDb(flags);
   try {
-    const { where, params, meta } = buildWhereClause(db, flags);
+    const { where, params, meta } = buildWhereClause(db, flags, openMounts);
     const like = `%${pattern}%`;
 
     const matchClauses = [];
@@ -584,9 +588,9 @@ async function cmdSemanticGrep(flags, query) {
   // Resolve character locally so the server gets a stable UUID.
   let characterId;
   {
-    const { db } = await openDb(flags);
+    const { db, openMounts } = await openDb(flags);
     try {
-      const resolved = resolveCharacter(db, flags.character);
+      const resolved = resolveCharacter(db, flags.character, openMounts);
       characterId = resolved.id;
     } finally {
       db.close();
@@ -675,9 +679,9 @@ async function cmdGrep(flags, positional) {
   if (flags.semantic) {
     return cmdSemanticGrep(flags, pattern);
   }
-  const { db } = await openDb(flags);
+  const { db, openMounts } = await openDb(flags);
   try {
-    const { where, params } = buildWhereClause(db, flags);
+    const { where, params } = buildWhereClause(db, flags, openMounts);
     // Always restrict to rows whose content can match — quick pre-filter so we
     // don't read all 32k rows into JS just to drop most of them.
     const likeNeedle = flags.ignoreCase ? `%${pattern.toLowerCase()}%` : `%${pattern}%`;
@@ -1044,11 +1048,11 @@ function graphToJson(node) {
 // ---------- status ----------
 
 async function cmdStatus(flags) {
-  const { db } = await openDb(flags);
+  const { db, openMounts } = await openDb(flags);
   try {
     let holderRows;
     if (flags.character && flags.character !== 'all') {
-      const c = resolveCharacter(db, flags.character);
+      const c = resolveCharacter(db, flags.character, openMounts);
       holderRows = [{ id: c.id, name: c.name }];
     } else {
       holderRows = db.prepare(`
@@ -1180,12 +1184,12 @@ function renderStatusBlock(holder, stats) {
 // ---------- validate ----------
 
 async function cmdValidate(flags) {
-  const { db } = await openDb(flags);
+  const { db, openMounts } = await openDb(flags);
   try {
     let holderIds = null;
     let holderRows;
     if (flags.character && flags.character !== 'all') {
-      const c = resolveCharacter(db, flags.character);
+      const c = resolveCharacter(db, flags.character, openMounts);
       holderRows = [{ id: c.id, name: c.name }];
       holderIds = [c.id];
     } else {

package/lib/native-modules.js

@@ -0,0 +1,151 @@
+'use strict';
+
+// Shared helpers for keeping native modules compiled against the current Node
+// ABI. Used by both the runtime CLI entry (bin/quilltap.js) and the package's
+// `postinstall` hook, so a fresh install picks up the correct binaries up front
+// and a later Node upgrade still self-heals on first run.
+
+const path = require('path');
+const { execSync } = require('child_process');
+
+const PACKAGE_DIR = path.resolve(__dirname, '..');
+
+// Resolve a native module's directory, handling npm hoisting.
+// Returns the directory containing package.json, or null if not found.
+function resolveModuleDir(moduleName) {
+  try {
+    const pkgJson = require.resolve(moduleName + '/package.json', { paths: [PACKAGE_DIR] });
+    return path.dirname(pkgJson);
+  } catch {
+    return null;
+  }
+}
+
+// node-pty needs a `spawn-helper` executable beside the pty.node it loads, or
+// pty.spawn() fails with `posix_spawnp failed`. An ABI rebuild lands a fresh
+// build/Release/pty.node (which node-pty's loader prefers over prebuilds/) but
+// emits only the addon, not node-pty's separate spawn-helper target; tar/extract
+// can also drop the exec bit on the shipped prebuilds/*/spawn-helper. spawn-helper
+// is a plain executable (no Node linkage) so the prebuilt copy is ABI-independent
+// and safe to reuse. Best-effort; never throws.
+function reconcileNodePtySpawnHelper() {
+  if (process.platform === 'win32') return; // conpty has no spawn-helper
+  const fs = require('fs');
+  try {
+    const nodePtyDir = resolveModuleDir('node-pty');
+    if (!nodePtyDir) return;
+    const prebuildsDir = path.join(nodePtyDir, 'prebuilds');
+    const prebuiltHelper = path.join(prebuildsDir, `${process.platform}-${process.arch}`, 'spawn-helper');
+
+    if (fs.existsSync(prebuildsDir)) {
+      for (const entry of fs.readdirSync(prebuildsDir)) {
+        const helper = path.join(prebuildsDir, entry, 'spawn-helper');
+        if (fs.existsSync(helper)) {
+          try { fs.chmodSync(helper, 0o755); } catch { /* best-effort */ }
+        }
+      }
+    }
+
+    for (const buildType of ['Release', 'Debug']) {
+      const buildDir = path.join(nodePtyDir, 'build', buildType);
+      const builtAddon = path.join(buildDir, 'pty.node');
+      const builtHelper = path.join(buildDir, 'spawn-helper');
+      if (fs.existsSync(builtHelper)) {
+        try { fs.chmodSync(builtHelper, 0o755); } catch { /* best-effort */ }
+      } else if (fs.existsSync(builtAddon) && fs.existsSync(prebuiltHelper)) {
+        fs.copyFileSync(prebuiltHelper, builtHelper);
+        fs.chmodSync(builtHelper, 0o755);
+        console.log(`  node-pty: backfilled build/${buildType}/spawn-helper from prebuilds`);
+      }
+    }
+  } catch {
+    // best-effort — node-pty terminals are optional; never block the CLI
+  }
+}
+
+// Check if native modules are compiled for the current Node.js version.
+// This handles the case where npx caches the package but the user upgrades
+// Node.js — the cached native modules will have a stale NODE_MODULE_VERSION.
+// Returns true if everything was healthy or successfully rebuilt; false on
+// rebuild failure. Never throws.
+function ensureNativeModules() {
+  const needsRebuild = [];
+
+  // Check better-sqlite3-multiple-ciphers (provides SQLCipher encryption support).
+  // The main app depends on this via an npm alias as 'better-sqlite3', so we must
+  // ensure the SQLCipher-capable version is available and link it as 'better-sqlite3'.
+  // We must load the native binding directly to detect NODE_MODULE_VERSION mismatches.
+  try {
+    const modDir = resolveModuleDir('better-sqlite3-multiple-ciphers')
+                || resolveModuleDir('better-sqlite3');
+    if (!modDir) throw Object.assign(new Error('not found'), { code: 'MODULE_NOT_FOUND' });
+    const bindingsPath = path.join(modDir, 'build', 'Release', 'better_sqlite3.node');
+    require(bindingsPath);
+  } catch (err) {
+    if (err.message && err.message.includes('NODE_MODULE_VERSION')) {
+      needsRebuild.push('better-sqlite3-multiple-ciphers');
+    } else if (err.code === 'MODULE_NOT_FOUND') {
+      needsRebuild.push('better-sqlite3-multiple-ciphers');
+    }
+  }
+
+  // Check sharp: loads its native binding eagerly on require.
+  try {
+    require.resolve('sharp', { paths: [PACKAGE_DIR] });
+    require('sharp');
+  } catch (err) {
+    if (err.message && err.message.includes('NODE_MODULE_VERSION')) {
+      needsRebuild.push('sharp');
+    } else if (err.code === 'MODULE_NOT_FOUND') {
+      needsRebuild.push('sharp');
+    }
+  }
+
+  // Check node-pty: backs the Ariel terminal feature. Loaded dynamically by
+  // pty-manager in the standalone server, so resolution must succeed and the
+  // native binding's NODE_MODULE_VERSION must match the runtime.
+  try {
+    require.resolve('node-pty', { paths: [PACKAGE_DIR] });
+    require('node-pty');
+  } catch (err) {
+    if (err.message && err.message.includes('NODE_MODULE_VERSION')) {
+      needsRebuild.push('node-pty');
+    } else if (err.code === 'MODULE_NOT_FOUND') {
+      needsRebuild.push('node-pty');
+    }
+  }
+
+  if (needsRebuild.length === 0) {
+    reconcileNodePtySpawnHelper();
+    return true;
+  }
+
+  console.log(`  Rebuilding native modules for Node.js ${process.version}...`);
+
+  try {
+    execSync(`npm rebuild ${needsRebuild.join(' ')}`, {
+      cwd: PACKAGE_DIR,
+      stdio: 'inherit',
+    });
+    console.log('  Done.');
+    console.log('');
+    reconcileNodePtySpawnHelper();
+    return true;
+  } catch (err) {
+    console.error('');
+    console.error(`  Warning: Failed to rebuild native modules: ${err.message}`);
+    console.error('  Try running: npm rebuild --prefix ' + PACKAGE_DIR);
+    console.error('');
+    return false;
+  }
+}
+
+module.exports = { resolveModuleDir, ensureNativeModules, reconcileNodePtySpawnHelper, PACKAGE_DIR };
+
+// Allow this file to be invoked directly as a postinstall script:
+//   node lib/native-modules.js
+// Exits 0 on success or graceful warning; never blocks npm install on failure.
+if (require.main === module) {
+  ensureNativeModules();
+  process.exit(0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quilltap",
-  "version": "4.5.1",
+  "version": "4.6.0-dev.105",
   "description": "Self-hosted AI workspace for writers, worldbuilders, and roleplayers. Run with npx quilltap.",
   "author": {
     "name": "Charles Sebold",
@@ -27,6 +27,9 @@
   "bin": {
     "quilltap": "bin/quilltap.js"
   },
+  "scripts": {
+    "postinstall": "node lib/native-modules.js"
+  },
   "files": [
     "bin/",
     "lib/",
@@ -34,11 +37,11 @@
   ],
   "dependencies": {
     "@napi-rs/canvas": "^0.1.100",
-    "better-sqlite3-multiple-ciphers": "^12.9.0",
+    "better-sqlite3-multiple-ciphers": "^12.10.0",
     "node-pty": "^1.1.0",
     "sharp": "^0.34.5",
     "tar": "^7.5.15",
-    "yauzl": "^3.3.0"
+    "yauzl": "^3.3.1"
   },
   "engines": {
     "node": ">=24.0.0"