@haaaiawd/second-nature 0.1.17 → 0.1.18

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,54 +1,58 @@
-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";
-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);
-    return {
-        stateDb,
-        observabilityDb,
-        stateApi,
-        readModels,
-        actionBridge,
-    };
-}
-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,
-    });
-    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 });
+    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";

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

@@ -1,35 +1,38 @@
-/**
- * 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";
-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;
-    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";
+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>;

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

@@ -1,71 +1,73 @@
-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);
-    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,
+    });
+    const cycle = await run(signal);
+    return mapCycleToSurface(cycle, "workspace_full_runtime");
+}

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

@@ -1,16 +1,19 @@
-/**
- * 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";
-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;
-}
-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";
+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;

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

@@ -1,87 +1,89 @@
-/**
- * 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,
-        }),
-        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,
-                    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";
+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}`,
+                },
+            };
+        },
+    };
+}