@haaaiawd/second-nature 0.1.34 → 0.1.39

package/runtime/core/second-nature/guidance/user-reply-continuity.js

@@ -1,80 +1,89 @@
-import { buildMinimalGuidanceFallback } from "../../../guidance/fallback.js";
-import { selectPersonaSnippets } from "../../../guidance/persona-selection.js";
-import { getBaselineAtmosphereTemplate } from "../../../guidance/template-registry.js";
-/**
- * Scene context for user reply - uses a distinct scene type
- * to avoid confusion with platform reply scene.
- */
-export const USER_REPLY_SCENE_TYPE = "user_reply";
-/**
- * Build very light continuity guidance for direct user replies.
- *
- * Returns a minimal guidance payload with:
- * - Light atmosphere (continuity-focused)
- * - NO impulses (unlike platform reply scene)
- * - Optional persona reinforcement (1-2 snippets max)
- * - Minimal output guard (tone consistency only)
- */
-export async function buildLightReplyContinuity(input) {
-    const sceneContext = {
-        sceneType: "user_reply",
-        mode: "active",
-        riskLevel: "low",
-        sceneSummary: "direct user reply continuity",
-    };
-    try {
-        // Light atmosphere - continuity focused
-        const atmosphereTemplate = getBaselineAtmosphereTemplate();
-        const atmosphere = {
-            kind: "atmosphere",
-            text: `保持同一个人的语气。${input.replyContext.recentTone ? `最近语气参考：${input.replyContext.recentTone}` : "延续既有连续感。"}`,
-            openness: "open",
-            pressureLabels: ["user_reply", "continuity"],
-            reviewStatus: atmosphereTemplate.reviewStatus,
-        };
-        // NO impulses for user reply - this is the key difference from platform reply
-        const impulses = [];
-        // Minimal persona reinforcement - only if candidates available
-        let personaReinforcement = [];
-        if (input.personaCandidates && input.personaCandidates.length > 0) {
-            const personaDecision = selectPersonaSnippets({
-                sceneContext,
-                candidates: input.personaCandidates.slice(0, 2), // Max 2 snippets for light continuity
-            });
-            personaReinforcement = personaDecision.snippets;
-        }
-        // Minimal output guard - tone consistency only
-        const outputGuard = {
-            kind: "output_guard",
-            constraints: [
-                "保持对话语气，不要用帖子回复腔",
-                "延续同一个人格连续性",
-            ],
-            hardGuardPriority: true,
-        };
-        return {
-            scene: sceneContext,
-            atmosphere,
-            impulses,
-            personaReinforcement,
-            outputGuard,
-        };
-    }
-    catch {
-        // Fallback to minimal guidance
-        return buildMinimalGuidanceFallback(sceneContext);
-    }
-}
-/**
- * Check if an input should be classified as direct user reply.
- *
- * Classification criteria:
- * - Trigger source is user_reply
- * - Not a platform comment/reply
- * - Not an explicit task delegation
- */
-export function isDirectUserReply(input) {
-    return (input.triggerSource === "user_reply" &&
-        !input.isPlatformReply &&
-        !input.isExplicitTask);
-}
+import { buildMinimalGuidanceFallback } from "../../../guidance/fallback.js";
+import { buildExpressionBoundary } from "../../../guidance/output-guard.js";
+import { selectPersonaSnippets } from "../../../guidance/persona-selection.js";
+import { getShortAtmosphereTemplate } from "../../../guidance/template-registry.js";
+/**
+ * Scene context for user reply - uses a distinct scene type
+ * to avoid confusion with platform reply scene.
+ */
+export const USER_REPLY_SCENE_TYPE = "user_reply";
+/**
+ * Build very light continuity guidance for direct user replies.
+ *
+ * Returns a minimal guidance payload with:
+ * - Light atmosphere (continuity-focused)
+ * - NO impulses (unlike platform reply scene)
+ * - Optional persona reinforcement (1-2 snippets max)
+ * - Minimal expression boundary (tone consistency only)
+ */
+export async function buildLightReplyContinuity(input) {
+    const sceneContext = {
+        sceneType: "user_reply",
+        mode: "active",
+        riskLevel: "low",
+        sceneSummary: "direct user reply continuity",
+    };
+    try {
+        // Light atmosphere - continuity focused (T-V7C.C.7: short constraint style)
+        const atmosphereTemplate = getShortAtmosphereTemplate(sceneContext.mode, sceneContext.riskLevel);
+        const atmosphere = {
+            kind: "atmosphere",
+            text: `保持同一个人的语气。${input.replyContext.recentTone ? `最近语气参考：${input.replyContext.recentTone}` : "延续既有连续感。"}`,
+            openness: "open",
+            pressureLabels: ["user_reply", "continuity"],
+            reviewStatus: atmosphereTemplate.reviewStatus,
+        };
+        // NO impulses for user reply - this is the key difference from platform reply
+        const impulses = [];
+        // Minimal persona reinforcement - only if candidates available
+        let personaReinforcement = [];
+        if (input.personaCandidates && input.personaCandidates.length > 0) {
+            const personaDecision = selectPersonaSnippets({
+                sceneContext,
+                candidates: input.personaCandidates.slice(0, 2), // Max 2 snippets for light continuity
+            });
+            personaReinforcement = personaDecision.snippets;
+        }
+        // Minimal expression boundary - tone consistency only (T-V7C.C.7)
+        const outputGuard = {
+            kind: "output_guard",
+            constraints: [
+                "保持对话语气，不要用帖子回复腔",
+                "延续同一个人格连续性",
+            ],
+            hardGuardPriority: true,
+            _semanticNote: "output_guard_only_shapes_expression",
+        };
+        const expressionBoundary = buildExpressionBoundary(sceneContext.sceneType);
+        // Override with user-reply-specific constraints
+        expressionBoundary.constraints = [
+            "保持对话语气，不要用帖子回复腔",
+            "延续同一个人格连续性",
+        ];
+        return {
+            scene: sceneContext,
+            atmosphere,
+            impulses,
+            personaReinforcement,
+            outputGuard,
+            expressionBoundary,
+        };
+    }
+    catch {
+        // Fallback to minimal guidance
+        return buildMinimalGuidanceFallback(sceneContext);
+    }
+}
+/**
+ * Check if an input should be classified as direct user reply.
+ *
+ * Classification criteria:
+ * - Trigger source is user_reply
+ * - Not a platform comment/reply
+ * - Not an explicit task delegation
+ */
+export function isDirectUserReply(input) {
+    return (input.triggerSource === "user_reply" &&
+        !input.isPlatformReply &&
+        !input.isExplicitTask);
+}

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

@@ -23,6 +23,8 @@ 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;
@@ -43,12 +45,14 @@ export interface HeartbeatOutreachDispatchDeps {
 /** 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">): Promise<HeartbeatCycleResult>;
+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>;
@@ -71,6 +75,8 @@ export interface HeartbeatDeps {
     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.

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

@@ -38,6 +38,8 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
             day,
             userInterestSnapshot: inputs.userInterestSnapshot,
             workspaceRoot: deps.quietWorkflow.workspaceRoot,
+            // v7 T-V7C.C.3: pass Dream schedule port so Quiet completion triggers Dream.
+            dreamSchedulePort: deps.quietWorkflow.dreamSchedulePort,
         });
         return quietRun.result;
     }
@@ -64,6 +66,8 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
             };
         }
         const decisionId = `decision:${intent.id}:${Date.now()}`;
+        // T-V7C.C.4: inject identity from EmbodiedContext into connector request (readable, no credential)
+        const platformHandle = runtime.identity?.platformHandles.find((h) => h.platformId === intent.platformId)?.handle;
         const result = await deps.connectorExecutor.executeEffect({
             platformId: intent.platformId,
             intent: toCapabilityIntent(intent),
@@ -71,6 +75,12 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
             decisionId,
             intentId: intent.id,
             idempotencyKey: `idem:${intent.id}:${Date.now()}`,
+            identity: platformHandle || runtime.identity?.canonicalName
+                ? {
+                    platformHandle,
+                    canonicalName: runtime.identity?.canonicalName,
+                }
+                : undefined,
         });
         // T3.3.1: on success, map connector result to life evidence and append.
         // On failure or empty result, no evidence is fabricated — attempt audit
@@ -96,6 +106,21 @@ export async function resolveAllowedIntentResult(intent, runtime, inputs, signal
                 console.warn(`[heartbeat] evidence append failed for ${intent.platformId ?? "unknown"}: ${errorMessage}`);
             }
         }
+        // v7 T-V7C.C.2: record ToolExperience for all connector attempts in heartbeat.
+        if (deps.experienceWriter) {
+            try {
+                await deps.experienceWriter.recordExperience({
+                    connectorId: intent.platformId,
+                    capabilityId: toCapabilityIntent(intent),
+                    result,
+                    triggerSource: "heartbeat",
+                });
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                console.warn(`[heartbeat] ToolExperience record failed for ${intent.platformId ?? "unknown"}: ${errorMessage}`);
+            }
+        }
         const base = {
             scope: "rhythm",
             status: "intent_selected",

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

@@ -5,6 +5,7 @@ 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";
+import type { AffordanceMap } from "../../../shared/types/v7-entities.js";
 export interface PlannerLifeEvidenceSlice {
     evidenceRefs: ControlPlaneSourceRef[];
     platformEventCount: number;
@@ -23,6 +24,10 @@ export interface HeartbeatRuntimeSnapshot {
     hardGuards: HardGuardDeps;
     narrativeState?: import("../../../storage/narrative/narrative-state-store.js").NarrativeState;
     relationshipMemory?: import("../../../storage/relationship/relationship-memory-store.js").RelationshipMemory;
+    /** v7: affordance map for breaker-aware guard evaluation (T-V7C.C.2). */
+    affordanceMap?: AffordanceMap;
+    /** T-V7C.C.4: identity profile for connector request identity injection. */
+    identity?: import("../../../shared/types/v7-entities.js").IdentityProfile;
 }
 export declare function buildLifeEvidenceSliceFromInputs(inputs: SnapshotInputs): PlannerLifeEvidenceSlice;
 export declare function buildHardGuardDeps(continuity: ContinuitySnapshot, inputs: SnapshotInputs): HardGuardDeps;

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

@@ -31,5 +31,14 @@ export function buildHeartbeatRuntimeSnapshot(timestamp, inputs, continuity) {
     const rhythmWindow = buildPlannerRhythmWindow(timestamp, continuity, policy);
     const lifeEvidence = buildLifeEvidenceSliceFromInputs(inputs);
     const hardGuards = buildHardGuardDeps(continuity, inputs);
-    return { continuity, lifeEvidence, rhythmWindow, hardGuards, narrativeState: inputs.narrativeState, relationshipMemory: inputs.relationshipMemory };
+    return {
+        continuity,
+        lifeEvidence,
+        rhythmWindow,
+        hardGuards,
+        narrativeState: inputs.narrativeState,
+        relationshipMemory: inputs.relationshipMemory,
+        affordanceMap: inputs.affordanceMap,
+        identity: inputs.identity,
+    };
 }

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

@@ -12,6 +12,7 @@ import type { DeliveryCapabilitySnapshot } from "../outreach/delivery-target.js"
 import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
 import type { NarrativeState } from "../../../storage/narrative/narrative-state-store.js";
 import type { RelationshipMemory } from "../../../storage/relationship/relationship-memory-store.js";
+import type { AffordanceMap, IdentityProfile } from "../../../shared/types/v7-entities.js";
 export interface SnapshotInputs {
     mode: TopLevelMode;
     currentWindowId: string;
@@ -58,6 +59,10 @@ export interface SnapshotInputs {
     narrativeState?: NarrativeState;
     /** When present, planner uses relationship memory to influence outreach timing. */
     relationshipMemory?: RelationshipMemory;
+    /** v7: affordance map for breaker-aware guard evaluation (T-V7C.C.2). */
+    affordanceMap?: AffordanceMap;
+    /** T-V7C.C.4: identity profile for connector request identity injection. */
+    identity?: IdentityProfile;
 }
 /**
  * Build a ContinuitySnapshot from loaded inputs.

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

@@ -42,6 +42,27 @@ export function evaluateHardGuards(intent, runtime) {
     if (!isSourceBacked(intent)) {
         reasons.push("missing_source_refs");
     }
+    // v7: Affordance / breaker guard (T-V7C.C.2)
+    if ((intent.effectClass === "connector_action" ||
+        intent.effectClass === "external_platform_action") &&
+        runtime.affordanceMap &&
+        intent.platformId) {
+        const platformItems = runtime.affordanceMap[intent.platformId] ?? [];
+        const match = intent.capabilityIntent
+            ? platformItems.find((i) => i.capabilityId === intent.capabilityIntent)
+            : platformItems.find((i) => i.intent === intent.summary);
+        if (match) {
+            if (match.status === "painful") {
+                reasons.push("connector_circuit_open");
+            }
+            else if (match.status === "unavailable") {
+                reasons.push("affordance_unavailable");
+            }
+        }
+        else {
+            reasons.push("affordance_unavailable");
+        }
+    }
     const key = intentFingerprint(intent);
     if (runtime.hardGuards.hasDuplicateIntent(key)) {
         reasons.push("duplicate_intent");
@@ -74,7 +95,9 @@ export function evaluateHardGuards(intent, runtime) {
     }
     const duplicate = reasons.includes("duplicate_intent");
     const cooldown = reasons.includes("outreach_cooldown");
-    if (duplicate || cooldown) {
+    const circuitOpen = reasons.includes("connector_circuit_open");
+    const affordanceUnavailable = reasons.includes("affordance_unavailable");
+    if (duplicate || cooldown || circuitOpen || affordanceUnavailable) {
         return {
             verdict: "defer",
             reasons,

package/runtime/core/second-nature/quiet/run-source-backed-quiet.d.ts

@@ -1,17 +1,37 @@
 /**
  * Quiet / reflection orchestration: empty evidence → empty_state; otherwise coverage-gated artifact (T2.3.3).
+ *
+ * v7 T-V7C.C.3: After a successful Quiet artifact write, if a DreamSchedulePort is provided,
+ * automatically trigger scheduleDream(quiet_completion). Skip reason is embedded in HeartbeatCycleResult
+ * reasons when the scheduler returns "skipped" (e.g. lock held).
  */
 import type { CandidateIntent } from "../types.js";
 import type { HeartbeatRuntimeSnapshot } from "../heartbeat/runtime-snapshot.js";
 import type { HeartbeatCycleResult } from "../heartbeat/signal.js";
 import { type QuietArtifactAck } from "../../../storage/quiet/quiet-artifact-writer.js";
 import type { UserInterestSnapshot } from "../../../storage/user-interest/types.js";
+/**
+ * Minimal port for triggering Dream after Quiet completion (T-V7C.C.3).
+ * Kept narrow so run-source-backed-quiet does not take a hard dependency on dream-scheduler.
+ */
+export interface QuietDreamSchedulePort {
+    scheduleDream(params: {
+        triggerKind: "quiet_completion";
+        runId: string;
+        traceId: string;
+    }): Promise<{
+        status: "started" | "skipped" | "queued";
+        reason?: string;
+    }>;
+}
 export interface RunSourceBackedQuietParams {
     candidate: CandidateIntent;
     runtime: HeartbeatRuntimeSnapshot;
     day: string;
     userInterestSnapshot?: UserInterestSnapshot;
     workspaceRoot?: string;
+    /** v7 T-V7C.C.3: when present, a successful Quiet artifact write auto-triggers Dream scheduling. */
+    dreamSchedulePort?: QuietDreamSchedulePort;
 }
 export interface RunSourceBackedQuietResult {
     result: HeartbeatCycleResult;

package/runtime/core/second-nature/quiet/run-source-backed-quiet.js

@@ -11,8 +11,33 @@ function toGuidanceRef(r) {
         observedAt: r.observedAt,
     };
 }
+/**
+ * v7 T-V7C.C.3: Fire-and-forget Dream schedule after successful Quiet write.
+ * Returns the schedule status reason string to embed in HeartbeatCycleResult reasons.
+ * Never throws — Dream scheduling failure must not break the Quiet cycle result.
+ */
+async function maybeScheduleDreamAfterQuiet(dreamSchedulePort, day) {
+    if (!dreamSchedulePort)
+        return undefined;
+    try {
+        const result = await dreamSchedulePort.scheduleDream({
+            triggerKind: "quiet_completion",
+            runId: `dream:quiet_completion:${day}:${Date.now()}`,
+            traceId: `trace:quiet_completion:${day}:${Date.now()}`,
+        });
+        if (result.status === "skipped") {
+            return `quiet_dream_skip:${result.reason ?? "lock_held"}`;
+        }
+        return "quiet_dream_scheduled";
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[run-source-backed-quiet] Dream schedule failed: ${msg}`);
+        return `quiet_dream_schedule_error:${msg.slice(0, 60)}`;
+    }
+}
 export async function runSourceBackedQuiet(params) {
-    const { candidate, runtime, day, userInterestSnapshot, workspaceRoot } = params;
+    const { candidate, runtime, day, userInterestSnapshot, workspaceRoot, dreamSchedulePort } = params;
     const empty = isLifeEvidenceSliceEmpty(runtime.lifeEvidence);
     if (empty) {
         const input = {
@@ -117,12 +142,17 @@ export async function runSourceBackedQuiet(params) {
         const p = await persistQuietArtifactToWorkspace(workspaceRoot, ack, reportWrite);
         persistedRelativePath = p.relativePath;
     }
+    // v7 T-V7C.C.3: After a successful source-backed Quiet write, auto-trigger Dream scheduling.
+    const dreamReason = await maybeScheduleDreamAfterQuiet(dreamSchedulePort, day);
+    const reasons = ["quiet_artifact_written", ...gq.hints.slice(0, 2)];
+    if (dreamReason)
+        reasons.push(dreamReason);
     return {
         result: {
             scope: "rhythm",
             status: "intent_selected",
             selectedIntentId: candidate.id,
-            reasons: ["quiet_artifact_written", ...gq.hints.slice(0, 2)],
+            reasons,
         },
         artifactAck: ack,
         persistedRelativePath,

package/runtime/core/second-nature/runtime/service-entry.d.ts

@@ -1,36 +1,39 @@
-/**
- * Second Nature Runtime Service Entry
- *
- * This module provides the actual implementation for the `second-nature-runtime` service.
- * It serves as the heartbeat host bridge candidate carrier and initializes the
- * minimal runtime state needed for the plugin to function.
- *
- * Per ADR-005: heartbeat is the free-rhythm main entry; this service provides
- * the stable runtime state that heartbeat rounds will interact with.
- */
-export interface RuntimeServiceContext {
-    /** Workspace root path for state/observability databases */
-    workspaceRoot?: string;
-    /** Plugin configuration overrides */
-    config?: Record<string, unknown>;
-}
-export interface RuntimeServiceHandle {
-    /** Service is ready and accepting requests */
-    ready: boolean;
-    /** Runtime version string */
-    version: string;
-    /** Close the runtime handle and release resources */
-    close: () => void;
-}
-/**
- * Start the Second Nature runtime service.
- *
- * This is the non-empty implementation that replaces the previous `start() { return; }` shell.
- * It initializes the minimal runtime state and returns a handle that can be used
- * by the heartbeat host bridge.
- */
-export declare function startRuntimeService(ctx?: RuntimeServiceContext): RuntimeServiceHandle;
-/**
- * Get the current runtime service handle, or null if not started.
- */
-export declare function getRuntimeHandle(): RuntimeServiceHandle | null;
+/**
+ * Second Nature Runtime Service Entry
+ *
+ * This module provides the actual implementation for the `second-nature-runtime` service.
+ * It serves as the heartbeat host bridge candidate carrier and initializes the
+ * minimal runtime state needed for the plugin to function.
+ *
+ * Per ADR-005: heartbeat is the free-rhythm main entry; this service provides
+ * the stable runtime state that heartbeat rounds will interact with.
+ */
+export interface RuntimeServiceContext {
+    /** Workspace root path for state/observability databases */
+    workspaceRoot?: string;
+    /** Plugin configuration overrides */
+    config?: Record<string, unknown>;
+    /** Runtime version — supplied by the plugin entry from its package manifest.
+     *  Eliminates hard-coded version drift (previously `const version = "0.1.38"`). */
+    version?: string;
+}
+export interface RuntimeServiceHandle {
+    /** Service is ready and accepting requests */
+    ready: boolean;
+    /** Runtime version string */
+    version: string;
+    /** Close the runtime handle and release resources */
+    close: () => void;
+}
+/**
+ * Start the Second Nature runtime service.
+ *
+ * This is the non-empty implementation that replaces the previous `start() { return; }` shell.
+ * It initializes the minimal runtime state and returns a handle that can be used
+ * by the heartbeat host bridge.
+ */
+export declare function startRuntimeService(ctx?: RuntimeServiceContext): RuntimeServiceHandle;
+/**
+ * Get the current runtime service handle, or null if not started.
+ */
+export declare function getRuntimeHandle(): RuntimeServiceHandle | null;

package/runtime/core/second-nature/runtime/service-entry.js

@@ -1,45 +1,44 @@
-/**
- * Second Nature Runtime Service Entry
- *
- * This module provides the actual implementation for the `second-nature-runtime` service.
- * It serves as the heartbeat host bridge candidate carrier and initializes the
- * minimal runtime state needed for the plugin to function.
- *
- * Per ADR-005: heartbeat is the free-rhythm main entry; this service provides
- * the stable runtime state that heartbeat rounds will interact with.
- */
-let activeHandle = null;
-/**
- * Start the Second Nature runtime service.
- *
- * This is the non-empty implementation that replaces the previous `start() { return; }` shell.
- * It initializes the minimal runtime state and returns a handle that can be used
- * by the heartbeat host bridge.
- */
-export function startRuntimeService(ctx) {
-    if (activeHandle?.ready) {
-        return activeHandle;
-    }
-    // Initialize minimal runtime state
-    // In future iterations, this will connect to:
-    // - state-system (SQLite database initialization)
-    // - observability-system (event store setup)
-    // - control-plane-system (heartbeat bridge preparation)
-    const workspaceRoot = ctx?.workspaceRoot ?? process.cwd();
-    /** Keep in sync with `plugin/package.json` when cutting releases. */
-    const version = "0.1.21";
-    activeHandle = {
-        ready: true,
-        version,
-        close() {
-            activeHandle = null;
-        },
-    };
-    return activeHandle;
-}
-/**
- * Get the current runtime service handle, or null if not started.
- */
-export function getRuntimeHandle() {
-    return activeHandle;
-}
+/**
+ * Second Nature Runtime Service Entry
+ *
+ * This module provides the actual implementation for the `second-nature-runtime` service.
+ * It serves as the heartbeat host bridge candidate carrier and initializes the
+ * minimal runtime state needed for the plugin to function.
+ *
+ * Per ADR-005: heartbeat is the free-rhythm main entry; this service provides
+ * the stable runtime state that heartbeat rounds will interact with.
+ */
+let activeHandle = null;
+/**
+ * Start the Second Nature runtime service.
+ *
+ * This is the non-empty implementation that replaces the previous `start() { return; }` shell.
+ * It initializes the minimal runtime state and returns a handle that can be used
+ * by the heartbeat host bridge.
+ */
+export function startRuntimeService(ctx) {
+    if (activeHandle?.ready) {
+        return activeHandle;
+    }
+    // Initialize minimal runtime state
+    // In future iterations, this will connect to:
+    // - state-system (SQLite database initialization)
+    // - observability-system (event store setup)
+    // - control-plane-system (heartbeat bridge preparation)
+    const workspaceRoot = ctx?.workspaceRoot ?? process.cwd();
+    const version = ctx?.version ?? "unknown";
+    activeHandle = {
+        ready: true,
+        version,
+        close() {
+            activeHandle = null;
+        },
+    };
+    return activeHandle;
+}
+/**
+ * Get the current runtime service handle, or null if not started.
+ */
+export function getRuntimeHandle() {
+    return activeHandle;
+}

package/runtime/dream/dream-engine.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Dream Engine — orchestrates the hybrid memory consolidation pipeline.
+ *
+ * Pipeline: load inputs → consolidate (rules) → sample → redact →
+ * optional model insights → merge → validate → write output + trace.
+ *
+ * Contract:
+ * - Input store is never modified.
+ * - Output is always candidate until validation passes and lifecycle port accepts it.
+ * - Budget/redaction/timeout failures degrade gracefully with trace.
+ * Test coverage: tests/integration/dream/t7-1-1-dream-pipeline.test.ts
+ */
+import type { DreamEngineInput, DreamRunResult } from "./types.js";
+export declare function runDream(input: DreamEngineInput): Promise<DreamRunResult>;