@haaaiawd/second-nature 0.1.8 → 0.1.10

package/runtime/connectors/base/map-life-evidence.js

@@ -0,0 +1,79 @@
+function extractSourceRefs(platformId, data, observedAt) {
+    if (data && typeof data === "object") {
+        const record = data;
+        if (Array.isArray(record.sourceRefs)) {
+            const out = [];
+            for (const item of record.sourceRefs) {
+                if (item && typeof item === "object" && "uri" in item && "id" in item) {
+                    const ref = item;
+                    out.push({
+                        id: String(ref.id),
+                        kind: ref.kind ?? "platform_item",
+                        uri: String(ref.uri),
+                        excerptHash: ref.excerptHash !== undefined ? String(ref.excerptHash) : undefined,
+                        observedAt: ref.observedAt !== undefined ? String(ref.observedAt) : observedAt,
+                    });
+                }
+            }
+            if (out.length > 0)
+                return out;
+        }
+        if (Array.isArray(record.items)) {
+            return record.items.map((item, index) => {
+                const id = item && typeof item === "object" && "id" in item
+                    ? String(item.id)
+                    : `${platformId}-item-${index}`;
+                return {
+                    id,
+                    kind: "platform_item",
+                    uri: `platform://${platformId}/item/${encodeURIComponent(id)}`,
+                    observedAt,
+                };
+            });
+        }
+    }
+    return [];
+}
+function resolveEvidenceType(intent) {
+    if (intent === "feed.read")
+        return "platform_browse";
+    if (intent === "work.discover")
+        return "task_discovery";
+    return null;
+}
+function resolveSensitivity(intent, explicit) {
+    if (explicit)
+        return explicit;
+    if (intent === "message.send" || intent === "comment.reply")
+        return "private";
+    return "public";
+}
+/**
+ * Produce a single life-evidence candidate from a connector outcome, or null if not mappable.
+ */
+export function mapLifeEvidence(input) {
+    if (input.result.status !== "success") {
+        return null;
+    }
+    if (input.intent === "message.send") {
+        return null;
+    }
+    const evidenceType = resolveEvidenceType(input.intent);
+    if (!evidenceType) {
+        return null;
+    }
+    const observedAt = input.observedAt ?? new Date().toISOString();
+    const refs = extractSourceRefs(input.platformId, input.result.data, observedAt);
+    if (refs.length === 0) {
+        return null;
+    }
+    return {
+        timestamp: observedAt,
+        evidenceType,
+        platformId: input.platformId,
+        summary: `${input.platformId}:${input.intent}`,
+        sourceRefs: refs,
+        sensitivity: resolveSensitivity(input.intent, input.sensitivityOverride),
+        producer: "connector-system",
+    };
+}

package/runtime/connectors/base/policy-layer.d.ts

@@ -1,4 +1,5 @@
 import { type FailureClass } from "./failure-taxonomy.js";
+import { type EffectCommitLedgerPort } from "./execution-policy.js";
 import type { CapabilityIntent, ConnectorRequest, ConnectorResult, ExecutionPlan, ExecutionRunner, RoutePlanner } from "./contract.js";
 import type { ExecutionTelemetry } from "../../observability/services/execution-telemetry.js";
 export interface RetryPolicy {
@@ -21,6 +22,7 @@ export interface ConnectorPolicyContext {
     cooldownPort?: CooldownPort;
     retryPolicy?: Partial<RetryPolicy>;
     allowDegradedFallback?: (plan: ExecutionPlan, request: ConnectorRequest) => boolean;
+    effectCommitLedger?: EffectCommitLedgerPort;
 }
 export declare function createConnectorPolicyLayer(ctx: ConnectorPolicyContext): {
     executeWithPolicy(intent: CapabilityIntent, request: ConnectorRequest): Promise<ConnectorResult<unknown>>;

package/runtime/connectors/base/policy-layer.js

@@ -1,4 +1,5 @@
 import { classifyFailure } from "./failure-taxonomy.js";
+import { enforceExecutionPolicy } from "./execution-policy.js";
 const DEFAULT_RETRY_MAX = 3;
 const DEFAULT_BASE_DELAY_MS = 1000;
 const DEFAULT_MAX_DELAY_MS = 30000;
@@ -106,6 +107,21 @@ export function createConnectorPolicyLayer(ctx) {
                     },
                 };
             }
+            const policyGate = await enforceExecutionPolicy(plan, intent, request, {
+                effectCommitLedger: ctx.effectCommitLedger,
+            });
+            if (policyGate.skipAdapter && policyGate.existingOutcomeRef) {
+                return {
+                    status: "success",
+                    data: { replayedCommit: true, outcomeRef: policyGate.existingOutcomeRef },
+                    metadata: {
+                        platformId: request.platformId,
+                        channel: plan.channel,
+                        latencyMs: 0,
+                        degraded: plan.degraded,
+                    },
+                };
+            }
             let lastFailure;
             for (let attempt = 1; attempt <= retryPolicy.maxRetries; attempt += 1) {
                 const traceId = `${makeTraceId(request, plan)}:${attempt}`;

package/runtime/connectors/base/route-planner.js

@@ -93,6 +93,7 @@ export class ConnectorRoutePlanner {
             channel: selected,
             endpointMode: endpointModeFor(selected),
             idempotencyKey: request.idempotencyKey,
+            degraded: isDegradedChannel(selected, manifest.degradedChannels),
         };
     }
 }

package/runtime/connectors/index.d.ts

@@ -2,3 +2,4 @@ export * from "./base/index.js";
 export * from "./social-community/moltbook/index.js";
 export * from "./social-community/instreet/index.js";
 export * from "./agent-network/evomap/index.js";
+export * from "./near-real/near-real-connector-smoke.js";

package/runtime/connectors/index.js

@@ -2,3 +2,4 @@ export * from "./base/index.js";
 export * from "./social-community/moltbook/index.js";
 export * from "./social-community/instreet/index.js";
 export * from "./agent-network/evomap/index.js";
+export * from "./near-real/near-real-connector-smoke.js";

package/runtime/connectors/near-real/near-real-connector-smoke.d.ts

@@ -0,0 +1,19 @@
+import type { ObservabilityDatabase } from "../../observability/db/index.js";
+import type { StateDatabase } from "../../storage/db/index.js";
+export interface NearRealConnectorSmokeResult {
+    generatedAt: string;
+    platforms: {
+        social: "moltbook";
+        agentNetwork: "evomap";
+    };
+    feedReadEvidenceId?: string;
+    workDiscoverEvidenceId?: string;
+    taskClaimDryRunOk: boolean;
+    executionAttemptRowsForDecision: number;
+}
+export interface RunNearRealConnectorSmokeInput {
+    state: StateDatabase;
+    observabilityDb: ObservabilityDatabase;
+    workspaceRoot: string;
+}
+export declare function runNearRealConnectorSmoke(input: RunNearRealConnectorSmokeInput): Promise<NearRealConnectorSmokeResult>;

package/runtime/connectors/near-real/near-real-connector-smoke.js

@@ -0,0 +1,152 @@
+/**
+ * T3.3.1 — Near-real connector smoke: sentinel adapters + policy + telemetry + life evidence ingest.
+ * Uses fixture payloads (no live HTTP); task.claim runs with idempotency key (dry-run style outcome).
+ */
+import { eq } from "drizzle-orm";
+import { CapabilityContractRegistry } from "../base/manifest.js";
+import { ConnectorRoutePlanner } from "../base/route-planner.js";
+import { ChannelHealthStore } from "../base/channel-health.js";
+import { createConnectorPolicyLayer } from "../base/policy-layer.js";
+import { InMemoryEffectCommitLedger } from "../base/execution-policy.js";
+import { mapLifeEvidence } from "../base/map-life-evidence.js";
+import { moltbookManifest } from "../social-community/moltbook/manifest.js";
+import { evomapManifest } from "../agent-network/evomap/manifest.js";
+import { ExecutionTelemetry } from "../../observability/services/execution-telemetry.js";
+import { executionAttempts } from "../../observability/db/schema/index.js";
+import { appendLifeEvidence } from "../../storage/life-evidence/append-life-evidence.js";
+const DECISION_ID = "dec-near-real-smoke";
+function smokeRouteContext() {
+    return {
+        async loadCredentialState(platformId) {
+            if (platformId === "moltbook") {
+                return { platformId, status: "active", credentialType: "api_key" };
+            }
+            if (platformId === "evomap") {
+                return { platformId, status: "active", credentialType: "node_secret" };
+            }
+            throw new Error(`near_real_smoke_unsupported_platform:${platformId}`);
+        },
+        async loadCooldownState() {
+            return { blocked: false };
+        },
+    };
+}
+const smokeExecutionRunner = {
+    async run(plan, request) {
+        if (plan.platformId === "moltbook" && plan.intent === "feed.read") {
+            return {
+                platformId: plan.platformId,
+                channel: plan.channel,
+                latencyMs: 2,
+                success: true,
+                payload: {
+                    items: [{ id: "mb-smoke-1", title: "near-real fixture post" }],
+                },
+            };
+        }
+        if (plan.platformId === "evomap" && plan.intent === "work.discover") {
+            return {
+                platformId: plan.platformId,
+                channel: plan.channel,
+                latencyMs: 3,
+                success: true,
+                payload: {
+                    items: [{ id: "ev-task-smoke-1", title: "fixture agent task" }],
+                },
+            };
+        }
+        if (plan.platformId === "evomap" && plan.intent === "task.claim") {
+            return {
+                platformId: plan.platformId,
+                channel: plan.channel,
+                latencyMs: 1,
+                success: true,
+                degraded: plan.degraded,
+                payload: {
+                    dryRun: true,
+                    taskId: typeof request.payload.taskId === "string" ? request.payload.taskId : "unknown",
+                    note: "near_real_smoke_no_external_side_effect",
+                },
+            };
+        }
+        throw new Error(`near_real_smoke_unhandled:${plan.platformId}:${plan.intent}`);
+    },
+};
+export async function runNearRealConnectorSmoke(input) {
+    const ledger = new InMemoryEffectCommitLedger();
+    const registry = new CapabilityContractRegistry();
+    registry.register({ ...moltbookManifest });
+    registry.register({ ...evomapManifest });
+    const planner = new ConnectorRoutePlanner(registry, smokeRouteContext(), new ChannelHealthStore());
+    const telemetry = new ExecutionTelemetry(input.observabilityDb);
+    const policy = createConnectorPolicyLayer({
+        routePlanner: planner,
+        executionRunner: smokeExecutionRunner,
+        telemetry,
+        effectCommitLedger: ledger,
+        retryPolicy: { maxRetries: 1, jitter: false },
+    });
+    const base = {
+        decisionId: DECISION_ID,
+        payload: {},
+    };
+    const feedResult = await policy.executeWithPolicy("feed.read", {
+        platformId: "moltbook",
+        intent: "feed.read",
+        ...base,
+        intentId: "intent-smoke-feed-read",
+        payload: {},
+    });
+    let feedReadEvidenceId;
+    const feedCand = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result: feedResult,
+    });
+    if (feedCand) {
+        const ack = await appendLifeEvidence(input.state, input.workspaceRoot, feedCand);
+        feedReadEvidenceId = ack.evidenceId;
+    }
+    const workResult = await policy.executeWithPolicy("work.discover", {
+        platformId: "evomap",
+        intent: "work.discover",
+        ...base,
+        intentId: "intent-smoke-work-discover",
+        payload: {},
+    });
+    let workDiscoverEvidenceId;
+    const workCand = mapLifeEvidence({
+        platformId: "evomap",
+        intent: "work.discover",
+        result: workResult,
+    });
+    if (workCand) {
+        const ack = await appendLifeEvidence(input.state, input.workspaceRoot, workCand);
+        workDiscoverEvidenceId = ack.evidenceId;
+    }
+    const claimResult = await policy.executeWithPolicy("task.claim", {
+        platformId: "evomap",
+        intent: "task.claim",
+        ...base,
+        intentId: "intent-smoke-task-claim",
+        payload: { taskId: "ev-task-smoke-1" },
+        idempotencyKey: "idem-near-real-task-claim-smoke",
+    });
+    const claimPayload = claimResult.status === "success" && claimResult.data && typeof claimResult.data === "object"
+        ? claimResult.data
+        : undefined;
+    const attemptRows = await input.observabilityDb.db
+        .select()
+        .from(executionAttempts)
+        .where(eq(executionAttempts.decisionId, DECISION_ID));
+    return {
+        generatedAt: new Date().toISOString(),
+        platforms: { social: "moltbook", agentNetwork: "evomap" },
+        feedReadEvidenceId,
+        workDiscoverEvidenceId,
+        taskClaimDryRunOk: claimResult.status === "success" &&
+            claimPayload?.dryRun === true &&
+            claimPayload?.note === "near_real_smoke_no_external_side_effect",
+        executionAttemptRowsForDecision: attemptRows.length,
+    };
+}

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

@@ -12,6 +12,8 @@ function intentKindToScene(kind) {
             return "outreach";
         case "exploration":
             return "explain";
+        case "quiet":
+            return null;
         default:
             return null;
     }

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

@@ -2,7 +2,7 @@
  * Heartbeat Decision Loop
  *
  * Main entry point for the heartbeat runtime. Accepts a HeartbeatSignal,
- * builds a ContinuitySnapshot, plans candidate intents, evaluates guards,
+ * builds runtime snapshot, plans candidate intents, evaluates hard guards,
  * and returns a HeartbeatCycleResult.
  *
  * Per design doc §4.3: heartbeat round follows the sequence:
@@ -12,28 +12,49 @@
  * implements the default conservative path where HEARTBEAT_OK is
  * the first-class result when no action is warranted.
  */
-import type { ContinuitySnapshot } from "../types.js";
-import type { HeartbeatSignal, HeartbeatCycleResult } from "./signal.js";
+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.
- *
- * 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 declare function ingestRhythmSignal(signal: HeartbeatSignal, deps: HeartbeatDeps): Promise<HeartbeatCycleResult>;
 /**

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