@haaaiawd/second-nature 0.1.6 → 0.1.7

package/index.js

@@ -1,3 +1,13 @@
+// @ts-ignore packaged runtime declarations are generated under plugin/runtime
+import { createCliRuntimeDeps, createCommandRouter } from "./runtime/cli/index.js";
+import { DecisionLedger } from "./runtime/observability/services/decision-ledger.js";
+import { ExecutionTelemetry } from "./runtime/observability/services/execution-telemetry.js";
+import { startRuntimeService, } from "./runtime/core/second-nature/runtime/service-entry.js";
+import { getLifecycleState, recordRegistration, } from "./runtime/core/second-nature/runtime/lifecycle-service.js";
+const INTERNAL_RUNTIME_PLATFORM_ID = "second-nature-runtime";
+const INTERNAL_RUNTIME_TRACE_PREFIX = "sn-runtime-";
+const INTERNAL_RUNTIME_CHANNEL = "plugin_host";
+let activationSpine = null;
 function createFallbackCommands() {
     const commandNames = ["status", "policy", "credential", "quiet", "report", "session", "audit", "explain"];
     return commandNames.map((name) => ({
@@ -10,16 +20,7 @@ function createFallbackCommands() {
         }),
     }));
 }
-async function resolveCommandRouterSafe() {
-    try {
-        const mod = await import("./runtime/cli/index.js");
-        if (mod?.createCommandRouter) {
-            return mod.createCommandRouter();
-        }
-    }
-    catch {
-        // fall through to fallback router
-    }
+function createFallbackRouter() {
     const commands = createFallbackCommands();
     return {
         commands,
@@ -28,51 +29,190 @@ async function resolveCommandRouterSafe() {
         },
     };
 }
-async function createRuntimeService() {
+function ensureActivationSpine() {
+    if (activationSpine) {
+        return activationSpine;
+    }
     try {
-        const runtimeMod = await import("./runtime/core/second-nature/runtime/service-entry.js");
-        if (runtimeMod?.startRuntimeService) {
-            const handle = runtimeMod.startRuntimeService();
-            return {
-                id: "second-nature-runtime",
-                start() {
-                    return { ready: handle.ready, version: handle.version };
-                },
-            };
-        }
+        const runtimeDeps = createCliRuntimeDeps();
+        const router = createCommandRouter({ deps: runtimeDeps });
+        activationSpine = {
+            runtimeDeps,
+            router,
+            decisionLedger: new DecisionLedger(runtimeDeps.observabilityDb),
+            executionTelemetry: new ExecutionTelemetry(runtimeDeps.observabilityDb),
+            runtimeHandle: startRuntimeService({ workspaceRoot: process.cwd() }),
+            lifecycleState: getLifecycleState(),
+            serviceStartRecorded: false,
+        };
+        return activationSpine;
     }
     catch {
-        // fall through to minimal service shell
+        activationSpine = {
+            router: createFallbackRouter(),
+            runtimeHandle: { ready: true, version: "0.1.7-minimal", close() { } },
+            lifecycleState: getLifecycleState(),
+            serviceStartRecorded: false,
+        };
+        return activationSpine;
+    }
+}
+function refreshRegistrationState() {
+    const spine = ensureActivationSpine();
+    spine.runtimeHandle = startRuntimeService({ workspaceRoot: process.cwd() });
+    spine.lifecycleState = recordRegistration();
+    spine.serviceStartRecorded = false;
+    recordRuntimeEvidence(spine, "register");
+    return spine;
+}
+function recordRuntimeEvidence(spine, origin) {
+    const decisionLedger = spine.decisionLedger;
+    const executionTelemetry = spine.executionTelemetry;
+    if (!decisionLedger || !executionTelemetry) {
+        return;
+    }
+    if (origin === "service_start" && spine.serviceStartRecorded) {
+        return;
+    }
+    if (origin === "service_start") {
+        spine.serviceStartRecorded = true;
+    }
+    const now = new Date().toISOString();
+    const traceId = `${INTERNAL_RUNTIME_TRACE_PREFIX}${origin}-${spine.lifecycleState.registerCount}-${Date.now()}`;
+    const decisionId = `decision-${traceId}`;
+    const tickId = `tick-${traceId}`;
+    const intentId = `intent-${traceId}`;
+    const capability = origin === "register"
+        ? spine.lifecycleState.registerCount === 1
+            ? "runtime.activate"
+            : "runtime.reload"
+        : "runtime.heartbeat";
+    void (async () => {
+        await decisionLedger.recordHeartbeatDecision({
+            id: decisionId,
+            tickId,
+            traceId,
+            intentId,
+            runtimeScope: "rhythm",
+            triggerSource: "heartbeat_bridge",
+            decisionStatus: "heartbeat_ok",
+            reasons: [
+                `origin:${origin}`,
+                `phase:${spine.lifecycleState.phase}`,
+                `registrations:${spine.lifecycleState.registerCount}`,
+            ],
+            mode: "active",
+            createdAt: now,
+        });
+        await executionTelemetry.startAttempt({
+            traceId,
+            decisionId,
+            intentId,
+            platformId: INTERNAL_RUNTIME_PLATFORM_ID,
+            capability,
+            channel: INTERNAL_RUNTIME_CHANNEL,
+            status: "started",
+            startedAt: now,
+        });
+        await executionTelemetry.completeAttempt(traceId, "succeeded", "committed");
+    })().catch(() => {
+        if (origin === "service_start") {
+            spine.serviceStartRecorded = false;
+        }
+    });
+}
+function parseCommandInput(rawArgs) {
+    const tokens = rawArgs?.trim().split(/\s+/).filter(Boolean) ?? [];
+    if (tokens.length === 0) {
+        return {
+            ok: false,
+            result: { ok: false, message: "Missing command argument." },
+        };
+    }
+    const [command, ...rest] = tokens;
+    if (command === "policy" && rest[0] === "set") {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                command,
+                message: "policy set requires structured args; use second_nature_ops instead.",
+            },
+        };
+    }
+    if (command === "credential" && rest[0] === "verify") {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                command,
+                message: "credential verify requires structured args; use second_nature_ops instead.",
+            },
+        };
     }
+    switch (command) {
+        case "status":
+        case "quiet":
+            return {
+                ok: true,
+                command,
+                input: rest.length > 0 ? { scope: rest.join(" ") } : undefined,
+            };
+        case "report":
+            return {
+                ok: true,
+                command,
+                input: rest[0] ? { day: rest[0] } : undefined,
+            };
+        case "session":
+            return {
+                ok: true,
+                command,
+                input: rest[0] ? { sessionId: rest[0] } : undefined,
+            };
+        case "credential":
+            return {
+                ok: true,
+                command,
+                input: rest[0] ? { platformId: rest[0] } : undefined,
+            };
+        case "explain":
+            return {
+                ok: true,
+                command,
+                input: rest.length > 0 ? { subject: rest.join(" ") } : undefined,
+            };
+        default:
+            return {
+                ok: true,
+                command,
+                input: undefined,
+            };
+    }
+}
+function createRuntimeService() {
     return {
         id: "second-nature-runtime",
         start() {
-            return { ready: true, version: "0.1.6-minimal" };
+            const spine = ensureActivationSpine();
+            recordRuntimeEvidence(spine, "service_start");
+            return {
+                ready: spine.runtimeHandle.ready,
+                version: spine.runtimeHandle.version,
+            };
         },
     };
 }
-async function createLifecycleService() {
-    try {
-        const lifecycleMod = await import("./runtime/core/second-nature/runtime/lifecycle-service.js");
-        if (lifecycleMod?.recordRegistration) {
-            return {
-                id: "second-nature-lifecycle",
-                start() {
-                    const state = lifecycleMod.recordRegistration();
-                    return { phase: state.phase, registerCount: state.registerCount };
-                },
-            };
-        }
-    }
-    catch {
-        // fall through to minimal lifecycle shell
-    }
-    let registerCount = 0;
+function createLifecycleService() {
     return {
         id: "second-nature-lifecycle",
         start() {
-            registerCount += 1;
-            return { phase: registerCount === 1 ? "loading" : "reloading", registerCount };
+            const spine = ensureActivationSpine();
+            return {
+                phase: spine.lifecycleState.phase,
+                registerCount: spine.lifecycleState.registerCount,
+                lastChangedAt: spine.lifecycleState.lastChangedAt,
+            };
         },
     };
 }
@@ -80,33 +220,30 @@ export default {
     id: "second-nature",
     name: "Second Nature",
     description: "Registers command/tool/service surface with load-reload lifecycle semantics.",
-    async register(api) {
-        const router = await resolveCommandRouterSafe();
-        const runtimeService = await createRuntimeService();
-        const lifecycleService = await createLifecycleService();
+    register(api) {
+        const spine = refreshRegistrationState();
+        const runtimeService = createRuntimeService();
+        const lifecycleService = createLifecycleService();
         api.registerService(runtimeService);
         api.registerService(lifecycleService);
-        api.registerCli(({ program }) => {
-            void program;
-        }, { commands: ["second-nature"] });
         api.registerCommand({
             name: "second-nature",
             description: "Route Agent-facing operational commands for Second Nature.",
             acceptsArgs: true,
             handler: async (ctx) => {
-                const command = ctx.args?.trim();
-                if (!command) {
+                const parsed = parseCommandInput(ctx.args);
+                if (!parsed.ok) {
                     return {
-                        text: JSON.stringify({ ok: false, message: "Missing command argument." }),
+                        text: JSON.stringify(parsed.result),
                     };
                 }
-                const resolved = router.resolve(command);
+                const resolved = spine.router.resolve(parsed.command);
                 if (!resolved) {
                     return {
-                        text: JSON.stringify({ ok: false, command, message: "Unknown Second Nature command." }),
+                        text: JSON.stringify({ ok: false, command: parsed.command, message: "Unknown Second Nature command." }),
                     };
                 }
-                const result = await resolved.execute();
+                const result = await resolved.execute(parsed.input);
                 return {
                     text: JSON.stringify(result),
                 };
@@ -120,12 +257,12 @@ export default {
                 additionalProperties: false,
                 properties: {
                     command: { type: "string" },
-                    args: { type: "object", additionalProperties: true }
+                    args: { type: "object", additionalProperties: true },
                 },
-                required: ["command"]
+                required: ["command"],
             },
             async execute(_id, params) {
-                const resolved = router.resolve(params.command);
+                const resolved = spine.router.resolve(params.command);
                 if (!resolved) {
                     return {
                         content: [

package/openclaw.plugin.json

@@ -1,13 +1,20 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "entry": "./index.js",
-  "description": "OpenClaw native plugin package for continuity, explain, and recovery operations.",
+  "description": "OpenClaw native plugin package with synchronous surface registration and a bundled runtime spine.",
   "capabilities": {
-    "commands": ["second-nature"],
-    "tools": ["second_nature_ops"],
-    "services": ["second-nature-runtime", "second-nature-lifecycle"]
+    "commands": [
+      "second-nature"
+    ],
+    "tools": [
+      "second_nature_ops"
+    ],
+    "services": [
+      "second-nature-runtime",
+      "second-nature-lifecycle"
+    ]
   },
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.6",
-  "description": "OpenClaw native plugin for long-running agent continuity, Quiet memory curation, and explainable operator flows.",
+  "version": "0.1.7",
+  "description": "OpenClaw native plugin with synchronous registration, a packaged runtime artifact, and operator-facing status/explain flows.",
   "keywords": [
     "openclaw",
     "plugin",

package/runtime/cli/read-models/index.js

@@ -1,9 +1,11 @@
+import { desc } from "drizzle-orm";
 import { createQuietInputLoader } from "../../storage/services/quiet-input-loader.js";
 import { AssetRepository } from "../../storage/repositories/asset-repository.js";
 import { CredentialRepository } from "../../storage/repositories/credential-repository.js";
 import { EvidenceQueryEngine } from "../../observability/query/evidence-query-engine.js";
-import { executionAttempts } from "../../observability/db/schema/index.js";
-import { desc } from "drizzle-orm";
+import { decisionLedger, executionAttempts } from "../../observability/db/schema/index.js";
+const INTERNAL_RUNTIME_PLATFORM_ID = "second-nature-runtime";
+const INTERNAL_RUNTIME_TRACE_PREFIX = "sn-runtime-";
 function buildCredentialNextStep(status) {
     if (status === "pending_verification")
         return "submit_verification_answer";
@@ -11,6 +13,24 @@ function buildCredentialNextStep(status) {
         return "refresh_credential_context";
     return undefined;
 }
+function mapRuntimeStatus(attempt) {
+    if (!attempt) {
+        return "unknown";
+    }
+    if (attempt.failureClass || attempt.status === "failed") {
+        return "degraded";
+    }
+    return "running";
+}
+function mapConnectorStatus(attempt) {
+    if (!attempt) {
+        return "unknown";
+    }
+    if (attempt.failureClass || attempt.status === "failed") {
+        return "degraded";
+    }
+    return "healthy";
+}
 export function createCliReadModels(deps) {
     const assetRepository = new AssetRepository(deps.stateDb);
     const credentialRepository = new CredentialRepository(deps.stateDb);
@@ -18,15 +38,28 @@ export function createCliReadModels(deps) {
     const evidenceQuery = new EvidenceQueryEngine(deps.observabilityDb);
     return {
         async loadStatus(_scope) {
-            let latestAttempt;
+            let recentAttempts = [];
+            let recentDecisions = [];
             let credentials = [];
             try {
-                latestAttempt = await deps.observabilityDb.db.query.executionAttempts.findFirst({
-                    orderBy: [desc(executionAttempts.startedAt)],
-                });
+                recentAttempts = await deps.observabilityDb.db
+                    .select()
+                    .from(executionAttempts)
+                    .orderBy(desc(executionAttempts.startedAt), desc(executionAttempts.finishedAt))
+                    .limit(50);
+            }
+            catch {
+                recentAttempts = [];
+            }
+            try {
+                recentDecisions = await deps.observabilityDb.db
+                    .select()
+                    .from(decisionLedger)
+                    .orderBy(desc(decisionLedger.createdAt))
+                    .limit(50);
             }
             catch {
-                latestAttempt = undefined;
+                recentDecisions = [];
             }
             try {
                 credentials = await deps.stateDb.db.query.credentialRecords.findMany();
@@ -34,28 +67,40 @@ export function createCliReadModels(deps) {
             catch {
                 credentials = [];
             }
-            const connectorSummary = latestAttempt
-                ? [{
-                        platformId: latestAttempt.platformId,
-                        status: latestAttempt.failureClass ? "degraded" : "healthy",
-                        channel: latestAttempt.channel,
-                        failureClass: latestAttempt.failureClass ?? undefined,
-                    }]
+            const latestRuntimeAttempt = recentAttempts.find((attempt) => attempt.platformId === INTERNAL_RUNTIME_PLATFORM_ID);
+            const latestConnectorAttempt = recentAttempts.find((attempt) => attempt.platformId !== INTERNAL_RUNTIME_PLATFORM_ID);
+            const latestRuntimeDecision = recentDecisions.find((decision) => decision.traceId.startsWith(INTERNAL_RUNTIME_TRACE_PREFIX));
+            const runtimeUpdatedAt = latestRuntimeAttempt?.finishedAt ?? latestRuntimeAttempt?.startedAt ?? latestRuntimeDecision?.createdAt ?? "";
+            const quietMode = latestRuntimeDecision?.mode === "quiet" ||
+                latestRuntimeDecision?.mode === "maintenance_only" ||
+                latestRuntimeDecision?.mode === "paused_for_interrupt"
+                ? latestRuntimeDecision.mode
+                : "unknown";
+            const riskFlags = [latestRuntimeAttempt?.failureClass, latestConnectorAttempt?.failureClass].filter((value) => Boolean(value));
+            const connectorSummary = latestConnectorAttempt
+                ? [
+                    {
+                        platformId: latestConnectorAttempt.platformId,
+                        status: mapConnectorStatus(latestConnectorAttempt),
+                        channel: latestConnectorAttempt.channel,
+                        failureClass: latestConnectorAttempt.failureClass ?? undefined,
+                    },
+                ]
                 : [];
             return {
                 runtime: {
                     host: "openclaw-plugin",
-                    serviceStatus: latestAttempt ? (latestAttempt.failureClass ? "degraded" : "running") : "unknown",
-                    updatedAt: new Date().toISOString(),
+                    serviceStatus: mapRuntimeStatus(latestRuntimeAttempt),
+                    updatedAt: runtimeUpdatedAt,
                 },
                 rhythm: {
-                    mode: "unknown",
+                    mode: latestRuntimeDecision?.mode ?? "unknown",
                     windowId: undefined,
                 },
                 quiet: {
-                    mode: "unknown",
-                    lastEvent: undefined,
-                    interrupted: undefined,
+                    mode: quietMode,
+                    lastEvent: latestRuntimeDecision?.traceId,
+                    interrupted: latestRuntimeDecision?.mode === "paused_for_interrupt" ? true : undefined,
                 },
                 connectors: connectorSummary,
                 credentials: credentials.map((item) => ({
@@ -64,8 +109,8 @@ export function createCliReadModels(deps) {
                     nextStep: buildCredentialNextStep(item.status),
                 })),
                 risk: {
-                    level: latestAttempt?.failureClass ? "medium" : "low",
-                    flags: latestAttempt?.failureClass ? [latestAttempt.failureClass] : [],
+                    level: riskFlags.length > 0 ? "medium" : "low",
+                    flags: riskFlags,
                 },
             };
         },

package/runtime/observability/db/index.js

@@ -6,6 +6,73 @@ import { fileURLToPath } from "node:url";
 import * as schema from "./schema/index.js";
 // Pre-initialize sql.js WASM at module load time
 const SQL = await initSqlJs();
+const OBSERVABILITY_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS decision_ledger (
+    id TEXT PRIMARY KEY,
+    tick_id TEXT NOT NULL,
+    trace_id TEXT NOT NULL,
+    intent_id TEXT,
+    platform_id TEXT,
+    verdict TEXT NOT NULL,
+    mode TEXT NOT NULL,
+    reasons TEXT NOT NULL,
+    reason_codes TEXT NOT NULL,
+    decision_basis TEXT NOT NULL,
+    evidence_refs TEXT NOT NULL,
+    model_eval_ref TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS decision_trace_idx ON decision_ledger(trace_id);
+  CREATE INDEX IF NOT EXISTS decision_tick_idx ON decision_ledger(tick_id);
+  CREATE TABLE IF NOT EXISTS execution_attempts (
+    id TEXT PRIMARY KEY,
+    trace_id TEXT NOT NULL,
+    decision_id TEXT NOT NULL,
+    intent_id TEXT NOT NULL,
+    platform_id TEXT NOT NULL,
+    capability TEXT NOT NULL,
+    channel TEXT NOT NULL,
+    status TEXT NOT NULL,
+    commit_state TEXT,
+    failure_class TEXT,
+    retry_policy TEXT,
+    idempotency_key TEXT,
+    started_at TEXT,
+    finished_at TEXT
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS attempt_trace_idx ON execution_attempts(trace_id);
+  CREATE INDEX IF NOT EXISTS attempt_decision_idx ON execution_attempts(decision_id);
+  CREATE INDEX IF NOT EXISTS attempt_platform_idx ON execution_attempts(platform_id);
+  CREATE TABLE IF NOT EXISTS governance_audit (
+    id TEXT PRIMARY KEY,
+    event_type TEXT NOT NULL,
+    proposal_id TEXT,
+    target_asset_id TEXT,
+    asset_path TEXT,
+    status_from TEXT,
+    status_to TEXT NOT NULL,
+    before_hash TEXT,
+    after_hash TEXT,
+    supporting_sources TEXT,
+    reason TEXT,
+    verification_deadline TEXT,
+    attempts_remaining INTEGER,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS audit_proposal_idx ON governance_audit(proposal_id);
+  CREATE INDEX IF NOT EXISTS audit_asset_idx ON governance_audit(target_asset_id);
+  CREATE INDEX IF NOT EXISTS audit_event_idx ON governance_audit(event_type);
+  CREATE TABLE IF NOT EXISTS redaction_manifest (
+    id TEXT PRIMARY KEY,
+    event_id TEXT NOT NULL,
+    event_type TEXT NOT NULL,
+    field_name TEXT NOT NULL,
+    action TEXT NOT NULL,
+    original_value_hash TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS redact_event_idx ON redaction_manifest(event_id);
+`;
 function resolveDbPath(filename) {
     if (path.isAbsolute(filename) || filename === ":memory:") {
         return filename;
@@ -18,6 +85,9 @@ function resolveDbPath(filename) {
     }
     return path.join(dataDir, filename);
 }
+function bootstrapObservabilitySchema(sqlite) {
+    sqlite.exec(OBSERVABILITY_SCHEMA_SQL);
+}
 export function createObservabilityDatabase(filename = "observability.db") {
     const dbPath = resolveDbPath(filename);
     const isMemory = filename === ":memory:";
@@ -26,6 +96,7 @@ export function createObservabilityDatabase(filename = "observability.db") {
         dbBuffer = fs.readFileSync(dbPath);
     }
     const sqlite = new SQL.Database(dbBuffer);
+    bootstrapObservabilitySchema(sqlite);
     const db = drizzle(sqlite, { schema });
     return {
         sqlite,

package/runtime/storage/db/index.js

@@ -6,6 +6,65 @@ import { fileURLToPath } from "node:url";
 import * as schema from "./schema/index.js";
 // Pre-initialize sql.js WASM at module load time
 const SQL = await initSqlJs();
+const STATE_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS credential_records (
+    platform_id TEXT PRIMARY KEY,
+    credential_type TEXT NOT NULL,
+    encrypted_value TEXT NOT NULL,
+    status TEXT NOT NULL,
+    verification_code TEXT,
+    challenge_text TEXT,
+    expires_at TEXT,
+    attempts_remaining INTEGER,
+    updated_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS policy_records (
+    platform_id TEXT PRIMARY KEY,
+    social_daily_limit INTEGER NOT NULL,
+    quiet_enabled INTEGER NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS asset_registry (
+    id TEXT PRIMARY KEY,
+    kind TEXT NOT NULL,
+    path TEXT NOT NULL,
+    hash TEXT NOT NULL,
+    version INTEGER NOT NULL DEFAULT 1,
+    layer TEXT NOT NULL,
+    last_indexed_at TEXT NOT NULL
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS asset_registry_path_idx ON asset_registry(path);
+  CREATE TABLE IF NOT EXISTS intent_commit_records (
+    id TEXT PRIMARY KEY,
+    intent_id TEXT NOT NULL,
+    decision_id TEXT NOT NULL,
+    checkpoint_id TEXT,
+    state TEXT NOT NULL,
+    outcome_ref TEXT,
+    metadata_json TEXT,
+    updated_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS proposal_records (
+    id TEXT PRIMARY KEY,
+    target_asset_id TEXT NOT NULL,
+    before_hash TEXT,
+    after_hash TEXT,
+    status TEXT NOT NULL,
+    proposed_diff TEXT NOT NULL,
+    reason TEXT NOT NULL,
+    supporting_sources TEXT NOT NULL,
+    confidence REAL NOT NULL,
+    created_at TEXT NOT NULL,
+    applied_at TEXT
+  );
+  CREATE TABLE IF NOT EXISTS provenance_edges (
+    id TEXT PRIMARY KEY,
+    from_id TEXT NOT NULL,
+    to_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+`;
 function resolveDbPath(filename) {
     if (path.isAbsolute(filename) || filename === ":memory:") {
         return filename;
@@ -18,6 +77,9 @@ function resolveDbPath(filename) {
     }
     return path.join(dataDir, filename);
 }
+function bootstrapStateSchema(sqlite) {
+    sqlite.exec(STATE_SCHEMA_SQL);
+}
 export function createStateDatabase(filename = "state.db") {
     const dbPath = resolveDbPath(filename);
     const isMemory = filename === ":memory:";
@@ -26,6 +88,7 @@ export function createStateDatabase(filename = "state.db") {
         dbBuffer = fs.readFileSync(dbPath);
     }
     const sqlite = new SQL.Database(dbBuffer);
+    bootstrapStateSchema(sqlite);
     const db = drizzle(sqlite, { schema });
     return {
         sqlite,

package/runtime/cli/action-bridge.d.ts

@@ -1,11 +0,0 @@
-import type { StateAPI } from "../storage/state-api.js";
-export interface PolicyWriteInput {
-    platformId: string;
-    socialDailyLimit: number;
-    quietEnabled: boolean;
-}
-export interface ActionBridge {
-    savePolicy(input: PolicyWriteInput): Promise<void>;
-    verifyCredential(platformId: string, answer: string): Promise<void>;
-}
-export declare function createActionBridge(stateApi: StateAPI): ActionBridge;

package/runtime/cli/index.d.ts

@@ -1,25 +0,0 @@
-import { type ObservabilityDatabase } from "../observability/db/index.js";
-import { type StateDatabase, type StateAPI } from "../storage/index.js";
-import { type ActionBridge } from "./action-bridge.js";
-import { type CliCommandDefinition } from "./commands/index.js";
-import { type CliReadModels } from "./read-models/index.js";
-export interface CommandRouter {
-    commands: CliCommandDefinition[];
-    resolve(name: string): CliCommandDefinition | undefined;
-}
-export interface CommandRouterDeps {
-    commands: CliCommandDefinition[];
-}
-export interface CliRuntimeDeps {
-    stateDb: StateDatabase;
-    observabilityDb: ObservabilityDatabase;
-    stateApi: StateAPI;
-    readModels: CliReadModels;
-    actionBridge: ActionBridge;
-}
-export interface CreateCommandRouterOptions {
-    deps?: Partial<CliRuntimeDeps>;
-}
-export declare function createCliRuntimeDeps(overrides?: Partial<CliRuntimeDeps>): CliRuntimeDeps;
-export declare function createCommandRouter(options?: CreateCommandRouterOptions): CommandRouter;
-export declare function closeCliRuntimeDeps(deps: Pick<CliRuntimeDeps, "stateDb" | "observabilityDb">): void;