@haaaiawd/second-nature 0.2.7 → 0.2.9

package/index.js

@@ -91,6 +91,7 @@ const WORKSPACE_BRIDGE_COMMANDS = new Set([
     "session",
     "explain",
     "heartbeat_check",
+    "heartbeat_run",
     "fallback",
     "storage_smoke",
     // T1.2.8 (SN-CODE-03): capability probe surface via workspace bridge
@@ -108,6 +109,8 @@ const WORKSPACE_BRIDGE_COMMANDS = new Set([
     "connector_test",
     "connector_behavior_add",
     "cycle:recent",
+    // v8 ops surface (T-ROS.C.1): causal loop health must be reachable from Claw.
+    "loop_status",
     // v7 ops surface (T-ROS.C.1 / T-ROS.C.2 / T-ROS.C.3 / T-V7C.C.5): self_health, tool_affordance,
     // heartbeat_digest, snapshot:capture, narrative:diff, timeline, restore, runtime_secret_bootstrap,
     // connector:run, guidance_payload
@@ -144,8 +147,10 @@ async function ensureWorkspaceOpsBridge(spine) {
     return { ok: true, dispatch: opened.dispatch };
 }
 async function routeSecondNatureCommand(spine, command, input) {
+    // T-ROS.C.1-followup: heartbeat_run is an alias for heartbeat_check on the plugin surface.
+    const normalizedCommand = command === "heartbeat_run" ? "heartbeat_check" : command;
     const wr = spine.workspaceRootContext;
-    const useBridge = wr.resolution !== "unknown" && isWorkspaceBridgeCommand(command, input);
+    const useBridge = wr.resolution !== "unknown" && isWorkspaceBridgeCommand(normalizedCommand, input);
     if (useBridge) {
         const bridge = await ensureWorkspaceOpsBridge(spine);
         if (!bridge.ok) {
@@ -162,10 +167,10 @@ async function routeSecondNatureCommand(spine, command, input) {
                 },
             };
         }
-        const payload = (await bridge.dispatch(command, input));
+        const payload = (await bridge.dispatch(normalizedCommand, input));
         return withSetupNudge(spine, command, payload);
     }
-    const def = spine.router.resolve(command);
+    const def = spine.router.resolve(normalizedCommand);
     if (!def) {
         return { ok: false, message: `Unknown Second Nature command: ${command}` };
     }
@@ -877,6 +882,11 @@ function createHostSafeRouter(spine) {
             description: "Show recent cycle summary (workspace runtime required)",
             execute: async () => createUnavailableActionError("HOST_SAFE_CYCLE_RECENT_UNAVAILABLE", "Cycle recent read requires workspace observability database; host-safe plugin does not load persisted audit events.", [], "run_workspace_second_nature_cli_or_full_runtime_package"),
         },
+        {
+            name: "loop_status",
+            description: "Show v8 causal loop health (workspace runtime required)",
+            execute: async () => createUnavailableActionError("HOST_SAFE_LOOP_STATUS_UNAVAILABLE", "loop_status requires workspace state database; provide workspaceRoot so the full workspace bridge can read persisted v8 loop state.", ["workspaceRoot"], "reinvoke_with_workspaceRoot_or_set_SECOND_NATURE_WORKSPACE_ROOT"),
+        },
     ];
     return {
         commands,
@@ -1088,6 +1098,8 @@ function parseCommandInput(rawArgs) {
                 command,
                 input: rest[0] ? { limit: Number(rest[0]) } : undefined,
             };
+        case "loop_status":
+            return { ok: true, command, input: undefined };
         // v7 ops surface (T-ROS.C.2)
         case "self_health":
             return { ok: true, command, input: undefined };

package/openclaw.plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.2.7",
-  "description": "OpenClaw native plugin with synchronous surface registration and bundled runtime spine. Set SECOND_NATURE_WORKSPACE_ROOT or tool workspaceRoot to the same path as the agent workspace. Agent inner guide is packaged as agent-inner-guide.md. v7 ops surface: self_health, tool_affordance, heartbeat_digest, snapshot:capture, narrative:diff, timeline, restore, runtime_secret_bootstrap, connector:run, guidance_payload.",
+  "version": "0.2.9",
+  "description": "OpenClaw native plugin with synchronous surface registration and bundled runtime spine. Set SECOND_NATURE_WORKSPACE_ROOT or tool workspaceRoot to the same path as the agent workspace. Agent inner guide is packaged as agent-inner-guide.md. Ops surface: loop_status, self_health, tool_affordance, heartbeat_check, heartbeat_run, heartbeat_digest, snapshot:capture, narrative:diff, timeline, restore, runtime_secret_bootstrap, connector:run, guidance_payload.",
   "activation": {
     "onStartup": true,
     "onCapabilities": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "OpenClaw native plugin with synchronous registration, a packaged runtime artifact, and operator-facing status/explain flows.",
   "keywords": [
     "openclaw",

package/runtime/cli/ops/heartbeat-surface.js

@@ -112,6 +112,7 @@ export async function heartbeatCheck(input) {
                 else {
                     const spine = v8Result;
                     surfaceResult.v8Spine = spine;
+                    surfaceResult.livedExperienceLoopClaimed = Boolean(spine.cycleId && (spine.closureRef || spine.noActionReason));
                     surfaceResult.reasons = [
                         ...surfaceResult.reasons,
                         `v8_spine_cycle:${spine.cycleId}`,

package/runtime/cli/ops/manual-run-dispatcher.d.ts

@@ -29,6 +29,7 @@ import type { CapabilityContractRegistryV7 } from "../../connectors/base/manifes
 import type { AppendOnlyAuditStore } from "../../observability/audit/append-only-audit-store.js";
 import { type HeartbeatCheckInput, type HeartbeatSurfaceResult } from "./heartbeat-surface.js";
 import type { RuntimeOpsEnvelope } from "./ops-router.js";
+import type { StateDatabase } from "../../storage/db/index.js";
 export interface ManualTriggerContext {
     triggerSource: "manual_run";
     affectsHeartbeatCadence: false;
@@ -47,6 +48,11 @@ export interface ConnectorRunResult {
     experienceId: string;
     triggerSource: "manual_run";
     affectsHeartbeatCadence: false;
+    evidence?: {
+        v7EvidenceId?: string;
+        v8EvidenceIds: string[];
+        emptyReason?: string;
+    };
 }
 export interface WetProbeRunInput {
     platformId: string;
@@ -77,5 +83,9 @@ export interface ManualRunDispatcherDeps {
     wetProbeRunner: WetProbeRunner;
     registryV7: CapabilityContractRegistryV7;
     auditStore?: AppendOnlyAuditStore;
+    /** Workspace state database for evidence persistence (v7 life_evidence + v8 EvidenceItem). */
+    state?: StateDatabase;
+    /** Workspace root required for v7 life evidence JSON artifacts. */
+    workspaceRoot?: string;
 }
 export declare function createManualRunDispatcher(deps: ManualRunDispatcherDeps): ManualRunDispatcher;

package/runtime/cli/ops/manual-run-dispatcher.js

@@ -25,6 +25,9 @@
 import * as crypto from "node:crypto";
 import { recordConnectorAttemptAudit } from "../../observability/services/audit-closure-recorders.js";
 import { heartbeatCheck, } from "./heartbeat-surface.js";
+import { appendLifeEvidence } from "../../storage/life-evidence/append-life-evidence.js";
+import { mapLifeEvidence } from "../../connectors/base/map-life-evidence.js";
+import { normalizeConnectorEvidence } from "../../connectors/evidence-normalizer.js";
 function buildManualContext(input) {
     return {
         triggerSource: "manual_run",
@@ -40,6 +43,7 @@ export function createManualRunDispatcher(deps) {
             const decisionId = `manual:${crypto.randomUUID()}`;
             const intentId = `manual-run:${input.platformId}:${input.capabilityId}`;
             const idempotencyKey = `idem:manual:${crypto.randomUUID()}`;
+            const now = new Date().toISOString();
             const connectorResult = await deps.connectorExecutor.executeEffect({
                 platformId: input.platformId,
                 intent: input.capabilityId,
@@ -64,11 +68,56 @@ export function createManualRunDispatcher(deps) {
                 decisionId,
                 intentId,
             });
+            const evidenceSummary = {
+                v8EvidenceIds: [],
+            };
+            if (connectorResult.status === "success" && deps.state) {
+                const capabilityIntent = input.capabilityId;
+                // v7 life evidence double-write (parity with heartbeat loop)
+                try {
+                    if (deps.workspaceRoot) {
+                        const lifeCandidate = mapLifeEvidence({
+                            platformId: input.platformId,
+                            intent: capabilityIntent,
+                            result: connectorResult,
+                            observedAt: now,
+                        });
+                        if (lifeCandidate) {
+                            const lifeAck = await appendLifeEvidence(deps.state, deps.workspaceRoot, lifeCandidate);
+                            evidenceSummary.v7EvidenceId = lifeAck.evidenceId;
+                        }
+                    }
+                }
+                catch (v7Err) {
+                    const msg = v7Err instanceof Error ? v7Err.message : String(v7Err);
+                    console.warn(`[connector:run] v7 life evidence append failed for ${input.platformId}: ${msg}`);
+                }
+                // v8 EvidenceItem content-bearing write
+                try {
+                    const v8Result = await normalizeConnectorEvidence(deps.state, {
+                        status: "success",
+                        platformId: input.platformId,
+                        capabilityId: input.capabilityId,
+                        data: connectorResult.data,
+                        observedAt: now,
+                    });
+                    evidenceSummary.v8EvidenceIds = v8Result.evidenceIds;
+                    evidenceSummary.emptyReason = v8Result.emptyReason;
+                    if (v8Result.degraded) {
+                        console.warn(`[connector:run] v8 evidence normalization degraded for ${input.platformId}: ${v8Result.degraded.reason}`);
+                    }
+                }
+                catch (v8Err) {
+                    const msg = v8Err instanceof Error ? v8Err.message : String(v8Err);
+                    console.warn(`[connector:run] v8 evidence normalization failed for ${input.platformId}: ${msg}`);
+                }
+            }
             const runResult = {
                 connectorResult,
                 experienceId,
                 triggerSource: ctx.triggerSource,
                 affectsHeartbeatCadence: ctx.affectsHeartbeatCadence,
+                evidence: evidenceSummary,
             };
             return {
                 ok: connectorResult.status === "success",

package/runtime/cli/ops/ops-router.js

@@ -785,6 +785,8 @@ export function createOpsRouter(deps) {
                     wetProbeRunner,
                     registryV7,
                     auditStore: deps.auditStore,
+                    state: deps.state,
+                    workspaceRoot: typeof input?.workspaceRoot === "string" ? input.workspaceRoot : process.cwd(),
                 });
                 return dispatcher.runConnector({
                     platformId,

package/runtime/connectors/base/normalized-evidence-content.js

@@ -185,12 +185,15 @@ function extractMetrics(item) {
 // ───────────────────────────────────────────────────────────────
 // Item extraction from connector payload
 // ───────────────────────────────────────────────────────────────
-function extractItems(data) {
+function extractItems(data, depth = 4) {
+    if (depth <= 0)
+        return [];
     if (Array.isArray(data))
         return data;
     if (!isRecord(data))
         return [];
-    for (const key of ["items", "data", "results", "posts", "nodes", "agents", "edges", "entries", "feed"]) {
+    const ARRAY_KEYS = ["items", "data", "results", "posts", "nodes", "agents", "edges", "entries", "feed"];
+    for (const key of ARRAY_KEYS) {
         const candidate = data[key];
         if (Array.isArray(candidate))
             return candidate;
@@ -198,6 +201,16 @@ function extractItems(data) {
     // If the payload itself looks like a single item, treat it as one-item array.
     if ("id" in data || "title" in data || "content" in data)
         return [data];
+    // Recurse into nested record-valued fields (e.g. real connector runners wrap
+    // the platform response in { capability, channel, data: apiResponse }).
+    for (const key of ARRAY_KEYS) {
+        const candidate = data[key];
+        if (isRecord(candidate)) {
+            const nested = extractItems(candidate, depth - 1);
+            if (nested.length > 0)
+                return nested;
+        }
+    }
     return [];
 }
 function normalizeSingleItem(item, options) {

package/runtime/connectors/services/connector-executor-adapter.js

@@ -187,6 +187,10 @@ function createMoltbookMockRunner(workspaceRoot) {
                             source: "mock",
                             items: Array.isArray(data.items) ? data.items : [],
                         },
+                        // Duplicate items at payload top-level so v8 evidence normalizer
+                        // can extract content-bearing evidence without re-implementing
+                        // the legacy v7 nested shape.
+                        items: Array.isArray(data.items) ? data.items : [],
                     },
                 };
             }

package/runtime/core/second-nature/quiet-dream/dream-consolidation-runner.d.ts

@@ -31,6 +31,7 @@ export interface DreamMemoryCandidate {
     confidence: number;
     validationStatus: "valid" | "rejected" | "blocked";
     validationReason?: string;
+    acceptedProjectionId?: string;
 }
 export interface RunDreamConsolidationResult {
     runId: string;

package/runtime/core/second-nature/quiet-dream/dream-consolidation-runner.js

@@ -20,7 +20,8 @@
  *
  * Test coverage: tests/unit/dream/dream-consolidation-runner.test.ts
  */
-import { readDreamConsolidationRunById, readQuietDailyReviewById, writeLongTermMemoryProjection, } from "../../../storage/v8-state-stores.js";
+import { readDreamConsolidationRunById, readQuietDailyReviewById, } from "../../../storage/v8-state-stores.js";
+import { acceptMemoryProjection } from "./memory-projection-lifecycle.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
@@ -144,30 +145,21 @@ export async function runDreamConsolidation(db, runId, options) {
             reason: "dream_blocked_redaction",
         };
     }
-    // Write valid candidates as projections (candidate status)
+    // Accept valid candidates as active long-term memory projections.
+    // This completes the Dream→memory lifecycle so accepted projections can be
+    // loaded by EmbodiedContext in subsequent heartbeats (T-DQ.R.3 followup).
     const validCandidates = candidates.filter((c) => c.validationStatus === "valid");
     for (const candidate of validCandidates) {
-        const projectionResult = await writeLongTermMemoryProjection(db, {
-            id: `proj_${candidate.id}`,
-            createdAt: now,
-            candidateId: candidate.id,
-            topicKey: `topic_${review.day}`,
-            status: "candidate",
-            sourceRefs: candidate.sourceRefs,
-            redactionClass: "none",
-            lifecycleStatus: "candidate",
-            payloadJson: JSON.stringify({
-                candidateText: candidate.candidateText,
-                confidence: candidate.confidence,
-                runId,
-            }),
-        });
-        if ("reason" in projectionResult) {
+        const acceptResult = await acceptMemoryProjection(db, candidate.id, `topic_${review.day}`, candidate.candidateText, candidate.sourceRefs, { now });
+        if ("projectionId" in acceptResult) {
+            candidate.acceptedProjectionId = acceptResult.projectionId;
+        }
+        else {
             return {
                 runId,
                 status: "failed",
                 candidates,
-                reason: projectionResult.reason,
+                reason: acceptResult.reason,
             };
         }
     }

package/workspace-ops-bridge.js

@@ -99,7 +99,35 @@ export async function openWorkspaceOpsBridge(workspaceRoot) {
             const prevCwd = process.cwd();
             try {
                 process.chdir(resolvedRoot);
-                return await def.execute(input);
+                const result = await def.execute(input);
+                // T-ROS.C.3-followup: ensure sql.js in-memory DB is persisted after each
+                // mutating tool call so subsequent calls (possibly in a new process) see
+                // the latest state. Flush failures are reported as warnings, never fatal.
+                try {
+                    if (typeof stateDb.flush === "function") {
+                        stateDb.flush();
+                    }
+                }
+                catch (flushErr) {
+                    const warning = flushErr instanceof Error ? flushErr.message : String(flushErr);
+                    result.warnings = [
+                        ...(result.warnings ?? []),
+                        `state_flush_warning:${warning}`,
+                    ];
+                }
+                try {
+                    if (typeof observabilityDb.flush === "function") {
+                        observabilityDb.flush();
+                    }
+                }
+                catch (flushErr) {
+                    const warning = flushErr instanceof Error ? flushErr.message : String(flushErr);
+                    result.warnings = [
+                        ...(result.warnings ?? []),
+                        `observability_flush_warning:${warning}`,
+                    ];
+                }
+                return result;
             }
             finally {
                 process.chdir(prevCwd);