@tpsdev-ai/flair 0.21.0 → 0.22.1

package/dist/resources/migrations/embedding-stamp.js

@@ -0,0 +1,178 @@
+/**
+ * embedding-stamp.ts — the first registered migration (per the spec):
+ * re-embeds every Memory row whose `embeddingModel` doesn't match
+ * `getModelId()`. riskClass 'derived-only' — embeddings are recomputable
+ * from `content` (SOURCE_FIELDS), never the only copy of anything
+ * (invariant I), so this is the cheapest posture: metadata-only snapshot,
+ * no content-hash gate (row-count + stamp convergence only).
+ *
+ * THE GATE (`EMBEDDING_PREFIXES_ENABLED` in resources/embeddings-provider.ts)
+ * is now ON (flair#504, flipped and re-baselined through the ratchet gate),
+ * so `getModelId()` returns `<base>+searchprefix` — every row written before
+ * this flip was stamped with the bare base id, so it now reads as stale and
+ * gets picked up by this migration on the next boot that reaches it. This is
+ * this migration's first real payload: before the flip, `getModelId()`
+ * returned the bare base id unconditionally, so this migration — live and
+ * always-registered from the day it shipped — had nothing to detect. That
+ * was intentional groundwork, not dead code: proving the detect/re-embed
+ * mechanism end-to-end (this file, `test/integration/
+ * migrations-embedding-stamp-e2e.test.ts`) before it ever had real work to
+ * do was the point.
+ *
+ * Reuses Memory's OWN regen branch — never duplicates embedding logic —
+ * via the SAME mechanism `flair reembed` (src/cli.ts) already uses in
+ * production: a genuine `PUT /Memory/:id` HTTP request (admin-authenticated
+ * loopback), not an in-process call on `databases.flair.Memory` directly.
+ *
+ * THIS IS LOAD-BEARING, confirmed empirically while building
+ * test/integration/migrations-embedding-stamp-e2e.test.ts against real
+ * Harper: `databases.flair.Memory` (the property Harper exposes to OTHER
+ * modules, imported the same way resources/health.ts / MemoryReindex.ts /
+ * etc. already do for READS) resolves to the RAW underlying table, not the
+ * resources/Memory.ts SUBCLASS that carries the actual regen/dedup/auth
+ * logic — that subclass is only reachable via Harper's own REST dispatch
+ * for a genuine `/Memory` request. Calling `.put()` on the raw reference
+ * writes the record fine (confirmed: fields land exactly as passed) but
+ * silently skips every override in resources/Memory.ts, INCLUDING the
+ * `if (content.content && !content.embedding) { regenerate } ` branch this
+ * migration exists to trigger. Reads (`.search()`/`.get()`, used below for
+ * detect/countPending/candidate-selection) are unaffected by this — only
+ * `.put()` needs the real dispatch, hence the loopback HTTP call for
+ * exactly that one step.
+ *
+ * Query correctness (also verified against real Harper): Harper's
+ * `not_equal` comparator only matches rows where the attribute holds an
+ * EXPLICIT value (including explicit `null`) — a row where the attribute
+ * was NEVER SET AT ALL (`getIndexedValues()` returns `undefined` for a
+ * truly-absent property, never indexed regardless of `indexNulls`) is
+ * invisible to ANY condition-based query, not just `not_equal`. Clearing to
+ * `null` (never `undefined`) on write is therefore load-bearing: if the
+ * regen HTTP call fails (engine not yet warmed up, transient failure,
+ * admin credential unavailable this cycle), the row must land back in an
+ * EXPLICIT-null state — queryable and retried on the next boot — never a
+ * truly-absent one that would be permanently invisible to this migration
+ * again. The pending condition is an OR of `not_equal <current>` (catches a
+ * stale non-null model string) and `equals null` (catches that
+ * explicit-null state) — together they catch every state this migration's
+ * OWN writes can ever produce. A row whose `embeddingModel` was NEVER
+ * touched by anything (truly absent from its very first write — only
+ * possible if the embeddings engine was down for that entire write) is a
+ * known, narrow gap this bounded query cannot see;
+ * resources/migration-boot.ts mitigates the common case by waiting for the
+ * embeddings engine to settle before running migrations at all.
+ */
+import { databases } from "@harperfast/harper";
+import { getModelId } from "../embeddings-provider.js";
+function defaultMemoryTable() {
+    return databases.flair.Memory;
+}
+export const EMBEDDING_STAMP_ID = "embedding-stamp";
+const REGEN_HTTP_TIMEOUT_MS = 20_000; // a real embedding compute can be slow on constrained hardware
+/** Same admin-password resolution as resources/auth-middleware.ts's getAdminPass(). */
+function resolveAdminAuthHeader() {
+    const pass = process.env.HDB_ADMIN_PASSWORD ?? process.env.FLAIR_ADMIN_PASSWORD;
+    if (!pass)
+        return null;
+    return "Basic " + Buffer.from(`admin:${pass}`).toString("base64");
+}
+/** Same HTTP_PORT env resolution src/cli.ts sets on every Harper spawn (see that file's grep for HTTP_PORT). */
+function resolveSelfBaseUrl() {
+    const port = process.env.HTTP_PORT ?? "9926";
+    return `http://127.0.0.1:${port}`;
+}
+/**
+ * Triggers Memory.put()'s regen branch via a genuine loopback HTTP PUT —
+ * the ONLY reliable way to reach resources/Memory.ts's subclass logic (see
+ * module doc). Returns true iff the request succeeded (2xx); NEVER throws
+ * — a failure just leaves the row in its current (queryable, explicit-null
+ * or stale-string) state for the next attempt.
+ */
+async function regenViaHttpPut(id, existing, fetchImpl) {
+    const authHeader = resolveAdminAuthHeader();
+    if (!authHeader)
+        return false; // no admin credential available this cycle — retried next boot
+    try {
+        const res = await fetchImpl(`${resolveSelfBaseUrl()}/Memory/${encodeURIComponent(id)}`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json", Authorization: authHeader },
+            body: JSON.stringify({ ...existing, embedding: null, embeddingModel: null }),
+            signal: AbortSignal.timeout(REGEN_HTTP_TIMEOUT_MS),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `getTable`/`getCurrentModelId`/`regen` are injectable so unit tests can
+ * exercise this migration's full detect/countPending/run logic against an
+ * in-memory fake table and a fake regen function (no real Harper, no real
+ * HTTP needed) — matching the mocking technique used throughout
+ * test/unit/*.ts (e.g. test/unit/instance-identity.test.ts). The real
+ * loopback-HTTP regen path is exercised for real in
+ * test/integration/migrations-embedding-stamp-e2e.test.ts.
+ */
+export function createEmbeddingStampMigration(getTable = defaultMemoryTable, getCurrentModelId = getModelId, regen = (id, existing) => regenViaHttpPut(id, existing, fetch)) {
+    function staleCondition() {
+        // OR-combined: `not_equal <current>` catches a stale non-null model
+        // string; `equals null` catches the explicit-null state this
+        // migration's own writes leave behind on a failed regen (see the
+        // module doc above — Harper's index never sees a TRULY ABSENT
+        // property, only an explicit null).
+        return [
+            {
+                operator: "or",
+                conditions: [
+                    { attribute: "embeddingModel", comparator: "not_equal", value: getCurrentModelId() },
+                    { attribute: "embeddingModel", comparator: "equals", value: null },
+                ],
+            },
+        ];
+    }
+    return {
+        id: EMBEDDING_STAMP_ID,
+        riskClass: "derived-only",
+        affectsTables: ["Memory"],
+        async detect() {
+            const table = getTable();
+            for await (const _row of table.search({ conditions: staleCondition(), limit: 1 })) {
+                return true;
+            }
+            return false;
+        },
+        async countPending() {
+            const table = getTable();
+            let n = 0;
+            for await (const _row of table.search({ conditions: staleCondition() }))
+                n++;
+            return n;
+        },
+        async run(batchSize) {
+            const table = getTable();
+            const current = getCurrentModelId();
+            const candidates = [];
+            for await (const row of table.search({ conditions: staleCondition(), limit: batchSize })) {
+                candidates.push(row);
+            }
+            const touchedIds = [];
+            for (const row of candidates) {
+                const id = String(row.id ?? "");
+                if (!id)
+                    continue;
+                const existing = await table.get(id);
+                if (!existing)
+                    continue; // deleted since the search above — nothing to fix
+                if (existing.embeddingModel === current)
+                    continue; // already stamped by a concurrent runner — idempotent skip
+                const ok = await regen(id, existing);
+                if (ok)
+                    touchedIds.push(id);
+                // A failed regen leaves the row untouched (still matching
+                // staleCondition — retried next batch/boot), never partially
+                // written or marked done.
+            }
+            return { processed: touchedIds.length, touchedIds };
+        },
+    };
+}

package/dist/resources/migrations/envelope.js

@@ -0,0 +1,43 @@
+/**
+ * envelope.ts — the corpus-wide integrity envelope: "full-corpus
+ * hash-of-source-field-hashes computed before first write and after
+ * completion; must match" (flair#695 invariant IV /
+ * Kern verdict), computed ONCE per boot cycle (K&S: "Envelope ASYNC after
+ * ready — boot serves immediately on the old shape; pre-hash runs async;
+ * migration deferred until it completes").
+ *
+ * `computeCorpusEnvelope` walks BOTH SOURCE_FIELDS tables (Memory,
+ * Relationship) once and returns both the single aggregate `corpusHash`
+ * (what schema-additive's full-envelope gate compares pre/post) AND the
+ * full `perRowHash` breakdown (`${table}:${id}` -> hash) — the latter isn't
+ * used by this module directly, but keeping the breakdown around lets a
+ * caller answer "did THIS specific row's source fields change" without a
+ * second full-corpus pass, if ever needed for diagnostics.
+ *
+ * Deliberately NOT scoped by risk class — this is the one integrity
+ * computation the whole cycle shares; risk-class-specific gate strictness
+ * (runner.ts) decides HOW MUCH of it each migration's completion gate
+ * actually checks.
+ */
+import { createHash } from "node:crypto";
+import { hashSourceFields, sourceFieldsFor } from "./source-fields.js";
+export const ENVELOPE_TABLES = ["Memory", "Relationship"];
+export async function computeCorpusEnvelope(getTable, now) {
+    const perRowHash = new Map();
+    const parts = [];
+    for (const table of ENVELOPE_TABLES) {
+        const fields = sourceFieldsFor(table);
+        const accessor = getTable(table);
+        for await (const row of accessor.search({})) {
+            const id = String(row.id ?? "");
+            if (!id)
+                continue;
+            const h = hashSourceFields(row, fields);
+            perRowHash.set(`${table}:${id}`, h);
+            parts.push(`${table}:${id}:${h}`);
+        }
+    }
+    parts.sort();
+    const corpusHash = createHash("sha256").update(parts.join("|")).digest("hex");
+    return { perRowHash, corpusHash, computedAt: now().toISOString() };
+}

package/dist/resources/migrations/export.js

@@ -0,0 +1,38 @@
+/**
+ * export.ts — content-only logical export fallback (ladder step 4):
+ * "Content-only logical export fallback: embeddings/indexes dominate
+ * data-dir size; the irreplaceable part (memory content + provenance)
+ * exports far smaller. If the physical snapshot doesn't fit but the content
+ * export does → export content, proceed (derived is recomputable by
+ * definition)." (flair#695, space-pressure step 4)
+ *
+ * Exports SOURCE_FIELDS ONLY (+id) — never derived fields (embedding is the
+ * dominant size driver this exists to skip) — as JSONL, one row per line,
+ * under the SAME 0700/0600 discipline as snapshot.ts.
+ */
+import { statSync } from "node:fs";
+import { join } from "node:path";
+import { ensureSecureDir, writeSecureFile } from "./dir-safety.js";
+import { sourceFieldsFor } from "./source-fields.js";
+function sanitizeIdPart(s) {
+    return s.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+export function createContentOnlyExport(opts, deps) {
+    const now = deps.now();
+    const iso = now.toISOString().replace(/[:.]/g, "-");
+    const dir = join(deps.exportRoot, `${sanitizeIdPart(opts.migrationId)}-${opts.table}-${iso}`);
+    ensureSecureDir(dir);
+    const fields = sourceFieldsFor(opts.table);
+    const lines = opts.rows.map((row) => {
+        const picked = { id: row.id };
+        for (const f of fields)
+            picked[f] = row[f] ?? null;
+        return JSON.stringify(picked);
+    });
+    const body = lines.join("\n") + (lines.length ? "\n" : "");
+    const path = join(dir, `${opts.table}.jsonl`);
+    writeSecureFile(path, body, dir);
+    const metaPath = join(dir, "manifest.json");
+    writeSecureFile(metaPath, JSON.stringify({ migrationId: opts.migrationId, table: opts.table, fromVersion: opts.fromVersion, createdAt: now.toISOString(), rowCount: opts.rows.length }, null, 2) + "\n", dir);
+    return { dir, path, bytes: statSync(path).size, rowCount: opts.rows.length };
+}

package/dist/resources/migrations/ledger.js

@@ -0,0 +1,55 @@
+/**
+ * ledger.ts — the migration ledger OrgEvent (invariant IV: "every migration
+ * records an OrgEvent (initiator, versions, scope, outcome, duration) —
+ * migrations get decision provenance. Dogfood.")
+ *
+ * Sherlock verdict: "Ledger discloses structural metadata only — versions,
+ * counts, outcome, duration; never memory IDs or content summaries." The
+ * shape below is EXACTLY the Kern-verdict field list (migration id,
+ * initiator, from/to version, scope, start/end, outcome, rows
+ * processed/remaining, error if halted, hash envelope) — nothing else is
+ * ever written into `detail`.
+ *
+ * Written via an internal (no-HTTP-context) call to
+ * `databases.flair.OrgEvent.put()` — resolveAgentAuth(undefined) resolves
+ * to `{kind: "internal"}` (trusted; see resources/agent-auth.ts), the same
+ * pattern resources/auth-middleware.ts's backfillEmbedding() and
+ * resources/MemoryReindex.ts's `_reindex` path already rely on for
+ * server-internal writes with no HTTP caller behind them.
+ */
+import { databases } from "@harperfast/harper";
+function defaultOrgEventTable() {
+    return databases.flair.OrgEvent;
+}
+/** Structural-only detail blob — see the module doc; never memory IDs/content. */
+export function buildLedgerDetail(evt) {
+    return JSON.stringify({
+        migrationId: evt.migrationId,
+        initiator: evt.initiator,
+        fromVersion: evt.fromVersion,
+        toVersion: evt.toVersion,
+        scope: evt.scope,
+        startedAt: evt.startedAt,
+        endedAt: evt.endedAt,
+        outcome: evt.outcome,
+        rowsProcessed: evt.rowsProcessed,
+        rowsRemaining: evt.rowsRemaining,
+        hashEnvelopeMatch: evt.hashEnvelopeMatch,
+        ...(evt.error ? { error: evt.error } : {}),
+    });
+}
+export async function writeLedgerEvent(evt, deps = {}) {
+    const table = deps.orgEventTable ?? defaultOrgEventTable();
+    const id = `migration-${evt.migrationId}-${evt.endedAt}`;
+    const remainingNote = evt.rowsRemaining > 0 ? `, ${evt.rowsRemaining} remaining` : "";
+    await table.put({
+        id,
+        authorId: "flair-migrations",
+        kind: "migration",
+        scope: evt.scope,
+        summary: `migration ${evt.migrationId} ${evt.outcome} (${evt.rowsProcessed} row${evt.rowsProcessed === 1 ? "" : "s"} processed${remainingNote})`,
+        detail: buildLedgerDetail(evt),
+        refId: evt.migrationId,
+        createdAt: evt.endedAt,
+    });
+}

package/dist/resources/migrations/lock.js

@@ -0,0 +1,154 @@
+/**
+ * lock.ts — single-flight guard (Kern verdict, 2026-07-12):
+ * "Single-flight v1 = in-process mutex + stale-tolerant file lock (flock on
+ * well-known path; dead-holder → break and proceed). Fabric-wide ordering =
+ * follow-on with its own review, NOT this slice."
+ *
+ * Two layers:
+ *   1. An in-process mutex (module-scope flag) — cheapest guard against two
+ *      concurrent async callers inside the SAME Node process (e.g. a
+ *      duplicate boot-trigger firing twice).
+ *   2. A file lock at a well-known path under the data dir. Node has no
+ *      portable flock() binding, so this uses exclusive file CREATE
+ *      (O_CREAT|O_EXCL — atomic at the OS level, the same primitive flock
+ *      ultimately reduces to for a single-host guard) instead. The lock file
+ *      holds `{pid, hostname, startedAt}`. A lock is considered STALE (and
+ *      is broken/removed before the new attempt) when either: the recorded
+ *      pid is no longer alive on this host, OR the file is older than
+ *      `staleMs` (covers a cross-host holder this process can't liveness-
+ *      check by pid — Fabric-wide coordination is explicitly out of scope
+ *      for this slice, so age is the only signal available for that case).
+ *
+ * This is a SINGLE-HOST guard, not a Fabric-wide one — multiple Flair
+ * instances in a Fabric cluster each have their OWN data dir today, so this
+ * is sufficient for v1. Fabric-wide ordering (one lock across a cluster
+ * sharing storage) is explicitly deferred, per the verdict above.
+ */
+import { existsSync, mkdirSync, openSync, closeSync, writeSync, readFileSync, unlinkSync, statSync, utimesSync, constants as fsConstants } from "node:fs";
+import { dirname } from "node:path";
+import { hostname as osHostname } from "node:os";
+export const DEFAULT_STALE_MS = 5 * 60 * 1000; // 5 minutes with no heartbeat touch = stale
+export function defaultIsProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function defaultLockDeps(lockPath) {
+    return {
+        lockPath,
+        staleMs: DEFAULT_STALE_MS,
+        isProcessAlive: defaultIsProcessAlive,
+        now: () => Date.now(),
+    };
+}
+// In-process mutex — module-scope, so it's shared by every caller within
+// this one Node process regardless of which lockPath they pass (a single
+// process only ever wants to run one migration cycle at a time).
+let inProcessHeld = false;
+/** Test-only reset for the in-process mutex (mirrors instance-identity.ts's `_reset*ForTests` idiom). */
+export function _resetInProcessLockForTests() {
+    inProcessHeld = false;
+}
+function readHolder(lockPath) {
+    try {
+        const raw = JSON.parse(readFileSync(lockPath, "utf-8"));
+        if (typeof raw?.pid === "number" && typeof raw?.hostname === "string" && typeof raw?.startedAt === "string") {
+            return raw;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Attempts to acquire the migration lock. On success, returns `release()`
+ * (removes the lock file + clears the in-process flag) and `touch()`
+ * (updates the lock file's mtime — the runner calls this periodically
+ * during a long-running migration so ANOTHER process's staleness check
+ * doesn't mistake a genuinely-still-running holder for dead).
+ */
+export function acquireMigrationLock(deps) {
+    const resolved = { ...defaultLockDeps(deps.lockPath), ...deps };
+    const { lockPath, staleMs, isProcessAlive, now } = resolved;
+    if (inProcessHeld) {
+        return { acquired: false, reason: "already held in-process (another async caller in this process holds it)" };
+    }
+    mkdirSync(dirname(lockPath), { recursive: true, mode: 0o700 });
+    if (existsSync(lockPath)) {
+        const holder = readHolder(lockPath);
+        let ageMs = Infinity;
+        try {
+            ageMs = now() - statSync(lockPath).mtimeMs;
+        }
+        catch {
+            /* vanished between existsSync and stat — fall through to acquire */
+        }
+        const dead = !holder || !isProcessAlive(holder.pid) || ageMs > staleMs;
+        if (dead) {
+            try {
+                unlinkSync(lockPath);
+            }
+            catch {
+                /* another racer already broke it — fine, continue to the exclusive create below */
+            }
+        }
+        else {
+            return {
+                acquired: false,
+                reason: `held by pid ${holder.pid} on ${holder.hostname} since ${holder.startedAt}`,
+                holder,
+            };
+        }
+    }
+    let fd;
+    try {
+        // O_EXCL: atomic exclusive create — fails with EEXIST if another
+        // process/racer won the create between our stale-check above and here.
+        fd = openSync(lockPath, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY, 0o600);
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "EEXIST") {
+            return { acquired: false, reason: "lost the race to acquire the lock file" };
+        }
+        throw err;
+    }
+    try {
+        const info = { pid: process.pid, hostname: osHostname(), startedAt: new Date(now()).toISOString() };
+        writeSync(fd, JSON.stringify(info));
+    }
+    finally {
+        closeSync(fd);
+    }
+    inProcessHeld = true;
+    let released = false;
+    return {
+        acquired: true,
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            inProcessHeld = false;
+            try {
+                unlinkSync(lockPath);
+            }
+            catch {
+                /* already gone — fine */
+            }
+        },
+        touch: () => {
+            const t = new Date(now());
+            try {
+                utimesSync(lockPath, t, t);
+            }
+            catch {
+                /* best-effort heartbeat — a failed touch must never break the migration */
+            }
+        },
+    };
+}

package/dist/resources/migrations/progress.js

@@ -0,0 +1,31 @@
+let cycleStatus = { phase: "idle" };
+const progressById = new Map();
+export function setCyclePhase(phase, error) {
+    cycleStatus = { phase, lastCycleError: error, lastCycleAt: new Date().toISOString() };
+}
+export function getCycleStatus() {
+    return { ...cycleStatus };
+}
+export function setMigrationProgress(p) {
+    progressById.set(p.id, p);
+}
+export function getMigrationProgress(id) {
+    return progressById.get(id);
+}
+export function listMigrationProgress() {
+    return Array.from(progressById.values());
+}
+/** Seeds an "idle" entry for every registered migration id — called once at
+ * boot-trigger registration time, synchronously, so `health` always has a
+ * row per registered migration even before the async cycle has run at all. */
+export function seedIdleProgress(ids) {
+    for (const id of ids) {
+        if (!progressById.has(id)) {
+            progressById.set(id, { id, rowsDone: 0, rowsRemaining: 0, state: "idle" });
+        }
+    }
+}
+export function _resetProgressForTests() {
+    progressById.clear();
+    cycleStatus = { phase: "idle" };
+}

package/dist/resources/migrations/registry.js

@@ -0,0 +1,36 @@
+/**
+ * registry.ts — the MigrationRegistry: an ordered list of registered
+ * migrations. embedding-stamp always registers; the synthetic CI-only
+ * variant registers ONLY when shouldRegisterSyntheticMigration() is true
+ * (see synthetic-test-migration.ts's doc for the exact gating rule).
+ */
+import { createEmbeddingStampMigration } from "./embedding-stamp.js";
+import { createSyntheticTestMigration, shouldRegisterSyntheticMigration } from "./synthetic-test-migration.js";
+export class MigrationRegistry {
+    migrations = [];
+    register(migration) {
+        if (this.migrations.some((m) => m.id === migration.id)) {
+            throw new Error(`migration id already registered: ${migration.id}`);
+        }
+        this.migrations.push(migration);
+        return this;
+    }
+    list() {
+        return this.migrations;
+    }
+    get(id) {
+        return this.migrations.find((m) => m.id === id);
+    }
+}
+/**
+ * Builds the production registry. Always includes embedding-stamp;
+ * conditionally includes the CI-only synthetic migration.
+ */
+export function buildRegistry(env = process.env) {
+    const registry = new MigrationRegistry();
+    registry.register(createEmbeddingStampMigration());
+    if (shouldRegisterSyntheticMigration(env)) {
+        registry.register(createSyntheticTestMigration());
+    }
+    return registry;
+}

package/dist/resources/migrations/risk-policy.js

@@ -0,0 +1,23 @@
+const POSTURE = {
+    "derived-only": {
+        riskClass: "derived-only",
+        batchSize: 50,
+        snapshotScope: "metadata-only",
+        gate: "count+marker",
+    },
+    "schema-additive": {
+        riskClass: "schema-additive",
+        batchSize: 50,
+        snapshotScope: "schema+metadata",
+        gate: "count+full-envelope",
+    },
+    "content-transform": {
+        riskClass: "content-transform",
+        batchSize: 10,
+        snapshotScope: "pointers+metadata",
+        gate: "count+old-row-envelope+new-row-presence",
+    },
+};
+export function postureFor(riskClass) {
+    return POSTURE[riskClass];
+}