@haaaiawd/second-nature 0.1.22 → 0.1.24

package/runtime/guidance/outreach-draft-schema.d.ts

@@ -53,10 +53,10 @@ export declare const sceneGuidanceRequestSchema: z.ZodObject<{
     rhythmWindowKind: z.ZodOptional<z.ZodEnum<{
         quiet: "quiet";
         social: "social";
+        maintenance: "maintenance";
         work: "work";
         exploration: "exploration";
         reflection: "reflection";
-        maintenance: "maintenance";
     }>>;
     riskLevel: z.ZodEnum<{
         medium: "medium";
@@ -107,10 +107,10 @@ export declare const outreachDraftRequestSchema: z.ZodObject<{
     rhythmWindowKind: z.ZodOptional<z.ZodEnum<{
         quiet: "quiet";
         social: "social";
+        maintenance: "maintenance";
         work: "work";
         exploration: "exploration";
         reflection: "reflection";
-        maintenance: "maintenance";
     }>>;
     riskLevel: z.ZodEnum<{
         medium: "medium";
@@ -205,7 +205,7 @@ export declare function safeParseOutreachDraftRequest(input: unknown): z.ZodSafe
         excerptHash?: string | undefined;
         observedAt?: string | undefined;
     }[];
-    rhythmWindowKind?: "quiet" | "social" | "work" | "exploration" | "reflection" | "maintenance" | undefined;
+    rhythmWindowKind?: "quiet" | "social" | "maintenance" | "work" | "exploration" | "reflection" | undefined;
     deliveryContext?: {
         deliveryVerdict: "target_none" | "channel_missing" | "host_unsupported" | "delivery_failed" | "target_available";
         wordingMode: "sendable" | "not_sent_fallback_candidate";

package/runtime/observability/connector-inventory-ledger.d.ts

@@ -0,0 +1,45 @@
+import type { ObservabilityDatabase } from "./db/index.js";
+export interface InventorySnapshot {
+    auditId: string;
+    snapshotId: string;
+    scanned: number;
+    registered: number;
+    skipped: number;
+    conflicts: Array<{
+        connectorId: string;
+        reason: string;
+    }>;
+    validationErrors: Array<{
+        connectorId: string;
+        errors: string[];
+    }>;
+    trustSummary: Record<string, number>;
+    createdAt: string;
+}
+export declare class ConnectorInventoryLedger {
+    private obs;
+    constructor(obs: ObservabilityDatabase);
+    private now;
+    private generateId;
+    recordAudit(input: {
+        snapshotId: string;
+        scanned: number;
+        registered: number;
+        skipped: number;
+        conflicts?: Array<{
+            connectorId: string;
+            reason: string;
+        }>;
+        validationErrors?: Array<{
+            connectorId: string;
+            errors: string[];
+        }>;
+        trustSummary?: Record<string, number>;
+    }): Promise<string>;
+    getLatestAudit(snapshotId: string): Promise<InventorySnapshot | undefined>;
+    listAudits(opts?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<InventorySnapshot[]>;
+    private rowToSnapshot;
+}

package/runtime/observability/connector-inventory-ledger.js

@@ -0,0 +1,72 @@
+import { eq, desc } from "drizzle-orm";
+import { connectorInventoryAudit } from "./db/schema/index.js";
+export class ConnectorInventoryLedger {
+    obs;
+    constructor(obs) {
+        this.obs = obs;
+    }
+    now() {
+        return new Date().toISOString();
+    }
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+    }
+    async recordAudit(input) {
+        const auditId = this.generateId();
+        const createdAt = this.now();
+        await this.obs.db
+            .insert(connectorInventoryAudit)
+            .values({
+            auditId,
+            snapshotId: input.snapshotId,
+            scanned: input.scanned,
+            registered: input.registered,
+            skipped: input.skipped,
+            conflictsJson: JSON.stringify(input.conflicts ?? []),
+            validationErrorsJson: JSON.stringify(input.validationErrors ?? []),
+            trustSummaryJson: JSON.stringify(input.trustSummary ?? {}),
+            createdAt,
+        })
+            .execute();
+        return auditId;
+    }
+    async getLatestAudit(snapshotId) {
+        const result = await this.obs.db
+            .select()
+            .from(connectorInventoryAudit)
+            .where(eq(connectorInventoryAudit.snapshotId, snapshotId))
+            .orderBy(desc(connectorInventoryAudit.createdAt))
+            .limit(1)
+            .execute();
+        if (!result || result.length === 0)
+            return undefined;
+        const row = result[0];
+        return this.rowToSnapshot(row);
+    }
+    async listAudits(opts) {
+        const limit = opts?.limit ?? 100;
+        const offset = opts?.offset ?? 0;
+        const rows = await this.obs.db
+            .select()
+            .from(connectorInventoryAudit)
+            .orderBy(desc(connectorInventoryAudit.createdAt))
+            .limit(limit)
+            .offset(offset)
+            .execute();
+        return rows.map((r) => this.rowToSnapshot(r));
+    }
+    rowToSnapshot(row) {
+        const r = row;
+        return {
+            auditId: String(r.auditId),
+            snapshotId: String(r.snapshotId),
+            scanned: Number(r.scanned),
+            registered: Number(r.registered),
+            skipped: Number(r.skipped),
+            conflicts: JSON.parse(String(r.conflictsJson ?? "[]")),
+            validationErrors: JSON.parse(String(r.validationErrorsJson ?? "[]")),
+            trustSummary: JSON.parse(String(r.trustSummaryJson ?? "{}")),
+            createdAt: String(r.createdAt),
+        };
+    }
+}

package/runtime/observability/db/index.js

@@ -83,6 +83,19 @@ const OBSERVABILITY_SCHEMA_SQL = `
     conflict_records_json TEXT NOT NULL,
     full_report_json TEXT NOT NULL
   );
+  CREATE TABLE IF NOT EXISTS connector_inventory_audit (
+    audit_id TEXT PRIMARY KEY,
+    snapshot_id TEXT NOT NULL,
+    scanned INTEGER NOT NULL,
+    registered INTEGER NOT NULL,
+    skipped INTEGER NOT NULL,
+    conflicts_json TEXT NOT NULL,
+    validation_errors_json TEXT NOT NULL,
+    trust_summary_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS connector_inventory_snapshot_idx ON connector_inventory_audit(snapshot_id);
+  CREATE INDEX IF NOT EXISTS connector_inventory_created_at_idx ON connector_inventory_audit(created_at);
 `;
 function resolveDbPath(filename) {
     if (path.isAbsolute(filename) || filename === ":memory:") {

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:") {