@haaaiawd/second-nature 0.1.22 → 0.1.24

package/runtime/storage/db/schema/narrative-state.js

@@ -0,0 +1,16 @@
+import { index, sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+export const narrativeState = sqliteTable("narrative_state", {
+    narrativeId: text("narrative_id").primaryKey(),
+    revision: integer("revision").notNull().default(1),
+    focus: text("focus").notNull(),
+    progressJson: text("progress_json").notNull(),
+    nextIntent: text("next_intent").notNull(),
+    confidence: integer("confidence").notNull().default(0),
+    sourceRefsJson: text("source_refs_json").notNull(),
+    unsupportedClaimsJson: text("unsupported_claims_json").notNull(),
+    status: text("status").notNull(),
+    updatedAt: text("updated_at").notNull(),
+}, (table) => [
+    index("narrative_state_status_idx").on(table.status),
+    index("narrative_state_updated_at_idx").on(table.updatedAt),
+]);

package/runtime/storage/db/schema/relationship-memory.d.ts

@@ -0,0 +1,174 @@
+export declare const relationshipMemory: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "relationship_memory";
+    schema: undefined;
+    columns: {
+        relationshipId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "relationship_id";
+            tableName: "relationship_memory";
+            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;
+        }>;
+        revision: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "revision";
+            tableName: "relationship_memory";
+            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;
+        }, {}, {}>;
+        tonePreference: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "tone_preference";
+            tableName: "relationship_memory";
+            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;
+        }>;
+        averageReplyDelayMinutes: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "average_reply_delay_minutes";
+            tableName: "relationship_memory";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        noReplyCount: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "no_reply_count";
+            tableName: "relationship_memory";
+            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;
+        }, {}, {}>;
+        topicAffinitiesJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "topic_affinities_json";
+            tableName: "relationship_memory";
+            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;
+        }>;
+        lastInteractionAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "last_interaction_at";
+            tableName: "relationship_memory";
+            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;
+        }>;
+        sourceRefsJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_refs_json";
+            tableName: "relationship_memory";
+            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: "relationship_memory";
+            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 RelationshipMemoryRow = typeof relationshipMemory.$inferSelect;
+export type NewRelationshipMemoryRow = typeof relationshipMemory.$inferInsert;

package/runtime/storage/db/schema/relationship-memory.js

@@ -0,0 +1,14 @@
+import { index, sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+export const relationshipMemory = sqliteTable("relationship_memory", {
+    relationshipId: text("relationship_id").primaryKey(),
+    revision: integer("revision").notNull().default(1),
+    tonePreference: text("tone_preference").notNull(),
+    averageReplyDelayMinutes: integer("average_reply_delay_minutes"),
+    noReplyCount: integer("no_reply_count").notNull().default(0),
+    topicAffinitiesJson: text("topic_affinities_json").notNull(),
+    lastInteractionAt: text("last_interaction_at"),
+    sourceRefsJson: text("source_refs_json").notNull(),
+    updatedAt: text("updated_at").notNull(),
+}, (table) => [
+    index("relationship_memory_updated_at_idx").on(table.updatedAt),
+]);

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";