@haaaiawd/second-nature 0.1.21 → 0.1.23

package/runtime/observability/db/schema/connector-inventory.d.ts

@@ -0,0 +1,174 @@
+export declare const connectorInventoryAudit: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "connector_inventory_audit";
+    schema: undefined;
+    columns: {
+        auditId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "audit_id";
+            tableName: "connector_inventory_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        snapshotId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "snapshot_id";
+            tableName: "connector_inventory_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        scanned: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scanned";
+            tableName: "connector_inventory_audit";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        registered: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "registered";
+            tableName: "connector_inventory_audit";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        skipped: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "skipped";
+            tableName: "connector_inventory_audit";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        conflictsJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "conflicts_json";
+            tableName: "connector_inventory_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        validationErrorsJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "validation_errors_json";
+            tableName: "connector_inventory_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        trustSummaryJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "trust_summary_json";
+            tableName: "connector_inventory_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "connector_inventory_audit";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type ConnectorInventoryAuditRow = typeof connectorInventoryAudit.$inferSelect;
+export type NewConnectorInventoryAuditRow = typeof connectorInventoryAudit.$inferInsert;

package/runtime/observability/db/schema/connector-inventory.js

@@ -0,0 +1,15 @@
+import { index, sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+export const connectorInventoryAudit = sqliteTable("connector_inventory_audit", {
+    auditId: text("audit_id").primaryKey(),
+    snapshotId: text("snapshot_id").notNull(),
+    scanned: integer("scanned").notNull(),
+    registered: integer("registered").notNull(),
+    skipped: integer("skipped").notNull(),
+    conflictsJson: text("conflicts_json").notNull(),
+    validationErrorsJson: text("validation_errors_json").notNull(),
+    trustSummaryJson: text("trust_summary_json").notNull(),
+    createdAt: text("created_at").notNull(),
+}, (table) => [
+    index("connector_inventory_snapshot_idx").on(table.snapshotId),
+    index("connector_inventory_created_at_idx").on(table.createdAt),
+]);

package/runtime/observability/db/schema/index.d.ts

@@ -945,3 +945,4 @@ export type NewGovernanceAuditDb = typeof governanceAudit.$inferInsert;
 export type RedactionManifestDb = typeof redactionManifest.$inferSelect;
 export type NewRedactionManifestDb = typeof redactionManifest.$inferInsert;
 export { hostCapabilityReports, type HostCapabilityReportRow, type NewHostCapabilityReportRow, } from "./host-capability-reports.js";
+export { connectorInventoryAudit, type ConnectorInventoryAuditRow, type NewConnectorInventoryAuditRow, } from "./connector-inventory.js";

package/runtime/observability/db/schema/index.js

@@ -69,3 +69,4 @@ export const redactionManifest = sqliteTable("redaction_manifest", {
     index("redact_event_idx").on(table.eventId),
 ]);
 export { hostCapabilityReports, } from "./host-capability-reports.js";
+export { connectorInventoryAudit, } from "./connector-inventory.js";

package/runtime/storage/chronicle/session-chronicle-store.d.ts

@@ -0,0 +1,42 @@
+import type { StateDatabase } from "../db/index.js";
+export type ChronicleEventKind = "heartbeat" | "connector_action" | "outreach" | "owner_reply" | "dream_run" | "maintenance";
+export interface SourceRef {
+    sourceId: string;
+    kind: string;
+    url?: string;
+    snippet?: string;
+}
+export interface OwnerReplySignal {
+    tone?: string;
+    delayMinutes?: number;
+    topics?: string[];
+    explicitPreference?: string;
+}
+export interface SessionChronicleEntry {
+    entryId: string;
+    eventKind: ChronicleEventKind;
+    actor: "agent" | "owner" | "system";
+    occurredAt: string;
+    summary: string;
+    result: "succeeded" | "failed" | "skipped" | "no_reply" | "partial";
+    sourceRefs: SourceRef[];
+    relatedDecisionId?: string;
+    relatedDreamRunId?: string;
+    ownerReply?: OwnerReplySignal;
+}
+export interface ChronicleQuery {
+    eventKinds?: ChronicleEventKind[];
+    from?: string;
+    to?: string;
+    actor?: "agent" | "owner" | "system";
+    limit?: number;
+}
+export interface ChronicleWriteAck {
+    entryId: string;
+    status: "acknowledged" | "degraded";
+}
+export interface SessionChronicleStore {
+    appendSessionChronicle(entry: SessionChronicleEntry): Promise<ChronicleWriteAck>;
+    loadSessionChronicle(query: ChronicleQuery): Promise<SessionChronicleEntry[]>;
+}
+export declare function createSessionChronicleStore(database: StateDatabase): SessionChronicleStore;

package/runtime/storage/chronicle/session-chronicle-store.js

@@ -0,0 +1,66 @@
+import { eq, gte, lte, inArray, desc, and } from "drizzle-orm";
+import { sessionChronicle } from "../db/schema/session-chronicle.js";
+function rowToEntry(row) {
+    return {
+        entryId: row.entryId,
+        eventKind: row.eventKind,
+        actor: row.actor,
+        occurredAt: row.occurredAt,
+        summary: row.summary,
+        result: row.result,
+        sourceRefs: safeParseJson(row.sourceRefsJson, []),
+        relatedDecisionId: row.relatedDecisionId ?? undefined,
+        relatedDreamRunId: row.relatedDreamRunId ?? undefined,
+        ownerReply: row.ownerReplyJson ? safeParseJson(row.ownerReplyJson, undefined) : undefined,
+    };
+}
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function createSessionChronicleStore(database) {
+    const db = database.db;
+    return {
+        async appendSessionChronicle(entry) {
+            await db.insert(sessionChronicle).values({
+                entryId: entry.entryId,
+                eventKind: entry.eventKind,
+                actor: entry.actor,
+                occurredAt: entry.occurredAt,
+                summary: entry.summary,
+                result: entry.result,
+                sourceRefsJson: JSON.stringify(entry.sourceRefs),
+                relatedDecisionId: entry.relatedDecisionId ?? null,
+                relatedDreamRunId: entry.relatedDreamRunId ?? null,
+                ownerReplyJson: entry.ownerReply ? JSON.stringify(entry.ownerReply) : null,
+            });
+            return { entryId: entry.entryId, status: "acknowledged" };
+        },
+        async loadSessionChronicle(query) {
+            const conditions = [];
+            if (query.eventKinds && query.eventKinds.length > 0) {
+                conditions.push(inArray(sessionChronicle.eventKind, query.eventKinds));
+            }
+            if (query.from) {
+                conditions.push(gte(sessionChronicle.occurredAt, query.from));
+            }
+            if (query.to) {
+                conditions.push(lte(sessionChronicle.occurredAt, query.to));
+            }
+            if (query.actor) {
+                conditions.push(eq(sessionChronicle.actor, query.actor));
+            }
+            const rows = await db
+                .select()
+                .from(sessionChronicle)
+                .where(conditions.length > 0 ? and(...conditions) : undefined)
+                .orderBy(desc(sessionChronicle.occurredAt))
+                .limit(query.limit ?? 100);
+            return rows.map(rowToEntry);
+        },
+    };
+}

package/runtime/storage/db/index.js

@@ -99,6 +99,81 @@ const STATE_SCHEMA_SQL = `
     created_at TEXT NOT NULL
   );
   CREATE INDEX IF NOT EXISTS operator_fallback_decision_idx ON operator_fallback_artifacts(decision_id);
+  CREATE TABLE IF NOT EXISTS session_chronicle (
+    entry_id TEXT PRIMARY KEY,
+    event_kind TEXT NOT NULL,
+    actor TEXT NOT NULL,
+    occurred_at TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    result TEXT NOT NULL,
+    source_refs_json TEXT NOT NULL,
+    related_decision_id TEXT,
+    related_dream_run_id TEXT,
+    owner_reply_json TEXT
+  );
+  CREATE INDEX IF NOT EXISTS session_chronicle_event_kind_idx ON session_chronicle(event_kind);
+  CREATE INDEX IF NOT EXISTS session_chronicle_occurred_at_idx ON session_chronicle(occurred_at);
+  CREATE INDEX IF NOT EXISTS session_chronicle_actor_idx ON session_chronicle(actor);
+  CREATE INDEX IF NOT EXISTS session_chronicle_decision_idx ON session_chronicle(related_decision_id);
+  CREATE TABLE IF NOT EXISTS narrative_state (
+    narrative_id TEXT PRIMARY KEY,
+    revision INTEGER NOT NULL DEFAULT 1,
+    focus TEXT NOT NULL,
+    progress_json TEXT NOT NULL,
+    next_intent TEXT NOT NULL,
+    confidence INTEGER NOT NULL DEFAULT 0,
+    source_refs_json TEXT NOT NULL,
+    unsupported_claims_json TEXT NOT NULL,
+    status TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS narrative_state_status_idx ON narrative_state(status);
+  CREATE INDEX IF NOT EXISTS narrative_state_updated_at_idx ON narrative_state(updated_at);
+  CREATE TABLE IF NOT EXISTS relationship_memory (
+    relationship_id TEXT PRIMARY KEY,
+    revision INTEGER NOT NULL DEFAULT 1,
+    tone_preference TEXT NOT NULL,
+    average_reply_delay_minutes INTEGER,
+    no_reply_count INTEGER NOT NULL DEFAULT 0,
+    topic_affinities_json TEXT NOT NULL,
+    last_interaction_at TEXT,
+    source_refs_json TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS relationship_memory_updated_at_idx ON relationship_memory(updated_at);
+  CREATE TABLE IF NOT EXISTS agent_goal (
+    goal_id TEXT PRIMARY KEY,
+    kind TEXT NOT NULL,
+    status TEXT NOT NULL,
+    origin TEXT NOT NULL,
+    description TEXT NOT NULL,
+    completion_criteria TEXT NOT NULL,
+    risk TEXT NOT NULL,
+    priority_hint INTEGER NOT NULL DEFAULT 0,
+    source_refs_json TEXT NOT NULL,
+    accepted_by TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS agent_goal_status_idx ON agent_goal(status);
+  CREATE INDEX IF NOT EXISTS agent_goal_origin_idx ON agent_goal(origin);
+  CREATE INDEX IF NOT EXISTS agent_goal_updated_at_idx ON agent_goal(updated_at);
+  CREATE TABLE IF NOT EXISTS memory_store (
+    memory_store_id TEXT PRIMARY KEY,
+    lifecycle_status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    input_memory_store_id TEXT,
+    dream_run_id TEXT,
+    canonical_entries_json TEXT NOT NULL,
+    insights_json TEXT NOT NULL,
+    narrative_snapshot_json TEXT,
+    relationship_snapshot_json TEXT,
+    validation_json TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS memory_store_lifecycle_idx ON memory_store(lifecycle_status);
+  CREATE INDEX IF NOT EXISTS memory_store_created_at_idx ON memory_store(created_at);
+  CREATE INDEX IF NOT EXISTS memory_store_input_idx ON memory_store(input_memory_store_id);
+  CREATE INDEX IF NOT EXISTS memory_store_dream_run_idx ON memory_store(dream_run_id);
 `;
 function resolveDbPath(filename) {
     if (path.isAbsolute(filename) || filename === ":memory:") {

package/runtime/storage/db/schema/agent-goal.d.ts

@@ -0,0 +1,235 @@
+export declare const agentGoal: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "agent_goal";
+    schema: undefined;
+    columns: {
+        goalId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "goal_id";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        kind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "kind";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        origin: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "origin";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        description: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "description";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        completionCriteria: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "completion_criteria";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        risk: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "risk";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        priorityHint: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "priority_hint";
+            tableName: "agent_goal";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sourceRefsJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_refs_json";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        acceptedBy: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "accepted_by";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "agent_goal";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type AgentGoalRow = typeof agentGoal.$inferSelect;
+export type NewAgentGoalRow = typeof agentGoal.$inferInsert;

package/runtime/storage/db/schema/agent-goal.js

@@ -0,0 +1,19 @@
+import { index, sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+export const agentGoal = sqliteTable("agent_goal", {
+    goalId: text("goal_id").primaryKey(),
+    kind: text("kind").notNull(),
+    status: text("status").notNull(),
+    origin: text("origin").notNull(),
+    description: text("description").notNull(),
+    completionCriteria: text("completion_criteria").notNull(),
+    risk: text("risk").notNull(),
+    priorityHint: integer("priority_hint").notNull().default(0),
+    sourceRefsJson: text("source_refs_json").notNull(),
+    acceptedBy: text("accepted_by"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+}, (table) => [
+    index("agent_goal_status_idx").on(table.status),
+    index("agent_goal_origin_idx").on(table.origin),
+    index("agent_goal_updated_at_idx").on(table.updatedAt),
+]);

package/runtime/storage/db/schema/index.d.ts

@@ -7,3 +7,8 @@ export * from "./proposals.js";
 export * from "./provenance.js";
 export * from "./delivery-attempts.js";
 export * from "./operator-fallback-artifacts.js";
+export * from "./session-chronicle.js";
+export * from "./narrative-state.js";
+export * from "./relationship-memory.js";
+export * from "./agent-goal.js";
+export * from "./memory-store.js";

package/runtime/storage/db/schema/index.js

@@ -7,3 +7,8 @@ export * from "./proposals.js";
 export * from "./provenance.js";
 export * from "./delivery-attempts.js";
 export * from "./operator-fallback-artifacts.js";
+export * from "./session-chronicle.js";
+export * from "./narrative-state.js";
+export * from "./relationship-memory.js";
+export * from "./agent-goal.js";
+export * from "./memory-store.js";