@haaaiawd/second-nature 0.1.50 → 0.2.0

package/dist/tests/unit/connectors/scriptable-node-runner.test.js

@@ -1,246 +0,0 @@
-/**
- * T-CS.C.11 — Scriptable node runner unit tests.
- *
- * Verifies createScriptableNodeRunner:
- * - manifest declares scriptable_node → executor loads and calls runner.mjs default export
- * - runner.mjs missing → configuration_missing with path
- * - runner.mjs throws → script_error with message
- * - runner.mjs timeout → timeout
- * - manifest schema accepts scriptable_node kind
- */
-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 { createConnectorExecutorAdapter } from "../../../src/connectors/services/connector-executor-adapter.js";
-import { createCredentialVault } from "../../../src/storage/services/credential-vault.js";
-const ORIGINAL_KEY = process.env.SECOND_NATURE_ENCRYPTION_KEY;
-test.beforeEach(() => {
-    process.env.SECOND_NATURE_ENCRYPTION_KEY = "x".repeat(32);
-});
-test.afterEach(() => {
-    if (ORIGINAL_KEY === undefined)
-        delete process.env.SECOND_NATURE_ENCRYPTION_KEY;
-    else
-        process.env.SECOND_NATURE_ENCRYPTION_KEY = ORIGINAL_KEY;
-});
-async function seedCredential(stateDb) {
-    const vault = createCredentialVault(stateDb.db);
-    await vault.saveCredentialContext({
-        platformId: "scriptable-platform",
-        credentialType: "api_key",
-        encryptedValue: "mock-token",
-        status: "active",
-    });
-}
-function makeWorkspaceWithRunner(scriptContent, runnerConfig) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-scriptable-"));
-    const connectorsDir = path.join(dir, ".second-nature", "connectors", "scriptable-platform");
-    fs.mkdirSync(connectorsDir, { recursive: true });
-    const configBlock = runnerConfig
-        ? `  config:\n${Object.entries(runnerConfig)
-            .map(([k, v]) => `    ${k}: ${JSON.stringify(v)}`)
-            .join("\n")}\n`
-        : "";
-    fs.writeFileSync(path.join(connectorsDir, "manifest.yaml"), `schemaVersion: "sn.connector.v1"
-platformId: "scriptable-platform"
-displayName: "Scriptable Platform"
-family: "custom"
-capabilities:
-  - id: "task.run"
-    channel: "api_rest"
-runner:
-  kind: "scriptable_node"
-  entrypoint: "runner.mjs"
-${configBlock}credentials:
-  - type: "api_key"
-    required: false
-sourceRefPolicy:
-  minSourceRefs: 1
-trust:
-  status: "declarative_trusted"
-`, "utf-8");
-    fs.writeFileSync(path.join(connectorsDir, "runner.mjs"), scriptContent, "utf-8");
-    return dir;
-}
-test("T-CS.C.11-A: scriptable_node executor loads runner.mjs and returns success", async () => {
-    const workspaceRoot = makeWorkspaceWithRunner(`
-export default async function handler(input) {
-  return { success: true, data: { result: "hello-from-script", intent: input.intent } };
-}
-`);
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot,
-        });
-        const result = await executor.executeEffect({
-            intent: "task.run",
-            platformId: "scriptable-platform",
-            payload: { value: 42 },
-            decisionId: "dec-script-1",
-            intentId: "intent-script-1",
-            idempotencyKey: "script-task-1",
-        });
-        assert.equal(result.status, "success", `expected success, got ${JSON.stringify(result)}`);
-        assert.ok(result.data, "result must contain data");
-        const payload = result.data;
-        const data = payload.data;
-        assert.equal(data.result, "hello-from-script");
-    }
-    finally {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-});
-test("T-CS.C.11-B: missing runner.mjs returns configuration_missing", async () => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-scriptable-missing-"));
-    const connectorsDir = path.join(dir, ".second-nature", "connectors", "scriptable-platform");
-    fs.mkdirSync(connectorsDir, { recursive: true });
-    fs.writeFileSync(path.join(connectorsDir, "manifest.yaml"), `schemaVersion: "sn.connector.v1"
-platformId: "scriptable-platform"
-displayName: "Scriptable Platform"
-family: "custom"
-capabilities:
-  - id: "task.run"
-    channel: "api_rest"
-runner:
-  kind: "scriptable_node"
-  entrypoint: "runner.mjs"
-credentials:
-  - type: "api_key"
-    required: false
-sourceRefPolicy:
-  minSourceRefs: 1
-trust:
-  status: "declarative_trusted"
-`, "utf-8");
-    // Note: runner.mjs intentionally not written
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot: dir,
-        });
-        const result = await executor.executeEffect({
-            intent: "task.run",
-            platformId: "scriptable-platform",
-            payload: {},
-            decisionId: "dec-script-2",
-            intentId: "intent-script-2",
-            idempotencyKey: "script-task-2",
-        });
-        assert.equal(result.status, "terminal_failure");
-        assert.equal(result.failureClass, "configuration_missing");
-        assert.ok(JSON.stringify(result).includes("runner.mjs"));
-    }
-    finally {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-test("T-CS.C.11-C: runner.mjs throws returns script_error", async () => {
-    const workspaceRoot = makeWorkspaceWithRunner(`
-export default async function handler() {
-  throw new Error("intentional_runner_crash");
-}
-`);
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot,
-        });
-        const result = await executor.executeEffect({
-            intent: "task.run",
-            platformId: "scriptable-platform",
-            payload: {},
-            decisionId: "dec-script-3",
-            intentId: "intent-script-3",
-            idempotencyKey: "script-task-3",
-        });
-        assert.equal(result.status, "terminal_failure");
-        assert.equal(result.failureClass, "script_error");
-        assert.ok(JSON.stringify(result).includes("intentional_runner_crash"));
-    }
-    finally {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-});
-test("T-CS.C.11-D: runner.mjs timeout returns timeout", async () => {
-    const workspaceRoot = makeWorkspaceWithRunner(`
-export default async function handler() {
-  await new Promise((resolve) => setTimeout(resolve, 20000));
-  return { success: true };
-}
-`);
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot,
-        });
-        const result = await executor.executeEffect({
-            intent: "task.run",
-            platformId: "scriptable-platform",
-            payload: {},
-            decisionId: "dec-script-4",
-            intentId: "intent-script-4",
-            idempotencyKey: "script-task-4",
-        });
-        assert.equal(result.status, "terminal_failure");
-        assert.equal(result.failureClass, "timeout");
-    }
-    finally {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-});
-test("T-CS.C.11-E: manifest runner.config.timeoutMs overrides default timeout", async () => {
-    const workspaceRoot = makeWorkspaceWithRunner(`
-export default async function handler() {
-  await new Promise((resolve) => setTimeout(resolve, 2000));
-  return { success: true };
-}
-`, { timeoutMs: 500 });
-    try {
-        const stateDb = createStateDatabase(":memory:");
-        const observabilityDb = createObservabilityDatabase(":memory:");
-        await seedCredential(stateDb);
-        const executor = createConnectorExecutorAdapter({
-            stateDb,
-            observabilityDb,
-            workspaceRoot,
-        });
-        const t0 = Date.now();
-        const result = await executor.executeEffect({
-            intent: "task.run",
-            platformId: "scriptable-platform",
-            payload: {},
-            decisionId: "dec-script-5",
-            intentId: "intent-script-5",
-            idempotencyKey: "script-task-5",
-        });
-        const elapsed = Date.now() - t0;
-        assert.equal(result.status, "terminal_failure");
-        assert.equal(result.failureClass, "timeout");
-        assert.ok(elapsed < 3000, `expected timeout under 3s (500ms × 2 attempts + retry delay), but took ${elapsed}ms`);
-        assert.ok(JSON.stringify(result).includes("500ms"), `expected error detail to mention 500ms timeout, got ${JSON.stringify(result)}`);
-    }
-    finally {
-        fs.rmSync(workspaceRoot, { recursive: true, force: true });
-    }
-});

package/dist/tests/unit/connectors/structured-unavailable-reason.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * StructuredUnavailableReason tests — T-CS.C.3
- *
- * Coverage:
- * - Builder builds all reason codes
- * - Factory functions produce correct codes
- * - ConnectorResult includes executionId
- * - FailureClass mapping accuracy (failureClass comes from FailureTaxonomy)
- * - No silent failures (all paths return a reason)
- */
-export {};

package/dist/tests/unit/connectors/structured-unavailable-reason.test.js

@@ -1,76 +0,0 @@
-/**
- * StructuredUnavailableReason tests — T-CS.C.3
- *
- * Coverage:
- * - Builder builds all reason codes
- * - Factory functions produce correct codes
- * - ConnectorResult includes executionId
- * - FailureClass mapping accuracy (failureClass comes from FailureTaxonomy)
- * - No silent failures (all paths return a reason)
- */
-import { describe, it } from "node:test";
-import assert from "node:assert";
-import { UnavailableReasonBuilder, unavailableCredentialsMissing, unavailableNotRegistered, unavailableTrustDenied, unavailableCircuitOpen, unavailablePlatformError, unavailableProbeFailed, unavailableProbePolicyDenied, } from "../../../src/connectors/base/structured-unavailable-reason.js";
-describe("StructuredUnavailableReason", () => {
-    it("builder produces correct code and message", () => {
-        const reason = UnavailableReasonBuilder.for("not_registered", "Manifest not found")
-            .withPlatformId("twitter")
-            .withCapabilityId("feed.read")
-            .build();
-        assert.strictEqual(reason.code, "not_registered");
-        assert.strictEqual(reason.platformId, "twitter");
-        assert.strictEqual(reason.capabilityId, "feed.read");
-        assert(reason.timestamp !== undefined);
-    });
-    it("builder requires code and message", () => {
-        assert.throws(() => {
-            UnavailableReasonBuilder.for("credentials_missing", "").build();
-        }, /message is required/);
-    });
-    it("unavailableCredentialsMissing factory", () => {
-        const r = unavailableCredentialsMissing("twitter");
-        assert.strictEqual(r.code, "credentials_missing");
-        assert.strictEqual(r.platformId, "twitter");
-    });
-    it("unavailableNotRegistered factory", () => {
-        const r = unavailableNotRegistered("github");
-        assert.strictEqual(r.code, "not_registered");
-    });
-    it("unavailableTrustDenied factory", () => {
-        const r = unavailableTrustDenied("discord");
-        assert.strictEqual(r.code, "trust_denied");
-    });
-    it("unavailableCircuitOpen with retryAfterMs", () => {
-        const r = unavailableCircuitOpen("twitter", 300_000);
-        assert.strictEqual(r.code, "circuit_open");
-        assert.strictEqual(r.retryAfterMs, 300_000);
-    });
-    it("unavailablePlatformError with failureClass", () => {
-        const r = unavailablePlatformError("twitter", "transport_failure");
-        assert.strictEqual(r.code, "platform_error");
-        assert.strictEqual(r.failureClass, "transport_failure");
-    });
-    it("unavailableProbeFailed factory", () => {
-        const r = unavailableProbeFailed("twitter", "feed.read");
-        assert.strictEqual(r.code, "probe_failed");
-        assert.strictEqual(r.capabilityId, "feed.read");
-    });
-    it("unavailableProbePolicyDenied factory", () => {
-        const r = unavailableProbePolicyDenied("twitter", "post.publish");
-        assert.strictEqual(r.code, "probe_policy_denied");
-        assert.strictEqual(r.capabilityId, "post.publish");
-    });
-    it("ConnectorResult type accepts executionId", () => {
-        const result = {
-            status: "terminal_failure",
-            failureClass: "auth_failure",
-            executionId: "exec-123",
-            metadata: {
-                platformId: "twitter",
-                channel: "api_rest",
-                latencyMs: 120,
-            },
-        };
-        assert.strictEqual(result.executionId, "exec-123");
-    });
-});

package/dist/tests/unit/connectors/t3-1-1-dynamic-registry.test.d.ts

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

package/dist/tests/unit/connectors/t3-1-1-dynamic-registry.test.js

@@ -1,178 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import test from "node:test";
-import assert from "node:assert/strict";
-import yaml from "js-yaml";
-import { DynamicConnectorRegistry, createRegistrySnapshotStore, } from "../../../src/connectors/registry/dynamic-connector-registry.js";
-import { scanConnectorManifests } from "../../../src/connectors/registry/manifest-scanner.js";
-import { parseConnectorManifestV6 } from "../../../src/connectors/manifest/manifest-parser.js";
-import { classifyTrust, isExecutable } from "../../../src/connectors/registry/trust-policy.js";
-function makeManifest(overrides = {}) {
-    return {
-        schemaVersion: "sn.connector.v1",
-        platformId: "test-platform",
-        displayName: "Test Platform",
-        family: "social_community",
-        capabilities: [{ id: "feed.read" }],
-        runner: { kind: "declarative_http" },
-        credentials: [{ type: "api_key", required: true }],
-        sourceRefPolicy: { minSourceRefs: 1 },
-        ...overrides,
-    };
-}
-function tempDir() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), "sn-connector-test-"));
-}
-function writeManifest(root, platformId, manifest) {
-    const dir = path.join(root, ".second-nature", "connectors", platformId);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, "manifest.yaml"), yaml.dump(manifest));
-}
-test("parseConnectorManifestV6 accepts valid manifest", () => {
-    const manifest = makeManifest();
-    const result = parseConnectorManifestV6(yaml.dump(manifest));
-    assert.equal(result.ok, true);
-    if (!result.ok)
-        return;
-    assert.equal(result.manifest.platformId, "test-platform");
-    assert.equal(result.manifest.runner.kind, "declarative_http");
-});
-test("parseConnectorManifestV6 rejects invalid schema", () => {
-    const result = parseConnectorManifestV6("not_yaml{{{");
-    assert.equal(result.ok, false);
-});
-test("parseConnectorManifestV6 rejects missing required fields", () => {
-    const result = parseConnectorManifestV6("platformId: only-this");
-    assert.equal(result.ok, false);
-});
-test("classifyTrust declarative_http -> declarative_trusted", () => {
-    const status = classifyTrust(makeManifest({ runner: { kind: "declarative_http" } }));
-    assert.equal(status, "declarative_trusted");
-});
-test("classifyTrust custom_adapter -> custom_adapter_pending_trust", () => {
-    const status = classifyTrust(makeManifest({ runner: { kind: "custom_adapter" } }));
-    assert.equal(status, "custom_adapter_pending_trust");
-});
-test("classifyTrust respects manifest.trust.status blocked", () => {
-    const status = classifyTrust(makeManifest({ runner: { kind: "declarative_http" }, trust: { status: "blocked" } }));
-    assert.equal(status, "blocked");
-});
-test("isExecutable declarative_trusted -> true", () => {
-    assert.equal(isExecutable("declarative_trusted"), true);
-});
-test("isExecutable custom_adapter_pending_trust -> false", () => {
-    assert.equal(isExecutable("custom_adapter_pending_trust"), false);
-});
-test("scanConnectorManifests returns empty when no connectors dir", () => {
-    const root = tempDir();
-    const results = scanConnectorManifests(root);
-    assert.equal(results.length, 0);
-});
-test("scanConnectorManifests enumerates manifest.yaml files", () => {
-    const root = tempDir();
-    writeManifest(root, "platform-a", makeManifest({ platformId: "platform-a" }));
-    writeManifest(root, "platform-b", makeManifest({ platformId: "platform-b" }));
-    const results = scanConnectorManifests(root);
-    assert.equal(results.length, 2);
-    assert.ok(results.some((r) => r.path.includes("platform-a")));
-    assert.ok(results.some((r) => r.path.includes("platform-b")));
-});
-test("DynamicConnectorRegistry reload registers valid manifest", () => {
-    const root = tempDir();
-    writeManifest(root, "moltbook", makeManifest({ platformId: "moltbook", displayName: "Moltbook" }));
-    const store = createRegistrySnapshotStore();
-    const registry = new DynamicConnectorRegistry({ snapshotStore: store });
-    const result = registry.reloadConnectors(root);
-    assert.equal(result.scanned, 1);
-    assert.equal(result.registered, 1);
-    assert.equal(result.skipped, 0);
-    assert.equal(result.conflicts.length, 0);
-    assert.equal(result.validationErrors.length, 0);
-    const entry = registry.describeConnector("moltbook");
-    assert.ok(entry);
-    assert.equal(entry.trustStatus, "declarative_trusted");
-    assert.equal(entry.executable, true);
-});
-test("DynamicConnectorRegistry reload skips invalid manifest and records validation error", () => {
-    const root = tempDir();
-    const dir = path.join(root, ".second-nature", "connectors", "bad-platform");
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, "manifest.yaml"), "invalid: yaml: [[");
-    const store = createRegistrySnapshotStore();
-    const registry = new DynamicConnectorRegistry({ snapshotStore: store });
-    const result = registry.reloadConnectors(root);
-    assert.equal(result.scanned, 1);
-    assert.equal(result.registered, 0);
-    assert.equal(result.skipped, 1);
-    assert.equal(result.validationErrors.length, 1);
-    assert.equal(registry.describeConnector("bad-platform"), undefined);
-});
-test("DynamicConnectorRegistry custom adapter is pending trust and not executable", () => {
-    const root = tempDir();
-    writeManifest(root, "custom-plat", makeManifest({ platformId: "custom-plat", runner: { kind: "custom_adapter", entrypoint: "./adapter.ts" } }));
-    const store = createRegistrySnapshotStore();
-    const registry = new DynamicConnectorRegistry({ snapshotStore: store });
-    registry.reloadConnectors(root);
-    const entry = registry.describeConnector("custom-plat");
-    assert.ok(entry);
-    assert.equal(entry.trustStatus, "custom_adapter_pending_trust");
-    assert.equal(entry.executable, false);
-});
-test("DynamicConnectorRegistry fail-closed conflict on duplicate platformId", () => {
-    const root = tempDir();
-    writeManifest(root, "dup", makeManifest({ platformId: "dup", displayName: "First" }));
-    // Second manifest with same platformId in a different dir
-    const dir2 = path.join(root, ".second-nature", "connectors", "dup-alt");
-    fs.mkdirSync(dir2, { recursive: true });
-    fs.writeFileSync(path.join(dir2, "manifest.yaml"), yaml.dump(makeManifest({ platformId: "dup", displayName: "Second" })));
-    const store = createRegistrySnapshotStore();
-    const registry = new DynamicConnectorRegistry({ snapshotStore: store });
-    const result = registry.reloadConnectors(root);
-    assert.equal(result.scanned, 2);
-    assert.equal(result.registered, 1);
-    assert.equal(result.skipped, 1);
-    assert.equal(result.conflicts.length, 1);
-    assert.equal(result.conflicts[0].platformId, "dup");
-    const entry = registry.describeConnector("dup");
-    assert.ok(entry);
-    assert.ok(entry);
-});
-test("DynamicConnectorRegistry built-in + dynamic merge", () => {
-    const root = tempDir();
-    writeManifest(root, "ws-plat", makeManifest({ platformId: "ws-plat" }));
-    const builtIn = makeManifest({ platformId: "builtin-plat", displayName: "Built-in" });
-    const store = createRegistrySnapshotStore();
-    const registry = new DynamicConnectorRegistry({
-        builtInManifests: [builtIn],
-        snapshotStore: store,
-    });
-    registry.reloadConnectors(root);
-    const snapshot = registry.getActiveRegistrySnapshot();
-    assert.equal(snapshot.entries.size, 2);
-    assert.equal(snapshot.builtInEntries.size, 1);
-    assert.equal(snapshot.dynamicEntries.size, 1);
-    assert.ok(snapshot.entries.has("builtin-plat"));
-    assert.ok(snapshot.entries.has("ws-plat"));
-});
-test("DynamicConnectorRegistry snapshot is immutable", () => {
-    const root = tempDir();
-    writeManifest(root, "plat", makeManifest({ platformId: "plat" }));
-    const store = createRegistrySnapshotStore();
-    const registry = new DynamicConnectorRegistry({ snapshotStore: store });
-    registry.reloadConnectors(root);
-    const snapshot = registry.getActiveRegistrySnapshot();
-    assert.equal(Object.isFrozen(snapshot), true);
-    assert.equal(Object.isFrozen(snapshot.conflicts), true);
-    assert.equal(Object.isFrozen(snapshot.validationErrors), true);
-});
-test("DynamicConnectorRegistry listConnectors returns all entries", () => {
-    const root = tempDir();
-    writeManifest(root, "a", makeManifest({ platformId: "a" }));
-    writeManifest(root, "b", makeManifest({ platformId: "b" }));
-    const store = createRegistrySnapshotStore();
-    const registry = new DynamicConnectorRegistry({ snapshotStore: store });
-    registry.reloadConnectors(root);
-    const list = registry.listConnectors();
-    assert.equal(list.length, 2);
-});

package/dist/tests/unit/connectors/t3-1-2-capability-registry.test.d.ts

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

package/dist/tests/unit/connectors/t3-1-2-capability-registry.test.js

@@ -1,105 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { CapabilityContractRegistry, parseConnectorManifest, } from "../../../src/connectors/base/manifest.js";
-test("resolveCapability namespaced platformId:capability", () => {
-    const registry = new CapabilityContractRegistry();
-    registry.register(parseConnectorManifest({
-        platformId: "agent-world",
-        supportedCapabilities: ["work.discover"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    const resolved = registry.resolveCapability("agent-world:work.discover");
-    assert.equal(resolved.platformId, "agent-world");
-    assert.equal(resolved.intent, "work.discover");
-    assert.equal(resolved.source, "namespace");
-});
-test("resolveCapability v5 explicit platform", () => {
-    const registry = new CapabilityContractRegistry();
-    registry.register(parseConnectorManifest({
-        platformId: "moltbook",
-        supportedCapabilities: ["feed.read"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    const resolved = registry.resolveCapability("feed.read", "moltbook");
-    assert.equal(resolved.platformId, "moltbook");
-    assert.equal(resolved.intent, "feed.read");
-    assert.equal(resolved.source, "v5_explicit");
-});
-test("resolveCapability unambiguous default when single platform supports capability", () => {
-    const registry = new CapabilityContractRegistry();
-    registry.register(parseConnectorManifest({
-        platformId: "evomap",
-        supportedCapabilities: ["task.claim"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    const resolved = registry.resolveCapability("task.claim");
-    assert.equal(resolved.platformId, "evomap");
-    assert.equal(resolved.intent, "task.claim");
-    assert.equal(resolved.source, "unambiguous_default");
-});
-test("resolveCapability ambiguous bare capability throws", () => {
-    const registry = new CapabilityContractRegistry();
-    registry.register(parseConnectorManifest({
-        platformId: "moltbook",
-        supportedCapabilities: ["feed.read"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    registry.register(parseConnectorManifest({
-        platformId: "instreet",
-        supportedCapabilities: ["feed.read"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    assert.throws(() => registry.resolveCapability("feed.read"), /ambiguous_capability/);
-});
-test("resolveCapability unknown platform throws", () => {
-    const registry = new CapabilityContractRegistry();
-    assert.throws(() => registry.resolveCapability("unknown:feed.read"), /platform_not_found/);
-});
-// SKIP (pre-existing, Wave 46+): CapabilityContractRegistry behavior change — unknown capabilities now return undefined instead of throwing.
-// Justification: Registry behavior intentionally changed during v6→v7 evolution; test asserts old contract.
-// Re-enabling requires either restoring throw behavior or updating assertion to match new undefined-return contract.
-test.skip("resolveCapability unknown capability throws", () => {
-    const registry = new CapabilityContractRegistry();
-    registry.register(parseConnectorManifest({
-        platformId: "moltbook",
-        supportedCapabilities: ["feed.read"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    assert.throws(() => registry.resolveCapability("moltbook:unknown.capability"), /capability_not_recognized/);
-});
-test("findPlatformsForIntent returns all supporting platforms", () => {
-    const registry = new CapabilityContractRegistry();
-    registry.register(parseConnectorManifest({
-        platformId: "a",
-        supportedCapabilities: ["feed.read"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    registry.register(parseConnectorManifest({
-        platformId: "b",
-        supportedCapabilities: ["feed.read", "post.publish"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    const platforms = registry.findPlatformsForIntent("feed.read");
-    assert.equal(platforms.length, 2);
-    assert.ok(platforms.includes("a"));
-    assert.ok(platforms.includes("b"));
-});
-test("findPlatformsForIntent returns empty when no support", () => {
-    const registry = new CapabilityContractRegistry();
-    registry.register(parseConnectorManifest({
-        platformId: "a",
-        supportedCapabilities: ["feed.read"],
-        channelPriority: ["api_rest"],
-        credentialTypes: ["api_key"],
-    }));
-    const platforms = registry.findPlatformsForIntent("task.claim");
-    assert.equal(platforms.length, 0);
-});

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

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