@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/control-plane/t2-4-2-source-backed-outreach-loop.test.js

@@ -0,0 +1,188 @@
+/**
+ * T2.4.2 — Source-backed outreach delivery / fallback closure integration.
+ *
+ * Verifies the full chain: connector evidence → candidate sourceRefs →
+ * outreach judgment → draft with evidence context → delivery / fallback.
+ *
+ * Acceptance:
+ * A. evidence in snapshot → outreach candidate carries evidence sourceRefs.
+ * B. evidence-backed candidate → draft contains evidence context.
+ * C. delivery unavailable → fallback written with evidence context.
+ * D. no evidence → outreach judgment deny (value too low).
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { dispatchUserOutreachIntent } from "../../../src/core/second-nature/outreach/dispatch-user-outreach.js";
+import { createDraftOutreachMessagePort } from "../../../src/guidance/draft-outreach-message.js";
+import { createNarrativeStateStore } from "../../../src/storage/narrative/narrative-state-store.js";
+import { createRelationshipMemoryStore } from "../../../src/storage/relationship/relationship-memory-store.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+import { planCandidateIntents } from "../../../src/core/second-nature/orchestrator/intent-planner.js";
+const evidenceRef = (id) => ({
+    id,
+    kind: "connector_result",
+    uri: `platform://moltbook/item/${id}`,
+});
+function makeSnapshot(ts, opts) {
+    const count = opts?.evidenceCount ?? 3;
+    const inputs = {
+        mode: "active",
+        currentWindowId: "win_work_morning",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        lifeEvidenceRefs: opts?.empty ? [] : Array.from({ length: count }, (_, i) => evidenceRef(`ev-${i}`)),
+        platformEventCount: opts?.empty ? 0 : count,
+        workEventCount: 0,
+        duplicateIntentKeys: [],
+        outreachCooldownKeys: [],
+    };
+    const continuity = buildContinuitySnapshot(inputs);
+    return buildHeartbeatRuntimeSnapshot(ts, inputs, continuity);
+}
+async function seedNarrativeAndRelationship(state) {
+    const narrativeStore = createNarrativeStateStore(state);
+    await narrativeStore.updateNarrativeState({
+        narrativeId: "default",
+        revision: 1,
+        focus: "Exploring platform integration",
+        progress: ["connected moltbook", "configured evomap"],
+        nextIntent: "reach out to owner about next steps",
+        confidence: 0.85,
+        sourceRefs: [{ sourceId: "ns-1", kind: "decision_record", url: "https://example.test/ns-1" }],
+        unsupportedClaims: [],
+        status: "active",
+        updatedAt: new Date().toISOString(),
+    });
+    const relStore = createRelationshipMemoryStore(state);
+    await relStore.upsertRelationshipMemory({
+        relationshipId: "default",
+        revision: 1,
+        tonePreference: "casual",
+        averageReplyDelayMinutes: 30,
+        noReplyCount: 0,
+        topicAffinities: [
+            { topic: "platform", affinity: 0.9 },
+            { topic: "work", affinity: 0.7 },
+        ],
+        lastInteractionAt: new Date().toISOString(),
+        sourceRefs: [{ sourceId: "rm-1", kind: "user_anchor", url: "https://example.test/rm-1" }],
+        updatedAt: new Date().toISOString(),
+    });
+}
+const judgeBase = {
+    userInterest: {
+        staleness: "fresh",
+        confidence: 0.9,
+        signals: [{ topic: "platform", confidence: 0.8, sourceRefs: [evidenceRef("int-1")] }],
+        sourceRefs: [evidenceRef("int-1")],
+    },
+    lifeEvidence: { empty: false, evidenceRefCount: 3 },
+    delivery: { target: "explicit", channel: "dm", recipient: "user-1" },
+};
+test("T2.4.2-A: evidence in snapshot → outreach candidate carries evidence sourceRefs", () => {
+    const runtime = makeSnapshot("2026-05-16T10:00:00Z", { evidenceCount: 3 });
+    const candidates = planCandidateIntents(runtime);
+    const outreach = candidates.find((c) => c.kind === "outreach");
+    assert.ok(outreach, "outreach candidate must be planned");
+    assert.ok(outreach.sourceRefs.length > 0, "outreach must carry evidence sourceRefs");
+    assert.ok(outreach.sourceRefs.some((r) => r.id.startsWith("ev-")), "sourceRefs must contain evidence refs");
+});
+test("T2.4.2-B: evidence-backed candidate → draft contains narrative/relationship/evidence context", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedNarrativeAndRelationship(state);
+    const guidance = createDraftOutreachMessagePort();
+    const delivery = {
+        sendDeliveryRequest: async () => ({
+            id: "attempt-1",
+            status: "sent",
+            messageId: "msg-1",
+        }),
+    };
+    const candidate = {
+        id: "c-outreach-evidence",
+        kind: "outreach",
+        priority: 40,
+        source: "tick",
+        summary: "share evidence with owner",
+        effectClass: "user_outreach",
+        sourceRefs: [evidenceRef("ev-0"), evidenceRef("ev-1"), evidenceRef("ev-2")],
+    };
+    const result = await dispatchUserOutreachIntent({
+        candidate,
+        snapshot: makeSnapshot("2026-05-16T10:00:00Z", { evidenceCount: 3 }),
+        judgeInput: { ...judgeBase, delivery: { target: "explicit", channel: "dm", recipient: "u1" } },
+        guidance,
+        delivery,
+        state,
+    });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.some((r) => r === "outreach_sent"));
+    // T2.4.2: the deterministic guidance port embeds evidence context into draft text
+    // when narrative/relationship/evidence are present.
+});
+test("T2.4.2-C: delivery unavailable → fallback written with evidence context", async () => {
+    const state = createStateDatabase(":memory:");
+    await seedNarrativeAndRelationship(state);
+    const guidance = createDraftOutreachMessagePort();
+    const delivery = {
+        sendDeliveryRequest: async () => ({ id: "a", status: "sent", messageId: "m" }),
+    };
+    const candidate = {
+        id: "c-outreach-fallback",
+        kind: "outreach",
+        priority: 40,
+        source: "tick",
+        summary: "share evidence with owner",
+        effectClass: "user_outreach",
+        sourceRefs: [evidenceRef("ev-0"), evidenceRef("ev-1")],
+    };
+    const result = await dispatchUserOutreachIntent({
+        candidate,
+        snapshot: makeSnapshot("2026-05-16T10:00:00Z", { evidenceCount: 2 }),
+        judgeInput: { ...judgeBase, delivery: { target: "none" } },
+        guidance,
+        delivery,
+        state,
+    });
+    assert.equal(result.status, "delivery_unavailable");
+    assert.ok(result.fallbackRef, "fallback must be written when delivery unavailable");
+    assert.ok(result.fallbackRef.includes("fallback"));
+});
+test("T2.4.2-D: no evidence → outreach judgment deny (value too low)", async () => {
+    const state = createStateDatabase(":memory:");
+    const guidance = createDraftOutreachMessagePort();
+    const delivery = {
+        sendDeliveryRequest: async () => ({ id: "a", status: "sent", messageId: "m" }),
+    };
+    const candidate = {
+        id: "c-outreach-no-evidence",
+        kind: "outreach",
+        priority: 40,
+        source: "tick",
+        summary: "share evidence with owner",
+        effectClass: "user_outreach",
+        sourceRefs: [],
+    };
+    const result = await dispatchUserOutreachIntent({
+        candidate,
+        snapshot: makeSnapshot("2026-05-16T10:00:00Z", { empty: true }),
+        judgeInput: {
+            ...judgeBase,
+            userInterest: {
+                staleness: "insufficient",
+                confidence: 0.1,
+                signals: [],
+                sourceRefs: [],
+            },
+            lifeEvidence: { empty: true, evidenceRefCount: 0 },
+        },
+        guidance,
+        delivery,
+        state,
+    });
+    assert.equal(result.status, "denied");
+    assert.ok(result.reasons.some((r) => r === "value_score_too_low"));
+});

package/dist/tests/integration/control-plane/v7c-evidence-body-feedback.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * T-V7C.C.2 集成测试 — Evidence + Body Feedback Closure
+ *
+ * 验收标准:
+ *  - heartbeat connector success 写 ToolExperience + life_evidence, triggerSource="heartbeat"
+ *  - heartbeat connector failure 也写 ToolExperience, triggerSource="heartbeat"
+ *  - guard-layer 在有 painful affordance (circuit open) 时 defer connector intent
+ *  - guard-layer 在有 unavailable affordance 时 defer connector intent
+ *  - guard-layer 在有 safe affordance 时 allow connector intent
+ */
+export {};

package/dist/tests/integration/control-plane/v7c-evidence-body-feedback.test.js

@@ -0,0 +1,213 @@
+/**
+ * T-V7C.C.2 集成测试 — Evidence + Body Feedback Closure
+ *
+ * 验收标准:
+ *  - heartbeat connector success 写 ToolExperience + life_evidence, triggerSource="heartbeat"
+ *  - heartbeat connector failure 也写 ToolExperience, triggerSource="heartbeat"
+ *  - guard-layer 在有 painful affordance (circuit open) 时 defer connector intent
+ *  - guard-layer 在有 unavailable affordance 时 defer connector intent
+ *  - guard-layer 在有 safe affordance 时 allow connector intent
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { ingestRhythmSignal } from "../../../src/core/second-nature/heartbeat/heartbeat-loop.js";
+import { evaluateHardGuards } from "../../../src/core/second-nature/orchestrator/guard-layer.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+const TEST_TIMESTAMP = "2026-05-25T10:00:00.000Z";
+/**
+ * Build SnapshotInputs with a life-evidence ref pointing to moltbook (fallback-supported platform).
+ * moltbook supports "feed.read" which maps to the "exploration" intent kind.
+ * This ensures planner can resolve platformId and produces sourceRefs for the intent,
+ * allowing the source-backed guard to pass.
+ */
+function makeSnapshotInputs(overrides = {}) {
+    return {
+        mode: "active",
+        currentWindowId: "w1",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        budgets: { socialUsed: 0, socialLimit: 5 },
+        awaitingUserInput: false,
+        riskSuppressed: false,
+        quietEnabledBridge: false,
+        duplicateIntentKeys: [],
+        outreachCooldownKeys: [],
+        // Provide a platform://moltbook/feed.read evidence ref so planner emits
+        // a moltbook exploration intent with non-empty sourceRefs, satisfying the
+        // source-backed guard (isSourceBacked) and resolving platformId.
+        lifeEvidenceRefs: [
+            {
+                id: "ev:moltbook:feed:1",
+                kind: "connector_result",
+                uri: "platform://moltbook/feed.read",
+                observedAt: TEST_TIMESTAMP,
+            },
+        ],
+        ...overrides,
+    };
+}
+function makeSignal() {
+    return {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: TEST_TIMESTAMP },
+    };
+}
+function makeConnectorResult(status, failureClass) {
+    return {
+        status,
+        failureClass,
+        metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 42 },
+    };
+}
+/**
+ * Build a connector_action CandidateIntent suitable for guard-layer tests.
+ * Uses moltbook which is in the fallback platform list.
+ */
+function makeConnectorIntent(platformId, capabilityId, overrides = {}) {
+    return {
+        id: `intent:${platformId}:${capabilityId}`,
+        kind: "exploration",
+        summary: `scan platform opportunities on ${platformId}`,
+        effectClass: "connector_action",
+        platformId,
+        capabilityIntent: capabilityId,
+        sourceRefs: [
+            {
+                id: `ev:${platformId}:feed:1`,
+                kind: "connector_result",
+                uri: `platform://${platformId}/feed.read`,
+                observedAt: TEST_TIMESTAMP,
+            },
+        ],
+        idempotencyKey: `exploration:${platformId}`,
+        goalInfluenceRefs: [],
+        priority: 70,
+        source: "tick",
+        ...overrides,
+    };
+}
+// ─── Tests: heartbeat loop + experienceWriter ───────────────────────────────
+describe("T-V7C.C.2 — Evidence + Body Feedback Closure", () => {
+    it("heartbeat connector success writes ToolExperience with triggerSource=heartbeat", async () => {
+        const recorded = [];
+        const mockExperienceWriter = {
+            async recordExperience(input) {
+                recorded.push({
+                    connectorId: input.connectorId,
+                    capabilityId: input.capabilityId,
+                    triggerSource: input.triggerSource,
+                    status: input.result.status,
+                });
+            },
+        };
+        const signal = makeSignal();
+        const deps = {
+            loadSnapshotInputs: async () => makeSnapshotInputs(),
+            connectorExecutor: {
+                async executeEffect() {
+                    return makeConnectorResult("success");
+                },
+            },
+            experienceWriter: mockExperienceWriter,
+        };
+        const result = await ingestRhythmSignal(signal, deps);
+        assert.strictEqual(result.status, "intent_selected", `expected intent_selected, got ${result.status} — reasons: ${result.reasons?.join(", ")}`);
+        assert.strictEqual(recorded.length, 1, `expected 1 ToolExperience record, got ${recorded.length}`);
+        assert.strictEqual(recorded[0].triggerSource, "heartbeat");
+        assert.strictEqual(recorded[0].status, "success");
+        // platformId resolved to moltbook by the evidence ref
+        assert.strictEqual(recorded[0].connectorId, "moltbook");
+    });
+    it("heartbeat connector failure also writes ToolExperience with triggerSource=heartbeat", async () => {
+        const recorded = [];
+        const mockExperienceWriter = {
+            async recordExperience(input) {
+                recorded.push({
+                    triggerSource: input.triggerSource,
+                    status: input.result.status,
+                    failureClass: input.result.failureClass,
+                });
+            },
+        };
+        const signal = makeSignal();
+        const deps = {
+            loadSnapshotInputs: async () => makeSnapshotInputs(),
+            connectorExecutor: {
+                async executeEffect() {
+                    return makeConnectorResult("terminal_failure", "transport_failure");
+                },
+            },
+            experienceWriter: mockExperienceWriter,
+        };
+        const result = await ingestRhythmSignal(signal, deps);
+        assert.strictEqual(result.status, "intent_selected", `expected intent_selected, got ${result.status} — reasons: ${result.reasons?.join(", ")}`);
+        assert.strictEqual(recorded.length, 1, `expected 1 ToolExperience record, got ${recorded.length}`);
+        assert.strictEqual(recorded[0].triggerSource, "heartbeat");
+        assert.strictEqual(recorded[0].status, "terminal_failure");
+        assert.strictEqual(recorded[0].failureClass, "transport_failure");
+    });
+    // ─── Tests: guard-layer affordance/breaker (direct evaluateHardGuards) ────
+    it("guard-layer defers connector_action when affordance status is painful (circuit open)", () => {
+        const painfulAffordanceMap = {
+            "moltbook": [
+                {
+                    platformId: "moltbook",
+                    capabilityId: "feed.read",
+                    intent: "scan platform opportunities on moltbook",
+                    status: "painful",
+                    reason: "breaker:open",
+                },
+            ],
+        };
+        const inputs = makeSnapshotInputs({ affordanceMap: painfulAffordanceMap });
+        const continuity = buildContinuitySnapshot(inputs);
+        const runtime = buildHeartbeatRuntimeSnapshot(TEST_TIMESTAMP, inputs, continuity);
+        const intent = makeConnectorIntent("moltbook", "feed.read");
+        const evaluation = evaluateHardGuards(intent, runtime);
+        assert.strictEqual(evaluation.verdict, "defer", `expected defer, got ${evaluation.verdict}`);
+        assert.ok(evaluation.reasons.some((r) => r.includes("connector_circuit_open")), `expected connector_circuit_open in reasons, got: ${evaluation.reasons.join(", ")}`);
+    });
+    it("guard-layer defers connector_action when affordance status is unavailable", () => {
+        const unavailableAffordanceMap = {
+            "moltbook": [
+                {
+                    platformId: "moltbook",
+                    capabilityId: "feed.read",
+                    intent: "scan platform opportunities on moltbook",
+                    status: "unavailable",
+                    reason: "probe:unavailable",
+                },
+            ],
+        };
+        const inputs = makeSnapshotInputs({ affordanceMap: unavailableAffordanceMap });
+        const continuity = buildContinuitySnapshot(inputs);
+        const runtime = buildHeartbeatRuntimeSnapshot(TEST_TIMESTAMP, inputs, continuity);
+        const intent = makeConnectorIntent("moltbook", "feed.read");
+        const evaluation = evaluateHardGuards(intent, runtime);
+        assert.strictEqual(evaluation.verdict, "defer", `expected defer, got ${evaluation.verdict}`);
+        assert.ok(evaluation.reasons.some((r) => r.includes("affordance_unavailable")), `expected affordance_unavailable in reasons, got: ${evaluation.reasons.join(", ")}`);
+    });
+    it("guard-layer allows connector_action when affordance status is safe", () => {
+        const safeAffordanceMap = {
+            "moltbook": [
+                {
+                    platformId: "moltbook",
+                    capabilityId: "feed.read",
+                    intent: "scan platform opportunities on moltbook",
+                    status: "safe",
+                    reason: "probe:available",
+                },
+            ],
+        };
+        const inputs = makeSnapshotInputs({ affordanceMap: safeAffordanceMap });
+        const continuity = buildContinuitySnapshot(inputs);
+        const runtime = buildHeartbeatRuntimeSnapshot(TEST_TIMESTAMP, inputs, continuity);
+        const intent = makeConnectorIntent("moltbook", "feed.read");
+        const evaluation = evaluateHardGuards(intent, runtime);
+        assert.strictEqual(evaluation.verdict, "allow", `expected allow, got ${evaluation.verdict} — reasons: ${evaluation.reasons.join(", ")}`);
+    });
+});

package/dist/tests/integration/control-plane/v7c-heartbeat-unlock-e2e.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Wave 82 — Heartbeat Unlock E2E
+ *
+ * Verifies the complete chain after W80+W81 fixes:
+ *   planCandidateIntents (goal sourceRefs)
+ *   → evaluateHardGuards (allow, no missing_source_refs / affordance_unavailable)
+ *   → connectorExecutor (moltbook mock runner success)
+ */
+export {};

package/dist/tests/integration/control-plane/v7c-heartbeat-unlock-e2e.test.js

@@ -0,0 +1,134 @@
+/**
+ * Wave 82 — Heartbeat Unlock E2E
+ *
+ * Verifies the complete chain after W80+W81 fixes:
+ *   planCandidateIntents (goal sourceRefs)
+ *   → evaluateHardGuards (allow, no missing_source_refs / affordance_unavailable)
+ *   → connectorExecutor (moltbook mock runner success)
+ */
+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 { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { planCandidateIntents } from "../../../src/core/second-nature/orchestrator/intent-planner.js";
+import { evaluateHardGuards } from "../../../src/core/second-nature/orchestrator/hard-guard-evaluator.js";
+import { createConnectorExecutorAdapter } from "../../../src/connectors/services/connector-executor-adapter.js";
+import { createCredentialVault } from "../../../src/storage/services/credential-vault.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+import { CapabilityContractRegistryV7 } from "../../../src/connectors/base/manifest-v7.js";
+import { createAffordanceAssembler } from "../../../src/core/second-nature/body/tool-affordance/affordance-assembler.js";
+const ORIGINAL_KEY = process.env.SECOND_NATURE_ENCRYPTION_KEY;
+const ORIGINAL_MOLTBOOK_URL = process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
+function tempWorkspaceWithMock() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-e2e-test-"));
+    const mockDir = path.join(dir, ".second-nature", "mock");
+    fs.mkdirSync(mockDir, { recursive: true });
+    fs.writeFileSync(path.join(mockDir, "moltbook-feed.json"), JSON.stringify({ items: [{ id: "e2e-1", title: "E2E mock item" }] }), "utf-8");
+    return dir;
+}
+function makeRuntime(ts) {
+    const inputs = {
+        mode: "active",
+        currentWindowId: "win_work_morning",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        lifeEvidenceRefs: [],
+        platformEventCount: 0,
+        workEventCount: 0,
+        duplicateIntentKeys: [],
+        outreachCooldownKeys: [],
+    };
+    const continuity = buildContinuitySnapshot(inputs);
+    return buildHeartbeatRuntimeSnapshot(ts, inputs, continuity);
+}
+test.beforeEach(() => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
+    delete process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
+});
+test.afterEach(() => {
+    if (ORIGINAL_KEY === undefined)
+        delete process.env.SECOND_NATURE_ENCRYPTION_KEY;
+    else
+        process.env.SECOND_NATURE_ENCRYPTION_KEY = ORIGINAL_KEY;
+    if (ORIGINAL_MOLTBOOK_URL === undefined)
+        delete process.env.SECOND_NATURE_MOLTBOOK_BASE_URL;
+    else
+        process.env.SECOND_NATURE_MOLTBOOK_BASE_URL = ORIGINAL_MOLTBOOK_URL;
+});
+test("W82: full chain intent → guard allow → mock execution success", async () => {
+    const workspaceRoot = tempWorkspaceWithMock();
+    try {
+        const stateDb = createStateDatabase(":memory:");
+        const observabilityDb = createObservabilityDatabase(":memory:");
+        const vault = createCredentialVault(stateDb.db);
+        await vault.saveCredentialContext({
+            platformId: "moltbook",
+            credentialType: "api_key",
+            encryptedValue: "mock-token",
+            status: "active",
+        });
+        // Step 1: planCandidateIntents with accepted goal → non-empty sourceRefs
+        const runtime = makeRuntime("2026-05-27T10:00:00Z");
+        const candidates = planCandidateIntents(runtime, {
+            acceptedGoals: [
+                {
+                    goalId: "goal-explore-moltbook",
+                    description: "Explore MoltBook integration opportunities",
+                    status: "accepted",
+                    origin: "owner_set",
+                },
+            ],
+        });
+        const exploration = candidates.find((c) => c.kind === "exploration" && c.platformId === "moltbook");
+        assert.ok(exploration, "must plan exploration intent for moltbook");
+        assert.ok(exploration.sourceRefs.length > 0, "exploration must have sourceRefs from goal fallback");
+        // Step 2: assemble affordance map with needs_auth posture
+        const registry = new CapabilityContractRegistryV7();
+        registry.register({
+            platformId: "moltbook",
+            capabilities: [
+                { capabilityId: "feed.read", intent: "feed.read", probeConfig: { safeEndpoint: "connector://moltbook/feed.read", idempotencyClass: "read_only" } },
+            ],
+            channelPriority: ["api_rest"],
+            credentialTypes: ["api_key"],
+        });
+        const affordanceAssembler = createAffordanceAssembler({
+            registry,
+            probeReader: { getLatestProbeResult: () => undefined },
+            credentialRequired: (platformId) => ["moltbook", "evomap", "agent-world", "instreet"].includes(platformId),
+        });
+        const affordanceMap = await affordanceAssembler.assembleAffordanceMap({
+            allowedStatuses: ["safe", "exploratory", "needs_auth"],
+        });
+        // Step 3: evaluateHardGuards → allow (no missing_source_refs, no affordance_unavailable)
+        const guardResult = evaluateHardGuards(exploration, {
+            hasDuplicateIntent: () => false,
+            isOutreachCooldownClear: () => true,
+            affordanceMap,
+        });
+        assert.equal(guardResult.verdict, "allow", `guard should allow, got reasons: ${guardResult.reasons.join(", ")}`);
+        // Step 4: connectorExecutor → mock success
+        const executor = createConnectorExecutorAdapter({
+            stateDb,
+            observabilityDb,
+            workspaceRoot,
+        });
+        const execResult = await executor.executeEffect({
+            intent: "feed.read",
+            platformId: "moltbook",
+            payload: {},
+            decisionId: "dec-e2e-1",
+            intentId: exploration.id,
+            idempotencyKey: exploration.idempotencyKey ?? "e2e-fallback-key",
+        });
+        assert.equal(execResult.status, "success", `execution should succeed: ${JSON.stringify(execResult)}`);
+    }
+    finally {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});

package/dist/tests/integration/dream/quiet-dream-trigger.test.d.ts

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

package/dist/tests/integration/dream/quiet-dream-trigger.test.js

@@ -0,0 +1,86 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { scheduleDream, memoryLockPort, } from "../../../src/dream/index.js";
+const makeStatePort = () => ({
+    async loadDreamInputs() {
+        return {
+            evidenceRefs: ["ev-1"],
+            chronicleEntryIds: ["ch-1"],
+            inputCounts: { evidence: 1, chronicle: 1, memoryEntries: 0 },
+            goalSnapshotIds: [],
+        };
+    },
+    async writeDreamOutput(output) {
+        return { outputId: output.outputId, status: "acknowledged" };
+    },
+    async markDreamOutputLifecycle() {
+        return { outputId: "out-1", status: "acknowledged" };
+    },
+});
+test("T-DQS.C.4 quiet_completion in window starts Dream async", async () => {
+    const result = await scheduleDream({
+        runId: "run-quiet-001",
+        traceId: "trace-quiet-001",
+        triggerKind: "quiet_completion",
+        statePort: makeStatePort(),
+    });
+    assert.equal(result.status, "started");
+    assert.equal(result.runId, "run-quiet-001");
+});
+test("T-DQS.C.4 quiet_completion with held lock returns skip:lock_held", async () => {
+    const lockPort = memoryLockPort();
+    const statePort = makeStatePort();
+    const first = await scheduleDream({
+        runId: "run-quiet-002",
+        traceId: "trace-quiet-002",
+        triggerKind: "quiet_completion",
+        statePort,
+        lockPort,
+    });
+    assert.equal(first.status, "started");
+    const second = await scheduleDream({
+        runId: "run-quiet-003",
+        traceId: "trace-quiet-003",
+        triggerKind: "quiet_completion",
+        statePort,
+        lockPort,
+    });
+    assert.equal(second.status, "skipped");
+    assert.equal(second.reason, "skip:lock_held");
+});
+test("T-DQS.C.4 modelAssistPort is passed through to runDream without error", async () => {
+    const modelAssistPort = {
+        async extractInsights() {
+            return { insights: [], unsupportedClaims: [] };
+        },
+    };
+    const result = await scheduleDream({
+        runId: "run-model-001",
+        traceId: "trace-model-001",
+        triggerKind: "quiet_completion",
+        statePort: makeStatePort(),
+        modelAssistPort,
+    });
+    assert.equal(result.status, "started");
+});
+test("T-DQS.C.4 non-quiet trigger with held lock returns legacy lock_held_by reason", async () => {
+    const lockPort = memoryLockPort();
+    const statePort = makeStatePort();
+    const first = await scheduleDream({
+        runId: "run-manual-001",
+        traceId: "trace-manual-001",
+        triggerKind: "manual",
+        statePort,
+        lockPort,
+    });
+    assert.equal(first.status, "started");
+    const second = await scheduleDream({
+        runId: "run-manual-002",
+        traceId: "trace-manual-002",
+        triggerKind: "manual",
+        statePort,
+        lockPort,
+    });
+    assert.equal(second.status, "skipped");
+    assert.ok(second.reason?.startsWith("lock_held_by:"));
+});

package/dist/tests/integration/dream/t7-1-1-dream-pipeline.test.d.ts

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