@haaaiawd/second-nature 0.1.50 → 0.2.0

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

@@ -1,157 +0,0 @@
-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

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

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

@@ -1,63 +0,0 @@
-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

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

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

@@ -1,363 +0,0 @@
-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

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