@haaaiawd/second-nature 0.1.33 → 0.1.38

package/agent-inner-guide.md

@@ -142,3 +142,28 @@ Second Nature 不会催你说更多。
 把关心放轻一点。
 
 这样就够了。
+
+## 带着动作的感觉进入平台
+
+Second Nature 在一些特定动作发生之前，会给你一个简短的内心独白，叫 impulse。
+
+它不是指令，也不是评分标准。更像是一个提醒——你现在要做的这件事，是什么性质的，该带着什么姿态进去。
+
+你不需要每次都把它翻出来念一遍。只要它在，你进入这个动作的感觉就会不一样。
+
+**capabilityClass 对应的四种基本姿态**：
+
+- `consume / discover`（读信息、看动态、搜索任务）：进来是为了摄入，带着问题进来，带着判断出去。
+- `broadcast`（发帖、发布内容）：你主动把自己放出去。说清楚为什么说，说清楚想让谁听到。
+- `interact`（回复、评论、私信）：对方先开口了。你接话，是因为真的有要说的，不是为了表示你在。
+- `claim`（接任务）：因为这件事有价值才接。卡住了就找出路，路不止一条。
+
+**平台特定 impulse**
+
+如果某个平台的场景有它自己的特殊性，Claw 可以在 workspace 里为这个平台的某个 capabilityClass 写一份定制 impulse。
+
+比如在爪子社区，`broadcast` 特指进入专业讨论圈发帖，和其他平台的"随手发"完全不同；这时候一份专门针对 Claw `broadcast` 的 impulse 会比通用文本更贴切。
+
+定制 impulse 不需要很长。一到三段，把这个平台在这个动作上的具体质感讲清楚就够了。
+
+格式和内置 impulse 一致——前置 frontmatter，正文纯文字，第一人称"我"，不带标题，不带列表。

package/index.js

@@ -71,7 +71,7 @@ process.stderr.write("[second-nature] module evaluated\n");
 const INTERNAL_RUNTIME_TRACE_PREFIX = "sn-runtime-";
 const HOST_SAFE_LIMITATION_MESSAGE = "Host-safe plugin package keeps synchronous register/load semantics, but mutating workspace runtime flows remain unavailable here.";
 const SETUP_MARKER_RELATIVE_PATH = path.join(".second-nature", "setup", "agent-inner-guide-ack.json");
-const SETUP_GUIDE_VERSION = "0.1.33";
+const SETUP_GUIDE_VERSION = "0.1.38";
 const SETUP_COMMANDS = new Set(["setup_hint", "setup_ack"]);
 let activationSpine = null;
 /** T1.1.4 — lazily opened full read bridge; closed when workspace root / resolution changes. */

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "second-nature",
   "name": "Second Nature",
-  "version": "0.1.33",
+  "version": "0.1.38",
   "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.",
   "activation": {
     "onStartup": true,

package/package.json

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

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

@@ -8,6 +8,7 @@ export interface GoalCommandInput {
     criteria?: string;
     risk?: "low" | "medium" | "high";
     kind?: "short_term" | "long_term";
+    scope?: string;
     statusFilter?: string;
     originFilter?: string;
     limit?: number;

package/runtime/cli/commands/goal.js

@@ -50,6 +50,7 @@ export async function goalCommand(stateDb, input) {
             await store.upsertAgentGoal({
                 goalId,
                 kind: input.kind ?? "short_term",
+                scope: input.scope?.trim() || "global",
                 status: "accepted",
                 origin: "owner_set",
                 description,

package/runtime/cli/index.js

@@ -186,9 +186,9 @@ function createSecretAnchorDeps(stateDb) {
         },
         credentialPort: {
             verifySampleDecrypt: async () => {
-                const result = stateDb.sqlite.exec(`SELECT platform_id, encrypted_value
-           FROM credential_records
-           WHERE encrypted_value IS NOT NULL AND encrypted_value != ''
+                const result = stateDb.sqlite.exec(`SELECT platform_id, encrypted_value
+           FROM credential_records
+           WHERE encrypted_value IS NOT NULL AND encrypted_value != ''
            LIMIT 3`);
                 if (result.length === 0 || result[0].values.length === 0) {
                     return { status: "ok", checkedIds: [] };

package/runtime/cli/ops/heartbeat-surface.d.ts

@@ -11,6 +11,8 @@ import type { RuntimeDecisionRecorder } from "../../observability/services/runti
 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";
+import type { AffordanceMap } from "../../shared/types/v7-entities.js";
+import type { ExperienceWriter } from "../../core/second-nature/body/tool-experience/experience-writer.js";
 export type HeartbeatSurfaceStatus = "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
 export interface HeartbeatSurfaceResult {
     ok: boolean;
@@ -50,5 +52,9 @@ export interface HeartbeatCheckInput {
     connectorExecutor?: ConnectorExecutor;
     /** Capability registry used by planner to avoid platform/capability protocol mismatches. */
     connectorRegistry?: CapabilityContractRegistry;
+    /** v7 T-V7C.C.2: affordance map for breaker-aware guard evaluation. */
+    affordanceMap?: AffordanceMap;
+    /** v7 T-V7C.C.2: experience writer for heartbeat connector attempts. */
+    experienceWriter?: ExperienceWriter;
 }
 export declare function heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;

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

@@ -75,6 +75,8 @@ export async function heartbeatCheck(input) {
         workspaceRoot: input.workspaceRoot ?? process.cwd(),
         connectorExecutor: input.connectorExecutor,
         connectorRegistry: input.connectorRegistry,
+        affordanceMap: input.affordanceMap,
+        experienceWriter: input.experienceWriter,
     });
     const cycle = await run(signal);
     return mapCycleToSurface(cycle, "workspace_full_runtime");

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

@@ -20,7 +20,7 @@ import { goalCommand } from "../commands/goal.js";
 // v7 observability services (T-ROS.C.1)
 import { getSelfHealthSnapshot, ensureMinimumProbes, } from "../../observability/services/self-health-snapshot.js";
 import { generateHeartbeatDigest, } from "../../observability/services/heartbeat-digest-assembler.js";
-import { queryNarrativeTimeline, queryNarrativeDiff, } from "../../observability/services/narrative-timeline-query-service.js";
+import { queryNarrativeTimeline, queryNarrativeDiff, NarrativeVersionNotFoundError, } from "../../observability/services/narrative-timeline-query-service.js";
 import { viewSecretAnchor, } from "../../observability/services/runtime-secret-anchor-view.js";
 import { writeRestoreAudit, } from "../../observability/services/restore-audit-service.js";
 import { createHistoryDigestStore } from "../../storage/services/history-digest-store.js";
@@ -154,6 +154,96 @@ function registerConnectorForWetProbe(input) {
         credentialTypes: ["runtime_ops_probe"],
     });
 }
+async function captureRuntimeSnapshot(deps, input) {
+    const generatedAt = new Date().toISOString();
+    if (!deps.state || !deps.restoreSnapshotStore) {
+        return {
+            ok: false,
+            command: "snapshot:capture",
+            runtimeMode: "unavailable",
+            surfaceMode: "cli",
+            generatedAt,
+            error: {
+                code: "SNAPSHOT_CAPTURE_DEPS_UNAVAILABLE",
+                message: "snapshot:capture requires state DB and RestoreSnapshotStore in OpsRouterDeps",
+                nextStep: "wire_state_and_restore_snapshot_store_into_ops_router",
+            },
+            warnings: [],
+            sourceRefs: [],
+        };
+    }
+    const snapshotId = textInput(input, "snapshotId") ??
+        `snapshot:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+    const requestedKinds = coerceRestorableKinds(input?.entityWhitelist) ?? [...DEFAULT_SNAPSHOT_KINDS];
+    const rowCounts = {};
+    const warnings = [];
+    for (const kind of requestedKinds) {
+        const table = SNAPSHOT_TABLE_BY_KIND[kind];
+        if (!tableExists(deps.state, table)) {
+            rowCounts[kind] = 0;
+            warnings.push(`table_missing:${kind}:${table}`);
+            continue;
+        }
+        rowCounts[kind] = readRowsFromTable(deps.state, table).length;
+    }
+    const historyStore = createHistoryDigestStore(deps.state);
+    const previousHash = (await historyStore.listNarrativeTimeline({ limit: 1 }))[0]?.currentHash ?? "";
+    const delta = buildSnapshotNarrativeDelta(input, snapshotId, rowCounts);
+    const currentHash = hashNarrativeSnapshot({
+        previousHash,
+        snapshotId,
+        delta,
+        createdAt: generatedAt,
+    });
+    await historyStore.appendNarrativeTimeline({
+        timelineId: snapshotId,
+        entryType: "owner.override",
+        subjectId: textInput(input, "subjectId") ?? snapshotId,
+        delta,
+        previousHash,
+        currentHash,
+        createdAt: generatedAt,
+    });
+    const payload = {};
+    const capturedKinds = [];
+    for (const kind of requestedKinds) {
+        const table = SNAPSHOT_TABLE_BY_KIND[kind];
+        if (!tableExists(deps.state, table))
+            continue;
+        const rows = readRowsFromTable(deps.state, table);
+        rowCounts[kind] = rows.length;
+        if (rows.length > 0) {
+            payload[kind] = rows;
+            capturedKinds.push(kind);
+        }
+    }
+    const snapshot = await deps.restoreSnapshotStore.captureSnapshot({
+        snapshotId,
+        entityWhitelist: requestedKinds,
+        payload,
+        capturedAt: generatedAt,
+    });
+    return {
+        ok: true,
+        command: "snapshot:capture",
+        runtimeMode: "workspace_full_runtime",
+        surfaceMode: "cli",
+        generatedAt,
+        data: {
+            snapshotId: snapshot.snapshotId,
+            capturedAt: snapshot.capturedAt,
+            entityWhitelist: snapshot.entityWhitelist,
+            capturedKinds,
+            rowCounts,
+            narrativeVersion: snapshotId,
+        },
+        warnings,
+        sourceRefs: [
+            "storage/services/restore-snapshot-store.ts",
+            "storage/services/history-digest-store.ts",
+        ],
+    };
+}
 /**
  * T1.2.8 — static local adapter: all checks return `unknown` when no real host is available.
  * Allows `capability_probe` to be called from CLI / workspace bridge without requiring a live host.
@@ -194,7 +284,21 @@ export function createOpsRouter(deps) {
                 const runtimeAvailable = typeof input?.runtimeAvailable === "boolean"
                     ? input.runtimeAvailable
                     : deps.runtimeAvailable;
-                return heartbeatCheck({
+                // v7 T-V7C.C.2: assemble affordance map and experience writer for breaker-aware heartbeat.
+                let affordanceMap;
+                if (deps.toolAffordancePort) {
+                    try {
+                        affordanceMap = await deps.toolAffordancePort.assembleAffordanceMap({});
+                    }
+                    catch {
+                        // degrade gracefully; guard-layer will skip breaker check without affordanceMap
+                    }
+                }
+                let experienceWriter;
+                if (deps.state) {
+                    experienceWriter = createExperienceWriter(createToolExperienceStore(deps.state));
+                }
+                const result = await heartbeatCheck({
                     probeOnly: coerceProbeOnlyFlag(input),
                     runtimeAvailable,
                     fakeControlPlanePassthrough: input?.fakeControlPlanePassthrough &&
@@ -218,7 +322,37 @@ export function createOpsRouter(deps) {
                         ?.connectorExecutor ?? deps.connectorExecutor,
                     connectorRegistry: input
                         ?.connectorRegistry ?? deps.connectorRegistry,
+                    affordanceMap,
+                    experienceWriter,
                 });
+                if (result.ok &&
+                    result.surfaceMode === "workspace_full_runtime" &&
+                    !coerceProbeOnlyFlag(input) &&
+                    deps.state &&
+                    deps.restoreSnapshotStore) {
+                    try {
+                        const capture = await captureRuntimeSnapshot(deps, {
+                            snapshotId: `heartbeat:${result.decisionId ?? "cycle"}:${Date.now()}`,
+                            subjectId: result.decisionId ?? "heartbeat_check",
+                            reasonCode: "heartbeat_check",
+                            summaryText: `Heartbeat ${result.status} captured bounded restore snapshot`,
+                            focus: result.status,
+                            progress: result.reasons.join(",") || "heartbeat_completed",
+                            nextIntent: "continue_runtime_loop",
+                            sourceRefs: result.decisionId
+                                ? [`heartbeat:${result.decisionId}`]
+                                : ["heartbeat:runtime"],
+                        });
+                        if (capture.ok) {
+                            result.reasons = [...result.reasons, "restore_snapshot_captured"];
+                        }
+                    }
+                    catch (err) {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        result.reasons = [...result.reasons, `restore_snapshot_capture_failed:${msg}`];
+                    }
+                }
+                return result;
             }
             if (command === "fallback") {
                 const ref = typeof input?.ref === "string" ? input.ref.trim() : "";
@@ -737,96 +871,7 @@ export function createOpsRouter(deps) {
              * NarrativeTimeline. This gives restore and narrative:diff real state to consume.
              */
             if (command === "snapshot:capture") {
-                const generatedAt = new Date().toISOString();
-                if (!deps.state || !deps.restoreSnapshotStore) {
-                    const envelope = {
-                        ok: false,
-                        command: "snapshot:capture",
-                        runtimeMode: "unavailable",
-                        surfaceMode: "cli",
-                        generatedAt,
-                        error: {
-                            code: "SNAPSHOT_CAPTURE_DEPS_UNAVAILABLE",
-                            message: "snapshot:capture requires state DB and RestoreSnapshotStore in OpsRouterDeps",
-                            nextStep: "wire_state_and_restore_snapshot_store_into_ops_router",
-                        },
-                        warnings: [],
-                        sourceRefs: [],
-                    };
-                    return envelope;
-                }
-                const snapshotId = textInput(input, "snapshotId") ??
-                    `snapshot:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
-                const requestedKinds = coerceRestorableKinds(input?.entityWhitelist) ?? [...DEFAULT_SNAPSHOT_KINDS];
-                const rowCounts = {};
-                const warnings = [];
-                for (const kind of requestedKinds) {
-                    const table = SNAPSHOT_TABLE_BY_KIND[kind];
-                    if (!tableExists(deps.state, table)) {
-                        rowCounts[kind] = 0;
-                        warnings.push(`table_missing:${kind}:${table}`);
-                        continue;
-                    }
-                    rowCounts[kind] = readRowsFromTable(deps.state, table).length;
-                }
-                const historyStore = createHistoryDigestStore(deps.state);
-                const previousHash = (await historyStore.listNarrativeTimeline({ limit: 1 }))[0]?.currentHash ?? "";
-                const delta = buildSnapshotNarrativeDelta(input, snapshotId, rowCounts);
-                const currentHash = hashNarrativeSnapshot({
-                    previousHash,
-                    snapshotId,
-                    delta,
-                    createdAt: generatedAt,
-                });
-                await historyStore.appendNarrativeTimeline({
-                    timelineId: snapshotId,
-                    entryType: "owner.override",
-                    subjectId: textInput(input, "subjectId") ?? snapshotId,
-                    delta,
-                    previousHash,
-                    currentHash,
-                    createdAt: generatedAt,
-                });
-                const payload = {};
-                const capturedKinds = [];
-                for (const kind of requestedKinds) {
-                    const table = SNAPSHOT_TABLE_BY_KIND[kind];
-                    if (!tableExists(deps.state, table))
-                        continue;
-                    const rows = readRowsFromTable(deps.state, table);
-                    rowCounts[kind] = rows.length;
-                    if (rows.length > 0) {
-                        payload[kind] = rows;
-                        capturedKinds.push(kind);
-                    }
-                }
-                const snapshot = await deps.restoreSnapshotStore.captureSnapshot({
-                    snapshotId,
-                    entityWhitelist: requestedKinds,
-                    payload,
-                    capturedAt: generatedAt,
-                });
-                const envelope = {
-                    ok: true,
-                    command: "snapshot:capture",
-                    runtimeMode: "workspace_full_runtime",
-                    surfaceMode: "cli",
-                    generatedAt,
-                    data: {
-                        snapshotId: snapshot.snapshotId,
-                        capturedAt: snapshot.capturedAt,
-                        entityWhitelist: snapshot.entityWhitelist,
-                        capturedKinds,
-                        rowCounts,
-                        narrativeVersion: snapshotId,
-                    },
-                    warnings,
-                    sourceRefs: [
-                        "storage/services/restore-snapshot-store.ts",
-                        "storage/services/history-digest-store.ts",
-                    ],
-                };
-                return envelope;
+                return captureRuntimeSnapshot(deps, input);
             }
             /**
              * [G6] narrative:diff — queryNarrativeDiff between two versions.
@@ -885,6 +930,23 @@ export function createOpsRouter(deps) {
                     return envelope;
                 }
                 catch (err) {
+                    if (err instanceof NarrativeVersionNotFoundError) {
+                        const envelope = {
+                            ok: false,
+                            command: "narrative:diff",
+                            runtimeMode: "workspace_full_runtime",
+                            surfaceMode: "cli",
+                            generatedAt,
+                            error: {
+                                code: "NARRATIVE_VERSION_NOT_FOUND",
+                                message: err.message,
+                                nextStep: "verify_version_exists_in_timeline",
+                            },
+                            warnings: [],
+                            sourceRefs: [],
+                        };
+                        return envelope;
+                    }
                     const msg = err instanceof Error ? err.message : String(err);
                     const envelope = {
                         ok: false,
@@ -1141,6 +1203,73 @@ export function createOpsRouter(deps) {
                     return envelope;
                 }
             }
+            // ─── T-V7C.C.4R: guidance_payload ──────────────────────────────────────
+            // Returns the assembled impulse + atmosphere for a given scene context.
+            // Useful for Claw to inspect what guidance content would be injected before
+            // a real heartbeat cycle, and to verify platform-specific impulse overrides.
+            if (command === "guidance_payload") {
+                const generatedAt = new Date().toISOString();
+                const { assembleImpulseSync } = await import("../../guidance/impulse-assembler.js");
+                const { getBaselineAtmosphereTemplate } = await import("../../guidance/template-registry.js");
+                const sceneType = input?.sceneType ?? "social";
+                const capabilityIntent = typeof input?.capabilityIntent === "string"
+                    ? input.capabilityIntent
+                    : undefined;
+                const platformId = typeof input?.platformId === "string"
+                    ? input.platformId
+                    : undefined;
+                const validSceneTypes = ["social", "reply", "outreach", "quiet", "explain", "user_reply"];
+                if (!validSceneTypes.includes(sceneType)) {
+                    const envelope = {
+                        ok: false,
+                        command: "guidance_payload",
+                        runtimeMode: "unavailable",
+                        surfaceMode: "cli",
+                        generatedAt,
+                        error: {
+                            code: "INVALID_SCENE_TYPE",
+                            message: `sceneType must be one of: ${validSceneTypes.join(", ")}`,
+                            nextStep: "reinvoke_with_valid_scene_type",
+                        },
+                        warnings: [],
+                        sourceRefs: [],
+                    };
+                    return envelope;
+                }
+                const impulseResult = assembleImpulseSync({
+                    sceneType: sceneType,
+                    capabilityIntent,
+                    platformId,
+                });
+                const atmosphere = getBaselineAtmosphereTemplate();
+                const envelope = {
+                    ok: true,
+                    command: "guidance_payload",
+                    runtimeMode: deps.runtimeAvailable ? "workspace_full_runtime" : "host_safe_carrier",
+                    surfaceMode: "cli",
+                    generatedAt,
+                    data: {
+                        sceneType,
+                        capabilityIntent: capabilityIntent ?? null,
+                        platformId: platformId ?? null,
+                        capabilityClass: impulseResult.capabilityClass,
+                        impulseSource: impulseResult.source,
+                        impulseText: impulseResult.impulse?.text ?? null,
+                        impulseReviewStatus: impulseResult.impulse?.reviewStatus ?? null,
+                        atmosphereText: atmosphere.text,
+                        atmosphereReviewStatus: atmosphere.reviewStatus,
+                    },
+                    warnings: impulseResult.source === "none"
+                        ? ["no_impulse_available_for_this_scene_and_capability"]
+                        : [],
+                    sourceRefs: [
+                        "guidance/capability-class.ts",
+                        "guidance/impulse-assembler.ts",
+                        "guidance/template-registry.ts",
+                    ],
+                };
+                return envelope;
+            }
             return {
                 ok: false,
                 error: {

package/runtime/cli/ops/workspace-heartbeat-runner.d.ts

@@ -19,6 +19,10 @@ import type { RuntimeDecisionRecorder } from "../../observability/services/runti
 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";
+import type { AffordanceMap } from "../../shared/types/v7-entities.js";
+import type { ExperienceWriter } from "../../core/second-nature/body/tool-experience/experience-writer.js";
+import type { QuietDreamSchedulePort } from "../../core/second-nature/quiet/run-source-backed-quiet.js";
+import { type HeartbeatDigestAssemblerDeps } from "../../observability/services/heartbeat-digest-assembler.js";
 export interface WorkspaceHeartbeatRunnerOptions {
     /** When supplied, the runner persists the cycle so `loadStatus` can read it (T1.2.3). */
     runtimeRecorder?: RuntimeDecisionRecorder;
@@ -44,9 +48,29 @@ export interface WorkspaceHeartbeatRunnerOptions {
      * and connector evidence.
      */
     connectorRegistry?: CapabilityContractRegistry;
+    /** v7 T-V7C.C.2: affordance map for breaker-aware guard evaluation. */
+    affordanceMap?: AffordanceMap;
+    /** v7 T-V7C.C.2: experience writer for heartbeat connector attempts. */
+    experienceWriter?: ExperienceWriter;
+    /** v7 T-V7C.C.3: when present, a successful Quiet write auto-triggers Dream scheduling. */
+    dreamSchedulePort?: QuietDreamSchedulePort;
+    /**
+     * v7 T-V7C.C.3: when present, generates a HeartbeatDigest after each cycle
+     * (inside the digest window hour, if specified) and attempts delivery.
+     * Digest delivery failure is recorded as fallbackReason — never blocks the cycle.
+     */
+    digestOpts?: {
+        assemblerDeps: HeartbeatDigestAssemblerDeps;
+        /**
+         * UTC hour (0–23) at which to attempt digest generation.
+         * If unset, digest is generated on every cycle (for testing / always-on mode).
+         */
+        digestWindowHour?: number;
+    };
 }
 export declare function loadSnapshotInputsForWorkspaceHeartbeat(readModels: CliReadModels, options?: {
     state?: StateDatabase;
     workspaceRoot?: string;
+    affordanceMap?: AffordanceMap;
 }): Promise<SnapshotInputs>;
 export declare function createWorkspaceHeartbeatRunner(readModels: CliReadModels, options?: WorkspaceHeartbeatRunnerOptions): (signal: HeartbeatSignal) => Promise<HeartbeatCycleResult>;

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

@@ -3,6 +3,8 @@ import { loadLifeEvidenceSnapshot } from "../../storage/snapshots/life-evidence-
 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";
+import { createIdentityProfileStore } from "../../storage/services/identity-profile-store.js";
+import { generateHeartbeatDigest, } from "../../observability/services/heartbeat-digest-assembler.js";
 export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, options = {}) {
     const status = await readModels.loadStatus();
     const mode = status.rhythm.mode === "unknown" ? "active" : status.rhythm.mode;
@@ -69,6 +71,7 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
     // CR-02: Load narrative state and relationship memory when state is available.
     let narrativeState;
     let relationshipMemory;
+    let identity;
     if (options.state) {
         try {
             const narrativeStore = createNarrativeStateStore(options.state);
@@ -84,6 +87,16 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
         catch {
             // Relationship memory is optional; failure should not block the cycle.
         }
+        try {
+            const identityStore = createIdentityProfileStore(options.state);
+            const identityResult = await identityStore.loadIdentityProfile("default");
+            if (identityResult.status === "loaded" && identityResult.profile) {
+                identity = identityResult.profile;
+            }
+        }
+        catch {
+            // Identity is optional; failure should not block the cycle.
+        }
     }
     return {
         mode,
@@ -103,6 +116,8 @@ export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, option
         acceptedGoalsLoadError,
         narrativeState,
         relationshipMemory,
+        affordanceMap: options.affordanceMap,
+        identity,
     };
 }
 export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
@@ -121,10 +136,15 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                 loadSnapshotInputs: () => loadSnapshotInputsForWorkspaceHeartbeat(readModels, {
                     state: options.state,
                     workspaceRoot: options.workspaceRoot,
+                    affordanceMap: options.affordanceMap,
                 }),
                 // T1.2.4: pass quietWorkflow dep so runSourceBackedQuiet can persist artifacts.
                 quietWorkflow: quietEnabled
-                    ? { workspaceRoot: options.workspaceRoot }
+                    ? {
+                        workspaceRoot: options.workspaceRoot,
+                        // v7 T-V7C.C.3: pass Dream schedule port so Quiet completion triggers Dream.
+                        dreamSchedulePort: options.dreamSchedulePort,
+                    }
                     : undefined,
                 connectorExecutor: options.connectorExecutor,
                 narrativeStateStore,
@@ -133,6 +153,8 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                 workspaceRoot: options.workspaceRoot,
                 // T2.4.1: pass registry so planner resolves platform-specific intents.
                 connectorRegistry: options.connectorRegistry,
+                // v7 T-V7C.C.2: pass experience writer for heartbeat connector attempts.
+                experienceWriter: options.experienceWriter,
             },
         });
         if (options.runtimeRecorder) {
@@ -145,6 +167,25 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                 // cycle outcome itself is still returned to the caller.
             }
         }
+        // v7 T-V7C.C.3: After each cycle, attempt HeartbeatDigest generation if configured.
+        // Only runs inside the designated UTC digest window hour, or on every cycle when
+        // digestWindowHour is unset (test / always-on mode).
+        if (options.digestOpts) {
+            const { assemblerDeps, digestWindowHour } = options.digestOpts;
+            const nowHour = new Date().getUTCHours();
+            const inDigestWindow = digestWindowHour === undefined || nowHour === digestWindowHour;
+            if (inDigestWindow) {
+                try {
+                    const date = new Date().toISOString().slice(0, 10);
+                    await generateHeartbeatDigest(date, assemblerDeps);
+                }
+                catch (err) {
+                    // Digest generation must not break the heartbeat cycle response.
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.warn(`[workspace-heartbeat-runner] Digest generation failed: ${msg}`);
+                }
+            }
+        }
         return cycle;
     };
 }

package/runtime/connectors/base/contract.d.ts

@@ -6,6 +6,12 @@ export declare const CAPABILITY_INTENTS: readonly ["feed.read", "post.publish",
 export type BuiltInCapabilityIntent = (typeof CAPABILITY_INTENTS)[number];
 export type CapabilityIntent = BuiltInCapabilityIntent | (string & {});
 export declare function isKnownCapabilityIntent(intent: string): intent is BuiltInCapabilityIntent;
+export interface ConnectorRequestIdentity {
+    /** Platform handle for the target platform (readable, no credential). */
+    platformHandle?: string;
+    /** Canonical name across all platforms. */
+    canonicalName?: string;
+}
 export interface ConnectorRequest {
     platformId: string;
     intent: CapabilityIntent;
@@ -15,6 +21,8 @@ export interface ConnectorRequest {
     idempotencyKey?: string;
     decisionId?: string;
     intentId?: string;
+    /** T-V7C.C.4: identity for connector request (readable, no credential). */
+    identity?: ConnectorRequestIdentity;
 }
 export interface ExecutionPlan {
     platformId: string;
@@ -89,6 +97,8 @@ export interface ConnectorExecutor {
         decisionId: string;
         intentId: string;
         idempotencyKey: string;
+        /** T-V7C.C.4: identity for connector request (readable, no credential). */
+        identity?: ConnectorRequestIdentity;
     }): Promise<ConnectorResult<unknown>>;
 }
 export declare function normalizeOutcome(attempt: RawAttempt): ConnectorResult<unknown>;

package/runtime/connectors/base/map-life-evidence.js

@@ -1,6 +1,11 @@
 function extractSourceRefs(platformId, data, observedAt) {
     if (data && typeof data === "object") {
         const record = data;
+        if (record.data && typeof record.data === "object") {
+            const nested = extractSourceRefs(platformId, record.data, observedAt);
+            if (nested.length > 0)
+                return nested;
+        }
         if (Array.isArray(record.sourceRefs)) {
             const out = [];
             for (const item of record.sourceRefs) {