@haaaiawd/second-nature 0.1.18 → 0.1.20

package/runtime/cli/ops/ops-router.js

@@ -1,89 +1,188 @@
-/**
- * Shared ops command dispatch for CLI + tool surfaces (T1.1.3, T1.2.2).
- */
-import { heartbeatCheck } from "./heartbeat-surface.js";
-import { showOperatorFallback, OperatorFallbackNotFoundError } from "./show-operator-fallback.js";
-function coerceProbeOnlyFlag(input) {
-    const v = input?.probeOnly;
-    return v === true || v === "true" || v === 1 || v === "1";
-}
-export function createOpsRouter(deps) {
-    return {
-        heartbeatCheck: (input) => heartbeatCheck({
-            ...input,
-            runtimeAvailable: input.runtimeAvailable ?? deps.runtimeAvailable,
-            readModels: input.readModels ?? deps.readModels,
-            runtimeRecorder: input.runtimeRecorder ?? deps.runtimeRecorder,
-        }),
-        dispatch(command, input) {
-            if (command === "heartbeat_check") {
-                const runtimeAvailable = typeof input?.runtimeAvailable === "boolean" ? input.runtimeAvailable : deps.runtimeAvailable;
-                return heartbeatCheck({
-                    probeOnly: coerceProbeOnlyFlag(input),
-                    runtimeAvailable,
-                    fakeControlPlanePassthrough: input?.fakeControlPlanePassthrough && typeof input.fakeControlPlanePassthrough === "object"
-                        ? input.fakeControlPlanePassthrough
-                        : undefined,
-                    readModels: input?.readModels ?? deps.readModels,
-                    runtimeRecorder: input?.runtimeRecorder ?? deps.runtimeRecorder,
-                    timestamp: typeof input?.timestamp === "string" ? input.timestamp : undefined,
-                    sessionContext: typeof input?.sessionContext === "string" ? input.sessionContext : undefined,
-                    scopeHint: input?.scopeHint,
-                });
-            }
-            if (command === "fallback") {
-                const ref = typeof input?.ref === "string" ? input.ref.trim() : "";
-                if (!ref) {
-                    return {
-                        ok: false,
-                        error: {
-                            code: "MISSING_FALLBACK_REF",
-                            message: "fallback requires args.ref (e.g. fallback:…)",
-                            requiredUserInput: ["ref"],
-                            nextStep: "reinvoke_with_ref",
-                        },
-                    };
-                }
-                if (!deps.readModels?.loadFallbackView) {
-                    return {
-                        ok: false,
-                        error: {
-                            code: "FALLBACK_READ_MODEL_UNAVAILABLE",
-                            message: "Operator fallback view requires workspace read models",
-                            requiredUserInput: ["ref"],
-                            nextStep: "wire_read_models_into_ops_router",
-                        },
-                    };
-                }
-                return (async () => {
-                    try {
-                        const data = await showOperatorFallback(ref, deps.readModels);
-                        return { ok: true, command: "fallback", data };
-                    }
-                    catch (error) {
-                        if (error instanceof OperatorFallbackNotFoundError) {
-                            return {
-                                ok: false,
-                                command: "fallback",
-                                error: {
-                                    code: error.code,
-                                    message: error.message,
-                                    requiredUserInput: ["ref"],
-                                    nextStep: "verify_fallback_ref_from_delivery_audit",
-                                },
-                            };
-                        }
-                        throw error;
-                    }
-                })();
-            }
-            return {
-                ok: false,
-                error: {
-                    code: "unknown_ops_command",
-                    message: `Unknown ops command: ${command}`,
-                },
-            };
-        },
-    };
-}
+/**
+ * Shared ops command dispatch for CLI + tool surfaces (T1.1.3, T1.2.2).
+ */
+import { heartbeatCheck, } from "./heartbeat-surface.js";
+import { showOperatorFallback, OperatorFallbackNotFoundError, } from "./show-operator-fallback.js";
+import { probeHostCapability } from "../host-capability/probe-host-capability.js";
+import { recordHostCapability } from "../host-capability/record-host-capability.js";
+import { runNearRealConnectorSmoke } from "../../connectors/near-real/near-real-connector-smoke.js";
+function coerceProbeOnlyFlag(input) {
+    const v = input?.probeOnly;
+    return v === true || v === "true" || v === 1 || v === "1";
+}
+/**
+ * T1.2.8 — static local adapter: all checks return `unknown` when no real host is available.
+ * Allows `capability_probe` to be called from CLI / workspace bridge without requiring a live host.
+ */
+function createStaticUnknownAdapter() {
+    const now = new Date().toISOString();
+    const unknownResult = (name) => ({
+        name,
+        verdict: "unknown",
+        observedAt: now,
+        reason: "static_local_probe_no_host_context",
+        evidenceRefs: [],
+    });
+    return {
+        checkPluginLoad: () => unknownResult("plugin_load"),
+        checkHeartbeatBridge: () => unknownResult("heartbeat_bridge"),
+        checkHeartbeatToolInvocation: () => unknownResult("heartbeat_tool_invocation"),
+        checkDeliveryTarget: () => ({ status: "unknown", evidenceRefs: [] }),
+        checkAckDropBehavior: () => unknownResult("ack_drop"),
+        checkHookSupport: () => [],
+    };
+}
+export function createOpsRouter(deps) {
+    return {
+        heartbeatCheck: (input) => heartbeatCheck({
+            ...input,
+            runtimeAvailable: input.runtimeAvailable ?? deps.runtimeAvailable,
+            readModels: input.readModels ?? deps.readModels,
+            runtimeRecorder: input.runtimeRecorder ?? deps.runtimeRecorder,
+            state: input.state ?? deps.state,
+            workspaceRoot: input.workspaceRoot ?? deps.workspaceRoot,
+        }),
+        dispatch(command, input) {
+            if (command === "heartbeat_check") {
+                const runtimeAvailable = typeof input?.runtimeAvailable === "boolean"
+                    ? input.runtimeAvailable
+                    : deps.runtimeAvailable;
+                return heartbeatCheck({
+                    probeOnly: coerceProbeOnlyFlag(input),
+                    runtimeAvailable,
+                    fakeControlPlanePassthrough: input?.fakeControlPlanePassthrough &&
+                        typeof input.fakeControlPlanePassthrough === "object"
+                        ? input.fakeControlPlanePassthrough
+                        : undefined,
+                    readModels: input?.readModels ??
+                        deps.readModels,
+                    runtimeRecorder: input
+                        ?.runtimeRecorder ?? deps.runtimeRecorder,
+                    state: input?.state ??
+                        deps.state,
+                    workspaceRoot: input
+                        ?.workspaceRoot ?? deps.workspaceRoot,
+                    timestamp: typeof input?.timestamp === "string" ? input.timestamp : undefined,
+                    sessionContext: typeof input?.sessionContext === "string"
+                        ? input.sessionContext
+                        : undefined,
+                    scopeHint: input?.scopeHint,
+                });
+            }
+            if (command === "fallback") {
+                const ref = typeof input?.ref === "string" ? input.ref.trim() : "";
+                if (!ref) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "MISSING_FALLBACK_REF",
+                            message: "fallback requires args.ref (e.g. fallback:…)",
+                            requiredUserInput: ["ref"],
+                            nextStep: "reinvoke_with_ref",
+                        },
+                    };
+                }
+                if (!deps.readModels?.loadFallbackView) {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "FALLBACK_READ_MODEL_UNAVAILABLE",
+                            message: "Operator fallback view requires workspace read models",
+                            requiredUserInput: ["ref"],
+                            nextStep: "wire_read_models_into_ops_router",
+                        },
+                    };
+                }
+                return (async () => {
+                    try {
+                        const data = await showOperatorFallback(ref, deps.readModels);
+                        return { ok: true, command: "fallback", data };
+                    }
+                    catch (error) {
+                        if (error instanceof OperatorFallbackNotFoundError) {
+                            return {
+                                ok: false,
+                                command: "fallback",
+                                error: {
+                                    code: error.code,
+                                    message: error.message,
+                                    requiredUserInput: ["ref"],
+                                    nextStep: "verify_fallback_ref_from_delivery_audit",
+                                },
+                            };
+                        }
+                        throw error;
+                    }
+                })();
+            }
+            if (command === "capability_probe") {
+                // T1.2.8 (SN-CODE-03): run host capability probe with static unknown adapter (CLI context).
+                // Persists report when observabilityDb is available; returns safe JSON subset.
+                return (async () => {
+                    const adapter = createStaticUnknownAdapter();
+                    const docCheckedAt = new Date().toISOString();
+                    const report = probeHostCapability({
+                        adapter,
+                        docLinks: [],
+                        docCheckedAt,
+                    });
+                    if (deps.observabilityDb) {
+                        await recordHostCapability(deps.observabilityDb, report);
+                    }
+                    return {
+                        ok: true,
+                        command: "capability_probe",
+                        data: {
+                            reportId: report.reportId,
+                            generatedAt: report.generatedAt,
+                            deliveryTarget: report.deliveryTarget,
+                            pluginLoad: { verdict: report.pluginLoad.verdict },
+                            heartbeatBridge: { verdict: report.heartbeatBridge.verdict },
+                            heartbeatToolInvocation: {
+                                verdict: report.heartbeatToolInvocation.verdict,
+                            },
+                            ackDropBehavior: { verdict: report.ackDropBehavior.verdict },
+                            conflictCount: report.conflictRecords.length,
+                            recommendedNextStep: report.recommendedNextStep,
+                            note: "static_local_probe: all verdicts are unknown without live host context",
+                        },
+                    };
+                })();
+            }
+            if (command === "near_real_smoke") {
+                // T3.3.2 (SN-CODE-05): wrap runNearRealConnectorSmoke as an ops surface command.
+                // Requires state + observabilityDb + workspaceRoot to be wired into OpsRouterDeps.
+                if (!deps.state || !deps.observabilityDb || !deps.workspaceRoot) {
+                    return {
+                        ok: false,
+                        command: "near_real_smoke",
+                        error: {
+                            code: "NEAR_REAL_SMOKE_DEPS_UNAVAILABLE",
+                            message: "near_real_smoke requires state, observabilityDb, and workspaceRoot in OpsRouterDeps",
+                            nextStep: "wire_deps_into_ops_router",
+                        },
+                    };
+                }
+                return (async () => {
+                    const result = await runNearRealConnectorSmoke({
+                        state: deps.state,
+                        observabilityDb: deps.observabilityDb,
+                        workspaceRoot: deps.workspaceRoot,
+                    });
+                    return {
+                        ok: true,
+                        command: "near_real_smoke",
+                        data: result,
+                    };
+                })();
+            }
+            return {
+                ok: false,
+                error: {
+                    code: "unknown_ops_command",
+                    message: `Unknown ops command: ${command}`,
+                },
+            };
+        },
+    };
+}

package/runtime/cli/ops/show-operator-fallback.d.ts

@@ -1,13 +1,13 @@
-import type { OperatorFallbackView } from "../../storage/fallback/operator-fallback-view.js";
-export declare class OperatorFallbackNotFoundError extends Error {
-    readonly ref: string;
-    readonly code: "FALLBACK_NOT_FOUND";
-    constructor(ref: string);
-}
-export interface ShowOperatorFallbackReadModels {
-    loadFallbackView(ref: string): Promise<OperatorFallbackView | null>;
-}
-/**
- * T1.2.2 — Operator-visible fallback: always `status: not_sent` (ADR-007), never sent/delivered.
- */
-export declare function showOperatorFallback(ref: string, readModels: ShowOperatorFallbackReadModels): Promise<OperatorFallbackView>;
+import type { OperatorFallbackView } from "../../storage/fallback/operator-fallback-view.js";
+export declare class OperatorFallbackNotFoundError extends Error {
+    readonly ref: string;
+    readonly code: "FALLBACK_NOT_FOUND";
+    constructor(ref: string);
+}
+export interface ShowOperatorFallbackReadModels {
+    loadFallbackView(ref: string): Promise<OperatorFallbackView | null>;
+}
+/**
+ * T1.2.2 — Operator-visible fallback: always `status: not_sent` (ADR-007), never sent/delivered.
+ */
+export declare function showOperatorFallback(ref: string, readModels: ShowOperatorFallbackReadModels): Promise<OperatorFallbackView>;

package/runtime/cli/ops/show-operator-fallback.js

@@ -1,22 +1,22 @@
-export class OperatorFallbackNotFoundError extends Error {
-    ref;
-    code = "FALLBACK_NOT_FOUND";
-    constructor(ref) {
-        super(`No operator fallback artifact for ref: ${ref}`);
-        this.ref = ref;
-        this.name = "OperatorFallbackNotFoundError";
-    }
-}
-/**
- * T1.2.2 — Operator-visible fallback: always `status: not_sent` (ADR-007), never sent/delivered.
- */
-export async function showOperatorFallback(ref, readModels) {
-    const view = await readModels.loadFallbackView(ref);
-    if (!view) {
-        throw new OperatorFallbackNotFoundError(ref.trim());
-    }
-    return {
-        ...view,
-        status: "not_sent",
-    };
-}
+export class OperatorFallbackNotFoundError extends Error {
+    ref;
+    code = "FALLBACK_NOT_FOUND";
+    constructor(ref) {
+        super(`No operator fallback artifact for ref: ${ref}`);
+        this.ref = ref;
+        this.name = "OperatorFallbackNotFoundError";
+    }
+}
+/**
+ * T1.2.2 — Operator-visible fallback: always `status: not_sent` (ADR-007), never sent/delivered.
+ */
+export async function showOperatorFallback(ref, readModels) {
+    const view = await readModels.loadFallbackView(ref);
+    if (!view) {
+        throw new OperatorFallbackNotFoundError(ref.trim());
+    }
+    return {
+        ...view,
+        status: "not_sent",
+    };
+}

package/runtime/cli/ops/workspace-heartbeat-runner.d.ts

@@ -1,19 +1,40 @@
-/**
- * Wires CLI read models into control-plane `runHeartbeatCycle` for `heartbeat_check` (US-001 / CH-09-02 / T1.2.3).
- *
- * Snapshot inputs are derived from aggregated status; delivery defaults to none until host capability is modeled here.
- *
- * T1.2.3: when a `RuntimeDecisionRecorder` is provided, persist a `sn-runtime-*` ledger row +
- * `second-nature-runtime` execution attempt after each cycle so `loadStatus` exits its `unknown`
- * baseline once the runtime has actually executed at least one full-runtime turn.
- */
-import type { HeartbeatSignal, HeartbeatCycleResult } from "../../core/second-nature/heartbeat/signal.js";
-import type { SnapshotInputs } from "../../core/second-nature/heartbeat/snapshot-builder.js";
-import type { CliReadModels } from "../read-models/index.js";
-import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
-export interface WorkspaceHeartbeatRunnerOptions {
-    /** When supplied, the runner persists the cycle so `loadStatus` can read it (T1.2.3). */
-    runtimeRecorder?: RuntimeDecisionRecorder;
-}
-export declare function loadSnapshotInputsForWorkspaceHeartbeat(readModels: CliReadModels): Promise<SnapshotInputs>;
-export declare function createWorkspaceHeartbeatRunner(readModels: CliReadModels, options?: WorkspaceHeartbeatRunnerOptions): (signal: HeartbeatSignal) => Promise<HeartbeatCycleResult>;
+/**
+ * Wires CLI read models into control-plane `runHeartbeatCycle` for `heartbeat_check` (US-001 / CH-09-02 / T1.2.3).
+ *
+ * Snapshot inputs are derived from aggregated status; delivery defaults to none until host capability is modeled here.
+ *
+ * T1.2.3: when a `RuntimeDecisionRecorder` is provided, persist a `sn-runtime-*` ledger row +
+ * `second-nature-runtime` execution attempt after each cycle so `loadStatus` exits its `unknown`
+ * baseline once the runtime has actually executed at least one full-runtime turn.
+ *
+ * T2.2.2: when `state` + `workspaceRoot` are supplied, call `loadLifeEvidenceSnapshot` to fill
+ * `lifeEvidenceRefs`, `platformEventCount`, `workEventCount`, and `lifeEvidenceEmptyReason` on
+ * `SnapshotInputs` so planner/guard paths that require source refs see real DB truth.
+ * Falls back gracefully to `lifeEvidenceEmptyReason: "state_unavailable"` when state is absent.
+ */
+import type { HeartbeatSignal, HeartbeatCycleResult } from "../../core/second-nature/heartbeat/signal.js";
+import type { SnapshotInputs } from "../../core/second-nature/heartbeat/snapshot-builder.js";
+import type { CliReadModels } from "../read-models/index.js";
+import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
+import type { StateDatabase } from "../../storage/db/index.js";
+export interface WorkspaceHeartbeatRunnerOptions {
+    /** When supplied, the runner persists the cycle so `loadStatus` can read it (T1.2.3). */
+    runtimeRecorder?: RuntimeDecisionRecorder;
+    /**
+     * T2.2.2: when state + workspaceRoot are provided, life evidence is loaded from DB and merged
+     * into SnapshotInputs so planner/guard paths have real source-ref truth.
+     */
+    state?: StateDatabase;
+    workspaceRoot?: string;
+    /**
+     * T1.2.4: when true (and workspaceRoot is set), inject a `quietWorkflow` dep into the heartbeat
+     * cycle so quiet/reflection intents can call `runSourceBackedQuiet` and write artifacts to disk.
+     * Defaults to true when workspaceRoot is provided, since this is the host-safe workspace path.
+     */
+    enableQuietWorkflow?: boolean;
+}
+export declare function loadSnapshotInputsForWorkspaceHeartbeat(readModels: CliReadModels, options?: {
+    state?: StateDatabase;
+    workspaceRoot?: string;
+}): Promise<SnapshotInputs>;
+export declare function createWorkspaceHeartbeatRunner(readModels: CliReadModels, options?: WorkspaceHeartbeatRunnerOptions): (signal: HeartbeatSignal) => Promise<HeartbeatCycleResult>;

package/runtime/cli/ops/workspace-heartbeat-runner.js

@@ -1,39 +1,93 @@
-import { runHeartbeatCycle } from "../../core/second-nature/heartbeat/run-heartbeat-cycle.js";
-export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels) {
-    const status = await readModels.loadStatus();
-    const mode = status.rhythm.mode === "unknown" ? "active" : status.rhythm.mode;
-    const quietEnabledBridge = status.quiet.mode === "quiet";
-    return {
-        mode,
-        currentWindowId: status.rhythm.windowId ?? "workspace-default",
-        pendingObligations: [],
-        recentOutreachHashes: [],
-        deniedIntents: [],
-        budgets: { socialUsed: 0, socialLimit: 5 },
-        awaitingUserInput: false,
-        quietEnabledBridge,
-        deliveryCapability: { target: "none" },
-    };
-}
-export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
-    return async (signal) => {
-        const cycle = await runHeartbeatCycle({
-            signal,
-            runtimeAvailable: true,
-            deps: {
-                loadSnapshotInputs: () => loadSnapshotInputsForWorkspaceHeartbeat(readModels),
-            },
-        });
-        if (options.runtimeRecorder) {
-            try {
-                await options.runtimeRecorder.recordHeartbeatCycle({ cycle, signal });
-            }
-            catch {
-                // T1.2.3: recorder must never break the heartbeat surface response.
-                // Failure here means status simply remains at its previous aggregate; the
-                // cycle outcome itself is still returned to the caller.
-            }
-        }
-        return cycle;
-    };
-}
+import { runHeartbeatCycle } from "../../core/second-nature/heartbeat/run-heartbeat-cycle.js";
+import { loadLifeEvidenceSnapshot } from "../../storage/snapshots/life-evidence-snapshot.js";
+export async function loadSnapshotInputsForWorkspaceHeartbeat(readModels, options = {}) {
+    const status = await readModels.loadStatus();
+    const mode = status.rhythm.mode === "unknown" ? "active" : status.rhythm.mode;
+    // CH-15-03: quietEnabledBridge should reflect whether the quiet *execution path* is wired
+    // (workspaceRoot available), not whether the last observed rhythm decision was "quiet".
+    // status.quiet.mode is typically "unknown" until a Quiet artifact has been persisted, which
+    // means binding to it would permanently suppress the quiet window — the opposite of intent.
+    // We instead enable the bridge whenever workspaceRoot is provided (same condition as
+    // `createWorkspaceHeartbeatRunner` uses for injecting quietWorkflow).
+    const quietEnabledBridge = !!options.workspaceRoot;
+    // T2.2.2: Load life evidence from state DB when available so SnapshotInputs carries real refs.
+    let lifeEvidenceRefs;
+    let platformEventCount;
+    let workEventCount;
+    let lifeEvidenceEmptyReason;
+    if (options.state && options.workspaceRoot) {
+        try {
+            const snapshot = await loadLifeEvidenceSnapshot(options.state, options.workspaceRoot, { limit: 50 }, 
+            // Skip repair gate here — runner is called inside a live cycle; gate ran at startup.
+            { runRepairGate: false });
+            lifeEvidenceRefs = snapshot.evidenceRefs.map((ref) => ({
+                id: ref.id,
+                kind: ref.kind,
+                uri: ref.uri,
+            }));
+            platformEventCount = snapshot.platformEvents.length;
+            workEventCount = snapshot.workEvents.length;
+            if (snapshot.empty) {
+                lifeEvidenceEmptyReason = "no_sources";
+            }
+        }
+        catch {
+            // If evidence load fails, signal state_unavailable rather than crashing the cycle.
+            lifeEvidenceRefs = [];
+            platformEventCount = 0;
+            workEventCount = 0;
+            lifeEvidenceEmptyReason = "state_unavailable";
+        }
+    }
+    else {
+        // No state wired — record that life evidence wasn't loaded so guards can reason honestly.
+        lifeEvidenceEmptyReason = "state_unavailable";
+    }
+    return {
+        mode,
+        currentWindowId: status.rhythm.windowId ?? "workspace-default",
+        pendingObligations: [],
+        recentOutreachHashes: [],
+        deniedIntents: [],
+        budgets: { socialUsed: 0, socialLimit: 5 },
+        awaitingUserInput: false,
+        quietEnabledBridge,
+        deliveryCapability: { target: "none" },
+        lifeEvidenceRefs,
+        platformEventCount,
+        workEventCount,
+        lifeEvidenceEmptyReason,
+    };
+}
+export function createWorkspaceHeartbeatRunner(readModels, options = {}) {
+    // T1.2.4: inject quietWorkflow dep when workspaceRoot is set so quiet/reflection intents
+    // can trigger runSourceBackedQuiet and persist artifacts to disk.
+    const quietEnabled = options.workspaceRoot && options.enableQuietWorkflow !== false;
+    return async (signal) => {
+        const cycle = await runHeartbeatCycle({
+            signal,
+            runtimeAvailable: true,
+            deps: {
+                loadSnapshotInputs: () => loadSnapshotInputsForWorkspaceHeartbeat(readModels, {
+                    state: options.state,
+                    workspaceRoot: options.workspaceRoot,
+                }),
+                // T1.2.4: pass quietWorkflow dep so runSourceBackedQuiet can persist artifacts.
+                quietWorkflow: quietEnabled
+                    ? { workspaceRoot: options.workspaceRoot }
+                    : undefined,
+            },
+        });
+        if (options.runtimeRecorder) {
+            try {
+                await options.runtimeRecorder.recordHeartbeatCycle({ cycle, signal });
+            }
+            catch {
+                // T1.2.3: recorder must never break the heartbeat surface response.
+                // Failure here means status simply remains at its previous aggregate; the
+                // cycle outcome itself is still returned to the caller.
+            }
+        }
+        return cycle;
+    };
+}

package/runtime/cli/read-models/index.d.ts

@@ -1,29 +1,46 @@
-import type { StateDatabase } from "../../storage/db/index.js";
-import type { ObservabilityDatabase } from "../../observability/db/index.js";
-import { AppendOnlyAuditStore } from "../../observability/audit/append-only-audit-store.js";
-import type { StatusReadModel, DailyReportReadModel, QuietReadModel, SessionDetailReadModel, CredentialReadModel, ExplainReadModel, ExplainSubjectKind } from "./types.js";
-export type { ExplainSubjectKind } from "./types.js";
-import type { OperatorFallbackView } from "../../storage/fallback/operator-fallback-view.js";
-export interface CliReadModels {
-    loadStatus(scope?: string): Promise<StatusReadModel>;
-    loadDailyReport(day: string): Promise<DailyReportReadModel>;
-    loadQuiet(scope?: string): Promise<QuietReadModel>;
-    loadSession(sessionId: string): Promise<SessionDetailReadModel>;
-    loadCredential(platformId: string): Promise<CredentialReadModel>;
-    explain(subject: ExplainSubject): Promise<ExplainReadModel>;
-    /** T1.2.2 — persisted operator fallback; view status is always not_sent. */
-    loadFallbackView(ref: string): Promise<OperatorFallbackView | null>;
-}
-/** T1.2.1 / T1.2.2 — operator-facing read surface (subset of full CLI read models). */
-export type OpsReadModelPort = Pick<CliReadModels, "loadStatus" | "loadDailyReport" | "loadQuiet" | "loadSession" | "loadCredential" | "explain" | "loadFallbackView">;
-export interface ExplainSubject {
-    kind: ExplainSubjectKind;
-    id: string;
-}
-export interface CliReadModelsDeps {
-    stateDb: StateDatabase;
-    observabilityDb: ObservabilityDatabase;
-    /** When set, explain can resolve delivery/fallback/report/source_ref and enrich decision subjects from lived-experience audit envelopes (T5.3.1 / T1.2.1). */
-    livedExperienceAuditStore?: AppendOnlyAuditStore;
-}
-export declare function createCliReadModels(deps: CliReadModelsDeps): CliReadModels;
+import type { StateDatabase } from "../../storage/db/index.js";
+import type { ObservabilityDatabase } from "../../observability/db/index.js";
+import { AppendOnlyAuditStore } from "../../observability/audit/append-only-audit-store.js";
+import type { StatusReadModel, DailyReportReadModel, QuietReadModel, SessionDetailReadModel, CredentialReadModel, ExplainReadModel, ExplainSubjectKind, AuditSummaryReadModel } from "./types.js";
+export type { AuditSummaryReadModel } from "./types.js";
+export type { ExplainSubjectKind } from "./types.js";
+import type { OperatorFallbackView } from "../../storage/fallback/operator-fallback-view.js";
+import { type RhythmPolicySnapshot } from "../../storage/rhythm/rhythm-policy-snapshot.js";
+export type { RhythmPolicySnapshot };
+export interface CliReadModels {
+    loadStatus(scope?: string): Promise<StatusReadModel>;
+    loadDailyReport(day: string): Promise<DailyReportReadModel>;
+    loadQuiet(scope?: string): Promise<QuietReadModel>;
+    loadSession(sessionId: string): Promise<SessionDetailReadModel>;
+    loadCredential(platformId: string): Promise<CredentialReadModel>;
+    explain(subject: ExplainSubject): Promise<ExplainReadModel>;
+    /** T1.2.2 — persisted operator fallback; view status is always not_sent. */
+    loadFallbackView(ref: string): Promise<OperatorFallbackView | null>;
+    /** T1.2.6 — rhythm policy snapshot for operator `policy show`. */
+    loadPolicy(): Promise<RhythmPolicySnapshot>;
+    /**
+     * T1.2.7 (SN-CODE-02) — minimal audit read-side view for operator `audit` command.
+     * Returns a summary of all in-memory audit events in the default store.
+     * Empty store returns `{ totalEvents: 0, events: [] }` (honest empty, not an error).
+     */
+    loadAuditSummary(): Promise<AuditSummaryReadModel>;
+}
+/** T1.2.1 / T1.2.2 — operator-facing read surface (subset of full CLI read models). */
+export type OpsReadModelPort = Pick<CliReadModels, "loadStatus" | "loadDailyReport" | "loadQuiet" | "loadSession" | "loadCredential" | "explain" | "loadFallbackView">;
+export interface ExplainSubject {
+    kind: ExplainSubjectKind;
+    id: string;
+}
+export interface CliReadModelsDeps {
+    stateDb: StateDatabase;
+    observabilityDb: ObservabilityDatabase;
+    /** When set, explain can resolve delivery/fallback/report/source_ref and enrich decision subjects from lived-experience audit envelopes (T5.3.1 / T1.2.1). */
+    livedExperienceAuditStore?: AppendOnlyAuditStore;
+    /**
+     * T1.2.4: when set, `loadQuiet` and `loadDailyReport` also scan `.second-nature/quiet/{day}/`
+     * for persisted Quiet artifact JSON files (from `persistQuietArtifactToWorkspace`) and merge
+     * them into the read model so operators see non-zero counts after Quiet actually runs.
+     */
+    workspaceRoot?: string;
+}
+export declare function createCliReadModels(deps: CliReadModelsDeps): CliReadModels;