@haaaiawd/second-nature 0.1.38 → 0.1.40

package/runtime/cli/ops/workspace-heartbeat-runner.js

@@ -5,6 +5,7 @@ import { createNarrativeStateStore } from "../../storage/narrative/narrative-sta
 import { createRelationshipMemoryStore } from "../../storage/relationship/relationship-memory-store.js";
 import { createIdentityProfileStore } from "../../storage/services/identity-profile-store.js";
 import { generateHeartbeatDigest, } from "../../observability/services/heartbeat-digest-assembler.js";
+import { createHistoryDigestStore } from "../../storage/services/history-digest-store.js";
 export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, options = {}) {
     const status = await readModels.loadStatus();
     const mode = status.rhythm.mode === "unknown" ? "active" : status.rhythm.mode;
@@ -167,7 +168,8 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
                 // cycle outcome itself is still returned to the caller.
             }
         }
-        // v7 T-V7C.C.3: After each cycle, attempt HeartbeatDigest generation if configured.
+        // v7 T-V7C.C.3 / T-V7C.C.6: After each cycle, attempt HeartbeatDigest generation
+        // and persist to heartbeat_digest table so the digest index actually grows.
         // Only runs inside the designated UTC digest window hour, or on every cycle when
         // digestWindowHour is unset (test / always-on mode).
         if (options.digestOpts) {
@@ -177,15 +179,58 @@ export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
             if (inDigestWindow) {
                 try {
                     const date = new Date().toISOString().slice(0, 10);
-                    await generateHeartbeatDigest(date, assemblerDeps);
+                    const assembledDigest = await generateHeartbeatDigest(date, assemblerDeps);
+                    // v7 T-V7C.C.6: Persist assembled digest to heartbeat_digest table when state DB is wired.
+                    if (options.state) {
+                        const digestStore = createHistoryDigestStore(options.state);
+                        await digestStore.writeHeartbeatDigest(toStoreDigest(assembledDigest));
+                    }
                 }
                 catch (err) {
-                    // Digest generation must not break the heartbeat cycle response.
+                    // Digest generation / persistence must not break the heartbeat cycle response.
                     const msg = err instanceof Error ? err.message : String(err);
-                    console.warn(`[workspace-heartbeat-runner] Digest generation failed: ${msg}`);
+                    console.warn(`[workspace-heartbeat-runner] Digest generation/persistence failed: ${msg}`);
                 }
             }
         }
         return cycle;
     };
 }
+/**
+ * Bridge: converts the assembler-facing HeartbeatDigest into the storage-facing
+ * HeartbeatDigest (shared/types/v7-entities.ts) so it can be written to heartbeat_digest.
+ *
+ * The two shapes diverge by design: assembler is an audit-aggregate rich view;
+ * store is a flattened day-keyed row. Mapping is lossy but sufficient for growth.
+ */
+function toStoreDigest(d) {
+    return {
+        digestId: `digest:${d.date}:${Date.now()}`,
+        day: d.date,
+        connectorSummary: d.connectorSummary.map((c) => ({
+            platformId: c.platformId,
+            status: c.blockedCount > 0
+                ? "blocked"
+                : c.circuitOpenCount > 0
+                    ? "blocked"
+                    : c.failureCount > 0
+                        ? "degraded"
+                        : "ok",
+            attemptCount: c.successCount + c.failureCount + c.blockedCount,
+        })),
+        goalSummary: [
+            { kind: "new", activeCount: d.goalSummary.newGoals },
+            { kind: "completed", activeCount: d.goalSummary.completedGoals },
+            { kind: "expired", activeCount: d.goalSummary.expiredGoals },
+            { kind: "replaced", activeCount: d.goalSummary.replacedGoals },
+            { kind: "active", activeCount: d.goalSummary.activeGoals },
+        ].filter((g) => g.activeCount > 0),
+        quietCount: d.quietDreamSummary.quietRuns,
+        dreamCount: d.quietDreamSummary.dreamRuns,
+        breakerSummary: d.healthSummary.circuitBreakerChanges > 0
+            ? [{ connectorId: "aggregate", state: "changed" }]
+            : [],
+        healthStatus: d.healthSummary.auditChainHealthy ? "ok" : "degraded",
+        createdAt: d.generatedAt,
+    };
+}

package/runtime/connectors/services/connector-executor-adapter.js

@@ -14,6 +14,8 @@ import { createCredentialVault } from "../../storage/services/credential-vault.j
 import { createCredentialRouteContextPort } from "./credential-route-context.js";
 import { scanConnectorManifests } from "../registry/manifest-scanner.js";
 import { parseConnectorManifestV6 } from "../manifest/manifest-parser.js";
+import fs from "node:fs";
+import path from "node:path";
 const DEFAULT_AGENT_WORLD_USERNAME = "nyx_ha";
 const DEFAULT_AGENT_WORLD_PROFILE_PATH_TEMPLATE = "/api/agents/profile/{username}";
 function readString(value) {
@@ -101,71 +103,206 @@ async function fetchAgentWorldJson(input) {
     }
     return resp.json();
 }
-function createAdaptiveExecutionRunner(vault) {
+function createMoltbookMockRunner(workspaceRoot) {
     return {
         async run(_plan, request) {
-            const platformId = request.platformId;
             const started = Date.now();
-            if (platformId !== "moltbook" &&
-                platformId !== "evomap" &&
-                platformId !== "agent-world") {
+            const mockPath = workspaceRoot
+                ? path.join(workspaceRoot, ".second-nature", "mock", "moltbook-feed.json")
+                : undefined;
+            if (!mockPath || !fs.existsSync(mockPath)) {
                 return {
-                    platformId,
+                    platformId: request.platformId,
                     channel: request.preferredChannel ?? "api_rest",
                     latencyMs: Date.now() - started,
                     success: false,
                     error: {
-                        code: "unknown_platform",
-                        detail: `no execution runner for ${platformId}`,
+                        code: "configuration_missing",
+                        detail: "SECOND_NATURE_MOLTBOOK_BASE_URL not set and no mock data found",
                     },
                 };
             }
-            const credential = await vault.loadCredentialContext(platformId);
-            if (!credential ||
-                credential.status !== "active" ||
-                !credential.encryptedValue) {
+            try {
+                const raw = fs.readFileSync(mockPath, "utf-8");
+                const data = JSON.parse(raw);
                 return {
-                    platformId,
+                    platformId: request.platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    degraded: true,
+                    success: true,
+                    payload: {
+                        capability: request.intent,
+                        channel: request.preferredChannel ?? "api_rest",
+                        data: {
+                            source: "mock",
+                            items: Array.isArray(data.items) ? data.items : [],
+                        },
+                    },
+                };
+            }
+            catch (err) {
+                return {
+                    platformId: request.platformId,
                     channel: request.preferredChannel ?? "api_rest",
                     latencyMs: Date.now() - started,
                     success: false,
                     error: {
-                        code: "auth_failure",
-                        detail: "credential_unavailable_for_execution",
+                        code: "mock_read_error",
+                        detail: String(err),
                     },
                 };
             }
-            if (platformId === "moltbook") {
-                const baseUrl = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
-                if (!baseUrl) {
+        },
+    };
+}
+function findWorkspaceManifest(platformId, workspaceRoot) {
+    if (!workspaceRoot)
+        return undefined;
+    for (const file of scanConnectorManifests(workspaceRoot)) {
+        const parsed = parseConnectorManifestV6(file.content, file.path);
+        if (parsed.ok && parsed.manifest.platformId === platformId) {
+            return parsed.manifest;
+        }
+    }
+    return undefined;
+}
+function resolveDeclarativeHttpPath(capabilityId) {
+    return `/${capabilityId.replace(/\./g, "/")}`;
+}
+function resolveDeclarativeHttpMethod(capabilityId) {
+    const readOps = ["read", "list", "discover", "get", "heartbeat", "fetch"];
+    if (readOps.some((op) => capabilityId.includes(op)))
+        return "GET";
+    return "POST";
+}
+function createDeclarativeHttpRunner(manifest, credential) {
+    return {
+        async run(plan, request) {
+            const started = Date.now();
+            const baseUrl = manifest.runner.config?.baseUrl ?? "";
+            if (!baseUrl) {
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "configuration_missing",
+                        detail: "runner.config.baseUrl not set for declarative_http connector",
+                    },
+                };
+            }
+            const httpPath = resolveDeclarativeHttpPath(request.intent);
+            const method = resolveDeclarativeHttpMethod(request.intent);
+            try {
+                const headers = {
+                    "Content-Type": "application/json",
+                };
+                if (credential?.encryptedValue) {
+                    headers.Authorization = `Bearer ${credential.encryptedValue}`;
+                }
+                const resp = await fetch(`${baseUrl.replace(/\/+$/, "")}${httpPath}`, {
+                    method,
+                    headers,
+                    body: method !== "GET" && request.payload ? JSON.stringify(request.payload) : undefined,
+                });
+                if (!resp.ok) {
                     return {
-                        platformId,
-                        channel: request.preferredChannel ?? "api_rest",
+                        platformId: request.platformId,
+                        channel: plan.channel,
                         latencyMs: Date.now() - started,
                         success: false,
                         error: {
-                            code: "configuration_missing",
-                            detail: "SECOND_NATURE_MOLTBOOK_BASE_URL not set",
+                            code: "api_error",
+                            detail: `HTTP ${resp.status}: ${await resp.text().catch(() => "")}`,
                         },
                     };
                 }
-                const apiClient = createMoltbookApiClient({
-                    baseUrl,
-                    accessToken: credential.encryptedValue,
-                    timeoutMs: 10000,
-                });
-                const runner = createMoltbookRunner({
-                    apiClient,
-                    skillRunner: {
-                        run: async () => {
-                            throw {
-                                code: "protocol_mismatch",
-                                detail: "moltbook_skill_runner_not_configured",
-                            };
-                        },
+                const data = await resp.json();
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    success: true,
+                    payload: {
+                        capability: request.intent,
+                        channel: plan.channel,
+                        data,
                     },
-                });
-                return runner.run(_plan, request);
+                };
+            }
+            catch (err) {
+                return {
+                    platformId: request.platformId,
+                    channel: plan.channel,
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "network_error",
+                        detail: String(err),
+                    },
+                };
+            }
+        },
+    };
+}
+function createAdaptiveExecutionRunner(vault, workspaceRoot) {
+    return {
+        async run(_plan, request) {
+            const platformId = request.platformId;
+            const started = Date.now();
+            const workspaceManifest = findWorkspaceManifest(platformId, workspaceRoot);
+            const isBuiltInPlatform = platformId === "moltbook" ||
+                platformId === "evomap" ||
+                platformId === "agent-world";
+            const requiresCredential = isBuiltInPlatform ||
+                Boolean(workspaceManifest?.credentials.some((credential) => credential.required !== false));
+            const credential = requiresCredential
+                ? await vault.loadCredentialContext(platformId)
+                : undefined;
+            if (requiresCredential &&
+                (!credential ||
+                    credential.status !== "active" ||
+                    !credential.encryptedValue)) {
+                return {
+                    platformId,
+                    channel: request.preferredChannel ?? "api_rest",
+                    latencyMs: Date.now() - started,
+                    success: false,
+                    error: {
+                        code: "auth_failure",
+                        detail: "credential_unavailable_for_execution",
+                    },
+                };
+            }
+            const activeCredential = credential?.status === "active" && credential.encryptedValue
+                ? { encryptedValue: credential.encryptedValue }
+                : undefined;
+            if (platformId === "moltbook") {
+                const baseUrl = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
+                if (baseUrl) {
+                    const apiClient = createMoltbookApiClient({
+                        baseUrl,
+                        accessToken: activeCredential.encryptedValue,
+                        timeoutMs: 10000,
+                    });
+                    const runner = createMoltbookRunner({
+                        apiClient,
+                        skillRunner: {
+                            run: async () => {
+                                throw {
+                                    code: "protocol_mismatch",
+                                    detail: "moltbook_skill_runner_not_configured",
+                                };
+                            },
+                        },
+                    });
+                    return runner.run(_plan, request);
+                }
+                // Mock fallback when real API is not configured
+                const mockRunner = createMoltbookMockRunner(workspaceRoot);
+                return mockRunner.run(_plan, request);
             }
             if (platformId === "evomap") {
                 return {
@@ -194,7 +331,7 @@ function createAdaptiveExecutionRunner(vault) {
                     };
                 }
                 const runner = createAgentWorldRunner({
-                    apiKey: credential.encryptedValue,
+                    apiKey: activeCredential.encryptedValue,
                     apiClient: {
                         async readFeed(payload, _apiKey) {
                             const username = resolveAgentWorldUsername(payload, "feed");
@@ -235,7 +372,21 @@ function createAdaptiveExecutionRunner(vault) {
                 });
                 return runner.run(_plan, request);
             }
-            throw new Error(`unreachable_connector_platform:${platformId}`);
+            // Wave 83: workspace declarative_http connector fallback
+            if (workspaceManifest && workspaceManifest.runner.kind === "declarative_http") {
+                const httpRunner = createDeclarativeHttpRunner(workspaceManifest, activeCredential);
+                return httpRunner.run(_plan, request);
+            }
+            return {
+                platformId,
+                channel: request.preferredChannel ?? "api_rest",
+                latencyMs: Date.now() - started,
+                success: false,
+                error: {
+                    code: "unknown_platform",
+                    detail: `no execution runner for ${platformId}`,
+                },
+            };
         },
     };
 }
@@ -249,7 +400,7 @@ export function createConnectorExecutorAdapter(options) {
     const routeContextPort = createCredentialRouteContextPort(vault);
     const routePlanner = new ConnectorRoutePlanner(registry, routeContextPort, new ChannelHealthStore());
     const telemetry = new ExecutionTelemetry(options.observabilityDb);
-    const executionRunner = createAdaptiveExecutionRunner(vault);
+    const executionRunner = createAdaptiveExecutionRunner(vault, options.workspaceRoot);
     const policy = createConnectorPolicyLayer({
         routePlanner,
         executionRunner,

package/runtime/core/second-nature/guidance/apply-guidance.d.ts

@@ -5,6 +5,8 @@ export interface AppliedGuidanceContext {
     atmosphereText?: string;
     impulseTexts: string[];
     personaRationales: string[];
+    /** @deprecated Use expressionConstraints. Kept for backward compatibility. */
     outputConstraints: string[];
+    expressionConstraints: string[];
 }
 export declare function applyGuidance(input: GuidancePayload | GuidanceFallback): AppliedGuidanceContext;

package/runtime/core/second-nature/guidance/apply-guidance.js

@@ -1,10 +1,15 @@
 export function applyGuidance(input) {
+    const isMinimal = "minimal" in input && input.minimal;
+    const boundaryConstraints = input.expressionBoundary?.constraints
+        ?? input.outputGuard?.constraints
+        ?? [];
     return {
-        source: "minimal" in input && input.minimal ? "minimal_fallback" : "guidance_payload",
+        source: isMinimal ? "minimal_fallback" : "guidance_payload",
         sceneType: input.scene.sceneType,
         atmosphereText: input.atmosphere?.text,
         impulseTexts: input.impulses.map((item) => item.text),
         personaRationales: input.personaReinforcement.map((item) => item.rationale),
         outputConstraints: input.outputGuard?.constraints ?? [],
+        expressionConstraints: boundaryConstraints,
     };
 }

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

@@ -26,7 +26,7 @@ export type UserReplySceneType = typeof USER_REPLY_SCENE_TYPE;
  * - Light atmosphere (continuity-focused)
  * - NO impulses (unlike platform reply scene)
  * - Optional persona reinforcement (1-2 snippets max)
- * - Minimal output guard (tone consistency only)
+ * - Minimal expression boundary (tone consistency only)
  */
 export declare function buildLightReplyContinuity(input: {
     replyContext: {

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

@@ -1,6 +1,7 @@
 import { buildMinimalGuidanceFallback } from "../../../guidance/fallback.js";
+import { buildExpressionBoundary } from "../../../guidance/output-guard.js";
 import { selectPersonaSnippets } from "../../../guidance/persona-selection.js";
-import { getBaselineAtmosphereTemplate } from "../../../guidance/template-registry.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.
@@ -13,7 +14,7 @@ export const USER_REPLY_SCENE_TYPE = "user_reply";
  * - Light atmosphere (continuity-focused)
  * - NO impulses (unlike platform reply scene)
  * - Optional persona reinforcement (1-2 snippets max)
- * - Minimal output guard (tone consistency only)
+ * - Minimal expression boundary (tone consistency only)
  */
 export async function buildLightReplyContinuity(input) {
     const sceneContext = {
@@ -23,8 +24,8 @@ export async function buildLightReplyContinuity(input) {
         sceneSummary: "direct user reply continuity",
     };
     try {
-        // Light atmosphere - continuity focused
-        const atmosphereTemplate = getBaselineAtmosphereTemplate();
+        // 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}` : "延续既有连续感。"}`,
@@ -43,7 +44,7 @@ export async function buildLightReplyContinuity(input) {
             });
             personaReinforcement = personaDecision.snippets;
         }
-        // Minimal output guard - tone consistency only
+        // Minimal expression boundary - tone consistency only (T-V7C.C.7)
         const outputGuard = {
             kind: "output_guard",
             constraints: [
@@ -51,13 +52,21 @@ export async function buildLightReplyContinuity(input) {
                 "延续同一个人格连续性",
             ],
             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 {

package/runtime/core/second-nature/orchestrator/intent-planner.js

@@ -120,6 +120,11 @@ export function planIntentWithKind(kind, basePriority, runtime, context, registr
         }));
     }
     const refs = kind === "work" ? [...OBLIGATION_SOURCE] : evidenceRefsForConnector(runtime);
+    const capabilityIntent = kind === "exploration" ? "feed.read"
+        : kind === "social" ? "comment.reply"
+            : kind === "work" ? "work.discover"
+                : kind === "outreach" ? "message.send"
+                    : undefined;
     return [
         {
             id: platformId ? `${config.idPrefix}-${platformId}` : config.idPrefix,
@@ -134,6 +139,7 @@ export function planIntentWithKind(kind, basePriority, runtime, context, registr
                 ? `${config.idempotencyPrefix}:${platformId}`
                 : `${config.idempotencyPrefix}:${config.summary(undefined)}`,
             goalInfluenceRefs: [],
+            ...(capabilityIntent ? { capabilityIntent } : {}),
         },
     ];
 }
@@ -242,6 +248,15 @@ export function planCandidateIntents(runtime, options) {
         if (related.length > 0) {
             intent.goalInfluenceRefs = related.map((g) => g.goalId);
         }
+        // W80: sourceRefs fallback — when lifeEvidence is empty, bind accepted goals
+        // as source refs so hard guard (isSourceBacked) does not deny/defer.
+        if (intent.sourceRefs.length === 0 && related.length > 0) {
+            intent.sourceRefs = related.slice(0, 4).map((g) => ({
+                id: g.goalId,
+                kind: "workspace_artifact",
+                uri: `goal://${g.goalId}`,
+            }));
+        }
     }
     // CR-02: apply narrative-focus bias globally across all candidate kinds.
     const adjusted = intents.map((intent) => {

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

@@ -13,6 +13,9 @@ export interface RuntimeServiceContext {
     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 */

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

@@ -26,8 +26,7 @@ export function startRuntimeService(ctx) {
     // - 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";
+    const version = ctx?.version ?? "unknown";
     activeHandle = {
         ready: true,
         version,

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>;