@holon-run/agentinbox 1.7.1 → 1.8.0

package/dist/src/store.js

@@ -166,6 +166,9 @@ class AgentInboxStore {
     save() {
         this.persist();
     }
+    getDataDirectory() {
+        return node_path_1.default.dirname(this.dbPath);
+    }
     getDatabaseHealth() {
         return {
             quickCheck: String(this.db.pragma("quick_check", { simple: true })),
@@ -347,8 +350,9 @@ class AgentInboxStore {
     inTransaction(fn) {
         this.db.exec("begin");
         try {
-            fn();
+            const result = fn();
             this.db.exec("commit");
+            return result;
         }
         catch (error) {
             this.db.exec("rollback");
@@ -1040,6 +1044,9 @@ class AgentInboxStore {
             this.run("delete from activation_dispatch_states where agent_id = ?", [agentId]);
             this.run("delete from activation_targets where agent_id = ?", [agentId]);
             if (inbox) {
+                this.run("delete from email_body_cache where inbox_id = ?", [inbox.inboxId]);
+                const itemIds = this.getAll("select item_id from inbox_items where inbox_id = ?", [inbox.inboxId]).map((row) => requiredText(row, "item_id"));
+                this.auditAndDeleteEmailAttachmentMaterializations(itemIds, "attachment_parent_deleted");
                 this.run("delete from inbox_items where inbox_id = ?", [inbox.inboxId]);
                 this.run("delete from activations where agent_id = ? or inbox_id = ?", [agentId, inbox.inboxId]);
                 this.run("delete from inboxes where inbox_id = ?", [inbox.inboxId]);
@@ -1295,6 +1302,308 @@ class AgentInboxStore {
         const rows = this.getAll("select * from inbox_entries where entry_id = ?", [(0, util_1.parseEntryRef)(entryId)]);
         return this.mapInboxEntries(rows)[0] ?? null;
     }
+    getInboxEntryForInbox(inboxId, entryId) {
+        const rows = this.getAll("select * from inbox_entries where inbox_id = ? and entry_id = ?", [inboxId, (0, util_1.parseEntryRef)(entryId)]);
+        return this.mapInboxEntries(rows)[0] ?? null;
+    }
+    getInboxItemForInbox(inboxId, itemId) {
+        const row = this.getOne("select * from inbox_items where inbox_id = ? and item_id = ?", [inboxId, itemId]);
+        return row ? this.mapInboxItem(row) : null;
+    }
+    getEmailBodyCache(inboxId, entryId) {
+        const row = this.getOne("select * from email_body_cache where inbox_id = ? and entry_id = ?", [inboxId, (0, util_1.parseEntryRef)(entryId)]);
+        return row ? this.mapEmailBodyCache(row) : null;
+    }
+    getEmailAttachmentMaterialization(itemId, attachmentSelector) {
+        const row = this.getOne(`
+      select *
+      from email_attachment_materializations
+      where item_id = ? and attachment_selector = ?
+      `, [itemId, attachmentSelector]);
+        return row ? this.mapEmailAttachmentMaterialization(row) : null;
+    }
+    appendEmailAttachmentAudit(event) {
+        this.insertEmailAttachmentAudit(event);
+        this.persist();
+    }
+    listEmailAttachmentAuditEvents(attachmentRef) {
+        const rows = attachmentRef
+            ? this.getAll("select * from email_attachment_audit_events where attachment_ref = ? order by created_at asc, audit_id asc", [attachmentRef])
+            : this.getAll("select * from email_attachment_audit_events order by created_at asc, audit_id asc");
+        return rows.map((row) => this.mapEmailAttachmentAuditEvent(row));
+    }
+    beginEmailAttachmentMaterialization(inboxId, record) {
+        const written = this.inTransaction(() => {
+            const itemStillExists = this.getOne("select 1 from inbox_items where inbox_id = ? and item_id = ?", [inboxId, record.itemId]);
+            if (!itemStillExists) {
+                return false;
+            }
+            this.run(`
+        insert into email_attachment_materializations (
+          item_id, attachment_selector, status, last_error_code, object_key,
+          sha256, declared_content_type, detected_content_type, declared_size,
+          stored_size, created_at, updated_at, expires_at, deleted_at
+        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        on conflict(item_id, attachment_selector) do update set
+          status = excluded.status,
+          last_error_code = excluded.last_error_code,
+          object_key = excluded.object_key,
+          sha256 = excluded.sha256,
+          declared_content_type = excluded.declared_content_type,
+          detected_content_type = excluded.detected_content_type,
+          declared_size = excluded.declared_size,
+          stored_size = excluded.stored_size,
+          updated_at = excluded.updated_at,
+          expires_at = excluded.expires_at,
+          deleted_at = excluded.deleted_at
+        `, materializationParams(record));
+            return true;
+        });
+        if (written) {
+            this.persist();
+        }
+        return written;
+    }
+    finishEmailAttachmentMaterialization(inboxId, record) {
+        const written = this.inTransaction(() => {
+            const itemStillExists = this.getOne("select 1 from inbox_items where inbox_id = ? and item_id = ?", [inboxId, record.itemId]);
+            if (!itemStillExists) {
+                return false;
+            }
+            const result = this.run(`
+        update email_attachment_materializations
+        set status = ?, last_error_code = ?, object_key = ?, sha256 = ?,
+            declared_content_type = ?, detected_content_type = ?,
+            declared_size = ?, stored_size = ?, updated_at = ?, expires_at = ?,
+            deleted_at = ?
+        where item_id = ? and attachment_selector = ?
+        `, [
+                record.status,
+                record.lastErrorCode,
+                record.objectKey,
+                record.sha256,
+                record.declaredContentType,
+                record.detectedContentType,
+                record.declaredSize,
+                record.storedSize,
+                record.updatedAt,
+                record.expiresAt,
+                record.deletedAt,
+                record.itemId,
+                record.attachmentSelector,
+            ]);
+            return result.changes > 0;
+        });
+        if (written) {
+            this.persist();
+        }
+        return written;
+    }
+    tombstoneEmailAttachmentMaterialization(inboxId, itemId, attachmentSelector, deletedAt, audit, fallback) {
+        const tombstone = this.inTransaction(() => {
+            const itemStillExists = this.getOne("select 1 from inbox_items where inbox_id = ? and item_id = ?", [inboxId, itemId]);
+            if (!itemStillExists) {
+                return null;
+            }
+            const row = this.getOne(`
+        select *
+        from email_attachment_materializations
+        where item_id = ? and attachment_selector = ?
+        `, [itemId, attachmentSelector]);
+            if (row?.status === "deleted") {
+                return null;
+            }
+            const current = row ? this.mapEmailAttachmentMaterialization(row) : fallback ?? null;
+            if (!current) {
+                return null;
+            }
+            if (row) {
+                this.run(`
+          update email_attachment_materializations
+          set status = 'deleted', last_error_code = ?, object_key = null,
+              updated_at = ?, expires_at = null, deleted_at = ?
+          where item_id = ? and attachment_selector = ?
+          `, [audit.errorCode, deletedAt, deletedAt, itemId, attachmentSelector]);
+            }
+            else {
+                this.run(`
+          insert into email_attachment_materializations (
+            item_id, attachment_selector, status, last_error_code, object_key,
+            sha256, declared_content_type, detected_content_type, declared_size,
+            stored_size, created_at, updated_at, expires_at, deleted_at
+          ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `, materializationParams({
+                    ...current,
+                    status: "deleted",
+                    lastErrorCode: audit.errorCode,
+                    objectKey: null,
+                    updatedAt: deletedAt,
+                    expiresAt: null,
+                    deletedAt,
+                }));
+            }
+            this.insertEmailAttachmentAudit(audit);
+            return current;
+        });
+        if (tombstone) {
+            this.persist();
+        }
+        return tombstone;
+    }
+    listExpiredEmailAttachmentMaterializations(cutoffIso, limit) {
+        return this.getAll(`
+      select m.*, i.inbox_id, i.source_id, b.owner_agent_id
+      from email_attachment_materializations m
+      join inbox_items i on i.item_id = m.item_id
+      join inboxes b on b.inbox_id = i.inbox_id
+      where m.status in ('available', 'quarantined')
+        and m.expires_at is not null
+        and m.expires_at <= ?
+      order by m.expires_at asc, m.updated_at asc
+      limit ?
+      `, [cutoffIso, limit]).map((row) => ({
+            materialization: this.mapEmailAttachmentMaterialization(row),
+            inboxId: requiredText(row, "inbox_id"),
+            agentId: requiredText(row, "owner_agent_id"),
+            sourceId: requiredText(row, "source_id"),
+        }));
+    }
+    listEmailAttachmentMaterializationsForObject(objectKey) {
+        return this.getAll(`
+      select m.*, i.inbox_id, i.source_id, b.owner_agent_id
+      from email_attachment_materializations m
+      join inbox_items i on i.item_id = m.item_id
+      join inboxes b on b.inbox_id = i.inbox_id
+      where m.object_key = ? and m.status in ('available', 'quarantined')
+      order by m.updated_at asc
+      `, [objectKey]).map((row) => ({
+            materialization: this.mapEmailAttachmentMaterialization(row),
+            inboxId: requiredText(row, "inbox_id"),
+            agentId: requiredText(row, "owner_agent_id"),
+            sourceId: requiredText(row, "source_id"),
+        }));
+    }
+    listOldestEmailAttachmentObjects(limit) {
+        return this.getAll(`
+      select object_key, max(stored_size) as stored_size
+      from email_attachment_materializations
+      where status in ('available', 'quarantined')
+        and object_key is not null
+        and stored_size is not null
+      group by object_key
+      order by min(updated_at) asc, object_key asc
+      limit ?
+      `, [limit]).map((row) => ({
+            objectKey: requiredText(row, "object_key"),
+            storedSize: Number(row.stored_size),
+        }));
+    }
+    sumManagedEmailAttachmentBytes() {
+        const row = this.getOne(`
+      select coalesce(sum(stored_size), 0) as total
+      from (
+        select max(stored_size) as stored_size
+        from email_attachment_materializations
+        where status in ('available', 'quarantined')
+          and object_key is not null
+          and stored_size is not null
+        group by object_key
+      )
+      `);
+        return Number(row?.total ?? 0);
+    }
+    countEmailAttachmentObjectReferences(objectKey) {
+        const row = this.getOne(`
+      select count(*) as count
+      from email_attachment_materializations
+      where object_key = ? and status in ('available', 'quarantined')
+      `, [objectKey]);
+        return Number(row?.count ?? 0);
+    }
+    listReferencedEmailAttachmentObjectKeys() {
+        return this.getAll(`
+      select distinct object_key
+      from email_attachment_materializations
+      where object_key is not null and status in ('available', 'quarantined')
+      `).map((row) => requiredText(row, "object_key"));
+    }
+    sumAvailableEmailAttachmentBytes(itemId, excludeAttachmentSelector) {
+        const row = this.getOne(`
+      select coalesce(sum(stored_size), 0) as total
+      from email_attachment_materializations
+      where item_id = ? and status = 'available'
+        ${excludeAttachmentSelector ? "and attachment_selector <> ?" : ""}
+      `, excludeAttachmentSelector ? [itemId, excludeAttachmentSelector] : [itemId]);
+        return Number(row?.total ?? 0);
+    }
+    putEmailBodyCache(record, maxTotalBytes) {
+        this.inTransaction(() => {
+            const entryStillExists = this.getOne(`
+        select 1
+        from inbox_entries e
+        join inbox_entry_items ei on ei.entry_id = e.entry_id
+        join inbox_items i on i.item_id = ei.item_id
+        where e.entry_id = ?
+          and e.inbox_id = ?
+          and ei.item_id = ?
+          and i.source_id = ?
+        limit 1
+        `, [(0, util_1.parseEntryRef)(record.entryId), record.inboxId, record.itemId, record.sourceId]);
+            if (!entryStillExists) {
+                return;
+            }
+            this.run(`
+        insert into email_body_cache (
+          entry_id, inbox_id, item_id, source_id, content_version, schema_version,
+          parser_version, text, bytes, completeness, reasons_json, created_at,
+          expires_at, last_accessed_at
+        ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        on conflict(entry_id) do update set
+          inbox_id = excluded.inbox_id,
+          item_id = excluded.item_id,
+          source_id = excluded.source_id,
+          content_version = excluded.content_version,
+          schema_version = excluded.schema_version,
+          parser_version = excluded.parser_version,
+          text = excluded.text,
+          bytes = excluded.bytes,
+          completeness = excluded.completeness,
+          reasons_json = excluded.reasons_json,
+          created_at = excluded.created_at,
+          expires_at = excluded.expires_at,
+          last_accessed_at = excluded.last_accessed_at
+        `, [
+                (0, util_1.parseEntryRef)(record.entryId),
+                record.inboxId,
+                record.itemId,
+                record.sourceId,
+                record.contentVersion,
+                record.schemaVersion,
+                record.parserVersion,
+                record.text,
+                record.bytes,
+                record.completeness,
+                JSON.stringify(record.reasons),
+                record.createdAt,
+                record.expiresAt,
+                record.lastAccessedAt,
+            ]);
+            this.deleteExpiredEmailBodyCache(record.lastAccessedAt, false);
+            this.evictEmailBodyCacheToLimit(maxTotalBytes);
+        });
+        this.persist();
+    }
+    touchEmailBodyCache(entryId, accessedAt) {
+        this.run("update email_body_cache set last_accessed_at = ? where entry_id = ?", [accessedAt, (0, util_1.parseEntryRef)(entryId)]);
+        this.persist();
+    }
+    deleteExpiredEmailBodyCache(now, persist = true) {
+        const result = this.run("delete from email_body_cache where expires_at <= ?", [now]);
+        if (persist && result.changes > 0) {
+            this.persist();
+        }
+        return result.changes;
+    }
     ackInboxEntries(inboxId, entryIds, ackedAt) {
         const resolvedIds = uniqueSorted(entryIds).map((entryId) => this.resolveInboxEntryId(inboxId, entryId));
         const itemIds = this.getRawItemIdsForEntryIds(resolvedIds);
@@ -2094,6 +2403,79 @@ class AgentInboxStore {
             ackedAt: row.acked_at ? String(row.acked_at) : null,
         };
     }
+    mapEmailBodyCache(row) {
+        return {
+            entryId: (0, util_1.formatEntryRef)(requiredText(row, "entry_id")),
+            inboxId: requiredText(row, "inbox_id"),
+            itemId: requiredText(row, "item_id"),
+            sourceId: requiredText(row, "source_id"),
+            contentVersion: requiredText(row, "content_version"),
+            schemaVersion: Number(row.schema_version),
+            parserVersion: requiredText(row, "parser_version"),
+            text: requiredText(row, "text"),
+            bytes: Number(row.bytes),
+            completeness: requiredText(row, "completeness"),
+            reasons: parseJson(row.reasons_json),
+            createdAt: requiredText(row, "created_at"),
+            expiresAt: requiredText(row, "expires_at"),
+            lastAccessedAt: requiredText(row, "last_accessed_at"),
+        };
+    }
+    mapEmailAttachmentMaterialization(row) {
+        return {
+            itemId: requiredText(row, "item_id"),
+            attachmentSelector: requiredText(row, "attachment_selector"),
+            status: requiredText(row, "status"),
+            lastErrorCode: row.last_error_code ? String(row.last_error_code) : null,
+            objectKey: row.object_key ? String(row.object_key) : null,
+            sha256: row.sha256 ? String(row.sha256) : null,
+            declaredContentType: row.declared_content_type ? String(row.declared_content_type) : null,
+            detectedContentType: row.detected_content_type ? String(row.detected_content_type) : null,
+            declaredSize: row.declared_size == null ? null : Number(row.declared_size),
+            storedSize: row.stored_size == null ? null : Number(row.stored_size),
+            createdAt: requiredText(row, "created_at"),
+            updatedAt: requiredText(row, "updated_at"),
+            expiresAt: row.expires_at ? String(row.expires_at) : null,
+            deletedAt: row.deleted_at ? String(row.deleted_at) : null,
+        };
+    }
+    mapEmailAttachmentAuditEvent(row) {
+        return {
+            auditId: requiredText(row, "audit_id"),
+            attachmentRef: requiredText(row, "attachment_ref"),
+            claimedAgentId: requiredText(row, "claimed_agent_id"),
+            inboxId: row.inbox_id ? String(row.inbox_id) : null,
+            itemId: row.item_id ? String(row.item_id) : null,
+            sourceId: row.source_id ? String(row.source_id) : null,
+            action: requiredText(row, "action"),
+            result: requiredText(row, "result"),
+            errorCode: row.error_code ? String(row.error_code) : null,
+            bytes: row.bytes == null ? null : Number(row.bytes),
+            sha256: row.sha256 ? String(row.sha256) : null,
+            createdAt: requiredText(row, "created_at"),
+        };
+    }
+    insertEmailAttachmentAudit(event) {
+        this.run(`
+      insert into email_attachment_audit_events (
+        audit_id, attachment_ref, claimed_agent_id, inbox_id, item_id, source_id,
+        action, result, error_code, bytes, sha256, created_at
+      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `, [
+            event.auditId,
+            event.attachmentRef,
+            event.claimedAgentId,
+            event.inboxId,
+            event.itemId,
+            event.sourceId,
+            event.action,
+            event.result,
+            event.errorCode,
+            event.bytes,
+            event.sha256,
+            event.createdAt,
+        ]);
+    }
     mapInboxEntry(row, itemIds) {
         const base = {
             entryId: (0, util_1.formatEntryRef)(requiredText(row, "entry_id")),
@@ -2323,6 +2705,20 @@ class AgentInboxStore {
         const itemIdsByEntry = this.listEntryItemIdsBulk(rows.map((row) => String(row.entry_id)));
         return rows.map((row) => this.mapInboxEntry(row, itemIdsByEntry.get(String(row.entry_id)) ?? []));
     }
+    evictEmailBodyCacheToLimit(maxTotalBytes) {
+        let total = Number(this.getOne("select coalesce(sum(bytes), 0) as total from email_body_cache")?.total ?? 0);
+        if (total <= maxTotalBytes) {
+            return;
+        }
+        const rows = this.getAll("select entry_id, bytes from email_body_cache order by last_accessed_at asc, created_at asc, entry_id asc");
+        for (const row of rows) {
+            if (total <= maxTotalBytes) {
+                break;
+            }
+            this.run("delete from email_body_cache where entry_id = ?", [String(row.entry_id)]);
+            total -= Number(row.bytes);
+        }
+    }
     syncInboxEntryAckState(inboxId, ackedAt) {
         this.run(`
       update inbox_entries
@@ -2350,6 +2746,8 @@ class AgentInboxStore {
     deleteInboxItemsAndEntryArtifacts(itemIds) {
         const placeholders = itemIds.map(() => "?").join(", ");
         this.inTransaction(() => {
+            this.run(`delete from email_body_cache where item_id in (${placeholders})`, itemIds);
+            this.auditAndDeleteEmailAttachmentMaterializations(itemIds, "attachment_parent_deleted");
             this.run(`delete from digest_thread_items where item_id in (${placeholders})`, itemIds);
             this.run(`delete from inbox_items where item_id in (${placeholders})`, itemIds);
             this.run(`
@@ -2408,6 +2806,40 @@ class AgentInboxStore {
         });
         this.persist();
     }
+    auditAndDeleteEmailAttachmentMaterializations(itemIds, errorCode) {
+        if (itemIds.length === 0) {
+            return;
+        }
+        const placeholders = itemIds.map(() => "?").join(", ");
+        const rows = this.getAll(`
+      select m.item_id, m.attachment_selector, m.stored_size, m.sha256,
+             i.inbox_id, i.source_id, b.owner_agent_id
+      from email_attachment_materializations m
+      join inbox_items i on i.item_id = m.item_id
+      join inboxes b on b.inbox_id = i.inbox_id
+      where m.item_id in (${placeholders})
+      `, itemIds);
+        const createdAt = (0, util_1.nowIso)();
+        for (const row of rows) {
+            const itemId = requiredText(row, "item_id");
+            const attachmentSelector = requiredText(row, "attachment_selector");
+            this.insertEmailAttachmentAudit({
+                auditId: (0, util_1.generateCanonicalId)("aat"),
+                attachmentRef: `att_v1.${itemId}.${attachmentSelector}`,
+                claimedAgentId: requiredText(row, "owner_agent_id"),
+                inboxId: requiredText(row, "inbox_id"),
+                itemId,
+                sourceId: requiredText(row, "source_id"),
+                action: "gc",
+                result: "deleted",
+                errorCode,
+                bytes: row.stored_size == null ? null : Number(row.stored_size),
+                sha256: row.sha256 ? String(row.sha256) : null,
+                createdAt,
+            });
+        }
+        this.run(`delete from email_attachment_materializations where item_id in (${placeholders})`, itemIds);
+    }
     mapStream(row) {
         return {
             streamId: String(row.stream_id),
@@ -2453,6 +2885,24 @@ class AgentInboxStore {
     }
 }
 exports.AgentInboxStore = AgentInboxStore;
+function materializationParams(record) {
+    return [
+        record.itemId,
+        record.attachmentSelector,
+        record.status,
+        record.lastErrorCode,
+        record.objectKey,
+        record.sha256,
+        record.declaredContentType,
+        record.detectedContentType,
+        record.declaredSize,
+        record.storedSize,
+        record.createdAt,
+        record.updatedAt,
+        record.expiresAt,
+        record.deletedAt,
+    ];
+}
 function requiredText(row, key) {
     const value = row[key];
     if (value == null) {

package/drizzle/migrations/0006_email_body_cache.sql

@@ -0,0 +1,19 @@
+CREATE TABLE `email_body_cache` (
+  `entry_id` text PRIMARY KEY NOT NULL,
+  `inbox_id` text NOT NULL,
+  `item_id` text NOT NULL,
+  `source_id` text NOT NULL,
+  `content_version` text NOT NULL,
+  `schema_version` integer NOT NULL,
+  `parser_version` text NOT NULL,
+  `text` text NOT NULL,
+  `bytes` integer NOT NULL,
+  `completeness` text NOT NULL,
+  `reasons_json` text NOT NULL,
+  `created_at` text NOT NULL,
+  `expires_at` text NOT NULL,
+  `last_accessed_at` text NOT NULL
+);
+CREATE INDEX `idx_email_body_cache_inbox_entry` ON `email_body_cache` (`inbox_id`,`entry_id`);
+CREATE INDEX `idx_email_body_cache_expiry` ON `email_body_cache` (`expires_at`);
+CREATE INDEX `idx_email_body_cache_access` ON `email_body_cache` (`last_accessed_at`);

package/drizzle/migrations/0007_email_attachment_materializations.sql

@@ -0,0 +1,20 @@
+CREATE TABLE `email_attachment_materializations` (
+  `item_id` text NOT NULL,
+  `attachment_selector` text NOT NULL,
+  `status` text NOT NULL,
+  `last_error_code` text,
+  `object_key` text,
+  `sha256` text,
+  `declared_content_type` text,
+  `detected_content_type` text,
+  `declared_size` integer,
+  `stored_size` integer,
+  `created_at` text NOT NULL,
+  `updated_at` text NOT NULL,
+  `expires_at` text,
+  `deleted_at` text,
+  PRIMARY KEY (`item_id`, `attachment_selector`)
+);
+CREATE INDEX `idx_email_attachment_materializations_object` ON `email_attachment_materializations` (`object_key`);
+CREATE INDEX `idx_email_attachment_materializations_status` ON `email_attachment_materializations` (`status`,`updated_at`);
+CREATE INDEX `idx_email_attachment_materializations_expiry` ON `email_attachment_materializations` (`expires_at`);

package/drizzle/migrations/0008_email_attachment_audit.sql

@@ -0,0 +1,17 @@
+CREATE TABLE `email_attachment_audit_events` (
+  `audit_id` text PRIMARY KEY NOT NULL,
+  `attachment_ref` text NOT NULL,
+  `claimed_agent_id` text NOT NULL,
+  `inbox_id` text,
+  `item_id` text,
+  `source_id` text,
+  `action` text NOT NULL,
+  `result` text NOT NULL,
+  `error_code` text,
+  `bytes` integer,
+  `sha256` text,
+  `created_at` text NOT NULL
+);
+CREATE INDEX `idx_email_attachment_audit_attachment` ON `email_attachment_audit_events` (`attachment_ref`,`created_at`);
+CREATE INDEX `idx_email_attachment_audit_item` ON `email_attachment_audit_events` (`item_id`,`created_at`);
+CREATE INDEX `idx_email_attachment_audit_created` ON `email_attachment_audit_events` (`created_at`);

package/drizzle/schema.ts

@@ -243,6 +243,68 @@ export const inboxEntryItems = sqliteTable("inbox_entry_items", {
   itemIdx: index("idx_inbox_entry_items_item").on(table.itemId),
 }));
 
+export const emailBodyCache = sqliteTable("email_body_cache", {
+  entryId: text("entry_id").primaryKey(),
+  inboxId: text("inbox_id").notNull(),
+  itemId: text("item_id").notNull(),
+  sourceId: text("source_id").notNull(),
+  contentVersion: text("content_version").notNull(),
+  schemaVersion: integer("schema_version").notNull(),
+  parserVersion: text("parser_version").notNull(),
+  text: text("text").notNull(),
+  bytes: integer("bytes").notNull(),
+  completeness: text("completeness").notNull(),
+  reasonsJson: text("reasons_json").notNull(),
+  createdAt: text("created_at").notNull(),
+  expiresAt: text("expires_at").notNull(),
+  lastAccessedAt: text("last_accessed_at").notNull(),
+}, (table) => ({
+  inboxEntryIdx: index("idx_email_body_cache_inbox_entry").on(table.inboxId, table.entryId),
+  expiryIdx: index("idx_email_body_cache_expiry").on(table.expiresAt),
+  accessIdx: index("idx_email_body_cache_access").on(table.lastAccessedAt),
+}));
+
+export const emailAttachmentMaterializations = sqliteTable("email_attachment_materializations", {
+  itemId: text("item_id").notNull(),
+  attachmentSelector: text("attachment_selector").notNull(),
+  status: text("status").notNull(),
+  lastErrorCode: text("last_error_code"),
+  objectKey: text("object_key"),
+  sha256: text("sha256"),
+  declaredContentType: text("declared_content_type"),
+  detectedContentType: text("detected_content_type"),
+  declaredSize: integer("declared_size"),
+  storedSize: integer("stored_size"),
+  createdAt: text("created_at").notNull(),
+  updatedAt: text("updated_at").notNull(),
+  expiresAt: text("expires_at"),
+  deletedAt: text("deleted_at"),
+}, (table) => ({
+  pk: primaryKey({ columns: [table.itemId, table.attachmentSelector] }),
+  objectIdx: index("idx_email_attachment_materializations_object").on(table.objectKey),
+  statusIdx: index("idx_email_attachment_materializations_status").on(table.status, table.updatedAt),
+  expiryIdx: index("idx_email_attachment_materializations_expiry").on(table.expiresAt),
+}));
+
+export const emailAttachmentAuditEvents = sqliteTable("email_attachment_audit_events", {
+  auditId: text("audit_id").primaryKey(),
+  attachmentRef: text("attachment_ref").notNull(),
+  claimedAgentId: text("claimed_agent_id").notNull(),
+  inboxId: text("inbox_id"),
+  itemId: text("item_id"),
+  sourceId: text("source_id"),
+  action: text("action").notNull(),
+  result: text("result").notNull(),
+  errorCode: text("error_code"),
+  bytes: integer("bytes"),
+  sha256: text("sha256"),
+  createdAt: text("created_at").notNull(),
+}, (table) => ({
+  attachmentIdx: index("idx_email_attachment_audit_attachment").on(table.attachmentRef, table.createdAt),
+  itemIdx: index("idx_email_attachment_audit_item").on(table.itemId, table.createdAt),
+  createdIdx: index("idx_email_attachment_audit_created").on(table.createdAt),
+}));
+
 export const digestThreadItems = sqliteTable("digest_thread_items", {
   threadId: text("thread_id").notNull(),
   itemId: text("item_id").notNull(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holon-run/agentinbox",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Local event subscription and delivery service for agents.",
   "license": "Apache-2.0",
   "repository": {
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@fastify/swagger": "^9.5.2",
-    "@holon-run/uxc-daemon-client": "^0.15.8",
+    "@holon-run/uxc-daemon-client": "^0.21.1",
     "better-sqlite3": "^12.10.0",
     "commander": "^14.0.3",
     "fastify": "^5.6.1",