@haaaiawd/second-nature 0.2.2 → 0.2.5

package/runtime/core/second-nature/control-plane/heartbeat-orchestrator.js

@@ -25,6 +25,12 @@ import { writeHeartbeatCycleTrace, readHeartbeatCycleTraces, } from "../../../st
 import { recordLoopStageEvent } from "../../../observability/loop-stage-event-sink.js";
 import { buildPerceptionCards } from "../perception/perception-builder.js";
 import { runAgentJudgments } from "../perception/judgment-engine.js";
+import { loadAcceptedProjections } from "./accepted-projection-loader.js";
+import { buildActionProposal, } from "../action/action-proposal-builder.js";
+import { evaluateActionPolicy } from "../action/autonomy-policy-evaluator.js";
+import { dispatchAllowedAction } from "../action/policy-bound-dispatch.js";
+import { recordNoActionClosure, recordRememberClosure, recordPolicyOutcomeClosure, recordExecutionClosure, } from "../action/action-closure-recorder.js";
+import { checkDailyRhythm } from "../quiet-dream/daily-rhythm-scheduler.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
@@ -38,6 +44,66 @@ async function nextCycleSequence(db) {
 function buildCycleId(sequence, now) {
     return `cyc_${now.replace(/[:.]/g, "")}_${sequence}`;
 }
+async function advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now) {
+    try {
+        const rhythmResult = await checkDailyRhythm(db, { now });
+        if ("status" in rhythmResult && rhythmResult.status === "checked") {
+            await recordLoopStageEvent(db, {
+                id: `evt_${cycleId}_daily_rhythm`,
+                cycleId,
+                cycleSequence,
+                stage: "quiet",
+                status: "completed",
+                occurredAt: new Date().toISOString(),
+                sourceRefs: [
+                    cycleRef,
+                    {
+                        uri: `sn://rhythm/${rhythmResult.state.day}`,
+                        family: "dream_run",
+                        id: `rhythm_${rhythmResult.state.day}`,
+                        redactionClass: "none",
+                        resolveStatus: "resolvable",
+                    },
+                ],
+            });
+            return { rhythmState: rhythmResult.state };
+        }
+        const degraded = rhythmResult;
+        await recordLoopStageEvent(db, {
+            id: `evt_${cycleId}_daily_rhythm`,
+            cycleId,
+            cycleSequence,
+            stage: "quiet",
+            status: "failed",
+            occurredAt: new Date().toISOString(),
+            reason: degraded.reason,
+            sourceRefs: [cycleRef],
+        });
+        return { rhythmDegraded: degraded };
+    }
+    catch (rhythmErr) {
+        const errMsg = rhythmErr instanceof Error ? rhythmErr.message : String(rhythmErr);
+        const degraded = {
+            status: "degraded",
+            reason: "state_unreadable",
+            ownerStage: "quiet",
+            sourceRefs: [cycleRef],
+            operatorNextAction: `Daily rhythm check failed: ${errMsg.slice(0, 120)}`,
+            retryable: true,
+        };
+        await recordLoopStageEvent(db, {
+            id: `evt_${cycleId}_daily_rhythm`,
+            cycleId,
+            cycleSequence,
+            stage: "quiet",
+            status: "failed",
+            occurredAt: new Date().toISOString(),
+            reason: degraded.reason,
+            sourceRefs: [cycleRef],
+        });
+        return { rhythmDegraded: degraded };
+    }
+}
 // ───────────────────────────────────────────────────────────────
 // Public API
 // ───────────────────────────────────────────────────────────────
@@ -45,6 +111,13 @@ export async function runHeartbeatCycle(db, request) {
     const now = request.requestedAt ?? new Date().toISOString();
     const cycleSequence = await nextCycleSequence(db);
     const cycleId = buildCycleId(cycleSequence, now);
+    const cycleRef = {
+        uri: `sn://heartbeat/${cycleId}`,
+        family: "audit",
+        id: cycleId,
+        redactionClass: "none",
+        resolveStatus: "resolvable",
+    };
     // Write cycle trace — started
     const traceResult = await writeHeartbeatCycleTrace(db, {
         id: cycleId,
@@ -53,22 +126,14 @@ export async function runHeartbeatCycle(db, request) {
         inputCount: 0,
         outputCount: 0,
         status: "started",
-        sourceRefs: [
-            {
-                uri: `sn://heartbeat/${cycleId}`,
-                family: "audit",
-                id: cycleId,
-                redactionClass: "none",
-                resolveStatus: "resolvable",
-            },
-        ],
+        sourceRefs: [cycleRef],
     });
     if ("reason" in traceResult) {
         return {
             status: "degraded",
             reason: "state_unreadable",
             ownerStage: "ingestion",
-            sourceRefs: [],
+            sourceRefs: [cycleRef],
             operatorNextAction: "Retry heartbeat after DB recovery",
             retryable: true,
         };
@@ -81,7 +146,7 @@ export async function runHeartbeatCycle(db, request) {
         stage: "ingestion",
         status: "started",
         occurredAt: now,
-        sourceRefs: [],
+        sourceRefs: [cycleRef],
     });
     // ── Perception stage ──
     const perceptionResult = await buildPerceptionCards(db, { cycleId, now });
@@ -98,22 +163,51 @@ export async function runHeartbeatCycle(db, request) {
         reason: perceptionDegraded
             ? perceptionResult.reason
             : undefined,
-        sourceRefs: [],
+        sourceRefs: [cycleRef],
     });
     if (perceptionDegraded || !("cards" in perceptionResult)) {
+        // Degraded path must still write a closure for observability
+        const degradedReason = perceptionDegraded
+            ? (perceptionResult.reason ?? "state_unreadable")
+            : "perception_failed";
+        const closureResult = await recordNoActionClosure(db, cycleId, degradedReason, { now });
+        let degradedClosureRef;
+        if ("closureId" in closureResult) {
+            degradedClosureRef = {
+                uri: `sn://closure/${closureResult.closureId}`,
+                family: "action_closure",
+                id: closureResult.closureId,
+                redactionClass: "none",
+                resolveStatus: "resolvable",
+            };
+        }
+        await recordLoopStageEvent(db, {
+            id: `evt_${cycleId}_closure`,
+            cycleId,
+            cycleSequence,
+            stage: "closure",
+            status: "failed",
+            occurredAt: new Date().toISOString(),
+            reason: degradedReason,
+            sourceRefs: degradedClosureRef ? [degradedClosureRef, cycleRef] : [cycleRef],
+        });
+        const { rhythmState } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
         return {
             cycleId,
             cycleSequence,
+            closureRef: degradedClosureRef,
+            noActionReason: degradedReason,
             degraded: perceptionDegraded
                 ? {
                     status: "degraded",
                     reason: perceptionResult.reason ?? "state_unreadable",
                     ownerStage: "perception",
-                    sourceRefs: [],
+                    sourceRefs: [cycleRef],
                     operatorNextAction: "Retry heartbeat after perception recovery",
                     retryable: true,
                 }
                 : undefined,
+            rhythmState,
         };
     }
     const cards = perceptionResult.cards;
@@ -127,16 +221,44 @@ export async function runHeartbeatCycle(db, request) {
             status: "skipped",
             occurredAt: new Date().toISOString(),
             reason: "evidence_batch_empty",
-            sourceRefs: [],
+            sourceRefs: [cycleRef],
+        });
+        // Write no-action closure — every cycle must produce exactly one
+        const closureResult = await recordNoActionClosure(db, cycleId, "evidence_batch_empty", { now });
+        let emptyClosureRef;
+        if ("closureId" in closureResult) {
+            emptyClosureRef = {
+                uri: `sn://closure/${closureResult.closureId}`,
+                family: "action_closure",
+                id: closureResult.closureId,
+                redactionClass: "none",
+                resolveStatus: "resolvable",
+            };
+        }
+        await recordLoopStageEvent(db, {
+            id: `evt_${cycleId}_closure`,
+            cycleId,
+            cycleSequence,
+            stage: "closure",
+            status: "completed",
+            occurredAt: new Date().toISOString(),
+            reason: "evidence_batch_empty",
+            sourceRefs: emptyClosureRef ? [emptyClosureRef, cycleRef] : [cycleRef],
         });
+        const { rhythmState } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
         return {
             cycleId,
             cycleSequence,
+            closureRef: emptyClosureRef,
             noActionReason: "evidence_batch_empty",
+            rhythmState,
         };
     }
+    // ── Context assembly: load accepted projections (T-DQ.R.3) ──
+    const projectionResult = await loadAcceptedProjections(db);
+    const acceptedProjections = projectionResult.ok ? projectionResult.slice.projections : [];
     // ── Judgment stage ──
-    const judgmentResult = await runAgentJudgments(db, cards.map((c) => c.id), { now });
+    const judgmentResult = await runAgentJudgments(db, cards.map((c) => c.id), { now, acceptedProjections });
     const judgmentFailed = judgmentResult.failed.length > 0;
     await recordLoopStageEvent(db, {
         id: `evt_${cycleId}_judgment`,
@@ -145,21 +267,286 @@ export async function runHeartbeatCycle(db, request) {
         stage: "judgment",
         status: judgmentFailed ? "failed" : "completed",
         occurredAt: new Date().toISOString(),
-        sourceRefs: [],
+        sourceRefs: [cycleRef],
     });
-    // Return cycle result
-    return {
+    // ── Action/Closure stage (T-CP.R.2) ──
+    // Every cycle must produce exactly one closure or no-action record.
+    let closureRef;
+    let noActionReason;
+    let closureDegraded;
+    // Record policy stage started
+    await recordLoopStageEvent(db, {
+        id: `evt_${cycleId}_policy`,
         cycleId,
         cycleSequence,
-        closureRef: judgmentResult.succeeded.length > 0
-            ? {
-                uri: `sn://judgment/${cycleId}`,
-                family: "judgment",
-                id: cycleId,
+        stage: "policy",
+        status: "started",
+        occurredAt: new Date().toISOString(),
+        sourceRefs: [cycleRef],
+    });
+    if (judgmentResult.succeeded.length === 0) {
+        // No actionable verdicts → no-action closure
+        const closureResult = await recordNoActionClosure(db, cycleId, "proposal_no_action", { now });
+        if ("closureId" in closureResult) {
+            closureRef = {
+                uri: `sn://closure/${closureResult.closureId}`,
+                family: "action_closure",
+                id: closureResult.closureId,
                 redactionClass: "none",
                 resolveStatus: "resolvable",
+            };
+        }
+        else if ("reason" in closureResult) {
+            closureDegraded = closureResult;
+        }
+        noActionReason = "proposal_no_action";
+    }
+    else {
+        // Find first actionable verdict (non-ignore, non-watch)
+        const actionableVerdict = judgmentResult.succeeded.find((v) => v.actionKind !== "ignore" && v.actionKind !== "watch");
+        if (!actionableVerdict) {
+            // All verdicts are ignore/watch → no-action
+            const closureResult = await recordNoActionClosure(db, cycleId, "proposal_no_action", { now });
+            if ("closureId" in closureResult) {
+                closureRef = {
+                    uri: `sn://closure/${closureResult.closureId}`,
+                    family: "action_closure",
+                    id: closureResult.closureId,
+                    redactionClass: "none",
+                    resolveStatus: "resolvable",
+                };
             }
-            : undefined,
-        noActionReason: judgmentResult.succeeded.length === 0 ? "proposal_no_action" : undefined,
+            else if ("reason" in closureResult) {
+                closureDegraded = closureResult;
+            }
+            noActionReason = "proposal_no_action";
+        }
+        else {
+            // Build proposal for the actionable verdict
+            const proposalResult = await buildActionProposal(db, actionableVerdict.id, { now });
+            if ("status" in proposalResult && proposalResult.status === "degraded") {
+                // Proposal build failed — still need a closure
+                closureDegraded = proposalResult;
+                const closureResult = await recordNoActionClosure(db, cycleId, closureDegraded.reason, { now });
+                if ("closureId" in closureResult) {
+                    closureRef = {
+                        uri: `sn://closure/${closureResult.closureId}`,
+                        family: "action_closure",
+                        id: closureResult.closureId,
+                        redactionClass: "none",
+                        resolveStatus: "resolvable",
+                    };
+                }
+                noActionReason = closureDegraded.reason;
+                await recordLoopStageEvent(db, {
+                    id: `evt_${cycleId}_policy`,
+                    cycleId,
+                    cycleSequence,
+                    stage: "policy",
+                    status: "failed",
+                    occurredAt: new Date().toISOString(),
+                    reason: closureDegraded.reason,
+                    sourceRefs: closureDegraded.sourceRefs.length > 0 ? closureDegraded.sourceRefs : [cycleRef],
+                });
+            }
+            else if (proposalResult.status === "no_action") {
+                const noAction = proposalResult;
+                const closureResult = await recordNoActionClosure(db, cycleId, noAction.reason, { now });
+                if ("closureId" in closureResult) {
+                    closureRef = {
+                        uri: `sn://closure/${closureResult.closureId}`,
+                        family: "action_closure",
+                        id: closureResult.closureId,
+                        redactionClass: "none",
+                        resolveStatus: "resolvable",
+                    };
+                }
+                noActionReason = noAction.reason;
+            }
+            else if (proposalResult.status === "remember_for_review") {
+                const remember = proposalResult;
+                const closureResult = await recordRememberClosure(db, cycleId, remember.memoryReviewCandidate, { now });
+                if ("closureId" in closureResult) {
+                    closureRef = {
+                        uri: `sn://closure/${closureResult.closureId}`,
+                        family: "action_closure",
+                        id: closureResult.closureId,
+                        redactionClass: "none",
+                        resolveStatus: "resolvable",
+                    };
+                }
+                else if ("reason" in closureResult) {
+                    closureDegraded = closureResult;
+                }
+            }
+            else if (proposalResult.status === "proposal") {
+                const { proposal } = proposalResult;
+                // Evaluate policy — conservative defaults: no real platform permission, no auto-allow
+                const decision = evaluateActionPolicy(proposal, {
+                    breakerStatus: "closed",
+                    platformPermissionDeclared: false,
+                    ownerPreferenceAllowAuto: false,
+                }, { now });
+                await recordLoopStageEvent(db, {
+                    id: `evt_${cycleId}_policy`,
+                    cycleId,
+                    cycleSequence,
+                    stage: "policy",
+                    status: "completed",
+                    occurredAt: new Date().toISOString(),
+                    reason: decision.decisionReason,
+                    sourceRefs: decision.proofRefs,
+                });
+                // Record execution stage started
+                await recordLoopStageEvent(db, {
+                    id: `evt_${cycleId}_execution`,
+                    cycleId,
+                    cycleSequence,
+                    stage: "execution",
+                    status: "started",
+                    occurredAt: new Date().toISOString(),
+                    sourceRefs: decision.proofRefs,
+                });
+                // Dispatch — no real external write in T-CP.R.2
+                const dispatchResult = dispatchAllowedAction(proposal, decision, { guidanceAvailable: false });
+                // Record closure based on dispatch outcome
+                if (dispatchResult.type === "none") {
+                    const closureStatus = decision.decision === "deny" ? "denied" : "deferred";
+                    const closureResult = await recordPolicyOutcomeClosure(db, cycleId, closureStatus, decision.decisionReason, {
+                        proposalId: proposal.id,
+                        decisionId: decision.id,
+                        platformId: proposal.targetPlatformId,
+                        capabilityId: proposal.targetCapabilityId,
+                        nextState: "await_next_cycle",
+                    }, { now });
+                    if ("closureId" in closureResult) {
+                        closureRef = {
+                            uri: `sn://closure/${closureResult.closureId}`,
+                            family: "action_closure",
+                            id: closureResult.closureId,
+                            redactionClass: "none",
+                            resolveStatus: "resolvable",
+                        };
+                    }
+                    else if ("reason" in closureResult) {
+                        closureDegraded = closureResult;
+                    }
+                }
+                else if (dispatchResult.type === "guidance_unavailable") {
+                    const closureResult = await recordPolicyOutcomeClosure(db, cycleId, "downgraded", "guidance_unavailable", {
+                        proposalId: proposal.id,
+                        decisionId: decision.id,
+                        platformId: proposal.targetPlatformId,
+                        capabilityId: proposal.targetCapabilityId,
+                        downgradedActionKind: dispatchResult.downgradedActionKind,
+                        nextState: "await_guidance_recovery",
+                    }, { now });
+                    if ("closureId" in closureResult) {
+                        closureRef = {
+                            uri: `sn://closure/${closureResult.closureId}`,
+                            family: "action_closure",
+                            id: closureResult.closureId,
+                            redactionClass: "none",
+                            resolveStatus: "resolvable",
+                        };
+                    }
+                    else if ("reason" in closureResult) {
+                        closureDegraded = closureResult;
+                    }
+                }
+                else if (dispatchResult.type === "guidance") {
+                    // Guidance draft dispatch — no external write
+                    const closureResult = await recordExecutionClosure(db, cycleId, "completed", "policy_allowed", {
+                        proposalId: proposal.id,
+                        decisionId: decision.id,
+                        platformId: proposal.targetPlatformId,
+                        capabilityId: proposal.targetCapabilityId,
+                        outputSummary: "Guidance draft dispatched (simulated)",
+                        nextState: "await_next_cycle",
+                    }, { now });
+                    if ("closureId" in closureResult) {
+                        closureRef = {
+                            uri: `sn://closure/${closureResult.closureId}`,
+                            family: "action_closure",
+                            id: closureResult.closureId,
+                            redactionClass: "none",
+                            resolveStatus: "resolvable",
+                        };
+                    }
+                    else if ("reason" in closureResult) {
+                        closureDegraded = closureResult;
+                    }
+                }
+                else if (dispatchResult.type === "connector") {
+                    // Connector dispatch — simulated, no real platform write (T-CP.R.2)
+                    const closureResult = await recordExecutionClosure(db, cycleId, "completed", "policy_allowed", {
+                        proposalId: proposal.id,
+                        decisionId: decision.id,
+                        platformId: proposal.targetPlatformId,
+                        capabilityId: proposal.targetCapabilityId,
+                        outputSummary: "Connector dispatch prepared (simulated — T-CP.R.2)",
+                        nextState: "await_real_execution",
+                    }, { now });
+                    if ("closureId" in closureResult) {
+                        closureRef = {
+                            uri: `sn://closure/${closureResult.closureId}`,
+                            family: "action_closure",
+                            id: closureResult.closureId,
+                            redactionClass: "none",
+                            resolveStatus: "resolvable",
+                        };
+                    }
+                    else if ("reason" in closureResult) {
+                        closureDegraded = closureResult;
+                    }
+                }
+                // Record execution stage completed
+                await recordLoopStageEvent(db, {
+                    id: `evt_${cycleId}_execution`,
+                    cycleId,
+                    cycleSequence,
+                    stage: "execution",
+                    status: closureDegraded ? "failed" : "completed",
+                    occurredAt: new Date().toISOString(),
+                    reason: closureDegraded?.reason,
+                    sourceRefs: decision.proofRefs,
+                });
+            }
+        }
+    }
+    // Record closure stage event
+    await recordLoopStageEvent(db, {
+        id: `evt_${cycleId}_closure`,
+        cycleId,
+        cycleSequence,
+        stage: "closure",
+        status: closureDegraded ? "failed" : "completed",
+        occurredAt: new Date().toISOString(),
+        reason: closureDegraded?.reason ?? noActionReason,
+        sourceRefs: closureRef ? [closureRef, cycleRef] : [cycleRef],
+    });
+    // Final safety net: if somehow nothing was recorded, write a degraded no-action
+    if (!closureRef && !noActionReason && !closureDegraded) {
+        const fallback = await recordNoActionClosure(db, cycleId, "proposal_no_action", { now });
+        if ("closureId" in fallback) {
+            closureRef = {
+                uri: `sn://closure/${fallback.closureId}`,
+                family: "action_closure",
+                id: fallback.closureId,
+                redactionClass: "none",
+                resolveStatus: "resolvable",
+            };
+        }
+        noActionReason = "proposal_no_action";
+    }
+    // T-CP.R.3: Advance daily rhythm after closure/no-action
+    const { rhythmState } = await advanceAndRecordDailyRhythm(db, cycleId, cycleSequence, cycleRef, now);
+    return {
+        cycleId,
+        cycleSequence,
+        closureRef,
+        noActionReason,
+        degraded: closureDegraded,
+        rhythmState,
     };
 }

package/runtime/core/second-nature/control-plane/real-runtime-spine.d.ts

@@ -0,0 +1,35 @@
+/**
+ * RealRuntimeSpine — Bridge real workspace heartbeat into v8 action-closure spine.
+ *
+ * Core logic: Wrap v8 heartbeat orchestrator for CLI/OpenClaw consumption.
+ * Ensures every real heartbeat cycle writes exactly one closure/no-action
+ * with state-backed persistence and canonical stage events.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/control-plane-system.md §4`
+ * - `.anws/v8/04_SYSTEM_DESIGN/action-closure-policy-system.md §4.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/runtime-ops-system.md §4`
+ *
+ * Boundary:
+ * - Does NOT execute real external writes (T-CP.R.2).
+ * - Does NOT register fake context-engines.
+ * - Delegates all semantic decisions to action-closure-policy-system.
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+import type { SourceRef, DegradedOperationResult, V8ReasonCode } from "../../../shared/types/v8-contracts.js";
+import type { DailyRhythmState } from "../quiet-dream/daily-rhythm-scheduler.js";
+export interface RealRuntimeSpineOptions {
+    workspaceRoot: string;
+    state: StateDatabase;
+    requestedAt?: string;
+    trigger?: "scheduled" | "manual" | "host";
+}
+export interface RealRuntimeSpineResult {
+    cycleId: string;
+    cycleSequence: number;
+    closureRef?: SourceRef;
+    noActionReason?: V8ReasonCode;
+    degraded?: DegradedOperationResult;
+    rhythmState?: DailyRhythmState;
+}
+export declare function runRealRuntimeHeartbeatCycle(options: RealRuntimeSpineOptions): Promise<RealRuntimeSpineResult | DegradedOperationResult>;

package/runtime/core/second-nature/control-plane/real-runtime-spine.js

@@ -0,0 +1,42 @@
+/**
+ * RealRuntimeSpine — Bridge real workspace heartbeat into v8 action-closure spine.
+ *
+ * Core logic: Wrap v8 heartbeat orchestrator for CLI/OpenClaw consumption.
+ * Ensures every real heartbeat cycle writes exactly one closure/no-action
+ * with state-backed persistence and canonical stage events.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/control-plane-system.md §4`
+ * - `.anws/v8/04_SYSTEM_DESIGN/action-closure-policy-system.md §4.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/runtime-ops-system.md §4`
+ *
+ * Boundary:
+ * - Does NOT execute real external writes (T-CP.R.2).
+ * - Does NOT register fake context-engines.
+ * - Delegates all semantic decisions to action-closure-policy-system.
+ */
+import { runHeartbeatCycle, } from "./heartbeat-orchestrator.js";
+// ───────────────────────────────────────────────────────────────
+// Public API
+// ───────────────────────────────────────────────────────────────
+export async function runRealRuntimeHeartbeatCycle(options) {
+    const request = {
+        workspaceRoot: options.workspaceRoot,
+        requestedAt: options.requestedAt,
+        trigger: options.trigger ?? "scheduled",
+    };
+    const result = await runHeartbeatCycle(options.state, request);
+    // Pass through degraded results directly
+    if ("status" in result && result.status === "degraded") {
+        return result;
+    }
+    const orchestrationResult = result;
+    return {
+        cycleId: orchestrationResult.cycleId,
+        cycleSequence: orchestrationResult.cycleSequence,
+        closureRef: orchestrationResult.closureRef,
+        noActionReason: orchestrationResult.noActionReason,
+        degraded: orchestrationResult.degraded,
+        rhythmState: orchestrationResult.rhythmState,
+    };
+}

package/runtime/core/second-nature/guidance/impulse-context-reader.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ImpulseContextReader — Read agent-facing impulse context artifact from state.
+ *
+ * Core logic: Retrieve the latest persisted artifact for a given scene/capability
+ * combo, with freshness diagnostics and explicit missing-artifact reasons.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/guidance-voice-system.md §1`
+ * - `docs/validation/openclaw-plugin-classification.md §5`
+ *
+ * Dependencies:
+ * - `src/storage/v8-state-stores.js` (readImpulseContextArtifact)
+ *
+ * Boundary:
+ * - Does NOT fall back to real-time assembly; returns missing reason when absent.
+ * - Does NOT register a fake OpenClaw context-engine.
+ */
+import type { StateDatabase } from "../../../storage/db/index.js";
+export interface ImpulseContextArtifactView {
+    id: string;
+    sceneType: string;
+    capabilityIntent: string | null;
+    platformId: string | null;
+    capabilityClass: string | null;
+    impulseSource: string;
+    impulseText: string | null;
+    atmosphereText: string | null;
+    expressionBoundaryConstraints: string[];
+    expressionBoundaryStyle: string | null;
+    freshnessVersion: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MissingArtifactReason {
+    available: false;
+    reason: "artifact_not_persisted" | "artifact_expired" | "state_unreadable" | "scene_capability_mismatch";
+    operatorNextAction: string;
+}
+export type ReadImpulseContextResult = {
+    available: true;
+    artifact: ImpulseContextArtifactView;
+    freshnessMs: number;
+} | MissingArtifactReason;
+export declare function readImpulseContext(db: StateDatabase, sceneType: string, capabilityIntent?: string, platformId?: string): Promise<ReadImpulseContextResult>;