@haaaiawd/second-nature 0.1.43 → 0.1.51

package/runtime/core/second-nature/heartbeat/goal-lifecycle-policy.d.ts

@@ -1,37 +1,24 @@
-/**
- * GoalLifecyclePolicy — T-CP.C.3
- *
- * Core logic: Evaluates active goals, detects replace/expire
- * conditions, and emits typed GoalTransitionRequest.
- *
- * Responsibility separation (DR-012):
- * - control-plane evaluates and emits transition requests.
- * - state-memory executes transitions via GoalLifecycleStore.
- * - This module does NOT write goal state directly.
- *
- * Rules:
- * - Same kind+scope: newest accepted goal stays active; older ones → replaced.
- * - Expired goals (expiresAt < now) → expired transition request.
- *
- * Boundary:
- * - Consumes AgentGoal[] from EmbodiedContext.goals slice.
- * - Returns GoalTransitionRequest[] for state-memory to execute.
- *
- * Test coverage: tests/unit/control-plane/goal-lifecycle-policy.test.ts
- */
-import type { AgentGoal } from "../../../shared/types/goal.js";
-export interface GoalTransitionRequest {
-    goalId: string;
-    newStatus: "completed" | "expired" | "replaced" | "paused" | "accepted";
-    reason: string;
-    updatedAt: string;
-}
-export interface GoalLifecyclePolicyResult {
-    activeGoals: AgentGoal[];
-    transitionRequests: GoalTransitionRequest[];
-    evaluatedAt: string;
-}
-export interface GoalLifecyclePolicy {
-    evaluate(goals: AgentGoal[]): GoalLifecyclePolicyResult;
-}
-export declare function createGoalLifecyclePolicy(): GoalLifecyclePolicy;
+export interface GoalTransitionRequest {
+    goalId: string;
+    newStatus: "completed" | "expired" | "replaced" | "paused" | "accepted";
+    reason: string;
+    updatedAt: string;
+}
+/** Minimal goal shape required by the lifecycle policy evaluator. */
+export interface EvaluableGoal {
+    goalId: string;
+    kind?: string;
+    scope?: string;
+    status: string;
+    updatedAt?: string;
+    expiresAt?: string;
+}
+export interface GoalLifecyclePolicyResult {
+    activeGoals: EvaluableGoal[];
+    transitionRequests: GoalTransitionRequest[];
+    evaluatedAt: string;
+}
+export interface GoalLifecyclePolicy {
+    evaluate(goals: EvaluableGoal[]): GoalLifecyclePolicyResult;
+}
+export declare function createGoalLifecyclePolicy(): GoalLifecyclePolicy;

package/runtime/core/second-nature/heartbeat/goal-lifecycle-policy.js

@@ -1,61 +1,61 @@
-export function createGoalLifecyclePolicy() {
-    return {
-        evaluate(goals) {
-            const now = new Date().toISOString();
-            const activeGoals = [];
-            const transitionRequests = [];
-            // Group by kind+scope to detect duplicates among accepted goals
-            const groups = new Map();
-            for (const goal of goals) {
-                if (goal.status !== "accepted")
-                    continue;
-                const key = `${goal.kind}:${goal.scope ?? "global"}`;
-                const list = groups.get(key) ?? [];
-                list.push(goal);
-                groups.set(key, list);
-            }
-            for (const [key, list] of groups) {
-                // Sort by updatedAt desc, keep newest as active
-                const sorted = [...list].sort((a, b) => {
-                    const aTime = new Date(a.updatedAt).getTime();
-                    const bTime = new Date(b.updatedAt).getTime();
-                    if (isNaN(aTime) || isNaN(bTime))
-                        return 0;
-                    return bTime - aTime;
-                });
-                const [newest, ...older] = sorted;
-                if (newest) {
-                    activeGoals.push(newest);
-                    // Older same kind+scope goals → replace
-                    for (const old of older) {
-                        transitionRequests.push({
-                            goalId: old.goalId,
-                            newStatus: "replaced",
-                            reason: `same_kind_scope_replace:${key}`,
-                            updatedAt: now,
-                        });
-                    }
-                }
-            }
-            // Detect expired goals among active
-            for (const goal of activeGoals) {
-                if (goal.expiresAt) {
-                    const expiresTime = new Date(goal.expiresAt).getTime();
-                    if (!isNaN(expiresTime) && expiresTime < new Date(now).getTime()) {
-                        transitionRequests.push({
-                            goalId: goal.goalId,
-                            newStatus: "expired",
-                            reason: "expires_at_reached",
-                            updatedAt: now,
-                        });
-                    }
-                }
-            }
-            return {
-                activeGoals,
-                transitionRequests,
-                evaluatedAt: now,
-            };
-        },
-    };
-}
+export function createGoalLifecyclePolicy() {
+    return {
+        evaluate(goals) {
+            const now = new Date().toISOString();
+            const activeGoals = [];
+            const transitionRequests = [];
+            // Group by kind+scope to detect duplicates among accepted goals
+            const groups = new Map();
+            for (const goal of goals) {
+                if (goal.status !== "accepted")
+                    continue;
+                const key = `${goal.kind}:${goal.scope ?? "global"}`;
+                const list = groups.get(key) ?? [];
+                list.push(goal);
+                groups.set(key, list);
+            }
+            for (const [key, list] of groups) {
+                // Sort by updatedAt desc, keep newest as active
+                const sorted = [...list].sort((a, b) => {
+                    const aTime = new Date(a.updatedAt ?? 0).getTime();
+                    const bTime = new Date(b.updatedAt ?? 0).getTime();
+                    if (isNaN(aTime) || isNaN(bTime))
+                        return 0;
+                    return bTime - aTime;
+                });
+                const [newest, ...older] = sorted;
+                if (newest) {
+                    activeGoals.push(newest);
+                    // Older same kind+scope goals → replace
+                    for (const old of older) {
+                        transitionRequests.push({
+                            goalId: old.goalId,
+                            newStatus: "replaced",
+                            reason: `same_kind_scope_replace:${key}`,
+                            updatedAt: now,
+                        });
+                    }
+                }
+            }
+            // Detect expired goals among active
+            for (const goal of activeGoals) {
+                if (goal.expiresAt) {
+                    const expiresTime = new Date(goal.expiresAt).getTime();
+                    if (!isNaN(expiresTime) && expiresTime < new Date(now).getTime()) {
+                        transitionRequests.push({
+                            goalId: goal.goalId,
+                            newStatus: "expired",
+                            reason: "expires_at_reached",
+                            updatedAt: now,
+                        });
+                    }
+                }
+            }
+            return {
+                activeGoals,
+                transitionRequests,
+                evaluatedAt: now,
+            };
+        },
+    };
+}

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

@@ -1,88 +1,97 @@
-/**
- * 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";
-import type { ConnectorExecutor } from "../../../connectors/base/contract.js";
-import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
-import type { NarrativeStateStore } from "../../../storage/narrative/narrative-state-store.js";
-import type { NarrativeTracePayload } from "../../../observability/services/lived-experience-audit.js";
-import type { ExperienceWriter } from "../body/tool-experience/experience-writer.js";
-import type { QuietDreamSchedulePort } from "../quiet/run-source-backed-quiet.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;
-    /** v7 T-V7C.C.3: when present, a successful Quiet write auto-triggers Dream scheduling. */
-    dreamSchedulePort?: QuietDreamSchedulePort;
-}
-/**
- * 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" | "connectorExecutor" | "state" | "workspaceRoot" | "experienceWriter">): 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;
-    /**
-     * When present, guard-allowed connector_action intents are dispatched
-     * through the connector-system instead of returning connector_dispatch_unwired.
-     */
-    connectorExecutor?: ConnectorExecutor;
-    /** T2.1.5: when present, heartbeat writes a source-backed NarrativeState revision after each cycle. */
-    narrativeStateStore?: NarrativeStateStore;
-    /** T5.1.2: when present, heartbeat records a NarrativeTrace after successful narrative state update. */
-    recordNarrativeTrace?: (payload: NarrativeTracePayload) => Promise<void>;
-    /** T3.3.1: when present, successful connector effects write LifeEvidence artifacts. */
-    state?: StateDatabase;
-    /** T3.3.1: workspace root for evidence artifact paths. */
-    workspaceRoot?: string;
-    /** T2.4.1: when present, planner resolves platform-specific intents. */
-    connectorRegistry?: CapabilityContractRegistry;
-    /** v7 T-V7C.C.2: when present, connector attempts write ToolExperience with triggerSource="heartbeat". */
-    experienceWriter?: ExperienceWriter;
-}
-/**
- * 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";
+import type { ConnectorExecutor } from "../../../connectors/base/contract.js";
+import type { CapabilityContractRegistry } from "../../../connectors/base/manifest.js";
+import type { NarrativeStateStore } from "../../../storage/narrative/narrative-state-store.js";
+import type { NarrativeTracePayload } from "../../../observability/services/lived-experience-audit.js";
+import type { ExperienceWriter } from "../body/tool-experience/experience-writer.js";
+import type { QuietDreamSchedulePort } from "../quiet/run-source-backed-quiet.js";
+import type { GoalLifecyclePolicy } from "./goal-lifecycle-policy.js";
+import type { IdleCuriosityPolicy } from "./idle-curiosity-policy.js";
+import type { CircuitBreakerManager } from "../body/circuit-breaker/circuit-breaker-manager.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;
+    /** v7 T-V7C.C.3: when present, a successful Quiet write auto-triggers Dream scheduling. */
+    dreamSchedulePort?: QuietDreamSchedulePort;
+}
+/**
+ * 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" | "connectorExecutor" | "state" | "workspaceRoot" | "experienceWriter" | "circuitBreakerManager">): 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;
+    /**
+     * When present, guard-allowed connector_action intents are dispatched
+     * through the connector-system instead of returning connector_dispatch_unwired.
+     */
+    connectorExecutor?: ConnectorExecutor;
+    /** T2.1.5: when present, heartbeat writes a source-backed NarrativeState revision after each cycle. */
+    narrativeStateStore?: NarrativeStateStore;
+    /** T5.1.2: when present, heartbeat records a NarrativeTrace after successful narrative state update. */
+    recordNarrativeTrace?: (payload: NarrativeTracePayload) => Promise<void>;
+    /** T3.3.1: when present, successful connector effects write LifeEvidence artifacts. */
+    state?: StateDatabase;
+    /** T3.3.1: workspace root for evidence artifact paths. */
+    workspaceRoot?: string;
+    /** T2.4.1: when present, planner resolves platform-specific intents. */
+    connectorRegistry?: CapabilityContractRegistry;
+    /** v7 T-V7C.C.2: when present, connector attempts write ToolExperience with triggerSource="heartbeat". */
+    experienceWriter?: ExperienceWriter;
+    /** v7 T-CP.C.3: when present, evaluates goal lifecycle transitions before candidate planning. */
+    goalLifecyclePolicy?: GoalLifecyclePolicy;
+    /** v7 T-CP.C.3: when present, selects read-only sensing intent when no active goals exist. */
+    idleCuriosityPolicy?: IdleCuriosityPolicy;
+    /** v7 T-BTS.C.5: when present, updates breaker state after connector execution. */
+    circuitBreakerManager?: CircuitBreakerManager;
+}
+/**
+ * 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;