@haaaiawd/second-nature 0.1.42 → 0.1.50

package/dist/src/core/second-nature/orchestrator/platform-capability-router.js

@@ -0,0 +1,149 @@
+function kindToCapability(kind) {
+    if (kind === "exploration")
+        return "feed.read";
+    if (kind === "social")
+        return "comment.reply";
+    if (kind === "work")
+        return "work.discover";
+    if (kind === "outreach")
+        return "message.send";
+    return null;
+}
+function getPlatformIds(registry) {
+    if (registry) {
+        return registry.listRegisteredPlatformIds();
+    }
+    // Fallback: built-in platforms when registry is absent (backward compat)
+    return ["moltbook", "instreet", "evomap", "agent-world"];
+}
+const FALLBACK_PLATFORM_CAPABILITIES = {
+    "moltbook": ["feed.read", "post.publish", "comment.reply", "message.send"],
+    "instreet": ["notification.list", "message.send", "comment.reply", "agent.heartbeat"],
+    "evomap": ["agent.register", "agent.heartbeat", "work.discover", "task.claim"],
+    "agent-world": ["feed.read", "work.discover", "task.claim"],
+};
+function fallbackPlatformSupportsCapability(platformId, kind) {
+    const capability = kindToCapability(kind);
+    if (!capability)
+        return false;
+    return (FALLBACK_PLATFORM_CAPABILITIES[platformId] ?? []).includes(capability);
+}
+function extractPlatformIdsFromGoals(goals, kind, platformIds) {
+    const capability = kindToCapability(kind);
+    const results = new Set();
+    for (const goal of goals) {
+        const text = `${goal.description} ${goal.completionCriteria ?? ""}`.toLowerCase();
+        for (const pid of platformIds) {
+            if (text.includes(pid)) {
+                results.add(pid);
+            }
+        }
+        // Also match if goal text contains the capability name (e.g. "feed.read")
+        if (capability && text.includes(capability.toLowerCase())) {
+            // capability alone doesn't tell us platform; keep for later
+        }
+    }
+    return [...results];
+}
+function extractPlatformIdsFromEvidence(refs, platformIds) {
+    const results = new Set();
+    for (const ref of refs) {
+        if (ref.kind === "connector_result" && ref.id) {
+            for (const pid of platformIds) {
+                if (ref.id.includes(pid)) {
+                    results.add(pid);
+                }
+            }
+        }
+        // Parse platform:// URIs (e.g. platform://moltbook/feed.read)
+        if (ref.uri && ref.uri.startsWith("platform://")) {
+            const afterScheme = ref.uri.slice("platform://".length);
+            const platformPart = afterScheme.split("/")[0];
+            if (platformPart && platformIds.includes(platformPart)) {
+                results.add(platformPart);
+            }
+        }
+        // L-02: Also support namespace format moltbook:feed.read (connector-system §5.3)
+        if (ref.uri && !ref.uri.includes("://") && ref.uri.includes(":")) {
+            const nsPart = ref.uri.split(":")[0];
+            if (nsPart && platformIds.includes(nsPart)) {
+                results.add(nsPart);
+            }
+        }
+    }
+    return [...results];
+}
+function validatePlatformCapability(platformId, kind, registry) {
+    const capability = kindToCapability(kind);
+    if (!capability)
+        return false;
+    try {
+        return registry.hasCapability(platformId, capability);
+    }
+    catch (err) {
+        // H-08: Log registry validation failures for observability.
+        console.warn(`[platform-capability-router] Registry validation failed for ${platformId}:${capability}`, err);
+        return false;
+    }
+}
+/**
+ * Resolve an explicit platformId for a candidate intent kind.
+ * Returns `undefined` when no unambiguous platform can be inferred.
+ */
+export function resolvePlatformForIntent(kind, context, registry) {
+    const capability = kindToCapability(kind);
+    if (!capability) {
+        // Quiet, reflection, maintenance have no connector capability mapping.
+        return undefined;
+    }
+    const platformIds = getPlatformIds(registry);
+    const candidates = [];
+    if (context.acceptedGoals && context.acceptedGoals.length > 0) {
+        candidates.push(...extractPlatformIdsFromGoals(context.acceptedGoals, kind, platformIds));
+    }
+    if (context.evidenceRefs && context.evidenceRefs.length > 0) {
+        candidates.push(...extractPlatformIdsFromEvidence(context.evidenceRefs, platformIds));
+    }
+    // Deduplicate while preserving order
+    const ordered = [...new Set(candidates)];
+    if (ordered.length > 1) {
+        // Ambiguous: multiple platforms inferred → do not guess, return undefined.
+        // Guard layer will deny with "ambiguous_platform" reason.
+        return undefined;
+    }
+    if (ordered.length === 1) {
+        const single = ordered[0];
+        if (registry) {
+            if (validatePlatformCapability(single, kind, registry)) {
+                return single;
+            }
+            // Registry says unsupported → undefined (guard layer will deny)
+            return undefined;
+        }
+        // No registry: keep legacy platform-name fallback, but do not invent an
+        // unsupported platform/capability pair that later fails as protocol_mismatch.
+        if (!fallbackPlatformSupportsCapability(single, kind)) {
+            return undefined;
+        }
+        return single;
+    }
+    // No candidates inferred from goals/evidence → fallback to a supported platform.
+    // Sort alphabetically so different capabilities map to different platforms over time,
+    // preventing a single platform (e.g. moltbook) from monopolising all connector traffic.
+    if (registry) {
+        const supported = platformIds
+            .filter((pid) => validatePlatformCapability(pid, kind, registry))
+            .sort();
+        if (supported.length > 0) {
+            return supported[0];
+        }
+    }
+    // No registry: use fallback capability mapping
+    const supportedFallback = platformIds
+        .filter((pid) => fallbackPlatformSupportsCapability(pid, kind))
+        .sort();
+    if (supportedFallback.length > 0) {
+        return supportedFallback[0];
+    }
+    return undefined;
+}

package/dist/src/storage/snapshots/types.js

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

package/dist/src/storage/user-interest/types.js

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

package/dist/tests/integration/cli/cli-ops-surface.test.d.ts

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

package/dist/tests/integration/cli/cli-ops-surface.test.js

@@ -0,0 +1,380 @@
+import test, { beforeEach } 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 { createCliRuntimeDeps, createCommandRouter, closeCliRuntimeDeps, } from "../../../src/cli/index.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { decisionLedger, executionAttempts, governanceAudit } from "../../../src/observability/db/schema/index.js";
+import { resolveDailyReportPath } from "../../../src/storage/memory/workspace/paths.js";
+beforeEach(() => {
+    process.env.SECOND_NATURE_ENCRYPTION_KEY = "abcdefghijklmnopqrstuvwxyz123456";
+});
+const STATE_TEST_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS credential_records (
+    platform_id TEXT PRIMARY KEY,
+    credential_type TEXT NOT NULL,
+    encrypted_value TEXT NOT NULL,
+    status TEXT NOT NULL,
+    verification_code TEXT,
+    challenge_text TEXT,
+    expires_at TEXT,
+    attempts_remaining INTEGER,
+    updated_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS policy_records (
+    platform_id TEXT PRIMARY KEY,
+    social_daily_limit INTEGER NOT NULL,
+    quiet_enabled INTEGER NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS asset_registry (
+    id TEXT PRIMARY KEY,
+    kind TEXT NOT NULL,
+    path TEXT NOT NULL,
+    hash TEXT NOT NULL,
+    version INTEGER NOT NULL DEFAULT 1,
+    layer TEXT NOT NULL,
+    last_indexed_at TEXT NOT NULL
+  );
+  CREATE TABLE IF NOT EXISTS intent_commit_records (
+    id TEXT PRIMARY KEY,
+    intent_id TEXT NOT NULL,
+    decision_id TEXT NOT NULL,
+    checkpoint_id TEXT,
+    state TEXT NOT NULL,
+    outcome_ref TEXT,
+    metadata_json TEXT,
+    updated_at TEXT NOT NULL
+  );
+`;
+const OBSERVABILITY_TEST_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS decision_ledger (
+    id TEXT PRIMARY KEY,
+    tick_id TEXT NOT NULL,
+    trace_id TEXT NOT NULL,
+    intent_id TEXT,
+    platform_id TEXT,
+    verdict TEXT NOT NULL,
+    mode TEXT NOT NULL,
+    reasons TEXT NOT NULL,
+    reason_codes TEXT NOT NULL,
+    decision_basis TEXT NOT NULL,
+    evidence_refs TEXT NOT NULL,
+    model_eval_ref TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS decision_trace_idx ON decision_ledger(trace_id);
+  CREATE INDEX IF NOT EXISTS decision_tick_idx ON decision_ledger(tick_id);
+  CREATE TABLE IF NOT EXISTS execution_attempts (
+    id TEXT PRIMARY KEY,
+    trace_id TEXT NOT NULL,
+    decision_id TEXT NOT NULL,
+    intent_id TEXT NOT NULL,
+    platform_id TEXT NOT NULL,
+    capability TEXT NOT NULL,
+    channel TEXT NOT NULL,
+    status TEXT NOT NULL,
+    commit_state TEXT,
+    failure_class TEXT,
+    retry_policy TEXT,
+    idempotency_key TEXT,
+    started_at TEXT,
+    finished_at TEXT
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS attempt_trace_idx ON execution_attempts(trace_id);
+  CREATE INDEX IF NOT EXISTS attempt_decision_idx ON execution_attempts(decision_id);
+  CREATE INDEX IF NOT EXISTS attempt_platform_idx ON execution_attempts(platform_id);
+  CREATE TABLE IF NOT EXISTS governance_audit (
+    id TEXT PRIMARY KEY,
+    event_type TEXT NOT NULL,
+    proposal_id TEXT,
+    target_asset_id TEXT,
+    asset_path TEXT,
+    status_from TEXT,
+    status_to TEXT NOT NULL,
+    before_hash TEXT,
+    after_hash TEXT,
+    supporting_sources TEXT,
+    reason TEXT,
+    verification_deadline TEXT,
+    attempts_remaining INTEGER,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS audit_proposal_idx ON governance_audit(proposal_id);
+  CREATE INDEX IF NOT EXISTS audit_asset_idx ON governance_audit(target_asset_id);
+  CREATE INDEX IF NOT EXISTS audit_event_idx ON governance_audit(event_type);
+  CREATE TABLE IF NOT EXISTS redaction_manifest (
+    id TEXT PRIMARY KEY,
+    event_id TEXT NOT NULL,
+    event_type TEXT NOT NULL,
+    field_name TEXT NOT NULL,
+    action TEXT NOT NULL,
+    original_value_hash TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS redact_event_idx ON redaction_manifest(event_id);
+`;
+function applyCliOpsTestSchema(runtime) {
+    runtime.stateDb.sqlite.exec(STATE_TEST_SCHEMA);
+    runtime.observabilityDb.sqlite.exec(OBSERVABILITY_TEST_SCHEMA);
+}
+function buildRuntimeAndRouter() {
+    const unique = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const statePath = path.join(os.tmpdir(), `sn-cli-state-${unique}.db`);
+    const obsPath = path.join(os.tmpdir(), `sn-cli-obs-${unique}.db`);
+    const seededRuntime = createCliRuntimeDeps({
+        stateDb: createStateDatabase(statePath),
+        observabilityDb: createObservabilityDatabase(obsPath),
+    });
+    applyCliOpsTestSchema(seededRuntime);
+    const router = createCommandRouter({ deps: seededRuntime });
+    return {
+        runtime: seededRuntime,
+        router,
+        cleanup() {
+            closeCliRuntimeDeps(seededRuntime);
+            if (fs.existsSync(statePath))
+                fs.rmSync(statePath, { force: true });
+            if (fs.existsSync(obsPath))
+                fs.rmSync(obsPath, { force: true });
+        },
+    };
+}
+function getCommand(router, name) {
+    const command = router.resolve(name);
+    assert.ok(command, `command ${name} should exist`);
+    return command;
+}
+test("T5.1.2 status/report/quiet/session/credential commands return aggregated read models", async () => {
+    const harness = buildRuntimeAndRouter();
+    await harness.runtime.stateApi.credentials.saveCredentialContext({
+        platformId: "instreet",
+        credentialType: "api_key",
+        encryptedValue: "encrypted",
+        status: "pending_verification",
+        verificationCode: "1234",
+        challengeText: "challenge",
+        expiresAt: "2026-03-25T10:00:00.000Z",
+        attemptsRemaining: 2,
+    });
+    const reportPath = resolveDailyReportPath("2026-03-25");
+    fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+    fs.writeFileSync(reportPath, [
+        "# Daily Report — 2026-03-25",
+        "",
+        "## Summary",
+        "Seeded summary",
+        "",
+        "## Highlights",
+        "- H1",
+        "",
+        "## Sources",
+        "- Activities: a1",
+        "- Observations: o1",
+    ].join("\n"), "utf-8");
+    const now = new Date().toISOString();
+    await harness.runtime.observabilityDb.db.insert(decisionLedger).values({
+        id: "decision-runtime",
+        tickId: "tick-runtime",
+        traceId: "sn-runtime-register-1",
+        intentId: "intent-runtime",
+        platformId: null,
+        verdict: "defer",
+        mode: "active",
+        reasons: JSON.stringify(["origin:register"]),
+        reasonCodes: JSON.stringify(["heartbeat_decision"]),
+        decisionBasis: "rule_only",
+        evidenceRefs: JSON.stringify(["scope:rhythm", "trigger:heartbeat_bridge", "status:heartbeat_ok"]),
+        modelEvalRef: null,
+        createdAt: now,
+    });
+    await harness.runtime.observabilityDb.db.insert(executionAttempts).values({
+        id: "attempt-runtime",
+        traceId: "sn-runtime-register-1",
+        decisionId: "decision-runtime",
+        intentId: "intent-runtime",
+        platformId: "second-nature-runtime",
+        capability: "runtime.activate",
+        channel: "plugin_host",
+        status: "succeeded",
+        commitState: "committed",
+        failureClass: null,
+        retryPolicy: null,
+        idempotencyKey: null,
+        startedAt: now,
+        finishedAt: now,
+    });
+    await harness.runtime.observabilityDb.db.insert(decisionLedger).values({
+        id: "decision-status",
+        tickId: "tick-status",
+        traceId: "trace-session-1",
+        intentId: "intent-1",
+        platformId: "instreet",
+        verdict: "allow",
+        mode: "active",
+        reasons: JSON.stringify(["policy_ok"]),
+        reasonCodes: JSON.stringify(["policy_ok"]),
+        decisionBasis: "rule_only",
+        evidenceRefs: JSON.stringify(["content_ref:status"]),
+        modelEvalRef: null,
+        createdAt: now,
+    });
+    await harness.runtime.observabilityDb.db.insert(executionAttempts).values({
+        id: "attempt-status",
+        traceId: "trace-session-1",
+        decisionId: "decision-status",
+        intentId: "intent-1",
+        platformId: "instreet",
+        capability: "feed.read",
+        channel: "api_rest",
+        status: "succeeded",
+        commitState: "committed",
+        failureClass: null,
+        retryPolicy: null,
+        idempotencyKey: null,
+        startedAt: now,
+        finishedAt: now,
+    });
+    await harness.runtime.observabilityDb.db.insert(governanceAudit).values({
+        id: "gov-session-1",
+        eventType: "anchor.applied",
+        proposalId: "proposal-1",
+        targetAssetId: "SOUL.md",
+        assetPath: "workspace/SOUL.md",
+        statusFrom: "approved",
+        statusTo: "applied",
+        beforeHash: "h1",
+        afterHash: "h2",
+        supportingSources: JSON.stringify(["content_ref:status"]),
+        reason: "seed",
+        verificationDeadline: null,
+        attemptsRemaining: null,
+        createdAt: now,
+    });
+    const status = getCommand(harness.router, "status");
+    const report = getCommand(harness.router, "report");
+    const quiet = getCommand(harness.router, "quiet");
+    const session = getCommand(harness.router, "session");
+    const credential = getCommand(harness.router, "credential");
+    const statusResult = await status.execute({});
+    assert.equal(statusResult.ok, true);
+    assert.equal(statusResult.data.runtime.host, "openclaw-plugin");
+    assert.equal(statusResult.data.runtime.serviceStatus, "running");
+    assert.equal(statusResult.data.credentials[0].platformId, "instreet");
+    assert.equal(statusResult.data.credentials[0].status, "pending_verification");
+    const reportResult = await report.execute({ day: "2026-03-25" });
+    assert.equal(reportResult.ok, true);
+    assert.equal(reportResult.data.day, "2026-03-25");
+    assert.equal(reportResult.data.summary, "Seeded summary");
+    assert.deepEqual(reportResult.data.highlights, ["H1"]);
+    const quietResult = await quiet.execute({ scope: "recent" });
+    assert.equal(quietResult.ok, true);
+    assert.equal(quietResult.data.scope, "recent");
+    assert.equal(quietResult.data.mode, "unknown");
+    const sessionMissing = await session.execute({});
+    assert.equal(sessionMissing.ok, false);
+    assert.deepEqual(sessionMissing.error.requiredUserInput, ["session_id"]);
+    const sessionResult = await session.execute({ sessionId: "trace-session-1" });
+    assert.equal(sessionResult.ok, true);
+    assert.equal(sessionResult.data.requestedSessionId, "trace-session-1");
+    assert.equal(sessionResult.data.traceId, "trace-session-1");
+    assert.equal(sessionResult.data.decisionCount, 1);
+    assert.equal(sessionResult.data.attemptCount, 1);
+    assert.equal(sessionResult.data.governanceCount, 0);
+    const credentialShow = await credential.execute({ platformId: "instreet" });
+    assert.equal(credentialShow.ok, true);
+    assert.equal(credentialShow.data.platformId, "instreet");
+    assert.equal(credentialShow.data.status, "pending_verification");
+    harness.cleanup();
+});
+test("T5.2.1 explain command routes subject and returns structured explanation", async () => {
+    const harness = buildRuntimeAndRouter();
+    const explain = getCommand(harness.router, "explain");
+    const now = new Date().toISOString();
+    await harness.runtime.observabilityDb.db.insert(decisionLedger).values({
+        id: "decision-explain-1",
+        tickId: "tick-explain-1",
+        traceId: "trace-explain-1",
+        intentId: "intent-explain-1",
+        platformId: "instreet",
+        verdict: "allow",
+        mode: "active",
+        reasons: JSON.stringify(["reason"]),
+        reasonCodes: JSON.stringify(["policy_ok", "value_high"]),
+        decisionBasis: "rule_only",
+        evidenceRefs: JSON.stringify(["content_ref:decision:1"]),
+        modelEvalRef: null,
+        createdAt: now,
+    });
+    await harness.runtime.observabilityDb.db.insert(governanceAudit).values({
+        id: "gov-explain-1",
+        eventType: "anchor.applied",
+        proposalId: "proposal-explain",
+        targetAssetId: "SOUL.md",
+        assetPath: "workspace/SOUL.md",
+        statusFrom: "approved",
+        statusTo: "applied",
+        beforeHash: "b1",
+        afterHash: "a1",
+        supportingSources: JSON.stringify(["content_ref:soul:1"]),
+        reason: "seed",
+        verificationDeadline: null,
+        attemptsRemaining: null,
+        createdAt: now,
+    });
+    const missing = await explain.execute({});
+    assert.equal(missing.ok, false);
+    assert.deepEqual(missing.error.requiredUserInput, ["subject"]);
+    const unsupported = await explain.execute({ subject: "unknown:1" });
+    assert.equal(unsupported.ok, false);
+    assert.equal(unsupported.error.code, "EXPLAIN_SUBJECT_UNSUPPORTED");
+    const decisionExplain = await explain.execute({ subject: "decision:decision-explain-1" });
+    assert.equal(decisionExplain.ok, true);
+    assert.equal(decisionExplain.data.subjectType, "decision");
+    assert.ok(decisionExplain.data.keyFactors.includes("policy_ok"));
+    const soulExplain = await explain.execute({ subject: "soul:SOUL.md" });
+    assert.equal(soulExplain.ok, true);
+    assert.equal(soulExplain.data.subjectType, "soul-change");
+    assert.ok(soulExplain.data.evidenceRefs.includes("content_ref:soul:1"));
+    harness.cleanup();
+});
+test("T5.2.2 policy set and credential verify return requiredUserInput for non-interactive recovery", async () => {
+    const harness = buildRuntimeAndRouter();
+    const policy = getCommand(harness.router, "policy");
+    const credential = getCommand(harness.router, "credential");
+    await harness.runtime.stateApi.credentials.saveCredentialContext({
+        platformId: "instreet",
+        credentialType: "api_key",
+        encryptedValue: "encrypted",
+        status: "pending_verification",
+        verificationCode: "pending",
+        challengeText: "challenge",
+        expiresAt: "2026-03-25T10:00:00.000Z",
+        attemptsRemaining: 3,
+    });
+    const policyMissing = await policy.execute({ action: "set", platformId: "instreet" });
+    assert.equal(policyMissing.ok, false);
+    assert.deepEqual(policyMissing.error.requiredUserInput, ["social_daily_limit", "quiet_enabled"]);
+    const policyOk = await policy.execute({
+        action: "set",
+        platformId: "instreet",
+        socialDailyLimit: 8,
+        quietEnabled: true,
+    });
+    assert.equal(policyOk.ok, true);
+    const savedPolicy = await harness.runtime.stateApi.read.loadPolicy("instreet");
+    assert.ok(savedPolicy);
+    assert.equal(savedPolicy?.socialDailyLimit, 8);
+    assert.equal(savedPolicy?.quietEnabled, true);
+    const verifyMissing = await credential.execute({ action: "verify", platformId: "instreet" });
+    assert.equal(verifyMissing.ok, false);
+    assert.deepEqual(verifyMissing.error.requiredUserInput, ["verification_answer"]);
+    const verifyOk = await credential.execute({ action: "verify", platformId: "instreet", answer: "4321" });
+    assert.equal(verifyOk.ok, true);
+    const savedCredential = await harness.runtime.stateApi.credentials.loadCredentialContext("instreet");
+    assert.equal(savedCredential?.status, "active");
+    assert.equal(savedCredential?.verificationCode, "4321");
+    harness.cleanup();
+});

package/dist/tests/integration/cli/heartbeat-surface-workspace.test.d.ts

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

package/dist/tests/integration/cli/heartbeat-surface-workspace.test.js

@@ -0,0 +1,61 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { closeCliRuntimeDeps, createCliRuntimeDeps, createCommandRouter, heartbeatCheck, } from "../../../src/cli/index.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+test("T1.1.3 heartbeatCheck runtime unavailable returns runtime_carrier_only without lived-experience claim", async () => {
+    const r = await heartbeatCheck({ runtimeAvailable: false });
+    assert.equal(r.status, "runtime_carrier_only");
+    assert.equal(r.surfaceMode, "host_safe_carrier");
+    assert.equal(r.livedExperienceLoopClaimed, false);
+});
+test("T1.1.3 heartbeatCheck without readModels must not claim heartbeat_ok (CH-09-02)", async () => {
+    const r = await heartbeatCheck({ runtimeAvailable: true, readModels: undefined });
+    assert.equal(r.status, "runtime_carrier_only");
+    assert.equal(r.surfaceMode, "host_safe_carrier");
+    assert.ok(r.reasons.includes("heartbeat_read_models_unavailable"));
+    assert.equal(r.livedExperienceLoopClaimed, false);
+});
+test("T1.1.3 heartbeatCheck fake control-plane passthrough is schema parity only", async () => {
+    const r = await heartbeatCheck({
+        runtimeAvailable: true,
+        fakeControlPlanePassthrough: { decisionId: "dec-fake" },
+    });
+    assert.equal(r.status, "intent_selected");
+    assert.equal(r.schemaParityOnly, true);
+    assert.equal(r.livedExperienceLoopClaimed, false);
+    assert.equal(r.decisionId, "dec-fake");
+});
+test("T1.1.3 command router exposes heartbeat_check with stable fields", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("heartbeat_check");
+    assert.ok(cmd);
+    const out = (await cmd.execute({ probeOnly: true }));
+    assert.equal(out.ok, true);
+    assert.equal(out.status, "heartbeat_ok");
+    assert.equal(out.surfaceMode, "capability_probe");
+    assert.equal(out.livedExperienceLoopClaimed, false);
+    closeCliRuntimeDeps(deps);
+});
+test("T1.1.3 heartbeat_check with read models does not return legacy placeholder reasons", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("heartbeat_check");
+    assert.ok(cmd);
+    const out = (await cmd.execute({ timestamp: "2026-05-03T10:00:00.000Z" }));
+    assert.equal(out.ok, true);
+    assert.equal(out.surfaceMode, "workspace_full_runtime");
+    assert.ok(!out.reasons.includes("s1_placeholder_no_decision_loop"));
+    assert.ok(!out.reasons.includes("heartbeat_read_models_unavailable"));
+    assert.ok(out.reasons.includes("restore_snapshot_captured"));
+    const restoreRows = stateDb.sqlite.exec("SELECT COUNT(*) FROM restore_snapshot");
+    assert.equal(restoreRows[0].values[0][0], 1);
+    const timelineRows = stateDb.sqlite.exec("SELECT COUNT(*) FROM narrative_timeline");
+    assert.equal(timelineRows[0].values[0][0], 1);
+    closeCliRuntimeDeps(deps);
+});

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

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

package/dist/tests/integration/cli/host-capability-probe.test.js

@@ -0,0 +1,37 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { probeHostCapability, recordHostCapability } from "../../../src/cli/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { hostCapabilityReports } from "../../../src/observability/db/schema/host-capability-reports.js";
+test("T1.1.2 recordHostCapability persists probe report", async () => {
+    const obs = createObservabilityDatabase(":memory:");
+    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: "fail",
+            observedAt: now,
+            evidenceRefs: ref("t1"),
+        }),
+        checkDeliveryTarget: () => ({ status: "target_available", evidenceRefs: ref("d1") }),
+        checkAckDropBehavior: () => ({ name: "ack_drop", verdict: "unknown", observedAt: now, evidenceRefs: [] }),
+        checkHookSupport: () => [],
+    };
+    const report = probeHostCapability({
+        adapter,
+        docLinks: [],
+        docCheckedAt: now,
+        hostVersion: "1.0",
+    });
+    await recordHostCapability(obs, report);
+    const rows = await obs.db.select().from(hostCapabilityReports);
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].reportId, report.reportId);
+    assert.equal(rows[0].deliveryTarget, "target_available");
+    const full = JSON.parse(rows[0].fullReportJson);
+    assert.equal(full.heartbeatToolInvocation.verdict, "fail");
+    obs.close();
+});

package/dist/tests/integration/cli/host-smoke-heartbeat-tool.test.d.ts

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