@haaaiawd/second-nature 0.2.12 → 0.2.13

package/runtime/observability/loop-stage-event-sink.js

@@ -21,6 +21,7 @@
  * Test coverage: tests/unit/observability/loop-stage-event-sink.test.ts
  */
 import { writeLoopStageEvent } from "../storage/v8-state-stores.js";
+import { classifyDegradedStatus } from "../shared/degraded-status-classifier.js";
 function validateEvent(event) {
     if (!event.cycleId || event.cycleId.trim().length === 0) {
         return { ok: false, reason: "cycle_id_required", field: "cycleId" };
@@ -100,7 +101,7 @@ export async function recordLoopStageEvent(db, event, options) {
     const validation = validateEvent(event);
     if (!validation.ok) {
         const degraded = {
-            status: "degraded",
+            status: classifyDegradedStatus("stage_event_missing"),
             reason: "stage_event_missing",
             ownerStage: event.stage || "ingestion",
             sourceRefs: event.sourceRefs || [],
@@ -111,6 +112,8 @@ export async function recordLoopStageEvent(db, event, options) {
     }
     const now = options?.now ?? new Date().toISOString();
     const sourceRefs = event.sourceRefs ?? [];
+    const proofRefs = event.proofRefs ?? [];
+    const traceRefs = event.traceRefs ?? [];
     const { redacted: redactedRefs, redactionClass } = redactSourceRefs(sourceRefs);
     const record = {
         id: event.id ?? `evt_${now.replace(/[:.]/g, "")}_${event.cycleId}_${event.stage}`,
@@ -120,6 +123,8 @@ export async function recordLoopStageEvent(db, event, options) {
         status: event.status,
         reason: event.reason,
         sourceRefs: redactedRefs,
+        proofRefs,
+        traceRefs,
         redactionClass,
         occurredAt: event.occurredAt,
         expectedDownstreamByCycle: event.expectedDownstreamByCycle,

package/runtime/observability/loop-status.d.ts

@@ -20,6 +20,7 @@
  */
 import type { StateDatabase } from "../storage/db/index.js";
 import type { DegradedOperationResult } from "../shared/types/v8-contracts.js";
+import type { EvidenceLevel } from "../shared/types/v8-contracts.js";
 export interface RealRunHealthProjection {
     gatePassed: boolean;
     contractSmokeOnly: boolean;
@@ -47,6 +48,7 @@ export interface LoopStatusReadModel {
     connectorTerminalCount: number;
     nextAction: string;
     realRunHealth: RealRunHealthProjection;
+    evidenceLevel: EvidenceLevel;
 }
 export interface StageSummary {
     stage: string;

package/runtime/observability/loop-status.js

@@ -21,6 +21,7 @@
 import { assembleLoopStatus } from "./causal-loop-health.js";
 import { checkRealRunHealth } from "./living-loop-health-gate.js";
 import { readActionClosuresByDay, readConnectorCooldownState, } from "../storage/v8-state-stores.js";
+import { classifyEvidenceLevel } from "../shared/evidence-level-classifier.js";
 // ───────────────────────────────────────────────────────────────
 // Helpers
 // ───────────────────────────────────────────────────────────────
@@ -163,7 +164,7 @@ export async function attributeDenials(db, options) {
 // ───────────────────────────────────────────────────────────────
 export async function readLoopStatus(db) {
     const health = await assembleLoopStatus(db, { limit: 50 });
-    if ("status" in health && health.status === "degraded") {
+    if ("ownerStage" in health) {
         return {
             ok: false,
             degraded: health,
@@ -214,6 +215,17 @@ export async function readLoopStatus(db) {
         overallStatus = "healthy";
         stalledAt = undefined;
     }
+    // T-OBS.R.7: derive evidenceLevel from observed proof
+    const evidenceLevel = classifyEvidenceLevel({
+        hasCarrierEnvelope: true, // loop_status command envelope itself
+        hasContractSmoke: snapshot.lastCycleSequence > 0 && !realRunHealth.hasRealClosure,
+        hasStatePresent: snapshot.lastCycleSequence === 0 &&
+            (realRunHealth.hasQuietArtifact ||
+                realRunHealth.hasDreamArtifact ||
+                realRunHealth.hasProjectionFeedback),
+        hasCycleExecution: snapshot.lastCycleSequence > 0 && realRunHealth.hasRealClosure,
+        hasReadbackVerification: realRunHealth.gatePassed,
+    });
     const stageSummaries = snapshot.stages.map((s) => ({
         stage: s.stage,
         eventCount: s.eventCount,
@@ -240,6 +252,7 @@ export async function readLoopStatus(db) {
             connectorTerminalCount: attribution.connectorTerminalCount,
             nextAction,
             realRunHealth,
+            evidenceLevel,
         },
     };
 }

package/runtime/observability/services/heartbeat-digest-assembler.d.ts

@@ -32,6 +32,7 @@
  */
 import type { AppendOnlyAuditStore } from "../audit/append-only-audit-store.js";
 import type { StateDatabase } from "../../storage/db/index.js";
+import type { EvidenceLevel } from "../../shared/types/v8-contracts.js";
 export interface ConnectorDaySummary {
     platformId: string;
     capability: string;
@@ -91,6 +92,8 @@ export interface HeartbeatDigest {
     healthSummary: HealthDaySummary;
     /** Real-run health gate result (T-OBS.R.3) */
     realRunHealth: RealRunHealthDigestProjection;
+    /** T-OBS.R.7: evidence level for this digest */
+    evidenceLevel: EvidenceLevel;
     /** Set when delivery succeeded */
     deliveredAt?: string;
     /** Proof of successful delivery (channel + message hash, no raw content) */

package/runtime/observability/services/heartbeat-digest-assembler.js

@@ -31,6 +31,7 @@
  *   tests/integration/observability/digest-delivery.test.ts (T-OBS.C.4)
  */
 import { checkRealRunHealth } from "../living-loop-health-gate.js";
+import { classifyEvidenceLevel } from "../../shared/evidence-level-classifier.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 function isSameDayUtc(isoTimestamp, dateStr) {
     // dateStr: "YYYY-MM-DD"
@@ -262,6 +263,13 @@ export async function generateHeartbeatDigest(date, deps) {
             };
         }
     }
+    const evidenceLevel = classifyEvidenceLevel({
+        hasCarrierEnvelope: true,
+        hasContractSmoke: !deps.db,
+        hasStatePresent: Boolean(deps.db) && !realRunHealth.gatePassed && !realRunHealth.hasRealClosure,
+        hasCycleExecution: realRunHealth.hasRealClosure,
+        hasReadbackVerification: realRunHealth.gatePassed,
+    });
     const digest = {
         date,
         generatedAt,
@@ -271,6 +279,7 @@ export async function generateHeartbeatDigest(date, deps) {
         quietDreamSummary,
         healthSummary,
         realRunHealth,
+        evidenceLevel,
     };
     // T-OBS.C.4: delivery hook — attempt delivery if adapter is provided
     if (deliveryAdapter) {

package/runtime/shared/degraded-status-classifier.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Degraded Status Classifier (T-OBS.R.8)
+ *
+ * Core logic: map canonical V8ReasonCode values to precise operational states
+ * so that stage-level diagnostics never use the aggregate "degraded" string.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/shared-v8-contracts.md §4.1`
+ *
+ * Dependencies: `src/shared/types/v8-contracts.js`
+ * Boundary: pure function; no I/O.
+ * Test coverage: tests/unit/shared/degraded-status-classifier.test.ts
+ */
+import type { DegradedOperationResult, V8ReasonCode } from "./types/v8-contracts.js";
+export type PreciseDegradedStatus = DegradedOperationResult["status"];
+export declare function classifyDegradedStatus(reason: V8ReasonCode): PreciseDegradedStatus;

package/runtime/shared/degraded-status-classifier.js

@@ -0,0 +1,68 @@
+/**
+ * Degraded Status Classifier (T-OBS.R.8)
+ *
+ * Core logic: map canonical V8ReasonCode values to precise operational states
+ * so that stage-level diagnostics never use the aggregate "degraded" string.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/shared-v8-contracts.md §4.1`
+ *
+ * Dependencies: `src/shared/types/v8-contracts.js`
+ * Boundary: pure function; no I/O.
+ * Test coverage: tests/unit/shared/degraded-status-classifier.test.ts
+ */
+const EMPTY_REASONS = new Set([
+    "evidence_batch_empty",
+    "evidence_content_missing",
+    "ingestion_empty",
+    "ingestion_no_data",
+    "quiet_empty_input",
+]);
+const BLOCKED_REASONS = new Set([
+    "source_refs_unresolved",
+    "proposal_missing_source_refs",
+    "judgment_missing_source_refs",
+    "quiet_redaction_blocked",
+    "dream_blocked_redaction",
+    "dream_blocked_no_content",
+    "dream_blocked_private_redacted",
+    "dream_blocked_credential",
+    "dream_blocked_validation_failed",
+    "dream_interval_active",
+]);
+const UNSAFE_REASONS = new Set([
+    "policy_denied_high_risk",
+    "policy_denied_breaker_open",
+    "closure_idempotency_conflict",
+]);
+const PARTIAL_REASONS = new Set([
+    "evidence_batch_truncated",
+    "perception_rules_only",
+    "dream_rules_only",
+    "dream_model_timeout",
+    "quiet_validation_failed",
+    "closure_downgraded_without_draft",
+]);
+const UNAVAILABLE_REASONS = new Set([
+    "state_unreadable",
+    "quiet_state_unreadable",
+    "ingestion_state_unreadable",
+    "stage_event_missing",
+    "execution_unavailable",
+    "guidance_unavailable",
+    "dream_scheduler_unavailable",
+    "policy_denied_missing_permission",
+    "closure_failed",
+    "closure_unavailable",
+]);
+export function classifyDegradedStatus(reason) {
+    if (EMPTY_REASONS.has(reason))
+        return "empty";
+    if (BLOCKED_REASONS.has(reason))
+        return "blocked";
+    if (UNSAFE_REASONS.has(reason))
+        return "unsafe";
+    if (PARTIAL_REASONS.has(reason))
+        return "partial";
+    return "unavailable";
+}

package/runtime/shared/evidence-level-classifier.d.ts

@@ -0,0 +1,61 @@
+/**
+ * EvidenceLevelClassifier — Monotonic evidence-level taxonomy for operator-facing surfaces.
+ *
+ * Core logic: classify how strongly a command/response is backed by runtime proof.
+ * Levels are ordered from weakest (carrier_ack) to strongest (durable_verified).
+ * A level may only stay the same or increase within one command; synthetic/carrier
+ * proofs can never be promoted to real_runtime or durable_verified.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/shared-v8-contracts.md §4.2, §4.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/runtime-ops-system.md §2, §3.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/observability-health-system.md §6.1`
+ *
+ * Dependencies: `src/shared/types/v8-contracts.js` (EvidenceLevel)
+ * Boundary: Pure classification functions; no storage or side effects.
+ * Test coverage: tests/unit/shared/evidence-level-classifier.test.ts
+ */
+import type { EvidenceLevel } from "./types/v8-contracts.js";
+export type { EvidenceLevel };
+export declare const EVIDENCE_LEVEL_ORDER: Record<EvidenceLevel, number>;
+export interface EvidenceLevelProofInput {
+    /** Host/plugin/CLI produced an envelope but no Second Nature contract path ran. */
+    hasCarrierEnvelope?: boolean;
+    /** Static/fixture contract path ran without proving live state mutation. */
+    hasContractSmoke?: boolean;
+    /** Durable state was read or existing rows were observed. */
+    hasStatePresent?: boolean;
+    /** Current v8 living-loop command executed and produced stage + closure proof. */
+    hasCycleExecution?: boolean;
+    /** real_runtime proof was persisted and read back through normal read model. */
+    hasReadbackVerification?: boolean;
+}
+/**
+ * Classify evidence level from observed proof flags.
+ * Returns the strongest level whose required proof is present.
+ */
+export declare function classifyEvidenceLevel(input: EvidenceLevelProofInput): EvidenceLevel;
+/**
+ * Cap a candidate level by a maximum allowed level.
+ * Used to prevent carrier/smoke proofs from masquerading as real runtime health.
+ */
+export declare function capEvidenceLevel(candidate: EvidenceLevel, cap: EvidenceLevel): EvidenceLevel;
+/**
+ * Promote a current level to a target level only if target is strictly stronger
+ * and promotion is supported by supplied proof.
+ */
+export declare function promoteEvidenceLevel(current: EvidenceLevel, target: EvidenceLevel, proof: EvidenceLevelProofInput): EvidenceLevel;
+/**
+ * Aggregate multiple stage evidence levels into the minimum (weakest) level.
+ * A chain is only as strong as its weakest proven stage.
+ */
+export declare function minEvidenceLevel(levels: EvidenceLevel[]): EvidenceLevel;
+/**
+ * Convenience: the strongest level achievable from the input proof set,
+ * but never exceeding a hard cap.
+ */
+export declare function classifyAndCapEvidenceLevel(input: EvidenceLevelProofInput, cap: EvidenceLevel): EvidenceLevel;
+/**
+ * Map an evidence level to a human-readable operator note.
+ */
+export declare function evidenceLevelDescription(level: EvidenceLevel): string;

package/runtime/shared/evidence-level-classifier.js

@@ -0,0 +1,116 @@
+/**
+ * EvidenceLevelClassifier — Monotonic evidence-level taxonomy for operator-facing surfaces.
+ *
+ * Core logic: classify how strongly a command/response is backed by runtime proof.
+ * Levels are ordered from weakest (carrier_ack) to strongest (durable_verified).
+ * A level may only stay the same or increase within one command; synthetic/carrier
+ * proofs can never be promoted to real_runtime or durable_verified.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/shared-v8-contracts.md §4.2, §4.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/runtime-ops-system.md §2, §3.3`
+ * - `.anws/v8/04_SYSTEM_DESIGN/observability-health-system.md §6.1`
+ *
+ * Dependencies: `src/shared/types/v8-contracts.js` (EvidenceLevel)
+ * Boundary: Pure classification functions; no storage or side effects.
+ * Test coverage: tests/unit/shared/evidence-level-classifier.test.ts
+ */
+export const EVIDENCE_LEVEL_ORDER = {
+    carrier_ack: 0,
+    contract_smoke: 1,
+    state_present: 2,
+    real_runtime: 3,
+    durable_verified: 4,
+};
+const LEVELS_BY_ORDER = [
+    "carrier_ack",
+    "contract_smoke",
+    "state_present",
+    "real_runtime",
+    "durable_verified",
+];
+/**
+ * Classify evidence level from observed proof flags.
+ * Returns the strongest level whose required proof is present.
+ */
+export function classifyEvidenceLevel(input) {
+    if (input.hasReadbackVerification && input.hasCycleExecution) {
+        return "durable_verified";
+    }
+    if (input.hasCycleExecution) {
+        return "real_runtime";
+    }
+    if (input.hasStatePresent) {
+        return "state_present";
+    }
+    if (input.hasContractSmoke) {
+        return "contract_smoke";
+    }
+    if (input.hasCarrierEnvelope) {
+        return "carrier_ack";
+    }
+    // Default: carrier_ack when an envelope exists but no stronger proof was supplied.
+    return "carrier_ack";
+}
+/**
+ * Cap a candidate level by a maximum allowed level.
+ * Used to prevent carrier/smoke proofs from masquerading as real runtime health.
+ */
+export function capEvidenceLevel(candidate, cap) {
+    if (EVIDENCE_LEVEL_ORDER[candidate] <= EVIDENCE_LEVEL_ORDER[cap]) {
+        return candidate;
+    }
+    return cap;
+}
+/**
+ * Promote a current level to a target level only if target is strictly stronger
+ * and promotion is supported by supplied proof.
+ */
+export function promoteEvidenceLevel(current, target, proof) {
+    const classified = classifyEvidenceLevel(proof);
+    if (EVIDENCE_LEVEL_ORDER[classified] >= EVIDENCE_LEVEL_ORDER[target]) {
+        return capEvidenceLevel(target, classified);
+    }
+    return current;
+}
+/**
+ * Aggregate multiple stage evidence levels into the minimum (weakest) level.
+ * A chain is only as strong as its weakest proven stage.
+ */
+export function minEvidenceLevel(levels) {
+    if (levels.length === 0)
+        return "carrier_ack";
+    let min = levels[0];
+    for (const level of levels) {
+        if (EVIDENCE_LEVEL_ORDER[level] < EVIDENCE_LEVEL_ORDER[min]) {
+            min = level;
+        }
+    }
+    return min;
+}
+/**
+ * Convenience: the strongest level achievable from the input proof set,
+ * but never exceeding a hard cap.
+ */
+export function classifyAndCapEvidenceLevel(input, cap) {
+    return capEvidenceLevel(classifyEvidenceLevel(input), cap);
+}
+/**
+ * Map an evidence level to a human-readable operator note.
+ */
+export function evidenceLevelDescription(level) {
+    switch (level) {
+        case "carrier_ack":
+            return "Host/plugin returned an envelope but no Second Nature contract path ran.";
+        case "contract_smoke":
+            return "Static or fixture contract path passed without live state mutation.";
+        case "state_present":
+            return "Durable state exists or was read, but no current cycle executed.";
+        case "real_runtime":
+            return "Current v8 living-loop command executed and produced stage/closure proof.";
+        case "durable_verified":
+            return "Real runtime proof persisted and read back through the normal read model.";
+        default:
+            return "Unknown evidence level.";
+    }
+}

package/runtime/shared/provenance-tier.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Provenance Tier Validator (T-SH.R.6)
+ *
+ * Core logic: enforce that real domain evidence lives in `sourceRefs`,
+ * runtime/policy/setup/host/packaging proofs live in `proofRefs`, and
+ * observability/audit/stage-event traces live in `traceRefs`.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/shared-v8-contracts.md §2.2`
+ *
+ * Dependencies: `src/shared/types/v8-contracts.js`
+ * Boundary: pure functions; no I/O.
+ * Test coverage: tests/unit/shared/provenance-tier.test.ts
+ */
+import type { SourceRef, ProvenanceBundle } from "./types/v8-contracts.js";
+export interface ProvenanceValidationError {
+    ok: false;
+    field: "sourceRefs" | "proofRefs" | "traceRefs";
+    ref: SourceRef;
+    reason: string;
+}
+export type ProvenanceValidationResult = {
+    ok: true;
+    bundle: ProvenanceBundle;
+} | {
+    ok: false;
+    errors: ProvenanceValidationError[];
+};
+export declare function validateProvenanceTiers(bundle: ProvenanceBundle): ProvenanceValidationResult;
+export declare function buildClosureProvenance(input: {
+    sourceRefs?: SourceRef[];
+    proofRefs?: SourceRef[];
+    traceRefs?: SourceRef[];
+}): ProvenanceBundle;
+export declare function cycleTraceRef(cycleId: string): SourceRef;
+export declare function closureTraceRef(closureId: string): SourceRef;
+export declare function decisionProofRef(decisionId: string): SourceRef;

package/runtime/shared/provenance-tier.js

@@ -0,0 +1,97 @@
+/**
+ * Provenance Tier Validator (T-SH.R.6)
+ *
+ * Core logic: enforce that real domain evidence lives in `sourceRefs`,
+ * runtime/policy/setup/host/packaging proofs live in `proofRefs`, and
+ * observability/audit/stage-event traces live in `traceRefs`.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/shared-v8-contracts.md §2.2`
+ *
+ * Dependencies: `src/shared/types/v8-contracts.js`
+ * Boundary: pure functions; no I/O.
+ * Test coverage: tests/unit/shared/provenance-tier.test.ts
+ */
+const PROOF_FAMILIES = new Set([
+    "action_closure",
+    "audit",
+    "connector_result",
+]);
+const TRACE_FAMILIES = new Set([
+    "audit",
+]);
+function isSyntheticProof(ref) {
+    return (ref.uri.startsWith("sn://closure/") ||
+        ref.uri.startsWith("sn://decision/") ||
+        ref.uri.startsWith("sn://policy/") ||
+        ref.uri.startsWith("sn://execution/") ||
+        ref.uri.startsWith("sn://cycle/") ||
+        ref.uri.startsWith("sn://host/") ||
+        ref.uri.startsWith("sn://setup/") ||
+        PROOF_FAMILIES.has(ref.family));
+}
+function isTraceRef(ref) {
+    return (ref.uri.startsWith("sn://cycle/") ||
+        ref.uri.startsWith("sn://event/") ||
+        TRACE_FAMILIES.has(ref.family));
+}
+export function validateProvenanceTiers(bundle) {
+    const errors = [];
+    for (const ref of bundle.sourceRefs) {
+        if (isSyntheticProof(ref)) {
+            errors.push({
+                ok: false,
+                field: "sourceRefs",
+                ref,
+                reason: "Synthetic proof/trace ref must not live in sourceRefs",
+            });
+        }
+    }
+    for (const ref of bundle.proofRefs) {
+        if (isTraceRef(ref)) {
+            errors.push({
+                ok: false,
+                field: "proofRefs",
+                ref,
+                reason: "Trace ref must live in traceRefs, not proofRefs",
+            });
+        }
+    }
+    return errors.length === 0
+        ? { ok: true, bundle }
+        : { ok: false, errors };
+}
+export function buildClosureProvenance(input) {
+    return {
+        sourceRefs: input.sourceRefs ?? [],
+        proofRefs: input.proofRefs ?? [],
+        traceRefs: input.traceRefs ?? [],
+    };
+}
+export function cycleTraceRef(cycleId) {
+    return {
+        uri: `sn://cycle/${cycleId}`,
+        family: "audit",
+        id: cycleId,
+        redactionClass: "none",
+        resolveStatus: "resolvable",
+    };
+}
+export function closureTraceRef(closureId) {
+    return {
+        uri: `sn://closure/${closureId}`,
+        family: "action_closure",
+        id: closureId,
+        redactionClass: "none",
+        resolveStatus: "resolvable",
+    };
+}
+export function decisionProofRef(decisionId) {
+    return {
+        uri: `sn://decision/${decisionId}`,
+        family: "action_closure",
+        id: decisionId,
+        redactionClass: "none",
+        resolveStatus: "resolvable",
+    };
+}

package/runtime/shared/setup-ack.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Setup Ack Truth Contract (T-ROS.R.8)
+ *
+ * Core logic: define the canonical SetupAck schema and a validator that rejects
+ * `placedIn: "unspecified"`, missing fields, unknown writers, and hand-written
+ * files that do not satisfy the schema.
+ *
+ * Design authority:
+ * - `.anws/v8/04_SYSTEM_DESIGN/runtime-ops-system.md §3.2`
+ *
+ * Dependencies: none (plain validation to keep plugin load lightweight)
+ * Boundary: Pure validation; no I/O.
+ * Test coverage: tests/unit/shared/setup-ack-validator.test.ts
+ */
+export declare const SETUP_ACK_SCHEMA_VERSION = 1;
+export type SetupAckPlacement = "workspace_guide" | "host_skill_registry" | "agent_profile" | "manual_operator_instruction";
+export type SetupAckWriter = "setup_ack_command" | "host_setup_bridge";
+export interface SetupAck {
+    schemaVersion: typeof SETUP_ACK_SCHEMA_VERSION;
+    acknowledgedAt: string;
+    placedIn: SetupAckPlacement;
+    placementProofRef: string;
+    writer: SetupAckWriter;
+    hostName?: string;
+    hostVersion?: string;
+    acceptedBy?: string;
+    note?: string;
+}
+export interface SetupAckValidationResult {
+    ok: true;
+    ack: SetupAck;
+}
+export interface SetupAckValidationError {
+    ok: false;
+    field: string;
+    reason: string;
+    repairAction: string;
+}
+export type ValidateSetupAckResult = SetupAckValidationResult | {
+    ok: false;
+    errors: SetupAckValidationError[];
+};
+export declare function validateSetupAck(raw: Record<string, unknown>): ValidateSetupAckResult;
+/**
+ * Check whether a raw marker object can be considered a complete ack.
+ * Hand-written files are treated as incomplete until verified.
+ */
+export declare function isSetupAckComplete(raw: Record<string, unknown>): {
+    complete: true;
+    ack: SetupAck;
+} | {
+    complete: false;
+    errors: SetupAckValidationError[];
+};