vellum 0.2.0 → 0.2.2

package/src/memory/db.ts

@@ -3,6 +3,9 @@ import { drizzle } from 'drizzle-orm/bun-sqlite';
 import { computeMemoryFingerprint } from './fingerprint.js';
 import * as schema from './schema.js';
 import { getDbPath, ensureDataDir, migrateToDataLayout, migrateToWorkspaceLayout } from '../util/platform.js';
+import { getLogger } from '../util/logger.js';
+
+const log = getLogger('memory-db');
 
 let db: ReturnType<typeof drizzle<typeof schema>> | null = null;
 
@@ -271,6 +274,7 @@ export function initializeDb(): void {
       name TEXT NOT NULL,
       enabled INTEGER NOT NULL DEFAULT 1,
       cron_expression TEXT NOT NULL,
+      schedule_syntax TEXT NOT NULL DEFAULT 'cron',
       timezone TEXT,
       message TEXT NOT NULL,
       next_run_at INTEGER NOT NULL,
@@ -337,8 +341,8 @@ export function initializeDb(): void {
     )
   `);
 
-  try { database.run(/*sql*/ `ALTER TABLE published_pages ADD COLUMN app_id TEXT`); } catch {}
-  try { database.run(/*sql*/ `ALTER TABLE published_pages ADD COLUMN project_slug TEXT`); } catch {}
+  try { database.run(/*sql*/ `ALTER TABLE published_pages ADD COLUMN app_id TEXT`); } catch (e) { log.debug({ err: e }, 'ALTER TABLE published_pages ADD COLUMN app_id (likely already exists)'); }
+  try { database.run(/*sql*/ `ALTER TABLE published_pages ADD COLUMN project_slug TEXT`); } catch (e) { log.debug({ err: e }, 'ALTER TABLE published_pages ADD COLUMN project_slug (likely already exists)'); }
 
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS shared_app_links (
@@ -538,12 +542,16 @@ export function initializeDb(): void {
   try { database.run(/*sql*/ `ALTER TABLE channel_inbound_events ADD COLUMN raw_payload TEXT`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE conversations ADD COLUMN thread_type TEXT NOT NULL DEFAULT 'standard'`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE conversations ADD COLUMN memory_scope_id TEXT NOT NULL DEFAULT 'default'`); } catch { /* already exists */ }
+  try { database.run(/*sql*/ `ALTER TABLE attachments ADD COLUMN thumbnail_base64 TEXT`); } catch { /* already exists */ }
+  try { database.run(/*sql*/ `ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`); } catch { /* already exists */ }
+  try { database.run(/*sql*/ `ALTER TABLE messages ADD COLUMN metadata TEXT`); } catch { /* already exists */ }
 
   migrateJobDeferrals(database);
   migrateToolInvocationsFk(database);
   migrateMemoryEntityRelationDedup(database);
   migrateMemoryItemsFingerprintScopeUnique(database);
   migrateMemoryItemsScopeSaltedFingerprints(database);
+  migrateAssistantIdToSelf(database);
 
   // Indexes for query performance on large datasets
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_llm_request_logs_conv_created ON llm_request_logs(conversation_id, created_at)`);
@@ -600,6 +608,7 @@ export function initializeDb(): void {
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_reminders_status_fire_at ON reminders(status, fire_at)`);
 
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run ON cron_jobs(enabled, next_run_at)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_syntax_enabled_next_run ON cron_jobs(schedule_syntax, enabled, next_run_at)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_runs_job_id ON cron_runs(job_id)`);
 
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_accounts_service ON accounts(service)`);
@@ -685,6 +694,75 @@ export function initializeDb(): void {
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_triage_results_sender ON triage_results(sender)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_triage_results_created_at ON triage_results(created_at DESC)`);
 
+  // ── Call Sessions (outgoing AI phone calls) ────────────────────────
+
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS call_sessions (
+      id TEXT PRIMARY KEY,
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      provider TEXT NOT NULL,
+      provider_call_sid TEXT,
+      from_number TEXT NOT NULL,
+      to_number TEXT NOT NULL,
+      task TEXT,
+      status TEXT NOT NULL DEFAULT 'initiated',
+      started_at INTEGER,
+      ended_at INTEGER,
+      last_error TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS call_events (
+      id TEXT PRIMARY KEY,
+      call_session_id TEXT NOT NULL REFERENCES call_sessions(id) ON DELETE CASCADE,
+      event_type TEXT NOT NULL,
+      payload_json TEXT NOT NULL DEFAULT '{}',
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS call_pending_questions (
+      id TEXT PRIMARY KEY,
+      call_session_id TEXT NOT NULL REFERENCES call_sessions(id) ON DELETE CASCADE,
+      question_text TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      asked_at INTEGER NOT NULL,
+      answered_at INTEGER,
+      answer_text TEXT
+    )
+  `);
+
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS processed_callbacks (
+      id TEXT PRIMARY KEY,
+      dedupe_key TEXT NOT NULL UNIQUE,
+      call_session_id TEXT NOT NULL REFERENCES call_sessions(id) ON DELETE CASCADE,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_call_sessions_conversation_id ON call_sessions(conversation_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_call_sessions_provider_call_sid ON call_sessions(provider_call_sid)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_call_sessions_status ON call_sessions(status)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_call_events_call_session_id ON call_events(call_session_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_call_pending_questions_call_session_id ON call_pending_questions(call_session_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_call_pending_questions_status ON call_pending_questions(status)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_processed_callbacks_dedupe_key ON processed_callbacks(dedupe_key)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_processed_callbacks_call_session_id ON processed_callbacks(call_session_id)`);
+
+  // Add claim ownership token to prevent cross-handler claim interference
+  try { database.run(/*sql*/ `ALTER TABLE processed_callbacks ADD COLUMN claim_id TEXT`); } catch { /* already exists */ }
+
+  // Unique constraint: at most one non-null provider_call_sid per (provider, provider_call_sid).
+  // On upgraded databases that pre-date this constraint, duplicate rows may exist; deduplicate
+  // them first to avoid a UNIQUE constraint failure that would prevent startup.
+  migrateCallSessionsProviderSidDedup(database);
+  database.run(/*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_call_sessions_provider_sid_unique ON call_sessions(provider, provider_call_sid) WHERE provider_call_sid IS NOT NULL`);
+
   // ── Follow-ups ─────────────────────────────────────────────────────
 
   database.run(/*sql*/ `
@@ -773,6 +851,13 @@ export function initializeDb(): void {
     )
   `);
 
+  // Work item run contract snapshot
+  try { database.run(/*sql*/ `ALTER TABLE work_items ADD COLUMN required_tools TEXT`); } catch (e) { log.debug({ err: e }, 'ALTER TABLE work_items ADD COLUMN required_tools (likely already exists)'); }
+
+  // Work item permission preflight columns
+  try { database.run(/*sql*/ `ALTER TABLE work_items ADD COLUMN approved_tools TEXT`); } catch (e) { log.debug({ err: e }, 'ALTER TABLE work_items ADD COLUMN approved_tools (likely already exists)'); }
+  try { database.run(/*sql*/ `ALTER TABLE work_items ADD COLUMN approval_status TEXT DEFAULT 'none'`); } catch (e) { log.debug({ err: e }, 'ALTER TABLE work_items ADD COLUMN approval_status (likely already exists)'); }
+
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_work_items_status ON work_items(status)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_work_items_task_id ON work_items(task_id)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_work_items_priority_sort ON work_items(priority_tier, sort_index)`);
@@ -1103,3 +1188,278 @@ function migrateMemoryItemsScopeSaltedFingerprints(database: ReturnType<typeof d
     throw e;
   }
 }
+
+/**
+ * One-shot migration: normalize all assistant_id values in assistant-scoped tables
+ * to "self" so they are visible after the daemon switched to the implicit single-tenant
+ * identity.
+ *
+ * Before this change, rows were keyed by the real assistantId string passed via the
+ * HTTP route. After the route change, all lookups use the constant "self". Without this
+ * migration an upgraded daemon would see empty history / attachment lists for existing
+ * data that was stored under the old assistantId.
+ *
+ * Affected tables:
+ *   - conversation_keys   UNIQUE (assistant_id, conversation_key)
+ *   - attachments         UNIQUE (assistant_id, content_hash) WHERE content_hash IS NOT NULL
+ *   - channel_inbound_events  UNIQUE (assistant_id, source_channel, external_chat_id, external_message_id)
+ *   - message_runs        no unique constraint on assistant_id
+ *
+ * Data-safety guarantees:
+ *   - conversation_keys: when a key exists under both 'self' and a real assistantId, the
+ *     'self' row is updated to point to the real-assistantId conversation (which holds the
+ *     historical message thread). The 'self' conversation may be orphaned but is not deleted.
+ *   - attachments: message_attachments links are remapped to the surviving attachment before
+ *     any duplicate row is deleted, so no message loses its attachment metadata.
+ *   - channel_inbound_events: only delivery-tracking metadata, not user content; dedup
+ *     keeps one row per unique (channel, chat, message) tuple.
+ *   - All conversations and messages remain untouched — only assistant_id index columns
+ *     and key-lookup rows are modified.
+ */
+function migrateAssistantIdToSelf(database: ReturnType<typeof drizzle<typeof schema>>): void {
+  const raw = (database as unknown as { $client: Database }).$client;
+  const checkpointKey = 'migration_normalize_assistant_id_to_self_v1';
+  const checkpoint = raw.query(
+    `SELECT 1 FROM memory_checkpoints WHERE key = ?`,
+  ).get(checkpointKey);
+  if (checkpoint) return;
+
+  try {
+    raw.exec('BEGIN');
+
+    // conversation_keys: UNIQUE (assistant_id, conversation_key)
+    //
+    // Step 1: Among non-self rows, keep only one per conversation_key so the
+    //         bulk UPDATE cannot hit a (non-self-A, key) + (non-self-B, key) collision.
+    raw.exec(/*sql*/ `
+      DELETE FROM conversation_keys
+      WHERE assistant_id != 'self'
+        AND rowid NOT IN (
+          SELECT MIN(rowid) FROM conversation_keys
+          WHERE assistant_id != 'self'
+          GROUP BY conversation_key
+        )
+    `);
+    // Step 2: For 'self' rows that have a non-self counterpart with the same
+    //         conversation_key, update the 'self' row to use the non-self row's
+    //         conversation_id. This preserves the historical conversation (which
+    //         has the message history from before the route change) rather than
+    //         discarding it in favour of a potentially-empty 'self' conversation.
+    raw.exec(/*sql*/ `
+      UPDATE conversation_keys
+      SET conversation_id = (
+        SELECT ck_ns.conversation_id
+        FROM conversation_keys ck_ns
+        WHERE ck_ns.assistant_id != 'self'
+          AND ck_ns.conversation_key = conversation_keys.conversation_key
+        ORDER BY ck_ns.rowid
+        LIMIT 1
+      )
+      WHERE assistant_id = 'self'
+        AND EXISTS (
+          SELECT 1 FROM conversation_keys ck_ns
+          WHERE ck_ns.assistant_id != 'self'
+            AND ck_ns.conversation_key = conversation_keys.conversation_key
+        )
+    `);
+    // Step 3: Delete the now-redundant non-self rows (their conversation_ids
+    //         have been preserved in the 'self' rows above).
+    raw.exec(/*sql*/ `
+      DELETE FROM conversation_keys
+      WHERE assistant_id != 'self'
+        AND EXISTS (
+          SELECT 1 FROM conversation_keys ck2
+          WHERE ck2.assistant_id = 'self'
+            AND ck2.conversation_key = conversation_keys.conversation_key
+        )
+    `);
+    // Step 4: Remaining non-self rows have no 'self' counterpart — safe to bulk-update.
+    raw.exec(/*sql*/ `
+      UPDATE conversation_keys SET assistant_id = 'self' WHERE assistant_id != 'self'
+    `);
+
+    // attachments: UNIQUE (assistant_id, content_hash) WHERE content_hash IS NOT NULL
+    //
+    // message_attachments rows reference attachment IDs with ON DELETE CASCADE, so we
+    // must remap links to the surviving row BEFORE deleting duplicates to avoid
+    // silently dropping attachment metadata from messages.
+    //
+    // Step 1: Remap message_attachments from non-self duplicates to their survivor
+    //         (MIN rowid per content_hash group), then delete the duplicates.
+    raw.exec(/*sql*/ `
+      UPDATE message_attachments
+      SET attachment_id = (
+        SELECT a_survivor.id
+        FROM attachments a_survivor
+        WHERE a_survivor.assistant_id != 'self'
+          AND a_survivor.content_hash = (
+            SELECT a_dup.content_hash FROM attachments a_dup
+            WHERE a_dup.id = message_attachments.attachment_id
+          )
+        ORDER BY a_survivor.rowid
+        LIMIT 1
+      )
+      WHERE attachment_id IN (
+        SELECT id FROM attachments
+        WHERE assistant_id != 'self'
+          AND content_hash IS NOT NULL
+          AND rowid NOT IN (
+            SELECT MIN(rowid) FROM attachments
+            WHERE assistant_id != 'self' AND content_hash IS NOT NULL
+            GROUP BY content_hash
+          )
+      )
+    `);
+    raw.exec(/*sql*/ `
+      DELETE FROM attachments
+      WHERE assistant_id != 'self'
+        AND content_hash IS NOT NULL
+        AND rowid NOT IN (
+          SELECT MIN(rowid) FROM attachments
+          WHERE assistant_id != 'self'
+            AND content_hash IS NOT NULL
+          GROUP BY content_hash
+        )
+    `);
+    // Step 2: Remap message_attachments from non-self rows conflicting with a 'self'
+    //         row to the 'self' row, then delete the now-unlinked non-self rows.
+    raw.exec(/*sql*/ `
+      UPDATE message_attachments
+      SET attachment_id = (
+        SELECT a_self.id
+        FROM attachments a_self
+        WHERE a_self.assistant_id = 'self'
+          AND a_self.content_hash = (
+            SELECT a_ns.content_hash FROM attachments a_ns
+            WHERE a_ns.id = message_attachments.attachment_id
+          )
+        LIMIT 1
+      )
+      WHERE attachment_id IN (
+        SELECT id FROM attachments
+        WHERE assistant_id != 'self'
+          AND content_hash IS NOT NULL
+          AND EXISTS (
+            SELECT 1 FROM attachments a2
+            WHERE a2.assistant_id = 'self'
+              AND a2.content_hash = attachments.content_hash
+          )
+      )
+    `);
+    raw.exec(/*sql*/ `
+      DELETE FROM attachments
+      WHERE assistant_id != 'self'
+        AND content_hash IS NOT NULL
+        AND EXISTS (
+          SELECT 1 FROM attachments a2
+          WHERE a2.assistant_id = 'self'
+            AND a2.content_hash = attachments.content_hash
+        )
+    `);
+    // Step 3: Bulk-update remaining non-self rows.
+    raw.exec(/*sql*/ `
+      UPDATE attachments SET assistant_id = 'self' WHERE assistant_id != 'self'
+    `);
+
+    // channel_inbound_events: UNIQUE (assistant_id, source_channel, external_chat_id, external_message_id)
+    // Step 1: Dedup non-self rows sharing the same (source_channel, external_chat_id, external_message_id).
+    raw.exec(/*sql*/ `
+      DELETE FROM channel_inbound_events
+      WHERE assistant_id != 'self'
+        AND rowid NOT IN (
+          SELECT MIN(rowid) FROM channel_inbound_events
+          WHERE assistant_id != 'self'
+          GROUP BY source_channel, external_chat_id, external_message_id
+        )
+    `);
+    // Step 2: Delete non-self rows conflicting with existing 'self' rows.
+    raw.exec(/*sql*/ `
+      DELETE FROM channel_inbound_events
+      WHERE assistant_id != 'self'
+        AND EXISTS (
+          SELECT 1 FROM channel_inbound_events e2
+          WHERE e2.assistant_id = 'self'
+            AND e2.source_channel = channel_inbound_events.source_channel
+            AND e2.external_chat_id = channel_inbound_events.external_chat_id
+            AND e2.external_message_id = channel_inbound_events.external_message_id
+        )
+    `);
+    // Step 3: Bulk-update remaining non-self rows.
+    raw.exec(/*sql*/ `
+      UPDATE channel_inbound_events SET assistant_id = 'self' WHERE assistant_id != 'self'
+    `);
+
+    // message_runs: no unique constraint on assistant_id — simple bulk update
+    raw.exec(/*sql*/ `
+      UPDATE message_runs SET assistant_id = 'self' WHERE assistant_id != 'self'
+    `);
+
+    raw.query(
+      `INSERT OR IGNORE INTO memory_checkpoints (key, value, updated_at) VALUES (?, '1', ?)`,
+    ).run(checkpointKey, Date.now());
+
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  }
+}
+
+/**
+ * One-shot migration: remove duplicate (provider, provider_call_sid) rows from
+ * call_sessions so that the unique index can be created safely on upgraded databases
+ * that pre-date the constraint.
+ *
+ * For each set of duplicates, the most recently updated row is kept.
+ */
+function migrateCallSessionsProviderSidDedup(database: ReturnType<typeof drizzle<typeof schema>>): void {
+  const raw = (database as unknown as { $client: Database }).$client;
+
+  // Quick check: if the unique index already exists, no dedup is needed.
+  const idxExists = raw.query(
+    `SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = 'idx_call_sessions_provider_sid_unique'`,
+  ).get();
+  if (idxExists) return;
+
+  // Check if the table even exists yet (first boot).
+  const tableExists = raw.query(
+    `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'call_sessions'`,
+  ).get();
+  if (!tableExists) return;
+
+  // Count duplicates before doing any work.
+  const dupCount = raw.query(/*sql*/ `
+    SELECT COUNT(*) AS c FROM (
+      SELECT provider, provider_call_sid
+      FROM call_sessions
+      WHERE provider_call_sid IS NOT NULL
+      GROUP BY provider, provider_call_sid
+      HAVING COUNT(*) > 1
+    )
+  `).get() as { c: number } | null;
+
+  if (!dupCount || dupCount.c === 0) return;
+
+  log.warn({ duplicateGroups: dupCount.c }, 'Deduplicating call_sessions with duplicate provider_call_sid before creating unique index');
+
+  try {
+    raw.exec('BEGIN');
+
+    // Keep the most recently updated row per (provider, provider_call_sid);
+    // delete the rest.
+    raw.exec(/*sql*/ `
+      DELETE FROM call_sessions
+      WHERE provider_call_sid IS NOT NULL
+        AND rowid NOT IN (
+          SELECT MAX(rowid) FROM call_sessions
+          WHERE provider_call_sid IS NOT NULL
+          GROUP BY provider, provider_call_sid
+        )
+    `);
+
+    raw.exec('COMMIT');
+  } catch (e) {
+    try { raw.exec('ROLLBACK'); } catch { /* no active transaction */ }
+    throw e;
+  }
+}

package/src/memory/entity-extractor.ts

@@ -3,11 +3,14 @@ import { eq, sql } from 'drizzle-orm';
 import { getConfig } from '../config/loader.js';
 import type { MemoryEntityConfig } from '../config/types.js';
 import { getLogger } from '../util/logger.js';
+import { truncate } from '../util/truncate.js';
 import { getDb } from './db.js';
 import { memoryEntities, memoryEntityRelations, memoryItemEntities } from './schema.js';
 
 const log = getLogger('memory-entity-extractor');
 
+const ENTITY_EXTRACTION_TIMEOUT_MS = 15_000;
+
 export type EntityType =
   | 'person'
   | 'project'
@@ -145,7 +148,7 @@ export async function extractEntitiesWithLLM(
         messages: [{ role: 'user' as const, content: text }],
       }) as Promise<Anthropic.Message>,
       new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error('Entity extraction LLM timeout')), 15000),
+        setTimeout(() => reject(new Error('Entity extraction LLM timeout')), ENTITY_EXTRACTION_TIMEOUT_MS),
       ),
     ]) as Anthropic.Message;
 
@@ -460,12 +463,12 @@ function dedupeAliasList(rawAliases: string[], canonicalName: string): string[]
 
 function normalizeEntityName(value: string | null | undefined): string | null {
   if (!value) return null;
-  const normalized = String(value).trim().slice(0, 200);
+  const normalized = truncate(String(value).trim(), 200, '');
   return normalized.length > 0 ? normalized : null;
 }
 
 function normalizeEvidence(value: string | null | undefined): string | null {
   if (!value) return null;
-  const normalized = String(value).trim().slice(0, 500);
+  const normalized = truncate(String(value).trim(), 500, '');
   return normalized.length > 0 ? normalized : null;
 }

package/src/memory/items-extractor.ts

@@ -4,6 +4,7 @@ import { v4 as uuid } from 'uuid';
 import { getConfig } from '../config/loader.js';
 import type { MemoryExtractionConfig } from '../config/types.js';
 import { getLogger } from '../util/logger.js';
+import { truncate } from '../util/truncate.js';
 import { computeMemoryFingerprint } from './fingerprint.js';
 import { enqueueMemoryJob } from './jobs-store.js';
 import { extractTextFromStoredMessageContent } from './message-content.js';
@@ -199,8 +200,8 @@ async function extractItemsWithLLM(
     for (const raw of input.items) {
       if (!VALID_KINDS.has(raw.kind)) continue;
       if (!raw.subject || !raw.statement) continue;
-      const subject = String(raw.subject).slice(0, 80);
-      const statement = String(raw.statement).slice(0, 500);
+      const subject = truncate(String(raw.subject), 80, '');
+      const statement = truncate(String(raw.statement), 500, '');
       const confidence = clamp(parseScore(raw.confidence, 0.5), 0, 1);
       const importance = clamp(parseScore(raw.importance, 0.5), 0, 1);
       const fingerprint = computeMemoryFingerprint(scopeId, raw.kind, subject, statement);
@@ -333,7 +334,7 @@ export async function extractAndUpsertMemoryItemsForMessage(messageId: string, s
     db.insert(memoryItemSources).values({
       memoryItemId,
       messageId,
-      evidence: item.statement.slice(0, 500),
+      evidence: truncate(item.statement, 500, ''),
       createdAt: now,
     }).onConflictDoNothing().run();
 
@@ -410,7 +411,7 @@ function inferSubject(sentence: string, kind: MemoryItemKind): string {
     if (match) return match[1];
   }
   const words = trimmed.split(/\s+/).slice(0, 6).join(' ');
-  return words.slice(0, 80);
+  return truncate(words, 80, '');
 }
 
 function includesAny(text: string, needles: string[]): boolean {

package/src/memory/jobs-store.ts

@@ -2,6 +2,7 @@ import { and, asc, eq, lte, notInArray, inArray } from 'drizzle-orm';
 import { v4 as uuid } from 'uuid';
 import { getDb } from './db.js';
 import { memoryJobs } from './schema.js';
+import { truncate } from '../util/truncate.js';
 
 export type MemoryJobType =
   | 'embed_segment'
@@ -331,7 +332,7 @@ export function failMemoryJob(
         status: 'failed',
         attempts,
         updatedAt: now,
-        lastError: error.slice(0, 2000),
+        lastError: truncate(error, 2000, ''),
       })
       .where(eq(memoryJobs.id, id))
       .run();
@@ -343,7 +344,7 @@ export function failMemoryJob(
       attempts,
       runAfter: now + retryDelayMs,
       updatedAt: now,
-      lastError: error.slice(0, 2000),
+      lastError: truncate(error, 2000, ''),
     })
     .where(eq(memoryJobs.id, id))
     .run();

package/src/memory/llm-usage-store.ts

@@ -16,7 +16,7 @@ export function recordUsageEvent(input: UsageEventInput, pricing: PricingResult)
   db.insert(llmUsageEvents).values({
     id: event.id,
     createdAt: event.createdAt,
-    assistantId: event.assistantId,
+    assistantId: 'self',
     conversationId: event.conversationId,
     runId: event.runId,
     requestId: event.requestId,
@@ -45,7 +45,6 @@ export function listUsageEvents(options?: { limit?: number }): UsageEvent[] {
   return rows.map(row => ({
     id: row.id,
     createdAt: row.createdAt,
-    assistantId: row.assistantId,
     conversationId: row.conversationId,
     runId: row.runId,
     requestId: row.requestId,

package/src/memory/runs-store.ts

@@ -85,7 +85,6 @@ function rowToRun(row: typeof messageRuns.$inferSelect): Run {
 // ---------------------------------------------------------------------------
 
 export function createRun(
-  assistantId: string,
   conversationId: string,
   messageId?: string,
 ): Run {
@@ -95,7 +94,7 @@ export function createRun(
 
   const row = {
     id,
-    assistantId,
+    assistantId: 'self',
     conversationId,
     messageId: messageId ?? null,
     status: 'running' as const,

package/src/memory/schema.ts

@@ -23,6 +23,7 @@ export const messages = sqliteTable('messages', {
   role: text('role').notNull(),
   content: text('content').notNull(),
   createdAt: integer('created_at').notNull(),
+  metadata: text('metadata'),
 });
 
 export const toolInvocations = sqliteTable('tool_invocations', {
@@ -164,6 +165,7 @@ export const attachments = sqliteTable('attachments', {
   kind: text('kind').notNull(),
   dataBase64: text('data_base64').notNull(),
   contentHash: text('content_hash'),
+  thumbnailBase64: text('thumbnail_base64'),
   createdAt: integer('created_at').notNull(),
 });
 
@@ -242,13 +244,14 @@ export const reminders = sqliteTable('reminders', {
   updatedAt: integer('updated_at').notNull(),
 });
 
-// ── Cron / Deferred Tasks ────────────────────────────────────────────
+// ── Recurrence Schedules ─────────────────────────────────────────────
 
 export const cronJobs = sqliteTable('cron_jobs', {
   id: text('id').primaryKey(),
   name: text('name').notNull(),
   enabled: integer('enabled', { mode: 'boolean' }).notNull().default(true),
   cronExpression: text('cron_expression').notNull(),    // e.g. '0 9 * * 1-5'
+  scheduleSyntax: text('schedule_syntax').notNull().default('cron'),  // 'cron' | 'rrule'
   timezone: text('timezone'),                           // e.g. 'America/Los_Angeles'
   message: text('message').notNull(),
   nextRunAt: integer('next_run_at').notNull(),
@@ -288,6 +291,11 @@ export const cronRuns = sqliteTable('cron_runs', {
   createdAt: integer('created_at').notNull(),
 });
 
+// Recurrence-centric aliases — prefer these in new code.
+// Physical table names remain `cron_jobs` / `cron_runs` for migration compatibility.
+export const scheduleJobs = cronJobs;
+export const scheduleRuns = cronRuns;
+
 // ── LLM Usage Events (cost tracking ledger) ─────────────────────────
 
 // ── Entity Graph ─────────────────────────────────────────────────────
@@ -432,7 +440,7 @@ export const workItems = sqliteTable('work_items', {
   taskId: text('task_id').notNull().references(() => tasks.id),
   title: text('title').notNull(),
   notes: text('notes'),
-  status: text('status').notNull().default('queued'),  // queued | running | awaiting_review | failed | done | archived
+  status: text('status').notNull().default('queued'),  // queued | running | awaiting_review | failed | cancelled | done | archived
   priorityTier: integer('priority_tier').notNull().default(1), // 0=high, 1=medium, 2=low
   sortIndex: integer('sort_index'),  // manual ordering within same priority tier; null = fall back to updated_at
   lastRunId: text('last_run_id'),
@@ -440,6 +448,9 @@ export const workItems = sqliteTable('work_items', {
   lastRunStatus: text('last_run_status'),  // 'completed' | 'failed' | null
   sourceType: text('source_type'),  // reserved for future bridge (e.g. 'followup', 'triage')
   sourceId: text('source_id'),      // reserved for future bridge
+  requiredTools: text('required_tools'),  // JSON array snapshot of tools needed for this run (null=unknown, []=none, ["bash",...]=specific)
+  approvedTools: text('approved_tools'),  // JSON array of pre-approved tool names
+  approvalStatus: text('approval_status').default('none'),  // 'none' | 'approved' | 'denied'
   createdAt: integer('created_at').notNull(),
   updatedAt: integer('updated_at').notNull(),
 });
@@ -527,3 +538,55 @@ export const llmUsageEvents = sqliteTable('llm_usage_events', {
   pricingStatus: text('pricing_status').notNull(),
   metadataJson: text('metadata_json'),
 });
+
+// ── Call Sessions (outgoing AI phone calls) ──────────────────────────
+
+export const callSessions = sqliteTable('call_sessions', {
+  id: text('id').primaryKey(),
+  conversationId: text('conversation_id')
+    .notNull()
+    .references(() => conversations.id, { onDelete: 'cascade' }),
+  provider: text('provider').notNull(),
+  providerCallSid: text('provider_call_sid'),
+  fromNumber: text('from_number').notNull(),
+  toNumber: text('to_number').notNull(),
+  task: text('task'),
+  status: text('status').notNull().default('initiated'),
+  startedAt: integer('started_at'),
+  endedAt: integer('ended_at'),
+  lastError: text('last_error'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+export const callEvents = sqliteTable('call_events', {
+  id: text('id').primaryKey(),
+  callSessionId: text('call_session_id')
+    .notNull()
+    .references(() => callSessions.id, { onDelete: 'cascade' }),
+  eventType: text('event_type').notNull(),
+  payloadJson: text('payload_json').notNull().default('{}'),
+  createdAt: integer('created_at').notNull(),
+});
+
+export const callPendingQuestions = sqliteTable('call_pending_questions', {
+  id: text('id').primaryKey(),
+  callSessionId: text('call_session_id')
+    .notNull()
+    .references(() => callSessions.id, { onDelete: 'cascade' }),
+  questionText: text('question_text').notNull(),
+  status: text('status').notNull().default('pending'),
+  askedAt: integer('asked_at').notNull(),
+  answeredAt: integer('answered_at'),
+  answerText: text('answer_text'),
+});
+
+export const processedCallbacks = sqliteTable('processed_callbacks', {
+  id: text('id').primaryKey(),
+  dedupeKey: text('dedupe_key').notNull().unique(),
+  callSessionId: text('call_session_id')
+    .notNull()
+    .references(() => callSessions.id, { onDelete: 'cascade' }),
+  claimId: text('claim_id'),
+  createdAt: integer('created_at').notNull(),
+});