@vellumai/assistant 0.4.31 → 0.4.32

package/src/daemon/ipc-contract/sessions.ts

@@ -141,11 +141,6 @@ export interface UsageRequest {
   sessionId: string;
 }
 
-export interface SandboxSetRequest {
-  type: "sandbox_set";
-  enabled: boolean;
-}
-
 export interface SessionsClearRequest {
   type: "sessions_clear";
 }
@@ -421,7 +416,6 @@ export type _SessionsClientMessages =
   | UndoRequest
   | RegenerateRequest
   | UsageRequest
-  | SandboxSetRequest
   | SessionListRequest
   | SessionCreateRequest
   | SessionSwitchRequest

package/src/daemon/ipc-contract-inventory.json

@@ -123,7 +123,6 @@
     "reorder_threads",
     "ride_shotgun_start",
     "ride_shotgun_stop",
-    "sandbox_set",
     "schedule_remove",
     "schedule_run_now",
     "schedule_toggle",

package/src/daemon/lifecycle.ts

@@ -20,7 +20,6 @@ import {
 import { loadConfig } from "../config/loader.js";
 import { ensurePromptFiles } from "../config/system-prompt.js";
 import { syncUpdateBulletinOnStartup } from "../config/update-bulletin.js";
-import { migrateContactsFromLegacyTables } from "../contacts/startup-migration.js";
 import { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import { getHookManager } from "../hooks/manager.js";
 import { installTemplates } from "../hooks/templates.js";
@@ -204,18 +203,6 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
-    // Catch-up migration: populate contacts table from legacy guardian
-    // bindings and contact rows. Ensures upgrades from pre-contacts
-    // versions have a populated contacts table on first boot.
-    try {
-      migrateContactsFromLegacyTables("self");
-    } catch (err) {
-      log.warn(
-        { err },
-        "Contacts startup migration failed — continuing startup",
-      );
-    }
-
     try {
       syncUpdateBulletinOnStartup();
     } catch (err) {
@@ -437,22 +424,6 @@ export async function runDaemon(): Promise<void> {
           sourceChannel,
           sourceInterface,
         ),
-      persistAndProcessMessage: (
-        conversationId,
-        content,
-        attachmentIds,
-        options,
-        sourceChannel,
-        sourceInterface,
-      ) =>
-        server.persistAndProcessMessage(
-          conversationId,
-          content,
-          attachmentIds,
-          options,
-          sourceChannel,
-          sourceInterface,
-        ),
       interfacesDir: getInterfacesDir(),
       approvalCopyGenerator: createApprovalCopyGenerator(),
       approvalConversationGenerator: createApprovalConversationGenerator(),

package/src/home-base/app-link-store.ts

@@ -76,10 +76,3 @@ export function setHomeBaseAppLink(
     updatedAt: now,
   };
 }
-
-export function clearHomeBaseAppLink(): void {
-  const db = getDb();
-  db.delete(homeBaseAppLinks)
-    .where(eq(homeBaseAppLinks.id, HOME_BASE_LINK_ID))
-    .run();
-}

package/src/memory/conversation-attention-store.ts

@@ -439,7 +439,7 @@ export function listConversationAttention(
     })
     .from(conversationAssistantAttentionState);
 
-  // Join with conversations table when filtering by source or sourceChannel
+  // Only join conversations table when filtering by source or sourceChannel
   if (source || sourceChannel) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     query = (query as any).innerJoin(

package/src/memory/conversation-store.ts

@@ -54,27 +54,6 @@ export { ensureDisplayOrderMigration as ensureColumns } from "./conversation-dis
 // CRUD functions for display_order and is_pinned
 // ---------------------------------------------------------------------------
 
-export function getDisplayOrder(conversationId: string): number | null {
-  ensureDisplayOrderMigration();
-  const row = rawGet<{ display_order: number | null }>(
-    "SELECT display_order FROM conversations WHERE id = ?",
-    conversationId,
-  );
-  return row?.display_order ?? null;
-}
-
-export function setDisplayOrder(
-  conversationId: string,
-  order: number | null,
-): void {
-  ensureDisplayOrderMigration();
-  rawRun(
-    "UPDATE conversations SET display_order = ? WHERE id = ?",
-    order,
-    conversationId,
-  );
-}
-
 export function batchSetDisplayOrders(
   updates: Array<{
     id: string;
@@ -100,36 +79,6 @@ export function batchSetDisplayOrders(
   }
 }
 
-export function setConversationPinned(
-  conversationId: string,
-  isPinned: boolean,
-): void {
-  ensureDisplayOrderMigration();
-  rawRun(
-    "UPDATE conversations SET is_pinned = ? WHERE id = ?",
-    isPinned ? 1 : 0,
-    conversationId,
-  );
-}
-
-export function getConversationDisplayMeta(conversationId: string): {
-  displayOrder: number | null;
-  isPinned: boolean;
-} {
-  ensureDisplayOrderMigration();
-  const row = rawGet<{
-    display_order: number | null;
-    is_pinned: number | null;
-  }>(
-    "SELECT display_order, is_pinned FROM conversations WHERE id = ?",
-    conversationId,
-  );
-  return {
-    displayOrder: row?.display_order ?? null,
-    isPinned: (row?.is_pinned ?? 0) === 1,
-  };
-}
-
 export function getDisplayMetaForConversations(
   conversationIds: string[],
 ): Map<string, { displayOrder: number | null; isPinned: boolean }> {

package/src/memory/db-init.ts

@@ -42,6 +42,7 @@ import {
   migrateContactChannelsAccessFields,
   migrateContactChannelsTypeChatIdIndex,
   migrateContactsAssistantId,
+  migrateContactsNotesColumn,
   migrateContactsRolePrincipal,
   migrateConversationsThreadTypeIndex,
   migrateDropLegacyMemberGuardianTables,
@@ -278,7 +279,10 @@ export function initializeDb(): void {
   // 37. Add contact_type to contacts and assistant_contact_metadata table
   migrateAssistantContactMetadata(database);
 
-  // 38. Backfill contact interaction stats from channel lastSeenAt
+  // 38. Consolidate contact metadata columns into single notes field
+  migrateContactsNotesColumn(database);
+
+  // 39. Backfill contact interaction stats from channel lastSeenAt
   migrateBackfillContactInteractionStats(database);
 
   validateMigrationState(database);

package/src/memory/job-handlers/conflict.ts

@@ -4,12 +4,14 @@ import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { resolveConflictClarification } from "../clarification-resolver.js";
 import {
+  areStatementsCoherent,
   computeConflictRelevance,
   looksLikeClarificationReply,
   shouldAttemptConflictResolution,
 } from "../conflict-intent.js";
 import {
   isConflictKindPairEligible,
+  isConflictUserEvidenced,
   isStatementConflictEligible,
 } from "../conflict-policy.js";
 import {
@@ -82,6 +84,28 @@ export async function resolvePendingConflictsForMessageJob(
         status: "dismissed",
         resolutionNote: "Dismissed by conflict policy (transient/non-durable).",
       });
+    } else if (
+      !isConflictUserEvidenced(
+        conflict.existingVerificationState,
+        conflict.candidateVerificationState,
+      )
+    ) {
+      resolveConflict(conflict.id, {
+        status: "dismissed",
+        resolutionNote:
+          "Dismissed by conflict policy (no user-evidenced provenance).",
+      });
+    } else if (
+      !areStatementsCoherent(
+        conflict.existingStatement,
+        conflict.candidateStatement,
+      )
+    ) {
+      resolveConflict(conflict.id, {
+        status: "dismissed",
+        resolutionNote:
+          "Dismissed by conflict policy (incoherent — zero statement overlap).",
+      });
     }
   }
 

package/src/memory/migrations/105-contacts-and-triage.ts

@@ -4,14 +4,14 @@ import type { DrizzleDb } from "../db-connection.js";
  * Contacts, contact channels, and triage results tables with indexes.
  */
 export function createContactsAndTriageTables(database: DrizzleDb): void {
+  // Columns removed: relationship, importance, response_expectation, preferred_tone
+  // — dropped by migration 134 (contacts-notes-column). Omitting them here keeps
+  //   the CREATE TABLE idempotent when initializeDb() runs a second time (e.g. the
+  //   "daemon restart" tests) after migration 134 has already dropped them.
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS contacts (
       id TEXT PRIMARY KEY,
       display_name TEXT NOT NULL,
-      relationship TEXT,
-      importance REAL NOT NULL DEFAULT 0.5,
-      response_expectation TEXT,
-      preferred_tone TEXT,
       last_interaction INTEGER,
       interaction_count INTEGER NOT NULL DEFAULT 0,
       created_at INTEGER NOT NULL,
@@ -33,9 +33,6 @@ export function createContactsAndTriageTables(database: DrizzleDb): void {
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_contacts_display_name ON contacts(display_name)`,
   );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_contacts_importance ON contacts(importance DESC)`,
-  );
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_contacts_last_interaction ON contacts(last_interaction DESC)`,
   );

package/src/memory/migrations/134-contacts-notes-column.ts

@@ -6,46 +6,63 @@ const log = getLogger("migration-134");
 export function migrateContactsNotesColumn(database: DrizzleDb): void {
   const raw = getSqliteFrom(database);
 
-  raw.exec(/*sql*/ `ALTER TABLE contacts ADD COLUMN notes TEXT`);
+  try {
+    raw.exec(/*sql*/ `ALTER TABLE contacts ADD COLUMN notes TEXT`);
+  } catch {
+    /* already exists */
+  }
+
+  // Check if legacy columns still exist before attempting backfill + drop
+  const cols = new Set(
+    (
+      raw.query(`PRAGMA table_info(contacts)`).all() as Array<{ name: string }>
+    ).map((c) => c.name),
+  );
 
-  const rows = raw
-    .query(
-      `SELECT id, relationship, importance, response_expectation, preferred_tone
+  if (cols.has("relationship")) {
+    const rows = raw
+      .query(
+        `SELECT id, relationship, importance, response_expectation, preferred_tone
        FROM contacts
        WHERE relationship IS NOT NULL
           OR importance != 0.5
           OR response_expectation IS NOT NULL
           OR preferred_tone IS NOT NULL`,
-    )
-    .all() as Array<{
-    id: string;
-    relationship: string | null;
-    importance: number;
-    response_expectation: string | null;
-    preferred_tone: string | null;
-  }>;
-
-  const update = raw.prepare(`UPDATE contacts SET notes = ? WHERE id = ?`);
-
-  for (const row of rows) {
-    const parts: string[] = [];
-    if (row.relationship) parts.push(`Relationship: ${row.relationship}`);
-    if (row.importance !== 0.5) parts.push(`Importance: ${row.importance}`);
-    if (row.response_expectation)
-      parts.push(`Response expectation: ${row.response_expectation}`);
-    if (row.preferred_tone) parts.push(`Preferred tone: ${row.preferred_tone}`);
-    if (parts.length > 0) {
-      update.run(parts.join("\n"), row.id);
+      )
+      .all() as Array<{
+      id: string;
+      relationship: string | null;
+      importance: number;
+      response_expectation: string | null;
+      preferred_tone: string | null;
+    }>;
+
+    const update = raw.prepare(`UPDATE contacts SET notes = ? WHERE id = ?`);
+
+    for (const row of rows) {
+      const parts: string[] = [];
+      if (row.relationship) parts.push(`Relationship: ${row.relationship}`);
+      if (row.importance !== 0.5) parts.push(`Importance: ${row.importance}`);
+      if (row.response_expectation)
+        parts.push(`Response expectation: ${row.response_expectation}`);
+      if (row.preferred_tone)
+        parts.push(`Preferred tone: ${row.preferred_tone}`);
+      if (parts.length > 0) {
+        update.run(parts.join("\n"), row.id);
+      }
     }
-  }
 
-  const migrated = rows.length;
-  if (migrated > 0) {
-    log.info({ migrated }, "Migrated contact metadata to notes field");
-  }
+    const migrated = rows.length;
+    if (migrated > 0) {
+      log.info({ migrated }, "Migrated contact metadata to notes field");
+    }
 
-  raw.exec(/*sql*/ `ALTER TABLE contacts DROP COLUMN relationship`);
-  raw.exec(/*sql*/ `ALTER TABLE contacts DROP COLUMN importance`);
-  raw.exec(/*sql*/ `ALTER TABLE contacts DROP COLUMN response_expectation`);
-  raw.exec(/*sql*/ `ALTER TABLE contacts DROP COLUMN preferred_tone`);
+    // Drop indexes that reference columns we're about to remove
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_contacts_importance`);
+
+    raw.exec(/*sql*/ `ALTER TABLE contacts DROP COLUMN relationship`);
+    raw.exec(/*sql*/ `ALTER TABLE contacts DROP COLUMN importance`);
+    raw.exec(/*sql*/ `ALTER TABLE contacts DROP COLUMN response_expectation`);
+    raw.exec(/*sql*/ `ALTER TABLE contacts DROP COLUMN preferred_tone`);
+  }
 }

package/src/memory/migrations/registry.ts

@@ -122,6 +122,12 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
     description:
       "Enforce NOT NULL on channel_guardian_bindings.guardian_principal_id after backfill",
   },
+  {
+    key: "backfill_contact_interaction_stats",
+    version: 17,
+    description:
+      "Backfill contacts.last_interaction from the max lastSeenAt across each contact's channels",
+  },
 ];
 
 export interface MigrationValidationResult {

package/src/memory/recall-cache.ts

@@ -115,8 +115,3 @@ export function setCachedRecall(
 
   _cache.set(key, { version: _version, createdAt: Date.now(), result });
 }
-
-/** Clear the entire cache (useful for testing). */
-export function clearRecallCache(): void {
-  _cache.clear();
-}

package/src/memory/schema/calls.ts

@@ -0,0 +1,274 @@
+import {
+  index,
+  integer,
+  real,
+  sqliteTable,
+  text,
+} from "drizzle-orm/sqlite-core";
+
+import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../runtime/assistant-scope.js";
+import { conversations } from "./conversations.js";
+
+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"),
+    callMode: text("call_mode"),
+    guardianVerificationSessionId: text("guardian_verification_session_id"),
+    callerIdentityMode: text("caller_identity_mode"),
+    callerIdentitySource: text("caller_identity_source"),
+    assistantId: text("assistant_id"),
+    initiatedFromConversationId: text("initiated_from_conversation_id"),
+    startedAt: integer("started_at"),
+    endedAt: integer("ended_at"),
+    lastError: text("last_error"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+  (table) => [index("idx_call_sessions_status").on(table.status)],
+);
+
+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(),
+});
+
+export const externalConversationBindings = sqliteTable(
+  "external_conversation_bindings",
+  {
+    conversationId: text("conversation_id")
+      .primaryKey()
+      .references(() => conversations.id, { onDelete: "cascade" }),
+    sourceChannel: text("source_channel").notNull(),
+    externalChatId: text("external_chat_id").notNull(),
+    externalUserId: text("external_user_id"),
+    displayName: text("display_name"),
+    username: text("username"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    lastInboundAt: integer("last_inbound_at"),
+    lastOutboundAt: integer("last_outbound_at"),
+  },
+);
+
+export const channelGuardianVerificationChallenges = sqliteTable(
+  "channel_guardian_verification_challenges",
+  {
+    id: text("id").primaryKey(),
+    assistantId: text("assistant_id").notNull(),
+    channel: text("channel").notNull(),
+    challengeHash: text("challenge_hash").notNull(),
+    expiresAt: integer("expires_at").notNull(),
+    status: text("status").notNull().default("pending"),
+    createdBySessionId: text("created_by_session_id"),
+    consumedByExternalUserId: text("consumed_by_external_user_id"),
+    consumedByChatId: text("consumed_by_chat_id"),
+    // Outbound session: expected-identity binding
+    expectedExternalUserId: text("expected_external_user_id"),
+    expectedChatId: text("expected_chat_id"),
+    expectedPhoneE164: text("expected_phone_e164"),
+    identityBindingStatus: text("identity_binding_status").default("bound"),
+    // Outbound session: delivery tracking
+    destinationAddress: text("destination_address"),
+    lastSentAt: integer("last_sent_at"),
+    sendCount: integer("send_count").default(0),
+    nextResendAt: integer("next_resend_at"),
+    // Session configuration
+    codeDigits: integer("code_digits").default(6),
+    maxAttempts: integer("max_attempts").default(3),
+    // Distinguishes guardian verification from trusted contact verification
+    verificationPurpose: text("verification_purpose").default("guardian"),
+    // Telegram bootstrap deep-link token hash
+    bootstrapTokenHash: text("bootstrap_token_hash"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);
+
+export const channelGuardianApprovalRequests = sqliteTable(
+  "channel_guardian_approval_requests",
+  {
+    id: text("id").primaryKey(),
+    runId: text("run_id").notNull(),
+    requestId: text("request_id"),
+    conversationId: text("conversation_id").notNull(),
+    assistantId: text("assistant_id")
+      .notNull()
+      .default(DAEMON_INTERNAL_ASSISTANT_ID),
+    channel: text("channel").notNull(),
+    requesterExternalUserId: text("requester_external_user_id").notNull(),
+    requesterChatId: text("requester_chat_id").notNull(),
+    guardianExternalUserId: text("guardian_external_user_id").notNull(),
+    guardianChatId: text("guardian_chat_id").notNull(),
+    toolName: text("tool_name").notNull(),
+    riskLevel: text("risk_level"),
+    reason: text("reason"),
+    status: text("status").notNull().default("pending"),
+    decidedByExternalUserId: text("decided_by_external_user_id"),
+    expiresAt: integer("expires_at").notNull(),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);
+
+export const channelGuardianRateLimits = sqliteTable(
+  "channel_guardian_rate_limits",
+  {
+    id: text("id").primaryKey(),
+    assistantId: text("assistant_id").notNull(),
+    channel: text("channel").notNull(),
+    actorExternalUserId: text("actor_external_user_id").notNull(),
+    actorChatId: text("actor_chat_id").notNull(),
+    // Legacy columns kept with defaults for backward compatibility with upgraded databases
+    // that still have the old NOT NULL columns without DEFAULT. Not read by app logic.
+    invalidAttempts: integer("invalid_attempts").notNull().default(0),
+    windowStartedAt: integer("window_started_at").notNull().default(0),
+    attemptTimestampsJson: text("attempt_timestamps_json")
+      .notNull()
+      .default("[]"),
+    lockedUntil: integer("locked_until"),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+  },
+);
+
+export const mediaAssets = sqliteTable("media_assets", {
+  id: text("id").primaryKey(),
+  title: text("title").notNull(),
+  filePath: text("file_path").notNull(),
+  mimeType: text("mime_type").notNull(),
+  durationSeconds: real("duration_seconds"),
+  fileHash: text("file_hash").notNull(),
+  status: text("status").notNull().default("registered"), // registered | processing | indexed | failed
+  mediaType: text("media_type").notNull(), // video | audio | image
+  metadata: text("metadata"), // JSON
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});
+
+export const processingStages = sqliteTable("processing_stages", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  stage: text("stage").notNull(),
+  status: text("status").notNull().default("pending"), // pending | running | completed | failed
+  progress: integer("progress").notNull().default(0), // 0-100
+  lastError: text("last_error"),
+  startedAt: integer("started_at"),
+  completedAt: integer("completed_at"),
+});
+
+export const mediaKeyframes = sqliteTable("media_keyframes", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  timestamp: real("timestamp").notNull(),
+  filePath: text("file_path").notNull(),
+  metadata: text("metadata"), // JSON
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaVisionOutputs = sqliteTable("media_vision_outputs", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  keyframeId: text("keyframe_id")
+    .notNull()
+    .references(() => mediaKeyframes.id, { onDelete: "cascade" }),
+  analysisType: text("analysis_type").notNull(),
+  output: text("output").notNull(), // JSON
+  confidence: real("confidence"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaTimelines = sqliteTable("media_timelines", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  startTime: real("start_time").notNull(),
+  endTime: real("end_time").notNull(),
+  segmentType: text("segment_type").notNull(),
+  attributes: text("attributes"), // JSON
+  confidence: real("confidence"),
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaEvents = sqliteTable("media_events", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  eventType: text("event_type").notNull(),
+  startTime: real("start_time").notNull(),
+  endTime: real("end_time").notNull(),
+  confidence: real("confidence").notNull(),
+  reasons: text("reasons").notNull(), // JSON array
+  metadata: text("metadata"), // JSON
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaTrackingProfiles = sqliteTable("media_tracking_profiles", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  capabilities: text("capabilities").notNull(), // JSON: { [capName]: { enabled, tier } }
+  createdAt: integer("created_at").notNull(),
+});
+
+export const mediaEventFeedback = sqliteTable("media_event_feedback", {
+  id: text("id").primaryKey(),
+  assetId: text("asset_id")
+    .notNull()
+    .references(() => mediaAssets.id, { onDelete: "cascade" }),
+  eventId: text("event_id")
+    .notNull()
+    .references(() => mediaEvents.id, { onDelete: "cascade" }),
+  feedbackType: text("feedback_type").notNull(), // correct | incorrect | boundary_edit | missed
+  originalStartTime: real("original_start_time"),
+  originalEndTime: real("original_end_time"),
+  correctedStartTime: real("corrected_start_time"),
+  correctedEndTime: real("corrected_end_time"),
+  notes: text("notes"),
+  createdAt: integer("created_at").notNull(),
+});