@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/unit/connectors/t3-2-1-v5-parity.test.js

@@ -0,0 +1,103 @@
+/**
+ * Unit coverage for v5 connector parity fixtures (T3.2.1).
+ *
+ * Verifies that Moltbook, InStreet, and EvoMap v6 manifest fixtures
+ * preserve capability sets, family, credential types, and trust semantics
+ * from their v5 built-in connector definitions.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { parseConnectorManifestV6 } from "../../../src/connectors/manifest/manifest-parser.js";
+import { moltbookManifest } from "../../../src/connectors/social-community/moltbook/manifest.js";
+import { instreetManifest } from "../../../src/connectors/social-community/instreet/manifest.js";
+import { evomapManifest } from "../../../src/connectors/agent-network/evomap/manifest.js";
+const projectRoot = process.cwd();
+const fixturesDir = path.resolve(projectRoot, "tests/fixtures/connectors");
+function loadFixture(platformId) {
+    return fs.readFileSync(path.join(fixturesDir, platformId, "manifest.yaml"), "utf-8");
+}
+test("T3.2.1 Moltbook v6 manifest preserves v5 capabilities, family, and credentials", async () => {
+    const yaml = loadFixture("moltbook");
+    const result = parseConnectorManifestV6(yaml, "moltbook/manifest.yaml");
+    assert.equal(result.ok, true);
+    const manifest = result.manifest;
+    assert.equal(manifest.platformId, moltbookManifest.platformId);
+    assert.equal(manifest.family, "social_community");
+    const v6Caps = manifest.capabilities.map((c) => c.id).sort();
+    const v5Caps = [...moltbookManifest.supportedCapabilities].sort();
+    assert.deepEqual(v6Caps, v5Caps);
+    const v6Creds = manifest.credentials.map((c) => c.type).sort();
+    const v5Creds = [...moltbookManifest.credentialTypes].sort();
+    assert.deepEqual(v6Creds, v5Creds);
+    assert.equal(manifest.trust?.status, "declarative_trusted");
+});
+test("T3.2.1 InStreet v6 manifest preserves v5 capabilities, family, and credentials", async () => {
+    const yaml = loadFixture("instreet");
+    const result = parseConnectorManifestV6(yaml, "instreet/manifest.yaml");
+    assert.equal(result.ok, true);
+    const manifest = result.manifest;
+    assert.equal(manifest.platformId, instreetManifest.platformId);
+    assert.equal(manifest.family, "social_community");
+    const v6Caps = manifest.capabilities.map((c) => c.id).sort();
+    const v5Caps = [...instreetManifest.supportedCapabilities].sort();
+    assert.deepEqual(v6Caps, v5Caps);
+    const v6Creds = manifest.credentials.map((c) => c.type).sort();
+    const v5Creds = [...instreetManifest.credentialTypes].sort();
+    assert.deepEqual(v6Creds, v5Creds);
+    assert.equal(manifest.trust?.status, "declarative_trusted");
+});
+test("T3.2.1 EvoMap v6 manifest preserves v5 capabilities, family, and credentials", async () => {
+    const yaml = loadFixture("evomap");
+    const result = parseConnectorManifestV6(yaml, "evomap/manifest.yaml");
+    assert.equal(result.ok, true);
+    const manifest = result.manifest;
+    assert.equal(manifest.platformId, evomapManifest.platformId);
+    assert.equal(manifest.family, "agent_network");
+    const v6Caps = manifest.capabilities.map((c) => c.id).sort();
+    const v5Caps = [...evomapManifest.supportedCapabilities].sort();
+    assert.deepEqual(v6Caps, v5Caps);
+    const v6Creds = manifest.credentials.map((c) => c.type).sort();
+    const v5Creds = [...evomapManifest.credentialTypes].sort();
+    assert.deepEqual(v6Creds, v5Creds);
+    assert.equal(manifest.trust?.status, "declarative_trusted");
+});
+test("T3.2.1 All parity fixtures are declarative_trusted and executable under trust policy", async () => {
+    const { classifyTrust, isExecutable } = await import("../../../src/connectors/registry/trust-policy.js");
+    for (const platformId of ["moltbook", "instreet", "evomap"]) {
+        const yaml = loadFixture(platformId);
+        const result = parseConnectorManifestV6(yaml, `${platformId}/manifest.yaml`);
+        assert.equal(result.ok, true);
+        const manifest = result.manifest;
+        const trust = classifyTrust(manifest);
+        assert.equal(trust, "declarative_trusted", `${platformId} trust mismatch`);
+        assert.equal(isExecutable(trust), true, `${platformId} should be executable`);
+    }
+});
+test("T3.2.1 Parity fixtures load successfully through DynamicConnectorRegistry reload", async () => {
+    const { DynamicConnectorRegistry, createRegistrySnapshotStore, } = await import("../../../src/connectors/registry/index.js");
+    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sn-parity-"));
+    const connectorsDir = path.join(tmpRoot, ".second-nature", "connectors");
+    for (const platformId of ["moltbook", "instreet", "evomap"]) {
+        const platformDir = path.join(connectorsDir, platformId);
+        fs.mkdirSync(platformDir, { recursive: true });
+        fs.copyFileSync(path.join(fixturesDir, platformId, "manifest.yaml"), path.join(platformDir, "manifest.yaml"));
+    }
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({ snapshotStore: store });
+    const reloadResult = registry.reloadConnectors(tmpRoot);
+    assert.equal(reloadResult.scanned, 3);
+    assert.equal(reloadResult.registered, 3);
+    assert.equal(reloadResult.skipped, 0);
+    const snapshot = registry.getActiveRegistrySnapshot();
+    assert.equal(snapshot.entries.size, 3);
+    for (const platformId of ["moltbook", "instreet", "evomap"]) {
+        const entry = snapshot.entries.get(platformId);
+        assert.ok(entry, `${platformId} must be in registry snapshot`);
+        assert.equal(entry.executable, true);
+        assert.equal(entry.source, "workspace");
+    }
+    fs.rmSync(tmpRoot, { recursive: true });
+});

package/dist/tests/unit/connectors/t3-3-1-evidence-mapper.test.d.ts

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

package/dist/tests/unit/connectors/t3-3-1-evidence-mapper.test.js

@@ -0,0 +1,198 @@
+/**
+ * T3.3.1 — Evidence mapper unit tests.
+ *
+ * Covers mapLifeEvidence boundary behaviours:
+ * - success with sourceRefs → candidate
+ * - empty data → null
+ * - failure status → null
+ * - missing sourceRefs → null
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mapLifeEvidence } from "../../../src/connectors/base/map-life-evidence.js";
+test("T3.3.1 success result with sourceRefs maps to LifeEvidenceCandidate", () => {
+    const result = {
+        status: "success",
+        data: {
+            sourceRefs: [
+                { id: "ref-1", kind: "platform_item", uri: "platform://moltbook/item/ref-1" },
+            ],
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.evidenceType, "platform_browse");
+    assert.equal(candidate.sourceRefs.length, 1);
+    assert.equal(candidate.sourceRefs[0].id, "ref-1");
+});
+test("T3.3.1 empty data returns null", () => {
+    const result = {
+        status: "success",
+        data: {},
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.equal(candidate, null);
+});
+test("T3.3.1 policy-wrapped connector payload maps nested data items", () => {
+    const result = {
+        status: "success",
+        data: {
+            capability: "feed.read",
+            channel: "api_rest",
+            data: {
+                items: [
+                    { id: "post-001", title: "Nested connector item" },
+                ],
+            },
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.sourceRefs[0].id, "post-001");
+});
+test("T3.3.1 failure status returns null", () => {
+    const result = {
+        status: "terminal_failure",
+        failureClass: "auth_failure",
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.equal(candidate, null);
+});
+test("T3.3.1 missing sourceRefs returns null", () => {
+    const result = {
+        status: "success",
+        data: { items: [] },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.equal(candidate, null);
+});
+// ── T-CS.C.7 Platform array recognition (Wave 85) ──
+test("T-CS.C.7 moltbook posts array generates sourceRefs", () => {
+    const result = {
+        status: "success",
+        data: {
+            posts: [
+                { id: "post-a", title: "Hello", url: "https://moltbook.example/p/post-a" },
+                { id: "post-b", title: "World" },
+            ],
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.sourceRefs.length, 2);
+    assert.equal(candidate.sourceRefs[0].id, "post-a");
+    assert.equal(candidate.sourceRefs[0].uri, "https://moltbook.example/p/post-a");
+    assert.equal(candidate.sourceRefs[1].id, "post-b");
+    assert.equal(candidate.sourceRefs[1].uri, "platform://moltbook/item/post-b");
+});
+test("T-CS.C.7 agent-world agents array generates sourceRefs", () => {
+    const result = {
+        status: "success",
+        data: {
+            agents: [{ id: "agent-1" }, { id: "agent-2" }],
+        },
+        metadata: { platformId: "agent-world", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "agent-world",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.sourceRefs.length, 2);
+    assert.equal(candidate.sourceRefs[0].id, "agent-1");
+    assert.equal(candidate.sourceRefs[1].id, "agent-2");
+});
+test("T-CS.C.7 deeply nested data posts array is reached through recursion", () => {
+    const result = {
+        status: "success",
+        data: {
+            capability: "feed.read",
+            channel: "api_rest",
+            data: {
+                posts: [{ id: "deep-1", url: "https://example.com/1" }],
+            },
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.sourceRefs.length, 1);
+    assert.equal(candidate.sourceRefs[0].id, "deep-1");
+});
+test("T-CS.C.7 legacy sourceRefs path still works (regression)", () => {
+    const result = {
+        status: "success",
+        data: {
+            sourceRefs: [
+                { id: "legacy-1", kind: "platform_item", uri: "platform://legacy/item/1" },
+            ],
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.sourceRefs[0].id, "legacy-1");
+});
+test("T-CS.C.7 legacy items path still works (regression)", () => {
+    const result = {
+        status: "success",
+        data: { items: [{ id: "item-1" }] },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.sourceRefs[0].id, "item-1");
+});

package/dist/tests/unit/connectors/t3-3-1-evidence-redaction.test.d.ts

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

package/dist/tests/unit/connectors/t3-3-1-evidence-redaction.test.js

@@ -0,0 +1,95 @@
+/**
+ * T3.3.1 — Evidence mapper redaction unit tests.
+ *
+ * Covers mapLifeEvidence sensitivity boundaries:
+ * - message.send intent → null (private, excluded)
+ * - comment.reply intent → null (private, excluded)
+ * - public intent with sourceRefs → candidate with sensitivity public
+ * - sensitivity override honoured
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mapLifeEvidence } from "../../../src/connectors/base/map-life-evidence.js";
+test("T3.3.1 message.send intent is excluded regardless of data", () => {
+    const result = {
+        status: "success",
+        data: {
+            sourceRefs: [{ id: "msg-1", kind: "message", uri: "platform://moltbook/msg/1" }],
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "message.send",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.equal(candidate, null);
+});
+test("T3.3.1 comment.reply intent is excluded", () => {
+    const result = {
+        status: "success",
+        data: {
+            sourceRefs: [{ id: "cmt-1", kind: "comment", uri: "platform://moltbook/comment/1" }],
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "comment.reply",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.equal(candidate, null);
+});
+test("T3.3.1 public intent with sourceRefs returns public sensitivity", () => {
+    const result = {
+        status: "success",
+        data: {
+            sourceRefs: [{ id: "ref-1", kind: "platform_item", uri: "platform://moltbook/item/1" }],
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.sensitivity, "public");
+});
+test("T3.3.1 sensitivityOverride is honoured", () => {
+    const result = {
+        status: "success",
+        data: {
+            sourceRefs: [{ id: "ref-1", kind: "platform_item", uri: "platform://moltbook/item/1" }],
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "feed.read",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+        sensitivityOverride: "private",
+    });
+    assert.ok(candidate);
+    assert.equal(candidate.sensitivity, "private");
+});
+test("T3.3.1 unknown intent without evidenceType mapping returns null", () => {
+    const result = {
+        status: "success",
+        data: {
+            sourceRefs: [{ id: "ref-1", kind: "platform_item", uri: "platform://moltbook/item/1" }],
+        },
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+    };
+    const candidate = mapLifeEvidence({
+        platformId: "moltbook",
+        intent: "unknown.action",
+        result,
+        observedAt: "2026-05-02T00:00:00.000Z",
+    });
+    assert.equal(candidate, null);
+});

package/dist/tests/unit/connectors/wet-probe-runner.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WetProbeRunner tests — T-CS.C.2
+ *
+ * Coverage:
+ * - runWetProbe with safe endpoint returns 200/available
+ * - runWetProbe with 404 returns unavailable
+ * - strict idempotencyClass returns probe_policy_denied, no HTTP
+ * - missing probeConfig returns unavailable with registry:missing ref
+ * - capabilityId is present in result
+ */
+export {};

package/dist/tests/unit/connectors/wet-probe-runner.test.js

@@ -0,0 +1,84 @@
+/**
+ * WetProbeRunner tests — T-CS.C.2
+ *
+ * Coverage:
+ * - runWetProbe with safe endpoint returns 200/available
+ * - runWetProbe with 404 returns unavailable
+ * - strict idempotencyClass returns probe_policy_denied, no HTTP
+ * - missing probeConfig returns unavailable with registry:missing ref
+ * - capabilityId is present in result
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createWetProbeRunner } from "../../../src/connectors/base/wet-probe-runner.js";
+import { CapabilityContractRegistryV7 } from "../../../src/connectors/base/manifest-v7.js";
+describe("WetProbeRunner", () => {
+    const runner = createWetProbeRunner();
+    function buildRegistry(idempotencyClass) {
+        const reg = new CapabilityContractRegistryV7();
+        reg.register({
+            platformId: "test-platform",
+            capabilities: [
+                {
+                    capabilityId: "cap-1",
+                    intent: "feed.read",
+                    probeConfig: {
+                        safeEndpoint: "http://localhost:9999/health",
+                        idempotencyClass,
+                    },
+                },
+            ],
+            channelPriority: ["api_rest"],
+            credentialTypes: ["token"],
+        });
+        return reg;
+    }
+    it("returns available on HTTP 200", async () => {
+        const reg = buildRegistry("read_only");
+        const mockHttpGet = async () => ({ status: 200, body: "ok" });
+        const result = await runner.runWetProbe("test-platform", "cap-1", reg, { httpGet: mockHttpGet });
+        assert.strictEqual(result.probeResult.actualStatus, "available");
+        assert.strictEqual(result.httpStatus, 200);
+        assert.strictEqual(result.probeResult.capabilityId, "cap-1");
+        assert(result.probeResult.sampleResponseRef !== undefined);
+    });
+    it("returns unavailable on HTTP 404", async () => {
+        const reg = buildRegistry("read_only");
+        const mockHttpGet = async () => ({ status: 404 });
+        const result = await runner.runWetProbe("test-platform", "cap-1", reg, { httpGet: mockHttpGet });
+        assert.strictEqual(result.probeResult.actualStatus, "unavailable");
+        assert.strictEqual(result.httpStatus, 404);
+    });
+    it("returns degraded on HTTP 503", async () => {
+        const reg = buildRegistry("read_only");
+        const mockHttpGet = async () => ({ status: 503 });
+        const result = await runner.runWetProbe("test-platform", "cap-1", reg, { httpGet: mockHttpGet });
+        assert.strictEqual(result.probeResult.actualStatus, "degraded");
+    });
+    it("returns probe_policy_denied for strict idempotencyClass", async () => {
+        const reg = buildRegistry("strict");
+        let httpCalled = false;
+        const mockHttpGet = async () => {
+            httpCalled = true;
+            return { status: 200 };
+        };
+        const result = await runner.runWetProbe("test-platform", "cap-1", reg, { httpGet: mockHttpGet });
+        assert.strictEqual(httpCalled, false);
+        assert.strictEqual(result.probeResult.actualStatus, "unavailable");
+        assert.strictEqual(result.httpStatus, 0);
+    });
+    it("returns unavailable when probeConfig missing", async () => {
+        const reg = new CapabilityContractRegistryV7();
+        reg.register({
+            platformId: "test-platform",
+            capabilities: [
+                { capabilityId: "cap-no-probe", intent: "feed.read" },
+            ],
+            channelPriority: ["api_rest"],
+            credentialTypes: ["token"],
+        });
+        const result = await runner.runWetProbe("test-platform", "cap-no-probe", reg);
+        assert.strictEqual(result.probeResult.actualStatus, "unavailable");
+        assert.strictEqual(result.probeResult.probeConfigRef, "registry:missing");
+    });
+});

package/dist/tests/unit/control-plane/decision-trace-emitter.test.d.ts

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

package/dist/tests/unit/control-plane/decision-trace-emitter.test.js

@@ -0,0 +1,51 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createDecisionTraceEmitter, createNoOpTraceEmitter, } from "../../../src/core/second-nature/heartbeat/decision-trace-emitter.js";
+describe("createDecisionTraceEmitter", () => {
+    it("emits trace payload through the port", async () => {
+        let captured;
+        const emitter = createDecisionTraceEmitter(async (payload) => {
+            captured = payload;
+        });
+        const trace = {
+            traceId: "trace:1",
+            decisionId: "dec:1",
+            scope: "rhythm",
+            status: "intent_selected",
+            reasons: ["guard_allow"],
+            emittedAt: new Date().toISOString(),
+        };
+        await emitter.emit(trace);
+        assert.ok(captured);
+        assert.strictEqual(captured.traceId, "trace:1");
+        assert.strictEqual(captured.decisionId, "dec:1");
+    });
+    it("rethrows port errors (emitter does not swallow)", async () => {
+        const emitter = createDecisionTraceEmitter(async () => {
+            throw new Error("port failure");
+        });
+        await assert.rejects(emitter.emit({
+            traceId: "trace:2",
+            decisionId: "dec:2",
+            scope: "rhythm",
+            status: "deferred",
+            reasons: [],
+            emittedAt: new Date().toISOString(),
+        }), /port failure/);
+    });
+});
+describe("createNoOpTraceEmitter", () => {
+    it("swallows any trace without error", async () => {
+        const emitter = createNoOpTraceEmitter();
+        await assert.doesNotReject(async () => {
+            await emitter.emit({
+                traceId: "trace:3",
+                decisionId: "dec:3",
+                scope: "rhythm",
+                status: "heartbeat_ok",
+                reasons: [],
+                emittedAt: new Date().toISOString(),
+            });
+        });
+    });
+});

package/dist/tests/unit/control-plane/downstream-intent-orchestrator.test.d.ts

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

package/dist/tests/unit/control-plane/downstream-intent-orchestrator.test.js

@@ -0,0 +1,57 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { createDownstreamIntentOrchestrator } from "../../../src/core/second-nature/orchestrator/downstream-intent-orchestrator.js";
+function makeIntent(overrides = {}) {
+    return {
+        id: "intent-test",
+        kind: "work",
+        priority: 100,
+        source: "tick",
+        platformId: "moltbook",
+        summary: "test intent",
+        effectClass: "connector_action",
+        sourceRefs: [{ id: "ref-1", kind: "platform_item", uri: "uri://1" }],
+        idempotencyKey: "test-key",
+        ...overrides,
+    };
+}
+describe("createDownstreamIntentOrchestrator", () => {
+    it("orchestrates connector_action to connector_intent request", () => {
+        const orch = createDownstreamIntentOrchestrator();
+        const result = orch.orchestrate(makeIntent());
+        assert.strictEqual(result.kind, "connector_intent");
+        assert.strictEqual(result.platformId, "moltbook");
+    });
+    it("orchestrates user_outreach to guidance_draft request", () => {
+        const orch = createDownstreamIntentOrchestrator();
+        const result = orch.orchestrate(makeIntent({ effectClass: "user_outreach", kind: "outreach" }));
+        assert.strictEqual(result.kind, "guidance_draft");
+    });
+    it("orchestrates maintenance to none request", () => {
+        const orch = createDownstreamIntentOrchestrator();
+        const result = orch.orchestrate(makeIntent({ effectClass: "maintenance" }));
+        assert.strictEqual(result.kind, "none");
+        assert.ok(result.reason.includes("no_downstream"));
+    });
+    it("orchestrates no_effect to none request", () => {
+        const orch = createDownstreamIntentOrchestrator();
+        const result = orch.orchestrate(makeIntent({ effectClass: "no_effect", kind: "quiet" }));
+        assert.strictEqual(result.kind, "none");
+    });
+    it("orchestrates memory_curation to dream_schedule request", () => {
+        const orch = createDownstreamIntentOrchestrator();
+        const result = orch.orchestrate(makeIntent({ effectClass: "memory_curation" }));
+        assert.strictEqual(result.kind, "dream_schedule");
+    });
+    it("orchestrates narrative_reflection to quiet_run request", () => {
+        const orch = createDownstreamIntentOrchestrator();
+        const result = orch.orchestrate(makeIntent({ effectClass: "narrative_reflection", kind: "reflection" }));
+        assert.strictEqual(result.kind, "quiet_run");
+    });
+    it("orchestrates unknown effect_class to none with reason", () => {
+        const orch = createDownstreamIntentOrchestrator();
+        const result = orch.orchestrate(makeIntent({ effectClass: "unknown_effect" }));
+        assert.strictEqual(result.kind, "none");
+        assert.ok(result.reason.includes("unhandled"));
+    });
+});

package/dist/tests/unit/control-plane/embodied-context-assembler.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * EmbodiedContextAssembler tests — T-CP.C.1
+ *
+ * Coverage:
+ * - assembleEmbodiedContext loads all 5 state slices + affordance + selfHealth
+ * - all slices status = loaded when data present
+ * - degraded slice when DB unavailable, others remain loaded
+ * - recentInteractions LIFO trimmed to 10
+ * - toolExperience LIFO trimmed to 10
+ * - candidate dream outputs excluded (accepted only)
+ * - P95 < 400ms benchmark
+ */
+export {};