@haaaiawd/second-nature 0.1.22 → 0.1.23

package/runtime/storage/db/schema/session-chronicle.d.ts

@@ -0,0 +1,199 @@
+export declare const sessionChronicle: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "session_chronicle";
+    schema: undefined;
+    columns: {
+        entryId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "entry_id";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        eventKind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "event_kind";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        actor: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "actor";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        occurredAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "occurred_at";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        summary: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "summary";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        result: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "result";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        sourceRefsJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_refs_json";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        relatedDecisionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "related_decision_id";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        relatedDreamRunId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "related_dream_run_id";
+            tableName: "session_chronicle";
+            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;
+        }>;
+        ownerReplyJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "owner_reply_json";
+            tableName: "session_chronicle";
+            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;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type SessionChronicleRow = typeof sessionChronicle.$inferSelect;
+export type NewSessionChronicleRow = typeof sessionChronicle.$inferInsert;

package/runtime/storage/db/schema/session-chronicle.js

@@ -0,0 +1,18 @@
+import { index, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const sessionChronicle = sqliteTable("session_chronicle", {
+    entryId: text("entry_id").primaryKey(),
+    eventKind: text("event_kind").notNull(),
+    actor: text("actor").notNull(),
+    occurredAt: text("occurred_at").notNull(),
+    summary: text("summary").notNull(),
+    result: text("result").notNull(),
+    sourceRefsJson: text("source_refs_json").notNull(),
+    relatedDecisionId: text("related_decision_id"),
+    relatedDreamRunId: text("related_dream_run_id"),
+    ownerReplyJson: text("owner_reply_json"),
+}, (table) => [
+    index("session_chronicle_event_kind_idx").on(table.eventKind),
+    index("session_chronicle_occurred_at_idx").on(table.occurredAt),
+    index("session_chronicle_actor_idx").on(table.actor),
+    index("session_chronicle_decision_idx").on(table.relatedDecisionId),
+]);

package/runtime/storage/goal/agent-goal-store.d.ts

@@ -0,0 +1,57 @@
+import type { StateDatabase } from "../db/index.js";
+export interface SourceRef {
+    sourceId: string;
+    kind: string;
+    url?: string;
+    snippet?: string;
+}
+export interface AgentGoal {
+    goalId: string;
+    kind: "short_term" | "long_term";
+    status: "proposal" | "accepted" | "rejected" | "completed" | "paused";
+    origin: "owner_set" | "agent_proposed" | "policy_seeded";
+    description: string;
+    completionCriteria: string;
+    risk: "low" | "medium" | "high";
+    priorityHint: number;
+    sourceRefs: SourceRef[];
+    acceptedBy?: "owner" | "policy_allowlist";
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AgentGoalWrite {
+    goalId: string;
+    kind: "short_term" | "long_term";
+    status: "proposal" | "accepted" | "rejected" | "completed" | "paused";
+    origin: "owner_set" | "agent_proposed" | "policy_seeded";
+    description: string;
+    completionCriteria: string;
+    risk: "low" | "medium" | "high";
+    priorityHint: number;
+    sourceRefs: SourceRef[];
+    acceptedBy?: "owner" | "policy_allowlist";
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AgentGoalStatusTransition {
+    goalId: string;
+    newStatus: "proposal" | "accepted" | "rejected" | "completed" | "paused";
+    acceptedBy?: "owner" | "policy_allowlist";
+    updatedAt: string;
+}
+export interface AgentGoalQuery {
+    statuses?: AgentGoal["status"][];
+    origins?: AgentGoal["origin"][];
+    limit?: number;
+}
+export interface AgentGoalWriteAck {
+    goalId: string;
+    status: "acknowledged" | "degraded";
+}
+export interface AgentGoalStore {
+    upsertAgentGoal(goal: AgentGoalWrite): Promise<AgentGoalWriteAck>;
+    listAgentGoals(query: AgentGoalQuery): Promise<AgentGoal[]>;
+    transitionGoalStatus(input: AgentGoalStatusTransition): Promise<AgentGoalWriteAck>;
+    loadAgentGoal(goalId: string): Promise<AgentGoal | null>;
+}
+export declare function createAgentGoalStore(database: StateDatabase): AgentGoalStore;

package/runtime/storage/goal/agent-goal-store.js

@@ -0,0 +1,109 @@
+import { eq, inArray, desc, and } from "drizzle-orm";
+import { agentGoal } from "../db/schema/agent-goal.js";
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rowToGoal(row) {
+    return {
+        goalId: row.goalId,
+        kind: row.kind,
+        status: row.status,
+        origin: row.origin,
+        description: row.description,
+        completionCriteria: row.completionCriteria,
+        risk: row.risk,
+        priorityHint: row.priorityHint,
+        sourceRefs: safeParseJson(row.sourceRefsJson, []),
+        acceptedBy: row.acceptedBy ? row.acceptedBy : undefined,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+export function createAgentGoalStore(database) {
+    const db = database.db;
+    return {
+        async upsertAgentGoal(goal) {
+            const existing = await db
+                .select()
+                .from(agentGoal)
+                .where(eq(agentGoal.goalId, goal.goalId))
+                .limit(1);
+            if (existing.length > 0) {
+                await db
+                    .update(agentGoal)
+                    .set({
+                    kind: goal.kind,
+                    status: goal.status,
+                    origin: goal.origin,
+                    description: goal.description,
+                    completionCriteria: goal.completionCriteria,
+                    risk: goal.risk,
+                    priorityHint: goal.priorityHint,
+                    sourceRefsJson: JSON.stringify(goal.sourceRefs),
+                    acceptedBy: goal.acceptedBy ?? null,
+                    updatedAt: goal.updatedAt,
+                })
+                    .where(eq(agentGoal.goalId, goal.goalId));
+            }
+            else {
+                await db.insert(agentGoal).values({
+                    goalId: goal.goalId,
+                    kind: goal.kind,
+                    status: goal.status,
+                    origin: goal.origin,
+                    description: goal.description,
+                    completionCriteria: goal.completionCriteria,
+                    risk: goal.risk,
+                    priorityHint: goal.priorityHint,
+                    sourceRefsJson: JSON.stringify(goal.sourceRefs),
+                    acceptedBy: goal.acceptedBy ?? null,
+                    createdAt: goal.createdAt,
+                    updatedAt: goal.updatedAt,
+                });
+            }
+            return { goalId: goal.goalId, status: "acknowledged" };
+        },
+        async listAgentGoals(query) {
+            const conditions = [];
+            if (query.statuses && query.statuses.length > 0) {
+                conditions.push(inArray(agentGoal.status, query.statuses));
+            }
+            if (query.origins && query.origins.length > 0) {
+                conditions.push(inArray(agentGoal.origin, query.origins));
+            }
+            const rows = await db
+                .select()
+                .from(agentGoal)
+                .where(conditions.length > 0 ? and(...conditions) : undefined)
+                .orderBy(desc(agentGoal.updatedAt))
+                .limit(query.limit ?? 100);
+            return rows.map(rowToGoal);
+        },
+        async transitionGoalStatus(input) {
+            await db
+                .update(agentGoal)
+                .set({
+                status: input.newStatus,
+                acceptedBy: input.acceptedBy ?? null,
+                updatedAt: input.updatedAt,
+            })
+                .where(eq(agentGoal.goalId, input.goalId));
+            return { goalId: input.goalId, status: "acknowledged" };
+        },
+        async loadAgentGoal(goalId) {
+            const rows = await db
+                .select()
+                .from(agentGoal)
+                .where(eq(agentGoal.goalId, goalId))
+                .limit(1);
+            if (rows.length === 0)
+                return null;
+            return rowToGoal(rows[0]);
+        },
+    };
+}

package/runtime/storage/index.d.ts

@@ -17,6 +17,11 @@ export { probeNativeSqliteLoad } from "./bootstrap/native-sqlite-probe.js";
 export { runStorageModeSmoke, type StorageModeSmokeReport, type RunStorageModeSmokeOptions, } from "./bootstrap/storage-mode-smoke.js";
 export { repairStateIndexes, type RepairSummary, type RepairStateIndexesOptions, type RepairGateStatus, } from "./bootstrap/repair-gate.js";
 export { createStateAPI, type StateAPI, type MemoryReadPort, type MemoryWritePort, type CredentialContextPort, type IntentCommitPort, type ProvenancePort } from "./state-api.js";
+export { createSessionChronicleStore, type SessionChronicleStore, type SessionChronicleEntry, type ChronicleQuery, type ChronicleWriteAck, type ChronicleEventKind, } from "./chronicle/session-chronicle-store.js";
+export { createNarrativeStateStore, type NarrativeStateStore, type NarrativeState, type NarrativeStateUpdate, type NarrativeStateWriteAck, } from "./narrative/narrative-state-store.js";
+export { createRelationshipMemoryStore, type RelationshipMemoryStore, type RelationshipMemory, type RelationshipMemoryUpdate, type RelationshipMemoryWriteAck, type TopicAffinity, } from "./relationship/relationship-memory-store.js";
+export { createAgentGoalStore, type AgentGoalStore, type AgentGoal, type AgentGoalWrite, type AgentGoalStatusTransition, type AgentGoalQuery, type AgentGoalWriteAck, } from "./goal/agent-goal-store.js";
+export { createMemoryStoreLifecycle, type MemoryStorePort, type MemoryStore, type MemoryStoreWrite, type MemoryStoreLifecycleTransition, type MemoryStoreAck, type CanonicalMemoryEntry, type DreamInsight, type MemoryStoreValidation, } from "./memory-store/memory-store-lifecycle.js";
 export type { LifeEvidence, LifeEvidenceCandidate, LifeEvidenceType, LifeEvidenceWriteAck, Sensitivity, SourceRef, } from "./life-evidence/types.js";
 export { appendLifeEvidence, type AppendLifeEvidenceOptions } from "./life-evidence/append-life-evidence.js";
 export { loadRhythmPolicySnapshot, type RhythmPolicySnapshot } from "./rhythm/rhythm-policy-snapshot.js";

package/runtime/storage/index.js

@@ -17,6 +17,11 @@ export { probeNativeSqliteLoad } from "./bootstrap/native-sqlite-probe.js";
 export { runStorageModeSmoke, } from "./bootstrap/storage-mode-smoke.js";
 export { repairStateIndexes, } from "./bootstrap/repair-gate.js";
 export { createStateAPI } from "./state-api.js";
+export { createSessionChronicleStore, } from "./chronicle/session-chronicle-store.js";
+export { createNarrativeStateStore, } from "./narrative/narrative-state-store.js";
+export { createRelationshipMemoryStore, } from "./relationship/relationship-memory-store.js";
+export { createAgentGoalStore, } from "./goal/agent-goal-store.js";
+export { createMemoryStoreLifecycle, } from "./memory-store/memory-store-lifecycle.js";
 export { appendLifeEvidence } from "./life-evidence/append-life-evidence.js";
 export { loadRhythmPolicySnapshot } from "./rhythm/rhythm-policy-snapshot.js";
 export { loadLifeEvidenceSnapshot } from "./snapshots/life-evidence-snapshot.js";

package/runtime/storage/memory-store/memory-store-lifecycle.d.ts

@@ -0,0 +1,70 @@
+import type { StateDatabase } from "../db/index.js";
+export interface SourceRef {
+    sourceId: string;
+    kind: string;
+    url?: string;
+    snippet?: string;
+}
+export interface CanonicalMemoryEntry {
+    entryId: string;
+    kind: string;
+    summary: string;
+    sourceRefs: SourceRef[];
+    createdAt: string;
+}
+export interface DreamInsight {
+    id: string;
+    type: "pattern" | "learning" | "observation" | "conflict";
+    summary: string;
+    sourceRefs: string[];
+    confidence: number;
+}
+export interface MemoryStoreValidation {
+    passed: boolean;
+    summary: string;
+    checkedAt: string;
+    unsupportedClaims?: string[];
+    redactionIssues?: string[];
+}
+export interface MemoryStore {
+    memoryStoreId: string;
+    lifecycleStatus: "candidate" | "accepted" | "archived" | "partial" | "superseded";
+    createdAt: string;
+    inputMemoryStoreId?: string;
+    dreamRunId?: string;
+    canonicalEntries: CanonicalMemoryEntry[];
+    insights: DreamInsight[];
+    narrativeSnapshot?: Record<string, unknown>;
+    relationshipSnapshot?: Record<string, unknown>;
+    validation: MemoryStoreValidation;
+}
+export interface MemoryStoreWrite {
+    memoryStoreId: string;
+    lifecycleStatus: "candidate" | "accepted" | "archived" | "partial" | "superseded";
+    createdAt: string;
+    inputMemoryStoreId?: string;
+    dreamRunId?: string;
+    canonicalEntries: CanonicalMemoryEntry[];
+    insights: DreamInsight[];
+    narrativeSnapshot?: Record<string, unknown>;
+    relationshipSnapshot?: Record<string, unknown>;
+    validation: MemoryStoreValidation;
+}
+export interface MemoryStoreLifecycleTransition {
+    memoryStoreId: string;
+    newStatus: "candidate" | "accepted" | "archived" | "partial" | "superseded";
+    validation?: MemoryStoreValidation;
+    updatedAt: string;
+}
+export interface MemoryStoreAck {
+    memoryStoreId: string;
+    status: "acknowledged" | "degraded";
+}
+export interface MemoryStorePort {
+    writeMemoryStore(output: MemoryStoreWrite): Promise<MemoryStoreAck>;
+    loadMemoryStore(memoryStoreId: string): Promise<MemoryStore | null>;
+    transitionMemoryStoreLifecycle(input: MemoryStoreLifecycleTransition): Promise<MemoryStoreAck>;
+    loadAcceptedMemoryProjection(): Promise<MemoryStore | null>;
+    listMemoryStoresByStatus(status: MemoryStore["lifecycleStatus"]): Promise<MemoryStore[]>;
+}
+export declare function createMemoryStoreLifecycle(database: StateDatabase): MemoryStorePort;

package/runtime/storage/memory-store/memory-store-lifecycle.js

@@ -0,0 +1,113 @@
+import { eq, desc } from "drizzle-orm";
+import { memoryStore } from "../db/schema/memory-store.js";
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rowToStore(row) {
+    return {
+        memoryStoreId: row.memoryStoreId,
+        lifecycleStatus: row.lifecycleStatus,
+        createdAt: row.createdAt,
+        inputMemoryStoreId: row.inputMemoryStoreId ?? undefined,
+        dreamRunId: row.dreamRunId ?? undefined,
+        canonicalEntries: safeParseJson(row.canonicalEntriesJson, []),
+        insights: safeParseJson(row.insightsJson, []),
+        narrativeSnapshot: row.narrativeSnapshotJson ? safeParseJson(row.narrativeSnapshotJson, undefined) : undefined,
+        relationshipSnapshot: row.relationshipSnapshotJson ? safeParseJson(row.relationshipSnapshotJson, undefined) : undefined,
+        validation: safeParseJson(row.validationJson, { passed: false, summary: "", checkedAt: "" }),
+    };
+}
+export function createMemoryStoreLifecycle(database) {
+    const db = database.db;
+    return {
+        async writeMemoryStore(output) {
+            const existing = await db
+                .select()
+                .from(memoryStore)
+                .where(eq(memoryStore.memoryStoreId, output.memoryStoreId))
+                .limit(1);
+            if (existing.length > 0) {
+                await db
+                    .update(memoryStore)
+                    .set({
+                    lifecycleStatus: output.lifecycleStatus,
+                    inputMemoryStoreId: output.inputMemoryStoreId ?? null,
+                    dreamRunId: output.dreamRunId ?? null,
+                    canonicalEntriesJson: JSON.stringify(output.canonicalEntries),
+                    insightsJson: JSON.stringify(output.insights),
+                    narrativeSnapshotJson: output.narrativeSnapshot ? JSON.stringify(output.narrativeSnapshot) : null,
+                    relationshipSnapshotJson: output.relationshipSnapshot ? JSON.stringify(output.relationshipSnapshot) : null,
+                    validationJson: JSON.stringify(output.validation),
+                })
+                    .where(eq(memoryStore.memoryStoreId, output.memoryStoreId));
+            }
+            else {
+                await db.insert(memoryStore).values({
+                    memoryStoreId: output.memoryStoreId,
+                    lifecycleStatus: output.lifecycleStatus,
+                    createdAt: output.createdAt,
+                    inputMemoryStoreId: output.inputMemoryStoreId ?? null,
+                    dreamRunId: output.dreamRunId ?? null,
+                    canonicalEntriesJson: JSON.stringify(output.canonicalEntries),
+                    insightsJson: JSON.stringify(output.insights),
+                    narrativeSnapshotJson: output.narrativeSnapshot ? JSON.stringify(output.narrativeSnapshot) : null,
+                    relationshipSnapshotJson: output.relationshipSnapshot ? JSON.stringify(output.relationshipSnapshot) : null,
+                    validationJson: JSON.stringify(output.validation),
+                });
+            }
+            return { memoryStoreId: output.memoryStoreId, status: "acknowledged" };
+        },
+        async loadMemoryStore(memoryStoreId) {
+            const rows = await db
+                .select()
+                .from(memoryStore)
+                .where(eq(memoryStore.memoryStoreId, memoryStoreId))
+                .limit(1);
+            if (rows.length === 0)
+                return null;
+            return rowToStore(rows[0]);
+        },
+        async transitionMemoryStoreLifecycle(input) {
+            const existing = await db
+                .select()
+                .from(memoryStore)
+                .where(eq(memoryStore.memoryStoreId, input.memoryStoreId))
+                .limit(1);
+            if (existing.length === 0) {
+                return { memoryStoreId: input.memoryStoreId, status: "degraded" };
+            }
+            const updates = { lifecycleStatus: input.newStatus };
+            if (input.validation) {
+                updates.validationJson = JSON.stringify(input.validation);
+            }
+            await db
+                .update(memoryStore)
+                .set(updates)
+                .where(eq(memoryStore.memoryStoreId, input.memoryStoreId));
+            return { memoryStoreId: input.memoryStoreId, status: "acknowledged" };
+        },
+        async loadAcceptedMemoryProjection() {
+            const rows = await db
+                .select()
+                .from(memoryStore)
+                .where(eq(memoryStore.lifecycleStatus, "accepted"))
+                .orderBy(desc(memoryStore.createdAt))
+                .limit(1);
+            if (rows.length === 0)
+                return null;
+            return rowToStore(rows[0]);
+        },
+        async listMemoryStoresByStatus(status) {
+            const rows = await db
+                .select()
+                .from(memoryStore)
+                .where(eq(memoryStore.lifecycleStatus, status));
+            return rows.map(rowToStore);
+        },
+    };
+}

package/runtime/storage/narrative/narrative-state-store.d.ts

@@ -0,0 +1,40 @@
+import type { StateDatabase } from "../db/index.js";
+export interface SourceRef {
+    sourceId: string;
+    kind: string;
+    url?: string;
+    snippet?: string;
+}
+export interface NarrativeState {
+    narrativeId: string;
+    revision: number;
+    focus: string;
+    progress: string[];
+    nextIntent: string;
+    confidence: number;
+    sourceRefs: SourceRef[];
+    unsupportedClaims: string[];
+    status: "active" | "insufficient_sources" | "awaiting_sources";
+    updatedAt: string;
+}
+export interface NarrativeStateUpdate {
+    narrativeId: string;
+    revision: number;
+    focus: string;
+    progress: string[];
+    nextIntent: string;
+    confidence: number;
+    sourceRefs: SourceRef[];
+    unsupportedClaims: string[];
+    status: "active" | "insufficient_sources" | "awaiting_sources";
+    updatedAt: string;
+}
+export interface NarrativeStateWriteAck {
+    narrativeId: string;
+    status: "acknowledged" | "degraded";
+}
+export interface NarrativeStateStore {
+    updateNarrativeState(input: NarrativeStateUpdate): Promise<NarrativeStateWriteAck>;
+    loadNarrativeState(narrativeId?: string): Promise<NarrativeState | null>;
+}
+export declare function createNarrativeStateStore(database: StateDatabase): NarrativeStateStore;