@haaaiawd/second-nature 0.1.50 → 0.1.51

package/dist/tests/integration/s3-exit/int-s3-body-heartbeat.test.d.ts

@@ -1,15 +0,0 @@
-/**
- * INT-S3 — S3 Body Tool + Heartbeat 集成冒烟测试
- *
- * Exit criteria verification:
- * 1. Affordance map correctly filters 5 status classes (safe, exploratory,
- *    unavailable, needs_auth, blocked/pending_trust) in heartbeat flow.
- * 2. Heartbeat assembles EmbodiedContext with 5 state-memory slices
- *    (identity, goals, recentInteractions, toolExperience, acceptedDream).
- * 3. CircuitBreaker cooldown / halfopen / closed states are observable
- *    and affect heartbeat guard evaluation.
- * 4. IdleCuriosityPolicy selects read-only intents only; no side-effect.
- *
- * Evidence: reports/int-s3-body-heartbeat-v7.md
- */
-export {};

package/dist/tests/integration/s3-exit/int-s3-body-heartbeat.test.js

@@ -1,462 +0,0 @@
-/**
- * INT-S3 — S3 Body Tool + Heartbeat 集成冒烟测试
- *
- * Exit criteria verification:
- * 1. Affordance map correctly filters 5 status classes (safe, exploratory,
- *    unavailable, needs_auth, blocked/pending_trust) in heartbeat flow.
- * 2. Heartbeat assembles EmbodiedContext with 5 state-memory slices
- *    (identity, goals, recentInteractions, toolExperience, acceptedDream).
- * 3. CircuitBreaker cooldown / halfopen / closed states are observable
- *    and affect heartbeat guard evaluation.
- * 4. IdleCuriosityPolicy selects read-only intents only; no side-effect.
- *
- * Evidence: reports/int-s3-body-heartbeat-v7.md
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { createGoalLifecycleStore } from "../../../src/storage/services/goal-lifecycle-store.js";
-import { createIdentityProfileStore } from "../../../src/storage/services/identity-profile-store.js";
-import { createInteractionSnapshotProjector } from "../../../src/storage/services/interaction-snapshot-projector.js";
-import { createToolExperienceStore } from "../../../src/storage/services/tool-experience-store.js";
-import { createEmbodiedContextStatePort } from "../../../src/storage/services/embodied-context-state-port.js";
-import { createEmbodiedContextAssembler } from "../../../src/core/second-nature/heartbeat/embodied-context-assembler.js";
-import { createAffordanceAssembler } from "../../../src/core/second-nature/body/tool-affordance/affordance-assembler.js";
-import { createCircuitBreakerManager } from "../../../src/core/second-nature/body/circuit-breaker/circuit-breaker-manager.js";
-import { createIdleCuriosityPolicy } from "../../../src/core/second-nature/heartbeat/idle-curiosity-policy.js";
-import { evaluateHardGuards } from "../../../src/core/second-nature/orchestrator/hard-guard-evaluator.js";
-import { CapabilityContractRegistryV7 } from "../../../src/connectors/base/manifest-v7.js";
-describe("INT-S3: S3 Body Tool + Heartbeat integration smoke", () => {
-    // ── Shared fixtures ─────────────────────────────────────────
-    function buildRegistry() {
-        const reg = new CapabilityContractRegistryV7();
-        reg.register({
-            platformId: "moltbook",
-            capabilities: [
-                {
-                    capabilityId: "feed-read",
-                    intent: "feed.read",
-                    probeConfig: {
-                        safeEndpoint: "http://localhost:9100/feed",
-                        idempotencyClass: "read_only",
-                    },
-                },
-                {
-                    capabilityId: "post-publish",
-                    intent: "post.publish",
-                    probeConfig: {
-                        safeEndpoint: "http://localhost:9100/post",
-                        idempotencyClass: "idempotent_write",
-                    },
-                },
-                {
-                    capabilityId: "msg-send",
-                    intent: "message.send",
-                    probeConfig: {
-                        safeEndpoint: "http://localhost:9100/msg",
-                        idempotencyClass: "idempotent_write",
-                    },
-                },
-                {
-                    capabilityId: "notify-list",
-                    intent: "notification.list",
-                    probeConfig: {
-                        safeEndpoint: "http://localhost:9100/notify",
-                        idempotencyClass: "read_only",
-                    },
-                },
-            ],
-            channelPriority: ["api_rest"],
-            credentialTypes: ["token"],
-        });
-        reg.register({
-            platformId: "instreet",
-            capabilities: [
-                {
-                    capabilityId: "discover",
-                    intent: "work.discover",
-                    probeConfig: {
-                        safeEndpoint: "http://localhost:9200/discover",
-                        idempotencyClass: "read_only",
-                    },
-                },
-            ],
-            channelPriority: ["api_rest"],
-            credentialTypes: ["token"],
-        });
-        return reg;
-    }
-    function buildProbeReader(statuses) {
-        return {
-            getLatestProbeResult(platformId, capabilityId) {
-                const key = `${platformId}:${capabilityId}`;
-                const status = statuses[key];
-                if (!status)
-                    return undefined;
-                return {
-                    actualStatus: status,
-                    createdAt: new Date().toISOString(),
-                };
-            },
-        };
-    }
-    function buildBreakerAdapter(probeStatus) {
-        return {
-            async runAndRecordProbe() {
-                return {
-                    actualStatus: probeStatus,
-                    httpStatus: probeStatus === "available" ? 200 : 503,
-                    recorded: true,
-                    experienceRecorded: false,
-                };
-            },
-        };
-    }
-    function buildBaseDeps() {
-        const db = createStateDatabase(":memory:");
-        const goalStore = createGoalLifecycleStore(db);
-        const identityStore = createIdentityProfileStore(db);
-        const projector = createInteractionSnapshotProjector(db);
-        const experienceStore = createToolExperienceStore(db);
-        const statePort = createEmbodiedContextStatePort({
-            database: db,
-            goalStore,
-            identityStore,
-            interactionProjector: projector,
-            experienceStore,
-        });
-        return { db, statePort, goalStore, identityStore, projector, experienceStore };
-    }
-    // ── C1: Affordance 5-status filtering ───────────────────────
-    it("affordance map reflects all 5 status classes from probe results", async () => {
-        const registry = buildRegistry();
-        // Map probes to 5 distinct statuses:
-        // safe (available), exploratory (degraded), unavailable (unavailable),
-        // needs_auth (no probe + cred required), blocked by scope
-        const probeReader = buildProbeReader({
-            "moltbook:feed-read": "available",
-            "moltbook:post-publish": "degraded",
-            "moltbook:msg-send": "unavailable",
-            // notify-list: no probe → needs_auth (credentialRequired=true)
-            "instreet:discover": "available",
-        });
-        const assembler = createAffordanceAssembler({
-            registry,
-            probeReader,
-            credentialRequired: () => true,
-        });
-        // Use explicit scope to include all statuses (BLOCKED_STATUSES filters unavailable
-        // at the scope layer, so verify status mapping at the assembler level by
-        // reading the raw map before scope filtering)
-        const rawMap = await assembler.assembleAffordanceMap({
-            allowedStatuses: ["safe", "exploratory", "needs_auth"],
-        });
-        // safe
-        const safeItems = Object.values(rawMap).flat().filter((i) => i.status === "safe");
-        assert.ok(safeItems.length >= 1, "expected at least one safe affordance");
-        // exploratory
-        const expItems = Object.values(rawMap).flat().filter((i) => i.status === "exploratory");
-        assert.strictEqual(expItems.length, 1);
-        assert.strictEqual(expItems[0].capabilityId, "post-publish");
-        // needs_auth (no probe + credential required)
-        const needsAuthItems = Object.values(rawMap).flat().filter((i) => i.status === "needs_auth");
-        assert.strictEqual(needsAuthItems.length, 1);
-        assert.strictEqual(needsAuthItems[0].capabilityId, "notify-list");
-        // Verify default heartbeat scope includes needs_auth (cbe3b06: heartbeat-usable statuses)
-        const defaultMap = await assembler.assembleAffordanceMap();
-        const defaultItems = Object.values(defaultMap).flat();
-        assert.strictEqual(defaultItems.some((i) => i.status === "needs_auth"), true);
-        // Verify unavailable is mapped correctly at assembler level (even if scope filters it)
-        // Build raw map manually using the same logic as the assembler
-        const rawStatuses = {};
-        for (const platformId of registry.listRegisteredPlatformIds()) {
-            for (const cap of registry.listCapabilities(platformId)) {
-                const probe = probeReader.getLatestProbeResult(platformId, cap.capabilityId);
-                if (probe) {
-                    rawStatuses[cap.capabilityId] = probe.actualStatus === "available" ? "safe" : probe.actualStatus === "degraded" ? "exploratory" : "unavailable";
-                }
-                else {
-                    rawStatuses[cap.capabilityId] = "needs_auth";
-                }
-            }
-        }
-        assert.strictEqual(rawStatuses["msg-send"], "unavailable");
-        assert.strictEqual(rawStatuses["notify-list"], "needs_auth");
-        assert.strictEqual(rawStatuses["feed-read"], "safe");
-        assert.strictEqual(rawStatuses["post-publish"], "exploratory");
-    });
-    it("default heartbeat scope excludes unavailable and blocked statuses", async () => {
-        const { statePort } = buildBaseDeps();
-        const registry = buildRegistry();
-        const probeReader = buildProbeReader({
-            "moltbook:feed-read": "available",
-            "moltbook:post-publish": "degraded",
-            "moltbook:msg-send": "unavailable",
-        });
-        const assembler = createAffordanceAssembler({
-            registry,
-            probeReader,
-            credentialRequired: () => false, // no cred required, so no probe → unavailable
-        });
-        const ctxAssembler = createEmbodiedContextAssembler({
-            statePort,
-            affordanceAssembler: assembler,
-        });
-        const ctx = await ctxAssembler.assembleEmbodiedContext();
-        const map = ctx.affordanceMap.data;
-        const items = Object.values(map).flat();
-        // Default scope only allows safe + exploratory
-        assert.ok(items.every((i) => i.status === "safe" || i.status === "exploratory"));
-        assert.strictEqual(items.some((i) => i.capabilityId === "msg-send"), false);
-    });
-    // ── C2: EmbodiedContext 5-slice assembly ─────────────────────
-    it("heartbeat assembles all 5 state-memory slices with loaded status", async () => {
-        const { db, statePort, goalStore, identityStore, projector, experienceStore } = buildBaseDeps();
-        const registry = buildRegistry();
-        // Seed data for all 5 slices
-        await identityStore.upsertIdentityProfile({
-            profileId: "default",
-            canonicalName: "Smoke Agent",
-            platformHandles: [{ platformId: "moltbook", handle: "@smoke" }],
-            updatedAt: new Date().toISOString(),
-        });
-        await goalStore.upsertAgentGoal({
-            goalId: "g-1",
-            kind: "short_term",
-            scope: "global",
-            description: "test goal",
-            status: "accepted",
-            origin: "owner_set",
-            completionCriteria: "done",
-            risk: "low",
-            priorityHint: 1,
-            sourceRefs: ["ref-1"],
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        });
-        db.sqlite.run(`INSERT INTO session_chronicle (entry_id, event_kind, actor, occurred_at, summary, result, source_refs_json)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`, ["i-1", "interaction", "user", new Date().toISOString(), "test mention", "ok", "[]"]);
-        await experienceStore.appendToolExperience({
-            experienceId: "e-1",
-            connectorId: "moltbook",
-            capabilityId: "feed-read",
-            outcome: "success",
-            latencyMs: 100,
-            evidenceQuality: 1,
-            sourceRefs: ["test:exp"],
-            triggerSource: "heartbeat",
-            createdAt: new Date().toISOString(),
-        });
-        const assembler = createAffordanceAssembler({
-            registry,
-            probeReader: buildProbeReader({ "moltbook:feed-read": "available" }),
-            credentialRequired: () => true,
-        });
-        const ctxAssembler = createEmbodiedContextAssembler({
-            statePort,
-            affordanceAssembler: assembler,
-        });
-        const ctx = await ctxAssembler.assembleEmbodiedContext();
-        // Identity: degraded because expectedPlatforms includes moltbook+agent_world+instreet
-        // Only moltbook seeded → degraded (ADR-007)
-        assert.ok(ctx.identity.status === "loaded" || ctx.identity.status === "degraded");
-        if (ctx.identity.status === "loaded") {
-            assert.strictEqual(ctx.identity.data.canonicalName, "Smoke Agent");
-        }
-        assert.strictEqual(ctx.goals.status, "loaded");
-        assert.strictEqual(ctx.goals.data.length, 1);
-        assert.strictEqual(ctx.goals.data[0].goalId, "g-1");
-        assert.strictEqual(ctx.recentInteractions.status, "loaded");
-        assert.strictEqual(ctx.recentInteractions.data.length, 1);
-        assert.strictEqual(ctx.toolExperience.status, "loaded");
-        assert.strictEqual(ctx.toolExperience.data.length, 1);
-        // acceptedDream: loaded when table exists (empty array), degraded if table missing
-        assert.ok(ctx.acceptedDream.status === "loaded" || ctx.acceptedDream.status === "degraded");
-        if (ctx.acceptedDream.status === "loaded") {
-            assert.deepStrictEqual(ctx.acceptedDream.data, []);
-        }
-        assert.strictEqual(ctx.affordanceMap?.status, "loaded");
-        // Core assertion: all 5 state-memory slices are present (loaded or degraded)
-        assert.ok(ctx.identity);
-        assert.ok(ctx.goals);
-        assert.ok(ctx.recentInteractions);
-        assert.ok(ctx.toolExperience);
-        assert.ok(ctx.acceptedDream);
-    });
-    it("partial failure degrades single slice without crashing others", async () => {
-        const { db, statePort } = buildBaseDeps();
-        // Don't seed any data → identity/goals degraded (empty), but affordance loads
-        const registry = buildRegistry();
-        const assembler = createAffordanceAssembler({
-            registry,
-            probeReader: buildProbeReader({ "moltbook:feed-read": "available" }),
-            credentialRequired: () => true,
-        });
-        const ctxAssembler = createEmbodiedContextAssembler({
-            statePort,
-            affordanceAssembler: assembler,
-        });
-        const ctx = await ctxAssembler.assembleEmbodiedContext();
-        // Identity should be degraded when no profile seeded
-        assert.ok(ctx.identity.status === "degraded" || ctx.identity.status === "loaded");
-        // Goals should be loaded (empty array) or degraded
-        assert.ok(ctx.goals.status === "loaded" || ctx.goals.status === "degraded");
-        // Affordance still loads because registry + probe are fine
-        assert.strictEqual(ctx.affordanceMap?.status, "loaded");
-    });
-    // ── C3: CircuitBreaker lifecycle observable in heartbeat ────
-    it("breaker open state blocks intent execution in heartbeat guards", async () => {
-        const db = createStateDatabase(":memory:");
-        const adapter = buildBreakerAdapter("unavailable");
-        const registry = buildRegistry();
-        const breaker = createCircuitBreakerManager({
-            database: db,
-            probeAdapter: adapter,
-            registry,
-            failureThreshold: 2,
-            cooldownMs: 30_000,
-        });
-        // 2 failures → open
-        await breaker.evaluateFailure("moltbook", "feed-read");
-        await breaker.evaluateFailure("moltbook", "feed-read");
-        const state = await breaker.getState("moltbook", "feed-read");
-        assert.strictEqual(state, "open");
-        // Simulate heartbeat guard deps with breaker-aware affordance
-        // capabilityId must match intent.capabilityIntent for hard-guard-evaluator
-        const affordanceMap = {
-            moltbook: [
-                {
-                    platformId: "moltbook",
-                    capabilityId: "feed.read",
-                    intent: "feed.read",
-                    status: "safe",
-                },
-            ],
-        };
-        const guardDeps = {
-            hasDuplicateIntent: () => false,
-            isOutreachCooldownClear: () => true,
-            affordanceMap,
-        };
-        const intent = {
-            id: "intent-read",
-            kind: "work",
-            priority: 100,
-            source: "tick",
-            platformId: "moltbook",
-            summary: "read feed",
-            effectClass: "connector_action",
-            sourceRefs: [{ id: "ref-1", kind: "platform_item", uri: "uri://1" }],
-            idempotencyKey: "key-1",
-            capabilityIntent: "feed.read",
-        };
-        const evalResult = evaluateHardGuards(intent, guardDeps);
-        // affordance is safe, so guard allows; but breaker is open.
-        // The hard-guard-evaluator only checks affordanceMap, not breaker state directly.
-        // Breaker check would happen at execution layer (connector-system).
-        // For INT-S3, we verify that breaker state is *observable* and *can be checked*
-        // before execution.
-        assert.strictEqual(evalResult.verdict, "allow");
-        // Verify canExecute respects open state
-        const canExec = await breaker.canExecute("moltbook", "feed-read");
-        assert.strictEqual(canExec, false);
-    });
-    it("breaker cooldown transition to halfopen then closed via probe", async () => {
-        const db = createStateDatabase(":memory:");
-        const adapter = buildBreakerAdapter("available");
-        const registry = buildRegistry();
-        const breaker = createCircuitBreakerManager({
-            database: db,
-            probeAdapter: adapter,
-            registry,
-            failureThreshold: 1,
-            cooldownMs: 0, // immediate cooldown for test
-        });
-        // 1 failure → open (threshold=1)
-        await breaker.evaluateFailure("moltbook", "feed-read");
-        assert.strictEqual(await breaker.getState("moltbook", "feed-read"), "open");
-        // cooldownMs=0, so canExecute returns true (cooldown elapsed)
-        const canExec = await breaker.canExecute("moltbook", "feed-read");
-        assert.strictEqual(canExec, true);
-        // attemptReset → halfopen → probe success → closed
-        const resetState = await breaker.attemptReset("moltbook", "feed-read");
-        assert.strictEqual(resetState, "closed");
-        assert.strictEqual(await breaker.getState("moltbook", "feed-read"), "closed");
-    });
-    // ── C4: IdleCuriosityPolicy read-only, no side-effect ───────
-    it("idle curiosity selects only read-only intents from safe affordances", () => {
-        const policy = createIdleCuriosityPolicy();
-        const affordanceMap = {
-            moltbook: [
-                { platformId: "moltbook", capabilityId: "feed-read", intent: "feed.read", status: "safe" },
-                { platformId: "moltbook", capabilityId: "post-publish", intent: "post.publish", status: "safe" },
-                { platformId: "moltbook", capabilityId: "msg-send", intent: "message.send", status: "exploratory" },
-            ],
-            instreet: [
-                { platformId: "instreet", capabilityId: "discover", intent: "work.discover", status: "safe" },
-            ],
-        };
-        const result = policy.select(affordanceMap, []);
-        assert.ok(result.candidate, "expected a candidate to be selected");
-        assert.ok(result.candidate.intent.endsWith(".read") ||
-            result.candidate.intent.endsWith(".discover") ||
-            result.candidate.intent.endsWith(".inspect") ||
-            result.candidate.intent.endsWith(".search"), `selected intent ${result.candidate.intent} must be read-only`);
-        // post.publish and message.send are write intents → excluded
-        assert.notStrictEqual(result.candidate.intent, "post.publish");
-        assert.notStrictEqual(result.candidate.intent, "message.send");
-    });
-    it("idle curiosity returns no_eligible_connector when only write intents available", () => {
-        const policy = createIdleCuriosityPolicy();
-        const affordanceMap = {
-            moltbook: [
-                { platformId: "moltbook", capabilityId: "post-publish", intent: "post.publish", status: "safe" },
-                { platformId: "moltbook", capabilityId: "msg-send", intent: "message.send", status: "safe" },
-            ],
-        };
-        const result = policy.select(affordanceMap, []);
-        assert.strictEqual(result.candidate, undefined);
-        assert.strictEqual(result.reason, "idle_policy_no_eligible_connector");
-    });
-    it("idle curiosity respects 1-hour cooldown per platform", () => {
-        const policy = createIdleCuriosityPolicy();
-        const affordanceMap = {
-            moltbook: [
-                { platformId: "moltbook", capabilityId: "feed-read", intent: "feed.read", status: "safe" },
-            ],
-            instreet: [
-                { platformId: "instreet", capabilityId: "discover", intent: "work.discover", status: "safe" },
-            ],
-        };
-        // Recent idle history on moltbook (10 minutes ago) → cooldown active
-        const recentHistory = [
-            { platformId: "moltbook", at: new Date(Date.now() - 10 * 60 * 1000).toISOString() },
-        ];
-        const result = policy.select(affordanceMap, recentHistory);
-        // moltbook is on cooldown, so instreet:discover is selected
-        assert.ok(result.candidate);
-        assert.strictEqual(result.candidate.platformId, "instreet");
-        assert.strictEqual(result.candidate.intent, "work.discover");
-    });
-    it("idle curiosity policy does not execute any connector (pure selection)", () => {
-        const policy = createIdleCuriosityPolicy();
-        // The policy.select method takes only affordanceMap and history.
-        // It returns a descriptor, never calls any external system.
-        // This test asserts the structural guarantee: no execution side-effects.
-        const affordanceMap = {
-            moltbook: [
-                { platformId: "moltbook", capabilityId: "feed-read", intent: "feed.read", status: "safe" },
-            ],
-        };
-        const result = policy.select(affordanceMap, []);
-        assert.ok(result.candidate);
-        // Result is a plain descriptor, not an execution authorization
-        assert.deepStrictEqual(Object.keys(result.candidate), [
-            "platformId",
-            "capabilityId",
-            "intent",
-            "reason",
-        ]);
-        assert.strictEqual(result.reason, "idle_sensing_selected");
-    });
-});

package/dist/tests/integration/s5-exit/int-s5-observability.test.d.ts

@@ -1,17 +0,0 @@
-/**
- * INT-S5 — S5 Observability 集成冒烟测试
- *
- * Exit criteria verification (05A_TASKS.md INT-S5):
- *
- * 1. Audit chain integrity verifiable — AppendOnlyAuditStore per-family hash chain
- *    links correctly; chain corruption is detected and marked degraded.
- * 2. SelfHealthSnapshot covers dynamic dimensions and minimum dimension set is
- *    complete; any single probe timeout does not affect overall snapshot.
- * 3. HeartbeatDigest per-platform counts correct; nothing_significant on empty day.
- * 4. NarrativeTimeline cursor pagination normal; 90-day range enforced.
- * 5. RestoreAudit writes on every attempt; partial_restore_error records entity lists.
- * 6. RuntimeSecretAnchorView returns recoverySteps for all three reason codes.
- *
- * Evidence: reports/int-s5-observability-v7.md
- */
-export {};