@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/cli/t2-2-2-snapshot-life-evidence.test.js

@@ -0,0 +1,116 @@
+/**
+ * T2.2.2 — Workspace SnapshotInputs 并入 bounded life evidence。
+ *
+ * CH-14-01 根因：`loadSnapshotInputsForWorkspaceHeartbeat` 未调用 `loadLifeEvidenceSnapshot`，
+ * 导致 planner/guard 需要 source refs 的候选路径拿到空快照。
+ *
+ * 验收标准：
+ * A. fixture workspace 有 life evidence index 行时，full-runtime heartbeat_check 运行后
+ *    SnapshotInputs 中 life evidence 计数或 refs 至少一项反映 DB 真值。
+ * B. 无数据时，`lifeEvidenceEmptyReason` 为 `no_sources` 或 `state_unavailable`，
+ *    不得伪造 refs。
+ * C. 无 state wired 时降级为 `lifeEvidenceEmptyReason: state_unavailable`，
+ *    不崩溃心跳循环。
+ *
+ * 验证路径：通过 `loadSnapshotInputsForWorkspaceHeartbeat` 直接调用 + 集成路径验证。
+ */
+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 { loadSnapshotInputsForWorkspaceHeartbeat } from "../../../src/cli/ops/workspace-heartbeat-runner.js";
+import { appendLifeEvidence } from "../../../src/storage/life-evidence/append-life-evidence.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { createCliReadModels } from "../../../src/cli/read-models/index.js";
+import { createCliRuntimeDeps, createCommandRouter, closeCliRuntimeDeps } from "../../../src/cli/index.js";
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function makeTempWorkspace() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "sn-t222-"));
+}
+// ─── Case A: DB 有 life evidence → SnapshotInputs 携带非空 refs ──────────────
+test("T2.2.2 A — with DB evidence, loadSnapshotInputsForWorkspaceHeartbeat populates lifeEvidenceRefs", async () => {
+    const ws = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb });
+    // Write one life evidence entry so DB has a real row.
+    await appendLifeEvidence(stateDb, ws, {
+        timestamp: new Date().toISOString(),
+        evidenceType: "platform_browse",
+        platformId: "moltbook",
+        summary: "Browsed moltbook feed",
+        sourceRefs: [{ id: "src-A1", kind: "platform_item", uri: "moltbook://item/1" }],
+        sensitivity: "public",
+        producer: "connector-system",
+    });
+    const inputs = await loadSnapshotInputsForWorkspaceHeartbeat(readModels, {
+        state: stateDb,
+        workspaceRoot: ws,
+    });
+    // At least one ref should be populated from DB truth.
+    assert.ok((inputs.lifeEvidenceRefs?.length ?? 0) > 0 || (inputs.platformEventCount ?? 0) > 0, `Expected life evidence refs or platformEventCount > 0 from DB truth; got refs=${inputs.lifeEvidenceRefs?.length ?? 0}, platformEventCount=${inputs.platformEventCount ?? 0}`);
+    // Must not carry state_unavailable when state was provided and worked.
+    assert.notEqual(inputs.lifeEvidenceEmptyReason, "state_unavailable", "lifeEvidenceEmptyReason must not be state_unavailable when state was successfully loaded");
+    stateDb.close();
+    observabilityDb.close();
+    fs.rmSync(ws, { recursive: true, force: true });
+});
+// ─── Case B: DB 为空 → emptyReason 为 no_sources，不伪造 refs ────────────────
+test("T2.2.2 B — empty DB, loadSnapshotInputsForWorkspaceHeartbeat reports no_sources without faking refs", async () => {
+    const ws = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb });
+    const inputs = await loadSnapshotInputsForWorkspaceHeartbeat(readModels, {
+        state: stateDb,
+        workspaceRoot: ws,
+    });
+    // No evidence in DB → refs should be empty.
+    assert.equal((inputs.lifeEvidenceRefs?.length ?? 0) + (inputs.platformEventCount ?? 0) + (inputs.workEventCount ?? 0), 0, "Must not fabricate evidence refs when DB is empty");
+    // Empty reason should be no_sources (state was available but had no rows).
+    assert.equal(inputs.lifeEvidenceEmptyReason, "no_sources", "lifeEvidenceEmptyReason must be no_sources when state is available but empty");
+    stateDb.close();
+    observabilityDb.close();
+    fs.rmSync(ws, { recursive: true, force: true });
+});
+// ─── Case C: 无 state wired → 降级为 state_unavailable，不崩溃 ────────────────
+test("T2.2.2 C — no state wired, loadSnapshotInputsForWorkspaceHeartbeat degrades gracefully", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({ stateDb, observabilityDb });
+    // Intentionally omit state + workspaceRoot.
+    const inputs = await loadSnapshotInputsForWorkspaceHeartbeat(readModels);
+    assert.equal(inputs.lifeEvidenceEmptyReason, "state_unavailable", "lifeEvidenceEmptyReason must be state_unavailable when no state is wired");
+    // Must not crash — heartbeat cycle must still get valid inputs.
+    assert.ok(inputs.mode, "mode field must be populated even without state");
+    assert.ok(inputs.currentWindowId, "currentWindowId must be populated even without state");
+    stateDb.close();
+    observabilityDb.close();
+});
+// ─── Case D: 集成路径 — full-runtime heartbeat_check 不因 evidence load 崩溃 ──
+test("T2.2.2 D — full-runtime heartbeat_check with state wired completes without error", async () => {
+    const ws = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    // Write evidence so the path exercises non-empty branch.
+    await appendLifeEvidence(stateDb, ws, {
+        timestamp: new Date().toISOString(),
+        evidenceType: "work_progress",
+        platformId: "evomap",
+        summary: "Task discovered on EvoMap",
+        sourceRefs: [{ id: "src-D1", kind: "connector_result", uri: "evomap://task/42" }],
+        sensitivity: "public",
+        producer: "connector-system",
+    });
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("heartbeat_check");
+    assert.ok(cmd, "heartbeat_check command must be registered");
+    const out = (await cmd.execute({ timestamp: "2026-05-10T10:00:00.000Z" }));
+    assert.equal(out.ok, true, "heartbeat_check must succeed with state wired");
+    assert.equal(out.surfaceMode, "workspace_full_runtime", "must run workspace full runtime path");
+    closeCliRuntimeDeps(deps);
+    fs.rmSync(ws, { recursive: true, force: true });
+});

package/dist/tests/integration/cli/t3-3-2-near-real-smoke-cli-bridge.test.d.ts

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

package/dist/tests/integration/cli/t3-3-2-near-real-smoke-cli-bridge.test.js

@@ -0,0 +1,69 @@
+/**
+ * T3.3.2 — `near_real_smoke` ops CLI/bridge 命令包装。
+ *
+ * SN-CODE-05 根因：`runNearRealConnectorSmoke` 存在于 connectors 层但未接入 ops surface，
+ * 导致 operator 无法通过 `second_nature_ops({ command: "near_real_smoke" })` 触发哨兵探测。
+ *
+ * 验收标准：
+ * A. Given workspace deps 可用（stateDb + observabilityDb + workspaceRoot）
+ *    When CLI 执行 `near_real_smoke`
+ *    Then 返回 `ok: true` + `data.taskClaimDryRunOk === true`，非 `unknown_ops_command`
+ * B. 缺少 deps 时，返回 `ok: false` + 诚实错误码 `NEAR_REAL_SMOKE_DEPS_UNAVAILABLE`（非 throw）
+ * C. 命令已注册（不返回 undefined），名称为 `near_real_smoke`
+ */
+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 { closeCliRuntimeDeps, createCliRuntimeDeps, createCommandRouter, } from "../../../src/cli/index.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { createOpsRouter } from "../../../src/cli/ops/ops-router.js";
+test("T3.3.2-A: near_real_smoke returns ok:true with smoke result data", async () => {
+    const ws = fs.mkdtempSync(path.join(os.tmpdir(), "sn-t332-"));
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("near_real_smoke");
+    assert.ok(cmd, "near_real_smoke command must be registered");
+    // createCommandRouter uses process.cwd() for workspaceRoot; the smoke just needs a dir.
+    // Override via opsRouter dispatch directly to pass the temp workspace.
+    const opsRouter = createOpsRouter({
+        runtimeAvailable: false,
+        readModels: deps.readModels,
+        state: stateDb,
+        observabilityDb,
+        workspaceRoot: ws,
+    });
+    const result = (await opsRouter.dispatch("near_real_smoke"));
+    assert.equal(result.ok, true, "near_real_smoke must return ok: true");
+    const data = result.data;
+    assert.equal(data.taskClaimDryRunOk, true, "taskClaimDryRunOk must be true");
+    assert.ok("feedReadEvidenceId" in data, "must include feedReadEvidenceId");
+    assert.ok("workDiscoverEvidenceId" in data, "must include workDiscoverEvidenceId");
+    await closeCliRuntimeDeps(deps);
+    observabilityDb.close();
+    fs.rmSync(ws, { recursive: true, force: true });
+});
+test("T3.3.2-B: near_real_smoke returns honest error when deps unavailable", async () => {
+    // OpsRouter without state/observabilityDb/workspaceRoot
+    const opsRouter = createOpsRouter({
+        runtimeAvailable: false,
+    });
+    const result = (await opsRouter.dispatch("near_real_smoke"));
+    assert.equal(result.ok, false, "must return ok: false when deps missing");
+    const err = result.error;
+    assert.equal(err.code, "NEAR_REAL_SMOKE_DEPS_UNAVAILABLE", "must return NEAR_REAL_SMOKE_DEPS_UNAVAILABLE");
+});
+test("T3.3.2-C: near_real_smoke command is registered in CLI commands list", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("near_real_smoke");
+    assert.ok(cmd, "near_real_smoke command must be findable by name");
+    assert.equal(cmd.name, "near_real_smoke");
+    await closeCliRuntimeDeps(deps);
+});

package/dist/tests/integration/connectors/connector-base.test.d.ts

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

package/dist/tests/integration/connectors/connector-base.test.js

@@ -0,0 +1,211 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { CapabilityContractRegistry, ConnectorRoutePlanner, ChannelHealthStore, ConnectorPolicyError, classifyFailure, createConnectorContractCore, } from "../../../src/connectors/base/index.js";
+function makeRouteContext(overrides) {
+    const credentialState = overrides?.credentialState ?? "active";
+    const cooldownBlocked = overrides?.cooldownBlocked ?? false;
+    return {
+        async loadCredentialState(platformId) {
+            return {
+                platformId,
+                status: credentialState,
+                credentialType: "api_key",
+            };
+        },
+        async loadCooldownState() {
+            return {
+                blocked: cooldownBlocked,
+                retryAfterMs: cooldownBlocked ? 30000 : undefined,
+            };
+        },
+    };
+}
+function registerManifest(registry, channelPriority = ["api_rest", "cli", "skill"]) {
+    registry.register({
+        platformId: "instreet",
+        supportedCapabilities: ["feed.read", "post.publish", "comment.reply", "message.send"],
+        channelPriority,
+        credentialTypes: ["api_key"],
+        degradedChannels: ["cli", "skill", "browser"],
+    });
+}
+test("manifest registry validates capability/channel and supports capability lookup", () => {
+    const registry = new CapabilityContractRegistry();
+    registerManifest(registry);
+    assert.equal(registry.hasCapability("instreet", "feed.read"), true);
+    assert.equal(registry.hasCapability("instreet", "task.claim"), false);
+    assert.throws(() => registry.register({
+        platformId: "bad-platform",
+        supportedCapabilities: ["feed.read"],
+        channelPriority: [],
+        credentialTypes: ["api_key"],
+    }), /too_small/);
+});
+test("manifest registry accepts workspace-defined behavior ids", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "github",
+        supportedCapabilities: ["repo.inspect", "issue.search", "agent.community.scan"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+    });
+    assert.equal(registry.hasCapability("github", "issue.search"), true);
+    assert.deepEqual(registry.resolveCapability("github:repo.inspect"), {
+        platformId: "github",
+        intent: "repo.inspect",
+        source: "namespace",
+    });
+    const planner = new ConnectorRoutePlanner(registry, makeRouteContext({ credentialState: "active" }), new ChannelHealthStore());
+    const plan = await planner.planRoute("agent.community.scan", {
+        platformId: "github",
+        intent: "agent.community.scan",
+        payload: {},
+    });
+    assert.equal(plan.intent, "agent.community.scan");
+    assert.equal(plan.channel, "api_rest");
+});
+test("failure taxonomy classifies rate-limit and verification errors uniformly", () => {
+    const rateLimited = classifyFailure({ status: 429, retryAfterSeconds: 7 });
+    assert.equal(rateLimited.class, "rate_limited");
+    assert.equal(rateLimited.retryable, true);
+    assert.equal(rateLimited.retryAfterMs, 7000);
+    const verification = classifyFailure({ code: "verification_required" });
+    assert.equal(verification.class, "verification_required");
+    assert.equal(verification.retryable, false);
+});
+test("route planner applies API-first, pending_verification fallback and cooldown block", async () => {
+    const registry = new CapabilityContractRegistry();
+    registerManifest(registry, ["api_rest", "cli", "skill"]);
+    const health = new ChannelHealthStore();
+    const activePlanner = new ConnectorRoutePlanner(registry, makeRouteContext({ credentialState: "active" }), health);
+    const activePlan = await activePlanner.planRoute("feed.read", {
+        platformId: "instreet",
+        intent: "feed.read",
+        payload: {},
+    });
+    assert.equal(activePlan.channel, "api_rest");
+    const pendingPlanner = new ConnectorRoutePlanner(registry, makeRouteContext({ credentialState: "pending_verification" }), health);
+    const pendingPlan = await pendingPlanner.planRoute("feed.read", {
+        platformId: "instreet",
+        intent: "feed.read",
+        payload: {},
+    });
+    assert.equal(pendingPlan.channel, "skill");
+    const blockedPlanner = new ConnectorRoutePlanner(registry, makeRouteContext({ cooldownBlocked: true }), health);
+    await assert.rejects(() => blockedPlanner.planRoute("feed.read", {
+        platformId: "instreet",
+        intent: "feed.read",
+        payload: {},
+    }), /cooldown_blocked/);
+});
+test("route planner uses manifest.degradedChannels semantics for side-effect safety", async () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "instreet",
+        supportedCapabilities: ["post.publish", "feed.read"],
+        channelPriority: ["api_rest", "cli"],
+        credentialTypes: ["api_key"],
+        degradedChannels: ["api_rest"],
+    });
+    const planner = new ConnectorRoutePlanner(registry, makeRouteContext({ credentialState: "active" }), new ChannelHealthStore());
+    await assert.rejects(() => planner.planRoute("post.publish", {
+        platformId: "instreet",
+        intent: "post.publish",
+        payload: {},
+    }), /degraded_channel_not_allowed_for_side_effect/);
+});
+test("contract core enforces capability contract and returns normalized result", async () => {
+    const registry = new CapabilityContractRegistry();
+    registerManifest(registry, ["api_rest", "cli"]);
+    const planner = new ConnectorRoutePlanner(registry, makeRouteContext({ credentialState: "active" }), new ChannelHealthStore());
+    const contract = createConnectorContractCore({
+        manifestLoader: registry,
+        routePlanner: planner,
+        executionRunner: {
+            async run(plan) {
+                return {
+                    platformId: plan.platformId,
+                    channel: plan.channel,
+                    latencyMs: 12,
+                    success: false,
+                    error: { status: 429, retryAfterSeconds: 1 },
+                };
+            },
+        },
+    });
+    const result = await contract.executeCapability("feed.read", {
+        platformId: "instreet",
+        intent: "feed.read",
+        payload: {},
+    });
+    assert.equal(result.status, "retryable_failure");
+    assert.equal(result.failureClass, "rate_limited");
+    assert.equal(result.retryAfterMs, 1000);
+    assert.equal(result.metadata.channel, "api_rest");
+});
+test("unsupported capability is treated as protocol mismatch, not skipped", async () => {
+    const registry = new CapabilityContractRegistry();
+    registerManifest(registry, ["api_rest", "cli"]);
+    const planner = new ConnectorRoutePlanner(registry, makeRouteContext({ credentialState: "active" }), new ChannelHealthStore());
+    const contract = createConnectorContractCore({
+        manifestLoader: registry,
+        routePlanner: planner,
+        executionRunner: {
+            async run() {
+                throw new Error("should_not_run");
+            },
+        },
+    });
+    await assert.rejects(() => contract.executeCapability("task.claim", {
+        platformId: "instreet",
+        intent: "task.claim",
+        payload: {},
+    }), /capability_not_supported_by_manifest/);
+});
+test("contract core forwards route planner plan object without rebuilding", async () => {
+    const registry = new CapabilityContractRegistry();
+    registerManifest(registry, ["api_rest", "cli"]);
+    const capturedPlans = [];
+    const contract = createConnectorContractCore({
+        manifestLoader: registry,
+        routePlanner: {
+            async planRoute() {
+                return {
+                    platformId: "instreet",
+                    intent: "feed.read",
+                    channel: "cli",
+                    endpointMode: "skill_call",
+                    idempotencyKey: "id-1",
+                };
+            },
+        },
+        executionRunner: {
+            async run(plan) {
+                capturedPlans.push({ endpointMode: plan.endpointMode, channel: plan.channel });
+                return {
+                    platformId: plan.platformId,
+                    channel: plan.channel,
+                    latencyMs: 5,
+                    success: true,
+                    payload: { ok: true },
+                };
+            },
+        },
+    });
+    const result = await contract.executeCapability("feed.read", {
+        platformId: "instreet",
+        intent: "feed.read",
+        payload: {},
+    });
+    assert.equal(result.status, "success");
+    assert.equal(capturedPlans.length, 1);
+    assert.deepEqual(capturedPlans[0], { endpointMode: "skill_call", channel: "cli" });
+});
+test("failure taxonomy keeps same retryability for same class across branches", () => {
+    const fromPolicy = classifyFailure(new ConnectorPolicyError("concurrency_conflict", "conflict"));
+    const fromObject = classifyFailure({ code: "concurrency_conflict" });
+    assert.equal(fromPolicy.class, "concurrency_conflict");
+    assert.equal(fromObject.class, "concurrency_conflict");
+    assert.equal(fromPolicy.retryable, fromObject.retryable);
+    assert.equal(fromPolicy.retryable, true);
+});

package/dist/tests/integration/connectors/connector-executor-adapter-honest-failure.test.d.ts

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