@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/tests/unit/control-plane/t2-4-1-credential-route.test.js

@@ -0,0 +1,75 @@
+/**
+ * T2.4.1 — Platform-specific intent credential-route unit tests.
+ *
+ * Covers resolvePlatformForIntent when registry is present but the
+ * resolved platform does not support the required capability (credential
+ * route unavailable), or when no registry is present.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolvePlatformForIntent } from "../../../src/core/second-nature/orchestrator/platform-capability-router.js";
+import { CapabilityContractRegistry } from "../../../src/connectors/base/manifest.js";
+test("T2.4.1-C: registry present but platform lacks capability → undefined", () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "moltbook",
+        supportedCapabilities: ["feed.read"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    });
+    // "work" maps to "work.discover", which moltbook does NOT support
+    const result = resolvePlatformForIntent("work", { acceptedGoals: [{ goalId: "g1", description: "work on moltbook" }] }, registry);
+    assert.equal(result, undefined);
+});
+test("T2.4.1-C: registry present and platform supports capability → platformId", () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "moltbook",
+        supportedCapabilities: ["feed.read"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    });
+    // "exploration" maps to "feed.read", which moltbook supports
+    const result = resolvePlatformForIntent("exploration", { acceptedGoals: [{ goalId: "g1", description: "explore moltbook" }] }, registry);
+    assert.equal(result, "moltbook");
+});
+test("T2.4.1-D: no registry + goal names platform → best-effort platformId", () => {
+    const result = resolvePlatformForIntent("exploration", { acceptedGoals: [{ goalId: "g1", description: "explore moltbook feed" }] }, undefined);
+    assert.equal(result, "moltbook");
+});
+test("T2.4.1-D: no registry + ambiguous goals → undefined", () => {
+    const result = resolvePlatformForIntent("exploration", {
+        acceptedGoals: [
+            { goalId: "g1", description: "explore moltbook" },
+            { goalId: "g2", description: "explore instreet" },
+        ],
+    }, undefined);
+    assert.equal(result, undefined);
+});
+test("T2.4.1-E: no registry + evidence refs name platform → platformId", () => {
+    const result = resolvePlatformForIntent("exploration", {
+        evidenceRefs: [
+            { id: "ev-1", kind: "platform_item", uri: "platform://moltbook/item/1" },
+        ],
+    }, undefined);
+    assert.equal(result, "moltbook");
+});
+test("T2.4.1-E: registry + unsupported capability via evidence → undefined", () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "moltbook",
+        supportedCapabilities: ["feed.read"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    });
+    // evidence names moltbook, but "work" → "work.discover" is unsupported
+    const result = resolvePlatformForIntent("work", {
+        evidenceRefs: [
+            { id: "ev-1", kind: "platform_item", uri: "platform://moltbook/item/1" },
+        ],
+    }, registry);
+    assert.equal(result, undefined);
+});

package/dist/tests/unit/control-plane/t2-4-1-platform-intent.test.d.ts

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

package/dist/tests/unit/control-plane/t2-4-1-platform-intent.test.js

@@ -0,0 +1,168 @@
+/**
+ * T2.4.1 — Platform-specific intent resolution unit tests.
+ *
+ * Acceptance:
+ * A. accepted goal names a known platform → intent gets platformId.
+ * B. evidence refs name a known platform → intent gets platformId.
+ * C. registry validates capability; unsupported platform falls through.
+ * D. ambiguous / no signal → platformId remains undefined.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolvePlatformForIntent } from "../../../src/core/second-nature/orchestrator/platform-capability-router.js";
+import { CapabilityContractRegistry } from "../../../src/connectors/base/manifest.js";
+function makeGoal(description, completionCriteria) {
+    return {
+        goalId: `goal-${Math.random().toString(36).slice(2)}`,
+        kind: "short_term",
+        description,
+        completionCriteria: completionCriteria ?? "",
+        status: "accepted",
+        origin: "owner_set",
+        acceptedBy: "owner",
+        risk: "low",
+        priorityHint: 50,
+        sourceRefs: [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+}
+function buildRegistry() {
+    const r = new CapabilityContractRegistry();
+    r.register({
+        platformId: "moltbook",
+        supportedCapabilities: ["feed.read", "comment.reply"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    });
+    r.register({
+        platformId: "evomap",
+        supportedCapabilities: ["work.discover", "task.claim"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    });
+    return r;
+}
+test("T2.4.1-A: goal names moltbook → exploration resolves platformId=moltbook", () => {
+    const platformId = resolvePlatformForIntent("exploration", {
+        acceptedGoals: [makeGoal("Explore new opportunities on moltbook")],
+    });
+    assert.equal(platformId, "moltbook");
+});
+test("T2.4.1-A: goal names evomap → work resolves platformId=evomap", () => {
+    const platformId = resolvePlatformForIntent("work", {
+        acceptedGoals: [makeGoal("Find tasks on evomap")],
+    });
+    assert.equal(platformId, "evomap");
+});
+test("T2.4.1-B: evidence ref with connector_result id containing moltbook → social resolves platformId=moltbook", () => {
+    const platformId = resolvePlatformForIntent("social", {
+        evidenceRefs: [
+            {
+                id: "moltbook-post-001",
+                kind: "connector_result",
+                uri: "platform://moltbook/item/moltbook-post-001",
+            },
+        ],
+    });
+    assert.equal(platformId, "moltbook");
+});
+test("T2.4.1-B: evidence ref uri platform://evomap → work resolves platformId=evomap", () => {
+    const platformId = resolvePlatformForIntent("work", {
+        evidenceRefs: [
+            {
+                id: "ref-1",
+                kind: "workspace_artifact",
+                uri: "platform://evomap/work/discovery",
+            },
+        ],
+    });
+    assert.equal(platformId, "evomap");
+});
+test("T2.4.1-C: registry validates capability; unsupported capability returns undefined", () => {
+    const registry = buildRegistry();
+    // evomap supports work.discover but NOT feed.read (exploration)
+    const platformId = resolvePlatformForIntent("exploration", {
+        acceptedGoals: [makeGoal("Check evomap feed")],
+    }, registry);
+    // With registry, unsupported capability → undefined (guard layer denies)
+    assert.equal(platformId, undefined);
+});
+test("T2.4.1-C: registry validates supported capability → returns validated platform", () => {
+    const registry = buildRegistry();
+    const platformId = resolvePlatformForIntent("exploration", {
+        acceptedGoals: [makeGoal("Read moltbook feed")],
+    }, registry);
+    assert.equal(platformId, "moltbook");
+});
+test("T2.4.1-D: no goals, no evidence → fallback to first supported platform", () => {
+    const platformId = resolvePlatformForIntent("exploration", {});
+    assert.equal(platformId, "agent-world");
+});
+test("T2.4.1-D: goal mentions unknown platform → fallback to first supported platform", () => {
+    const platformId = resolvePlatformForIntent("exploration", {
+        acceptedGoals: [makeGoal("Explore new opportunities on unknownplatform")],
+    });
+    assert.equal(platformId, "agent-world");
+});
+test("T2.4.1-D: goal and evidence point to different platforms → ambiguous, returns undefined", () => {
+    const platformId = resolvePlatformForIntent("exploration", {
+        acceptedGoals: [makeGoal("Look at moltbook")],
+        evidenceRefs: [
+            {
+                id: "evomap-task-001",
+                kind: "connector_result",
+                uri: "platform://evomap/task/001",
+            },
+        ],
+    });
+    // Multiple distinct platforms → ambiguous, return undefined (guard layer denies)
+    assert.equal(platformId, undefined);
+});
+test("T2.4.1-E: dynamic registry includes new platform → resolves new platformId", () => {
+    const registry = new CapabilityContractRegistry();
+    registry.register({
+        platformId: "agentworld",
+        supportedCapabilities: ["feed.read"],
+        channelPriority: ["api_rest"],
+        credentialTypes: ["api_key"],
+        sourceRefPolicy: { minSourceRefs: 1 },
+    });
+    const platformId = resolvePlatformForIntent("exploration", {
+        acceptedGoals: [makeGoal("Explore agentworld")],
+    }, registry);
+    assert.equal(platformId, "agentworld");
+});
+test("T2.4.1-F: no registry, unknown platform → fallback to first supported platform", () => {
+    const platformId = resolvePlatformForIntent("exploration", {
+        acceptedGoals: [makeGoal("Explore agentworld")],
+    });
+    // Fallback returns first alphabetically-sorted platform supporting the capability.
+    assert.equal(platformId, "agent-world");
+});
+test("T2.4.1-F: no registry still rejects unsupported fallback capability", () => {
+    const platformId = resolvePlatformForIntent("work", {
+        acceptedGoals: [makeGoal("work on moltbook")],
+    });
+    assert.equal(platformId, undefined);
+});
+test("T2.4.1: priority order: work → exploration → social → outreach → quiet", () => {
+    // kindToCapability mapping verification
+    assert.equal(resolvePlatformForIntent("work", {
+        acceptedGoals: [makeGoal("evomap tasks")],
+    }), "evomap");
+    assert.equal(resolvePlatformForIntent("exploration", {
+        acceptedGoals: [makeGoal("moltbook feed")],
+    }), "moltbook");
+    assert.equal(resolvePlatformForIntent("social", {
+        acceptedGoals: [makeGoal("moltbook social")],
+    }), "moltbook");
+    assert.equal(resolvePlatformForIntent("outreach", {
+        acceptedGoals: [makeGoal("message on moltbook")],
+    }), "moltbook");
+    assert.equal(resolvePlatformForIntent("quiet", {
+        acceptedGoals: [makeGoal("quiet on moltbook")],
+    }), undefined);
+});

package/dist/tests/unit/core/outreach-judgment.test.d.ts

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

package/dist/tests/unit/core/outreach-judgment.test.js

@@ -0,0 +1,109 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveDeliveryTarget } from "../../../src/core/second-nature/outreach/delivery-target.js";
+import { judgeOutreach } from "../../../src/core/second-nature/outreach/judge-outreach.js";
+const baseCandidate = () => ({
+    id: "c1",
+    kind: "outreach",
+    priority: 5,
+    source: "tick",
+    summary: "Discuss project alpha with you",
+    effectClass: "user_outreach",
+    sourceRefs: [
+        {
+            id: "ref1",
+            kind: "platform_item",
+            uri: "https://example.com/p/1",
+        },
+    ],
+});
+function baseInput(over = {}) {
+    return {
+        candidate: baseCandidate(),
+        userInterest: {
+            staleness: "fresh",
+            confidence: 0.8,
+            signals: [
+                {
+                    topic: "project alpha",
+                    confidence: 0.9,
+                    sourceRefs: [{ id: "sig1", kind: "user_anchor", uri: "file:///USER.md" }],
+                },
+            ],
+            sourceRefs: [],
+        },
+        lifeEvidence: { empty: false, evidenceRefCount: 4 },
+        delivery: { target: "explicit", channel: "dm", recipient: "user-1" },
+        ...over,
+    };
+}
+test("resolveDeliveryTarget: target_none", () => {
+    const r = resolveDeliveryTarget({ target: "none" });
+    assert.equal(r.verdict, "target_none");
+});
+test("resolveDeliveryTarget: explicit missing channel -> channel_missing", () => {
+    const r = resolveDeliveryTarget({ target: "explicit", channel: "", recipient: "u" });
+    assert.equal(r.verdict, "channel_missing");
+});
+test("resolveDeliveryTarget: explicit ok", () => {
+    const r = resolveDeliveryTarget({ target: "explicit", channel: "dm", recipient: "u" });
+    assert.equal(r.verdict, "target_available");
+    assert.equal(r.channel, "dm");
+});
+test("resolveDeliveryTarget: last without lastKnownVisibleChannel", () => {
+    const r = resolveDeliveryTarget({ target: "last" });
+    assert.equal(r.verdict, "channel_missing");
+});
+test("judgeOutreach: allow when delivery available and scores ok", () => {
+    const j = judgeOutreach(baseInput());
+    assert.equal(j.verdict, "allow");
+    assert.equal(j.deliveryVerdict, "target_available");
+});
+test("judgeOutreach: deny on missing sources", () => {
+    const c = baseCandidate();
+    c.sourceRefs = [];
+    const j = judgeOutreach(baseInput({ candidate: c }));
+    assert.equal(j.verdict, "deny");
+    assert.ok(j.reasons.includes("missing_source_refs"));
+});
+test("judgeOutreach: target_none still allow judgment but marks delivery verdict", () => {
+    const j = judgeOutreach(baseInput({ delivery: { target: "none" } }));
+    assert.equal(j.deliveryVerdict, "target_none");
+    assert.equal(j.verdict, "allow");
+    assert.ok(j.reasons.includes("target_none"));
+});
+test("judgeOutreach: defer on duplicate", () => {
+    const j = judgeOutreach(baseInput({ duplicateBlocked: true }));
+    assert.equal(j.verdict, "defer");
+    assert.equal(j.cooldownState, "duplicate");
+});
+test("judgeOutreach: defer on cooldown", () => {
+    const j = judgeOutreach(baseInput({ cooldownBlocked: true }));
+    assert.equal(j.verdict, "defer");
+});
+test("judgeOutreach: insufficient interest and low actionability -> deny", () => {
+    const j = judgeOutreach(baseInput({
+        userInterest: {
+            staleness: "insufficient",
+            confidence: 0,
+            signals: [],
+            sourceRefs: [],
+        },
+        candidate: {
+            ...baseCandidate(),
+            summary: "random unrelated text xyzabc",
+        },
+    }));
+    assert.equal(j.verdict, "deny");
+    assert.ok(j.reasons.includes("not_interest_relevant_or_actionable"));
+});
+test("judgeOutreach: low outreach value score -> deny with value_score_too_low (CH-09-06)", () => {
+    const c = baseCandidate();
+    c.priority = 0;
+    const j = judgeOutreach(baseInput({
+        candidate: c,
+        lifeEvidence: { empty: true, evidenceRefCount: 0 },
+    }));
+    assert.equal(j.verdict, "deny");
+    assert.ok(j.reasons.includes("value_score_too_low"));
+});

package/dist/tests/unit/core/resolve-allowed-intent.test.d.ts

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

package/dist/tests/unit/core/resolve-allowed-intent.test.js

@@ -0,0 +1,69 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveAllowedIntentResult } from "../../../src/core/second-nature/heartbeat/heartbeat-loop.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+import { createDraftOutreachMessagePort } from "../../../src/guidance/draft-outreach-message.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+const signal = {
+    trigger: "heartbeat_bridge",
+    scopeHint: "rhythm",
+    payload: { timestamp: "2026-05-02T12:00:00.000Z" },
+};
+test("CR-M1 resolveAllowedIntentResult runs outreach dispatch chain", async () => {
+    const state = createStateDatabase(":memory:");
+    const candidate = {
+        id: "c-out",
+        kind: "outreach",
+        priority: 40,
+        source: "tick",
+        summary: "platform direction check-in",
+        effectClass: "user_outreach",
+        sourceRefs: [{ id: "s1", kind: "platform_item", uri: "https://example/s1" }],
+        idempotencyKey: "outreach:test",
+    };
+    const inputs = {
+        mode: "active",
+        currentWindowId: "win_work_morning",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        lifeEvidenceRefs: [{ id: "s1", kind: "platform_item", uri: "https://example/s1" }],
+        deliveryCapability: { target: "explicit", channel: "dm", recipient: "u1" },
+        userInterestSnapshot: {
+            snapshotId: "uis-1",
+            generatedAt: "2026-05-02T12:00:00Z",
+            signals: [
+                {
+                    id: "sig-1",
+                    topic: "platform",
+                    confidence: 0.8,
+                    affinity: "positive",
+                    reason: "r",
+                    sourceRefs: [],
+                    updatedAt: "2026-05-02T12:00:00Z",
+                },
+            ],
+            sourceRefs: [],
+            confidence: 0.8,
+            staleness: "fresh",
+        },
+    };
+    const continuity = buildContinuitySnapshot(inputs);
+    const runtime = buildHeartbeatRuntimeSnapshot("2026-05-02T12:00:00.000Z", inputs, continuity);
+    const r = await resolveAllowedIntentResult(candidate, runtime, inputs, signal, {
+        outreachDispatch: {
+            state,
+            guidance: createDraftOutreachMessagePort(),
+            delivery: {
+                sendDeliveryRequest: async () => ({
+                    id: "att-x",
+                    status: "failed",
+                    errorClass: "transport_failure",
+                }),
+            },
+        },
+    });
+    assert.equal(r.status, "delivery_unavailable");
+    state.close();
+});

package/dist/tests/unit/core/t2-2-3-connector-action-honest-result.test.d.ts

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

package/dist/tests/unit/core/t2-2-3-connector-action-honest-result.test.js

@@ -0,0 +1,130 @@
+/**
+ * T2.2.3 — `connector_action` / 无外部效应 `intent_selected` 诚实闭合。
+ *
+ * CH-14-02/03 根因：`resolveAllowedIntentResult` 对 maintenance/no_effect effectClass
+ * 返回 `reasons: []`，operator 无法区分「已执行外部效应」vs「内部节律周期无可见输出」。
+ *
+ * 验收标准：
+ * A. `effectClass === "maintenance"` 时，周期 JSON 含 `internal_tick` reason。
+ * B. `effectClass === "no_effect"` 时，周期 JSON 含 `internal_tick` reason。
+ * C. `kind === "maintenance"` 时，周期 JSON 含 `internal_tick` reason。
+ * D. `effectClass === "connector_action"` 但无 dispatch wired 时，reasons 含
+ *    `connector_dispatch_unwired`（CH-15-01：禁止空 reasons 冒充已执行，需有可机读原因区分）。
+ * E. 通过 `ingestRhythmSignal` 完整路径验证 maintenance intent 被选后
+ *    其 reasons 包含 `internal_tick`。
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveAllowedIntentResult, ingestRhythmSignal, } from "../../../src/core/second-nature/heartbeat/heartbeat-loop.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+const signal = {
+    trigger: "heartbeat_bridge",
+    scopeHint: "rhythm",
+    payload: { timestamp: "2026-05-10T10:00:00.000Z" },
+};
+const baseInputs = {
+    mode: "active",
+    currentWindowId: "win_work_morning",
+    pendingObligations: [],
+    recentOutreachHashes: [],
+    deniedIntents: [],
+};
+function makeRuntime(inputs) {
+    const continuity = buildContinuitySnapshot(inputs);
+    return buildHeartbeatRuntimeSnapshot("2026-05-10T10:00:00.000Z", inputs, continuity);
+}
+// ─── Case A: maintenance effectClass → internal_tick ─────────────────────────
+test("T2.2.3 A — maintenance effectClass → reasons includes internal_tick", async () => {
+    const intent = {
+        id: "intent-maint-a",
+        kind: "maintenance",
+        priority: 10,
+        source: "tick",
+        summary: "run maintenance checks",
+        effectClass: "maintenance",
+        sourceRefs: [],
+        idempotencyKey: "maint:a",
+    };
+    const runtime = makeRuntime(baseInputs);
+    const result = await resolveAllowedIntentResult(intent, runtime, baseInputs, signal, {});
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("internal_tick"), `Expected reasons to include 'internal_tick', got: ${JSON.stringify(result.reasons)}`);
+});
+// ─── Case B: no_effect effectClass → internal_tick ───────────────────────────
+test("T2.2.3 B — no_effect effectClass → reasons includes internal_tick", async () => {
+    const intent = {
+        id: "intent-noeffect-b",
+        kind: "work",
+        priority: 10,
+        source: "tick",
+        summary: "internal state check",
+        effectClass: "no_effect",
+        sourceRefs: [],
+        idempotencyKey: "noeffect:b",
+    };
+    const runtime = makeRuntime(baseInputs);
+    const result = await resolveAllowedIntentResult(intent, runtime, baseInputs, signal, {});
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("internal_tick"), `Expected reasons to include 'internal_tick', got: ${JSON.stringify(result.reasons)}`);
+});
+// ─── Case C: maintenance kind (any effectClass) → internal_tick ───────────────
+test("T2.2.3 C — maintenance kind → reasons includes internal_tick", async () => {
+    const intent = {
+        id: "intent-maint-c",
+        kind: "maintenance",
+        priority: 10,
+        source: "tick",
+        summary: "run maintenance checks",
+        effectClass: "memory_curation",
+        sourceRefs: [],
+        idempotencyKey: "maint:c",
+    };
+    const runtime = makeRuntime(baseInputs);
+    const result = await resolveAllowedIntentResult(intent, runtime, baseInputs, signal, {});
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("internal_tick"), `Expected reasons to include 'internal_tick' for maintenance kind, got: ${JSON.stringify(result.reasons)}`);
+});
+// ─── Case D: connector_action without dispatch → reasons empty (not internal_tick) ──
+test("T2.2.3 D — connector_action without dispatch wired → reasons empty (not internal_tick)", async () => {
+    const intent = {
+        id: "intent-conn-d",
+        kind: "exploration",
+        priority: 30,
+        source: "tick",
+        summary: "explore moltbook feed",
+        effectClass: "connector_action",
+        platformId: "moltbook",
+        sourceRefs: [{ id: "s1", kind: "platform_item", uri: "moltbook://item/1" }],
+        idempotencyKey: "conn:d",
+    };
+    const runtime = makeRuntime(baseInputs);
+    const result = await resolveAllowedIntentResult(intent, runtime, baseInputs, signal, {});
+    assert.equal(result.status, "intent_selected");
+    // CH-15-01: connector_action without dispatch wired must carry "connector_dispatch_unwired"
+    // so operators can distinguish "no dispatch configured" from "dispatch executed".
+    assert.ok(result.reasons.includes("connector_dispatch_unwired"), `Expected reasons to include 'connector_dispatch_unwired' for unwired connector_action, got: ${JSON.stringify(result.reasons)}`);
+    assert.ok(!result.reasons.includes("internal_tick"), `Expected no 'internal_tick' for connector_action (not maintenance), got: ${JSON.stringify(result.reasons)}`);
+});
+// ─── Case E: ingestRhythmSignal full path — maintenance selected → internal_tick ──
+test("T2.2.3 E — ingestRhythmSignal maintenance path → result includes internal_tick", async () => {
+    // Force maintenance_only mode so planner yields only the maintenance intent.
+    const inputs = {
+        ...baseInputs,
+        mode: "maintenance_only",
+        currentWindowId: "win_maintenance",
+    };
+    const result = await ingestRhythmSignal(signal, {
+        loadSnapshotInputs: async () => inputs,
+    });
+    // In maintenance_only mode the planner should emit the maintenance intent.
+    // Guard evaluates it as "allow"; resolveAllowedIntentResult should then tag internal_tick.
+    if (result.status === "intent_selected") {
+        assert.ok(result.reasons.includes("internal_tick"), `maintenance_only mode → expected internal_tick in reasons, got: ${JSON.stringify(result.reasons)}`);
+    }
+    else {
+        // If no intent was selected (e.g., heartbeat_ok or denied), that's still valid — just note it.
+        // The key contract is: IF selected, internal_tick must be present for maintenance-class intents.
+        assert.ok(["heartbeat_ok", "deferred", "denied"].includes(result.status), `Unexpected status: ${result.status}`);
+    }
+});

package/dist/tests/unit/core/t2-2-3-connector-dispatch-wired.test.d.ts

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

package/dist/tests/unit/core/t2-2-3-connector-dispatch-wired.test.js

@@ -0,0 +1,99 @@
+/**
+ * T2.2.3 extension — connector_action with wired connectorExecutor.
+ *
+ * When connectorExecutor is present, resolveAllowedIntentResult dispatches
+ * through the connector-system instead of returning connector_dispatch_unwired.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveAllowedIntentResult } from "../../../src/core/second-nature/heartbeat/heartbeat-loop.js";
+import { buildContinuitySnapshot } from "../../../src/core/second-nature/heartbeat/snapshot-builder.js";
+import { buildHeartbeatRuntimeSnapshot } from "../../../src/core/second-nature/heartbeat/runtime-snapshot.js";
+const signal = {
+    trigger: "heartbeat_bridge",
+    scopeHint: "rhythm",
+    payload: { timestamp: "2026-05-10T10:00:00.000Z" },
+};
+const baseInputs = {
+    mode: "active",
+    currentWindowId: "win_work_morning",
+    pendingObligations: [],
+    recentOutreachHashes: [],
+    deniedIntents: [],
+};
+function makeRuntime(inputs) {
+    const continuity = buildContinuitySnapshot(inputs);
+    return buildHeartbeatRuntimeSnapshot("2026-05-10T10:00:00.000Z", inputs, continuity);
+}
+function makeExplorationIntent() {
+    return {
+        id: "intent-conn-explore",
+        kind: "exploration",
+        priority: 30,
+        source: "tick",
+        summary: "explore moltbook feed",
+        effectClass: "connector_action",
+        platformId: "moltbook",
+        sourceRefs: [{ id: "s1", kind: "platform_item", uri: "moltbook://item/1" }],
+        idempotencyKey: "conn:explore",
+    };
+}
+// ─── Case F: connectorExecutor present + success → connector_effect_executed ─────
+test("T2.2.3 F — connector_action with executor success → connector_effect_executed", async () => {
+    const executor = {
+        async executeEffect() {
+            return {
+                status: "success",
+                data: { items: [{ id: "mb-1", title: "test" }] },
+                metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 5 },
+            };
+        },
+    };
+    const runtime = makeRuntime(baseInputs);
+    const result = await resolveAllowedIntentResult(makeExplorationIntent(), runtime, baseInputs, signal, { connectorExecutor: executor });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("connector_effect_executed"), `Expected connector_effect_executed, got: ${JSON.stringify(result.reasons)}`);
+    assert.ok(result.decisionId, "expected decisionId to be set");
+});
+// ─── Case G: connectorExecutor present + retryable failure → connector_retryable_failure ─
+test("T2.2.3 G — connector_action with executor retryable_failure → connector_retryable_failure", async () => {
+    const executor = {
+        async executeEffect() {
+            return {
+                status: "retryable_failure",
+                failureClass: "rate_limited",
+                retryAfterMs: 30000,
+                metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 2 },
+            };
+        },
+    };
+    const runtime = makeRuntime(baseInputs);
+    const result = await resolveAllowedIntentResult(makeExplorationIntent(), runtime, baseInputs, signal, { connectorExecutor: executor });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("connector_retryable_failure"), `Expected connector_retryable_failure, got: ${JSON.stringify(result.reasons)}`);
+    assert.ok(result.reasons.includes("rate_limited"), `Expected rate_limited in reasons, got: ${JSON.stringify(result.reasons)}`);
+});
+// ─── Case H: connectorExecutor present + terminal failure → connector_terminal_failure ──
+test("T2.2.3 H — connector_action with executor terminal failure → connector_terminal_failure", async () => {
+    const executor = {
+        async executeEffect() {
+            return {
+                status: "terminal_failure",
+                failureClass: "auth_failure",
+                metadata: { platformId: "moltbook", channel: "api_rest", latencyMs: 1 },
+            };
+        },
+    };
+    const runtime = makeRuntime(baseInputs);
+    const result = await resolveAllowedIntentResult(makeExplorationIntent(), runtime, baseInputs, signal, { connectorExecutor: executor });
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("connector_terminal_failure"), `Expected connector_terminal_failure, got: ${JSON.stringify(result.reasons)}`);
+    assert.ok(result.reasons.includes("auth_failure"), `Expected auth_failure in reasons, got: ${JSON.stringify(result.reasons)}`);
+});
+// ─── Case I: no connectorExecutor → still returns connector_dispatch_unwired ──────
+test("T2.2.3 I — connector_action without executor still returns connector_dispatch_unwired", async () => {
+    const runtime = makeRuntime(baseInputs);
+    const result = await resolveAllowedIntentResult(makeExplorationIntent(), runtime, baseInputs, signal, {});
+    assert.equal(result.status, "intent_selected");
+    assert.ok(result.reasons.includes("connector_dispatch_unwired"), `Expected connector_dispatch_unwired, got: ${JSON.stringify(result.reasons)}`);
+});