@haaaiawd/second-nature 0.1.24 → 0.1.26

package/index.js

@@ -7,6 +7,7 @@
  *   runtime graph currently contains async sql.js bootstrap that breaks vm sandbox loading
  * - expose a minimal in-memory activation spine so status/lifecycle stay truthful even when
  *   the full workspace runtime is not loaded inside the host
+ * - T4.2.1: owner reply ingestion → RelationshipMemory feedback (full runtime only)
  *
  * Dependencies:
  * - only imports runtime lifecycle/service modules that are synchronous at load time
@@ -103,6 +104,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 +640,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 +831,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/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.23",
+  "version": "0.1.26",
   "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 (see README / T1.1.4 ops norm).",
   "activation": {
     "onStartup": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@haaaiawd/second-nature",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "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,28 @@
+import type { StateDatabase } from "../../storage/db/index.js";
+export interface GoalCommandInput {
+    action: "set" | "list" | "accept" | "reject";
+    goalId?: string;
+    description?: string;
+    completionCriteria?: string;
+    /** T1.4.2 — alias for `completionCriteria`. */
+    criteria?: 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,163 @@
+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();
+            // T1.4.2: `criteria` is an alias for `completionCriteria`.
+            const completionCriteria = input.completionCriteria?.trim() ||
+                input.criteria?.trim() ||
+                "";
+            await store.upsertAgentGoal({
+                goalId,
+                kind: input.kind ?? "short_term",
+                status: "accepted",
+                origin: "owner_set",
+                description,
+                completionCriteria,
+                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 };
             },
         },
@@ -136,7 +136,7 @@ export function createCliCommands(deps) {
                         return explainSubjectError("EXPLAIN_SUBJECT_REQUIRES_ID", "subject must include identifier");
                     }
                     if (code === "explain_subject_unsupported") {
-                        return explainSubjectError("EXPLAIN_SUBJECT_UNSUPPORTED", "supported subjects include decision:, platform:, outreach:, soul:, fallback:, delivery:, probe:, report:, source:");
+                        return explainSubjectError("EXPLAIN_SUBJECT_UNSUPPORTED", "supported subjects include decision:, platform:, outreach:, soul:, fallback:, delivery:, probe:, report:, source:, relationship:");
                     }
                     return explainSubjectError("EXPLAIN_SUBJECT_INVALID", "invalid explain subject");
                 }
@@ -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/explain/resolve-subject.js

@@ -37,5 +37,8 @@ export function resolveExplainSubject(raw) {
     if (prefix === "source" || prefix === "source_ref") {
         return { kind: "source_ref", id };
     }
+    if (prefix === "relationship") {
+        return { kind: "relationship", id };
+    }
     throw new Error("explain_subject_unsupported");
 }

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,67 @@ 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";
+                const sanitizeText = (v, maxLen = 1000) => {
+                    if (typeof v !== "string")
+                        return undefined;
+                    const trimmed = v.trim();
+                    if (trimmed.length === 0)
+                        return undefined;
+                    return trimmed.slice(0, maxLen);
+                };
+                return goalCommand(deps.state, {
+                    action,
+                    goalId: typeof input?.goalId === "string" ? input.goalId.trim().slice(0, 128) : undefined,
+                    description: sanitizeText(input?.description),
+                    completionCriteria: sanitizeText(input?.completionCriteria),
+                    // T1.4.2: criteria alias for completionCriteria
+                    criteria: sanitizeText(input?.criteria),
+                    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/ops/workspace-heartbeat-runner.d.ts

@@ -18,6 +18,7 @@ import type { CliReadModels } from "../read-models/index.js";
 import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
 import type { StateDatabase } from "../../storage/db/index.js";
 import type { ConnectorExecutor } from "../../core/second-nature/orchestrator/effect-dispatcher.js";
+import type { CapabilityContractRegistry } from "../../connectors/base/manifest.js";
 export interface WorkspaceHeartbeatRunnerOptions {
     /** When supplied, the runner persists the cycle so `loadStatus` can read it (T1.2.3). */
     runtimeRecorder?: RuntimeDecisionRecorder;
@@ -38,6 +39,11 @@ export interface WorkspaceHeartbeatRunnerOptions {
      * connector-system instead of returning connector_dispatch_unwired.
      */
     connectorExecutor?: ConnectorExecutor;
+    /**
+     * T2.4.1: when present, planner resolves platform-specific intents from accepted goals
+     * and connector evidence.
+     */
+    connectorRegistry?: CapabilityContractRegistry;
 }
 export declare function loadSnapshotInputsForWorkspaceHeartbeat(readModels: CliReadModels, options?: {
     state?: StateDatabase;

package/runtime/cli/ops/workspace-heartbeat-runner.js

@@ -2,6 +2,7 @@ import { runHeartbeatCycle } from "../../core/second-nature/heartbeat/run-heartb
 import { loadLifeEvidenceSnapshot } from "../../storage/snapshots/life-evidence-snapshot.js";
 import { createAgentGoalStore } from "../../storage/goal/agent-goal-store.js";
 import { createNarrativeStateStore } from "../../storage/narrative/narrative-state-store.js";
+import { createRelationshipMemoryStore } from "../../storage/relationship/relationship-memory-store.js";
 export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, options = {}) {
     const status = await readModels.loadStatus();
     const mode = status.rhythm.mode === "unknown" ? "active" : status.rhythm.mode;
@@ -30,6 +31,8 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
             platformEventCount = snapshot.platformEvents.length;
             workEventCount = snapshot.workEvents.length;
             if (snapshot.empty) {
+                // L-01: Currently snapshot only exposes `empty` boolean.
+                // Future: if snapshot adds `emptyReason` (e.g. "redacted_only"), map it here.
                 lifeEvidenceEmptyReason = "no_sources";
             }
         }
@@ -46,7 +49,9 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
         lifeEvidenceEmptyReason = "state_unavailable";
     }
     // T2.1.4: Load accepted goals from state DB when available.
+    // M-03: typed as GoalContext to avoid coupling to the full AgentGoal schema.
     let acceptedGoals;
+    let acceptedGoalsLoadError;
     if (options.state) {
         try {
             const goalStore = createAgentGoalStore(options.state);
@@ -55,8 +60,29 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
                 limit: 20,
             });
         }
+        catch (err) {
+            acceptedGoals = [];
+            acceptedGoalsLoadError = err instanceof Error ? err.message : String(err);
+            // H-05: Distinguish "load failed" from "no goals" for observability.
+        }
+    }
+    // CR-02: Load narrative state and relationship memory when state is available.
+    let narrativeState;
+    let relationshipMemory;
+    if (options.state) {
+        try {
+            const narrativeStore = createNarrativeStateStore(options.state);
+            narrativeState = (await narrativeStore.loadNarrativeState()) ?? undefined;
+        }
+        catch {
+            // Narrative state is optional; failure should not block the cycle.
+        }
+        try {
+            const relationshipStore = createRelationshipMemoryStore(options.state);
+            relationshipMemory = (await relationshipStore.loadRelationshipMemory()) ?? undefined;
+        }
         catch {
-            acceptedGoals = undefined;
+            // Relationship memory is optional; failure should not block the cycle.
         }
     }
     return {
@@ -74,6 +100,9 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
         workEventCount,
         lifeEvidenceEmptyReason,
         acceptedGoals,
+        acceptedGoalsLoadError,
+        narrativeState,
+        relationshipMemory,
     };
 }
 export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
@@ -99,6 +128,11 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                     : undefined,
                 connectorExecutor: options.connectorExecutor,
                 narrativeStateStore,
+                // T3.3.1: pass state + workspaceRoot so connector effects can write life evidence.
+                state: options.state,
+                workspaceRoot: options.workspaceRoot,
+                // T2.4.1: pass registry so planner resolves platform-specific intents.
+                connectorRegistry: options.connectorRegistry,
             },
         });
         if (options.runtimeRecorder) {

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">;