@haaaiawd/second-nature 0.1.1 → 0.1.2

package/index.ts

@@ -12,10 +12,6 @@ interface RegisterApi {
   registerTool(tool: unknown, options?: unknown): void;
 }
 
-const lifecycleState = {
-  registerCount: 0,
-};
-
 function createFallbackCommands(): Array<{
   name: string;
   description: string;
@@ -41,7 +37,7 @@ function resolveCommandRouterSafe(): {
   const require = createRequire(import.meta.url);
 
   try {
-    const mod = require("../src/cli/index.js") as { createCommandRouter: () => { commands: any[]; resolve: (name: string) => any } };
+    const mod = require("./runtime/cli/index.js") as { createCommandRouter: () => { commands: any[]; resolve: (name: string) => any } };
     if (mod?.createCommandRouter) {
       return mod.createCommandRouter();
     }
@@ -58,30 +54,77 @@ function resolveCommandRouterSafe(): {
   };
 }
 
-const serviceShell = {
-  id: "second-nature-runtime",
-  start() {
-    return;
-  },
-};
+function createRuntimeService(): { id: string; start: () => unknown } {
+  const require = createRequire(import.meta.url);
+
+  try {
+    const runtimeMod = require("./runtime/core/second-nature/runtime/service-entry.js") as {
+      startRuntimeService: (ctx?: Record<string, unknown>) => { ready: boolean; version: string; close: () => void };
+    };
+
+    if (runtimeMod?.startRuntimeService) {
+      const handle = runtimeMod.startRuntimeService();
+      return {
+        id: "second-nature-runtime",
+        start() {
+          return { ready: handle.ready, version: handle.version };
+        },
+      };
+    }
+  } catch {
+    // fall through to minimal service shell
+  }
+
+  return {
+    id: "second-nature-runtime",
+    start() {
+      return { ready: true, version: "0.1.0-minimal" };
+    },
+  };
+}
+
+function createLifecycleService(): { id: string; start: () => unknown } {
+  const require = createRequire(import.meta.url);
+
+  try {
+    const lifecycleMod = require("./runtime/core/second-nature/runtime/lifecycle-service.js") as {
+      recordRegistration: () => { registerCount: number; phase: string; lastChangedAt: number };
+    };
+
+    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;
+  return {
+    id: "second-nature-lifecycle",
+    start() {
+      registerCount += 1;
+      return { phase: registerCount === 1 ? "loading" : "reloading", registerCount };
+    },
+  };
+}
 
 export default {
   id: "second-nature",
   name: "Second Nature",
   description: "Registers command/tool/service surface with load-reload lifecycle semantics.",
   register(api: RegisterApi) {
-    lifecycleState.registerCount += 1;
-    const lifecycleEvent = lifecycleState.registerCount === 1 ? "load" : "reload";
     const router = resolveCommandRouterSafe();
+    const runtimeService = createRuntimeService();
+    const lifecycleService = createLifecycleService();
 
-    api.registerService(serviceShell);
-
-    api.registerService({
-      id: "second-nature-lifecycle",
-      start() {
-        return;
-      },
-    });
+    api.registerService(runtimeService);
+    api.registerService(lifecycleService);
 
     api.registerCli(
       ({ program }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "OpenClaw native plugin for long-running agent continuity, Quiet memory curation, and explainable operator flows.",
   "keywords": [
     "openclaw",
@@ -17,7 +17,8 @@
   "main": "./index.ts",
   "files": [
     "index.ts",
-    "openclaw.plugin.json"
+    "openclaw.plugin.json",
+    "runtime/"
   ],
   "publishConfig": {
     "access": "public"
@@ -27,5 +28,10 @@
     "extensions": [
       "./index.ts"
     ]
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.10.0",
+    "drizzle-orm": "^0.44.4",
+    "zod": "^4.1.5"
   }
 }

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

@@ -0,0 +1,11 @@
+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/action-bridge.js

@@ -0,0 +1,27 @@
+export function createActionBridge(stateApi) {
+    return {
+        async savePolicy(input) {
+            await stateApi.write.savePolicy(input);
+        },
+        async verifyCredential(platformId, answer) {
+            const existing = await stateApi.credentials.loadCredentialContext(platformId);
+            if (!existing) {
+                throw new Error("credential_context_not_found");
+            }
+            const isPending = existing.status === "pending_verification";
+            if (!isPending) {
+                throw new Error("credential_not_pending_verification");
+            }
+            if (!answer.trim()) {
+                throw new Error("verification_answer_required");
+            }
+            await stateApi.credentials.saveCredentialContext({
+                ...existing,
+                status: "active",
+                verificationCode: answer,
+                encryptedValue: existing.encryptedValue,
+                updatedAt: new Date().toISOString(),
+            });
+        },
+    };
+}

package/runtime/cli/commands/credential.d.ts

@@ -0,0 +1,2 @@
+import type { ActionBridge } from "../action-bridge.js";
+export declare function credentialVerify(bridge: ActionBridge, input?: Record<string, unknown>): Promise<Record<string, unknown>>;

package/runtime/cli/commands/credential.js

@@ -0,0 +1,40 @@
+export async function credentialVerify(bridge, input) {
+    const platformId = typeof input?.platformId === "string" ? input.platformId.trim() : "";
+    const answer = typeof input?.answer === "string" ? input.answer.trim() : "";
+    const requiredUserInput = [];
+    if (!platformId)
+        requiredUserInput.push("platform_id");
+    if (!answer)
+        requiredUserInput.push("verification_answer");
+    if (requiredUserInput.length > 0) {
+        return {
+            ok: false,
+            error: {
+                code: "MISSING_VERIFICATION_FIELDS",
+                message: "credential verify requires platform and answer",
+                requiredUserInput,
+                nextStep: "reinvoke_credential_verify_with_required_fields",
+            },
+        };
+    }
+    try {
+        await bridge.verifyCredential(platformId, answer);
+        return {
+            ok: true,
+            data: {
+                platformId,
+                verified: true,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: {
+                code: "CREDENTIAL_VERIFY_FAILED",
+                message: String(error),
+                nextStep: "inspect_credential_status_then_retry_verify",
+            },
+        };
+    }
+}

package/runtime/cli/commands/index.d.ts

@@ -0,0 +1,12 @@
+import type { ActionBridge } from "../action-bridge.js";
+import type { CliReadModels } from "../read-models/index.js";
+export interface CliCommandDefinition {
+    name: string;
+    description: string;
+    execute(input?: Record<string, unknown>): Promise<Record<string, unknown>>;
+}
+export interface CliCommandDeps {
+    readModels: CliReadModels;
+    actionBridge: ActionBridge;
+}
+export declare function createCliCommands(deps: CliCommandDeps): CliCommandDefinition[];

package/runtime/cli/commands/index.js

@@ -0,0 +1,138 @@
+import { credentialVerify } from "./credential.js";
+import { formatExplanation } from "../explain/format-explanation.js";
+import { resolveExplainSubject } from "../explain/resolve-subject.js";
+import { policySet } from "./policy.js";
+const notImplemented = async (command) => ({
+    ok: false,
+    command,
+    message: "Command shell registered. Implementation lands in later Wave tasks.",
+});
+function explainSubjectError(code, message) {
+    return {
+        ok: false,
+        error: {
+            code,
+            message,
+            requiredUserInput: ["subject"],
+            nextStep: "reinvoke_explain_with_supported_subject",
+        },
+    };
+}
+export function createCliCommands(deps) {
+    const { readModels, actionBridge } = deps;
+    return [
+        {
+            name: "status",
+            description: "Show aggregated Second Nature status",
+            execute: async (input) => {
+                const scope = typeof input?.scope === "string" ? input.scope : undefined;
+                const data = await readModels.loadStatus(scope);
+                return { ok: true, data };
+            },
+        },
+        {
+            name: "policy",
+            description: "Write or inspect policy state",
+            execute: async (input) => {
+                const action = typeof input?.action === "string" ? input.action : "show";
+                if (action === "set") {
+                    return policySet(actionBridge, input);
+                }
+                return notImplemented("policy");
+            },
+        },
+        {
+            name: "credential",
+            description: "Inspect or recover credential state",
+            execute: async (input) => {
+                const action = typeof input?.action === "string" ? input.action : "show";
+                if (action === "verify") {
+                    return credentialVerify(actionBridge, input);
+                }
+                const platformId = typeof input?.platformId === "string" ? input.platformId : "unknown";
+                const data = await readModels.loadCredential(platformId);
+                return { ok: true, data };
+            },
+        },
+        {
+            name: "quiet",
+            description: "Inspect Quiet lifecycle state",
+            execute: async (input) => {
+                const scope = typeof input?.scope === "string" ? input.scope : undefined;
+                const data = await readModels.loadQuiet(scope);
+                return { ok: true, data };
+            },
+        },
+        {
+            name: "report",
+            description: "Show daily report artifacts",
+            execute: async (input) => {
+                const day = typeof input?.day === "string" ? input.day : new Date().toISOString().slice(0, 10);
+                const data = await readModels.loadDailyReport(day);
+                return { ok: true, data };
+            },
+        },
+        {
+            name: "session",
+            description: "Inspect continuity session details",
+            execute: async (input) => {
+                const sessionId = typeof input?.sessionId === "string" ? input.sessionId : "";
+                if (!sessionId) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "MISSING_SESSION_ID",
+                            message: "session show requires sessionId",
+                            requiredUserInput: ["session_id"],
+                            nextStep: "reinvoke_session_with_session_id",
+                        },
+                    };
+                }
+                const data = await readModels.loadSession(sessionId);
+                return { ok: true, data };
+            },
+        },
+        {
+            name: "audit",
+            description: "Inspect audit and evidence views",
+            execute: () => notImplemented("audit"),
+        },
+        {
+            name: "explain",
+            description: "Answer why-question explain requests",
+            execute: async (input) => {
+                const subjectRaw = typeof input?.subject === "string" ? input.subject.trim() : "";
+                if (!subjectRaw) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "MISSING_EXPLAIN_SUBJECT",
+                            message: "explain requires subject",
+                            requiredUserInput: ["subject"],
+                            nextStep: "reinvoke_explain_with_subject",
+                        },
+                    };
+                }
+                let subject;
+                try {
+                    subject = resolveExplainSubject(subjectRaw);
+                }
+                catch (error) {
+                    const code = error.message;
+                    if (code === "explain_subject_requires_id") {
+                        return explainSubjectError("EXPLAIN_SUBJECT_REQUIRES_ID", "subject must include identifier");
+                    }
+                    if (code === "explain_subject_unsupported") {
+                        return explainSubjectError("EXPLAIN_SUBJECT_UNSUPPORTED", "supported subjects are decision:<id>, platform:<id>, outreach:<id>, soul:<id>");
+                    }
+                    return explainSubjectError("EXPLAIN_SUBJECT_INVALID", "invalid explain subject");
+                }
+                const model = await readModels.explain(subject);
+                return {
+                    ok: true,
+                    data: formatExplanation(model),
+                };
+            },
+        },
+    ];
+}

package/runtime/cli/commands/policy.d.ts

@@ -0,0 +1,12 @@
+import type { ActionBridge } from "../action-bridge.js";
+export interface CliResult<T = Record<string, unknown>> {
+    ok: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+        requiredUserInput?: string[];
+        nextStep?: string;
+    };
+}
+export declare function policySet(bridge: ActionBridge, input?: Record<string, unknown>): Promise<Record<string, unknown>>;

package/runtime/cli/commands/policy.js

@@ -0,0 +1,43 @@
+function toNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+export async function policySet(bridge, input) {
+    const platformId = typeof input?.platformId === "string" ? input.platformId.trim() : "";
+    const socialDailyLimit = toNumber(input?.socialDailyLimit);
+    const quietEnabled = typeof input?.quietEnabled === "boolean" ? input.quietEnabled : undefined;
+    const requiredUserInput = [];
+    if (!platformId)
+        requiredUserInput.push("platform_id");
+    if (socialDailyLimit === undefined)
+        requiredUserInput.push("social_daily_limit");
+    if (quietEnabled === undefined)
+        requiredUserInput.push("quiet_enabled");
+    if (requiredUserInput.length > 0) {
+        return {
+            ok: false,
+            error: {
+                code: "MISSING_POLICY_FIELDS",
+                message: "policy set requires complete non-interactive fields",
+                requiredUserInput,
+                nextStep: "reinvoke_policy_set_with_required_fields",
+            },
+        };
+    }
+    const payload = {
+        platformId,
+        socialDailyLimit: socialDailyLimit,
+        quietEnabled: quietEnabled,
+    };
+    await bridge.savePolicy(payload);
+    return {
+        ok: true,
+        data: { platformId },
+    };
+}

package/runtime/cli/explain/format-explanation.d.ts

@@ -0,0 +1,10 @@
+import type { ExplainReadModel } from "../read-models/types.js";
+export interface FormattedExplanation {
+    subjectType: ExplainReadModel["subjectType"];
+    conclusion: string;
+    keyFactors: string[];
+    evidenceRefs: string[];
+    requiredUserInput?: string[];
+    nextStep?: string;
+}
+export declare function formatExplanation(model: ExplainReadModel): FormattedExplanation;

package/runtime/cli/explain/format-explanation.js

@@ -0,0 +1,10 @@
+export function formatExplanation(model) {
+    return {
+        subjectType: model.subjectType,
+        conclusion: model.conclusion,
+        keyFactors: model.keyFactors,
+        evidenceRefs: model.evidenceRefs,
+        requiredUserInput: model.requiredUserInput,
+        nextStep: model.nextStep,
+    };
+}

package/runtime/cli/explain/resolve-subject.d.ts

@@ -0,0 +1,2 @@
+import type { ExplainSubject } from "../read-models/index.js";
+export declare function resolveExplainSubject(raw: string): ExplainSubject;

package/runtime/cli/explain/resolve-subject.js

@@ -0,0 +1,26 @@
+function splitSubject(raw) {
+    const [prefix, ...rest] = raw.split(":");
+    return {
+        prefix: (prefix ?? "").trim(),
+        id: rest.join(":").trim(),
+    };
+}
+export function resolveExplainSubject(raw) {
+    const { prefix, id } = splitSubject(raw);
+    if (!id) {
+        throw new Error("explain_subject_requires_id");
+    }
+    if (prefix === "decision") {
+        return { kind: "decision", id };
+    }
+    if (prefix === "platform") {
+        return { kind: "platform-selection", id };
+    }
+    if (prefix === "outreach") {
+        return { kind: "outreach", id };
+    }
+    if (prefix === "soul") {
+        return { kind: "soul-change", id };
+    }
+    throw new Error("explain_subject_unsupported");
+}

package/runtime/cli/index.d.ts

@@ -0,0 +1,25 @@
+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;

package/runtime/cli/index.js

@@ -0,0 +1,36 @@
+import { createObservabilityDatabase } from "../observability/db/index.js";
+import { createStateAPI, createStateDatabase } from "../storage/index.js";
+import { createActionBridge } from "./action-bridge.js";
+import { createCliCommands } from "./commands/index.js";
+import { createCliReadModels } from "./read-models/index.js";
+export function createCliRuntimeDeps(overrides = {}) {
+    const stateDb = overrides.stateDb ?? createStateDatabase();
+    const observabilityDb = overrides.observabilityDb ?? createObservabilityDatabase();
+    const stateApi = overrides.stateApi ?? createStateAPI(stateDb);
+    const readModels = overrides.readModels ?? createCliReadModels({ stateDb, observabilityDb });
+    const actionBridge = overrides.actionBridge ?? createActionBridge(stateApi);
+    return {
+        stateDb,
+        observabilityDb,
+        stateApi,
+        readModels,
+        actionBridge,
+    };
+}
+export function createCommandRouter(options = {}) {
+    const runtime = createCliRuntimeDeps(options.deps);
+    const commands = createCliCommands({
+        readModels: runtime.readModels,
+        actionBridge: runtime.actionBridge,
+    });
+    return {
+        commands,
+        resolve(name) {
+            return commands.find((command) => command.name === name);
+        },
+    };
+}
+export function closeCliRuntimeDeps(deps) {
+    deps.stateDb.close();
+    deps.observabilityDb.close();
+}

package/runtime/cli/read-models/index.d.ts

@@ -0,0 +1,20 @@
+import type { StateDatabase } from "../../storage/db/index.js";
+import type { ObservabilityDatabase } from "../../observability/db/index.js";
+import type { StatusReadModel, DailyReportReadModel, QuietReadModel, SessionDetailReadModel, CredentialReadModel, ExplainReadModel } from "./types.js";
+export interface CliReadModels {
+    loadStatus(scope?: string): Promise<StatusReadModel>;
+    loadDailyReport(day: string): Promise<DailyReportReadModel>;
+    loadQuiet(scope?: string): Promise<QuietReadModel>;
+    loadSession(sessionId: string): Promise<SessionDetailReadModel>;
+    loadCredential(platformId: string): Promise<CredentialReadModel>;
+    explain(subject: ExplainSubject): Promise<ExplainReadModel>;
+}
+export interface ExplainSubject {
+    kind: "decision" | "platform-selection" | "outreach" | "soul-change";
+    id: string;
+}
+export interface CliReadModelsDeps {
+    stateDb: StateDatabase;
+    observabilityDb: ObservabilityDatabase;
+}
+export declare function createCliReadModels(deps: CliReadModelsDeps): CliReadModels;