@haaaiawd/second-nature 0.1.8 → 0.1.9

package/runtime/storage/snapshots/continuity-snapshot.js

@@ -0,0 +1,41 @@
+/**
+ * Continuity snapshot read model (T4.2.1) — lightweight bridge until full state feeds land.
+ */
+import * as crypto from "node:crypto";
+import { desc } from "drizzle-orm";
+import { decisionLedger } from "../../observability/db/schema/index.js";
+import { repairStateIndexes } from "../bootstrap/repair-gate.js";
+import { loadLifeEvidenceSnapshot } from "./life-evidence-snapshot.js";
+export async function loadContinuitySnapshot(params) {
+    await repairStateIndexes(params.state, { startupGate: true, workspaceRoot: params.workspaceRoot });
+    const life = await loadLifeEvidenceSnapshot(params.state, params.workspaceRoot, { limit: 50 }, { runRepairGate: false });
+    let recentDecisionRefs = [];
+    if (params.observability) {
+        const rows = await params.observability.db
+            .select()
+            .from(decisionLedger)
+            .orderBy(desc(decisionLedger.createdAt))
+            .limit(5);
+        recentDecisionRefs = rows.map((r) => ({
+            id: r.id,
+            kind: "decision_record",
+            uri: `sn://decision/${r.id}`,
+        }));
+    }
+    const pendingCount = life.platformEvents.length + life.workEvents.length + life.userInteractionEvents.length;
+    const oldest = [...life.platformEvents, ...life.workEvents, ...life.userInteractionEvents]
+        .map((e) => e.timestamp)
+        .sort()[0];
+    return {
+        snapshotId: crypto.randomUUID(),
+        generatedAt: new Date().toISOString(),
+        recentDecisionRefs,
+        openObligations: [],
+        quietDebt: {
+            hasUnprocessedEvidence: !life.empty,
+            oldestUnprocessedEvidenceAt: oldest,
+            pendingCount,
+        },
+        fallbackRefs: [],
+    };
+}

package/runtime/storage/snapshots/life-evidence-snapshot.d.ts

@@ -0,0 +1,6 @@
+import type { StateDatabase } from "../db/index.js";
+import type { LifeEvidenceQuery, LifeEvidenceSnapshot } from "./types.js";
+export interface LoadLifeEvidenceSnapshotOptions {
+    runRepairGate?: boolean;
+}
+export declare function loadLifeEvidenceSnapshot(state: StateDatabase, workspaceRoot: string, query: LifeEvidenceQuery, options?: LoadLifeEvidenceSnapshotOptions): Promise<LifeEvidenceSnapshot>;

package/runtime/storage/snapshots/life-evidence-snapshot.js

@@ -0,0 +1,114 @@
+/**
+ * Bounded life evidence snapshot read model (T4.2.1).
+ */
+import * as crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { and, desc, gte, inArray, lte } from "drizzle-orm";
+import { lifeEvidenceIndex } from "../db/schema/life-evidence-index.js";
+import { repairStateIndexes } from "../bootstrap/repair-gate.js";
+function toReadModel(stored) {
+    return {
+        id: stored.id,
+        timestamp: stored.timestamp,
+        evidenceType: stored.evidenceType,
+        platformId: stored.platformId,
+        summary: stored.summary,
+        rawContentRef: stored.rawContentRef,
+        sourceRefs: stored.sourceRefs,
+        sensitivity: stored.sensitivity,
+        confidence: stored.confidence,
+        tags: stored.tags,
+        producer: stored.producer,
+    };
+}
+function buildCoverage(events) {
+    if (events.length === 0) {
+        return { coverageRatio: 1, unsupportedClaims: [], claimCoverage: [] };
+    }
+    const backed = events.filter((e) => e.sourceRefs.length > 0).length;
+    return {
+        coverageRatio: backed / events.length,
+        unsupportedClaims: [],
+        claimCoverage: events.map((e, i) => ({
+            claimId: `ev:${e.id}:${i}`,
+            backed: e.sourceRefs.length > 0,
+            sourceRefs: e.sourceRefs,
+        })),
+    };
+}
+export async function loadLifeEvidenceSnapshot(state, workspaceRoot, query, options) {
+    const runGate = options?.runRepairGate !== false;
+    if (runGate) {
+        const repair = await repairStateIndexes(state, { startupGate: true, workspaceRoot });
+        if (repair.status === "repair_required") {
+            const err = new Error("state_repair_required");
+            err.code = "repair_required";
+            throw err;
+        }
+    }
+    const now = new Date().toISOString();
+    const windowEnd = query.windowEnd ?? now;
+    const windowStart = query.windowStart ?? new Date(Date.now() - 7 * 86400000).toISOString();
+    const limit = query.limit ?? 50;
+    const conditions = [gte(lifeEvidenceIndex.timestamp, windowStart), lte(lifeEvidenceIndex.timestamp, windowEnd)];
+    if (query.evidenceTypes?.length) {
+        conditions.push(inArray(lifeEvidenceIndex.evidenceType, query.evidenceTypes));
+    }
+    const rows = await state.db
+        .select()
+        .from(lifeEvidenceIndex)
+        .where(and(...conditions))
+        .orderBy(desc(lifeEvidenceIndex.timestamp))
+        .limit(limit);
+    const platformEvents = [];
+    const workEvents = [];
+    const userInteractionEvents = [];
+    const quietArtifacts = [];
+    const evidenceRefs = [];
+    for (const row of rows) {
+        const abs = path.join(workspaceRoot, row.artifactPath.replace(/\//g, path.sep));
+        if (!fs.existsSync(abs)) {
+            continue;
+        }
+        const stored = JSON.parse(fs.readFileSync(abs, "utf-8"));
+        const model = toReadModel(stored);
+        evidenceRefs.push({
+            id: `ref:${model.id}`,
+            kind: "workspace_artifact",
+            uri: row.artifactPath,
+        });
+        if (model.evidenceType === "platform_browse" || model.evidenceType === "platform_interaction") {
+            platformEvents.push(model);
+        }
+        else if (model.evidenceType === "work_progress" || model.evidenceType === "task_discovery") {
+            workEvents.push(model);
+        }
+        else if (model.evidenceType === "user_interaction") {
+            userInteractionEvents.push(model);
+        }
+        else if (model.evidenceType === "quiet_reflection") {
+            quietArtifacts.push({
+                id: `quiet:${model.id}`,
+                kind: "workspace_artifact",
+                uri: row.artifactPath,
+            });
+        }
+    }
+    const all = [...platformEvents, ...workEvents, ...userInteractionEvents];
+    const coverage = buildCoverage(all);
+    const empty = all.length === 0;
+    return {
+        snapshotId: crypto.randomUUID(),
+        generatedAt: now,
+        windowStart,
+        windowEnd,
+        evidenceRefs,
+        platformEvents,
+        workEvents,
+        userInteractionEvents,
+        quietArtifacts,
+        coverage,
+        empty,
+    };
+}

package/runtime/storage/snapshots/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Read-model snapshots aligned with state-system v5 (subset for S1/S2).
+ */
+import type { LifeEvidenceType, SourceRef } from "../life-evidence/types.js";
+export interface LifeEvidenceQuery {
+    windowStart?: string;
+    windowEnd?: string;
+    evidenceTypes?: LifeEvidenceType[];
+    limit?: number;
+}
+export interface SourceCoverage {
+    coverageRatio: number;
+    unsupportedClaims: string[];
+    claimCoverage: Array<{
+        claimId: string;
+        backed: boolean;
+        sourceRefs: SourceRef[];
+    }>;
+}
+export interface LifeEvidenceReadModel {
+    id: string;
+    timestamp: string;
+    evidenceType: LifeEvidenceType;
+    platformId?: string;
+    summary: string;
+    rawContentRef?: string;
+    sourceRefs: SourceRef[];
+    sensitivity: import("../life-evidence/types.js").Sensitivity;
+    confidence: number;
+    tags: string[];
+    producer: string;
+}
+export interface LifeEvidenceSnapshot {
+    snapshotId: string;
+    generatedAt: string;
+    windowStart: string;
+    windowEnd: string;
+    evidenceRefs: SourceRef[];
+    platformEvents: LifeEvidenceReadModel[];
+    workEvents: LifeEvidenceReadModel[];
+    userInteractionEvents: LifeEvidenceReadModel[];
+    quietArtifacts: SourceRef[];
+    coverage: SourceCoverage;
+    empty: boolean;
+}
+export interface ContinuitySnapshot {
+    snapshotId: string;
+    generatedAt: string;
+    lastHeartbeatAt?: string;
+    recentDecisionRefs: SourceRef[];
+    openObligations: SourceRef[];
+    quietDebt: {
+        hasUnprocessedEvidence: boolean;
+        oldestUnprocessedEvidenceAt?: string;
+        pendingCount: number;
+    };
+    fallbackRefs: SourceRef[];
+}

package/runtime/storage/snapshots/types.js

@@ -0,0 +1 @@
+export {};

package/runtime/storage/state-api.js

@@ -7,6 +7,7 @@ import { PolicyRepository } from "./repositories/policy-repository.js";
 import { createDailyLogPipeline, } from "./services/daily-log-pipeline.js";
 import { createQuietInputLoader, } from "./services/quiet-input-loader.js";
 import { createPersonaCandidateLoader } from "./services/persona-candidate-loader.js";
+import { encryptCredentialAtRest, isCredentialCiphertext } from "./services/credential-vault.js";
 export class DefaultStateAPI {
     database;
     read;
@@ -31,11 +32,13 @@ export class DefaultStateAPI {
                 const record = await policyRepository.findByPlatformId(platformId);
                 if (!record)
                     return undefined;
+                const r = record;
                 return {
-                    platformId: record.platformId ?? record.platform_id,
-                    socialDailyLimit: record.socialDailyLimit ?? record.social_daily_limit,
-                    quietEnabled: record.quietEnabled ?? Boolean(record.quiet_enabled),
-                    updatedAt: record.updatedAt ?? record.updated_at,
+                    platformId: r.platformId ?? r.platform_id ?? platformId,
+                    socialDailyLimit: r.socialDailyLimit ?? r.social_daily_limit ?? 0,
+                    quietEnabled: r.quietEnabled ?? Boolean(r.quiet_enabled),
+                    outreachDailyBudget: r.outreachDailyBudget ?? r.outreach_daily_budget ?? 2,
+                    updatedAt: r.updatedAt ?? r.updated_at ?? "",
                 };
             },
             loadPersonaCandidates: (sceneContext) => personaCandidateLoader.loadPersonaCandidates(sceneContext),
@@ -50,6 +53,7 @@ export class DefaultStateAPI {
                     platformId: policy.platformId,
                     socialDailyLimit: policy.socialDailyLimit,
                     quietEnabled: policy.quietEnabled,
+                    outreachDailyBudget: policy.outreachDailyBudget ?? 2,
                     updatedAt: new Date().toISOString(),
                 });
             },
@@ -74,8 +78,11 @@ export class DefaultStateAPI {
             },
             saveCredentialContext: async (input) => {
                 const ctx = input;
+                const raw = ctx.encryptedValue != null ? String(ctx.encryptedValue) : "";
+                const encryptedValue = !raw || isCredentialCiphertext(raw) ? raw : encryptCredentialAtRest(raw);
                 await credentialRepository.upsert({
                     ...ctx,
+                    encryptedValue,
                     updatedAt: ctx.updatedAt ?? new Date().toISOString(),
                 });
             },

package/runtime/storage/user-interest/load-user-interest-snapshot.d.ts

@@ -0,0 +1,2 @@
+import type { UserInterestSnapshot } from "./types.js";
+export declare function loadUserInterestSnapshot(workspaceRoot: string): Promise<UserInterestSnapshot>;

package/runtime/storage/user-interest/load-user-interest-snapshot.js

@@ -0,0 +1,150 @@
+/**
+ * Minimal loadUserInterestSnapshot: anchor + curated presence, no fabricated preferences (T4.2.2).
+ *
+ * Core logic: USER.md / MEMORY.md / memory/curated/*.md drive signals; otherwise insufficient.
+ * Boundaries: never invent topics; staleness insufficient when anchors missing and no curated signals.
+ */
+import * as crypto from "node:crypto";
+import * as fs from "fs/promises";
+import * as path from "node:path";
+import { fileExists, readText } from "../memory/workspace/paths.js";
+const MIN_MEANINGFUL_ANCHOR_CHARS = 24;
+const STALE_MS = 30 * 24 * 60 * 60 * 1000;
+const INSUFFICIENT_CONFIDENCE_THRESHOLD = 0.35;
+function anchorRef(asset, workspaceRoot) {
+    return {
+        id: `anchor:${asset}`,
+        kind: "user_anchor",
+        uri: path.join(workspaceRoot, asset),
+        observedAt: new Date().toISOString(),
+    };
+}
+async function newestMtime(paths) {
+    let max = 0;
+    for (const p of paths) {
+        try {
+            const st = await fs.stat(p);
+            max = Math.max(max, st.mtimeMs);
+        }
+        catch {
+            /* missing */
+        }
+    }
+    return max;
+}
+async function listCuratedSignalFiles(workspaceRoot) {
+    const dir = path.join(workspaceRoot, "memory", "curated");
+    if (!(await fileExists(dir)))
+        return [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => path.join(dir, e.name));
+}
+export async function loadUserInterestSnapshot(workspaceRoot) {
+    const generatedAt = new Date().toISOString();
+    const userPath = path.join(workspaceRoot, "USER.md");
+    const memoryPath = path.join(workspaceRoot, "MEMORY.md");
+    const hasUser = await fileExists(userPath);
+    const hasMemory = await fileExists(memoryPath);
+    const userText = hasUser ? (await readText(userPath)).trim() : "";
+    const memoryText = hasMemory ? (await readText(memoryPath)).trim() : "";
+    const curatedFiles = await listCuratedSignalFiles(workspaceRoot);
+    const curatedNonEmpty = [];
+    for (const fp of curatedFiles) {
+        const body = (await readText(fp)).trim();
+        if (body.length >= MIN_MEANINGFUL_ANCHOR_CHARS)
+            curatedNonEmpty.push(fp);
+    }
+    const userOk = hasUser && userText.length >= MIN_MEANINGFUL_ANCHOR_CHARS;
+    const memoryOk = hasMemory && memoryText.length >= MIN_MEANINGFUL_ANCHOR_CHARS;
+    if (!userOk && !memoryOk && curatedNonEmpty.length === 0) {
+        return {
+            snapshotId: crypto.randomUUID(),
+            generatedAt,
+            signals: [],
+            sourceRefs: [],
+            confidence: 0,
+            staleness: "insufficient",
+            missingReasons: ["missing_user_interest_model"],
+        };
+    }
+    const signals = [];
+    const allRefs = [];
+    if (userOk) {
+        const ref = anchorRef("USER.md", workspaceRoot);
+        allRefs.push(ref);
+        signals.push({
+            id: `interest:user:${crypto.randomUUID()}`,
+            topic: "user_anchor_profile",
+            affinity: "unknown",
+            reason: "derived_from_USER.md_anchor",
+            confidence: 0.55,
+            sourceRefs: [ref],
+            updatedAt: generatedAt,
+        });
+    }
+    if (memoryOk) {
+        const ref = anchorRef("MEMORY.md", workspaceRoot);
+        allRefs.push(ref);
+        signals.push({
+            id: `interest:memory:${crypto.randomUUID()}`,
+            topic: "relational_memory_anchor",
+            affinity: "watching",
+            reason: "derived_from_MEMORY.md_anchor",
+            confidence: 0.52,
+            sourceRefs: [ref],
+            updatedAt: generatedAt,
+        });
+    }
+    for (const fp of curatedNonEmpty) {
+        const ref = {
+            id: `curated:${path.basename(fp, ".md")}`,
+            kind: "workspace_artifact",
+            uri: fp,
+            observedAt: generatedAt,
+        };
+        allRefs.push(ref);
+        signals.push({
+            id: `interest:curated:${crypto.randomUUID()}`,
+            topic: `curated:${path.basename(fp, ".md")}`,
+            affinity: "positive",
+            reason: "derived_from_curated_memory_file",
+            confidence: 0.48,
+            sourceRefs: [ref],
+            updatedAt: generatedAt,
+        });
+    }
+    if (signals.length === 0) {
+        return {
+            snapshotId: crypto.randomUUID(),
+            generatedAt,
+            signals: [],
+            sourceRefs: [],
+            confidence: 0,
+            staleness: "insufficient",
+            missingReasons: ["missing_user_interest_model"],
+        };
+    }
+    const confidence = signals.reduce((s, x) => s + x.confidence, 0) / signals.length;
+    if (confidence < INSUFFICIENT_CONFIDENCE_THRESHOLD) {
+        return {
+            snapshotId: crypto.randomUUID(),
+            generatedAt,
+            signals: [],
+            sourceRefs: [],
+            confidence: 0,
+            staleness: "insufficient",
+            missingReasons: ["missing_user_interest_model"],
+        };
+    }
+    const mtimes = await newestMtime([hasUser ? userPath : "", hasMemory ? memoryPath : "", ...curatedNonEmpty].filter(Boolean));
+    const staleness = mtimes > 0 && Date.now() - mtimes > STALE_MS ? "stale" : "fresh";
+    const uniqueRefs = [...new Map(allRefs.map((r) => [r.uri, r])).values()];
+    return {
+        snapshotId: crypto.randomUUID(),
+        generatedAt,
+        signals,
+        sourceRefs: uniqueRefs,
+        confidence,
+        staleness,
+    };
+}

package/runtime/storage/user-interest/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * User interest read model (T4.2.2 / state-system v5 subset).
+ *
+ * Test coverage: tests/unit/storage/user-interest-snapshot.test.ts
+ */
+import type { SourceRef } from "../life-evidence/types.js";
+export type UserInterestStaleness = "fresh" | "stale" | "insufficient";
+export interface UserInterestSignal {
+    id: string;
+    topic: string;
+    affinity: "positive" | "negative" | "watching" | "unknown";
+    reason: string;
+    confidence: number;
+    sourceRefs: SourceRef[];
+    updatedAt: string;
+}
+export interface UserInterestSnapshot {
+    snapshotId: string;
+    generatedAt: string;
+    signals: UserInterestSignal[];
+    sourceRefs: SourceRef[];
+    confidence: number;
+    staleness: UserInterestStaleness;
+    missingReasons?: string[];
+}

package/runtime/storage/user-interest/types.js

@@ -0,0 +1 @@
+export {};