@haaaiawd/second-nature 0.1.38 → 0.1.40

package/agent-inner-guide.md

@@ -167,3 +167,21 @@ Second Nature 在一些特定动作发生之前，会给你一个简短的内心
 定制 impulse 不需要很长。一到三段，把这个平台在这个动作上的具体质感讲清楚就够了。
 
 格式和内置 impulse 一致——前置 frontmatter，正文纯文字，第一人称"我"，不带标题，不带列表。
+
+## expression boundary 与 output guard
+
+Second Nature 会给你一组表达边界（expression boundary），用来提醒你避免某些腔调或表达陷阱。
+
+它不是格式规范，也不是硬 guard 的 verdict。它只负责一件事：**让你的表达更像你自己，而不是像某个模板、客服系统或日报机器。**
+
+比如它会提醒你：
+
+- 避免客服腔或通知系统语气
+- 避免日报、周报或例行播报腔
+- 避免教程、步骤说明或培训手册腔
+- 不要虚构经历、关系、情绪事件
+- 不要滑进高重复、硬模板化的措辞
+
+这些提醒不会替你决定「能不能做这件事」——能不能做由 hard guard 单独判断。expression boundary 只在你已经决定要做之后，轻轻 shaping 一下你的表达方式。
+
+你也不需要把它当成必须逐条遵守的评分表。它只是空气里的一道微弱边界：当你快要滑进某种腔调时，你会感觉到它在。

package/index.js

@@ -55,6 +55,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_VERSION = JSON.parse(fs.readFileSync(path.resolve(__dirname, "package.json"), "utf-8")).version;
 import { startRuntimeService, } from "./runtime/core/second-nature/runtime/service-entry.js";
 import { getLifecycleState, recordRegistration, } from "./runtime/core/second-nature/runtime/lifecycle-service.js";
 import { openWorkspaceOpsBridge } from "./workspace-ops-bridge.js";
@@ -106,8 +108,9 @@ const WORKSPACE_BRIDGE_COMMANDS = new Set([
     "connector_test",
     "connector_behavior_add",
     "cycle:recent",
-    // v7 ops surface (T-ROS.C.1 / T-ROS.C.2 / T-ROS.C.3): self_health, tool_affordance, heartbeat_digest,
-    // narrative:diff, timeline, restore, runtime_secret_bootstrap, connector:run
+    // 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
     "self_health",
     "tool_affordance",
     "heartbeat_digest",
@@ -117,6 +120,8 @@ const WORKSPACE_BRIDGE_COMMANDS = new Set([
     "restore",
     "runtime_secret_bootstrap",
     "connector:run",
+    // T-V7C.C.5: host ops surface parity — guidance_payload must be whitelisted for Claw reachability
+    "guidance_payload",
 ]);
 function isWorkspaceBridgeCommand(command, input) {
     if (command === "credential") {
@@ -193,6 +198,7 @@ function syncWorkspaceRootFromTool(spine, toolWorkspaceRoot) {
     if (changed) {
         spine.runtimeHandle = startRuntimeService({
             workspaceRoot: next.runtimeRoot,
+            version: PLUGIN_VERSION,
         });
     }
 }
@@ -885,6 +891,7 @@ function createActivationSpine() {
         router: undefined,
         runtimeHandle: startRuntimeService({
             workspaceRoot: workspaceRootContext.runtimeRoot,
+            version: PLUGIN_VERSION,
         }),
         lifecycleState: getLifecycleState(),
         serviceStartRecorded: false,
@@ -933,6 +940,7 @@ function refreshRegistrationState() {
     spine.workspaceRootContext = workspaceRootContext;
     spine.runtimeHandle = startRuntimeService({
         workspaceRoot: workspaceRootContext.runtimeRoot,
+        version: PLUGIN_VERSION,
     });
     spine.lifecycleState = recordRegistration();
     spine.serviceStartRecorded = false;

package/openclaw.plugin.json

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

package/package.json

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

package/runtime/cli/commands/connector-init.js

@@ -11,23 +11,30 @@ function generateManifestYaml(input) {
     const displayName = input.displayName ?? platformId;
     const family = input.family ?? "custom";
     const runnerKind = input.runnerKind ?? "declarative_http";
-    const baseUrlLine = input.baseUrl ? `\nbaseUrl: ${input.baseUrl}` : "";
+    const trustStatus = runnerKind === "declarative_http" ||
+        runnerKind === "declarative_a2a" ||
+        runnerKind === "declarative_mcp"
+        ? "declarative_trusted"
+        : "custom_adapter_pending_trust";
+    const configBlock = input.baseUrl
+        ? `\n  config:\n    baseUrl: ${input.baseUrl}`
+        : "";
     return `schemaVersion: sn.connector.v1
 platformId: ${platformId}
 displayName: ${displayName}
-family: ${family}${baseUrlLine}
+family: ${family}
 capabilities:
   - id: ${platformId}.placeholder
     description: Placeholder capability — replace with real capability declarations
 runner:
   kind: ${runnerKind}
-  entrypoint: ""
+  entrypoint: ""${configBlock}
 credentials: []
 sourceRefPolicy:
   minSourceRefs: 1
   rejectInlineSensitivePayload: true
 trust:
-  status: custom_adapter_pending_trust
+  status: ${trustStatus}
   reason: generated_by_connector_init
 `;
 }

package/runtime/cli/index.js

@@ -113,7 +113,12 @@ function createWorkspaceAffordanceAssembler(registry, workspaceRoot) {
                 return undefined;
             },
         },
-        credentialRequired: () => false,
+        // W80: built-in connectors without probe history should posture as
+        // "needs_auth" (guard allows) rather than "unavailable" (guard defers).
+        credentialRequired: (platformId) => {
+            const builtInPlatforms = new Set(["moltbook", "evomap", "agent-world", "instreet"]);
+            return builtInPlatforms.has(platformId);
+        },
     });
 }
 function stringifyDeltaField(delta, key) {

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

@@ -13,6 +13,8 @@ import type { ConnectorExecutor } from "../../core/second-nature/orchestrator/ef
 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 type HeartbeatSurfaceStatus = "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
 export interface HeartbeatSurfaceResult {
     ok: boolean;
@@ -56,5 +58,18 @@ export interface HeartbeatCheckInput {
     affordanceMap?: AffordanceMap;
     /** v7 T-V7C.C.2: experience writer for heartbeat connector attempts. */
     experienceWriter?: ExperienceWriter;
+    /**
+     * v7 T-V7C.C.6: when present, a successful Quiet write auto-triggers Dream scheduling.
+     * Fixes the production-data gap where dream_output_index does not grow after Quiet.
+     */
+    dreamSchedulePort?: QuietDreamSchedulePort;
+    /**
+     * v7 T-V7C.C.6: when present, generates a HeartbeatDigest after each cycle.
+     * Fixes the production-data gap where heartbeat_digest does not grow.
+     */
+    digestOpts?: {
+        assemblerDeps: HeartbeatDigestAssemblerDeps;
+        digestWindowHour?: number;
+    };
 }
 export declare function heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;

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

@@ -77,7 +77,21 @@ export async function heartbeatCheck(input) {
         connectorRegistry: input.connectorRegistry,
         affordanceMap: input.affordanceMap,
         experienceWriter: input.experienceWriter,
+        dreamSchedulePort: input.dreamSchedulePort,
+        digestOpts: input.digestOpts,
     });
-    const cycle = await run(signal);
-    return mapCycleToSurface(cycle, "workspace_full_runtime");
+    try {
+        const cycle = await run(signal);
+        return mapCycleToSurface(cycle, "workspace_full_runtime");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            status: "denied",
+            surfaceMode: "workspace_full_runtime",
+            reasons: [`heartbeat_cycle_exception:${msg.slice(0, 120)}`],
+            livedExperienceLoopClaimed: false,
+        };
+    }
 }

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

@@ -30,10 +30,54 @@ import { createExperienceWriter } from "../../core/second-nature/body/tool-exper
 import { createCapabilityProbeResultStore, createToolExperienceStore, } from "../../storage/services/tool-experience-store.js";
 import { createWetProbeRunner } from "../../connectors/base/wet-probe-runner.js";
 import { CapabilityContractRegistryV7 } from "../../connectors/base/manifest-v7.js";
+// v7 T-V7C.C.6: Dream scheduling deps for heartbeat_check quiet→dream auto-trigger
+import { scheduleDream } from "../../dream/dream-scheduler.js";
+import { createDreamInputLoader } from "../../dream/dream-input-loader.js";
+import { createDiaryDreamStore } from "../../storage/services/diary-dream-store.js";
 function coerceProbeOnlyFlag(input) {
     const v = input?.probeOnly;
     return v === true || v === "true" || v === 1 || v === "1";
 }
+/**
+ * v7 T-V7C.C.6: Build a minimal QuietDreamSchedulePort backed by the state DB.
+ * When a source-backed Quiet write completes, this port triggers Dream scheduling
+ * via the standard scheduleDream path (rules-only mode when no model port).
+ */
+function createQuietDreamSchedulePort(state) {
+    return {
+        async scheduleDream({ triggerKind, runId, traceId }) {
+            const dreamStore = createDiaryDreamStore(state);
+            const inputLoader = createDreamInputLoader({ database: state });
+            const statePort = {
+                async loadDreamInputs(query) {
+                    return inputLoader.loadDreamInputs(query);
+                },
+                async writeDreamOutput(output) {
+                    // Bridge: dream-engine emits dream/types DreamOutput; diary-dream-store expects shared/types.
+                    // Structures are identical at runtime; TS strictness requires the cast.
+                    await dreamStore.appendDreamOutput(output);
+                    return { outputId: output.outputId, status: "acknowledged" };
+                },
+                async markDreamOutputLifecycle(input) {
+                    // transitionDreamOutputLifecycle only accepts accepted|archived.
+                    if (input.newStatus !== "accepted" && input.newStatus !== "archived") {
+                        return { outputId: input.outputId, status: "degraded" };
+                    }
+                    await dreamStore.transitionDreamOutputLifecycle(input.outputId, input.newStatus);
+                    return { outputId: input.outputId, status: "acknowledged" };
+                },
+            };
+            const result = await scheduleDream({
+                triggerKind,
+                runId,
+                traceId,
+                statePort,
+                windowKey: "quiet_completion",
+            });
+            return { status: result.status, reason: result.reason };
+        },
+    };
+}
 const SNAPSHOT_TABLE_BY_KIND = {
     identity_profile: "identity_profile",
     agent_goal: "agent_goal",
@@ -278,6 +322,8 @@ export function createOpsRouter(deps) {
             connectorExecutor: input.connectorExecutor ?? deps.connectorExecutor,
             connectorRegistry: input
                 ?.connectorRegistry ?? deps.connectorRegistry,
+            digestOpts: input.digestOpts,
+            dreamSchedulePort: input.dreamSchedulePort,
         }),
         async dispatch(command, input) {
             if (command === "heartbeat_check") {
@@ -298,61 +344,98 @@ export function createOpsRouter(deps) {
                 if (deps.state) {
                     experienceWriter = createExperienceWriter(createToolExperienceStore(deps.state));
                 }
-                const result = await heartbeatCheck({
-                    probeOnly: coerceProbeOnlyFlag(input),
-                    runtimeAvailable,
-                    fakeControlPlanePassthrough: input?.fakeControlPlanePassthrough &&
-                        typeof input.fakeControlPlanePassthrough === "object"
-                        ? input.fakeControlPlanePassthrough
-                        : undefined,
-                    readModels: input?.readModels ??
-                        deps.readModels,
-                    runtimeRecorder: input
-                        ?.runtimeRecorder ?? deps.runtimeRecorder,
-                    state: input?.state ??
-                        deps.state,
-                    workspaceRoot: input
-                        ?.workspaceRoot ?? deps.workspaceRoot,
-                    timestamp: typeof input?.timestamp === "string" ? input.timestamp : undefined,
-                    sessionContext: typeof input?.sessionContext === "string"
-                        ? input.sessionContext
-                        : undefined,
-                    scopeHint: input?.scopeHint,
-                    connectorExecutor: input
-                        ?.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"];
+                // v7 T-V7C.C.6: assemble digest opts when auditStore is wired.
+                let digestOpts;
+                if (deps.auditStore) {
+                    digestOpts = {
+                        assemblerDeps: {
+                            auditStore: deps.auditStore,
+                            ...deps.heartbeatDigestDeps,
+                        },
+                    };
+                }
+                // v7 T-V7C.C.6: assemble dream schedule port when state DB is wired.
+                let dreamSchedulePort;
+                if (deps.state) {
+                    dreamSchedulePort = createQuietDreamSchedulePort(deps.state);
+                }
+                try {
+                    const result = await heartbeatCheck({
+                        probeOnly: coerceProbeOnlyFlag(input),
+                        runtimeAvailable,
+                        fakeControlPlanePassthrough: input?.fakeControlPlanePassthrough &&
+                            typeof input.fakeControlPlanePassthrough === "object"
+                            ? input.fakeControlPlanePassthrough
+                            : undefined,
+                        readModels: input?.readModels ??
+                            deps.readModels,
+                        runtimeRecorder: input
+                            ?.runtimeRecorder ?? deps.runtimeRecorder,
+                        state: input?.state ??
+                            deps.state,
+                        workspaceRoot: input
+                            ?.workspaceRoot ?? deps.workspaceRoot,
+                        timestamp: typeof input?.timestamp === "string" ? input.timestamp : undefined,
+                        sessionContext: typeof input?.sessionContext === "string"
+                            ? input.sessionContext
+                            : undefined,
+                        scopeHint: input?.scopeHint,
+                        connectorExecutor: input
+                            ?.connectorExecutor ?? deps.connectorExecutor,
+                        connectorRegistry: input
+                            ?.connectorRegistry ?? deps.connectorRegistry,
+                        affordanceMap,
+                        experienceWriter,
+                        digestOpts,
+                        dreamSchedulePort,
+                    });
+                    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}`];
                         }
                     }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        result.reasons = [...result.reasons, `restore_snapshot_capture_failed:${msg}`];
-                    }
+                    return result;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    const envelope = {
+                        ok: false,
+                        command: "heartbeat_check",
+                        runtimeMode: runtimeAvailable ? "workspace_full_runtime" : "unavailable",
+                        surfaceMode: "cli",
+                        generatedAt: new Date().toISOString(),
+                        error: {
+                            code: "HEARTBEAT_CYCLE_EXCEPTION",
+                            message: `heartbeat_check cycle threw unexpectedly: ${msg.slice(0, 200)}`,
+                            nextStep: "check_logs_and_report",
+                        },
+                        warnings: [],
+                        sourceRefs: [],
+                    };
+                    return envelope;
                 }
-                return result;
             }
             if (command === "fallback") {
                 const ref = typeof input?.ref === "string" ? input.ref.trim() : "";
@@ -569,7 +652,9 @@ export function createOpsRouter(deps) {
                     warnings.push("state_db_unavailable:capability_probe_result_not_persisted");
                 }
                 return {
-                    ok: wetResult.probeResult.actualStatus !== "unavailable",
+                    // T-V7C.C.5: only "available" (HTTP 200-299) counts as success;
+                    // "degraded" (429/503) and "unavailable" both result in ok=false.
+                    ok: wetResult.probeResult.actualStatus === "available",
                     command: "connector_test",
                     data: {
                         ...data,
@@ -1047,29 +1132,84 @@ export function createOpsRouter(deps) {
                     };
                     return envelope;
                 }
-                const missingFields = [];
-                if (typeof input?.restoreTarget !== "string")
-                    missingFields.push("restoreTarget");
-                if (typeof input?.fromVersion !== "string")
-                    missingFields.push("fromVersion");
-                if (typeof input?.toVersion !== "string")
-                    missingFields.push("toVersion");
-                if (missingFields.length > 0) {
-                    const envelope = {
-                        ok: false,
-                        command: "restore",
-                        runtimeMode: "workspace_full_runtime",
-                        surfaceMode: "cli",
-                        generatedAt,
-                        error: {
-                            code: "MISSING_RESTORE_FIELDS",
-                            message: `restore requires: ${missingFields.join(", ")}`,
-                            nextStep: "reinvoke_with_required_fields",
-                        },
-                        warnings: [],
-                        sourceRefs: [],
-                    };
-                    return envelope;
+                let restoreTarget;
+                let fromVersion;
+                let toVersion;
+                // T-V7C.C.5: snapshotId operator-friendly parameter takes precedence over legacy fields.
+                // When snapshotId is provided, resolve restoreTarget/fromVersion/toVersion from the
+                // matching snapshot row; otherwise fall back to explicit legacy parameters.
+                const snapshotId = textInput(input, "snapshotId");
+                if (snapshotId) {
+                    if (!deps.restoreSnapshotStore) {
+                        const envelope = {
+                            ok: false,
+                            command: "restore",
+                            runtimeMode: "unavailable",
+                            surfaceMode: "cli",
+                            generatedAt,
+                            error: {
+                                code: "RESTORE_SNAPSHOT_STORE_UNAVAILABLE",
+                                message: "snapshotId restore requires restoreSnapshotStore in OpsRouterDeps",
+                                nextStep: "wire_restore_snapshot_store_into_ops_router",
+                            },
+                            warnings: [],
+                            sourceRefs: [],
+                        };
+                        return envelope;
+                    }
+                    const snapshots = await deps.restoreSnapshotStore.listSnapshots();
+                    const match = snapshots.find((s) => s.snapshotId === snapshotId);
+                    if (match) {
+                        restoreTarget = snapshotId;
+                        fromVersion = match.capturedAt;
+                        toVersion = snapshotId;
+                    }
+                    else {
+                        const envelope = {
+                            ok: false,
+                            command: "restore",
+                            runtimeMode: "workspace_full_runtime",
+                            surfaceMode: "cli",
+                            generatedAt,
+                            error: {
+                                code: "SNAPSHOT_NOT_FOUND",
+                                message: `snapshotId ${snapshotId} not found in restore_snapshot table`,
+                                nextStep: "list_available_snapshots_or_verify_snapshotId",
+                            },
+                            warnings: [],
+                            sourceRefs: [],
+                        };
+                        return envelope;
+                    }
+                }
+                else {
+                    const missingFields = [];
+                    if (typeof input?.restoreTarget !== "string")
+                        missingFields.push("restoreTarget");
+                    if (typeof input?.fromVersion !== "string")
+                        missingFields.push("fromVersion");
+                    if (typeof input?.toVersion !== "string")
+                        missingFields.push("toVersion");
+                    if (missingFields.length > 0) {
+                        const envelope = {
+                            ok: false,
+                            command: "restore",
+                            runtimeMode: "workspace_full_runtime",
+                            surfaceMode: "cli",
+                            generatedAt,
+                            error: {
+                                code: "MISSING_RESTORE_FIELDS",
+                                message: `restore requires: ${missingFields.join(", ")}`,
+                                nextStep: "reinvoke_with_required_fields",
+                            },
+                            warnings: [],
+                            sourceRefs: [],
+                        };
+                        return envelope;
+                    }
+                    restoreTarget = input.restoreTarget;
+                    fromVersion = input.fromVersion;
+                    toVersion = input.toVersion;
                 }
                 // [NEW] Invoke bounded restore via RestoreSnapshotStore when wired
                 let restoreResult = {
@@ -1080,16 +1220,16 @@ export function createOpsRouter(deps) {
                 };
                 if (deps.restoreSnapshotStore) {
                     restoreResult = await deps.restoreSnapshotStore.applyBoundedRestore({
-                        restoreTarget: input.restoreTarget,
-                        fromVersion: input.fromVersion,
-                        toVersion: input.toVersion,
+                        restoreTarget: restoreTarget,
+                        fromVersion: fromVersion,
+                        toVersion: toVersion,
                     });
                 }
                 const event = {
                     id: `restore-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-                    restoreTarget: input.restoreTarget,
-                    fromVersion: input.fromVersion,
-                    toVersion: input.toVersion,
+                    restoreTarget: restoreTarget,
+                    fromVersion: fromVersion,
+                    toVersion: toVersion,
                     triggeredBy: input?.triggeredBy ?? "operator",
                     reason: typeof input?.reason === "string" ? input.reason : "manual_restore",
                     completedEntities: restoreResult.completedEntities,
@@ -1241,7 +1381,10 @@ export function createOpsRouter(deps) {
                     capabilityIntent,
                     platformId,
                 });
-                const atmosphere = getBaselineAtmosphereTemplate();
+                const { buildExpressionBoundary } = await import("../../guidance/output-guard.js");
+                const { getShortAtmosphereTemplate } = await import("../../guidance/template-registry.js");
+                const atmosphere = getShortAtmosphereTemplate("active", "low");
+                const expressionBoundary = buildExpressionBoundary(sceneType);
                 const envelope = {
                     ok: true,
                     command: "guidance_payload",
@@ -1258,6 +1401,8 @@ export function createOpsRouter(deps) {
                         impulseReviewStatus: impulseResult.impulse?.reviewStatus ?? null,
                         atmosphereText: atmosphere.text,
                         atmosphereReviewStatus: atmosphere.reviewStatus,
+                        expressionBoundaryConstraints: expressionBoundary.constraints,
+                        expressionBoundaryStyle: expressionBoundary.style,
                     },
                     warnings: impulseResult.source === "none"
                         ? ["no_impulse_available_for_this_scene_and_capability"]
@@ -1266,6 +1411,7 @@ export function createOpsRouter(deps) {
                         "guidance/capability-class.ts",
                         "guidance/impulse-assembler.ts",
                         "guidance/template-registry.ts",
+                        "guidance/output-guard.ts",
                     ],
                 };
                 return envelope;