@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/control-plane/decision-loop-validation.test.js

@@ -0,0 +1,319 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EffectDispatcher, LeaseManager, resumeFromCheckpoint, } from "../../../src/core/second-nature/index.js";
+import { createObservabilityDatabase, DecisionLedger, EvidenceQueryEngine, ExecutionTelemetry, } from "../../../src/observability/index.js";
+import { createEffectCommitStore, createStateDatabase } from "../../../src/storage/index.js";
+import { createDecisionCycleHarness } from "./_helpers/decision-cycle-harness.js";
+function setupObservability() {
+    const db = createObservabilityDatabase(":memory:");
+    db.sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS decision_ledger (
+      id TEXT PRIMARY KEY,
+      tick_id TEXT NOT NULL,
+      trace_id TEXT NOT NULL,
+      intent_id TEXT,
+      platform_id TEXT,
+      verdict TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      reasons TEXT NOT NULL,
+      reason_codes TEXT NOT NULL,
+      decision_basis TEXT NOT NULL,
+      evidence_refs TEXT NOT NULL,
+      model_eval_ref TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS execution_attempts (
+      id TEXT PRIMARY KEY,
+      trace_id TEXT NOT NULL,
+      decision_id TEXT NOT NULL,
+      intent_id TEXT NOT NULL,
+      platform_id TEXT NOT NULL,
+      capability TEXT NOT NULL,
+      channel TEXT NOT NULL,
+      status TEXT NOT NULL,
+      commit_state TEXT,
+      failure_class TEXT,
+      retry_policy TEXT,
+      idempotency_key TEXT,
+      started_at TEXT,
+      finished_at TEXT
+    );
+    CREATE TABLE IF NOT EXISTS governance_audit (
+      id TEXT PRIMARY KEY,
+      event_type TEXT NOT NULL,
+      proposal_id TEXT,
+      target_asset_id TEXT,
+      asset_path TEXT,
+      status_from TEXT,
+      status_to TEXT NOT NULL,
+      before_hash TEXT,
+      after_hash TEXT,
+      supporting_sources TEXT,
+      reason TEXT,
+      verification_deadline TEXT,
+      attempts_remaining INTEGER,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS redaction_manifest (
+      id TEXT PRIMARY KEY,
+      event_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      field_name TEXT NOT NULL,
+      action TEXT NOT NULL,
+      original_value_hash TEXT,
+      created_at TEXT NOT NULL
+    );
+  `);
+    return db;
+}
+test("whole-loop validation covers active/quiet/interrupt/outreach/deny and durability+explainability chain", async () => {
+    const obsDb = setupObservability();
+    const decisionLedger = new DecisionLedger(obsDb);
+    const telemetry = new ExecutionTelemetry(obsDb);
+    const evidenceQuery = new EvidenceQueryEngine(obsDb);
+    const stateDb = createStateDatabase(":memory:");
+    stateDb.sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS intent_commit_records (
+      id TEXT PRIMARY KEY,
+      intent_id TEXT NOT NULL,
+      decision_id TEXT NOT NULL,
+      checkpoint_id TEXT,
+      state TEXT NOT NULL,
+      outcome_ref TEXT,
+      metadata_json TEXT,
+      updated_at TEXT NOT NULL
+    );
+  `);
+    const commitStore = createEffectCommitStore(stateDb.db);
+    const rhythmPolicy = {
+        timezone: "UTC",
+        quietSuppressionEnabled: true,
+        windows: [
+            { id: "active-window", startMinute: 0, endMinute: 1320, mode: "active" },
+            { id: "quiet-window", startMinute: 1320, endMinute: 1440, mode: "quiet" },
+        ],
+    };
+    const checkpoints = new Map();
+    const snapshots = new Map();
+    const dispatcher = new EffectDispatcher(new LeaseManager(), {
+        async createIntentCommitRecord(input) {
+            const record = await commitStore.createIntentCommitRecord(input);
+            return { id: record.id };
+        },
+        async advanceIntentCommitState(id, state, metadata) {
+            await commitStore.advanceIntentCommitState(id, state, metadata);
+        },
+        async commitIntentOutcome(id, outcome) {
+            await commitStore.commitIntentOutcome(id, outcome);
+        },
+        async abortIntentCommit(id, reason) {
+            await commitStore.abortIntentCommit(id, reason);
+        },
+    }, {
+        async executeEffect(input) {
+            await telemetry.recordExecutionAttempt({
+                id: `attempt:${input.intentId}`,
+                traceId: `trace:${input.decisionId}`,
+                decisionId: input.decisionId,
+                intentId: input.intentId,
+                platformId: input.platformId,
+                capability: input.intent,
+                channel: "api_rest",
+                status: "succeeded",
+                startedAt: new Date().toISOString(),
+                finishedAt: new Date().toISOString(),
+            });
+            return {
+                status: "success",
+                data: { ok: true },
+                metadata: {
+                    platformId: input.platformId,
+                    channel: "api_rest",
+                    latencyMs: 1,
+                },
+            };
+        },
+    }, {
+        async saveCheckpoint(input) {
+            checkpoints.set(input.id, { id: input.id, intentId: input.intentId, snapshotRef: input.snapshotRef });
+        },
+    }, {
+        async persistCurationResult() {
+            return;
+        },
+    }, {
+        async runNarrativeReflection() {
+            return { outcomeRef: "reflection-artifact" };
+        },
+    });
+    const harness = createDecisionCycleHarness({
+        rhythmPolicy,
+        decisionLedger,
+        effectDispatcher: dispatcher,
+        outreachModel: {
+            async evaluateOutreachCandidate() {
+                return {
+                    valueScore: 0.9,
+                    novelty: 0.8,
+                    userRelevance: 0.9,
+                    actionability: 0.8,
+                    urgency: 0.7,
+                    requiredUserHelp: true,
+                    isRoutineProgress: false,
+                    minThreshold: 0.65,
+                    sourceRefs: ["report:1"],
+                };
+            },
+        },
+    });
+    const activeSnapshot = {
+        mode: "active",
+        currentWindowId: "active-window",
+        pendingObligations: ["heartbeat"],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        budgets: { socialUsed: 0, socialLimit: 3 },
+    };
+    const activeDispatch = await harness.ingestTick({ id: "tick-active", source: "cron", receivedAt: "2026-03-25T09:00:00.000Z" }, activeSnapshot);
+    assert.equal(activeDispatch.status, "effect_executed");
+    assert.ok(activeDispatch.decisionId);
+    assert.ok(activeDispatch.intentId);
+    const quietAllowSnapshot = {
+        ...activeSnapshot,
+        mode: "quiet",
+        deniedIntents: [],
+        awaitingUserInput: false,
+        pendingObligations: [],
+        budgets: { socialUsed: 99, socialLimit: 1 },
+        recentOutreachHashes: [
+            "intent-outreach",
+            "intent-outreach|consider proactive user outreach",
+        ],
+    };
+    const quietAllowResult = await harness.ingestTick({ id: "tick-quiet-allow", source: "heartbeat", receivedAt: "2026-03-25T22:10:00.000Z" }, quietAllowSnapshot);
+    assert.equal(quietAllowResult.status, "maintenance_done");
+    const quietAllowEvidence = await evidenceQuery.queryEvidence({ decisionId: quietAllowResult.decisionId });
+    assert.equal(quietAllowEvidence.decisions.length, 1);
+    assert.equal(quietAllowEvidence.decisions[0]?.mode, "quiet");
+    assert.equal(quietAllowEvidence.decisions[0]?.verdict, "allow");
+    assert.equal(quietAllowEvidence.decisions[0]?.decisionBasis, "rule_only");
+    const quietAllowCommit = await commitStore.loadIntentCommitRecord(quietAllowResult.intentId);
+    assert.equal(quietAllowCommit?.state, "committed");
+    const denySnapshot = {
+        ...activeSnapshot,
+        mode: "quiet",
+        deniedIntents: [],
+        awaitingUserInput: false,
+        pendingObligations: ["urgent-obligation"],
+    };
+    const denyResult = await harness.ingestTick({ id: "tick-deny", source: "heartbeat", receivedAt: "2026-03-25T22:20:00.000Z" }, denySnapshot);
+    assert.notEqual(denyResult.status, "effect_executed");
+    const denyDecisions = await decisionLedger.queryByTickId("tick-deny");
+    const denyDecision = denyDecisions.find((item) => item.verdict === "deny");
+    assert.ok(denyDecision);
+    const interruptSnapshot = {
+        ...activeSnapshot,
+        mode: "paused_for_interrupt",
+    };
+    const interruptResult = await harness.ingestTick({ id: "tick-interrupt", source: "user_interrupt", receivedAt: "2026-03-25T09:30:00.000Z" }, interruptSnapshot);
+    assert.equal(interruptResult.status, "interrupt_deferred");
+    const outreachSnapshot = {
+        ...activeSnapshot,
+        mode: "active",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [
+            { intentHash: "exploration:scan platform opportunities", reason: "duplicate_intent", at: "now" },
+            { intentHash: "social:engage social platforms", reason: "duplicate_intent", at: "now" },
+        ],
+    };
+    const outreachResult = await harness.ingestTick({ id: "tick-outreach", source: "cron", receivedAt: "2026-03-25T10:00:00.000Z" }, outreachSnapshot);
+    assert.ok(outreachResult.status === "outreach_allowed" || outreachResult.status === "outreach_denied");
+    assert.ok(outreachResult.decisionId);
+    const evidence = await evidenceQuery.queryEvidence({ decisionId: activeDispatch.decisionId });
+    assert.equal(evidence.decisions.length, 1);
+    assert.equal(evidence.attempts.length, 1);
+    assert.equal(evidence.decisions[0]?.verdict, "allow");
+    assert.ok((evidence.decisions[0]?.reasonCodes ?? []).includes("guard_clear"));
+    const denyEvidence = await evidenceQuery.queryEvidence({ decisionId: denyDecision.id });
+    assert.equal(denyEvidence.decisions.length, 1);
+    assert.equal(denyEvidence.decisions[0]?.verdict, "deny");
+    assert.ok((denyEvidence.decisions[0]?.reasonCodes ?? []).some((c) => c.includes("quiet_window") || c.includes("quiet_window_suppression")));
+    const outreachEvidence = await evidenceQuery.queryEvidence({ decisionId: outreachResult.decisionId });
+    assert.equal(outreachEvidence.decisions.length, 1);
+    assert.equal(outreachEvidence.decisions[0]?.decisionBasis, "model_assisted");
+    const committed = await commitStore.loadIntentCommitRecord(activeDispatch.intentId);
+    assert.equal(committed?.state, "committed");
+    const activeTrace = evidence.decisions[0]?.traceId ?? "";
+    snapshots.set(activeTrace, { mode: "active", tickId: "tick-active" });
+    const activeCheckpointId = `checkpoint:${activeDispatch.intentId}:tick-active`;
+    const resumeAlreadyCommitted = await resumeFromCheckpoint({
+        async loadCheckpoint(checkpointId) {
+            return checkpoints.get(checkpointId) ?? null;
+        },
+        async loadIntentCommitRecord(intentId) {
+            const rec = await commitStore.loadIntentCommitRecord(intentId);
+            return rec ? { id: rec.id, intentId: rec.intentId, state: rec.state, outcomeRef: rec.outcomeRef } : null;
+        },
+        async loadSnapshotByRef(snapshotRef) {
+            return snapshots.get(snapshotRef) ?? {};
+        },
+    }, activeCheckpointId);
+    assert.equal(resumeAlreadyCommitted.status, "already_committed");
+    checkpoints.set("checkpoint-reconcile", {
+        id: "checkpoint-reconcile",
+        intentId: "intent-reconcile",
+        snapshotRef: "snapshot-reconcile",
+    });
+    const recRecord = await commitStore.createIntentCommitRecord({
+        intentId: "intent-reconcile",
+        decisionId: "decision-reconcile",
+        checkpointId: "checkpoint-reconcile",
+        state: "planned",
+    });
+    await commitStore.advanceIntentCommitState(recRecord.id, "dispatched");
+    await commitStore.advanceIntentCommitState(recRecord.id, "externally_acknowledged", {
+        outcomeRef: "outcome-ack",
+    });
+    snapshots.set("snapshot-reconcile", { mode: "active", tickId: "tick-reconcile" });
+    const resumeNeedsReconcile = await resumeFromCheckpoint({
+        async loadCheckpoint(checkpointId) {
+            return checkpoints.get(checkpointId) ?? null;
+        },
+        async loadIntentCommitRecord(intentId) {
+            const rec = await commitStore.loadIntentCommitRecord(intentId);
+            return rec ? { id: rec.id, intentId: rec.intentId, state: rec.state, outcomeRef: rec.outcomeRef } : null;
+        },
+        async loadSnapshotByRef(snapshotRef) {
+            return snapshots.get(snapshotRef) ?? {};
+        },
+    }, "checkpoint-reconcile");
+    assert.equal(resumeNeedsReconcile.status, "needs_reconcile");
+    checkpoints.set("checkpoint-ready", {
+        id: "checkpoint-ready",
+        intentId: "intent-ready",
+        snapshotRef: "snapshot-ready",
+    });
+    await commitStore.createIntentCommitRecord({
+        intentId: "intent-ready",
+        decisionId: "decision-ready",
+        checkpointId: "checkpoint-ready",
+        state: "planned",
+    });
+    snapshots.set("snapshot-ready", { mode: "quiet", tickId: "tick-ready" });
+    const resumeReady = await resumeFromCheckpoint({
+        async loadCheckpoint(checkpointId) {
+            return checkpoints.get(checkpointId) ?? null;
+        },
+        async loadIntentCommitRecord(intentId) {
+            const rec = await commitStore.loadIntentCommitRecord(intentId);
+            return rec ? { id: rec.id, intentId: rec.intentId, state: rec.state, outcomeRef: rec.outcomeRef } : null;
+        },
+        async loadSnapshotByRef(snapshotRef) {
+            return snapshots.get(snapshotRef) ?? {};
+        },
+    }, "checkpoint-ready");
+    assert.equal(resumeReady.status, "ready_to_resume");
+    stateDb.close();
+    obsDb.close();
+});

package/dist/tests/integration/control-plane/delivery-failed-fallback.test.d.ts

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

package/dist/tests/integration/control-plane/delivery-failed-fallback.test.js

@@ -0,0 +1,118 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { dispatchUserOutreachIntent } from "../../../src/core/second-nature/outreach/dispatch-user-outreach.js";
+import { createDraftOutreachMessagePort } from "../../../src/guidance/draft-outreach-message.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { listDeliveryAttemptsByDecisionId } from "../../../src/storage/delivery/query-delivery-attempts.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+const ref = (id) => ({
+    id,
+    kind: "platform_item",
+    uri: `https://example.test/${id}`,
+});
+function makeSnapshot(ts) {
+    const inputs = {
+        mode: "active",
+        currentWindowId: "win_work_morning",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        lifeEvidenceRefs: [ref("ev-1")],
+        duplicateIntentKeys: [],
+        outreachCooldownKeys: [],
+    };
+    const continuity = buildContinuitySnapshot(inputs);
+    return buildHeartbeatRuntimeSnapshot(ts, inputs, continuity);
+}
+const candidate = {
+    id: "c-del-fail",
+    kind: "outreach",
+    priority: 5,
+    source: "tick",
+    summary: "platform direction check-in",
+    effectClass: "user_outreach",
+    sourceRefs: [ref("src-1")],
+};
+const judgeBase = {
+    userInterest: {
+        staleness: "fresh",
+        confidence: 0.9,
+        signals: [{ topic: "platform", confidence: 0.8, sourceRefs: [ref("int-1")] }],
+        sourceRefs: [ref("int-1")],
+    },
+    lifeEvidence: { empty: false, evidenceRefCount: 2 },
+    delivery: { target: "explicit", channel: "dm", recipient: "user-1" },
+};
+test("T2.3.2 delivery failed writes attempt + operator fallback and returns delivery_unavailable", async () => {
+    const state = createStateDatabase(":memory:");
+    const guidance = createDraftOutreachMessagePort();
+    const result = await dispatchUserOutreachIntent({
+        candidate,
+        snapshot: makeSnapshot("2026-05-02T14:00:00.000Z"),
+        judgeInput: judgeBase,
+        guidance,
+        delivery: {
+            sendDeliveryRequest: async () => ({
+                id: "att-failed-1",
+                status: "failed",
+                errorClass: "transport_failure",
+            }),
+        },
+        state,
+    });
+    assert.equal(result.status, "delivery_unavailable");
+    assert.ok(result.fallbackRef?.startsWith("fallback:"));
+    assert.equal(result.deliveryAttemptId, "att-failed-1");
+    const rows = await listDeliveryAttemptsByDecisionId(state, result.decisionId);
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].status, "failed");
+    assert.equal(rows[0].fallbackRef, result.fallbackRef);
+    state.close();
+});
+test("T2.3.2 host sent without messageId or hostProofRef is delivery_unavailable with delivery_proof_missing", async () => {
+    const state = createStateDatabase(":memory:");
+    const guidance = createDraftOutreachMessagePort();
+    const result = await dispatchUserOutreachIntent({
+        candidate: { ...candidate, id: "c-no-proof" },
+        snapshot: makeSnapshot("2026-05-02T14:10:00.000Z"),
+        judgeInput: judgeBase,
+        guidance,
+        delivery: {
+            sendDeliveryRequest: async () => ({
+                id: "att-no-proof",
+                status: "sent",
+            }),
+        },
+        state,
+    });
+    assert.equal(result.status, "delivery_unavailable");
+    assert.ok(result.fallbackRef?.startsWith("fallback:"));
+    const rows = await listDeliveryAttemptsByDecisionId(state, result.decisionId);
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].status, "failed");
+    assert.equal(rows[0].errorClass, "delivery_proof_missing");
+    state.close();
+});
+test("T2.3.2 dropped_by_host_policy writes attempt + fallback", async () => {
+    const state = createStateDatabase(":memory:");
+    const guidance = createDraftOutreachMessagePort();
+    const result = await dispatchUserOutreachIntent({
+        candidate: { ...candidate, id: "c-drop" },
+        snapshot: makeSnapshot("2026-05-02T14:05:00.000Z"),
+        judgeInput: judgeBase,
+        guidance,
+        delivery: {
+            sendDeliveryRequest: async () => ({
+                id: "att-drop-1",
+                status: "dropped_by_host_policy",
+                errorClass: "dropped_by_host_policy",
+            }),
+        },
+        state,
+    });
+    assert.equal(result.status, "delivery_unavailable");
+    const rows = await listDeliveryAttemptsByDecisionId(state, result.decisionId);
+    assert.equal(rows[0].status, "dropped_by_host_policy");
+    state.close();
+});

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

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

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

@@ -0,0 +1,109 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+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";
+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 };
+}
+function createMinimalAffordanceAssembler() {
+    return {
+        async assembleAffordanceMap() {
+            return {};
+        },
+        invalidateCache() {
+            /* no-op */
+        },
+    };
+}
+function setupDreamOutputTable(db) {
+    db.sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS dream_output_index (
+      output_id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'candidate',
+      canonical_entries_json TEXT NOT NULL DEFAULT '[]',
+      insights_json TEXT NOT NULL DEFAULT '[]',
+      narrative_update_json TEXT,
+      relationship_update_json TEXT,
+      validation_json TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+function insertDreamOutput(db, outputId, runId, status) {
+    const stmt = db.sqlite.prepare(`INSERT INTO dream_output_index
+     (output_id, run_id, status, canonical_entries_json, insights_json, validation_json, created_at)
+     VALUES (?, ?, ?, '[]', '[]', '{}', datetime('now'))`);
+    stmt.run([outputId, runId, status]);
+    stmt.free();
+}
+test("T-DQS.C.5 accepted projection is loaded by EmbodiedContextAssembler", async () => {
+    const { db, statePort } = buildBaseDeps();
+    setupDreamOutputTable(db);
+    insertDreamOutput(db, "out-accepted-1", "run-1", "accepted");
+    insertDreamOutput(db, "out-candidate-1", "run-2", "candidate");
+    insertDreamOutput(db, "out-archived-1", "run-3", "archived");
+    const assembler = createEmbodiedContextAssembler({
+        statePort,
+        affordanceAssembler: createMinimalAffordanceAssembler(),
+    });
+    const context = await assembler.assembleEmbodiedContext();
+    assert.equal(context.acceptedDream.status, "loaded");
+    assert.equal(context.acceptedDream.data.length, 1);
+    assert.equal(context.acceptedDream.data[0].outputId, "out-accepted-1");
+});
+test("T-DQS.C.5 candidate projection is excluded from heartbeat context", async () => {
+    const { db, statePort } = buildBaseDeps();
+    setupDreamOutputTable(db);
+    insertDreamOutput(db, "out-candidate-1", "run-1", "candidate");
+    const assembler = createEmbodiedContextAssembler({
+        statePort,
+        affordanceAssembler: createMinimalAffordanceAssembler(),
+    });
+    const context = await assembler.assembleEmbodiedContext();
+    assert.equal(context.acceptedDream.status, "degraded");
+    assert.equal(context.acceptedDream.data.length, 0);
+    assert.equal(context.acceptedDream.reason, "context_degraded:dream_projection_unavailable");
+});
+test("T-DQS.C.5 empty accepted projection returns degraded reason code", async () => {
+    const { db, statePort } = buildBaseDeps();
+    setupDreamOutputTable(db);
+    const assembler = createEmbodiedContextAssembler({
+        statePort,
+        affordanceAssembler: createMinimalAffordanceAssembler(),
+    });
+    const context = await assembler.assembleEmbodiedContext();
+    assert.equal(context.acceptedDream.status, "degraded");
+    assert.equal(context.acceptedDream.data.length, 0);
+    assert.equal(context.acceptedDream.reason, "context_degraded:dream_projection_unavailable");
+});
+test("T-DQS.C.5 loadAcceptedDreamProjection filters by accepted status only", async () => {
+    const { db, statePort } = buildBaseDeps();
+    setupDreamOutputTable(db);
+    insertDreamOutput(db, "out-accepted-1", "run-1", "accepted");
+    insertDreamOutput(db, "out-accepted-2", "run-2", "accepted");
+    insertDreamOutput(db, "out-candidate-1", "run-3", "candidate");
+    insertDreamOutput(db, "out-archived-1", "run-4", "archived");
+    const result = await statePort.loadAcceptedDreamProjection(10);
+    assert.equal(result.status, "loaded");
+    assert.equal(result.data.length, 2);
+    const ids = result.data.map((d) => d.outputId).sort();
+    assert.deepEqual(ids, ["out-accepted-1", "out-accepted-2"]);
+});

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

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