@haaaiawd/second-nature 0.1.22 → 0.1.24

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;

package/runtime/storage/narrative/narrative-state-store.js

@@ -0,0 +1,79 @@
+import { eq } from "drizzle-orm";
+import { narrativeState } from "../db/schema/narrative-state.js";
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rowToState(row) {
+    return {
+        narrativeId: row.narrativeId,
+        revision: row.revision,
+        focus: row.focus,
+        progress: safeParseJson(row.progressJson, []),
+        nextIntent: row.nextIntent,
+        confidence: row.confidence,
+        sourceRefs: safeParseJson(row.sourceRefsJson, []),
+        unsupportedClaims: safeParseJson(row.unsupportedClaimsJson, []),
+        status: row.status,
+        updatedAt: row.updatedAt,
+    };
+}
+const DEFAULT_NARRATIVE_ID = "default";
+export function createNarrativeStateStore(database) {
+    const db = database.db;
+    return {
+        async updateNarrativeState(input) {
+            const existing = await db
+                .select()
+                .from(narrativeState)
+                .where(eq(narrativeState.narrativeId, input.narrativeId))
+                .limit(1);
+            if (existing.length > 0) {
+                await db
+                    .update(narrativeState)
+                    .set({
+                    revision: input.revision,
+                    focus: input.focus,
+                    progressJson: JSON.stringify(input.progress),
+                    nextIntent: input.nextIntent,
+                    confidence: input.confidence,
+                    sourceRefsJson: JSON.stringify(input.sourceRefs),
+                    unsupportedClaimsJson: JSON.stringify(input.unsupportedClaims),
+                    status: input.status,
+                    updatedAt: input.updatedAt,
+                })
+                    .where(eq(narrativeState.narrativeId, input.narrativeId));
+            }
+            else {
+                await db.insert(narrativeState).values({
+                    narrativeId: input.narrativeId,
+                    revision: input.revision,
+                    focus: input.focus,
+                    progressJson: JSON.stringify(input.progress),
+                    nextIntent: input.nextIntent,
+                    confidence: input.confidence,
+                    sourceRefsJson: JSON.stringify(input.sourceRefs),
+                    unsupportedClaimsJson: JSON.stringify(input.unsupportedClaims),
+                    status: input.status,
+                    updatedAt: input.updatedAt,
+                });
+            }
+            return { narrativeId: input.narrativeId, status: "acknowledged" };
+        },
+        async loadNarrativeState(narrativeId) {
+            const id = narrativeId ?? DEFAULT_NARRATIVE_ID;
+            const rows = await db
+                .select()
+                .from(narrativeState)
+                .where(eq(narrativeState.narrativeId, id))
+                .limit(1);
+            if (rows.length === 0)
+                return null;
+            return rowToState(rows[0]);
+        },
+    };
+}

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

@@ -0,0 +1,42 @@
+import type { StateDatabase } from "../db/index.js";
+export interface SourceRef {
+    sourceId: string;
+    kind: string;
+    url?: string;
+    snippet?: string;
+}
+export interface TopicAffinity {
+    topic: string;
+    affinity: number;
+}
+export interface RelationshipMemory {
+    relationshipId: string;
+    revision: number;
+    tonePreference: "casual" | "direct" | "quiet" | "unknown";
+    averageReplyDelayMinutes?: number;
+    noReplyCount: number;
+    topicAffinities: TopicAffinity[];
+    lastInteractionAt?: string;
+    sourceRefs: SourceRef[];
+    updatedAt: string;
+}
+export interface RelationshipMemoryUpdate {
+    relationshipId: string;
+    revision: number;
+    tonePreference: "casual" | "direct" | "quiet" | "unknown";
+    averageReplyDelayMinutes?: number;
+    noReplyCount: number;
+    topicAffinities: TopicAffinity[];
+    lastInteractionAt?: string;
+    sourceRefs: SourceRef[];
+    updatedAt: string;
+}
+export interface RelationshipMemoryWriteAck {
+    relationshipId: string;
+    status: "acknowledged" | "degraded";
+}
+export interface RelationshipMemoryStore {
+    upsertRelationshipMemory(input: RelationshipMemoryUpdate): Promise<RelationshipMemoryWriteAck>;
+    loadRelationshipMemory(relationshipId?: string): Promise<RelationshipMemory | null>;
+}
+export declare function createRelationshipMemoryStore(database: StateDatabase): RelationshipMemoryStore;

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

@@ -0,0 +1,76 @@
+import { eq } from "drizzle-orm";
+import { relationshipMemory } from "../db/schema/relationship-memory.js";
+function safeParseJson(json, fallback) {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rowToMemory(row) {
+    return {
+        relationshipId: row.relationshipId,
+        revision: row.revision,
+        tonePreference: row.tonePreference,
+        averageReplyDelayMinutes: row.averageReplyDelayMinutes ?? undefined,
+        noReplyCount: row.noReplyCount,
+        topicAffinities: safeParseJson(row.topicAffinitiesJson, []),
+        lastInteractionAt: row.lastInteractionAt ?? undefined,
+        sourceRefs: safeParseJson(row.sourceRefsJson, []),
+        updatedAt: row.updatedAt,
+    };
+}
+const DEFAULT_RELATIONSHIP_ID = "default";
+export function createRelationshipMemoryStore(database) {
+    const db = database.db;
+    return {
+        async upsertRelationshipMemory(input) {
+            const existing = await db
+                .select()
+                .from(relationshipMemory)
+                .where(eq(relationshipMemory.relationshipId, input.relationshipId))
+                .limit(1);
+            if (existing.length > 0) {
+                await db
+                    .update(relationshipMemory)
+                    .set({
+                    revision: input.revision,
+                    tonePreference: input.tonePreference,
+                    averageReplyDelayMinutes: input.averageReplyDelayMinutes ?? null,
+                    noReplyCount: input.noReplyCount,
+                    topicAffinitiesJson: JSON.stringify(input.topicAffinities),
+                    lastInteractionAt: input.lastInteractionAt ?? null,
+                    sourceRefsJson: JSON.stringify(input.sourceRefs),
+                    updatedAt: input.updatedAt,
+                })
+                    .where(eq(relationshipMemory.relationshipId, input.relationshipId));
+            }
+            else {
+                await db.insert(relationshipMemory).values({
+                    relationshipId: input.relationshipId,
+                    revision: input.revision,
+                    tonePreference: input.tonePreference,
+                    averageReplyDelayMinutes: input.averageReplyDelayMinutes ?? null,
+                    noReplyCount: input.noReplyCount,
+                    topicAffinitiesJson: JSON.stringify(input.topicAffinities),
+                    lastInteractionAt: input.lastInteractionAt ?? null,
+                    sourceRefsJson: JSON.stringify(input.sourceRefs),
+                    updatedAt: input.updatedAt,
+                });
+            }
+            return { relationshipId: input.relationshipId, status: "acknowledged" };
+        },
+        async loadRelationshipMemory(relationshipId) {
+            const id = relationshipId ?? DEFAULT_RELATIONSHIP_ID;
+            const rows = await db
+                .select()
+                .from(relationshipMemory)
+                .where(eq(relationshipMemory.relationshipId, id))
+                .limit(1);
+            if (rows.length === 0)
+                return null;
+            return rowToMemory(rows[0]);
+        },
+    };
+}

package/workspace-ops-bridge.js

@@ -47,6 +47,7 @@ export async function openWorkspaceOpsBridge(workspaceRoot) {
             state: stateDb,
             workspaceRoot: resolvedRoot,
             connectorExecutor: deps.connectorExecutor,
+            registry: deps.registry,
         });
         const commands = commandsMod.createCliCommands({
             readModels: deps.readModels,