@haaaiawd/second-nature 0.1.43 → 0.1.50

package/dist/tests/integration/cli/t1-2-1-narrative-command.test.js

@@ -0,0 +1,194 @@
+/**
+ * T1.2.1 — CLI `narrative` 命令最小闭环。
+ *
+ * Acceptance:
+ * A. 无数据时返回 ok:true + status nothing_yet，不返回空对象。
+ * B. 有数据时返回 focus、progress、nextIntent、sourceRefs、groundingStatus。
+ * C. groundingStatus 随 confidence 正确推导（pass / degraded / blocked）。
+ * D. 命令通过 createCommandRouter 正确注册并可解析。
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+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 { createNarrativeStateStore } from "../../../src/storage/narrative/narrative-state-store.js";
+test("T1.2.1-A: narrative returns ok:true with nothing_yet when store is empty", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("narrative");
+    assert.ok(cmd, "narrative command must be registered");
+    const result = (await cmd.execute());
+    assert.equal(result.ok, true, "narrative must return ok: true");
+    assert.ok(!JSON.stringify(result).includes("Implementation lands in later Wave tasks"), "must not return notImplemented placeholder");
+    const data = result.data;
+    assert.ok(data, "must include data");
+    assert.equal(data.status, "nothing_yet", "empty store must return status: nothing_yet");
+    assert.equal(data.focus, "", "empty store focus must be empty string");
+    assert.deepEqual(data.progress, [], "empty store progress must be []");
+    assert.deepEqual(data.sourceRefs, [], "empty store sourceRefs must be []");
+    assert.equal(data.groundingStatus, "blocked", "empty store groundingStatus must be blocked");
+    await closeCliRuntimeDeps(deps);
+});
+test("T1.2.1-B: narrative returns full NarrativeReadModel shape when data exists", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    // Seed a NarrativeState row before constructing deps
+    const narrativeStore = createNarrativeStateStore(stateDb);
+    await narrativeStore.updateNarrativeState({
+        narrativeId: "default",
+        revision: 2,
+        focus: "Completing Wave 32 narrative command",
+        progress: ["T1.2.1 spec implemented", "T1.2.6 aggregate ready"],
+        nextIntent: "Write integration tests",
+        confidence: 0.85,
+        sourceRefs: [{ sourceId: "src-001", kind: "heartbeat", url: "https://example.com/evidence" }],
+        unsupportedClaims: [],
+        status: "active",
+        updatedAt: "2026-05-16T10:00:00Z",
+    });
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("narrative");
+    assert.ok(cmd);
+    const result = (await cmd.execute());
+    assert.equal(result.ok, true);
+    const data = result.data;
+    assert.equal(data.narrativeId, "default");
+    assert.equal(data.revision, 2);
+    assert.equal(data.focus, "Completing Wave 32 narrative command");
+    assert.deepEqual(data.progress, ["T1.2.1 spec implemented", "T1.2.6 aggregate ready"]);
+    assert.equal(data.nextIntent, "Write integration tests");
+    assert.equal(data.confidence, 0.85);
+    assert.equal(data.status, "active");
+    assert.equal(data.updatedAt, "2026-05-16T10:00:00Z");
+    const refs = data.sourceRefs;
+    assert.equal(refs.length, 1);
+    assert.equal(refs[0].sourceId, "src-001");
+    assert.equal(refs[0].kind, "heartbeat");
+    assert.equal(refs[0].url, "https://example.com/evidence");
+    await closeCliRuntimeDeps(deps);
+});
+test("T1.2.1-C: groundingStatus correctly derived from confidence and status", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const narrativeStore = createNarrativeStateStore(stateDb);
+    // Case 1: confidence >= 0.7, active => pass
+    await narrativeStore.updateNarrativeState({
+        narrativeId: "default",
+        revision: 1,
+        focus: "pass scenario",
+        progress: [],
+        nextIntent: "next",
+        confidence: 0.75,
+        sourceRefs: [],
+        unsupportedClaims: [],
+        status: "active",
+        updatedAt: "2026-05-16T10:00:00Z",
+    });
+    let deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    let router = createCommandRouter({ deps });
+    let cmd = router.resolve("narrative");
+    let result = (await cmd.execute());
+    let data = result.data;
+    assert.equal(data.groundingStatus, "pass", "confidence 0.75 + active => pass");
+    await closeCliRuntimeDeps(deps);
+    // Case 2: confidence 0.5, insufficient_sources => degraded
+    const stateDb2 = createStateDatabase(":memory:");
+    const narrativeStore2 = createNarrativeStateStore(stateDb2);
+    await narrativeStore2.updateNarrativeState({
+        narrativeId: "default",
+        revision: 1,
+        focus: "degraded scenario",
+        progress: [],
+        nextIntent: "next",
+        confidence: 0.5,
+        sourceRefs: [],
+        unsupportedClaims: ["unsupported claim"],
+        status: "insufficient_sources",
+        updatedAt: "2026-05-16T10:00:00Z",
+    });
+    deps = createCliRuntimeDeps({ stateDb: stateDb2, observabilityDb });
+    router = createCommandRouter({ deps });
+    cmd = router.resolve("narrative");
+    result = (await cmd.execute());
+    data = result.data;
+    assert.equal(data.groundingStatus, "degraded", "confidence 0.5 + insufficient_sources => degraded");
+    await closeCliRuntimeDeps(deps);
+    // Case 3: awaiting_sources => blocked
+    const stateDb3 = createStateDatabase(":memory:");
+    const narrativeStore3 = createNarrativeStateStore(stateDb3);
+    await narrativeStore3.updateNarrativeState({
+        narrativeId: "default",
+        revision: 1,
+        focus: "blocked scenario",
+        progress: [],
+        nextIntent: "next",
+        confidence: 0.9,
+        sourceRefs: [],
+        unsupportedClaims: [],
+        status: "awaiting_sources",
+        updatedAt: "2026-05-16T10:00:00Z",
+    });
+    const obsDb3 = createObservabilityDatabase(":memory:");
+    deps = createCliRuntimeDeps({ stateDb: stateDb3, observabilityDb: obsDb3 });
+    router = createCommandRouter({ deps });
+    cmd = router.resolve("narrative");
+    result = (await cmd.execute());
+    data = result.data;
+    assert.equal(data.groundingStatus, "blocked", "awaiting_sources => blocked regardless of confidence");
+    await closeCliRuntimeDeps(deps);
+});
+test("T1.2.1-E: groundingStatus boundary value matrix", async () => {
+    // Boundary value analysis for deriveGroundingStatus thresholds (0.4, 0.7)
+    const cases = [
+        // Boundary at 0.7 (pass threshold)
+        { confidence: 0.7, status: "active", expected: "pass", label: "exactly 0.7 + active => pass" },
+        { confidence: 0.69, status: "active", expected: "degraded", label: "0.69 + active => degraded (just below pass)" },
+        // Boundary at 0.4 (degraded threshold)
+        { confidence: 0.4, status: "active", expected: "degraded", label: "exactly 0.4 + active => degraded" },
+        { confidence: 0.39, status: "active", expected: "blocked", label: "0.39 + active => blocked (just below degraded)" },
+        // Mid-range values
+        { confidence: 0.5, status: "active", expected: "degraded", label: "0.5 + active => degraded" },
+        { confidence: 0.75, status: "insufficient_sources", expected: "degraded", label: "0.75 + insufficient_sources => degraded" },
+        // Extremes
+        { confidence: 0.0, status: "active", expected: "blocked", label: "0.0 + active => blocked" },
+        { confidence: 1.0, status: "active", expected: "pass", label: "1.0 + active => pass" },
+    ];
+    for (const c of cases) {
+        const stateDb = createStateDatabase(":memory:");
+        const observabilityDb = createObservabilityDatabase(":memory:");
+        const narrativeStore = createNarrativeStateStore(stateDb);
+        await narrativeStore.updateNarrativeState({
+            narrativeId: "default",
+            revision: 1,
+            focus: c.label,
+            progress: [],
+            nextIntent: "next",
+            confidence: c.confidence,
+            sourceRefs: [],
+            unsupportedClaims: [],
+            status: c.status,
+            updatedAt: "2026-05-16T10:00:00Z",
+        });
+        const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+        const router = createCommandRouter({ deps });
+        const cmd = router.resolve("narrative");
+        const result = (await cmd.execute());
+        const data = result.data;
+        assert.equal(data.groundingStatus, c.expected, `${c.label} (confidence=${c.confidence}, status=${c.status})`);
+        await closeCliRuntimeDeps(deps);
+    }
+});
+test("T1.2.1-D: narrative command is registered in createCommandRouter", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("narrative");
+    assert.ok(cmd, "narrative must be registered in command router");
+    assert.ok(cmd.description.toLowerCase().includes("narrative"), "description must mention narrative");
+    await closeCliRuntimeDeps(deps);
+});

package/dist/tests/integration/cli/t1-2-2-dream-recent.test.d.ts

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

package/dist/tests/integration/cli/t1-2-2-dream-recent.test.js

@@ -0,0 +1,100 @@
+/**
+ * T1.2.2 — CLI `dream:recent` 命令最小闭环。
+ *
+ * Acceptance:
+ * A. 空 audit store 时返回 ok:true + { totalRuns: 0, runs: [] }，不含 notImplemented 占位。
+ * B. 有 dream.trace 事件时返回正确结构的 DreamRecentReadModel。
+ * C. limit 参数有效限制返回条数。
+ * D. 命令通过 createCommandRouter 正确注册并可解析。
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+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 { AppendOnlyAuditStore } from "../../../src/observability/audit/append-only-audit-store.js";
+import { createLivedExperienceAuditRecorder } from "../../../src/observability/services/lived-experience-audit.js";
+test("T1.2.2-A: dream:recent returns ok:true with honest empty when store is empty", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("dream:recent");
+    assert.ok(cmd, "dream:recent command must be registered");
+    const result = (await cmd.execute());
+    assert.equal(result.ok, true, "dream:recent must return ok: true");
+    assert.ok(!JSON.stringify(result).includes("Implementation lands in later Wave tasks"), "must not return notImplemented placeholder");
+    const data = result.data;
+    assert.ok(data, "must include data");
+    assert.equal(data.totalRuns, 0, "empty store must return totalRuns: 0");
+    assert.deepEqual(data.runs, [], "empty store must return runs: []");
+    await closeCliRuntimeDeps(deps);
+});
+test("T1.2.2-B: dream:recent returns correct DreamRecentReadModel shape", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const store = new AppendOnlyAuditStore();
+    const recorder = createLivedExperienceAuditRecorder(store);
+    recorder.recordDreamTrace({
+        traceId: "dream:trace-cli-001",
+        runId: "run-cli-001",
+        startedAt: "2026-05-16T08:00:00Z",
+        finishedAt: "2026-05-16T08:01:00Z",
+        durationMs: 60000,
+        inputCounts: { evidence: 3, chronicle: 2, memoryEntries: 5 },
+    });
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb, livedExperienceAuditStore: store });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("dream:recent");
+    assert.ok(cmd);
+    const result = (await cmd.execute());
+    assert.equal(result.ok, true);
+    const data = result.data;
+    assert.equal(data.totalRuns, 1);
+    const runs = data.runs;
+    assert.equal(runs.length, 1);
+    const run = runs[0];
+    assert.equal(run.traceId, "dream:trace-cli-001");
+    assert.equal(run.runId, "run-cli-001");
+    assert.equal(run.durationMs, 60000);
+    assert.deepEqual(run.inputCounts, { evidence: 3, chronicle: 2, memoryEntries: 5 });
+    assert.equal(run.lifecycleStatus, "completed");
+    assert.ok(typeof run.createdAt === "string");
+    await closeCliRuntimeDeps(deps);
+});
+test("T1.2.2-C: dream:recent respects limit parameter", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const store = new AppendOnlyAuditStore();
+    const recorder = createLivedExperienceAuditRecorder(store);
+    for (let i = 0; i < 5; i++) {
+        recorder.recordDreamTrace({
+            traceId: `dream:trace-limit-${i}`,
+            runId: `run-limit-${i}`,
+            startedAt: "2026-05-16T08:00:00Z",
+            finishedAt: `2026-05-16T0${i + 1}:00:00Z`,
+            durationMs: 1000,
+            inputCounts: { evidence: 1, chronicle: 0, memoryEntries: 0 },
+        });
+    }
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb, livedExperienceAuditStore: store });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("dream:recent");
+    assert.ok(cmd);
+    const result = (await cmd.execute({ limit: 2 }));
+    assert.equal(result.ok, true);
+    const data = result.data;
+    assert.equal(data.totalRuns, 5); // totalRuns reflects all events
+    assert.equal(data.runs.length, 2); // but only 2 returned
+    await closeCliRuntimeDeps(deps);
+});
+test("T1.2.2-D: dream:recent command is registered in createCommandRouter", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const router = createCommandRouter({ deps });
+    const cmd = router.resolve("dream:recent");
+    assert.ok(cmd, "dream:recent must be registered in command router");
+    assert.ok(cmd.description.toLowerCase().includes("dream"), "description must mention dream");
+    await closeCliRuntimeDeps(deps);
+});

package/dist/tests/integration/cli/t1-2-3-status-observability-writeback.test.d.ts

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

package/dist/tests/integration/cli/t1-2-3-status-observability-writeback.test.js

@@ -0,0 +1,71 @@
+/**
+ * T1.2.3 — `loadStatus` aggregate observability writeback.
+ *
+ * Verifies that a workspace `heartbeat_check` (full runtime) writes:
+ *   - `decision_ledger` row with `traceId` prefix `sn-runtime-`
+ *   - `execution_attempts` row with `platformId === "second-nature-runtime"`
+ * so that `loadStatus()` no longer returns `unknown` for `rhythm.mode` /
+ * `runtime.serviceStatus` purely because observability tables are empty.
+ *
+ * Also verifies that carrier-only / probe-only paths intentionally do NOT write,
+ * preserving the host-safe carrier contract from T1.1.3 / ADR-005.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import { desc } from "drizzle-orm";
+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 { decisionLedger, executionAttempts } from "../../../src/observability/db/schema/index.js";
+test("T1.2.3 workspace heartbeat_check writes sn-runtime ledger + second-nature-runtime attempt", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const deps = createCliRuntimeDeps({ stateDb, observabilityDb });
+    const before = await deps.readModels.loadStatus();
+    assert.equal(before.rhythm.mode, "unknown", "baseline rhythm must be unknown when ledger is empty");
+    assert.equal(before.runtime.serviceStatus, "unknown", "baseline runtime serviceStatus must be unknown when execution_attempts is empty");
+    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-09T10:00:00.000Z" }));
+    assert.equal(out.ok, true);
+    assert.equal(out.surfaceMode, "workspace_full_runtime");
+    assert.equal(out.livedExperienceLoopClaimed, false);
+    const decisions = await observabilityDb.db
+        .select()
+        .from(decisionLedger)
+        .orderBy(desc(decisionLedger.createdAt))
+        .limit(5);
+    const runtimeDecision = decisions.find((row) => row.traceId.startsWith("sn-runtime-"));
+    assert.ok(runtimeDecision, "decision_ledger must contain a sn-runtime-* row after heartbeat_check");
+    const attempts = await observabilityDb.db
+        .select()
+        .from(executionAttempts)
+        .orderBy(desc(executionAttempts.startedAt));
+    const runtimeAttempt = attempts.find((row) => row.platformId === "second-nature-runtime");
+    assert.ok(runtimeAttempt, "execution_attempts must contain a second-nature-runtime row after heartbeat_check");
+    assert.equal(runtimeAttempt.traceId, runtimeDecision.traceId, "attempt and decision must share traceId");
+    const after = await deps.readModels.loadStatus();
+    assert.notEqual(after.rhythm.mode, "unknown", "rhythm.mode must exit unknown after a recorded cycle");
+    assert.notEqual(after.runtime.serviceStatus, "unknown", "runtime.serviceStatus must exit unknown after a recorded attempt");
+    closeCliRuntimeDeps(deps);
+});
+test("T1.2.3 probeOnly heartbeat_check does not write observability rows (host-safe carrier preserved)", 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.surfaceMode, "capability_probe");
+    const decisions = await observabilityDb.db.select().from(decisionLedger);
+    const attempts = await observabilityDb.db.select().from(executionAttempts);
+    assert.equal(decisions.filter((d) => d.traceId.startsWith("sn-runtime-")).length, 0, "probe-only must not write sn-runtime decision rows");
+    assert.equal(attempts.filter((a) => a.platformId === "second-nature-runtime").length, 0, "probe-only must not write second-nature-runtime attempts");
+    const after = await deps.readModels.loadStatus();
+    assert.equal(after.rhythm.mode, "unknown", "probe-only must keep rhythm.mode unknown");
+    assert.equal(after.runtime.serviceStatus, "unknown", "probe-only must keep runtime.serviceStatus unknown");
+    closeCliRuntimeDeps(deps);
+});

package/dist/tests/integration/cli/t1-2-4-quiet-report-read-canonical.test.d.ts

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

package/dist/tests/integration/cli/t1-2-4-quiet-report-read-canonical.test.js

@@ -0,0 +1,206 @@
+/**
+ * T1.2.4 — Quiet JSON 工件与 `report`/`quiet` canonical 对齐 + workspace quietWorkflow 接线。
+ *
+ * CH-14-07 根因：
+ *   - `persistQuietArtifactToWorkspace` 写入 `.second-nature/quiet/{day}/`
+ *   - `loadQuiet` 读取 `memory/` 目录（journal + reports）
+ *   - 两路数据断裂：写了 JSON 工件后，`loadQuiet` 仍返回 sourceCount=0
+ *
+ * 场测勘误：「写了读不到」当前现场不适用（磁盘无 `.second-nature/quiet/`）；
+ * 但任务仍需保证 Quiet 一旦运行后读路径非空。
+ *
+ * 验收标准 A：fixture 已执行一次 source-backed Quiet 并落盘 JSON 后，
+ *   `loadQuiet` 返回 sourceCount > 0 且 mode !== "unknown"。
+ * 验收标准 B：full-runtime heartbeat 选中 quiet intent（通过 maintenance_only + quietEnabled 路径
+ *   来触发 quiet intent 写盘）后，周期结果含 `quiet_artifact_written` 或诚实原因。
+ * 验收标准 C：quietWorkflow 接线后，heartbeat 不因 workspaceRoot 注入而崩溃。
+ */
+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 { createCliReadModels } from "../../../src/cli/read-models/index.js";
+import { createStateDatabase } from "../../../src/storage/db/index.js";
+import { createObservabilityDatabase } from "../../../src/observability/db/index.js";
+import { writeQuietArtifact } from "../../../src/storage/quiet/quiet-artifact-writer.js";
+import { persistQuietArtifactToWorkspace } from "../../../src/storage/quiet/persist-quiet-artifact.js";
+import { createWorkspaceHeartbeatRunner } from "../../../src/cli/ops/workspace-heartbeat-runner.js";
+function makeTempWorkspace() {
+    return fs.mkdtempSync(path.join(os.tmpdir(), "sn-t124-"));
+}
+const today = new Date().toISOString().slice(0, 10);
+// ─── Case A: 写盘后 loadQuiet 非零 ───────────────────────────────────────────
+test("T1.2.4 A — after empty Quiet artifact persisted, loadQuiet tracks empty state separately", async () => {
+    const ws = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({
+        stateDb,
+        observabilityDb,
+        workspaceRoot: ws,
+    });
+    // Before: quiet should be unknown
+    const before = await readModels.loadQuiet();
+    assert.equal(before.mode, "unknown", "Before Quiet runs, mode must be unknown");
+    assert.equal(before.sourceCount, 0, "Before Quiet runs, sourceCount must be 0");
+    // Simulate Quiet artifact write (empty_state path, simplest valid write).
+    const input = {
+        day: today,
+        kind: "empty_state",
+        title: "Quiet — empty state test",
+        body: "No evidence.",
+        claims: [],
+        sourceRefs: [],
+    };
+    const ack = writeQuietArtifact(input);
+    await persistQuietArtifactToWorkspace(ws, ack, input);
+    // After: empty_state is visible, but does not masquerade as a source-backed report.
+    const after = await readModels.loadQuiet();
+    assert.equal(after.sourceCount, 0, `Expected sourceCount to remain 0 for empty_state; got ${after.sourceCount}`);
+    assert.equal(after.emptyStateCount, 1);
+    assert.equal(after.mode, "unknown", "Empty state alone must not switch Quiet read model into source-backed mode");
+    stateDb.close();
+    observabilityDb.close();
+    fs.rmSync(ws, { recursive: true, force: true });
+});
+// ─── Case B: 无 workspaceRoot → loadQuiet 静默降级，不崩溃 ───────────────────
+test("T1.2.4 B — without workspaceRoot, loadQuiet returns unknown gracefully", async () => {
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    // Intentionally omit workspaceRoot.
+    const readModels = createCliReadModels({ stateDb, observabilityDb });
+    const result = await readModels.loadQuiet();
+    // Without workspaceRoot, can't scan .second-nature/quiet/ — should return unknown safely.
+    assert.equal(result.mode, "unknown", "Without workspaceRoot, mode must be unknown (no evidence)");
+    assert.equal(result.sourceCount, 0, "Without workspaceRoot, sourceCount must be 0");
+    stateDb.close();
+    observabilityDb.close();
+});
+// ─── Case C: quietWorkflow 注入不崩溃心跳 ─────────────────────────────────────
+test("T1.2.4 C — createWorkspaceHeartbeatRunner with quietWorkflow injected does not crash", async () => {
+    const ws = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({
+        stateDb,
+        observabilityDb,
+        workspaceRoot: ws,
+    });
+    const runner = createWorkspaceHeartbeatRunner(readModels, {
+        workspaceRoot: ws,
+        enableQuietWorkflow: true,
+        state: stateDb,
+    });
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: "rhythm",
+        payload: { timestamp: "2026-05-10T10:00:00.000Z" },
+    };
+    const result = await runner(signal);
+    // Should complete without throwing, returning a valid HeartbeatCycleResult.
+    assert.ok(result.status, "heartbeat cycle must return a valid status");
+    assert.ok(Array.isArray(result.reasons), "heartbeat cycle must return reasons array");
+    stateDb.close();
+    observabilityDb.close();
+    fs.rmSync(ws, { recursive: true, force: true });
+});
+// ─── Case D: quiet intent path → artifact 写盘 → loadQuiet 读到 ───────────────
+test("T1.2.4 D — after quiet intent writes artifact via heartbeat runner, loadQuiet reads it back", async () => {
+    const ws = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({
+        stateDb,
+        observabilityDb,
+        workspaceRoot: ws,
+    });
+    // Directly persist a daily_report artifact (simulating a non-empty Quiet path).
+    const input = {
+        day: today,
+        kind: "daily_report",
+        title: "Quiet daily report",
+        body: "Source-backed summary.",
+        claims: [
+            {
+                id: "fact:1",
+                text: "Evidence-backed fact",
+                claimType: "fact",
+                sourceRefs: [
+                    { id: "src-1", kind: "platform_item", uri: "moltbook://1" },
+                ],
+            },
+        ],
+        sourceRefs: [
+            {
+                id: "src-1",
+                kind: "platform_item",
+                uri: "moltbook://1",
+                excerptHash: undefined,
+                observedAt: undefined,
+            },
+        ],
+    };
+    const ack = writeQuietArtifact(input);
+    await persistQuietArtifactToWorkspace(ws, ack, input);
+    const quietResult = await readModels.loadQuiet();
+    assert.ok(quietResult.sourceCount > 0, "loadQuiet must reflect persisted daily_report artifact");
+    assert.equal(quietResult.mode, "quiet", "mode must be 'quiet' when artifacts exist");
+    assert.ok(quietResult.reportCount > 0, "reportCount must be > 0 after artifact persisted");
+    stateDb.close();
+    observabilityDb.close();
+    fs.rmSync(ws, { recursive: true, force: true });
+});
+// ─── Case E: loadDailyReport 也反映写盘工件（T1.2.4 / code review gap 修复）──────
+//
+// Code review 发现 loadDailyReport 未扫描 .second-nature/quiet/{day}/；
+// 本测试验证修复后 loadDailyReport(day).sourceRefs 能反映写盘工件。
+test("T1.2.4 E — after Quiet artifact persisted, loadDailyReport sourceRefs is non-empty", async () => {
+    const ws = makeTempWorkspace();
+    const stateDb = createStateDatabase(":memory:");
+    const observabilityDb = createObservabilityDatabase(":memory:");
+    const readModels = createCliReadModels({
+        stateDb,
+        observabilityDb,
+        workspaceRoot: ws,
+    });
+    // Before: loadDailyReport should have no sourceRefs.
+    const before = await readModels.loadDailyReport(today);
+    assert.equal(before.sourceRefs.length, 0, "Before artifact persisted, sourceRefs must be empty");
+    // Write a source-backed Quiet report artifact for today.
+    const input = {
+        day: today,
+        kind: "daily_report",
+        title: "Quiet — daily report test",
+        body: "Saw a source-backed event worth carrying forward.",
+        claims: [
+            {
+                id: "fact:daily-report-source",
+                text: "Source-backed event observed.",
+                claimType: "fact",
+                sourceRefs: [
+                    {
+                        id: "src-daily-report-source",
+                        kind: "platform_item",
+                        uri: "moltbook://daily-report-source",
+                    },
+                ],
+            },
+        ],
+        sourceRefs: [
+            {
+                id: "src-daily-report-source",
+                kind: "platform_item",
+                uri: "moltbook://daily-report-source",
+            },
+        ],
+    };
+    const ack = writeQuietArtifact(input);
+    await persistQuietArtifactToWorkspace(ws, ack, input);
+    // After: loadDailyReport should include the artifact as a sourceRef.
+    const after = await readModels.loadDailyReport(today);
+    assert.ok(after.sourceRefs.length > 0, `Expected loadDailyReport sourceRefs to be non-empty after artifact persisted; got ${after.sourceRefs.length}`);
+    stateDb.close();
+    observabilityDb.close();
+    fs.rmSync(ws, { recursive: true, force: true });
+});

package/dist/tests/integration/cli/t1-2-5-cycle-recent.test.d.ts

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