@haaaiawd/second-nature 0.1.50 → 0.1.51

package/dist/tests/integration/storage/schema-migration.test.js

@@ -1,183 +0,0 @@
-/**
- * T-SMS.F.2 — Schema migration integration tests.
- *
- * Verification (05A / 05B):
- * - Fresh DB: v7-001 migration creates all tables, schema_version = 1
- * - Old schema: pending migrations applied sequentially
- * - Failed SQL: marks degraded, existing data preserved
- *
- * Dependencies: sql.js, migration-runner, v7-001-foundation
- */
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import initSqlJs from "sql.js";
-import { runMigrations, isMigrationFailed, } from "../../../src/storage/db/migration-runner.js";
-import { ALL_MIGRATIONS } from "../../../src/storage/db/migrations/index.js";
-async function createMemoryDb() {
-    const SQL = await initSqlJs();
-    return new SQL.Database();
-}
-const V7_EXPECTED_TABLES = [
-    "identity_profile",
-    "tool_experience",
-    "daily_diary_index",
-    "dream_output_index",
-    "capability_probe_result",
-    "restore_snapshot",
-    "runtime_secret_anchor",
-    "heartbeat_digest",
-    "narrative_timeline",
-];
-describe("schema-migration integration (v7-001)", () => {
-    // SKIP (pre-existing, v7 initial): schema version assertion mismatch due to v7 schema drift.
-    // Justification: Migration fixture pre-creates legacy agent_goal table, causing v7-001 ALTER conflicts;
-    // migration runner itself is correct, fixture needs alignment with current schema bootstrap.
-    it.skip("fresh DB: all v7 tables created and schema_version = 1", async () => {
-        const sqlite = await createMemoryDb();
-        // Pre-create the legacy tables that v7-001 extends
-        sqlite.exec(`
-      CREATE TABLE IF NOT EXISTS agent_goal (
-        goal_id TEXT PRIMARY KEY,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        origin TEXT NOT NULL,
-        description TEXT NOT NULL,
-        completion_criteria TEXT NOT NULL,
-        risk TEXT NOT NULL,
-        priority_hint INTEGER NOT NULL DEFAULT 0,
-        source_refs_json TEXT NOT NULL,
-        accepted_by TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-    `);
-        const result = runMigrations(sqlite, ALL_MIGRATIONS);
-        assert.equal(result.schemaVersion, 1);
-        assert.deepEqual(result.applied, [1]);
-        assert.equal(result.failed, false);
-        assert.equal(isMigrationFailed(sqlite), false);
-        // Verify all expected tables exist
-        for (const table of V7_EXPECTED_TABLES) {
-            const check = sqlite.exec(`SELECT name FROM sqlite_master WHERE type='table' AND name='${table}'`);
-            assert.equal(check.length, 1, `Expected table '${table}' to exist`);
-        }
-        // Verify agent_goal v7 columns exist
-        const goalInfo = sqlite.exec("PRAGMA table_info(agent_goal)");
-        const columnNames = goalInfo[0].values.map((row) => row[1]);
-        assert.ok(columnNames.includes("scope"), "agent_goal should have 'scope' column");
-        assert.ok(columnNames.includes("expires_at"), "agent_goal should have 'expires_at' column");
-        sqlite.close();
-    });
-    // SKIP (pre-existing, v7 initial): same root cause as fresh-DB test — fixture legacy table causes idempotency mismatch.
-    it.skip("re-running migrations on migrated DB is idempotent", async () => {
-        const sqlite = await createMemoryDb();
-        sqlite.exec(`
-      CREATE TABLE IF NOT EXISTS agent_goal (
-        goal_id TEXT PRIMARY KEY,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        origin TEXT NOT NULL,
-        description TEXT NOT NULL,
-        completion_criteria TEXT NOT NULL,
-        risk TEXT NOT NULL,
-        priority_hint INTEGER NOT NULL DEFAULT 0,
-        source_refs_json TEXT NOT NULL,
-        accepted_by TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-    `);
-        runMigrations(sqlite, ALL_MIGRATIONS);
-        const result2 = runMigrations(sqlite, ALL_MIGRATIONS);
-        assert.equal(result2.schemaVersion, 1);
-        assert.deepEqual(result2.applied, []);
-        assert.equal(result2.failed, false);
-        sqlite.close();
-    });
-    // SKIP (pre-existing, v7 initial): same root cause as fresh-DB test — fixture legacy table causes assertion mismatch.
-    it.skip("failed migration SQL marks degraded without losing data", async () => {
-        const sqlite = await createMemoryDb();
-        sqlite.exec(`
-      CREATE TABLE IF NOT EXISTS agent_goal (
-        goal_id TEXT PRIMARY KEY,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        origin TEXT NOT NULL,
-        description TEXT NOT NULL,
-        completion_criteria TEXT NOT NULL,
-        risk TEXT NOT NULL,
-        priority_hint INTEGER NOT NULL DEFAULT 0,
-        source_refs_json TEXT NOT NULL,
-        accepted_by TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-      INSERT INTO agent_goal (goal_id, kind, status, origin, description,
-        completion_criteria, risk, priority_hint, source_refs_json,
-        created_at, updated_at)
-      VALUES ('g1', 'short_term', 'accepted', 'owner_set', 'test',
-        'criteria', 'low', 1, '["ref1"]',
-        '2026-01-01T00:00:00Z', '2026-01-01T00:00:00Z');
-    `);
-        // Inject a bad migration after the real ones
-        const migrationsWithBad = [
-            ...ALL_MIGRATIONS,
-            {
-                version: 999,
-                label: "intentionally-broken",
-                sql: "ALTER TABLE nonexistent_table ADD COLUMN x TEXT;",
-            },
-        ];
-        const result = runMigrations(sqlite, migrationsWithBad);
-        assert.equal(result.failed, true);
-        assert.equal(result.failedVersion, 999);
-        assert.equal(result.schemaVersion, 1); // v7-001 succeeded
-        assert.equal(isMigrationFailed(sqlite), true);
-        // Existing data preserved
-        const rows = sqlite.exec("SELECT goal_id FROM agent_goal WHERE goal_id = 'g1'");
-        assert.equal(rows[0].values[0][0], "g1");
-        sqlite.close();
-    });
-    it("v7 tables have correct column defaults (DEFAULT NULL)", async () => {
-        const sqlite = await createMemoryDb();
-        sqlite.exec(`
-      CREATE TABLE IF NOT EXISTS agent_goal (
-        goal_id TEXT PRIMARY KEY,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        origin TEXT NOT NULL,
-        description TEXT NOT NULL,
-        completion_criteria TEXT NOT NULL,
-        risk TEXT NOT NULL,
-        priority_hint INTEGER NOT NULL DEFAULT 0,
-        source_refs_json TEXT NOT NULL,
-        accepted_by TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-    `);
-        runMigrations(sqlite, ALL_MIGRATIONS);
-        // Insert into identity_profile with minimal fields
-        sqlite.exec(`
-      INSERT INTO identity_profile (profile_id, canonical_name, updated_at)
-      VALUES ('p1', 'TestAgent', '2026-01-01T00:00:00Z');
-    `);
-        const rows = sqlite.exec("SELECT canonical_avatar, canonical_bio FROM identity_profile WHERE profile_id = 'p1'");
-        // Should be NULL (default)
-        assert.equal(rows[0].values[0][0], null);
-        assert.equal(rows[0].values[0][1], null);
-        // agent_goal scope/expires_at should be NULL for pre-existing rows
-        sqlite.exec(`
-      INSERT INTO agent_goal (goal_id, kind, status, origin, description,
-        completion_criteria, risk, priority_hint, source_refs_json,
-        created_at, updated_at)
-      VALUES ('g-new', 'short_term', 'proposal', 'agent_proposed', 'desc',
-        'criteria', 'low', 0, '["ref"]',
-        '2026-01-01T00:00:00Z', '2026-01-01T00:00:00Z');
-    `);
-        const goalRows = sqlite.exec("SELECT scope, expires_at FROM agent_goal WHERE goal_id = 'g-new'");
-        assert.equal(goalRows[0].values[0][0], null);
-        assert.equal(goalRows[0].values[0][1], null);
-        sqlite.close();
-    });
-});

package/dist/tests/integration/storage/storage-mode-smoke.test.d.ts

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

package/dist/tests/integration/storage/storage-mode-smoke.test.js

@@ -1,18 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { runStorageModeSmoke } from "../../../src/storage/bootstrap/storage-mode-smoke.js";
-test("T4.1.4 runStorageModeSmoke — sql.js runtime, no WAL assumption, native probe present", async () => {
-    const report = await runStorageModeSmoke({});
-    assert.equal(report.runtimeIndexDriver, "sql_js");
-    assert.equal(report.semantics.sqlJs.walAssumed, false);
-    assert.match(report.semantics.sqlJs.journalConcurrencyNotes, /sql\.js|WASM/i);
-    assert.match(report.semantics.sqlJs.backupNotes, /export|manifest/i);
-    assert.equal(report.nativeSqliteProbe.runtimeUsesNativeDriver, false);
-    assert.equal(typeof report.nativeSqliteProbe.moduleLoadOk, "boolean");
-});
-test("T4.1.4 repair fixture replays evidence artifact into index (sql.js path)", async () => {
-    const report = await runStorageModeSmoke({ runRepairFixture: true });
-    assert.ok(report.repairFromArtifactsFixture?.ran);
-    assert.equal(report.repairFromArtifactsFixture?.repairStatus, "ok");
-    assert.ok((report.repairFromArtifactsFixture?.repairedEvidenceIndexRows ?? 0) >= 1);
-});

package/dist/tests/integration/storage/t4-1-5-memory-store-lifecycle.test.d.ts

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

package/dist/tests/integration/storage/t4-1-5-memory-store-lifecycle.test.js

@@ -1,118 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createStateDatabase } from "../../../src/storage/db/index.js";
-import { createMemoryStoreLifecycle, } from "../../../src/storage/memory-store/memory-store-lifecycle.js";
-function makeWrite(overrides = {}) {
-    return {
-        memoryStoreId: `ms-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-        lifecycleStatus: "candidate",
-        createdAt: new Date().toISOString(),
-        inputMemoryStoreId: "input-1",
-        dreamRunId: "dream-1",
-        canonicalEntries: [{ entryId: "e1", kind: "insight", summary: "test", sourceRefs: [], createdAt: new Date().toISOString() }],
-        insights: [{ id: "i1", type: "pattern", summary: "pattern A", sourceRefs: ["s1"], confidence: 0.8 }],
-        validation: { passed: true, summary: "ok", checkedAt: new Date().toISOString() },
-        ...overrides,
-    };
-}
-test("writeMemoryStore writes candidate and load returns it", async () => {
-    const db = createStateDatabase(":memory:");
-    const port = createMemoryStoreLifecycle(db);
-    const write = makeWrite();
-    const ack = await port.writeMemoryStore(write);
-    assert.equal(ack.memoryStoreId, write.memoryStoreId);
-    assert.equal(ack.status, "acknowledged");
-    const loaded = await port.loadMemoryStore(write.memoryStoreId);
-    assert.ok(loaded);
-    assert.equal(loaded.lifecycleStatus, "candidate");
-    assert.equal(loaded.inputMemoryStoreId, "input-1");
-    assert.equal(loaded.canonicalEntries.length, 1);
-});
-test("transitionMemoryStoreLifecycle candidate -> accepted updates active pointer", async () => {
-    const db = createStateDatabase(":memory:");
-    const port = createMemoryStoreLifecycle(db);
-    const write = makeWrite();
-    await port.writeMemoryStore(write);
-    const transition = {
-        memoryStoreId: write.memoryStoreId,
-        newStatus: "accepted",
-        updatedAt: new Date().toISOString(),
-    };
-    const ack = await port.transitionMemoryStoreLifecycle(transition);
-    assert.equal(ack.status, "acknowledged");
-    const loaded = await port.loadMemoryStore(write.memoryStoreId);
-    assert.equal(loaded.lifecycleStatus, "accepted");
-    const projection = await port.loadAcceptedMemoryProjection();
-    assert.ok(projection);
-    assert.equal(projection.memoryStoreId, write.memoryStoreId);
-});
-test("transitionMemoryStoreLifecycle candidate -> archived on validation failure", async () => {
-    const db = createStateDatabase(":memory:");
-    const port = createMemoryStoreLifecycle(db);
-    const write = makeWrite();
-    await port.writeMemoryStore(write);
-    await port.transitionMemoryStoreLifecycle({
-        memoryStoreId: write.memoryStoreId,
-        newStatus: "archived",
-        validation: { passed: false, summary: "unsupported claims detected", checkedAt: new Date().toISOString(), unsupportedClaims: ["bad claim"] },
-        updatedAt: new Date().toISOString(),
-    });
-    const loaded = await port.loadMemoryStore(write.memoryStoreId);
-    assert.equal(loaded.lifecycleStatus, "archived");
-    const projection = await port.loadAcceptedMemoryProjection();
-    assert.equal(projection, null);
-});
-test("loadAcceptedMemoryProjection only reads accepted stores", async () => {
-    const db = createStateDatabase(":memory:");
-    const port = createMemoryStoreLifecycle(db);
-    const candidate = makeWrite({ memoryStoreId: "c1" });
-    const accepted = makeWrite({ memoryStoreId: "a1", lifecycleStatus: "accepted" });
-    await port.writeMemoryStore(candidate);
-    await port.writeMemoryStore(accepted);
-    const projection = await port.loadAcceptedMemoryProjection();
-    assert.ok(projection);
-    assert.equal(projection.memoryStoreId, "a1");
-});
-test("inputMemoryStoreId remains unchanged after write", async () => {
-    const db = createStateDatabase(":memory:");
-    const port = createMemoryStoreLifecycle(db);
-    const write = makeWrite({ inputMemoryStoreId: "immutable-input" });
-    await port.writeMemoryStore(write);
-    const loaded = await port.loadMemoryStore(write.memoryStoreId);
-    assert.equal(loaded.inputMemoryStoreId, "immutable-input");
-});
-test("listMemoryStoresByStatus filters correctly", async () => {
-    const db = createStateDatabase(":memory:");
-    const port = createMemoryStoreLifecycle(db);
-    await port.writeMemoryStore(makeWrite({ memoryStoreId: "c1" }));
-    await port.writeMemoryStore(makeWrite({ memoryStoreId: "c2" }));
-    await port.writeMemoryStore(makeWrite({ memoryStoreId: "a1", lifecycleStatus: "accepted" }));
-    const candidates = await port.listMemoryStoresByStatus("candidate");
-    assert.equal(candidates.length, 2);
-    const accepted = await port.listMemoryStoresByStatus("accepted");
-    assert.equal(accepted.length, 1);
-    assert.equal(accepted[0].memoryStoreId, "a1");
-});
-test("transition on missing store returns degraded", async () => {
-    const db = createStateDatabase(":memory:");
-    const port = createMemoryStoreLifecycle(db);
-    const ack = await port.transitionMemoryStoreLifecycle({
-        memoryStoreId: "missing",
-        newStatus: "accepted",
-        updatedAt: new Date().toISOString(),
-    });
-    assert.equal(ack.status, "degraded");
-});
-test("writeMemoryStore update replaces existing candidate", async () => {
-    const db = createStateDatabase(":memory:");
-    const port = createMemoryStoreLifecycle(db);
-    const write = makeWrite({ canonicalEntries: [{ entryId: "e1", kind: "insight", summary: "first", sourceRefs: [], createdAt: "" }] });
-    await port.writeMemoryStore(write);
-    await port.writeMemoryStore({
-        ...write,
-        canonicalEntries: [{ entryId: "e2", kind: "insight", summary: "second", sourceRefs: [], createdAt: "" }],
-    });
-    const loaded = await port.loadMemoryStore(write.memoryStoreId);
-    assert.equal(loaded.canonicalEntries.length, 1);
-    assert.equal(loaded.canonicalEntries[0].summary, "second");
-});

package/dist/tests/unit/body/affordance-assembler.test.d.ts

@@ -1,14 +0,0 @@
-/**
- * AffordanceAssembler tests — T-BTS.C.1
- *
- * Coverage:
- * - assembleAffordanceMap builds platform→capability map from registry + probes
- * - probe available → safe; degraded → exploratory; unavailable → unavailable
- * - no probe + credential required → needs_auth
- * - no probe + no credential required → unavailable
- * - cache hit on second call with same scope
- * - invalidateCache causes rebuild
- * - P95 < 1s for 50 manifests (smoke)
- * - contextScope filtering applied (platformIds, allowedStatuses)
- */
-export {};

package/dist/tests/unit/body/affordance-assembler.test.js

@@ -1,259 +0,0 @@
-/**
- * AffordanceAssembler tests — T-BTS.C.1
- *
- * Coverage:
- * - assembleAffordanceMap builds platform→capability map from registry + probes
- * - probe available → safe; degraded → exploratory; unavailable → unavailable
- * - no probe + credential required → needs_auth
- * - no probe + no credential required → unavailable
- * - cache hit on second call with same scope
- * - invalidateCache causes rebuild
- * - P95 < 1s for 50 manifests (smoke)
- * - contextScope filtering applied (platformIds, allowedStatuses)
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { createAffordanceAssembler } from "../../../src/core/second-nature/body/tool-affordance/affordance-assembler.js";
-import { CapabilityContractRegistryV7 } from "../../../src/connectors/base/manifest-v7.js";
-function buildRegistry(capCount) {
-    const reg = new CapabilityContractRegistryV7();
-    for (let p = 0; p < capCount; p++) {
-        reg.register({
-            platformId: `platform-${p}`,
-            capabilities: [
-                {
-                    capabilityId: `cap-${p}-read`,
-                    intent: "feed.read",
-                    probeConfig: {
-                        safeEndpoint: `http://localhost:${9000 + p}/health`,
-                        idempotencyClass: "read_only",
-                    },
-                },
-                {
-                    capabilityId: `cap-${p}-write`,
-                    intent: "post.publish",
-                    probeConfig: {
-                        safeEndpoint: `http://localhost:${9000 + p}/post`,
-                        idempotencyClass: "idempotent_write",
-                    },
-                },
-            ],
-            channelPriority: ["api_rest"],
-            credentialTypes: ["token"],
-        });
-    }
-    return reg;
-}
-function buildProbeReader(overrides) {
-    return {
-        getLatestProbeResult(platformId, capabilityId) {
-            const key = `${platformId}:${capabilityId}`;
-            const status = overrides[key];
-            if (!status)
-                return undefined;
-            return {
-                actualStatus: status,
-                createdAt: new Date().toISOString(),
-            };
-        },
-    };
-}
-describe("AffordanceAssembler", () => {
-    it("maps available probe to safe", async () => {
-        const reg = buildRegistry(1);
-        const reader = buildProbeReader({
-            "platform-0:cap-0-read": "available",
-        });
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-        });
-        const map = await assembler.assembleAffordanceMap();
-        const items = map["platform-0"] ?? [];
-        const readItem = items.find((i) => i.capabilityId === "cap-0-read");
-        assert.strictEqual(readItem.status, "safe");
-    });
-    it("maps degraded probe to exploratory", async () => {
-        const reg = buildRegistry(1);
-        const reader = buildProbeReader({
-            "platform-0:cap-0-write": "degraded",
-        });
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-        });
-        const map = await assembler.assembleAffordanceMap();
-        const items = map["platform-0"] ?? [];
-        const writeItem = items.find((i) => i.capabilityId === "cap-0-write");
-        assert.strictEqual(writeItem.status, "exploratory");
-    });
-    it("maps unavailable probe to unavailable (filtered out by default scope)", async () => {
-        const reg = buildRegistry(1);
-        const reader = buildProbeReader({
-            "platform-0:cap-0-read": "unavailable",
-        });
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-        });
-        const map = await assembler.assembleAffordanceMap();
-        // unavailable capability is filtered by default scope, while same-platform
-        // needs_auth capabilities remain available to heartbeat.
-        const items = map["platform-0"] ?? [];
-        assert.strictEqual(items.some((i) => i.capabilityId === "cap-0-read"), false);
-        assert(items.some((i) => i.status === "needs_auth"), "default scope should retain needs_auth capabilities");
-    });
-    it("no probe + credential required → needs_auth", async () => {
-        const reg = buildRegistry(1);
-        const reader = buildProbeReader({});
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-        });
-        const map = await assembler.assembleAffordanceMap();
-        const items = map["platform-0"] ?? [];
-        assert(items.length > 0);
-        assert(items.every((i) => i.status === "needs_auth"));
-    });
-    it("no probe + no credential required → unavailable", async () => {
-        const reg = buildRegistry(1);
-        const reader = buildProbeReader({});
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => false,
-        });
-        const map = await assembler.assembleAffordanceMap();
-        const items = map["platform-0"] ?? [];
-        // unavailable is filtered by default scope, so platform-0 should not appear
-        assert.strictEqual(items.length, 0);
-        // Verify with custom scope that includes unavailable
-        const fullMap = await assembler.assembleAffordanceMap({
-            allowedStatuses: ["safe", "exploratory", "needs_auth", "unavailable"],
-        });
-        const fullItems = fullMap["platform-0"] ?? [];
-        assert(fullItems.every((i) => i.status === "unavailable"));
-    });
-    it("caches results and returns cached on second call", async () => {
-        const reg = buildRegistry(1);
-        let callCount = 0;
-        const reader = {
-            getLatestProbeResult() {
-                callCount++;
-                return {
-                    actualStatus: "available",
-                    createdAt: new Date().toISOString(),
-                };
-            },
-        };
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-            ttlMs: 60_000,
-        });
-        await assembler.assembleAffordanceMap();
-        const firstCount = callCount;
-        await assembler.assembleAffordanceMap();
-        assert.strictEqual(callCount, firstCount); // no extra probe calls
-    });
-    it("invalidateCache causes rebuild", async () => {
-        const reg = buildRegistry(1);
-        let callCount = 0;
-        const reader = {
-            getLatestProbeResult() {
-                callCount++;
-                return {
-                    actualStatus: "available",
-                    createdAt: new Date().toISOString(),
-                };
-            },
-        };
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-            ttlMs: 60_000,
-        });
-        await assembler.assembleAffordanceMap();
-        const firstCount = callCount;
-        assembler.invalidateCache();
-        await assembler.assembleAffordanceMap();
-        assert.strictEqual(callCount, firstCount + 2); // 2 capabilities
-    });
-    it("P95 < 1s for 50 manifests", async () => {
-        const reg = buildRegistry(50);
-        const reader = buildProbeReader({});
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-        });
-        const start = performance.now();
-        await assembler.assembleAffordanceMap();
-        const elapsed = performance.now() - start;
-        assert(elapsed < 1000, `assembleAffordanceMap took ${elapsed}ms, exceeds 1s P95 target`);
-    });
-    it("contextScope.platformIds filters output", async () => {
-        const reg = buildRegistry(3);
-        const reader = buildProbeReader({
-            "platform-1:cap-1-read": "available",
-        });
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-        });
-        const map = await assembler.assembleAffordanceMap({
-            platformIds: ["platform-1"],
-        });
-        assert.deepStrictEqual(Object.keys(map), ["platform-1"]);
-    });
-    it("contextScope.allowedStatuses custom filter", async () => {
-        const reg = buildRegistry(2);
-        const reader = buildProbeReader({
-            "platform-0:cap-0-read": "available",
-            "platform-0:cap-0-write": "degraded",
-            "platform-1:cap-1-read": "available",
-        });
-        const assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: reader,
-            credentialRequired: () => true,
-        });
-        const map = await assembler.assembleAffordanceMap({
-            allowedStatuses: ["safe"],
-        });
-        for (const items of Object.values(map)) {
-            for (const item of items) {
-                assert.strictEqual(item.status, "safe");
-            }
-        }
-    });
-    it("built-in platforms without probe → needs_auth (not unavailable)", async () => {
-        const reg = new CapabilityContractRegistryV7();
-        reg.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 assembler = createAffordanceAssembler({
-            registry: reg,
-            probeReader: { getLatestProbeResult: () => undefined },
-            credentialRequired: (platformId) => ["moltbook", "evomap", "agent-world", "instreet"].includes(platformId),
-        });
-        const map = await assembler.assembleAffordanceMap({
-            allowedStatuses: ["safe", "exploratory", "needs_auth"],
-        });
-        const items = map["moltbook"] ?? [];
-        assert(items.length > 0, "moltbook should appear in affordance map");
-        assert.strictEqual(items[0].status, "needs_auth", "built-in without probe should posture as needs_auth");
-    });
-});

package/dist/tests/unit/body/affordance-context-scope.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * AffordanceContextScope tests — T-BTS.C.2
- *
- * Coverage:
- * - default allowedStatuses filters to safe + exploratory + needs_auth
- * - blocked (unavailable) always excluded even if in allowedStatuses
- * - platformIds whitelist
- * - goalKind passive_sensing only exposes read-only intents
- * - goalKind task_completion does not filter out read intents
- * - empty platformIds = all platforms
- */
-export {};