@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/unit/cli/connector-init-manifest.test.js

@@ -0,0 +1,68 @@
+/**
+ * Wave 83 — connector-init manifest generation tests
+ *
+ * Verifies that connectorInit generates correct manifest structure:
+ * - declarative_http → trust.status = declarative_trusted
+ * - baseUrl → placed in runner.config.baseUrl
+ * - custom_adapter → trust.status = custom_adapter_pending_trust
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { connectorInit } from "../../../src/cli/commands/connector-init.js";
+describe("connectorInit manifest generation (W83)", () => {
+    it("declarative_http with baseUrl generates declarative_trusted + config.baseUrl", async () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-init-test-"));
+        try {
+            const result = await connectorInit({
+                platformId: "my-api",
+                runnerKind: "declarative_http",
+                baseUrl: "https://my-api.example.com",
+                workspaceRoot: tmpDir,
+            });
+            assert.ok(result.created, "manifest should be created");
+            const manifestContent = fs.readFileSync(result.manifestPath, "utf-8");
+            assert.ok(manifestContent.includes("status: declarative_trusted"), "declarative_http should have declarative_trusted trust status");
+            assert.ok(manifestContent.includes("config:") && manifestContent.includes("baseUrl: https://my-api.example.com"), "baseUrl should be nested under runner.config");
+            assert.ok(!manifestContent.includes("baseUrl:") || manifestContent.includes("runner:") && manifestContent.indexOf("baseUrl:") > manifestContent.indexOf("runner:"), "baseUrl should not be at top-level");
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("custom_adapter without baseUrl generates pending_trust", async () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-init-test-"));
+        try {
+            const result = await connectorInit({
+                platformId: "my-custom",
+                runnerKind: "custom_adapter",
+                workspaceRoot: tmpDir,
+            });
+            assert.ok(result.created, "manifest should be created");
+            const manifestContent = fs.readFileSync(result.manifestPath, "utf-8");
+            assert.ok(manifestContent.includes("status: custom_adapter_pending_trust"), "custom_adapter should have pending_trust status");
+        }
+        finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("declarative_a2a and declarative_mcp also generate declarative_trusted", async () => {
+        for (const kind of ["declarative_a2a", "declarative_mcp"]) {
+            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-init-test-"));
+            try {
+                const result = await connectorInit({
+                    platformId: `my-${kind}`,
+                    runnerKind: kind,
+                    workspaceRoot: tmpDir,
+                });
+                const manifestContent = fs.readFileSync(result.manifestPath, "utf-8");
+                assert.ok(manifestContent.includes("status: declarative_trusted"), `${kind} should have declarative_trusted trust status`);
+            }
+            finally {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+        }
+    });
+});

package/dist/tests/unit/cli/delivery-target-probe.test.d.ts

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

package/dist/tests/unit/cli/delivery-target-probe.test.js

@@ -0,0 +1,108 @@
+/**
+ * T-ROS.C.6 — Delivery target real probe unit tests.
+ *
+ * Verifies createStaticUnknownAdapter.checkDeliveryTarget:
+ * - workspace manifest with message.send → target_available + evidenceRefs
+ * - workspace without delivery connector → target_none + reason
+ * - no workspaceRoot → target_none + reason
+ */
+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 the built module (test runs against dist/ after build)
+import { createOpsRouter } from "../../../src/cli/ops/ops-router.js";
+function makeWorkspaceWithDeliveryConnector() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-delivery-"));
+    const connectorsDir = path.join(dir, ".second-nature", "connectors", "test-platform");
+    fs.mkdirSync(connectorsDir, { recursive: true });
+    fs.writeFileSync(path.join(connectorsDir, "manifest.yaml"), `schemaVersion: "sn.connector.v1"
+platformId: "test-platform"
+displayName: "Test Platform"
+family: "social_community"
+capabilities:
+  - id: "feed.read"
+    channel: "api_rest"
+  - id: "message.send"
+    channel: "api_rest"
+runner:
+  kind: "declarative_http"
+  config:
+    baseUrl: "https://example.com"
+credentials:
+  - type: "api_key"
+    required: true
+sourceRefPolicy:
+  minSourceRefs: 1
+trust:
+  status: "declarative_trusted"
+`, "utf-8");
+    return dir;
+}
+function makeWorkspaceWithoutDeliveryConnector() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sn-no-delivery-"));
+    const connectorsDir = path.join(dir, ".second-nature", "connectors", "test-platform");
+    fs.mkdirSync(connectorsDir, { recursive: true });
+    fs.writeFileSync(path.join(connectorsDir, "manifest.yaml"), `schemaVersion: "sn.connector.v1"
+platformId: "test-platform"
+displayName: "Test Platform"
+family: "social_community"
+capabilities:
+  - id: "feed.read"
+    channel: "api_rest"
+runner:
+  kind: "declarative_http"
+  config:
+    baseUrl: "https://example.com"
+credentials:
+  - type: "api_key"
+    required: true
+sourceRefPolicy:
+  minSourceRefs: 1
+trust:
+  status: "declarative_trusted"
+`, "utf-8");
+    return dir;
+}
+test("T-ROS.C.6-A: workspace with message.send returns target_available", async () => {
+    const workspaceRoot = makeWorkspaceWithDeliveryConnector();
+    try {
+        const router = createOpsRouter({
+            runtimeAvailable: true,
+            workspaceRoot,
+        });
+        const result = await router.dispatch("capability_probe");
+        assert.ok(result && typeof result === "object" && "data" in result, "result must contain data");
+        const data = result.data;
+        assert.equal(data.deliveryTarget, "target_available", `expected target_available, got ${data.deliveryTarget}`);
+    }
+    finally {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});
+test("T-ROS.C.6-B: workspace without delivery connector returns target_none", async () => {
+    const workspaceRoot = makeWorkspaceWithoutDeliveryConnector();
+    try {
+        const router = createOpsRouter({
+            runtimeAvailable: true,
+            workspaceRoot,
+        });
+        const result = await router.dispatch("capability_probe");
+        assert.ok(result && typeof result === "object" && "data" in result);
+        const data = result.data;
+        assert.equal(data.deliveryTarget, "target_none");
+    }
+    finally {
+        fs.rmSync(workspaceRoot, { recursive: true, force: true });
+    }
+});
+test("T-ROS.C.6-C: no workspaceRoot returns target_none", async () => {
+    const router = createOpsRouter({
+        runtimeAvailable: true,
+    });
+    const result = await router.dispatch("capability_probe");
+    assert.ok(result && typeof result === "object" && "data" in result);
+    const data = result.data;
+    assert.equal(data.deliveryTarget, "target_none");
+});

package/dist/tests/unit/cli/host-capability.test.d.ts

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

package/dist/tests/unit/cli/host-capability.test.js

@@ -0,0 +1,50 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { classifyDeliveryCapability } from "../../../src/cli/host-capability/classify-delivery.js";
+import { probeHostCapability } from "../../../src/cli/host-capability/probe-host-capability.js";
+test("classifyDeliveryCapability maps host signals", () => {
+    assert.equal(classifyDeliveryCapability({ rawTarget: "none", channel: "x" }), "target_none");
+    assert.equal(classifyDeliveryCapability({ rawTarget: "last", channel: "dm" }), "target_available");
+    assert.equal(classifyDeliveryCapability({ rawTarget: "last", channel: "" }), "channel_missing");
+    assert.equal(classifyDeliveryCapability({ apiAvailable: false }), "host_api_unavailable");
+    assert.equal(classifyDeliveryCapability({ hostUnsupported: true }), "host_unsupported");
+});
+test("probeHostCapability aggregates adapter fields", () => {
+    const now = new Date().toISOString();
+    const ref = (id) => [{ id, kind: "host_report", uri: `sn://${id}` }];
+    const adapter = {
+        checkPluginLoad: () => ({ name: "plugin_load", verdict: "pass", observedAt: now, evidenceRefs: ref("p1") }),
+        checkHeartbeatBridge: () => ({ name: "heartbeat_bridge", verdict: "pass", observedAt: now, evidenceRefs: ref("h1") }),
+        checkHeartbeatToolInvocation: () => ({
+            name: "heartbeat_tool_invocation",
+            verdict: "unknown",
+            observedAt: now,
+            evidenceRefs: ref("t1"),
+        }),
+        checkDeliveryTarget: () => ({ status: "target_none", evidenceRefs: ref("d1"), reason: "host_reports_none" }),
+        checkAckDropBehavior: () => ({ name: "ack_drop", verdict: "pass", observedAt: now, evidenceRefs: [] }),
+        checkHookSupport: () => [
+            { name: "hook:runHeartbeatOnce", verdict: "not_applicable", observedAt: now, evidenceRefs: [] },
+        ],
+    };
+    const report = probeHostCapability({
+        adapter,
+        docLinks: [
+            {
+                title: "OpenClaw delivery",
+                url: "https://example.invalid/docs",
+                checkedAt: now,
+                documentedBehavior: "Delivery target available by default",
+            },
+        ],
+        docCheckedAt: now,
+        hostVersion: "test-host",
+        observedVersion: "test-observed",
+    });
+    assert.ok(report.reportId.length > 0);
+    assert.equal(report.pluginLoad.verdict, "pass");
+    assert.equal(report.heartbeatToolInvocation.name, "heartbeat_tool_invocation");
+    assert.equal(report.deliveryTarget, "target_none");
+    assert.equal(report.hookSupport.length, 1);
+    assert.equal(report.docCheckedAt, now);
+});

package/dist/tests/unit/cli/operator-fallback-view.test.d.ts

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

package/dist/tests/unit/cli/operator-fallback-view.test.js

@@ -0,0 +1,60 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { eq } from "drizzle-orm";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { operatorFallbackArtifacts } from "../../../src/storage/db/schema/operator-fallback-artifacts.js";
+import { writeOperatorFallback } from "../../../src/storage/fallback/write-operator-fallback.js";
+import { showOperatorFallback } from "../../../src/cli/ops/show-operator-fallback.js";
+import { createCliReadModels } from "../../../src/cli/read-models/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+const reasons = ["target_none", "channel_missing", "host_unsupported", "delivery_failed"];
+async function seedFallback(state, reason, suffix) {
+    const { fallbackRef } = await writeOperatorFallback(state, {
+        reason,
+        decisionId: `dec-${suffix}`,
+        sourceRefs: [{ id: `sr-${suffix}`, kind: "decision_record", uri: `uri:${suffix}` }],
+        candidateMessage: `redacted-${suffix}`,
+        nextStep: `next-${suffix}`,
+    });
+    return fallbackRef;
+}
+test("T1.2.2 showOperatorFallback — four OperatorFallbackReason kinds; status always not_sent", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb });
+    for (let i = 0; i < reasons.length; i++) {
+        const reason = reasons[i];
+        const ref = await seedFallback(stateDb, reason, `${i}`);
+        const view = await showOperatorFallback(ref, readModels);
+        assert.equal(view.status, "not_sent");
+        assert.equal(view.reason, reason);
+        assert.ok(view.sourceRefs.length);
+        assert.equal(view.candidateMessage, `redacted-${i}`);
+        assert.equal(view.nextStep, `next-${i}`);
+    }
+    stateDb.close();
+    observabilityDb.close();
+});
+test("T1.2.2 ref without fallback: prefix normalizes", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb });
+    const ref = await seedFallback(stateDb, "target_none", "norm");
+    const bareUuid = ref.replace(/^fallback:/, "");
+    const view = await showOperatorFallback(bareUuid, readModels);
+    assert.equal(view.fallbackRef, ref);
+    assert.equal(view.status, "not_sent");
+    stateDb.close();
+    observabilityDb.close();
+});
+test("T1.2.2 corrupt persisted status is never exposed as sent/delivered", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb });
+    const ref = await seedFallback(stateDb, "delivery_failed", "corrupt");
+    await stateDb.db.update(operatorFallbackArtifacts).set({ status: "sent" }).where(eq(operatorFallbackArtifacts.fallbackRef, ref));
+    const view = await showOperatorFallback(ref, readModels);
+    assert.equal(view.status, "not_sent");
+    stateDb.close();
+    observabilityDb.close();
+});

package/dist/tests/unit/cli/runtime-artifact-boundary.test.d.ts

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

package/dist/tests/unit/cli/runtime-artifact-boundary.test.js

@@ -0,0 +1,57 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { PACKAGED_RUNTIME_REQUIRED_ENTRIES, detectForbiddenSourcePathDependencies, resolvePackagedRuntime, } from "../../../src/cli/runtime/runtime-artifact-boundary.js";
+function touchFile(absPath) {
+    fs.mkdirSync(path.dirname(absPath), { recursive: true });
+    fs.writeFileSync(absPath, "// fixture\n", "utf-8");
+}
+function writeMinimalRuntimeTree(runtimeRoot) {
+    for (const rel of PACKAGED_RUNTIME_REQUIRED_ENTRIES) {
+        touchFile(path.join(runtimeRoot, rel));
+    }
+}
+test("resolvePackagedRuntime succeeds when runtime layout is complete", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "sn-pack-"));
+    const runtimeRoot = path.join(root, "runtime");
+    fs.mkdirSync(runtimeRoot, { recursive: true });
+    writeMinimalRuntimeTree(runtimeRoot);
+    const res = resolvePackagedRuntime(root);
+    assert.equal(res.ok, true);
+    if (res.ok) {
+        assert.equal(res.boundary.sourcePathDependencyAllowed, false);
+        assert.ok(res.runtimeRoot.endsWith("runtime"));
+    }
+});
+test("resolvePackagedRuntime returns runtime_artifact_missing when runtime dir absent", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "sn-pack-"));
+    const res = resolvePackagedRuntime(root);
+    assert.equal(res.ok, false);
+    if (!res.ok) {
+        assert.equal(res.code, "runtime_artifact_missing");
+    }
+});
+test("resolvePackagedRuntime returns runtime_layout_incomplete when required modules missing", () => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "sn-pack-"));
+    const runtimeRoot = path.join(root, "runtime");
+    fs.mkdirSync(runtimeRoot, { recursive: true });
+    touchFile(path.join(runtimeRoot, "cli/index.js"));
+    const res = resolvePackagedRuntime(root);
+    assert.equal(res.ok, false);
+    if (!res.ok) {
+        assert.equal(res.code, "runtime_layout_incomplete");
+        assert.ok(res.missingPaths.length > 0);
+    }
+});
+test("detectForbiddenSourcePathDependencies flags repository-relative src imports", () => {
+    const bad = `
+import { x } from "../../src/cli/index.js";
+const y = require('../src/foo.ts');
+`;
+    const hits = detectForbiddenSourcePathDependencies(bad);
+    assert.ok(hits.length >= 2);
+    const clean = `import { x } from "./runtime/cli/index.js";`;
+    assert.deepEqual(detectForbiddenSourcePathDependencies(clean), []);
+});

package/dist/tests/unit/cli/t1-2-3-connector-status.test.d.ts

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

package/dist/tests/unit/cli/t1-2-3-connector-status.test.js

@@ -0,0 +1,214 @@
+/**
+ * Unit coverage for `connectorStatus` and `connectorTest` (T1.2.3).
+ *
+ * Verifies inventory summary, trust/executable flags, conflict reporting,
+ * dry-run default, pending-trust denial, missing platformId, and registry
+ * unavailable paths.
+ */
+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 { connectorStatus, connectorTest, } from "../../../src/cli/commands/connector-status.js";
+import { DynamicConnectorRegistry, createRegistrySnapshotStore, } from "../../../src/connectors/registry/index.js";
+const builtInMoltbook = {
+    schemaVersion: "sn.connector.v1",
+    platformId: "moltbook",
+    displayName: "Moltbook",
+    family: "social_community",
+    capabilities: [
+        { id: "feed.read" },
+        { id: "post.publish" },
+        { id: "comment.reply" },
+    ],
+    runner: { kind: "declarative_http" },
+    credentials: [{ type: "api_key", required: true }],
+    sourceRefPolicy: { minSourceRefs: 1 },
+};
+const builtInEvoMap = {
+    schemaVersion: "sn.connector.v1",
+    platformId: "evomap",
+    displayName: "EvoMap",
+    family: "agent_network",
+    capabilities: [
+        { id: "agent.register" },
+        { id: "work.discover" },
+    ],
+    runner: { kind: "declarative_http" },
+    credentials: [{ type: "api_key", required: true }],
+    sourceRefPolicy: { minSourceRefs: 1 },
+};
+// CR7-02: workspace custom adapter manifest that will be pending-trust
+const customAdapterManifest = {
+    schemaVersion: "sn.connector.v1",
+    platformId: "custom-agent",
+    displayName: "Custom Agent",
+    family: "custom",
+    capabilities: [{ id: "custom.agent_action" }],
+    runner: { kind: "custom_adapter" },
+    credentials: [],
+    sourceRefPolicy: { minSourceRefs: 1 },
+};
+function tmpDir() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "sn-connector-status-"));
+}
+test("T1.2.3 connectorStatus returns inventory summary with trust and executable flags", async () => {
+    const root = tmpDir();
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook, builtInEvoMap],
+        snapshotStore: store,
+    });
+    registry.reloadConnectors(root);
+    const result = await connectorStatus(registry, undefined);
+    assert.equal(result.ok, true);
+    const data = result.data;
+    const summary = data.summary;
+    assert.equal(summary.total, 2);
+    assert.equal(summary.builtIn, 2);
+    assert.equal(summary.executable, 2);
+    const connectors = data.connectors;
+    assert.equal(connectors.length, 2);
+    const moltbook = connectors.find((c) => c.platformId === "moltbook");
+    assert.ok(moltbook);
+    assert.equal(moltbook.executable, true);
+    assert.equal(moltbook.trustStatus, "declarative_trusted");
+    fs.rmSync(root, { recursive: true });
+});
+test("T1.2.3 connectorStatus returns unavailable when registry absent", async () => {
+    const result = await connectorStatus(undefined, undefined);
+    assert.equal(result.ok, false);
+    const err = result.error;
+    assert.equal(err.code, "REGISTRY_UNAVAILABLE");
+});
+test("T1.2.3 connectorTest dry-run returns health checks for executable connector", async () => {
+    const root = tmpDir();
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook],
+        snapshotStore: store,
+    });
+    registry.reloadConnectors(root);
+    const result = await connectorTest(registry, { platformId: "moltbook" });
+    assert.equal(result.ok, true);
+    const data = result.data;
+    assert.equal(data.platformId, "moltbook");
+    assert.equal(data.dryRun, true);
+    assert.ok(Array.isArray(data.healthChecks));
+    assert.ok(data.healthChecks.includes("ok"));
+    fs.rmSync(root, { recursive: true });
+});
+test("T1.2.3 connectorTest defaults to dry-run even when dryRun omitted", async () => {
+    const root = tmpDir();
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook],
+        snapshotStore: store,
+    });
+    registry.reloadConnectors(root);
+    const result = await connectorTest(registry, { platformId: "moltbook" });
+    const data = result.data;
+    assert.equal(data.dryRun, true);
+    assert.ok(data.note.includes("dry-run"));
+    fs.rmSync(root, { recursive: true });
+});
+test("T1.2.3 connectorTest allows live mode only when dryRun:false explicitly set", async () => {
+    const root = tmpDir();
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook],
+        snapshotStore: store,
+    });
+    registry.reloadConnectors(root);
+    const result = await connectorTest(registry, {
+        platformId: "moltbook",
+        dryRun: false,
+    });
+    const data = result.data;
+    assert.equal(data.dryRun, false);
+    assert.ok(data.note.includes("live test"));
+    fs.rmSync(root, { recursive: true });
+});
+test("T1.2.3 connectorTest returns not_found for unknown platformId", async () => {
+    const root = tmpDir();
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook],
+        snapshotStore: store,
+    });
+    registry.reloadConnectors(root);
+    const result = await connectorTest(registry, { platformId: "unknown" });
+    assert.equal(result.ok, false);
+    const err = result.error;
+    assert.equal(err.code, "CONNECTOR_NOT_FOUND");
+    fs.rmSync(root, { recursive: true });
+});
+test("T1.2.3 connectorTest returns missing_platform_id when empty", async () => {
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook],
+        snapshotStore: store,
+    });
+    const result = await connectorTest(registry, { platformId: "" });
+    assert.equal(result.ok, false);
+    const err = result.error;
+    assert.equal(err.code, "MISSING_PLATFORM_ID");
+});
+// CR7-02: pending-trust / non-executable connector must fail-closed
+test("T1.2.3 connectorTest returns PENDING_TRUST_DENIED for custom adapter (non-executable)", async () => {
+    const root = tmpDir();
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook, customAdapterManifest],
+        snapshotStore: store,
+    });
+    registry.reloadConnectors(root);
+    // custom-agent is pending-trust / not executable
+    const result = await connectorTest(registry, { platformId: "custom-agent" });
+    assert.equal(result.ok, false);
+    const err = result.error;
+    assert.equal(err.code, "PENDING_TRUST_DENIED");
+    assert.ok(err.message.includes("custom-agent"));
+    assert.ok(err.message.includes("not executable"));
+    assert.equal(err.trustStatus, "custom_adapter_pending_trust");
+    assert.equal(err.platformId, "custom-agent");
+    fs.rmSync(root, { recursive: true });
+});
+test("T1.2.3 connectorStatus shows pendingTrust count for custom adapter", async () => {
+    const root = tmpDir();
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook, customAdapterManifest],
+        snapshotStore: store,
+    });
+    registry.reloadConnectors(root);
+    const result = await connectorStatus(registry, undefined);
+    assert.equal(result.ok, true);
+    const data = result.data;
+    const summary = data.summary;
+    assert.equal(summary.total, 2);
+    assert.equal(summary.executable, 1);
+    assert.equal(summary.pendingTrust, 1);
+    const connectors = data.connectors;
+    const custom = connectors.find((c) => c.platformId === "custom-agent");
+    assert.ok(custom);
+    assert.equal(custom.executable, false);
+    assert.equal(custom.trustStatus, "custom_adapter_pending_trust");
+    fs.rmSync(root, { recursive: true });
+});
+test("T1.2.3 connectorStatus records conflicts and validation errors when present", async () => {
+    const root = tmpDir();
+    const store = createRegistrySnapshotStore();
+    const registry = new DynamicConnectorRegistry({
+        builtInManifests: [builtInMoltbook],
+        snapshotStore: store,
+    });
+    registry.reloadConnectors(root);
+    const result = await connectorStatus(registry, undefined);
+    assert.equal(result.ok, true);
+    const data = result.data;
+    assert.ok(Array.isArray(data.conflicts));
+    assert.ok(Array.isArray(data.validationErrors));
+    fs.rmSync(root, { recursive: true });
+});

package/dist/tests/unit/cli/t1-2-4-goal-command.test.d.ts

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