@haaaiawd/second-nature 0.1.18 → 0.1.20

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

@@ -1,152 +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,
-    };
-}
+/**
+ * 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

@@ -1,114 +1,114 @@
-import { EffectDispatcher, buildDecisionContext } from "../orchestrator/effect-dispatcher.js";
-/**
- * Map an intent kind to its guidance scene type.
- * Only generative scenes (social, outreach, explain) request guidance.
- * Maintenance, reflection, and work do not request guidance.
- */
-function intentKindToScene(kind) {
-    switch (kind) {
-        case "social":
-            return "social";
-        case "outreach":
-            return "outreach";
-        case "exploration":
-            return "explain";
-        case "quiet":
-            return null;
-        default:
-            return null;
-    }
-}
-/**
- * Build a scene context from an allowed intent and runtime mode.
- *
- * Mode comes from the actual runtime context (active/quiet/maintenance_only/paused_for_interrupt),
- * not hardcoded.
- */
-function buildSceneContext(intent, mode) {
-    return {
-        sceneType: intentKindToScene(intent.kind) ?? "explain",
-        mode,
-        sceneSummary: intent.summary,
-    };
-}
-/**
- * Request guidance for a selected intent.
- *
- * Guidance is only requested when:
- * - The intent kind maps to a generative scene (social, outreach, explain)
- * - Maintenance, reflection, and work do not request guidance
- *
- * The guidance payload is used for context assembly within control-plane.
- * It does NOT cross the connector execution boundary.
- */
-export async function requestGuidanceForIntent(intent, mode, deps) {
-    const sceneType = intentKindToScene(intent.kind);
-    if (!sceneType) {
-        // Non-generative intents don't request guidance
-        return { intent };
-    }
-    const sceneContext = buildSceneContext(intent, mode);
-    const guidanceResult = await deps.requestGuidance({ sceneContext });
-    const appliedContext = deps.applyGuidance(guidanceResult.guidance);
-    return {
-        intent,
-        guidanceResult,
-        appliedContext,
-    };
-}
-/**
- * Dispatch effects for an allowed intent.
- *
- * This function enforces the allow-only boundary:
- * - Only called when guard verdict is "allow"
- * - Creates a decision context and dispatches through EffectDispatcher
- * - Guidance context stays within control-plane and is NOT passed to connector executor
- *
- * The connector executor receives the original intent payload without any
- * guidance-derived fields. Guidance participates in control-plane context
- * assembly but does not leak into the connector execution boundary.
- */
-export async function dispatchAllowedEffect(intent, deps) {
-    const dispatcher = new EffectDispatcher(deps.leaseManager, deps.commitPort, deps.connectorExecutor, deps.checkpointPort, deps.memoryPort, deps.reflectionPort);
-    const decisionContext = buildDecisionContext({
-        tickId: `tick:${Date.now()}`,
-        intentId: intent.id,
-    });
-    // Dispatch with the original intent payload.
-    // Guidance context (if any) remains within control-plane boundary
-    // and is NOT embedded in the connector payload.
-    return dispatcher.dispatchEffect(intent, decisionContext);
-}
-/**
- * Full heartbeat execution: guidance bridge + allow-only effect dispatch.
- *
- * Flow:
- * 1. Check guard verdict — non-allow paths skip guidance entirely
- * 2. For allow verdict: request guidance (if generative scene), then dispatch effect
- * 3. Return execution result with guidance and dispatch info
- *
- * Per T2.2.2 boundaries:
- * - Guidance is NOT requested for deny/defer verdicts
- * - Guidance payload does NOT cross into connector execution boundary
- * - External effects only occur under allow verdict
- */
-export async function executeHeartbeatCycle(intent, guardVerdict, mode, deps) {
-    // Non-allow verdicts: skip guidance entirely, no effect dispatch
-    if (guardVerdict !== "allow") {
-        return {
-            decisionId: `decision:${intent.id}:${Date.now()}`,
-            intentId: intent.id,
-            guardVerdict,
-        };
-    }
-    // Allow verdict: request guidance for generative scenes, then dispatch
-    const guidance = await requestGuidanceForIntent(intent, mode, deps.guidance);
-    const dispatch = await dispatchAllowedEffect(intent, deps.effects);
-    return {
-        decisionId: `decision:${intent.id}:${Date.now()}`,
-        intentId: intent.id,
-        guardVerdict,
-        guidance,
-        dispatch,
-    };
-}
+import { EffectDispatcher, buildDecisionContext } from "../orchestrator/effect-dispatcher.js";
+/**
+ * Map an intent kind to its guidance scene type.
+ * Only generative scenes (social, outreach, explain) request guidance.
+ * Maintenance, reflection, and work do not request guidance.
+ */
+function intentKindToScene(kind) {
+    switch (kind) {
+        case "social":
+            return "social";
+        case "outreach":
+            return "outreach";
+        case "exploration":
+            return "explain";
+        case "quiet":
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Build a scene context from an allowed intent and runtime mode.
+ *
+ * Mode comes from the actual runtime context (active/quiet/maintenance_only/paused_for_interrupt),
+ * not hardcoded.
+ */
+function buildSceneContext(intent, mode) {
+    return {
+        sceneType: intentKindToScene(intent.kind) ?? "explain",
+        mode,
+        sceneSummary: intent.summary,
+    };
+}
+/**
+ * Request guidance for a selected intent.
+ *
+ * Guidance is only requested when:
+ * - The intent kind maps to a generative scene (social, outreach, explain)
+ * - Maintenance, reflection, and work do not request guidance
+ *
+ * The guidance payload is used for context assembly within control-plane.
+ * It does NOT cross the connector execution boundary.
+ */
+export async function requestGuidanceForIntent(intent, mode, deps) {
+    const sceneType = intentKindToScene(intent.kind);
+    if (!sceneType) {
+        // Non-generative intents don't request guidance
+        return { intent };
+    }
+    const sceneContext = buildSceneContext(intent, mode);
+    const guidanceResult = await deps.requestGuidance({ sceneContext });
+    const appliedContext = deps.applyGuidance(guidanceResult.guidance);
+    return {
+        intent,
+        guidanceResult,
+        appliedContext,
+    };
+}
+/**
+ * Dispatch effects for an allowed intent.
+ *
+ * This function enforces the allow-only boundary:
+ * - Only called when guard verdict is "allow"
+ * - Creates a decision context and dispatches through EffectDispatcher
+ * - Guidance context stays within control-plane and is NOT passed to connector executor
+ *
+ * The connector executor receives the original intent payload without any
+ * guidance-derived fields. Guidance participates in control-plane context
+ * assembly but does not leak into the connector execution boundary.
+ */
+export async function dispatchAllowedEffect(intent, deps) {
+    const dispatcher = new EffectDispatcher(deps.leaseManager, deps.commitPort, deps.connectorExecutor, deps.checkpointPort, deps.memoryPort, deps.reflectionPort);
+    const decisionContext = buildDecisionContext({
+        tickId: `tick:${Date.now()}`,
+        intentId: intent.id,
+    });
+    // Dispatch with the original intent payload.
+    // Guidance context (if any) remains within control-plane boundary
+    // and is NOT embedded in the connector payload.
+    return dispatcher.dispatchEffect(intent, decisionContext);
+}
+/**
+ * Full heartbeat execution: guidance bridge + allow-only effect dispatch.
+ *
+ * Flow:
+ * 1. Check guard verdict — non-allow paths skip guidance entirely
+ * 2. For allow verdict: request guidance (if generative scene), then dispatch effect
+ * 3. Return execution result with guidance and dispatch info
+ *
+ * Per T2.2.2 boundaries:
+ * - Guidance is NOT requested for deny/defer verdicts
+ * - Guidance payload does NOT cross into connector execution boundary
+ * - External effects only occur under allow verdict
+ */
+export async function executeHeartbeatCycle(intent, guardVerdict, mode, deps) {
+    // Non-allow verdicts: skip guidance entirely, no effect dispatch
+    if (guardVerdict !== "allow") {
+        return {
+            decisionId: `decision:${intent.id}:${Date.now()}`,
+            intentId: intent.id,
+            guardVerdict,
+        };
+    }
+    // Allow verdict: request guidance for generative scenes, then dispatch
+    const guidance = await requestGuidanceForIntent(intent, mode, deps.guidance);
+    const dispatch = await dispatchAllowedEffect(intent, deps.effects);
+    return {
+        decisionId: `decision:${intent.id}:${Date.now()}`,
+        intentId: intent.id,
+        guardVerdict,
+        guidance,
+        dispatch,
+    };
+}