escribano 0.4.4 → 0.5.0

package/dist/db/repositories/subject.sqlite.js

@@ -7,7 +7,7 @@ export function createSqliteSubjectRepository(db) {
         findById: db.prepare('SELECT * FROM subjects WHERE id = ?'),
         findByRecording: db.prepare('SELECT * FROM subjects WHERE recording_id = ? ORDER BY created_at ASC'),
         insert: db.prepare(`
-      INSERT INTO subjects (id, recording_id, label, is_personal, duration, activity_breakdown, metadata, created_at)
+      INSERT OR IGNORE INTO subjects (id, recording_id, label, is_personal, duration, activity_breakdown, metadata, created_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `),
         insertLink: db.prepare(`

package/dist/python-utils.js

@@ -10,6 +10,16 @@ import { resolve } from 'node:path';
 export const ESCRIBANO_HOME = resolve(homedir(), '.escribano');
 export const ESCRIBANO_VENV = resolve(ESCRIBANO_HOME, 'venv');
 export const ESCRIBANO_VENV_PYTHON = resolve(ESCRIBANO_VENV, 'bin', 'python3');
+/**
+ * Check if a path is inside the current working directory (project-local).
+ * Used to skip VIRTUAL_ENV/UV_PROJECT_ENVIRONMENT that are dev venvs for
+ * the project itself, not suitable as Escribano's Python runtime.
+ */
+function isInsideCwd(path) {
+    const absPath = resolve(path);
+    const cwd = process.cwd();
+    return absPath.startsWith(`${cwd}/`) || absPath.startsWith(`${cwd}\\`);
+}
 /**
  * Get explicitly configured Python path.
  * Returns null when nothing is explicitly configured or found via well-known
@@ -19,29 +29,37 @@ export const ESCRIBANO_VENV_PYTHON = resolve(ESCRIBANO_VENV, 'bin', 'python3');
  *
  * Priority:
  * 1. ESCRIBANO_PYTHON_PATH env var (explicit override)
- * 2. Active virtual environment (VIRTUAL_ENV)
- * 3. UV_PROJECT_ENVIRONMENT (uv project-synced venv)
- * 4. Project-local .venv (created by `uv venv` in CWD)
- * 5. ~/.venv/bin/python3 (home-level venv)
- * 6. null — no environment detected; auto-venv will be created
+ * 2. ~/.escribano/venv (managed venv, if it exists — preferred once created)
+ * 3. Active virtual environment (VIRTUAL_ENV, unless inside CWD)
+ * 4. UV_PROJECT_ENVIRONMENT (uv project-synced venv, unless inside CWD)
+ * 5. Project-local .venv (created by `uv venv` in CWD)
+ * 6. ~/.venv/bin/python3 (home-level venv)
+ * 7. null — no environment detected; auto-venv will be created
  */
 export function getPythonPath() {
+    // 1. Explicit override always wins
     if (process.env.ESCRIBANO_PYTHON_PATH) {
         return process.env.ESCRIBANO_PYTHON_PATH;
     }
-    if (process.env.VIRTUAL_ENV) {
+    // 2. Escribano's managed venv — preferred once it exists
+    if (existsSync(ESCRIBANO_VENV_PYTHON)) {
+        return ESCRIBANO_VENV_PYTHON;
+    }
+    // 3. Active virtual environment (skip if it's a project-local dev venv)
+    if (process.env.VIRTUAL_ENV && !isInsideCwd(process.env.VIRTUAL_ENV)) {
         return resolve(process.env.VIRTUAL_ENV, 'bin', 'python3');
     }
-    // UV_PROJECT_ENVIRONMENT: set by uv when running inside a project with `uv sync`
-    if (process.env.UV_PROJECT_ENVIRONMENT) {
+    // 4. UV_PROJECT_ENVIRONMENT (skip if inside CWD)
+    if (process.env.UV_PROJECT_ENVIRONMENT &&
+        !isInsideCwd(process.env.UV_PROJECT_ENVIRONMENT)) {
         return resolve(process.env.UV_PROJECT_ENVIRONMENT, 'bin', 'python3');
     }
-    // Check project-local .venv (created by `uv venv` in the current working directory)
+    // 5. Project-local .venv (created by `uv venv` in the current working directory)
     const localVenv = resolve(process.cwd(), '.venv', 'bin', 'python3');
     if (existsSync(localVenv)) {
         return localVenv;
     }
-    // Check common home-level venv (e.g., `uv venv ~/.venv`)
+    // 6. Home-level venv (e.g., `uv venv ~/.venv`)
     const uvHomeVenv = resolve(homedir(), '.venv', 'bin', 'python3');
     if (existsSync(uvHomeVenv)) {
         return uvHomeVenv;

package/dist/services/subject-grouping.js

@@ -7,6 +7,7 @@
 import { readFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { step } from '../pipeline/context.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PERSONAL_APPS = new Set([
     'WhatsApp',
@@ -24,7 +25,7 @@ const PERSONAL_APPS = new Set([
     'Messages',
 ]);
 const PERSONAL_APP_THRESHOLD = 0.5;
-const SUBJECT_GROUPING_MODEL = process.env.ESCRIBANO_SUBJECT_GROUPING_MODEL || 'qwen3.5:27b';
+const SUBJECT_GROUPING_MODEL = process.env.ESCRIBANO_SUBJECT_GROUPING_MODEL;
 export async function groupTopicBlocksIntoSubjects(topicBlocks, intelligence, recordingId) {
     if (topicBlocks.length === 0) {
         return {
@@ -35,16 +36,42 @@ export async function groupTopicBlocksIntoSubjects(topicBlocks, intelligence, re
     }
     const blocksForGrouping = topicBlocks.map(extractBlockForGrouping);
     const prompt = buildGroupingPrompt(blocksForGrouping);
-    console.log(`[subject-grouping] Grouping ${topicBlocks.length} blocks into subjects (model: ${SUBJECT_GROUPING_MODEL})`);
+    const modelInfo = SUBJECT_GROUPING_MODEL
+        ? ` (model: ${SUBJECT_GROUPING_MODEL})`
+        : ' (auto-detected)';
+    console.log(`[subject-grouping] Grouping ${topicBlocks.length} blocks into subjects${modelInfo}`);
     try {
-        const response = await intelligence.generateText(prompt, {
-            expectJson: false,
-            model: SUBJECT_GROUPING_MODEL,
-            numPredict: 2000,
-            think: false,
+        const response = await step('llm_subject_grouping', async () => {
+            return intelligence.generateText(prompt, {
+                expectJson: false,
+                model: SUBJECT_GROUPING_MODEL || undefined,
+                numPredict: 2000,
+                think: false,
+                debugContext: {
+                    recordingId,
+                    callType: 'subject_grouping',
+                },
+            });
         });
-        console.log(`[subject-grouping] LLM response (${response.length} chars):\n${response.slice(0, 500)}${response.length > 500 ? '...' : ''}`);
-        const grouping = parseGroupingResponse(response, topicBlocks);
+        // Strip thinking leakage if present
+        let cleaned = response.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+        if (cleaned.includes('</think>')) {
+            // Handle orphan </think> tag (Qwen3.5 behavior)
+            cleaned = cleaned.split('</think>')[1].trim();
+        }
+        // Strip "Thinking Process:" prose (Qwen3.5-OptiQ format)
+        const tpMatch = cleaned.match(/(?:^|\n)Thinking Process:/);
+        if (tpMatch !== null) {
+            const after = cleaned.slice((tpMatch.index ?? 0) + tpMatch[0].length);
+            const heading = after.match(/\n(#\s|\*\*|Group\s)/);
+            cleaned =
+                heading?.index !== undefined ? after.slice(heading.index).trim() : '';
+        }
+        if (cleaned.length < 10) {
+            console.warn('[subject-grouping] Thinking leakage detected or response too short — parseGroupingResponse will fall back');
+        }
+        console.log(`[subject-grouping] LLM response (${cleaned.length} chars after stripping):\n${cleaned.slice(0, 500)}${cleaned.length > 500 ? '...' : ''}`);
+        const grouping = parseGroupingResponse(cleaned || response, topicBlocks);
         console.log(`[subject-grouping] Parsed ${grouping.groups.length} groups: ${grouping.groups.map((g) => g.label).join(', ')}`);
         const subjects = grouping.groups.map((group, index) => {
             const subjectId = `subject-${recordingId}-${index}`;

package/dist/tests/index.test.js

@@ -1,40 +1,53 @@
-import { chmod, mkdir, rm, stat, symlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { access, chmod, constants, mkdir, readdir, rm, stat, symlink, writeFile, } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 const VIDEO_EXTENSIONS = ['.mov', '.mp4', '.mkv', '.avi', '.webm'];
 function expandPath(inputPath) {
+    if (!inputPath.startsWith('~')) {
+        return inputPath;
+    }
+    const homeDir = homedir();
+    if (!homeDir) {
+        return inputPath;
+    }
+    if (inputPath === '~' || inputPath === '~/') {
+        return homeDir;
+    }
     if (inputPath.startsWith('~/')) {
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
         return path.join(homeDir, inputPath.slice(2));
     }
     return inputPath;
 }
 async function findLatestVideo(dirPath) {
     const resolvedPath = expandPath(dirPath);
-    const { readdir } = await import('node:fs/promises');
     const entries = await readdir(resolvedPath, { withFileTypes: true });
     const videoFiles = entries.filter((entry) => entry.isFile() &&
         VIDEO_EXTENSIONS.some((ext) => entry.name.toLowerCase().endsWith(ext)));
     if (videoFiles.length === 0) {
         throw new Error(`No video files found in: ${resolvedPath}`);
     }
-    const filesWithMtime = await Promise.all(videoFiles.map(async (entry) => {
+    let latestFilePath = null;
+    let latestMtime = -Infinity;
+    for (const entry of videoFiles) {
         const fullPath = path.join(resolvedPath, entry.name);
         try {
+            await access(fullPath, constants.R_OK);
             const fileStat = await stat(fullPath);
-            return { path: fullPath, mtime: fileStat.mtime };
+            const mtimeMs = fileStat.mtime.getTime();
+            if (mtimeMs > latestMtime) {
+                latestMtime = mtimeMs;
+                latestFilePath = fullPath;
+            }
         }
         catch {
-            return null;
+            // Skip files that are inaccessible (permission denied, broken symlink, etc.)
         }
-    }));
-    const validFiles = filesWithMtime.filter((f) => f !== null);
-    if (validFiles.length === 0) {
+    }
+    if (!latestFilePath) {
         throw new Error(`No accessible video files found in: ${resolvedPath}`);
     }
-    validFiles.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-    return validFiles[0].path;
+    return latestFilePath;
 }
 describe('findLatestVideo', () => {
     let testDir;

package/dist/tests/intelligence.mlx.adapter.test.js

@@ -22,7 +22,7 @@ vi.mock('node:child_process', () => ({
         kill: vi.fn(),
     })),
 }));
-import { existsSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { resolvePythonPath } from '../adapters/intelligence.mlx.adapter.js';
 import { getPythonPath } from '../python-utils.js';
 const mockExistsSync = vi.mocked(existsSync);
@@ -178,8 +178,10 @@ describe('resolvePythonPath', () => {
     });
     it('installs mlx-vlm when the import probe fails', async () => {
         const venvPython = resolve(homedir(), '.escribano', 'venv', 'bin', 'python3');
-        // Simulate: managed venv python exists
-        mockExistsSync.mockImplementation((p) => p === venvPython);
+        const escribanoHome = resolve(homedir(), '.escribano');
+        mockExistsSync.mockImplementation((p) => p === escribanoHome);
+        const mockMkdirSync = vi.mocked(mkdirSync);
+        mockMkdirSync.mockReturnValue(undefined);
         const { spawn } = await import('node:child_process');
         const mockSpawn = vi.mocked(spawn);
         mockSpawn.mockClear();
@@ -189,9 +191,12 @@ describe('resolvePythonPath', () => {
             const emitter = {
                 on: vi.fn((event, cb) => {
                     if (event === 'exit') {
-                        // First call: import probe fails (non-zero exit)
-                        // All subsequent calls (ensurepip, pip install, ...): succeed
-                        cb(thisCall === 0 ? 1 : 0);
+                        if (thisCall === 1) {
+                            cb(1);
+                        }
+                        else {
+                            cb(0);
+                        }
                     }
                     return emitter;
                 }),
@@ -202,8 +207,7 @@ describe('resolvePythonPath', () => {
             return emitter;
         });
         await expect(resolvePythonPath()).resolves.toBe(venvPython);
-        expect(mockSpawn.mock.calls.length).toBeGreaterThanOrEqual(2);
-        // Find the pip install call regardless of its position (robust to ensurepip being inserted)
+        expect(mockSpawn.mock.calls.length).toBeGreaterThanOrEqual(3);
         const installCall = mockSpawn.mock.calls.find(([_cmd, args]) => Array.isArray(args) &&
             args.includes('-m') &&
             args.includes('pip') &&
@@ -217,6 +221,7 @@ describe('resolvePythonPath', () => {
             'mlx-vlm',
             'torch',
             'torchvision',
+            'mlx-lm',
         ]));
     });
 });

package/dist/tests/utils/env-logger.test.js

@@ -127,7 +127,7 @@ OTHER_VAR=value`;
         });
         it('marks custom values with [CUSTOM]', () => {
             const mockContent = `# Default batch size
-ESCRIBANO_VLM_BATCH_SIZE=4`;
+ESCRIBANO_VLM_BATCH_SIZE=2`;
             vi.mocked(readFileSync).mockReturnValue(mockContent);
             process.env.ESCRIBANO_VERBOSE = 'true';
             process.env.ESCRIBANO_VLM_BATCH_SIZE = '8';
@@ -138,15 +138,15 @@ ESCRIBANO_VLM_BATCH_SIZE=4`;
                 .join('\n');
             expect(output).toContain('[CUSTOM]');
             expect(output).toContain('Current: 8');
-            expect(output).toContain('Default: 4');
+            expect(output).toContain('Default: 2');
             consoleSpy.mockRestore();
         });
         it('does not mark default values', () => {
             const mockContent = `# Default batch size
-ESCRIBANO_VLM_BATCH_SIZE=4`;
+ESCRIBANO_VLM_BATCH_SIZE=2`;
             vi.mocked(readFileSync).mockReturnValue(mockContent);
             process.env.ESCRIBANO_VERBOSE = 'true';
-            process.env.ESCRIBANO_VLM_BATCH_SIZE = '4';
+            process.env.ESCRIBANO_VLM_BATCH_SIZE = '2';
             const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
             logEnvironmentVariables();
             const output = consoleSpy.mock.calls
@@ -170,7 +170,7 @@ ESCRIBANO_VLM_BATCH_SIZE=4`;
             consoleSpy.mockRestore();
         });
         it('does not mask non-secret values', () => {
-            const mockContent = `ESCRIBANO_VLM_BATCH_SIZE=4`;
+            const mockContent = `ESCRIBANO_VLM_BATCH_SIZE=2`;
             vi.mocked(readFileSync).mockReturnValue(mockContent);
             process.env.ESCRIBANO_VERBOSE = 'true';
             process.env.ESCRIBANO_VLM_BATCH_SIZE = '8';
@@ -184,7 +184,7 @@ ESCRIBANO_VLM_BATCH_SIZE=4`;
             consoleSpy.mockRestore();
         });
         it('shows "not set" for undefined variables', () => {
-            const mockContent = `ESCRIBANO_VLM_BATCH_SIZE=4`;
+            const mockContent = `ESCRIBANO_VLM_BATCH_SIZE=2`;
             vi.mocked(readFileSync).mockReturnValue(mockContent);
             process.env.ESCRIBANO_VERBOSE = 'true';
             delete process.env.ESCRIBANO_VLM_BATCH_SIZE;

package/dist/utils/model-detector.js

@@ -3,6 +3,11 @@
  *
  * Detects the best available LLM model from installed Ollama models
  * based on system RAM and model quality tiers.
+ *
+ * MLX Models Note:
+ * Uses lmstudio-community Instruct-2507 models for reliable inference.
+ * These models respect think=False and produce clean output without
+ * thinking leakage, unlike older Qwen3.5 models.
  */
 import { totalmem } from 'node:os';
 export const LLM_MODEL_TIERS = [
@@ -11,6 +16,26 @@ export const LLM_MODEL_TIERS = [
     { model: 'qwen3:8b', tier: 2, minRamGB: 10, label: 'good' },
     { model: 'qwen3:4b', tier: 1, minRamGB: 6, label: 'minimum' },
 ];
+export const MLX_LLM_MODEL_TIERS = [
+    {
+        model: 'lmstudio-community/Qwen3-30B-A3B-Instruct-2507-MLX-8bit',
+        tier: 3,
+        minRamGB: 64,
+        label: 'best',
+    },
+    {
+        model: 'lmstudio-community/Qwen3-30B-A3B-Instruct-2507-MLX-4bit',
+        tier: 2,
+        minRamGB: 32,
+        label: 'good',
+    },
+    {
+        model: 'lmstudio-community/Qwen3-4B-Instruct-2507-MLX-4bit',
+        tier: 1,
+        minRamGB: 8,
+        label: 'minimum',
+    },
+];
 const OLLAMA_ENDPOINT = process.env.OLLAMA_HOST || 'http://localhost:11434';
 /**
  * Fetch installed models from Ollama
@@ -135,6 +160,84 @@ export async function selectBestLLMModel() {
         recommendation: `Install at least ${lowest.model}: ollama pull ${lowest.model}`,
     };
 }
+/**
+ * Select the best MLX LLM model based on system RAM.
+ *
+ * If ESCRIBANO_LLM_MLX_MODEL is set, uses that but still validates and warns.
+ * Otherwise, auto-selects the best available model that fits in RAM.
+ */
+export async function selectBestMLXModel() {
+    const ramGB = getSystemRamGB();
+    const envModel = process.env.ESCRIBANO_LLM_MLX_MODEL;
+    // If env var is set, use it but validate
+    if (envModel) {
+        const tier = MLX_LLM_MODEL_TIERS.find((t) => t.model.toLowerCase() === envModel.toLowerCase());
+        if (!tier) {
+            return {
+                model: envModel,
+                source: 'env',
+                tier: 0,
+                label: 'unknown',
+                ramGB,
+                warning: `${envModel} is not a recognized MLX model.`,
+                recommendation: `Consider using one of: ${MLX_LLM_MODEL_TIERS.map((t) => t.model).join(', ')}`,
+            };
+        }
+        if (tier.minRamGB > ramGB) {
+            const recommended = MLX_LLM_MODEL_TIERS.find((t) => t.minRamGB <= ramGB);
+            return {
+                model: envModel,
+                source: 'env',
+                tier: tier.tier,
+                label: tier.label,
+                ramGB,
+                warning: `${envModel} may be too large for your ${ramGB}GB RAM.`,
+                recommendation: recommended
+                    ? `Consider ${recommended.model} for stability`
+                    : undefined,
+            };
+        }
+        // Check if there's a better model available for this RAM
+        const betterTier = MLX_LLM_MODEL_TIERS.find((t) => t.tier > tier.tier && t.minRamGB <= ramGB);
+        return {
+            model: envModel,
+            source: 'env',
+            tier: tier.tier,
+            label: tier.label,
+            ramGB,
+            recommendation: betterTier
+                ? `${betterTier.model} would give better quality for your ${ramGB}GB RAM`
+                : undefined,
+        };
+    }
+    // Auto-select: find best model that fits in RAM
+    for (const tier of MLX_LLM_MODEL_TIERS) {
+        if (tier.minRamGB > ramGB)
+            continue;
+        // Check if there's a better model NOT selected
+        const betterTier = MLX_LLM_MODEL_TIERS.find((t) => t.tier > tier.tier && t.minRamGB <= ramGB);
+        return {
+            model: tier.model,
+            source: 'auto',
+            tier: tier.tier,
+            label: tier.label,
+            ramGB,
+            recommendation: betterTier
+                ? `For better quality, consider ${betterTier.model} (install via mlx-vlm)`
+                : undefined,
+        };
+    }
+    // Nothing found - return lowest tier
+    const lowest = MLX_LLM_MODEL_TIERS[MLX_LLM_MODEL_TIERS.length - 1];
+    return {
+        model: lowest.model,
+        source: 'auto',
+        tier: 0,
+        label: 'minimum',
+        ramGB,
+        warning: `Selected minimum MLX model for ${ramGB}GB RAM.`,
+    };
+}
 /**
  * Format model selection for console output
  */
@@ -145,10 +248,10 @@ export function formatModelSelection(selection) {
         : '(auto-detected)';
     lines.push(`Using ${selection.model} ${sourceLabel}`);
     if (selection.warning) {
-        lines.push(`  ⚠ ${selection.warning}`);
+        lines.push(`  ! ${selection.warning}`);
     }
     if (selection.recommendation) {
-        lines.push(`  ℹ ${selection.recommendation}`);
+        lines.push(`  i ${selection.recommendation}`);
     }
     return lines.join('\n');
 }

package/migrations/010_llm_backend_metadata.sql

@@ -0,0 +1,25 @@
+-- Migration 010: Add LLM backend tracking to existing runs
+-- 
+-- Marks all existing runs as having used Ollama backend (before MLX-LM migration).
+-- This allows benchmarking comparisons between backends.
+
+-- Update existing runs to set llm_backend in metadata
+-- Since SQLite doesn't have native JSON functions in all versions, we update the metadata text directly
+UPDATE processing_runs 
+SET metadata = CASE 
+  WHEN metadata IS NULL THEN '{"llm_backend":"ollama"}'
+  WHEN metadata LIKE '%"llm_backend"%' THEN metadata  -- Already set, don't override
+  WHEN metadata = '{}' THEN '{"llm_backend":"ollama"}'
+  ELSE REPLACE(metadata, '}', ',"llm_backend":"ollama"}')
+END
+WHERE status IN ('completed', 'failed');
+
+-- For running/other statuses that may be stale, also update them
+UPDATE processing_runs 
+SET metadata = CASE 
+  WHEN metadata IS NULL THEN '{"llm_backend":"ollama"}'
+  WHEN metadata LIKE '%"llm_backend"%' THEN metadata
+  WHEN metadata = '{}' THEN '{"llm_backend":"ollama"}'
+  ELSE REPLACE(metadata, '}', ',"llm_backend":"ollama"}')
+END
+WHERE metadata IS NULL OR metadata NOT LIKE '%"llm_backend"%';

package/migrations/011_llm_debug_log.sql

@@ -0,0 +1,19 @@
+-- Migration 011: LLM Debug Log Table
+-- Stores raw LLM inputs/outputs for debugging thinking leakage
+
+CREATE TABLE IF NOT EXISTS llm_debug_log (
+  id TEXT PRIMARY KEY,
+  recording_id TEXT,
+  artifact_id TEXT,
+  call_type TEXT NOT NULL,        -- 'subject_grouping' | 'artifact_generation'
+  prompt TEXT,                    -- raw user prompt (before apply_chat_template)
+  result TEXT,                    -- final processed response returned to caller
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  
+  -- Everything else as JSON (model, tokens, timing, raw_response diff, etc.)
+  metadata TEXT NOT NULL
+);
+
+CREATE INDEX idx_llm_debug_log_recording ON llm_debug_log(recording_id);
+CREATE INDEX idx_llm_debug_log_call_type ON llm_debug_log(call_type);
+CREATE INDEX idx_llm_debug_log_created ON llm_debug_log(created_at);

package/migrations/012_llm_debug_log_prompt_result.sql

@@ -0,0 +1,20 @@
+-- Migration 012: Rebuild llm_debug_log with prompt/result columns
+-- Drops and recreates the table to add first-class prompt + result columns.
+-- Safe: this table only contains debug data.
+
+DROP TABLE IF EXISTS llm_debug_log;
+
+CREATE TABLE IF NOT EXISTS llm_debug_log (
+  id TEXT PRIMARY KEY,
+  recording_id TEXT,
+  artifact_id TEXT,
+  call_type TEXT NOT NULL,
+  prompt TEXT,
+  result TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  metadata TEXT NOT NULL
+);
+
+CREATE INDEX idx_llm_debug_log_recording ON llm_debug_log(recording_id);
+CREATE INDEX idx_llm_debug_log_call_type ON llm_debug_log(call_type);
+CREATE INDEX idx_llm_debug_log_created ON llm_debug_log(created_at);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "escribano",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "AI-powered session intelligence tool — turn screen recordings into structured work summaries",
   "main": "dist/index.js",
   "type": "module",