@haaaiawd/second-nature 0.1.18 → 0.1.20

package/runtime/cli/host-smoke/types.d.ts

@@ -1,35 +1,35 @@
-/**
- * Host smoke plan + report types (T1.3.1).
- *
- * `heartbeat_tool_invocation` verifies that a near-real transcript actually invoked heartbeat_check.
- */
-export interface HeartbeatToolInvocationCase {
-    readonly type: "heartbeat_tool_invocation";
-    /** Tool names, ops strings, or host transcript fragments observed during the smoke turn */
-    toolInvocations: string[];
-}
-export interface DocsVsObservedConflictCase {
-    readonly type: "docs_vs_observed_conflict";
-    docExpectation: string;
-    observedBehavior: string;
-}
-export type HostSmokeCase = HeartbeatToolInvocationCase | DocsVsObservedConflictCase;
-export interface HostSmokePlan {
-    cases: HostSmokeCase[];
-    docLinks?: string[];
-    docCheckedAt?: string;
-    hostVersion?: string;
-}
-export interface HostSmokeCaseResult {
-    caseType: HostSmokeCase["type"];
-    status: "pass" | "fail" | "unknown";
-    reasons: string[];
-}
-export interface HostSmokeReport {
-    reportId: string;
-    generatedAt: string;
-    results: HostSmokeCaseResult[];
-    docLinks?: string[];
-    docCheckedAt?: string;
-    hostVersion?: string;
-}
+/**
+ * Host smoke plan + report types (T1.3.1).
+ *
+ * `heartbeat_tool_invocation` verifies that a near-real transcript actually invoked heartbeat_check.
+ */
+export interface HeartbeatToolInvocationCase {
+    readonly type: "heartbeat_tool_invocation";
+    /** Tool names, ops strings, or host transcript fragments observed during the smoke turn */
+    toolInvocations: string[];
+}
+export interface DocsVsObservedConflictCase {
+    readonly type: "docs_vs_observed_conflict";
+    docExpectation: string;
+    observedBehavior: string;
+}
+export type HostSmokeCase = HeartbeatToolInvocationCase | DocsVsObservedConflictCase;
+export interface HostSmokePlan {
+    cases: HostSmokeCase[];
+    docLinks?: string[];
+    docCheckedAt?: string;
+    hostVersion?: string;
+}
+export interface HostSmokeCaseResult {
+    caseType: HostSmokeCase["type"];
+    status: "pass" | "fail" | "unknown";
+    reasons: string[];
+}
+export interface HostSmokeReport {
+    reportId: string;
+    generatedAt: string;
+    results: HostSmokeCaseResult[];
+    docLinks?: string[];
+    docCheckedAt?: string;
+    hostVersion?: string;
+}

package/runtime/cli/host-smoke/types.js

@@ -1,6 +1,6 @@
-/**
- * Host smoke plan + report types (T1.3.1).
- *
- * `heartbeat_tool_invocation` verifies that a near-real transcript actually invoked heartbeat_check.
- */
-export {};
+/**
+ * Host smoke plan + report types (T1.3.1).
+ *
+ * `heartbeat_tool_invocation` verifies that a near-real transcript actually invoked heartbeat_check.
+ */
+export {};

package/runtime/cli/index.js

@@ -1,58 +1,67 @@
-import { createObservabilityDatabase } from "../observability/db/index.js";
-import { createStateAPI, createStateDatabase } from "../storage/index.js";
-import path from "node:path";
-import { createActionBridge } from "./action-bridge.js";
-import { createCliCommands } from "./commands/index.js";
-import { createOpsRouter } from "./ops/ops-router.js";
-import { createCliReadModels } from "./read-models/index.js";
-import { resolvePackagedRuntime } from "./runtime/runtime-artifact-boundary.js";
-import { createRuntimeDecisionRecorder, } from "../observability/services/runtime-decision-recorder.js";
-export function createCliRuntimeDeps(overrides = {}) {
-    const stateDb = overrides.stateDb ?? createStateDatabase();
-    const observabilityDb = overrides.observabilityDb ?? createObservabilityDatabase();
-    const stateApi = overrides.stateApi ?? createStateAPI(stateDb);
-    const readModels = overrides.readModels ?? createCliReadModels({ stateDb, observabilityDb });
-    const actionBridge = overrides.actionBridge ?? createActionBridge(stateApi);
-    const runtimeRecorder = overrides.runtimeRecorder ?? createRuntimeDecisionRecorder(observabilityDb);
-    return {
-        stateDb,
-        observabilityDb,
-        stateApi,
-        readModels,
-        actionBridge,
-        runtimeRecorder,
-    };
-}
-export function createCommandRouter(options = {}) {
-    const runtime = createCliRuntimeDeps(options.deps);
-    const pluginRoot = path.join(process.cwd(), "plugin");
-    const opsRouter = createOpsRouter({
-        runtimeAvailable: resolvePackagedRuntime(pluginRoot).ok,
-        readModels: runtime.readModels,
-        runtimeRecorder: runtime.runtimeRecorder,
-    });
-    const commands = createCliCommands({
-        readModels: runtime.readModels,
-        actionBridge: runtime.actionBridge,
-        opsRouter,
-    });
-    return {
-        commands,
-        resolve(name) {
-            return commands.find((command) => command.name === name);
-        },
-    };
-}
-export function closeCliRuntimeDeps(deps) {
-    deps.stateDb.close();
-    deps.observabilityDb.close();
-}
-export { createOpsRouter } from "./ops/ops-router.js";
-export { heartbeatCheck, } from "./ops/heartbeat-surface.js";
-export * from "./host-capability/types.js";
-export { classifyDeliveryCapability } from "./host-capability/classify-delivery.js";
-export { probeHostCapability } from "./host-capability/probe-host-capability.js";
-export { recordHostCapability } from "./host-capability/record-host-capability.js";
-export { runHostSmoke } from "./host-smoke/run-host-smoke.js";
-export { explainSurfaceSubject } from "./explain/explain-surface-subject.js";
-export { showOperatorFallback, OperatorFallbackNotFoundError } from "./ops/show-operator-fallback.js";
+import { createObservabilityDatabase, } from "../observability/db/index.js";
+import { createStateAPI, createStateDatabase, } from "../storage/index.js";
+import path from "node:path";
+import { createActionBridge } from "./action-bridge.js";
+import { createCliCommands, } from "./commands/index.js";
+import { createOpsRouter } from "./ops/ops-router.js";
+import { createCliReadModels, } from "./read-models/index.js";
+import { resolvePackagedRuntime } from "./runtime/runtime-artifact-boundary.js";
+import { createRuntimeDecisionRecorder, } from "../observability/services/runtime-decision-recorder.js";
+export function createCliRuntimeDeps(overrides = {}) {
+    const stateDb = overrides.stateDb ?? createStateDatabase();
+    const observabilityDb = overrides.observabilityDb ?? createObservabilityDatabase();
+    const stateApi = overrides.stateApi ?? createStateAPI(stateDb);
+    const readModels = overrides.readModels ??
+        createCliReadModels({
+            stateDb,
+            observabilityDb,
+            workspaceRoot: process.cwd(),
+            livedExperienceAuditStore: overrides.livedExperienceAuditStore,
+        });
+    const actionBridge = overrides.actionBridge ?? createActionBridge(stateApi);
+    const runtimeRecorder = overrides.runtimeRecorder ?? createRuntimeDecisionRecorder(observabilityDb);
+    return {
+        stateDb,
+        observabilityDb,
+        stateApi,
+        readModels,
+        actionBridge,
+        runtimeRecorder,
+    };
+}
+export function createCommandRouter(options = {}) {
+    const runtime = createCliRuntimeDeps(options.deps);
+    const pluginRoot = path.join(process.cwd(), "plugin");
+    const opsRouter = createOpsRouter({
+        runtimeAvailable: resolvePackagedRuntime(pluginRoot).ok,
+        readModels: runtime.readModels,
+        runtimeRecorder: runtime.runtimeRecorder,
+        state: runtime.stateDb,
+        workspaceRoot: process.cwd(),
+        observabilityDb: runtime.observabilityDb,
+    });
+    const commands = createCliCommands({
+        readModels: runtime.readModels,
+        actionBridge: runtime.actionBridge,
+        opsRouter,
+    });
+    return {
+        commands,
+        resolve(name) {
+            return commands.find((command) => command.name === name);
+        },
+    };
+}
+export function closeCliRuntimeDeps(deps) {
+    deps.stateDb.close();
+    deps.observabilityDb.close();
+}
+export { createOpsRouter, } from "./ops/ops-router.js";
+export { heartbeatCheck, } from "./ops/heartbeat-surface.js";
+export * from "./host-capability/types.js";
+export { classifyDeliveryCapability, } from "./host-capability/classify-delivery.js";
+export { probeHostCapability } from "./host-capability/probe-host-capability.js";
+export { recordHostCapability } from "./host-capability/record-host-capability.js";
+export { runHostSmoke } from "./host-smoke/run-host-smoke.js";
+export { explainSurfaceSubject } from "./explain/explain-surface-subject.js";
+export { showOperatorFallback, OperatorFallbackNotFoundError, } from "./ops/show-operator-fallback.js";

package/runtime/cli/ops/heartbeat-surface.d.ts

@@ -1,38 +1,45 @@
-/**
- * Stable HeartbeatSurfaceResult for second_nature_ops / CLI (T1.1.3, cli-system / ADR-005).
- *
- * S1 scope: carrier / probe / runtime-unavailable / fake control-plane passthrough only.
- * Workspace full runtime: delegates to `runHeartbeatCycle` when read models are wired (US-001 / CH-09-02).
- */
-import type { SurfaceMode } from "../runtime/runtime-artifact-boundary.js";
-import type { HeartbeatSignal } from "../../core/second-nature/heartbeat/signal.js";
-import type { CliReadModels } from "../read-models/index.js";
-import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
-export type HeartbeatSurfaceStatus = "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
-export interface HeartbeatSurfaceResult {
-    ok: boolean;
-    status: HeartbeatSurfaceStatus;
-    surfaceMode: SurfaceMode;
-    decisionId?: string;
-    deliveryAttemptId?: string;
-    capabilityReportRef?: string;
-    fallbackRef?: string;
-    reasons: string[];
-    /** When false, callers must not treat the round as lived-experience loop completion */
-    livedExperienceLoopClaimed: boolean;
-    /** True when structured fields mirror a fake adapter for schema parity only */
-    schemaParityOnly?: boolean;
-}
-export interface HeartbeatCheckInput {
-    probeOnly?: boolean;
-    runtimeAvailable: boolean;
-    fakeControlPlanePassthrough?: Record<string, unknown>;
-    /** When set, full-runtime heartbeat_check runs the control-plane decision loop (US-001). */
-    readModels?: CliReadModels;
-    /** When set, full-runtime cycles are persisted so `loadStatus` exits unknown (T1.2.3). */
-    runtimeRecorder?: RuntimeDecisionRecorder;
-    timestamp?: string;
-    sessionContext?: string;
-    scopeHint?: HeartbeatSignal["scopeHint"];
-}
-export declare function heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;
+/**
+ * Stable HeartbeatSurfaceResult for second_nature_ops / CLI (T1.1.3, cli-system / ADR-005).
+ *
+ * S1 scope: carrier / probe / runtime-unavailable / fake control-plane passthrough only.
+ * Workspace full runtime: delegates to `runHeartbeatCycle` when read models are wired (US-001 / CH-09-02).
+ */
+import type { SurfaceMode } from "../runtime/runtime-artifact-boundary.js";
+import type { HeartbeatSignal } from "../../core/second-nature/heartbeat/signal.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 type HeartbeatSurfaceStatus = "heartbeat_ok" | "intent_selected" | "denied" | "deferred" | "runtime_carrier_only" | "delivery_unavailable";
+export interface HeartbeatSurfaceResult {
+    ok: boolean;
+    status: HeartbeatSurfaceStatus;
+    surfaceMode: SurfaceMode;
+    decisionId?: string;
+    deliveryAttemptId?: string;
+    capabilityReportRef?: string;
+    fallbackRef?: string;
+    reasons: string[];
+    /** When false, callers must not treat the round as lived-experience loop completion */
+    livedExperienceLoopClaimed: boolean;
+    /** True when structured fields mirror a fake adapter for schema parity only */
+    schemaParityOnly?: boolean;
+}
+export interface HeartbeatCheckInput {
+    probeOnly?: boolean;
+    runtimeAvailable: boolean;
+    fakeControlPlanePassthrough?: Record<string, unknown>;
+    /** When set, full-runtime heartbeat_check runs the control-plane decision loop (US-001). */
+    readModels?: CliReadModels;
+    /** When set, full-runtime cycles are persisted so `loadStatus` exits unknown (T1.2.3). */
+    runtimeRecorder?: RuntimeDecisionRecorder;
+    /**
+     * T2.2.2: when set together with `workspaceRoot`, life evidence from the state DB is loaded
+     * and merged into SnapshotInputs so planner/guard paths see real source-ref truth.
+     */
+    state?: StateDatabase;
+    workspaceRoot?: string;
+    timestamp?: string;
+    sessionContext?: string;
+    scopeHint?: HeartbeatSignal["scopeHint"];
+}
+export declare function heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;

package/runtime/cli/ops/heartbeat-surface.js

@@ -1,73 +1,79 @@
-import { createWorkspaceHeartbeatRunner } from "./workspace-heartbeat-runner.js";
-function mapCycleToSurface(cycle, surfaceMode) {
-    const status = cycle.status === "runtime_carrier_only" ? "runtime_carrier_only" : cycle.status;
-    return {
-        ok: true,
-        status,
-        surfaceMode,
-        decisionId: cycle.decisionId,
-        deliveryAttemptId: cycle.deliveryAttemptId,
-        fallbackRef: cycle.fallbackRef,
-        reasons: cycle.reasons,
-        livedExperienceLoopClaimed: false,
-    };
-}
-export async function heartbeatCheck(input) {
-    if (!input.runtimeAvailable) {
-        return {
-            ok: true,
-            status: "runtime_carrier_only",
-            surfaceMode: "host_safe_carrier",
-            reasons: ["runtime_unavailable_packaged_carrier"],
-            livedExperienceLoopClaimed: false,
-        };
-    }
-    if (input.probeOnly) {
-        return {
-            ok: true,
-            status: "heartbeat_ok",
-            surfaceMode: "capability_probe",
-            reasons: ["probe_only"],
-            livedExperienceLoopClaimed: false,
-        };
-    }
-    if (input.fakeControlPlanePassthrough) {
-        const decisionId = typeof input.fakeControlPlanePassthrough.decisionId === "string"
-            ? input.fakeControlPlanePassthrough.decisionId
-            : undefined;
-        return {
-            ok: true,
-            status: "intent_selected",
-            surfaceMode: "host_safe_carrier",
-            reasons: ["fake_control_plane_passthrough"],
-            decisionId,
-            livedExperienceLoopClaimed: false,
-            schemaParityOnly: true,
-        };
-    }
-    if (!input.readModels) {
-        return {
-            ok: true,
-            status: "runtime_carrier_only",
-            surfaceMode: "host_safe_carrier",
-            reasons: ["heartbeat_read_models_unavailable"],
-            livedExperienceLoopClaimed: false,
-        };
-    }
-    const timestamp = typeof input.timestamp === "string" && input.timestamp.trim().length > 0
-        ? input.timestamp.trim()
-        : new Date().toISOString();
-    const signal = {
-        trigger: "heartbeat_bridge",
-        scopeHint: input.scopeHint,
-        payload: {
-            timestamp,
-            sessionContext: typeof input.sessionContext === "string" ? input.sessionContext : undefined,
-        },
-    };
-    const run = createWorkspaceHeartbeatRunner(input.readModels, {
-        runtimeRecorder: input.runtimeRecorder,
-    });
-    const cycle = await run(signal);
-    return mapCycleToSurface(cycle, "workspace_full_runtime");
-}
+import { createWorkspaceHeartbeatRunner } from "./workspace-heartbeat-runner.js";
+function mapCycleToSurface(cycle, surfaceMode) {
+    const status = cycle.status === "runtime_carrier_only"
+        ? "runtime_carrier_only"
+        : cycle.status;
+    return {
+        ok: true,
+        status,
+        surfaceMode,
+        decisionId: cycle.decisionId,
+        deliveryAttemptId: cycle.deliveryAttemptId,
+        fallbackRef: cycle.fallbackRef,
+        reasons: cycle.reasons,
+        livedExperienceLoopClaimed: false,
+    };
+}
+export async function heartbeatCheck(input) {
+    if (!input.runtimeAvailable) {
+        return {
+            ok: true,
+            status: "runtime_carrier_only",
+            surfaceMode: "host_safe_carrier",
+            reasons: ["runtime_unavailable_packaged_carrier"],
+            livedExperienceLoopClaimed: false,
+        };
+    }
+    if (input.probeOnly) {
+        return {
+            ok: true,
+            status: "heartbeat_ok",
+            surfaceMode: "capability_probe",
+            reasons: ["probe_only"],
+            livedExperienceLoopClaimed: false,
+        };
+    }
+    if (input.fakeControlPlanePassthrough) {
+        const decisionId = typeof input.fakeControlPlanePassthrough.decisionId === "string"
+            ? input.fakeControlPlanePassthrough.decisionId
+            : undefined;
+        return {
+            ok: true,
+            status: "intent_selected",
+            surfaceMode: "host_safe_carrier",
+            reasons: ["fake_control_plane_passthrough"],
+            decisionId,
+            livedExperienceLoopClaimed: false,
+            schemaParityOnly: true,
+        };
+    }
+    if (!input.readModels) {
+        return {
+            ok: true,
+            status: "runtime_carrier_only",
+            surfaceMode: "host_safe_carrier",
+            reasons: ["heartbeat_read_models_unavailable"],
+            livedExperienceLoopClaimed: false,
+        };
+    }
+    const timestamp = typeof input.timestamp === "string" && input.timestamp.trim().length > 0
+        ? input.timestamp.trim()
+        : new Date().toISOString();
+    const signal = {
+        trigger: "heartbeat_bridge",
+        scopeHint: input.scopeHint,
+        payload: {
+            timestamp,
+            sessionContext: typeof input.sessionContext === "string"
+                ? input.sessionContext
+                : undefined,
+        },
+    };
+    const run = createWorkspaceHeartbeatRunner(input.readModels, {
+        runtimeRecorder: input.runtimeRecorder,
+        state: input.state,
+        workspaceRoot: input.workspaceRoot ?? process.cwd(),
+    });
+    const cycle = await run(signal);
+    return mapCycleToSurface(cycle, "workspace_full_runtime");
+}

package/runtime/cli/ops/ops-router.d.ts

@@ -1,19 +1,32 @@
-/**
- * Shared ops command dispatch for CLI + tool surfaces (T1.1.3, T1.2.2).
- */
-import { type HeartbeatCheckInput, type HeartbeatSurfaceResult } from "./heartbeat-surface.js";
-import type { CliReadModels } from "../read-models/index.js";
-import type { RuntimeDecisionRecorder } from "../../observability/services/runtime-decision-recorder.js";
-export interface OpsRouterDeps {
-    /** When true, packaged runtime artifacts resolved and full graph is loadable */
-    runtimeAvailable: boolean;
-    /** Workspace read models: fallback view + heartbeat decision loop inputs (T1.2.2 / US-001). */
-    readModels?: CliReadModels;
-    /** Persists full-runtime heartbeat cycles so `loadStatus` exits the unknown baseline (T1.2.3). */
-    runtimeRecorder?: RuntimeDecisionRecorder;
-}
-export interface OpsRouter {
-    heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;
-    dispatch(command: string, input?: Record<string, unknown>): HeartbeatSurfaceResult | Record<string, unknown> | Promise<HeartbeatSurfaceResult> | Promise<Record<string, unknown>>;
-}
-export declare function createOpsRouter(deps: OpsRouterDeps): OpsRouter;
+/**
+ * Shared ops command dispatch for CLI + tool surfaces (T1.1.3, T1.2.2).
+ */
+import { type HeartbeatCheckInput, type HeartbeatSurfaceResult } from "./heartbeat-surface.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";
+import type { ObservabilityDatabase } from "../../observability/db/index.js";
+export interface OpsRouterDeps {
+    /** When true, packaged runtime artifacts resolved and full graph is loadable */
+    runtimeAvailable: boolean;
+    /** Workspace read models: fallback view + heartbeat decision loop inputs (T1.2.2 / US-001). */
+    readModels?: CliReadModels;
+    /** Persists full-runtime heartbeat cycles so `loadStatus` exits the unknown baseline (T1.2.3). */
+    runtimeRecorder?: RuntimeDecisionRecorder;
+    /**
+     * T2.2.2: state DB + workspace root for life evidence loading in full-runtime heartbeat cycles.
+     * When set, `loadSnapshotInputsForWorkspaceHeartbeat` can fill `lifeEvidenceRefs` from real DB truth.
+     */
+    state?: StateDatabase;
+    workspaceRoot?: string;
+    /**
+     * T1.2.8 (SN-CODE-03): observability DB for persisting capability probe reports.
+     * When absent, `capability_probe` still runs but skips persistence.
+     */
+    observabilityDb?: ObservabilityDatabase;
+}
+export interface OpsRouter {
+    heartbeatCheck(input: HeartbeatCheckInput): Promise<HeartbeatSurfaceResult>;
+    dispatch(command: string, input?: Record<string, unknown>): HeartbeatSurfaceResult | Record<string, unknown> | Promise<HeartbeatSurfaceResult> | Promise<Record<string, unknown>>;
+}
+export declare function createOpsRouter(deps: OpsRouterDeps): OpsRouter;