@haaaiawd/second-nature 0.1.8 → 0.1.9

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

@@ -1,69 +1,135 @@
 import { buildContinuitySnapshot } from "./snapshot-builder.js";
-import { planIntent } from "../orchestrator/intent-planner.js";
-import { evaluateGuards } from "../orchestrator/guard-layer.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.
- *
- * Decision flow:
- * 1. Build continuity snapshot from state-system inputs
- * 2. Plan candidate intents from snapshot
- * 3. Evaluate guards for each candidate in priority order
- * 4. Return one of:
- *    - intent_selected: a candidate passed all guards
- *    - denied: candidates existed but all were rejected by guards
- *    - heartbeat_ok: no candidates or no action warranted (conservative default)
- *
- * 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.
  */
 export async function ingestRhythmSignal(signal, deps) {
-    // Step 1: Build continuity snapshot
     const inputs = await deps.loadSnapshotInputs();
     const snapshot = buildContinuitySnapshot(inputs);
-    // Step 2: Plan candidate intents
-    const candidates = planIntent(snapshot);
-    // Step 3: Evaluate guards for each candidate (priority order)
+    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 = evaluateGuards(intent, snapshot);
+        const evaluation = evaluateHardGuards(intent, runtime);
         if (evaluation.verdict === "allow") {
             anyAllow = true;
-            return {
+            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(",")})`);
     }
-    // Step 4: No viable intent path
     if (!hasCandidates) {
-        // No candidates at all → heartbeat_ok (nothing to do)
-        return {
+        const result = {
             scope: "rhythm",
             status: "heartbeat_ok",
-            reasons: ["no_candidates"],
+            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) {
-        // Candidates existed but all denied/deferred/escalated → denied
-        return {
+        const result = {
             scope: "rhythm",
             status: "denied",
             reasons: denyReasons,
         };
+        await emitTrace(result);
+        return result;
     }
-    // Fallback: conservative heartbeat_ok
-    return {
+    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).

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

@@ -1,5 +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, type HeartbeatDeps, buildSnapshotFromInputs, } from "./heartbeat-loop.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,4 +1,7 @@
 export { buildContinuitySnapshot, } from "./snapshot-builder.js";
-export { ingestRhythmSignal, buildSnapshotFromInputs, } from "./heartbeat-loop.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

@@ -0,0 +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>;

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

@@ -0,0 +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);
+}

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

@@ -0,0 +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;

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

@@ -0,0 +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 };
+}

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

@@ -7,7 +7,11 @@
  */
 export type RuntimeScope = "rhythm" | "user_task" | "user_reply";
 export type RuntimeTrigger = "heartbeat_bridge" | "user_task" | "user_reply" | "interrupt" | "resume";
-export type HeartbeatCycleStatus = "heartbeat_ok" | "intent_selected" | "deferred" | "denied";
+export type HeartbeatCycleStatus = "heartbeat_ok" | "intent_selected" | "deferred" | "denied"
+/** Delivery port returned failed / host dropped; operator fallback written (T2.3.2 / ADR-007). */
+ | "delivery_unavailable"
+/** Host-safe packaged carrier: no lived-experience loop (ADR-005 / control-plane L0). */
+ | "runtime_carrier_only";
 export interface HeartbeatSignal {
     trigger: RuntimeTrigger;
     scopeHint?: RuntimeScope;
@@ -23,10 +27,13 @@ export interface ScopedRuntimeInput {
     payload: Record<string, unknown>;
 }
 export interface HeartbeatCycleResult {
-    scope: "rhythm";
+    scope: RuntimeScope;
     status: HeartbeatCycleStatus;
     selectedIntentId?: string;
     reasons: string[];
+    decisionId?: string;
+    deliveryAttemptId?: string;
+    fallbackRef?: string;
 }
 export interface ScopeRouteResult {
     scope: RuntimeScope;

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

@@ -6,7 +6,10 @@
  *
  * Per design doc §4.2: SnapshotBuilder prepares inputs for the Rhythm Engine.
  */
-import type { ContinuitySnapshot, TopLevelMode } from "../types.js";
+import type { ContinuitySnapshot, ControlPlaneSourceRef, TopLevelMode } from "../types.js";
+import type { RhythmPolicy } from "../rhythm/rhythm-policy.js";
+import type { DeliveryCapabilitySnapshot } from "../outreach/delivery-target.js";
+import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
 export interface SnapshotInputs {
     mode: TopLevelMode;
     currentWindowId: string;
@@ -23,6 +26,21 @@ export interface SnapshotInputs {
     };
     awaitingUserInput?: boolean;
     riskSuppressed?: boolean;
+    /** Evidence refs for source-backed planner/guards (T2.1.3 / T2.2.1). */
+    lifeEvidenceRefs?: ControlPlaneSourceRef[];
+    platformEventCount?: number;
+    workEventCount?: number;
+    lifeEvidenceEmptyReason?: "no_sources" | "state_unavailable" | "redacted_only";
+    /** Optional explicit rhythm geometry; otherwise `quietEnabledBridge` drives policy-bridge default. */
+    rhythmPolicy?: RhythmPolicy;
+    /** Passed to `rhythmPolicySnapshotToRhythmPolicy` when `rhythmPolicy` is absent. */
+    quietEnabledBridge?: boolean;
+    duplicateIntentKeys?: string[];
+    outreachCooldownKeys?: string[];
+    /** When present, outreach judgment uses this delivery snapshot (ADR-007). */
+    deliveryCapability?: DeliveryCapabilitySnapshot;
+    /** When present, outreach judgment uses this user-interest read model (T4.2.2). */
+    userInterestSnapshot?: UserInterestSnapshot;
 }
 /**
  * Build a ContinuitySnapshot from loaded inputs.

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

@@ -1,8 +1,10 @@
 export * from "./types.js";
 export * from "./rhythm/rhythm-policy.js";
 export * from "./rhythm/select-window.js";
+export * from "./rhythm/policy-bridge.js";
 export * from "./orchestrator/intent-planner.js";
 export * from "./orchestrator/guard-layer.js";
+export * from "./heartbeat/runtime-snapshot.js";
 export * from "./orchestrator/lease-manager.js";
 export * from "./orchestrator/effect-dispatcher.js";
 export * from "./orchestrator/resume-from-checkpoint.js";
@@ -10,5 +12,11 @@ export * from "./quiet/quiet-pipeline.js";
 export * from "./reflection/run-narrative-reflection.js";
 export * from "./outreach/evaluate-outreach.js";
 export * from "./outreach/build-message.js";
+export * from "./outreach/delivery-target.js";
+export * from "./outreach/judge-outreach.js";
+export * from "./outreach/build-outreach-draft-request.js";
+export * from "./outreach/dispatch-user-outreach.js";
+export * from "./outreach/judge-input-from-snapshot.js";
+export * from "./quiet/run-source-backed-quiet.js";
 export * from "./guidance/request-guidance.js";
 export * from "./guidance/apply-guidance.js";

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

@@ -1,8 +1,10 @@
 export * from "./types.js";
 export * from "./rhythm/rhythm-policy.js";
 export * from "./rhythm/select-window.js";
+export * from "./rhythm/policy-bridge.js";
 export * from "./orchestrator/intent-planner.js";
 export * from "./orchestrator/guard-layer.js";
+export * from "./heartbeat/runtime-snapshot.js";
 export * from "./orchestrator/lease-manager.js";
 export * from "./orchestrator/effect-dispatcher.js";
 export * from "./orchestrator/resume-from-checkpoint.js";
@@ -10,5 +12,11 @@ export * from "./quiet/quiet-pipeline.js";
 export * from "./reflection/run-narrative-reflection.js";
 export * from "./outreach/evaluate-outreach.js";
 export * from "./outreach/build-message.js";
+export * from "./outreach/delivery-target.js";
+export * from "./outreach/judge-outreach.js";
+export * from "./outreach/build-outreach-draft-request.js";
+export * from "./outreach/dispatch-user-outreach.js";
+export * from "./outreach/judge-input-from-snapshot.js";
+export * from "./quiet/run-source-backed-quiet.js";
 export * from "./guidance/request-guidance.js";
 export * from "./guidance/apply-guidance.js";

package/runtime/core/second-nature/orchestrator/effect-dispatcher.d.ts

@@ -2,7 +2,7 @@ import type { ConnectorResult, CapabilityIntent } from "../../../connectors/base
 import { LeaseManager, type EffectClass } from "./lease-manager.js";
 export interface AllowedIntent {
     id: string;
-    kind: "work" | "exploration" | "social" | "reflection" | "outreach" | "maintenance";
+    kind: "work" | "exploration" | "social" | "quiet" | "reflection" | "outreach" | "maintenance";
     summary: string;
     effectClass: EffectClass;
     platformId?: string;

package/runtime/core/second-nature/orchestrator/effect-dispatcher.js

@@ -1,9 +1,12 @@
 import * as crypto from "crypto";
 function needsLease(effectClass) {
-    return effectClass === "external_platform_action" || effectClass === "user_outreach";
+    return effectClass === "external_platform_action" || effectClass === "connector_action" || effectClass === "user_outreach";
 }
 function needsCheckpoint(effectClass) {
-    return effectClass !== "maintenance";
+    return effectClass !== "maintenance" && effectClass !== "no_effect";
+}
+function isConnectorEffect(effectClass) {
+    return effectClass === "external_platform_action" || effectClass === "connector_action";
 }
 function toCapabilityIntent(intent) {
     if (intent.kind === "work")
@@ -14,6 +17,8 @@ function toCapabilityIntent(intent) {
         return "comment.reply";
     if (intent.kind === "outreach")
         return "message.send";
+    if (intent.kind === "quiet")
+        return "feed.read";
     return "feed.read";
 }
 export class EffectDispatcher {
@@ -43,7 +48,7 @@ export class EffectDispatcher {
                 id: decision.checkpointId,
                 tickId: decision.tickId,
                 intentId: decision.intentId,
-                phase: intent.effectClass === "external_platform_action" ? "before_effect" : "before_quiet_write",
+                phase: isConnectorEffect(intent.effectClass) ? "before_effect" : "before_quiet_write",
                 snapshotRef: decision.traceId,
             });
         }
@@ -54,7 +59,7 @@ export class EffectDispatcher {
             state: "planned",
         });
         try {
-            if (intent.effectClass === "external_platform_action") {
+            if (isConnectorEffect(intent.effectClass)) {
                 await this.commitPort.advanceIntentCommitState(commit.id, "dispatched");
                 const result = await this.connectorExecutor.executeEffect({
                     platformId: intent.platformId ?? "unknown",

package/runtime/core/second-nature/orchestrator/guard-layer.d.ts

@@ -1,2 +1,8 @@
 import type { CandidateIntent, ContinuitySnapshot, GuardEvaluation } from "../types.js";
+import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+/**
+ * Hard guard evaluation (T2.1.3): source, dedupe, cooldown, quiet bias, budget, risk, awaiting user.
+ */
+export declare function evaluateHardGuards(intent: CandidateIntent, runtime: HeartbeatRuntimeSnapshot): GuardEvaluation;
+/** Continuity-only guard path for legacy call sites; builds a minimal runtime snapshot. */
 export declare function evaluateGuards(intent: CandidateIntent, snapshot: ContinuitySnapshot): GuardEvaluation;

package/runtime/core/second-nature/orchestrator/guard-layer.js

@@ -1,9 +1,7 @@
-function stableIntentHash(intent) {
-    return `${intent.kind}:${intent.summary}`;
-}
-function isDuplicateIntent(intent, snapshot) {
-    const hash = stableIntentHash(intent);
-    return snapshot.deniedIntents.some((item) => item.intentHash === hash && item.reason === "duplicate_intent");
+import { buildHeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+const QUIET_DENY_KINDS = ["outreach", "social"];
+function intentFingerprint(intent) {
+    return intent.idempotencyKey ?? `${intent.kind}:${intent.summary}`;
 }
 function isBudgetExceeded(intent, snapshot) {
     if (intent.kind !== "social")
@@ -12,43 +10,101 @@ function isBudgetExceeded(intent, snapshot) {
         return false;
     return snapshot.budgets.socialUsed >= snapshot.budgets.socialLimit;
 }
-function isQuietSuppressed(intent, snapshot) {
-    if (snapshot.mode !== "quiet")
-        return false;
-    if (intent.effectClass === "maintenance" || intent.effectClass === "memory_curation" || intent.effectClass === "narrative_reflection") {
+function isQuietSuppressed(intent, runtime) {
+    if (!runtime.rhythmWindow.quietBias)
         return false;
+    if (QUIET_DENY_KINDS.includes(intent.kind)) {
+        return true;
+    }
+    if (intent.effectClass === "connector_action" || intent.effectClass === "external_platform_action") {
+        return true;
     }
-    return true;
+    return false;
 }
-export function evaluateGuards(intent, snapshot) {
+function isSourceBacked(intent) {
+    if (intent.sourceRefs.length > 0)
+        return true;
+    if (intent.effectClass === "maintenance" || intent.effectClass === "no_effect")
+        return true;
+    return false;
+}
+function isRiskBlocked(intent, snapshot) {
+    if (!snapshot.riskSuppressed)
+        return false;
+    return intent.kind === "exploration" || intent.kind === "social" || intent.kind === "outreach";
+}
+/**
+ * Hard guard evaluation (T2.1.3): source, dedupe, cooldown, quiet bias, budget, risk, awaiting user.
+ */
+export function evaluateHardGuards(intent, runtime) {
+    const snapshot = runtime.continuity;
     const reasons = [];
-    if (isDuplicateIntent(intent, snapshot)) {
+    if (!isSourceBacked(intent)) {
+        reasons.push("missing_source_refs");
+    }
+    const key = intentFingerprint(intent);
+    if (runtime.hardGuards.hasDuplicateIntent(key)) {
         reasons.push("duplicate_intent");
     }
+    if (intent.effectClass === "user_outreach" && !runtime.hardGuards.isOutreachCooldownClear(key)) {
+        reasons.push("outreach_cooldown");
+    }
+    if (isQuietSuppressed(intent, runtime)) {
+        reasons.push("quiet_window_suppression");
+    }
     if (isBudgetExceeded(intent, snapshot)) {
         reasons.push("budget_exceeded");
     }
-    if (isQuietSuppressed(intent, snapshot)) {
-        reasons.push("quiet_window");
-    }
     if (snapshot.awaitingUserInput) {
         reasons.push("awaiting_user");
     }
+    if (isRiskBlocked(intent, snapshot)) {
+        reasons.push("risk_suppressed");
+    }
     if (reasons.length === 0) {
         return {
             verdict: "allow",
-            reasons,
+            reasons: [],
             quietSuppressed: false,
-            leaseRequired: intent.effectClass === "external_platform_action" || intent.effectClass === "user_outreach",
-            requiresCheckpoint: intent.effectClass !== "maintenance",
+            leaseRequired: intent.effectClass === "external_platform_action" ||
+                intent.effectClass === "connector_action" ||
+                intent.effectClass === "user_outreach",
+            requiresCheckpoint: intent.effectClass !== "maintenance" && intent.effectClass !== "no_effect",
+        };
+    }
+    const duplicate = reasons.includes("duplicate_intent");
+    const cooldown = reasons.includes("outreach_cooldown");
+    if (duplicate || cooldown) {
+        return {
+            verdict: "defer",
+            reasons,
+            quietSuppressed: reasons.includes("quiet_window_suppression"),
+            leaseRequired: false,
+            requiresCheckpoint: false,
         };
     }
     const escalated = reasons.includes("awaiting_user") && intent.kind === "outreach";
     return {
         verdict: escalated ? "escalate" : "deny",
         reasons,
-        quietSuppressed: reasons.includes("quiet_window"),
+        quietSuppressed: reasons.includes("quiet_window_suppression"),
         leaseRequired: false,
         requiresCheckpoint: false,
     };
 }
+/** Continuity-only guard path for legacy call sites; builds a minimal runtime snapshot. */
+export function evaluateGuards(intent, snapshot) {
+    const inputs = {
+        mode: snapshot.mode,
+        currentWindowId: snapshot.currentWindowId,
+        pendingObligations: snapshot.pendingObligations,
+        recentOutreachHashes: snapshot.recentOutreachHashes,
+        deniedIntents: snapshot.deniedIntents,
+        budgets: snapshot.budgets,
+        awaitingUserInput: snapshot.awaitingUserInput,
+        riskSuppressed: snapshot.riskSuppressed,
+        quietEnabledBridge: snapshot.mode === "quiet",
+    };
+    const runtime = buildHeartbeatRuntimeSnapshot("2026-03-25T12:00:00.000Z", inputs, snapshot);
+    return evaluateHardGuards(intent, runtime);
+}

package/runtime/core/second-nature/orchestrator/intent-planner.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Candidate intent planner (T2.1.3): window-biased planning + priority cap.
+ * `planCandidateIntents` is the contract name; `planIntent` bridges legacy continuity-only tests.
+ */
 import type { CandidateIntent, ContinuitySnapshot, DecisionBasis } from "../types.js";
+import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
+/**
+ * Plan ordered candidates for one heartbeat turn using rhythm window + life evidence slice.
+ */
+export declare function planCandidateIntents(runtime: HeartbeatRuntimeSnapshot): CandidateIntent[];
+/** @deprecated Continuity-only helper for tests; prefer `planCandidateIntents` + `buildHeartbeatRuntimeSnapshot`. */
 export declare function planIntent(snapshot: ContinuitySnapshot): CandidateIntent[];
 export declare function decideDecisionBasis(intent: CandidateIntent): DecisionBasis;