@haaaiawd/second-nature 0.1.18 → 0.1.19

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

@@ -1,139 +1,162 @@
-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;
+    }
+    // T2.2.3 (CH-14-02/03 / CH-15-01): all intent_selected results must carry at least one
+    // machine-readable reason so operators can distinguish between effect classes:
+    //   - maintenance / no_effect → "internal_tick" (no external side-effects)
+    //   - connector_action without dispatch wired → "connector_dispatch_unwired"
+    //   - external_platform_action / memory_curation → not generated by intent-planner today;
+    //     if a future path produces them, they will reach the fallback [] branch below and
+    //     should have dedicated reason codes added (e.g. "external_platform_action_unwired").
+    //   - other (outreach / quiet) → caught by the early-return branches above
+    const noExternalEffect = intent.effectClass === "maintenance" ||
+        intent.effectClass === "no_effect" ||
+        intent.kind === "maintenance";
+    const connectorUnwired = intent.effectClass === "connector_action";
+    const reasons = noExternalEffect
+        ? ["internal_tick"]
+        : connectorUnwired
+            ? ["connector_dispatch_unwired"]
+            : [];
+    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";

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

@@ -1,7 +1,7 @@
-export { buildContinuitySnapshot, } from "./snapshot-builder.js";
-export { ingestRhythmSignal, resolveAllowedIntentResult, buildSnapshotFromInputs, } from "./heartbeat-loop.js";
-export { buildHeartbeatRuntimeSnapshot, buildLifeEvidenceSliceFromInputs, buildHardGuardDeps, resolveRhythmPolicyForHeartbeat, isLifeEvidenceSliceEmpty, } from "./runtime-snapshot.js";
-export { buildPlannerRhythmWindow } from "../rhythm/planner-rhythm-window.js";
-export { runHeartbeatCycle } from "./run-heartbeat-cycle.js";
-export { routeScopedInput, } from "./scope-router.js";
-export { requestGuidanceForIntent, dispatchAllowedEffect, executeHeartbeatCycle, } from "./heartbeat-executor.js";
+export { buildContinuitySnapshot, } from "./snapshot-builder.js";
+export { ingestRhythmSignal, resolveAllowedIntentResult, buildSnapshotFromInputs, } from "./heartbeat-loop.js";
+export { buildHeartbeatRuntimeSnapshot, buildLifeEvidenceSliceFromInputs, buildHardGuardDeps, resolveRhythmPolicyForHeartbeat, isLifeEvidenceSliceEmpty, } from "./runtime-snapshot.js";
+export { buildPlannerRhythmWindow } from "../rhythm/planner-rhythm-window.js";
+export { runHeartbeatCycle } from "./run-heartbeat-cycle.js";
+export { routeScopedInput, } from "./scope-router.js";
+export { requestGuidanceForIntent, dispatchAllowedEffect, executeHeartbeatCycle, } from "./heartbeat-executor.js";

package/runtime/core/second-nature/heartbeat/run-heartbeat-cycle.d.ts

@@ -1,21 +1,21 @@
-/**
- * Control-plane heartbeat cycle entry (T2.1.1).
- *
- * Core logic: runtime availability gate → scope routing (user_task bypasses rhythm) →
- * rhythm path delegates to ingestRhythmSignal. Mirrors L0 control-plane-system §4.3.
- *
- * Boundaries: does not claim lived-experience completion when runtime is unavailable;
- * user_task / user_reply do not enter the rhythm candidate planner.
- */
-import type { HeartbeatSignal, HeartbeatCycleResult } from "./signal.js";
-import type { HeartbeatDeps } from "./heartbeat-loop.js";
-export interface RunHeartbeatCycleInput {
-    signal: HeartbeatSignal;
-    /** When false, return runtime_carrier_only without loading snapshots (host-safe carrier). */
-    runtimeAvailable: boolean;
-    deps: HeartbeatDeps;
-}
-/**
- * Single entry for one heartbeat turn: scope routing, runtime gate, then rhythm loop if applicable.
- */
-export declare function runHeartbeatCycle(input: RunHeartbeatCycleInput): Promise<HeartbeatCycleResult>;
+/**
+ * Control-plane heartbeat cycle entry (T2.1.1).
+ *
+ * Core logic: runtime availability gate → scope routing (user_task bypasses rhythm) →
+ * rhythm path delegates to ingestRhythmSignal. Mirrors L0 control-plane-system §4.3.
+ *
+ * Boundaries: does not claim lived-experience completion when runtime is unavailable;
+ * user_task / user_reply do not enter the rhythm candidate planner.
+ */
+import type { HeartbeatSignal, HeartbeatCycleResult } from "./signal.js";
+import type { HeartbeatDeps } from "./heartbeat-loop.js";
+export interface RunHeartbeatCycleInput {
+    signal: HeartbeatSignal;
+    /** When false, return runtime_carrier_only without loading snapshots (host-safe carrier). */
+    runtimeAvailable: boolean;
+    deps: HeartbeatDeps;
+}
+/**
+ * Single entry for one heartbeat turn: scope routing, runtime gate, then rhythm loop if applicable.
+ */
+export declare function runHeartbeatCycle(input: RunHeartbeatCycleInput): Promise<HeartbeatCycleResult>;

package/runtime/core/second-nature/heartbeat/run-heartbeat-cycle.js

@@ -1,35 +1,35 @@
-import { ingestRhythmSignal } from "./heartbeat-loop.js";
-import { routeScopedInput } from "./scope-router.js";
-/**
- * Single entry for one heartbeat turn: scope routing, runtime gate, then rhythm loop if applicable.
- */
-export async function runHeartbeatCycle(input) {
-    const scoped = {
-        trigger: input.signal.trigger,
-        scopeHint: input.signal.scopeHint,
-        payload: input.signal.payload,
-    };
-    const route = routeScopedInput(scoped);
-    if (!input.runtimeAvailable) {
-        return {
-            scope: route.scope,
-            status: "runtime_carrier_only",
-            reasons: ["runtime_unavailable_no_lived_experience_loop"],
-        };
-    }
-    if (route.scope === "user_task") {
-        return {
-            scope: "user_task",
-            status: "heartbeat_ok",
-            reasons: ["rhythm_gate_bypass_user_task"],
-        };
-    }
-    if (route.scope === "user_reply") {
-        return {
-            scope: "user_reply",
-            status: "heartbeat_ok",
-            reasons: ["user_reply_light_continuity_skeleton"],
-        };
-    }
-    return ingestRhythmSignal(input.signal, input.deps);
-}
+import { ingestRhythmSignal } from "./heartbeat-loop.js";
+import { routeScopedInput } from "./scope-router.js";
+/**
+ * Single entry for one heartbeat turn: scope routing, runtime gate, then rhythm loop if applicable.
+ */
+export async function runHeartbeatCycle(input) {
+    const scoped = {
+        trigger: input.signal.trigger,
+        scopeHint: input.signal.scopeHint,
+        payload: input.signal.payload,
+    };
+    const route = routeScopedInput(scoped);
+    if (!input.runtimeAvailable) {
+        return {
+            scope: route.scope,
+            status: "runtime_carrier_only",
+            reasons: ["runtime_unavailable_no_lived_experience_loop"],
+        };
+    }
+    if (route.scope === "user_task") {
+        return {
+            scope: "user_task",
+            status: "heartbeat_ok",
+            reasons: ["rhythm_gate_bypass_user_task"],
+        };
+    }
+    if (route.scope === "user_reply") {
+        return {
+            scope: "user_reply",
+            status: "heartbeat_ok",
+            reasons: ["user_reply_light_continuity_skeleton"],
+        };
+    }
+    return ingestRhythmSignal(input.signal, input.deps);
+}

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

@@ -1,28 +1,28 @@
-/**
- * HeartbeatRuntimeSnapshot assembly for candidate planner + hard guards (T2.1.3, T2.2.1).
- */
-import type { ContinuitySnapshot, ControlPlaneSourceRef } from "../types.js";
-import type { RhythmPolicy } from "../rhythm/rhythm-policy.js";
-import { type PlannerRhythmWindowSlice } from "../rhythm/planner-rhythm-window.js";
-import type { SnapshotInputs } from "./snapshot-builder.js";
-export interface PlannerLifeEvidenceSlice {
-    evidenceRefs: ControlPlaneSourceRef[];
-    platformEventCount: number;
-    workEventCount: number;
-    emptyReason?: "no_sources" | "state_unavailable" | "redacted_only";
-}
-export declare function isLifeEvidenceSliceEmpty(slice: PlannerLifeEvidenceSlice): boolean;
-export interface HardGuardDeps {
-    hasDuplicateIntent: (idempotencyKey: string) => boolean;
-    isOutreachCooldownClear: (idempotencyKey: string) => boolean;
-}
-export interface HeartbeatRuntimeSnapshot {
-    continuity: ContinuitySnapshot;
-    lifeEvidence: PlannerLifeEvidenceSlice;
-    rhythmWindow: PlannerRhythmWindowSlice;
-    hardGuards: HardGuardDeps;
-}
-export declare function buildLifeEvidenceSliceFromInputs(inputs: SnapshotInputs): PlannerLifeEvidenceSlice;
-export declare function buildHardGuardDeps(continuity: ContinuitySnapshot, inputs: SnapshotInputs): HardGuardDeps;
-export declare function resolveRhythmPolicyForHeartbeat(inputs: SnapshotInputs): RhythmPolicy;
-export declare function buildHeartbeatRuntimeSnapshot(timestamp: string, inputs: SnapshotInputs, continuity: ContinuitySnapshot): HeartbeatRuntimeSnapshot;
+/**
+ * HeartbeatRuntimeSnapshot assembly for candidate planner + hard guards (T2.1.3, T2.2.1).
+ */
+import type { ContinuitySnapshot, ControlPlaneSourceRef } from "../types.js";
+import type { RhythmPolicy } from "../rhythm/rhythm-policy.js";
+import { type PlannerRhythmWindowSlice } from "../rhythm/planner-rhythm-window.js";
+import type { SnapshotInputs } from "./snapshot-builder.js";
+export interface PlannerLifeEvidenceSlice {
+    evidenceRefs: ControlPlaneSourceRef[];
+    platformEventCount: number;
+    workEventCount: number;
+    emptyReason?: "no_sources" | "state_unavailable" | "redacted_only";
+}
+export declare function isLifeEvidenceSliceEmpty(slice: PlannerLifeEvidenceSlice): boolean;
+export interface HardGuardDeps {
+    hasDuplicateIntent: (idempotencyKey: string) => boolean;
+    isOutreachCooldownClear: (idempotencyKey: string) => boolean;
+}
+export interface HeartbeatRuntimeSnapshot {
+    continuity: ContinuitySnapshot;
+    lifeEvidence: PlannerLifeEvidenceSlice;
+    rhythmWindow: PlannerRhythmWindowSlice;
+    hardGuards: HardGuardDeps;
+}
+export declare function buildLifeEvidenceSliceFromInputs(inputs: SnapshotInputs): PlannerLifeEvidenceSlice;
+export declare function buildHardGuardDeps(continuity: ContinuitySnapshot, inputs: SnapshotInputs): HardGuardDeps;
+export declare function resolveRhythmPolicyForHeartbeat(inputs: SnapshotInputs): RhythmPolicy;
+export declare function buildHeartbeatRuntimeSnapshot(timestamp: string, inputs: SnapshotInputs, continuity: ContinuitySnapshot): HeartbeatRuntimeSnapshot;

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

@@ -1,35 +1,35 @@
-import { rhythmPolicySnapshotToRhythmPolicy } from "../rhythm/policy-bridge.js";
-import { buildPlannerRhythmWindow } from "../rhythm/planner-rhythm-window.js";
-export function isLifeEvidenceSliceEmpty(slice) {
-    return slice.evidenceRefs.length === 0 && slice.platformEventCount === 0 && slice.workEventCount === 0;
-}
-export function buildLifeEvidenceSliceFromInputs(inputs) {
-    return {
-        evidenceRefs: inputs.lifeEvidenceRefs ?? [],
-        platformEventCount: inputs.platformEventCount ?? 0,
-        workEventCount: inputs.workEventCount ?? 0,
-        emptyReason: inputs.lifeEvidenceEmptyReason,
-    };
-}
-export function buildHardGuardDeps(continuity, inputs) {
-    return {
-        hasDuplicateIntent: (key) => (inputs.duplicateIntentKeys?.includes(key) ?? false) ||
-            continuity.deniedIntents.some((d) => d.reason === "duplicate_intent" && d.intentHash === key),
-        isOutreachCooldownClear: (key) => !(inputs.outreachCooldownKeys?.includes(key) ?? false),
-    };
-}
-export function resolveRhythmPolicyForHeartbeat(inputs) {
-    if (inputs.rhythmPolicy) {
-        return inputs.rhythmPolicy;
-    }
-    return rhythmPolicySnapshotToRhythmPolicy({
-        quietEnabled: inputs.quietEnabledBridge ?? false,
-    });
-}
-export function buildHeartbeatRuntimeSnapshot(timestamp, inputs, continuity) {
-    const policy = resolveRhythmPolicyForHeartbeat(inputs);
-    const rhythmWindow = buildPlannerRhythmWindow(timestamp, continuity, policy);
-    const lifeEvidence = buildLifeEvidenceSliceFromInputs(inputs);
-    const hardGuards = buildHardGuardDeps(continuity, inputs);
-    return { continuity, lifeEvidence, rhythmWindow, hardGuards };
-}
+import { rhythmPolicySnapshotToRhythmPolicy } from "../rhythm/policy-bridge.js";
+import { buildPlannerRhythmWindow } from "../rhythm/planner-rhythm-window.js";
+export function isLifeEvidenceSliceEmpty(slice) {
+    return slice.evidenceRefs.length === 0 && slice.platformEventCount === 0 && slice.workEventCount === 0;
+}
+export function buildLifeEvidenceSliceFromInputs(inputs) {
+    return {
+        evidenceRefs: inputs.lifeEvidenceRefs ?? [],
+        platformEventCount: inputs.platformEventCount ?? 0,
+        workEventCount: inputs.workEventCount ?? 0,
+        emptyReason: inputs.lifeEvidenceEmptyReason,
+    };
+}
+export function buildHardGuardDeps(continuity, inputs) {
+    return {
+        hasDuplicateIntent: (key) => (inputs.duplicateIntentKeys?.includes(key) ?? false) ||
+            continuity.deniedIntents.some((d) => d.reason === "duplicate_intent" && d.intentHash === key),
+        isOutreachCooldownClear: (key) => !(inputs.outreachCooldownKeys?.includes(key) ?? false),
+    };
+}
+export function resolveRhythmPolicyForHeartbeat(inputs) {
+    if (inputs.rhythmPolicy) {
+        return inputs.rhythmPolicy;
+    }
+    return rhythmPolicySnapshotToRhythmPolicy({
+        quietEnabled: inputs.quietEnabledBridge ?? false,
+    });
+}
+export function buildHeartbeatRuntimeSnapshot(timestamp, inputs, continuity) {
+    const policy = resolveRhythmPolicyForHeartbeat(inputs);
+    const rhythmWindow = buildPlannerRhythmWindow(timestamp, continuity, policy);
+    const lifeEvidence = buildLifeEvidenceSliceFromInputs(inputs);
+    const hardGuards = buildHardGuardDeps(continuity, inputs);
+    return { continuity, lifeEvidence, rhythmWindow, hardGuards };
+}