@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/control-plane/effect-dispatcher.test.js

@@ -0,0 +1,157 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EffectDispatcher, LeaseManager, buildDecisionContext } from "../../../src/core/second-nature/index.js";
+test("effect dispatcher wires state-owned commit protocol and lease for external effects", async () => {
+    const calls = [];
+    const dispatcher = new EffectDispatcher(new LeaseManager(), {
+        async createIntentCommitRecord(input) {
+            calls.push(`create:${input.state}`);
+            return { id: "commit-1" };
+        },
+        async advanceIntentCommitState(_id, state) {
+            calls.push(`advance:${state}`);
+        },
+        async commitIntentOutcome(_id, outcome) {
+            calls.push(`commit:${outcome.outcomeRef}`);
+        },
+        async abortIntentCommit(_id, reason) {
+            calls.push(`abort:${reason}`);
+        },
+    }, {
+        async executeEffect() {
+            return {
+                status: "success",
+                metadata: {
+                    platformId: "instreet",
+                    channel: "api_rest",
+                    latencyMs: 1,
+                },
+                data: { ok: true },
+            };
+        },
+    }, {
+        async saveCheckpoint(input) {
+            calls.push(`checkpoint:${input.phase}`);
+        },
+    }, {
+        async persistCurationResult() {
+            calls.push("curation");
+        },
+    }, {
+        async runNarrativeReflection() {
+            calls.push("reflection");
+            return { outcomeRef: "reflection-artifact" };
+        },
+    });
+    const intent = {
+        id: "intent-1",
+        kind: "social",
+        summary: "reply",
+        effectClass: "external_platform_action",
+        platformId: "instreet",
+        payload: { text: "hello" },
+    };
+    const context = buildDecisionContext({ tickId: "tick-1", intentId: "intent-1", decisionId: "decision-1" });
+    const result = await dispatcher.dispatchEffect(intent, context);
+    assert.equal(result.status, "effect_executed");
+    assert.deepEqual(calls, [
+        "checkpoint:before_effect",
+        "create:planned",
+        "advance:dispatched",
+        "advance:externally_acknowledged",
+        "commit:instreet",
+    ]);
+});
+test("effect dispatcher keeps lease/checkpoint scoped by effect class", async () => {
+    const calls = [];
+    const dispatcher = new EffectDispatcher(new LeaseManager(), {
+        async createIntentCommitRecord() {
+            return { id: "commit-2" };
+        },
+        async advanceIntentCommitState(_id, state) {
+            calls.push(`advance:${state}`);
+        },
+        async commitIntentOutcome() {
+            calls.push("commit");
+        },
+        async abortIntentCommit() {
+            calls.push("abort");
+        },
+    }, {
+        async executeEffect() {
+            throw new Error("should_not_execute_for_maintenance");
+        },
+    }, {
+        async saveCheckpoint() {
+            calls.push("checkpoint");
+        },
+    }, {
+        async persistCurationResult() {
+            calls.push("curation");
+        },
+    }, {
+        async runNarrativeReflection() {
+            return { outcomeRef: "reflection-artifact" };
+        },
+    });
+    const maintenance = {
+        id: "intent-maint",
+        kind: "maintenance",
+        summary: "housekeeping",
+        effectClass: "maintenance",
+    };
+    const context = buildDecisionContext({ tickId: "tick-2", intentId: "intent-maint", decisionId: "decision-2" });
+    const result = await dispatcher.dispatchEffect(maintenance, context);
+    assert.equal(result.status, "maintenance_done");
+    assert.deepEqual(calls, ["advance:dispatched", "commit"]);
+});
+test("effect dispatcher advances non-external effects through dispatched before committed", async () => {
+    const calls = [];
+    const dispatcher = new EffectDispatcher(new LeaseManager(), {
+        async createIntentCommitRecord() {
+            calls.push("create:planned");
+            return { id: "commit-3" };
+        },
+        async advanceIntentCommitState(_id, state) {
+            calls.push(`advance:${state}`);
+        },
+        async commitIntentOutcome() {
+            calls.push("commit");
+        },
+        async abortIntentCommit() {
+            calls.push("abort");
+        },
+    }, {
+        async executeEffect() {
+            throw new Error("should_not_execute_for_reflection");
+        },
+    }, {
+        async saveCheckpoint(input) {
+            calls.push(`checkpoint:${input.phase}`);
+        },
+    }, {
+        async persistCurationResult() {
+            calls.push("curation");
+        },
+    }, {
+        async runNarrativeReflection() {
+            calls.push("reflection");
+            return { outcomeRef: "reflection-artifact" };
+        },
+    });
+    const reflectionIntent = {
+        id: "intent-reflect",
+        kind: "reflection",
+        summary: "reflect",
+        effectClass: "narrative_reflection",
+    };
+    const result = await dispatcher.dispatchEffect(reflectionIntent, buildDecisionContext({ tickId: "tick-3", intentId: "intent-reflect", decisionId: "decision-3" }));
+    assert.equal(result.status, "reflected");
+    assert.deepEqual(calls, [
+        "checkpoint:before_quiet_write",
+        "create:planned",
+        "advance:dispatched",
+        "reflection",
+        "commit",
+    ]);
+});

package/dist/tests/integration/control-plane/guidance-request.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/integration/control-plane/guidance-request.test.js

@@ -0,0 +1,63 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { requestGuidance } from "../../../src/core/second-nature/guidance/request-guidance.js";
+import { applyGuidance } from "../../../src/core/second-nature/guidance/apply-guidance.js";
+test("control-plane remains the unique guidance request owner and applies payload context", async () => {
+    const result = await requestGuidance({
+        sceneContext: {
+            sceneType: "reply",
+            mode: "active",
+            riskLevel: "low",
+        },
+        personaCandidates: [],
+        port: {
+            async assembleGuidance() {
+                return {
+                    scene: {
+                        sceneType: "reply",
+                        mode: "active",
+                        riskLevel: "low",
+                    },
+                    atmosphere: {
+                        kind: "atmosphere",
+                        text: "atm",
+                        openness: "open",
+                        pressureLabels: ["active"],
+                        reviewStatus: "pending_human_review",
+                    },
+                    impulses: [{ kind: "reply", text: "impulse", reviewStatus: "pending_human_review" }],
+                    personaReinforcement: [],
+                    outputGuard: { kind: "output_guard", constraints: ["c1"], hardGuardPriority: true },
+                };
+            },
+        },
+    });
+    assert.equal(result.owner, "control-plane-system");
+    assert.equal(result.usedFallback, false);
+    const applied = applyGuidance(result.guidance);
+    assert.equal(applied.source, "guidance_payload");
+    assert.equal(applied.sceneType, "reply");
+});
+test("control-plane request falls back to minimal guidance when guidance is unavailable", async () => {
+    const result = await requestGuidance({
+        sceneContext: {
+            sceneType: "quiet",
+            mode: "quiet",
+            riskLevel: "medium",
+        },
+        personaCandidates: [],
+        port: {
+            async assembleGuidance() {
+                return {
+                    available: false,
+                    reason: "missing_template",
+                };
+            },
+        },
+    });
+    assert.equal(result.owner, "control-plane-system");
+    assert.equal(result.usedFallback, true);
+    const applied = applyGuidance(result.guidance);
+    assert.equal(applied.source, "minimal_fallback");
+    assert.equal(applied.sceneType, "quiet");
+});

package/dist/tests/integration/control-plane/heartbeat-executor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/integration/control-plane/heartbeat-executor.test.js

@@ -0,0 +1,363 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { executeHeartbeatCycle, } from "../../../src/core/second-nature/heartbeat/index.js";
+// ─── Mock helpers ─────────────────────────────────────────────────────────────
+function createMockGuidanceDeps(override) {
+    const mockGuidancePayload = {
+        scene: { sceneType: "social", mode: "active" },
+        impulses: [{ kind: "social", text: "Be friendly", reviewStatus: "approved" }],
+        personaReinforcement: [],
+        outputGuard: { kind: "output_guard", constraints: ["no-customer-service"], hardGuardPriority: true },
+    };
+    const mockAppliedContext = {
+        source: "guidance_payload",
+        sceneType: "social",
+        impulseTexts: ["Be friendly"],
+        personaRationales: [],
+        outputConstraints: ["no-customer-service"],
+        expressionConstraints: ["no-customer-service"],
+    };
+    return {
+        requestGuidance: async (input) => ({
+            owner: "control-plane-system",
+            sceneContext: input.sceneContext,
+            guidance: mockGuidancePayload,
+            usedFallback: false,
+        }),
+        applyGuidance: (_input) => mockAppliedContext,
+        ...override,
+    };
+}
+function createMockEffectDeps(override) {
+    const mockConnectorResult = {
+        status: "success",
+        metadata: { platformId: "mock", channel: "api_rest", latencyMs: 0 },
+    };
+    return {
+        leaseManager: {
+            acquire: async () => ({ granted: true, release: async () => { } }),
+        },
+        commitPort: {
+            createIntentCommitRecord: async () => ({ id: "commit-1" }),
+            advanceIntentCommitState: async () => { },
+            commitIntentOutcome: async () => { },
+            abortIntentCommit: async () => { },
+        },
+        connectorExecutor: {
+            executeEffect: async () => mockConnectorResult,
+        },
+        checkpointPort: {
+            saveCheckpoint: async () => { },
+        },
+        memoryPort: {
+            persistCurationResult: async () => { },
+        },
+        reflectionPort: {
+            runNarrativeReflection: async () => ({ outcomeRef: "reflection-1" }),
+        },
+        ...override,
+    };
+}
+function createAllowedIntent(kind) {
+    return {
+        id: `intent-${kind}`,
+        kind,
+        summary: `Test ${kind} intent`,
+        effectClass: kind === "social" ? "external_platform_action" : kind === "outreach" ? "user_outreach" : "maintenance",
+    };
+}
+// ─── T2.2.2: Guidance Bridge Tests ──────────────────────────────────────────
+test("T2.2.2 deny verdict: guidance is NOT requested", async () => {
+    let guidanceRequested = false;
+    const guidanceDeps = {
+        requestGuidance: async () => {
+            guidanceRequested = true;
+            throw new Error("Guidance should not be requested for deny verdict");
+        },
+        applyGuidance: () => {
+            throw new Error("applyGuidance should not be called for deny verdict");
+        },
+    };
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("social");
+    const result = await executeHeartbeatCycle(intent, "deny", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(guidanceRequested, false, "guidance should NOT be requested for deny verdict");
+    assert.equal(result.guardVerdict, "deny");
+    assert.equal(result.dispatch, undefined, "no dispatch for deny verdict");
+    assert.equal(result.guidance, undefined, "no guidance for deny verdict");
+});
+test("T2.2.2 defer verdict: guidance is NOT requested", async () => {
+    let guidanceRequested = false;
+    const guidanceDeps = {
+        requestGuidance: async () => {
+            guidanceRequested = true;
+            throw new Error("Guidance should not be requested for defer verdict");
+        },
+        applyGuidance: () => {
+            throw new Error("applyGuidance should not be called for defer verdict");
+        },
+    };
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("social");
+    const result = await executeHeartbeatCycle(intent, "defer", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(guidanceRequested, false, "guidance should NOT be requested for defer verdict");
+    assert.equal(result.guardVerdict, "defer");
+    assert.equal(result.dispatch, undefined, "no dispatch for defer verdict");
+    assert.equal(result.guidance, undefined, "no guidance for defer verdict");
+});
+test("T2.2.2 allow verdict: guidance is requested for generative scene (social)", async () => {
+    let guidanceRequested = false;
+    let requestedSceneType;
+    let requestedMode;
+    const guidanceDeps = {
+        requestGuidance: async (input) => {
+            guidanceRequested = true;
+            requestedSceneType = input.sceneContext.sceneType;
+            requestedMode = input.sceneContext.mode;
+            return {
+                owner: "control-plane-system",
+                sceneContext: input.sceneContext,
+                guidance: {
+                    scene: input.sceneContext,
+                    impulses: [],
+                    personaReinforcement: [],
+                    outputGuard: { kind: "output_guard", constraints: [], hardGuardPriority: true },
+                },
+                usedFallback: false,
+            };
+        },
+        applyGuidance: () => ({
+            source: "guidance_payload",
+            sceneType: "social",
+            impulseTexts: [],
+            personaRationales: [],
+            outputConstraints: [],
+            expressionConstraints: [],
+        }),
+    };
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("social");
+    const result = await executeHeartbeatCycle(intent, "allow", "quiet", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(guidanceRequested, true, "guidance should be requested for allow verdict");
+    assert.equal(requestedSceneType, "social");
+    assert.equal(requestedMode, "quiet", "mode should come from runtime context, not hardcoded");
+    assert.ok(result.guidance, "guidance result should be present");
+    assert.ok(result.dispatch, "dispatch should occur for allow verdict");
+});
+test("T2.2.2 allow verdict: guidance is NOT requested for non-generative scene (maintenance)", async () => {
+    let guidanceRequested = false;
+    const guidanceDeps = {
+        requestGuidance: async () => {
+            guidanceRequested = true;
+            throw new Error("Guidance should not be requested for maintenance");
+        },
+        applyGuidance: () => {
+            throw new Error("applyGuidance should not be called");
+        },
+    };
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("maintenance");
+    const result = await executeHeartbeatCycle(intent, "allow", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(guidanceRequested, false, "guidance should NOT be requested for maintenance");
+    assert.ok(result.dispatch, "dispatch should still occur for allow verdict");
+});
+test("T2.2.2 allow verdict: guidance is NOT requested for reflection", async () => {
+    let guidanceRequested = false;
+    const guidanceDeps = {
+        requestGuidance: async () => {
+            guidanceRequested = true;
+            throw new Error("Guidance should not be requested for reflection");
+        },
+        applyGuidance: () => {
+            throw new Error("applyGuidance should not be called");
+        },
+    };
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("reflection");
+    const result = await executeHeartbeatCycle(intent, "allow", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(guidanceRequested, false, "guidance should NOT be requested for reflection");
+    assert.ok(result.dispatch, "dispatch should still occur for allow verdict");
+});
+test("T2.2.2 connector executor receives payload without any guidance-derived fields", async () => {
+    let connectorPayload;
+    const mockResult = {
+        status: "success",
+        metadata: { platformId: "mock", channel: "api_rest", latencyMs: 0 },
+    };
+    const effectDeps = {
+        ...createMockEffectDeps(),
+        connectorExecutor: {
+            executeEffect: async (input) => {
+                connectorPayload = input.payload;
+                return mockResult;
+            },
+        },
+    };
+    const guidanceDeps = createMockGuidanceDeps();
+    const intent = createAllowedIntent("social");
+    await executeHeartbeatCycle(intent, "allow", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.ok(connectorPayload, "connector received a payload");
+    // No guidance-derived private context should leak into connector payload
+    assert.ok(!("_guidanceContext" in (connectorPayload || {})), "no _guidanceContext in connector payload");
+    assert.ok(!("_guidancePayload" in (connectorPayload || {})), "no _guidancePayload in connector payload");
+    assert.ok(!("guidance" in (connectorPayload || {})), "no guidance field in connector payload");
+});
+test("T2.2.2 sceneContext.mode comes from real runtime input, not hardcoded", async () => {
+    let receivedMode;
+    const guidanceDeps = {
+        requestGuidance: async (input) => {
+            receivedMode = input.sceneContext.mode;
+            return {
+                owner: "control-plane-system",
+                sceneContext: input.sceneContext,
+                guidance: {
+                    scene: input.sceneContext,
+                    impulses: [],
+                    personaReinforcement: [],
+                    outputGuard: { kind: "output_guard", constraints: [], hardGuardPriority: true },
+                },
+                usedFallback: false,
+            };
+        },
+        applyGuidance: () => ({
+            source: "guidance_payload",
+            sceneType: "social",
+            impulseTexts: [],
+            personaRationales: [],
+            outputConstraints: [],
+            expressionConstraints: [],
+        }),
+    };
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("social");
+    // Test with quiet mode
+    await executeHeartbeatCycle(intent, "allow", "quiet", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(receivedMode, "quiet", "mode should be quiet when passed as quiet");
+    // Test with maintenance_only mode
+    await executeHeartbeatCycle(intent, "allow", "maintenance_only", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(receivedMode, "maintenance_only", "mode should be maintenance_only when passed as such");
+});
+test("T2.2.2 outreach generative scene requests guidance", async () => {
+    let guidanceRequested = false;
+    let requestedSceneType;
+    const guidanceDeps = {
+        requestGuidance: async (input) => {
+            guidanceRequested = true;
+            requestedSceneType = input.sceneContext.sceneType;
+            return {
+                owner: "control-plane-system",
+                sceneContext: input.sceneContext,
+                guidance: {
+                    scene: input.sceneContext,
+                    impulses: [],
+                    personaReinforcement: [],
+                    outputGuard: { kind: "output_guard", constraints: [], hardGuardPriority: true },
+                },
+                usedFallback: false,
+            };
+        },
+        applyGuidance: () => ({
+            source: "guidance_payload",
+            sceneType: "outreach",
+            impulseTexts: [],
+            personaRationales: [],
+            outputConstraints: [],
+            expressionConstraints: [],
+        }),
+    };
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("outreach");
+    const result = await executeHeartbeatCycle(intent, "allow", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(guidanceRequested, true, "guidance should be requested for outreach");
+    assert.equal(requestedSceneType, "outreach");
+    assert.ok(result.guidance, "guidance result should be present");
+});
+test("T2.2.2 exploration generative scene requests guidance", async () => {
+    let guidanceRequested = false;
+    let requestedSceneType;
+    const guidanceDeps = {
+        requestGuidance: async (input) => {
+            guidanceRequested = true;
+            requestedSceneType = input.sceneContext.sceneType;
+            return {
+                owner: "control-plane-system",
+                sceneContext: input.sceneContext,
+                guidance: {
+                    scene: input.sceneContext,
+                    impulses: [],
+                    personaReinforcement: [],
+                    outputGuard: { kind: "output_guard", constraints: [], hardGuardPriority: true },
+                },
+                usedFallback: false,
+            };
+        },
+        applyGuidance: () => ({
+            source: "guidance_payload",
+            sceneType: "explain",
+            impulseTexts: [],
+            personaRationales: [],
+            outputConstraints: [],
+            expressionConstraints: [],
+        }),
+    };
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("exploration");
+    const result = await executeHeartbeatCycle(intent, "allow", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(guidanceRequested, true, "guidance should be requested for exploration");
+    assert.equal(requestedSceneType, "explain");
+    assert.ok(result.guidance, "guidance result should be present");
+});
+test("T2.2.2 maintenance non-generative path dispatches without guidance", async () => {
+    const guidanceDeps = createMockGuidanceDeps();
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("maintenance");
+    const result = await executeHeartbeatCycle(intent, "allow", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(result.guardVerdict, "allow");
+    assert.ok(result.dispatch, "dispatch should occur for allow verdict");
+    assert.equal(result.guidance?.guidanceResult, undefined, "no guidance for maintenance");
+});
+test("T2.2.2 reflection non-generative path dispatches without guidance", async () => {
+    const guidanceDeps = createMockGuidanceDeps();
+    const effectDeps = createMockEffectDeps();
+    const intent = createAllowedIntent("reflection");
+    const result = await executeHeartbeatCycle(intent, "allow", "active", {
+        guidance: guidanceDeps,
+        effects: effectDeps,
+    });
+    assert.equal(result.guardVerdict, "allow");
+    assert.ok(result.dispatch, "dispatch should occur for allow verdict");
+    assert.equal(result.guidance?.guidanceResult, undefined, "no guidance for reflection");
+});

package/dist/tests/integration/control-plane/heartbeat-loop.test.d.ts

@@ -0,0 +1 @@
+export {};