@haaaiawd/second-nature 0.1.16 → 0.1.18

package/runtime/core/second-nature/heartbeat/heartbeat-executor.js

@@ -1,114 +1,114 @@
-import { EffectDispatcher, buildDecisionContext } from "../orchestrator/effect-dispatcher.js";
-/**
- * Map an intent kind to its guidance scene type.
- * Only generative scenes (social, outreach, explain) request guidance.
- * Maintenance, reflection, and work do not request guidance.
- */
-function intentKindToScene(kind) {
-    switch (kind) {
-        case "social":
-            return "social";
-        case "outreach":
-            return "outreach";
-        case "exploration":
-            return "explain";
-        case "quiet":
-            return null;
-        default:
-            return null;
-    }
-}
-/**
- * Build a scene context from an allowed intent and runtime mode.
- *
- * Mode comes from the actual runtime context (active/quiet/maintenance_only/paused_for_interrupt),
- * not hardcoded.
- */
-function buildSceneContext(intent, mode) {
-    return {
-        sceneType: intentKindToScene(intent.kind) ?? "explain",
-        mode,
-        sceneSummary: intent.summary,
-    };
-}
-/**
- * Request guidance for a selected intent.
- *
- * Guidance is only requested when:
- * - The intent kind maps to a generative scene (social, outreach, explain)
- * - Maintenance, reflection, and work do not request guidance
- *
- * The guidance payload is used for context assembly within control-plane.
- * It does NOT cross the connector execution boundary.
- */
-export async function requestGuidanceForIntent(intent, mode, deps) {
-    const sceneType = intentKindToScene(intent.kind);
-    if (!sceneType) {
-        // Non-generative intents don't request guidance
-        return { intent };
-    }
-    const sceneContext = buildSceneContext(intent, mode);
-    const guidanceResult = await deps.requestGuidance({ sceneContext });
-    const appliedContext = deps.applyGuidance(guidanceResult.guidance);
-    return {
-        intent,
-        guidanceResult,
-        appliedContext,
-    };
-}
-/**
- * Dispatch effects for an allowed intent.
- *
- * This function enforces the allow-only boundary:
- * - Only called when guard verdict is "allow"
- * - Creates a decision context and dispatches through EffectDispatcher
- * - Guidance context stays within control-plane and is NOT passed to connector executor
- *
- * The connector executor receives the original intent payload without any
- * guidance-derived fields. Guidance participates in control-plane context
- * assembly but does not leak into the connector execution boundary.
- */
-export async function dispatchAllowedEffect(intent, deps) {
-    const dispatcher = new EffectDispatcher(deps.leaseManager, deps.commitPort, deps.connectorExecutor, deps.checkpointPort, deps.memoryPort, deps.reflectionPort);
-    const decisionContext = buildDecisionContext({
-        tickId: `tick:${Date.now()}`,
-        intentId: intent.id,
-    });
-    // Dispatch with the original intent payload.
-    // Guidance context (if any) remains within control-plane boundary
-    // and is NOT embedded in the connector payload.
-    return dispatcher.dispatchEffect(intent, decisionContext);
-}
-/**
- * Full heartbeat execution: guidance bridge + allow-only effect dispatch.
- *
- * Flow:
- * 1. Check guard verdict — non-allow paths skip guidance entirely
- * 2. For allow verdict: request guidance (if generative scene), then dispatch effect
- * 3. Return execution result with guidance and dispatch info
- *
- * Per T2.2.2 boundaries:
- * - Guidance is NOT requested for deny/defer verdicts
- * - Guidance payload does NOT cross into connector execution boundary
- * - External effects only occur under allow verdict
- */
-export async function executeHeartbeatCycle(intent, guardVerdict, mode, deps) {
-    // Non-allow verdicts: skip guidance entirely, no effect dispatch
-    if (guardVerdict !== "allow") {
-        return {
-            decisionId: `decision:${intent.id}:${Date.now()}`,
-            intentId: intent.id,
-            guardVerdict,
-        };
-    }
-    // Allow verdict: request guidance for generative scenes, then dispatch
-    const guidance = await requestGuidanceForIntent(intent, mode, deps.guidance);
-    const dispatch = await dispatchAllowedEffect(intent, deps.effects);
-    return {
-        decisionId: `decision:${intent.id}:${Date.now()}`,
-        intentId: intent.id,
-        guardVerdict,
-        guidance,
-        dispatch,
-    };
-}
+import { EffectDispatcher, buildDecisionContext } from "../orchestrator/effect-dispatcher.js";
+/**
+ * Map an intent kind to its guidance scene type.
+ * Only generative scenes (social, outreach, explain) request guidance.
+ * Maintenance, reflection, and work do not request guidance.
+ */
+function intentKindToScene(kind) {
+    switch (kind) {
+        case "social":
+            return "social";
+        case "outreach":
+            return "outreach";
+        case "exploration":
+            return "explain";
+        case "quiet":
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Build a scene context from an allowed intent and runtime mode.
+ *
+ * Mode comes from the actual runtime context (active/quiet/maintenance_only/paused_for_interrupt),
+ * not hardcoded.
+ */
+function buildSceneContext(intent, mode) {
+    return {
+        sceneType: intentKindToScene(intent.kind) ?? "explain",
+        mode,
+        sceneSummary: intent.summary,
+    };
+}
+/**
+ * Request guidance for a selected intent.
+ *
+ * Guidance is only requested when:
+ * - The intent kind maps to a generative scene (social, outreach, explain)
+ * - Maintenance, reflection, and work do not request guidance
+ *
+ * The guidance payload is used for context assembly within control-plane.
+ * It does NOT cross the connector execution boundary.
+ */
+export async function requestGuidanceForIntent(intent, mode, deps) {
+    const sceneType = intentKindToScene(intent.kind);
+    if (!sceneType) {
+        // Non-generative intents don't request guidance
+        return { intent };
+    }
+    const sceneContext = buildSceneContext(intent, mode);
+    const guidanceResult = await deps.requestGuidance({ sceneContext });
+    const appliedContext = deps.applyGuidance(guidanceResult.guidance);
+    return {
+        intent,
+        guidanceResult,
+        appliedContext,
+    };
+}
+/**
+ * Dispatch effects for an allowed intent.
+ *
+ * This function enforces the allow-only boundary:
+ * - Only called when guard verdict is "allow"
+ * - Creates a decision context and dispatches through EffectDispatcher
+ * - Guidance context stays within control-plane and is NOT passed to connector executor
+ *
+ * The connector executor receives the original intent payload without any
+ * guidance-derived fields. Guidance participates in control-plane context
+ * assembly but does not leak into the connector execution boundary.
+ */
+export async function dispatchAllowedEffect(intent, deps) {
+    const dispatcher = new EffectDispatcher(deps.leaseManager, deps.commitPort, deps.connectorExecutor, deps.checkpointPort, deps.memoryPort, deps.reflectionPort);
+    const decisionContext = buildDecisionContext({
+        tickId: `tick:${Date.now()}`,
+        intentId: intent.id,
+    });
+    // Dispatch with the original intent payload.
+    // Guidance context (if any) remains within control-plane boundary
+    // and is NOT embedded in the connector payload.
+    return dispatcher.dispatchEffect(intent, decisionContext);
+}
+/**
+ * Full heartbeat execution: guidance bridge + allow-only effect dispatch.
+ *
+ * Flow:
+ * 1. Check guard verdict — non-allow paths skip guidance entirely
+ * 2. For allow verdict: request guidance (if generative scene), then dispatch effect
+ * 3. Return execution result with guidance and dispatch info
+ *
+ * Per T2.2.2 boundaries:
+ * - Guidance is NOT requested for deny/defer verdicts
+ * - Guidance payload does NOT cross into connector execution boundary
+ * - External effects only occur under allow verdict
+ */
+export async function executeHeartbeatCycle(intent, guardVerdict, mode, deps) {
+    // Non-allow verdicts: skip guidance entirely, no effect dispatch
+    if (guardVerdict !== "allow") {
+        return {
+            decisionId: `decision:${intent.id}:${Date.now()}`,
+            intentId: intent.id,
+            guardVerdict,
+        };
+    }
+    // Allow verdict: request guidance for generative scenes, then dispatch
+    const guidance = await requestGuidanceForIntent(intent, mode, deps.guidance);
+    const dispatch = await dispatchAllowedEffect(intent, deps.effects);
+    return {
+        decisionId: `decision:${intent.id}:${Date.now()}`,
+        intentId: intent.id,
+        guardVerdict,
+        guidance,
+        dispatch,
+    };
+}

package/runtime/core/second-nature/heartbeat/heartbeat-loop.d.ts

@@ -1,63 +1,63 @@
-/**
- * Heartbeat Decision Loop
- *
- * Main entry point for the heartbeat runtime. Accepts a HeartbeatSignal,
- * builds runtime snapshot, plans candidate intents, evaluates hard guards,
- * and returns a HeartbeatCycleResult.
- *
- * Per design doc §4.3: heartbeat round follows the sequence:
- * signal → snapshot → plan → guard → result (HEARTBEAT_OK or intent_selected)
- *
- * Per ADR-005: heartbeat is the free-rhythm main entry; this loop
- * implements the default conservative path where HEARTBEAT_OK is
- * the first-class result when no action is warranted.
- */
-import type { HeartbeatSignal, HeartbeatCycleResult, HeartbeatCycleStatus, RuntimeScope, RuntimeTrigger } from "./signal.js";
-import type { CandidateIntent, ContinuitySnapshot, IntentKind } from "../types.js";
-import { type SnapshotInputs } from "./snapshot-builder.js";
-import { type HeartbeatRuntimeSnapshot } from "./runtime-snapshot.js";
-import type { GuidanceDraftPort } from "../../../guidance/outreach-draft-schema.js";
-import type { StateDatabase } from "../../../storage/db/index.js";
-import { type OpenClawDeliveryPort } from "../outreach/dispatch-user-outreach.js";
-export interface HeartbeatDecisionTracePayload {
-    scope: RuntimeScope;
-    status: HeartbeatCycleStatus;
-    reasons: string[];
-    selectedIntentId?: string;
-    rhythmWindowId: string;
-    allowedIntentKinds: IntentKind[];
-    candidateCount: number;
-    lifeEvidenceEmpty: boolean;
-    trigger: RuntimeTrigger;
-}
-/** Optional outreach delivery chain: when set, first allowed `user_outreach` runs dispatch (CR-M1). */
-export interface HeartbeatOutreachDispatchDeps {
-    state: StateDatabase;
-    guidance: GuidanceDraftPort;
-    delivery: OpenClawDeliveryPort;
-}
-/** Optional Quiet orchestration: when set, quiet/reflection allows run source-backed Quiet writer (T2.3.3). */
-export interface HeartbeatQuietWorkflowDeps {
-    workspaceRoot: string;
-}
-/**
- * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
- * Exported for unit tests (CR-M1 wiring).
- */
-export declare function resolveAllowedIntentResult(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs, signal: HeartbeatSignal, deps: Pick<HeartbeatDeps, "outreachDispatch" | "quietWorkflow">): Promise<HeartbeatCycleResult>;
-export interface HeartbeatDeps {
-    /** Load snapshot inputs from state-system */
-    loadSnapshotInputs: () => Promise<SnapshotInputs>;
-    /** Optional observability hook (T2.2.1): one record per completed cycle. */
-    recordDecisionTrace?: (payload: HeartbeatDecisionTracePayload) => Promise<void>;
-    outreachDispatch?: HeartbeatOutreachDispatchDeps;
-    quietWorkflow?: HeartbeatQuietWorkflowDeps;
-}
-/**
- * Ingest a heartbeat rhythm signal and drive one full decision round.
- */
-export declare function ingestRhythmSignal(signal: HeartbeatSignal, deps: HeartbeatDeps): Promise<HeartbeatCycleResult>;
-/**
- * Build a snapshot directly from inputs (for testing or when state-system is unavailable).
- */
-export declare function buildSnapshotFromInputs(inputs: SnapshotInputs): ContinuitySnapshot;
+/**
+ * Heartbeat Decision Loop
+ *
+ * Main entry point for the heartbeat runtime. Accepts a HeartbeatSignal,
+ * builds runtime snapshot, plans candidate intents, evaluates hard guards,
+ * and returns a HeartbeatCycleResult.
+ *
+ * Per design doc §4.3: heartbeat round follows the sequence:
+ * signal → snapshot → plan → guard → result (HEARTBEAT_OK or intent_selected)
+ *
+ * Per ADR-005: heartbeat is the free-rhythm main entry; this loop
+ * implements the default conservative path where HEARTBEAT_OK is
+ * the first-class result when no action is warranted.
+ */
+import type { HeartbeatSignal, HeartbeatCycleResult, HeartbeatCycleStatus, RuntimeScope, RuntimeTrigger } from "./signal.js";
+import type { CandidateIntent, ContinuitySnapshot, IntentKind } from "../types.js";
+import { type SnapshotInputs } from "./snapshot-builder.js";
+import { type HeartbeatRuntimeSnapshot } from "./runtime-snapshot.js";
+import type { GuidanceDraftPort } from "../../../guidance/outreach-draft-schema.js";
+import type { StateDatabase } from "../../../storage/db/index.js";
+import { type OpenClawDeliveryPort } from "../outreach/dispatch-user-outreach.js";
+export interface HeartbeatDecisionTracePayload {
+    scope: RuntimeScope;
+    status: HeartbeatCycleStatus;
+    reasons: string[];
+    selectedIntentId?: string;
+    rhythmWindowId: string;
+    allowedIntentKinds: IntentKind[];
+    candidateCount: number;
+    lifeEvidenceEmpty: boolean;
+    trigger: RuntimeTrigger;
+}
+/** Optional outreach delivery chain: when set, first allowed `user_outreach` runs dispatch (CR-M1). */
+export interface HeartbeatOutreachDispatchDeps {
+    state: StateDatabase;
+    guidance: GuidanceDraftPort;
+    delivery: OpenClawDeliveryPort;
+}
+/** Optional Quiet orchestration: when set, quiet/reflection allows run source-backed Quiet writer (T2.3.3). */
+export interface HeartbeatQuietWorkflowDeps {
+    workspaceRoot: string;
+}
+/**
+ * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
+ * Exported for unit tests (CR-M1 wiring).
+ */
+export declare function resolveAllowedIntentResult(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot, inputs: SnapshotInputs, signal: HeartbeatSignal, deps: Pick<HeartbeatDeps, "outreachDispatch" | "quietWorkflow">): Promise<HeartbeatCycleResult>;
+export interface HeartbeatDeps {
+    /** Load snapshot inputs from state-system */
+    loadSnapshotInputs: () => Promise<SnapshotInputs>;
+    /** Optional observability hook (T2.2.1): one record per completed cycle. */
+    recordDecisionTrace?: (payload: HeartbeatDecisionTracePayload) => Promise<void>;
+    outreachDispatch?: HeartbeatOutreachDispatchDeps;
+    quietWorkflow?: HeartbeatQuietWorkflowDeps;
+}
+/**
+ * Ingest a heartbeat rhythm signal and drive one full decision round.
+ */
+export declare function ingestRhythmSignal(signal: HeartbeatSignal, deps: HeartbeatDeps): Promise<HeartbeatCycleResult>;
+/**
+ * Build a snapshot directly from inputs (for testing or when state-system is unavailable).
+ */
+export declare function buildSnapshotFromInputs(inputs: SnapshotInputs): ContinuitySnapshot;

package/runtime/core/second-nature/heartbeat/heartbeat-loop.js

@@ -1,139 +1,139 @@
-import { buildContinuitySnapshot } from "./snapshot-builder.js";
-import { buildHeartbeatRuntimeSnapshot } from "./runtime-snapshot.js";
-import { planCandidateIntents } from "../orchestrator/intent-planner.js";
-import { evaluateHardGuards } from "../orchestrator/guard-layer.js";
-import { dispatchUserOutreachIntent } from "../outreach/dispatch-user-outreach.js";
-import { buildJudgeOutreachInputFromSnapshot } from "../outreach/judge-input-from-snapshot.js";
-import { runSourceBackedQuiet } from "../quiet/run-source-backed-quiet.js";
-/**
- * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
- * Exported for unit tests (CR-M1 wiring).
- */
-export async function resolveAllowedIntentResult(intent, runtime, inputs, signal, deps) {
-    const day = typeof signal.payload.timestamp === "string" ? signal.payload.timestamp.slice(0, 10) : "1970-01-01";
-    if (intent.effectClass === "user_outreach" && deps.outreachDispatch) {
-        return dispatchUserOutreachIntent({
-            candidate: intent,
-            snapshot: runtime,
-            judgeInput: buildJudgeOutreachInputFromSnapshot(intent, runtime, inputs),
-            guidance: deps.outreachDispatch.guidance,
-            delivery: deps.outreachDispatch.delivery,
-            state: deps.outreachDispatch.state,
-        });
-    }
-    if (deps.quietWorkflow &&
-        (intent.kind === "quiet" || (intent.kind === "reflection" && intent.effectClass === "narrative_reflection"))) {
-        const quietRun = await runSourceBackedQuiet({
-            candidate: intent,
-            runtime,
-            day,
-            userInterestSnapshot: inputs.userInterestSnapshot,
-            workspaceRoot: deps.quietWorkflow.workspaceRoot,
-        });
-        return quietRun.result;
-    }
-    return {
-        scope: "rhythm",
-        status: "intent_selected",
-        selectedIntentId: intent.id,
-        reasons: [],
-    };
-}
-/**
- * Ingest a heartbeat rhythm signal and drive one full decision round.
- */
-export async function ingestRhythmSignal(signal, deps) {
-    const inputs = await deps.loadSnapshotInputs();
-    const snapshot = buildContinuitySnapshot(inputs);
-    const timestamp = signal.payload.timestamp;
-    const runtime = buildHeartbeatRuntimeSnapshot(timestamp, inputs, snapshot);
-    const candidates = planCandidateIntents(runtime);
-    const emitTrace = async (result) => {
-        if (!deps.recordDecisionTrace)
-            return;
-        await deps.recordDecisionTrace({
-            scope: result.scope,
-            status: result.status,
-            reasons: result.reasons,
-            selectedIntentId: result.selectedIntentId,
-            rhythmWindowId: runtime.rhythmWindow.windowId,
-            allowedIntentKinds: [...runtime.rhythmWindow.allowedIntentKinds],
-            candidateCount: candidates.length,
-            lifeEvidenceEmpty: runtime.lifeEvidence.evidenceRefs.length === 0 &&
-                runtime.lifeEvidence.platformEventCount === 0 &&
-                runtime.lifeEvidence.workEventCount === 0,
-            trigger: signal.trigger,
-        });
-    };
-    let hasCandidates = false;
-    let anyAllow = false;
-    let anyDefer = false;
-    let anyDeny = false;
-    const denyReasons = [];
-    for (const intent of candidates) {
-        hasCandidates = true;
-        const evaluation = evaluateHardGuards(intent, runtime);
-        if (evaluation.verdict === "allow") {
-            anyAllow = true;
-            const base = {
-                scope: "rhythm",
-                status: "intent_selected",
-                selectedIntentId: intent.id,
-                reasons: evaluation.reasons,
-            };
-            const resolved = await resolveAllowedIntentResult(intent, runtime, inputs, signal, deps);
-            const result = resolved.status === "intent_selected" && resolved.reasons.length === 0 && evaluation.reasons.length > 0
-                ? { ...resolved, reasons: evaluation.reasons }
-                : resolved;
-            await emitTrace(result);
-            return result;
-        }
-        if (evaluation.verdict === "defer") {
-            anyDefer = true;
-            denyReasons.push(`${intent.id}:${evaluation.verdict}(${evaluation.reasons.join(",")})`);
-            continue;
-        }
-        anyDeny = true;
-        denyReasons.push(`${intent.id}:${evaluation.verdict}(${evaluation.reasons.join(",")})`);
-    }
-    if (!hasCandidates) {
-        const result = {
-            scope: "rhythm",
-            status: "heartbeat_ok",
-            reasons: ["silent_no_candidates"],
-        };
-        await emitTrace(result);
-        return result;
-    }
-    if (!anyAllow && anyDefer && !anyDeny) {
-        const result = {
-            scope: "rhythm",
-            status: "deferred",
-            reasons: denyReasons.length > 0 ? denyReasons : ["all_candidates_deferred"],
-        };
-        await emitTrace(result);
-        return result;
-    }
-    if (!anyAllow && denyReasons.length > 0) {
-        const result = {
-            scope: "rhythm",
-            status: "denied",
-            reasons: denyReasons,
-        };
-        await emitTrace(result);
-        return result;
-    }
-    const result = {
-        scope: "rhythm",
-        status: "heartbeat_ok",
-        reasons: ["no_allow_verdict"],
-    };
-    await emitTrace(result);
-    return result;
-}
-/**
- * Build a snapshot directly from inputs (for testing or when state-system is unavailable).
- */
-export function buildSnapshotFromInputs(inputs) {
-    return buildContinuitySnapshot(inputs);
-}
+import { buildContinuitySnapshot } from "./snapshot-builder.js";
+import { buildHeartbeatRuntimeSnapshot } from "./runtime-snapshot.js";
+import { planCandidateIntents } from "../orchestrator/intent-planner.js";
+import { evaluateHardGuards } from "../orchestrator/guard-layer.js";
+import { dispatchUserOutreachIntent } from "../outreach/dispatch-user-outreach.js";
+import { buildJudgeOutreachInputFromSnapshot } from "../outreach/judge-input-from-snapshot.js";
+import { runSourceBackedQuiet } from "../quiet/run-source-backed-quiet.js";
+/**
+ * Resolves the heartbeat outcome for a guard-allowed intent (outreach dispatch, quiet orchestration, or default).
+ * Exported for unit tests (CR-M1 wiring).
+ */
+export async function resolveAllowedIntentResult(intent, runtime, inputs, signal, deps) {
+    const day = typeof signal.payload.timestamp === "string" ? signal.payload.timestamp.slice(0, 10) : "1970-01-01";
+    if (intent.effectClass === "user_outreach" && deps.outreachDispatch) {
+        return dispatchUserOutreachIntent({
+            candidate: intent,
+            snapshot: runtime,
+            judgeInput: buildJudgeOutreachInputFromSnapshot(intent, runtime, inputs),
+            guidance: deps.outreachDispatch.guidance,
+            delivery: deps.outreachDispatch.delivery,
+            state: deps.outreachDispatch.state,
+        });
+    }
+    if (deps.quietWorkflow &&
+        (intent.kind === "quiet" || (intent.kind === "reflection" && intent.effectClass === "narrative_reflection"))) {
+        const quietRun = await runSourceBackedQuiet({
+            candidate: intent,
+            runtime,
+            day,
+            userInterestSnapshot: inputs.userInterestSnapshot,
+            workspaceRoot: deps.quietWorkflow.workspaceRoot,
+        });
+        return quietRun.result;
+    }
+    return {
+        scope: "rhythm",
+        status: "intent_selected",
+        selectedIntentId: intent.id,
+        reasons: [],
+    };
+}
+/**
+ * Ingest a heartbeat rhythm signal and drive one full decision round.
+ */
+export async function ingestRhythmSignal(signal, deps) {
+    const inputs = await deps.loadSnapshotInputs();
+    const snapshot = buildContinuitySnapshot(inputs);
+    const timestamp = signal.payload.timestamp;
+    const runtime = buildHeartbeatRuntimeSnapshot(timestamp, inputs, snapshot);
+    const candidates = planCandidateIntents(runtime);
+    const emitTrace = async (result) => {
+        if (!deps.recordDecisionTrace)
+            return;
+        await deps.recordDecisionTrace({
+            scope: result.scope,
+            status: result.status,
+            reasons: result.reasons,
+            selectedIntentId: result.selectedIntentId,
+            rhythmWindowId: runtime.rhythmWindow.windowId,
+            allowedIntentKinds: [...runtime.rhythmWindow.allowedIntentKinds],
+            candidateCount: candidates.length,
+            lifeEvidenceEmpty: runtime.lifeEvidence.evidenceRefs.length === 0 &&
+                runtime.lifeEvidence.platformEventCount === 0 &&
+                runtime.lifeEvidence.workEventCount === 0,
+            trigger: signal.trigger,
+        });
+    };
+    let hasCandidates = false;
+    let anyAllow = false;
+    let anyDefer = false;
+    let anyDeny = false;
+    const denyReasons = [];
+    for (const intent of candidates) {
+        hasCandidates = true;
+        const evaluation = evaluateHardGuards(intent, runtime);
+        if (evaluation.verdict === "allow") {
+            anyAllow = true;
+            const base = {
+                scope: "rhythm",
+                status: "intent_selected",
+                selectedIntentId: intent.id,
+                reasons: evaluation.reasons,
+            };
+            const resolved = await resolveAllowedIntentResult(intent, runtime, inputs, signal, deps);
+            const result = resolved.status === "intent_selected" && resolved.reasons.length === 0 && evaluation.reasons.length > 0
+                ? { ...resolved, reasons: evaluation.reasons }
+                : resolved;
+            await emitTrace(result);
+            return result;
+        }
+        if (evaluation.verdict === "defer") {
+            anyDefer = true;
+            denyReasons.push(`${intent.id}:${evaluation.verdict}(${evaluation.reasons.join(",")})`);
+            continue;
+        }
+        anyDeny = true;
+        denyReasons.push(`${intent.id}:${evaluation.verdict}(${evaluation.reasons.join(",")})`);
+    }
+    if (!hasCandidates) {
+        const result = {
+            scope: "rhythm",
+            status: "heartbeat_ok",
+            reasons: ["silent_no_candidates"],
+        };
+        await emitTrace(result);
+        return result;
+    }
+    if (!anyAllow && anyDefer && !anyDeny) {
+        const result = {
+            scope: "rhythm",
+            status: "deferred",
+            reasons: denyReasons.length > 0 ? denyReasons : ["all_candidates_deferred"],
+        };
+        await emitTrace(result);
+        return result;
+    }
+    if (!anyAllow && denyReasons.length > 0) {
+        const result = {
+            scope: "rhythm",
+            status: "denied",
+            reasons: denyReasons,
+        };
+        await emitTrace(result);
+        return result;
+    }
+    const result = {
+        scope: "rhythm",
+        status: "heartbeat_ok",
+        reasons: ["no_allow_verdict"],
+    };
+    await emitTrace(result);
+    return result;
+}
+/**
+ * Build a snapshot directly from inputs (for testing or when state-system is unavailable).
+ */
+export function buildSnapshotFromInputs(inputs) {
+    return buildContinuitySnapshot(inputs);
+}

package/runtime/core/second-nature/heartbeat/index.d.ts

@@ -1,8 +1,8 @@
-export { type RuntimeScope, type RuntimeTrigger, type HeartbeatCycleStatus, type HeartbeatSignal, type ScopedRuntimeInput, type HeartbeatCycleResult, type ScopeRouteResult, } from "./signal.js";
-export { buildContinuitySnapshot, type SnapshotInputs, } from "./snapshot-builder.js";
-export { ingestRhythmSignal, resolveAllowedIntentResult, type HeartbeatDeps, type HeartbeatOutreachDispatchDeps, type HeartbeatQuietWorkflowDeps, type HeartbeatDecisionTracePayload, buildSnapshotFromInputs, } from "./heartbeat-loop.js";
-export { buildHeartbeatRuntimeSnapshot, buildLifeEvidenceSliceFromInputs, buildHardGuardDeps, resolveRhythmPolicyForHeartbeat, isLifeEvidenceSliceEmpty, type HeartbeatRuntimeSnapshot, type PlannerLifeEvidenceSlice, type HardGuardDeps, } from "./runtime-snapshot.js";
-export { buildPlannerRhythmWindow, type PlannerRhythmWindowSlice } from "../rhythm/planner-rhythm-window.js";
-export { runHeartbeatCycle, type RunHeartbeatCycleInput } from "./run-heartbeat-cycle.js";
-export { routeScopedInput, type ScopeRouterDeps, } from "./scope-router.js";
-export { requestGuidanceForIntent, dispatchAllowedEffect, executeHeartbeatCycle, type GuidanceBridgeDeps, type EffectDispatchDeps, type HeartbeatExecutorDeps, type GuidanceBridgeResult, type HeartbeatExecutionResult, } from "./heartbeat-executor.js";
+export { type RuntimeScope, type RuntimeTrigger, type HeartbeatCycleStatus, type HeartbeatSignal, type ScopedRuntimeInput, type HeartbeatCycleResult, type ScopeRouteResult, } from "./signal.js";
+export { buildContinuitySnapshot, type SnapshotInputs, } from "./snapshot-builder.js";
+export { ingestRhythmSignal, resolveAllowedIntentResult, type HeartbeatDeps, type HeartbeatOutreachDispatchDeps, type HeartbeatQuietWorkflowDeps, type HeartbeatDecisionTracePayload, buildSnapshotFromInputs, } from "./heartbeat-loop.js";
+export { buildHeartbeatRuntimeSnapshot, buildLifeEvidenceSliceFromInputs, buildHardGuardDeps, resolveRhythmPolicyForHeartbeat, isLifeEvidenceSliceEmpty, type HeartbeatRuntimeSnapshot, type PlannerLifeEvidenceSlice, type HardGuardDeps, } from "./runtime-snapshot.js";
+export { buildPlannerRhythmWindow, type PlannerRhythmWindowSlice } from "../rhythm/planner-rhythm-window.js";
+export { runHeartbeatCycle, type RunHeartbeatCycleInput } from "./run-heartbeat-cycle.js";
+export { routeScopedInput, type ScopeRouterDeps, } from "./scope-router.js";
+export { requestGuidanceForIntent, dispatchAllowedEffect, executeHeartbeatCycle, type GuidanceBridgeDeps, type EffectDispatchDeps, type HeartbeatExecutorDeps, type GuidanceBridgeResult, type HeartbeatExecutionResult, } from "./heartbeat-executor.js";