@haaaiawd/second-nature 0.1.24 → 0.1.25

package/index.js

@@ -103,6 +103,13 @@ const WORKSPACE_BRIDGE_COMMANDS = new Set([
     "audit",
     // T3.3.2: near-real connector smoke sentinel
     "near_real_smoke",
+    // v6 ops surface (CR8-01): narrative, goal, dream:recent, connector_status/test, cycle:recent
+    "narrative",
+    "goal",
+    "dream:recent",
+    "connector_status",
+    "connector_test",
+    "cycle:recent",
 ]);
 function isWorkspaceBridgeCommand(command, input) {
     if (command === "credential") {
@@ -632,6 +639,43 @@ function createHostSafeRouter(spine) {
             description: "Run near-real connector smoke (workspace runtime + connectors required)",
             execute: async () => createUnavailableActionError("HOST_SAFE_NEAR_REAL_SMOKE_UNAVAILABLE", "Near-real connector smoke requires workspace state and observability databases; host-safe plugin cannot run connector harness.", [], "run_workspace_second_nature_cli_or_full_runtime_package"),
         },
+        // v6 ops surface (CR8-01): host-safe router returns unavailable for workspace-only commands
+        {
+            name: "narrative",
+            description: "Show current NarrativeState (workspace runtime required)",
+            execute: async () => createUnavailableActionError("HOST_SAFE_NARRATIVE_UNAVAILABLE", "NarrativeState read requires workspace state database; host-safe plugin does not load persisted narrative rows.", [], "run_workspace_second_nature_cli_or_full_runtime_package"),
+        },
+        {
+            name: "goal",
+            description: "Owner-governed goal operations (workspace runtime required)",
+            execute: async (input) => {
+                const action = typeof input?.action === "string" ? input.action : "list";
+                if (action === "set" || action === "accept" || action === "reject") {
+                    return createUnavailableActionError("HOST_SAFE_GOAL_MUTATE_UNAVAILABLE", "Goal mutation requires workspace state database; host-safe plugin cannot write persisted goal rows.", [], "run_workspace_second_nature_cli_or_full_runtime_package");
+                }
+                return createUnavailableActionError("HOST_SAFE_GOAL_READ_UNAVAILABLE", "Goal list/read requires workspace state database; host-safe plugin does not load persisted goal rows.", [], "run_workspace_second_nature_cli_or_full_runtime_package");
+            },
+        },
+        {
+            name: "dream:recent",
+            description: "Show recent Dream runs (workspace runtime required)",
+            execute: async () => createUnavailableActionError("HOST_SAFE_DREAM_RECENT_UNAVAILABLE", "Dream 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: "connector_status",
+            description: "Show connector inventory (workspace runtime required)",
+            execute: async () => createUnavailableActionError("HOST_SAFE_CONNECTOR_STATUS_UNAVAILABLE", "Connector status requires workspace state and registry scan; host-safe plugin cannot access connector manifests.", [], "run_workspace_second_nature_cli_or_full_runtime_package"),
+        },
+        {
+            name: "connector_test",
+            description: "Dry-run test a connector (workspace runtime required)",
+            execute: async () => createUnavailableActionError("HOST_SAFE_CONNECTOR_TEST_UNAVAILABLE", "Connector test requires workspace state and registry; host-safe plugin cannot run connector harness.", [], "run_workspace_second_nature_cli_or_full_runtime_package"),
+        },
+        {
+            name: "cycle:recent",
+            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"),
+        },
     ];
     return {
         commands,
@@ -786,6 +830,39 @@ function parseCommandInput(rawArgs) {
                 input: wantRepair ? { runRepairFixture: true } : undefined,
             };
         }
+        // v6 ops surface (CR8-01): simple command parsing for new commands
+        case "narrative":
+            return {
+                ok: true,
+                command,
+                input: rest[0] ? { narrativeId: rest[0] } : undefined,
+            };
+        case "goal":
+            return {
+                ok: true,
+                command,
+                input: rest.length > 0 ? { action: rest[0], goalId: rest[1] } : undefined,
+            };
+        case "dream:recent":
+            return {
+                ok: true,
+                command,
+                input: rest[0] ? { limit: Number(rest[0]) } : undefined,
+            };
+        case "connector_status":
+            return { ok: true, command, input: undefined };
+        case "connector_test":
+            return {
+                ok: true,
+                command,
+                input: rest[0] ? { platformId: rest[0] } : undefined,
+            };
+        case "cycle:recent":
+            return {
+                ok: true,
+                command,
+                input: rest[0] ? { limit: Number(rest[0]) } : undefined,
+            };
         default:
             return {
                 ok: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "OpenClaw native plugin with synchronous registration, a packaged runtime artifact, and operator-facing status/explain flows.",
   "keywords": [
     "openclaw",
@@ -33,11 +33,11 @@
       "./index.js"
     ],
     "compat": {
-      "pluginApi": ">=2026.5.4"
+      "pluginApi": ">=2026.5.12"
     }
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.4"
+    "openclaw": ">=2026.5.12"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -45,8 +45,8 @@
     }
   },
   "dependencies": {
-    "drizzle-orm": "^0.44.4",
+    "drizzle-orm": "^0.45.2",
     "sql.js": "^1.14.1",
-    "zod": "^4.1.5"
+    "zod": "^4.4.3"
   }
 }

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

@@ -0,0 +1,26 @@
+import type { StateDatabase } from "../../storage/db/index.js";
+export interface GoalCommandInput {
+    action: "set" | "list" | "accept" | "reject";
+    goalId?: string;
+    description?: string;
+    completionCriteria?: string;
+    risk?: "low" | "medium" | "high";
+    kind?: "short_term" | "long_term";
+    statusFilter?: string;
+    originFilter?: string;
+    limit?: number;
+}
+export interface GoalCommandResult {
+    ok: boolean;
+    command: "goal";
+    action: string;
+    data?: unknown;
+    error?: {
+        code: string;
+        message: string;
+        requiredUserInput?: string[];
+        nextStep?: string;
+    };
+    [key: string]: unknown;
+}
+export declare function goalCommand(stateDb: StateDatabase | undefined, input: GoalCommandInput): Promise<GoalCommandResult>;

package/runtime/cli/commands/goal.js

@@ -0,0 +1,159 @@
+import { createAgentGoalStore } from "../../storage/goal/agent-goal-store.js";
+import { randomUUID } from "node:crypto";
+function createGoalCommandError(code, message, requiredUserInput, nextStep) {
+    return {
+        ok: false,
+        command: "goal",
+        action: "unknown",
+        error: {
+            code,
+            message,
+            requiredUserInput,
+            nextStep,
+        },
+    };
+}
+function serializeGoal(goal) {
+    return {
+        goalId: goal.goalId,
+        kind: goal.kind,
+        status: goal.status,
+        origin: goal.origin,
+        description: goal.description,
+        completionCriteria: goal.completionCriteria,
+        risk: goal.risk,
+        priorityHint: goal.priorityHint,
+        sourceRefs: goal.sourceRefs,
+        acceptedBy: goal.acceptedBy,
+        createdAt: goal.createdAt,
+        updatedAt: goal.updatedAt,
+    };
+}
+export async function goalCommand(stateDb, input) {
+    if (!stateDb) {
+        return createGoalCommandError("STATE_UNAVAILABLE", "goal command requires StateDatabase to be wired into OpsRouterDeps", [], "wire_state_into_ops_router");
+    }
+    const store = createAgentGoalStore(stateDb);
+    const action = input.action;
+    switch (action) {
+        case "set": {
+            const description = input.description?.trim();
+            if (!description || description.length === 0) {
+                return createGoalCommandError("MISSING_DESCRIPTION", "goal set requires description", ["description"], "reinvoke_goal_set_with_description");
+            }
+            const goalId = input.goalId?.trim() || randomUUID();
+            const now = new Date().toISOString();
+            await store.upsertAgentGoal({
+                goalId,
+                kind: input.kind ?? "short_term",
+                status: "accepted",
+                origin: "owner_set",
+                description,
+                completionCriteria: input.completionCriteria?.trim() || "",
+                risk: input.risk ?? "low",
+                priorityHint: 0,
+                sourceRefs: [],
+                acceptedBy: "owner",
+                createdAt: now,
+                updatedAt: now,
+            });
+            const created = await store.loadAgentGoal(goalId);
+            return {
+                ok: true,
+                command: "goal",
+                action: "set",
+                data: {
+                    goal: created ? serializeGoal(created) : null,
+                    before: null,
+                    after: { status: "accepted", origin: "owner_set", acceptedBy: "owner" },
+                },
+            };
+        }
+        case "list": {
+            const statuses = input.statusFilter
+                ? input.statusFilter.split(",").map((s) => s.trim())
+                : undefined;
+            const origins = input.originFilter
+                ? input.originFilter.split(",").map((s) => s.trim())
+                : undefined;
+            const goals = await store.listAgentGoals({
+                statuses,
+                origins,
+                limit: input.limit ?? 50,
+            });
+            return {
+                ok: true,
+                command: "goal",
+                action: "list",
+                data: {
+                    total: goals.length,
+                    goals: goals.map(serializeGoal),
+                },
+            };
+        }
+        case "accept": {
+            const goalId = input.goalId?.trim();
+            if (!goalId) {
+                return createGoalCommandError("MISSING_GOAL_ID", "goal accept requires goalId", ["goalId"], "reinvoke_goal_accept_with_goalId");
+            }
+            const before = await store.loadAgentGoal(goalId);
+            if (!before) {
+                return createGoalCommandError("GOAL_NOT_FOUND", `No goal found for goalId: ${goalId}`, ["goalId"], "verify_goal_id_or_run_goal_list");
+            }
+            if (before.status !== "proposal") {
+                return createGoalCommandError("INVALID_STATUS_TRANSITION", `Cannot accept goal with status '${before.status}'. Only 'proposal' goals can be accepted.`, ["goalId"], "verify_goal_status_or_run_goal_list");
+            }
+            await store.transitionGoalStatus({
+                goalId,
+                newStatus: "accepted",
+                acceptedBy: "owner",
+                updatedAt: new Date().toISOString(),
+            });
+            const after = await store.loadAgentGoal(goalId);
+            return {
+                ok: true,
+                command: "goal",
+                action: "accept",
+                data: {
+                    goalId,
+                    before: { status: before.status, origin: before.origin },
+                    after: after
+                        ? { status: after.status, origin: after.origin, acceptedBy: after.acceptedBy }
+                        : null,
+                },
+            };
+        }
+        case "reject": {
+            const goalId = input.goalId?.trim();
+            if (!goalId) {
+                return createGoalCommandError("MISSING_GOAL_ID", "goal reject requires goalId", ["goalId"], "reinvoke_goal_reject_with_goalId");
+            }
+            const before = await store.loadAgentGoal(goalId);
+            if (!before) {
+                return createGoalCommandError("GOAL_NOT_FOUND", `No goal found for goalId: ${goalId}`, ["goalId"], "verify_goal_id_or_run_goal_list");
+            }
+            if (before.status !== "proposal") {
+                return createGoalCommandError("INVALID_STATUS_TRANSITION", `Cannot reject goal with status '${before.status}'. Only 'proposal' goals can be rejected.`, ["goalId"], "verify_goal_status_or_run_goal_list");
+            }
+            await store.transitionGoalStatus({
+                goalId,
+                newStatus: "rejected",
+                updatedAt: new Date().toISOString(),
+            });
+            const after = await store.loadAgentGoal(goalId);
+            return {
+                ok: true,
+                command: "goal",
+                action: "reject",
+                data: {
+                    goalId,
+                    before: { status: before.status, origin: before.origin },
+                    after: after ? { status: after.status, origin: after.origin } : null,
+                },
+            };
+        }
+        default: {
+            return createGoalCommandError("UNKNOWN_GOAL_ACTION", `Unknown goal action: ${action}. Supported: set, list, accept, reject.`, ["action"], "reinvoke_with_supported_action");
+        }
+    }
+}

package/runtime/cli/commands/index.js

@@ -26,10 +26,10 @@ export function createCliCommands(deps) {
     return [
         {
             name: "status",
-            description: "Show aggregated Second Nature status",
+            description: "T1.2.6 — Show v6 aggregated Second Nature status (narrative + dream + cycles + runtime)",
             execute: async (input) => {
                 const scope = typeof input?.scope === "string" ? input.scope : undefined;
-                const data = await readModels.loadStatus(scope);
+                const data = await readModels.loadV6Status(scope);
                 return { ok: true, data };
             },
         },
@@ -260,5 +260,40 @@ export function createCliCommands(deps) {
                 return surface;
             },
         },
+        {
+            name: "goal",
+            description: "T1.2.4 — owner-governed goal operations: set, list, accept, reject",
+            execute: async (input) => {
+                const surface = await Promise.resolve(opsRouter.dispatch("goal", input));
+                return surface;
+            },
+        },
+        {
+            name: "narrative",
+            description: "T1.2.1 — show current NarrativeState: focus, progress, next intent, source refs, grounding status",
+            execute: async (input) => {
+                const narrativeId = typeof input?.narrativeId === "string" ? input.narrativeId : undefined;
+                const data = await readModels.loadNarrative(narrativeId);
+                return { ok: true, data };
+            },
+        },
+        {
+            name: "dream:recent",
+            description: "T1.2.2 — show recent Dream run results, candidate/accepted status, fallback/partial summary",
+            execute: async (input) => {
+                const limit = typeof input?.limit === "number" ? input.limit : 5;
+                const data = await readModels.loadDreamRecent(limit);
+                return { ok: true, data };
+            },
+        },
+        {
+            name: "cycle:recent",
+            description: "T1.2.5 — aggregate recent heartbeat, narrative, Dream, delivery, connector cycle summary",
+            execute: async (input) => {
+                const limit = typeof input?.limit === "number" ? input.limit : 5;
+                const data = await readModels.loadCycleRecent(limit);
+                return { ok: true, data };
+            },
+        },
     ];
 }

package/runtime/cli/ops/ops-router.d.ts

@@ -38,6 +38,6 @@ export interface OpsRouterDeps {
 }
 export interface OpsRouter {
     heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;
-    dispatch(command: string, input?: Record<string, unknown>): HeartbeatSurfaceResult | Record<string, unknown> | Promise<HeartbeatSurfaceResult> | Promise<Record<string, unknown>>;
+    dispatch(command: string, input?: Record<string, unknown>): Promise<HeartbeatSurfaceResult | Record<string, unknown>>;
 }
 export declare function createOpsRouter(deps: OpsRouterDeps): OpsRouter;

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

@@ -8,6 +8,7 @@ import { recordHostCapability } from "../host-capability/record-host-capability.
 import { runNearRealConnectorSmoke } from "../../connectors/near-real/near-real-connector-smoke.js";
 import { connectorInit } from "../commands/connector-init.js";
 import { connectorStatus, connectorTest } from "../commands/connector-status.js";
+import { goalCommand } from "../commands/goal.js";
 function coerceProbeOnlyFlag(input) {
     const v = input?.probeOnly;
     return v === true || v === "true" || v === 1 || v === "1";
@@ -45,7 +46,7 @@ export function createOpsRouter(deps) {
             workspaceRoot: input.workspaceRoot ?? deps.workspaceRoot,
             connectorExecutor: input.connectorExecutor ?? deps.connectorExecutor,
         }),
-        dispatch(command, input) {
+        async dispatch(command, input) {
             if (command === "heartbeat_check") {
                 const runtimeAvailable = typeof input?.runtimeAvailable === "boolean"
                     ? input.runtimeAvailable
@@ -213,6 +214,59 @@ export function createOpsRouter(deps) {
                     dryRun: input?.dryRun === false ? false : true, // default dry-run
                 });
             }
+            if (command === "goal") {
+                const rawAction = typeof input?.action === "string" ? input.action : "list";
+                const action = ["set", "list", "accept", "reject"].includes(rawAction)
+                    ? rawAction
+                    : "list";
+                return goalCommand(deps.state, {
+                    action,
+                    goalId: typeof input?.goalId === "string" ? input.goalId : undefined,
+                    description: typeof input?.description === "string" ? input.description : undefined,
+                    completionCriteria: typeof input?.completionCriteria === "string"
+                        ? input.completionCriteria
+                        : undefined,
+                    risk: typeof input?.risk === "string"
+                        ? input.risk
+                        : undefined,
+                    kind: typeof input?.kind === "string"
+                        ? input.kind
+                        : undefined,
+                    statusFilter: typeof input?.statusFilter === "string" ? input.statusFilter : undefined,
+                    originFilter: typeof input?.originFilter === "string" ? input.originFilter : undefined,
+                    limit: typeof input?.limit === "number" ? input.limit : undefined,
+                });
+            }
+            if (command === "dream:recent") {
+                if (!deps.readModels) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "READ_MODELS_UNAVAILABLE",
+                            message: "dream:recent requires workspace read models",
+                            nextStep: "wire_read_models_into_ops_router",
+                        },
+                    };
+                }
+                const limit = typeof input?.limit === "number" ? input.limit : 5;
+                const data = await deps.readModels.loadDreamRecent(limit);
+                return { ok: true, data };
+            }
+            if (command === "cycle:recent") {
+                if (!deps.readModels) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "READ_MODELS_UNAVAILABLE",
+                            message: "cycle:recent requires workspace read models",
+                            nextStep: "wire_read_models_into_ops_router",
+                        },
+                    };
+                }
+                const limit = typeof input?.limit === "number" ? input.limit : 5;
+                const data = await deps.readModels.loadCycleRecent(limit);
+                return { ok: true, data };
+            }
             return {
                 ok: false,
                 error: {

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

@@ -1,8 +1,8 @@
 import type { StateDatabase } from "../../storage/db/index.js";
 import type { ObservabilityDatabase } from "../../observability/db/index.js";
 import { AppendOnlyAuditStore } from "../../observability/audit/append-only-audit-store.js";
-import type { StatusReadModel, DailyReportReadModel, QuietReadModel, SessionDetailReadModel, CredentialReadModel, ExplainReadModel, ExplainSubjectKind, AuditSummaryReadModel } from "./types.js";
-export type { AuditSummaryReadModel } from "./types.js";
+import type { StatusReadModel, DailyReportReadModel, QuietReadModel, SessionDetailReadModel, CredentialReadModel, ExplainReadModel, ExplainSubjectKind, AuditSummaryReadModel, DreamRecentReadModel, CycleRecentReadModel, NarrativeReadModel, StatusV6ReadModel } from "./types.js";
+export type { AuditSummaryReadModel, StatusV6ReadModel } from "./types.js";
 export type { ExplainSubjectKind } from "./types.js";
 import type { OperatorFallbackView } from "../../storage/fallback/operator-fallback-view.js";
 import { type RhythmPolicySnapshot } from "../../storage/rhythm/rhythm-policy-snapshot.js";
@@ -24,6 +24,18 @@ export interface CliReadModels {
      * Empty store returns `{ totalEvents: 0, events: [] }` (honest empty, not an error).
      */
     loadAuditSummary(): Promise<AuditSummaryReadModel>;
+    /** T1.2.2 — recent Dream runs from audit store. */
+    loadDreamRecent(limit?: number): Promise<DreamRecentReadModel>;
+    /** T1.2.5 — recent cycle summary from audit store. */
+    loadCycleRecent(limit?: number): Promise<CycleRecentReadModel>;
+    /** T1.2.1 — current NarrativeState; returns nothing_yet when no data exists. */
+    loadNarrative(narrativeId?: string): Promise<NarrativeReadModel>;
+    /**
+     * T1.2.6 — v6 status aggregate: StatusReadModel extended with narrative, dream recent,
+     * and cycle recent sections. Each section has a sentinel status (nothing_yet / has_runs /
+     * has_cycles) so operators always get a meaningful, non-empty response.
+     */
+    loadV6Status(scope?: string): Promise<StatusV6ReadModel>;
 }
 /** T1.2.1 / T1.2.2 — operator-facing read surface (subset of full CLI read models). */
 export type OpsReadModelPort = Pick<CliReadModels, "loadStatus" | "loadDailyReport" | "loadQuiet" | "loadSession" | "loadCredential" | "explain" | "loadFallbackView">;