@haaaiawd/second-nature 0.1.3 → 0.1.4

package/index.js

@@ -0,0 +1,155 @@
+import { createRequire } from "node:module";
+function createFallbackCommands() {
+    const commandNames = ["status", "policy", "credential", "quiet", "report", "session", "audit", "explain"];
+    return commandNames.map((name) => ({
+        name,
+        description: `Fallback command shell for ${name}`,
+        execute: async (_input) => ({
+            ok: false,
+            command: name,
+            message: "Plugin loaded in packaging fallback mode; reinstall full workspace build for command runtime.",
+        }),
+    }));
+}
+function resolveCommandRouterSafe() {
+    const require = createRequire(import.meta.url);
+    try {
+        const mod = require("./runtime/cli/index.js");
+        if (mod?.createCommandRouter) {
+            return mod.createCommandRouter();
+        }
+    }
+    catch {
+        // fall through to fallback router
+    }
+    const commands = createFallbackCommands();
+    return {
+        commands,
+        resolve(name) {
+            return commands.find((command) => command.name === name);
+        },
+    };
+}
+function createRuntimeService() {
+    const require = createRequire(import.meta.url);
+    try {
+        const runtimeMod = require("./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 };
+                },
+            };
+        }
+    }
+    catch {
+        // fall through to minimal service shell
+    }
+    return {
+        id: "second-nature-runtime",
+        start() {
+            return { ready: true, version: "0.1.4-minimal" };
+        },
+    };
+}
+function createLifecycleService() {
+    const require = createRequire(import.meta.url);
+    try {
+        const lifecycleMod = require("./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;
+    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) {
+        const router = resolveCommandRouterSafe();
+        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) {
+                    return {
+                        text: JSON.stringify({ ok: false, message: "Missing command argument." }),
+                    };
+                }
+                const resolved = router.resolve(command);
+                if (!resolved) {
+                    return {
+                        text: JSON.stringify({ ok: false, command, message: "Unknown Second Nature command." }),
+                    };
+                }
+                const result = await resolved.execute();
+                return {
+                    text: JSON.stringify(result),
+                };
+            },
+        });
+        api.registerTool({
+            name: "second_nature_ops",
+            description: "Access the Second Nature command surface through a single tool shell.",
+            parameters: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    command: { type: "string" },
+                    args: { type: "object", additionalProperties: true }
+                },
+                required: ["command"]
+            },
+            async execute(_id, params) {
+                const resolved = router.resolve(params.command);
+                if (!resolved) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify({ ok: false, message: "Unknown Second Nature command." }),
+                            },
+                        ],
+                    };
+                }
+                const result = await resolved.execute(params.args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                };
+            },
+        });
+    },
+};

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.3",
-  "entry": "./index.ts",
+  "version": "0.1.4",
+  "entry": "./index.js",
   "description": "OpenClaw native plugin package for continuity, explain, and recovery operations.",
   "capabilities": {
     "commands": ["second-nature"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "OpenClaw native plugin for long-running agent continuity, Quiet memory curation, and explainable operator flows.",
   "keywords": [
     "openclaw",
@@ -14,9 +14,9 @@
   ],
   "license": "Apache-2.0",
   "type": "module",
-  "main": "./index.ts",
+  "main": "./index.js",
   "files": [
-    "index.ts",
+    "index.js",
     "openclaw.plugin.json",
     "runtime/"
   ],
@@ -26,7 +26,7 @@
   "openclaw": {
     "manifest": "./openclaw.plugin.json",
     "extensions": [
-      "./index.ts"
+      "./index.js"
     ]
   },
   "dependencies": {

package/runtime/connectors/social-community/moltbook/api-client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Moltbook REST API Client
+ *
+ * Implements the MoltbookApiClient interface for direct REST API access.
+ * Uses fetch() with Bearer token authentication.
+ *
+ * API Reference: moltbook.apidog.io
+ * Auth: OAuth 2.0 via CLI (moltbook login)
+ *
+ * Per T3.1.1: This provides a minimal real client for feed.read capability,
+ * with a replaceable seam for skill/CLI fallback.
+ */
+import type { MoltbookApiClient } from "./adapter.js";
+export interface MoltbookApiConfig {
+    /** Base URL for Moltbook REST API */
+    baseUrl: string;
+    /** OAuth Bearer token */
+    accessToken: string;
+    /** Request timeout in milliseconds */
+    timeoutMs?: number;
+}
+export declare function createMoltbookApiClient(config: MoltbookApiConfig): MoltbookApiClient;
+export declare class MoltbookApiError extends Error {
+    readonly statusCode: number;
+    readonly responseBody?: string | undefined;
+    constructor(statusCode: number, message: string, responseBody?: string | undefined);
+}

package/runtime/connectors/social-community/moltbook/api-client.js

@@ -0,0 +1,71 @@
+export function createMoltbookApiClient(config) {
+    const { baseUrl, accessToken, timeoutMs = 5000 } = config;
+    async function request(path, options = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(`${baseUrl}${path}`, {
+                ...options,
+                headers: {
+                    "Authorization": `Bearer ${accessToken}`,
+                    "Content-Type": "application/json",
+                    ...options.headers,
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => "");
+                throw new MoltbookApiError(response.status, `Moltbook API error: ${response.status} ${response.statusText}`, errorBody);
+            }
+            return response.json();
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    return {
+        async readFeed(payload) {
+            const params = new URLSearchParams();
+            if (payload.limit)
+                params.set("limit", String(payload.limit));
+            if (payload.offset)
+                params.set("offset", String(payload.offset));
+            if (payload.sort)
+                params.set("sort", String(payload.sort));
+            const queryString = params.toString();
+            return request(`/api/v1/feed${queryString ? `?${queryString}` : ""}`);
+        },
+        async publishPost(payload) {
+            return request("/api/v1/posts", {
+                method: "POST",
+                body: JSON.stringify({
+                    content: payload.content,
+                    link: payload.link,
+                    community: payload.community,
+                }),
+            });
+        },
+        async replyComment(payload) {
+            const postId = payload.postId;
+            if (!postId) {
+                throw new MoltbookApiError(400, "postId is required for comment.reply");
+            }
+            return request(`/api/v1/posts/${postId}/comments`, {
+                method: "POST",
+                body: JSON.stringify({
+                    content: payload.content,
+                }),
+            });
+        },
+    };
+}
+export class MoltbookApiError extends Error {
+    statusCode;
+    responseBody;
+    constructor(statusCode, message, responseBody) {
+        super(message);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = "MoltbookApiError";
+    }
+}

package/runtime/connectors/social-community/moltbook/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./manifest.js";
 export * from "./adapter.js";
+export * from "./api-client.js";

package/runtime/connectors/social-community/moltbook/index.js

@@ -1,2 +1,3 @@
 export * from "./manifest.js";
 export * from "./adapter.js";
+export * from "./api-client.js";

package/runtime/core/second-nature/guidance/user-reply-continuity.d.ts

@@ -0,0 +1,50 @@
+/**
+ * User Reply Light Continuity Contract
+ *
+ * Per T6.1.1: Provides very light continuity guidance for direct user replies.
+ * This is separate from the platform `reply` scene - it only provides
+ * lightweight persona continuity and tone consistency for user-facing chat.
+ *
+ * Key differences from platform `reply` scene:
+ * - No platform-specific impulses
+ * - No comment/reply formatting constraints
+ * - Only persona continuity and minimal tone guidance
+ * - Does not enter the reply scene impulse system
+ */
+import type { GuidanceFallback, GuidancePayload } from "../../../guidance/index.js";
+import type { PersonaCandidate } from "../../../guidance/index.js";
+/**
+ * Scene context for user reply - uses a distinct scene type
+ * to avoid confusion with platform reply scene.
+ */
+export declare const USER_REPLY_SCENE_TYPE: "user_reply";
+export type UserReplySceneType = typeof USER_REPLY_SCENE_TYPE;
+/**
+ * Build very light continuity guidance for direct user replies.
+ *
+ * Returns a minimal guidance payload with:
+ * - Light atmosphere (continuity-focused)
+ * - NO impulses (unlike platform reply scene)
+ * - Optional persona reinforcement (1-2 snippets max)
+ * - Minimal output guard (tone consistency only)
+ */
+export declare function buildLightReplyContinuity(input: {
+    replyContext: {
+        recentTone?: string;
+        lastInteractionSummary?: string;
+    };
+    personaCandidates?: PersonaCandidate[];
+}): Promise<GuidancePayload | GuidanceFallback>;
+/**
+ * Check if an input should be classified as direct user reply.
+ *
+ * Classification criteria:
+ * - Trigger source is user_reply
+ * - Not a platform comment/reply
+ * - Not an explicit task delegation
+ */
+export declare function isDirectUserReply(input: {
+    triggerSource: string;
+    isPlatformReply: boolean;
+    isExplicitTask: boolean;
+}): boolean;

package/runtime/core/second-nature/guidance/user-reply-continuity.js

@@ -0,0 +1,80 @@
+import { buildMinimalGuidanceFallback } from "../../../guidance/fallback.js";
+import { selectPersonaSnippets } from "../../../guidance/persona-selection.js";
+import { getBaselineAtmosphereTemplate } from "../../../guidance/template-registry.js";
+/**
+ * Scene context for user reply - uses a distinct scene type
+ * to avoid confusion with platform reply scene.
+ */
+export const USER_REPLY_SCENE_TYPE = "user_reply";
+/**
+ * Build very light continuity guidance for direct user replies.
+ *
+ * Returns a minimal guidance payload with:
+ * - Light atmosphere (continuity-focused)
+ * - NO impulses (unlike platform reply scene)
+ * - Optional persona reinforcement (1-2 snippets max)
+ * - Minimal output guard (tone consistency only)
+ */
+export async function buildLightReplyContinuity(input) {
+    const sceneContext = {
+        sceneType: "user_reply",
+        mode: "active",
+        riskLevel: "low",
+        sceneSummary: "direct user reply continuity",
+    };
+    try {
+        // Light atmosphere - continuity focused
+        const atmosphereTemplate = getBaselineAtmosphereTemplate();
+        const atmosphere = {
+            kind: "atmosphere",
+            text: `保持同一个人的语气。${input.replyContext.recentTone ? `最近语气参考：${input.replyContext.recentTone}` : "延续既有连续感。"}`,
+            openness: "open",
+            pressureLabels: ["user_reply", "continuity"],
+            reviewStatus: atmosphereTemplate.reviewStatus,
+        };
+        // NO impulses for user reply - this is the key difference from platform reply
+        const impulses = [];
+        // Minimal persona reinforcement - only if candidates available
+        let personaReinforcement = [];
+        if (input.personaCandidates && input.personaCandidates.length > 0) {
+            const personaDecision = selectPersonaSnippets({
+                sceneContext,
+                candidates: input.personaCandidates.slice(0, 2), // Max 2 snippets for light continuity
+            });
+            personaReinforcement = personaDecision.snippets;
+        }
+        // Minimal output guard - tone consistency only
+        const outputGuard = {
+            kind: "output_guard",
+            constraints: [
+                "保持对话语气，不要用帖子回复腔",
+                "延续同一个人格连续性",
+            ],
+            hardGuardPriority: true,
+        };
+        return {
+            scene: sceneContext,
+            atmosphere,
+            impulses,
+            personaReinforcement,
+            outputGuard,
+        };
+    }
+    catch {
+        // Fallback to minimal guidance
+        return buildMinimalGuidanceFallback(sceneContext);
+    }
+}
+/**
+ * Check if an input should be classified as direct user reply.
+ *
+ * Classification criteria:
+ * - Trigger source is user_reply
+ * - Not a platform comment/reply
+ * - Not an explicit task delegation
+ */
+export function isDirectUserReply(input) {
+    return (input.triggerSource === "user_reply" &&
+        !input.isPlatformReply &&
+        !input.isExplicitTask);
+}

package/runtime/core/second-nature/heartbeat/heartbeat-executor.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Heartbeat Executor Bridge
+ *
+ * Connects the decision loop to guidance and effect dispatch.
+ * Per T2.2.2:
+ * - Guidance is only requested when an allow verdict enters a generative scene
+ * - External effects only occur under allow verdict
+ * - Guidance payload participates in generative context assembly within control-plane,
+ *   and does NOT cross into connector execution boundary
+ *
+ * This module does NOT make guidance a decision maker:
+ * - Guidance does not decide allow/deny
+ * - Guidance does not replace guards
+ * - Guidance does not directly drive connector executor
+ */
+import type { GuidanceMode } from "../../../guidance/index.js";
+import type { GuardVerdict } from "../types.js";
+import { requestGuidance, type RequestGuidanceResult } from "../guidance/request-guidance.js";
+import { applyGuidance, type AppliedGuidanceContext } from "../guidance/apply-guidance.js";
+import { type AllowedIntent, type DispatchResult } from "../orchestrator/effect-dispatcher.js";
+import type { LeaseManager } from "../orchestrator/lease-manager.js";
+import type { IntentCommitPort, ConnectorExecutor, CheckpointPort, MemoryPort, ReflectionPort } from "../orchestrator/effect-dispatcher.js";
+export interface GuidanceBridgeDeps {
+    /** Request guidance from the behavioral guidance system */
+    requestGuidance: typeof requestGuidance;
+    /** Apply guidance payload into context */
+    applyGuidance: typeof applyGuidance;
+}
+export interface EffectDispatchDeps {
+    leaseManager: LeaseManager;
+    commitPort: IntentCommitPort;
+    connectorExecutor: ConnectorExecutor;
+    checkpointPort: CheckpointPort;
+    memoryPort: MemoryPort;
+    reflectionPort: ReflectionPort;
+}
+export interface HeartbeatExecutorDeps {
+    guidance: GuidanceBridgeDeps;
+    effects: EffectDispatchDeps;
+}
+/**
+ * Result of the guidance bridge step.
+ * Guidance is only requested for generative scenes under allow verdict.
+ */
+export interface GuidanceBridgeResult {
+    intent: AllowedIntent;
+    guidanceResult?: RequestGuidanceResult;
+    appliedContext?: AppliedGuidanceContext;
+}
+/**
+ * Result of the full heartbeat execution cycle.
+ */
+export interface HeartbeatExecutionResult {
+    decisionId: string;
+    intentId: string;
+    guardVerdict: GuardVerdict;
+    guidance?: GuidanceBridgeResult;
+    dispatch?: DispatchResult;
+}
+/**
+ * Request guidance for a selected intent.
+ *
+ * Guidance is only requested when:
+ * - The intent kind maps to a generative scene (social, outreach, explain)
+ * - Maintenance, reflection, and work do not request guidance
+ *
+ * The guidance payload is used for context assembly within control-plane.
+ * It does NOT cross the connector execution boundary.
+ */
+export declare function requestGuidanceForIntent(intent: AllowedIntent, mode: GuidanceMode, deps: GuidanceBridgeDeps): Promise<GuidanceBridgeResult>;
+/**
+ * Dispatch effects for an allowed intent.
+ *
+ * This function enforces the allow-only boundary:
+ * - Only called when guard verdict is "allow"
+ * - Creates a decision context and dispatches through EffectDispatcher
+ * - Guidance context stays within control-plane and is NOT passed to connector executor
+ *
+ * The connector executor receives the original intent payload without any
+ * guidance-derived fields. Guidance participates in control-plane context
+ * assembly but does not leak into the connector execution boundary.
+ */
+export declare function dispatchAllowedEffect(intent: AllowedIntent, deps: EffectDispatchDeps): Promise<DispatchResult>;
+/**
+ * Full heartbeat execution: guidance bridge + allow-only effect dispatch.
+ *
+ * Flow:
+ * 1. Check guard verdict — non-allow paths skip guidance entirely
+ * 2. For allow verdict: request guidance (if generative scene), then dispatch effect
+ * 3. Return execution result with guidance and dispatch info
+ *
+ * Per T2.2.2 boundaries:
+ * - Guidance is NOT requested for deny/defer verdicts
+ * - Guidance payload does NOT cross into connector execution boundary
+ * - External effects only occur under allow verdict
+ */
+export declare function executeHeartbeatCycle(intent: AllowedIntent, guardVerdict: GuardVerdict, mode: GuidanceMode, deps: HeartbeatExecutorDeps): Promise<HeartbeatExecutionResult>;

package/runtime/core/second-nature/heartbeat/heartbeat-executor.js

@@ -0,0 +1,112 @@
+import { EffectDispatcher, buildDecisionContext } from "../orchestrator/effect-dispatcher.js";
+/**
+ * Map an intent kind to its guidance scene type.
+ * Only generative scenes (social, outreach, explain) request guidance.
+ * Maintenance, reflection, and work do not request guidance.
+ */
+function intentKindToScene(kind) {
+    switch (kind) {
+        case "social":
+            return "social";
+        case "outreach":
+            return "outreach";
+        case "exploration":
+            return "explain";
+        default:
+            return null;
+    }
+}
+/**
+ * Build a scene context from an allowed intent and runtime mode.
+ *
+ * Mode comes from the actual runtime context (active/quiet/maintenance_only/paused_for_interrupt),
+ * not hardcoded.
+ */
+function buildSceneContext(intent, mode) {
+    return {
+        sceneType: intentKindToScene(intent.kind) ?? "explain",
+        mode,
+        sceneSummary: intent.summary,
+    };
+}
+/**
+ * Request guidance for a selected intent.
+ *
+ * Guidance is only requested when:
+ * - The intent kind maps to a generative scene (social, outreach, explain)
+ * - Maintenance, reflection, and work do not request guidance
+ *
+ * The guidance payload is used for context assembly within control-plane.
+ * It does NOT cross the connector execution boundary.
+ */
+export async function requestGuidanceForIntent(intent, mode, deps) {
+    const sceneType = intentKindToScene(intent.kind);
+    if (!sceneType) {
+        // Non-generative intents don't request guidance
+        return { intent };
+    }
+    const sceneContext = buildSceneContext(intent, mode);
+    const guidanceResult = await deps.requestGuidance({ sceneContext });
+    const appliedContext = deps.applyGuidance(guidanceResult.guidance);
+    return {
+        intent,
+        guidanceResult,
+        appliedContext,
+    };
+}
+/**
+ * Dispatch effects for an allowed intent.
+ *
+ * This function enforces the allow-only boundary:
+ * - Only called when guard verdict is "allow"
+ * - Creates a decision context and dispatches through EffectDispatcher
+ * - Guidance context stays within control-plane and is NOT passed to connector executor
+ *
+ * The connector executor receives the original intent payload without any
+ * guidance-derived fields. Guidance participates in control-plane context
+ * assembly but does not leak into the connector execution boundary.
+ */
+export async function dispatchAllowedEffect(intent, deps) {
+    const dispatcher = new EffectDispatcher(deps.leaseManager, deps.commitPort, deps.connectorExecutor, deps.checkpointPort, deps.memoryPort, deps.reflectionPort);
+    const decisionContext = buildDecisionContext({
+        tickId: `tick:${Date.now()}`,
+        intentId: intent.id,
+    });
+    // Dispatch with the original intent payload.
+    // Guidance context (if any) remains within control-plane boundary
+    // and is NOT embedded in the connector payload.
+    return dispatcher.dispatchEffect(intent, decisionContext);
+}
+/**
+ * Full heartbeat execution: guidance bridge + allow-only effect dispatch.
+ *
+ * Flow:
+ * 1. Check guard verdict — non-allow paths skip guidance entirely
+ * 2. For allow verdict: request guidance (if generative scene), then dispatch effect
+ * 3. Return execution result with guidance and dispatch info
+ *
+ * Per T2.2.2 boundaries:
+ * - Guidance is NOT requested for deny/defer verdicts
+ * - Guidance payload does NOT cross into connector execution boundary
+ * - External effects only occur under allow verdict
+ */
+export async function executeHeartbeatCycle(intent, guardVerdict, mode, deps) {
+    // Non-allow verdicts: skip guidance entirely, no effect dispatch
+    if (guardVerdict !== "allow") {
+        return {
+            decisionId: `decision:${intent.id}:${Date.now()}`,
+            intentId: intent.id,
+            guardVerdict,
+        };
+    }
+    // Allow verdict: request guidance for generative scenes, then dispatch
+    const guidance = await requestGuidanceForIntent(intent, mode, deps.guidance);
+    const dispatch = await dispatchAllowedEffect(intent, deps.effects);
+    return {
+        decisionId: `decision:${intent.id}:${Date.now()}`,
+        intentId: intent.id,
+        guardVerdict,
+        guidance,
+        dispatch,
+    };
+}