@mnemom/mnemom 0.17.33 → 0.17.34-next.2

package/dist/vendor/shared/durable-contract/admission.js

@@ -0,0 +1,533 @@
+// GENERATED from shared/durable-contract/src/admission.ts by cli/scripts/sync-durable-contract.mjs; do not edit.
+/**
+ * Gateway admission for mnm_ds_ keys: one total pure function over the resolver's `durable`
+ * object plus the request pin and posture (design §3.6 steps 1-4; C06-R14/R15; C08-R13/R14;
+ * C09-R08/R11; C11-R33; rulings I03, I12, I20, r3 I01). Data, not branches, wherever possible:
+ * ADMISSION_PRECEDENCE is the order the oracle reads, and `admissionTruthTable()` enumerates the
+ * cross product the eval compares against.
+ *
+ * Precedence, first match wins:
+ *   1 unknown or invalid key            -> the baseline unknown-key answer for the path and mode
+ *   2 resolver fault or bad schema      -> 503 durable_admission_unavailable
+ *   3 key_state revoked                 -> 401 durable_key_revoked
+ *   4 pin absent or mismatched          -> 409 durable_identity_mismatch
+ *   5 durable_mode tracked              -> 410 durable_unlocked
+ *   6 effective terminal                -> 410 durable_session_ended {state, state_reason}
+ *   7 fenced (unless nofence)           -> 409 durable_lease_fenced
+ *   8 paused or non-admitting suspended -> 423 durable_session_stopped {state, state_reason}
+ *   9 posture: attended admits; unattended -> 503 durable_guard_unavailable on a guard fault,
+ *     else 503 durable_unattended_unavailable (M1 refuses all unattended work).
+ * The one exception (wave-0 fix ruling 22): a POST /v1/messages/count_tokens with no chain= (header
+ * absent, or no chain on the newest entry) runs steps 1-8 and skips step 9: it is admitted as
+ * admit_unchained, with no chain row and no posture insert. Every other request is unchanged.
+ * Hello transition: only an admitted attended request moves an effectively resuming session to
+ * running (helloTransition). admit_unchained never does and writes nothing (a resuming session
+ * stays resuming).
+ * The door (normalizeCellId(CELL_ID) vs home_cell) is diagnostic only in M1.
+ * An attended guard fault is admitted (today's behaviour) and reported (C08-R14).
+ */
+import { canonicalJson, sha256Hex } from "./canonical.js";
+import { deriveEffectiveState, EFFECTIVE_STATES, isEffectiveStateConsistent, isValidStateReason, endedBody, SESSION_STATES, STATE_REASONS, } from "./states.js";
+import { NOFENCE_ADMIT_VALUE } from "./constants.js";
+import { CANONICAL_CELL_IDS } from "./cell-id.js";
+export const KEY_STATES = ["active", "revoked"];
+export const POSTURES = ["attended", "unattended"];
+export const EXECUTOR_KINDS = ["host", "fleet", "container"];
+export const OUTAGE_MODES = ["stop", "continue"];
+/**
+ * The resolver per-field schema. A missing field, wrong type, unknown enum value, or null on a
+ * non-nullable field is a schema fault: 503 durable_admission_unavailable, never a throw.
+ */
+export const RESOLVER_SCHEMA = {
+    key_state: { type: "enum", nullable: false, values: KEY_STATES },
+    session_id: { type: "uuid", nullable: false },
+    aip_session_id: { type: "string", nullable: false },
+    durable_mode: { type: "enum", nullable: false, values: ["tracked", "locked"] },
+    state: { type: "enum", nullable: false, values: SESSION_STATES },
+    effective_state: { type: "enum", nullable: false, values: EFFECTIVE_STATES },
+    state_reason: {
+        type: "string",
+        nullable: true,
+        nullMeans: "no reason (running, parked, resuming, owner kill)",
+    },
+    epoch: { type: "integer", nullable: false },
+    fenced: { type: "boolean", nullable: false },
+    agent_id: { type: "uuid", nullable: false },
+    home_cell: { type: "enum", nullable: false, values: CANONICAL_CELL_IDS },
+    posture: {
+        type: "enum",
+        nullable: true,
+        values: POSTURES,
+        nullMeans: "no chain row yet: unattended",
+    },
+    executor_kind: { type: "enum", nullable: false, values: EXECUTOR_KINDS },
+    host_unattended: { type: "boolean", nullable: false },
+    unattended_enabled: { type: "boolean", nullable: false },
+    grant_live: { type: "boolean", nullable: false },
+    expires_at: { type: "timestamp", nullable: true, nullMeans: "never expires (always NULL in M1)" },
+    lease_expires_at: {
+        type: "timestamp",
+        nullable: true,
+        nullMeans: "lease cleared by pause, kill, revoke or unlock",
+    },
+    lease_executor_id: { type: "uuid", nullable: true, nullMeans: "lease cleared" },
+    attach_until: { type: "timestamp", nullable: true, nullMeans: "no attach (P0b)" },
+    attach_live: { type: "boolean", nullable: true, nullMeans: "not applicable on a host executor" },
+    sealed: { type: "boolean", nullable: false },
+    outage_mode: { type: "enum", nullable: true, values: OUTAGE_MODES, nullMeans: "no opt-in: stop" },
+    charter_hash: { type: "string", nullable: true, nullMeans: "tracked: no charter" },
+    guard_state: { type: "object", nullable: true, nullMeans: "guard fault for a locked session" },
+    has_pointer: { type: "boolean", nullable: false },
+};
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const TS_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d{1,6})?(Z|[+-]\d{2}(:?\d{2})?)$/;
+/** One resolver field against its spec (pure; exported for its direct test). */
+export function fieldOk(spec, v) {
+    if (v === null)
+        return spec.nullable;
+    switch (spec.type) {
+        case "uuid":
+            return typeof v === "string" && UUID_RE.test(v);
+        case "string":
+            return typeof v === "string" && v.length > 0;
+        case "boolean":
+            return typeof v === "boolean";
+        case "integer":
+            return Number.isSafeInteger(v) && v >= 0;
+        case "timestamp":
+            return typeof v === "string" && TS_RE.test(v);
+        case "object":
+            return typeof v === "object" && !Array.isArray(v);
+        case "enum":
+            return typeof v === "string" && (spec.values ?? []).includes(v);
+    }
+}
+/**
+ * Validate a resolver answer. Returns the typed object, or null for any schema fault (missing
+ * field, wrong type, unknown enum, null on non-nullable, an illegal state_reason for the state, an
+ * effective state the derivation cannot produce, or a locked row with no charter).
+ */
+export function parseResolverDurable(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    for (const [field, spec] of Object.entries(RESOLVER_SCHEMA)) {
+        if (!(field in r) || !fieldOk(spec, r[field]))
+            return null;
+    }
+    const d = r;
+    // state and effective_state are already closed enums in RESOLVER_SCHEMA (checked above).
+    if (!isValidStateReason(d.state, d.state_reason))
+        return null;
+    if (!isEffectiveStateConsistent(d.state, d.state_reason, d.effective_state))
+        return null;
+    if (d.durable_mode === "locked" && d.charter_hash === null)
+        return null;
+    return d;
+}
+/** Whether a locked session's guard_state is usable (C08-R13): an object carrying numeric spend_usd. */
+export function guardStateOk(guard) {
+    return (guard !== null &&
+        typeof guard.spend_usd === "number" &&
+        Number.isFinite(guard.spend_usd) &&
+        guard.spend_usd >= 0);
+}
+/**
+ * Canonical guard_state fixtures for the case datasets (`$S1.GUARD_STATE_OK` / `$S1.GUARD_STATE_FAULT`,
+ * written as jsonb): OK passes guardStateOk; FAULT is a present object of the wrong shape (spend_usd
+ * not a number), the C08-R13 / claim check 7 fault, never null so it exercises the shape check.
+ */
+export const GUARD_STATE_OK = Object.freeze({ spend_usd: 0 });
+export const GUARD_STATE_FAULT = Object.freeze({
+    spend_usd: "unparseable",
+});
+/** Whether DURABLE_ADMIT is honoured: only the exact bytes "nofence" (NOFENCE_M1, r3 I01). */
+export function nofenceHonoured(durableAdmit) {
+    return durableAdmit === NOFENCE_ADMIT_VALUE;
+}
+/** The order the oracle reads (C11-R33). */
+export const ADMISSION_PRECEDENCE = [
+    "unknown_key",
+    "resolver_fault",
+    "revoked",
+    "identity",
+    "tracked",
+    "terminal",
+    "fenced",
+    "stopped",
+    "posture",
+];
+export const ADMISSION_STEP_CODE = {
+    resolver_fault: "durable_admission_unavailable",
+    revoked: "durable_key_revoked",
+    identity: "durable_identity_mismatch",
+    tracked: "durable_unlocked",
+    terminal: "durable_session_ended",
+    fenced: "durable_lease_fenced",
+    stopped: "durable_session_stopped",
+};
+/** Persisted or effective states that admit an attended chain (design §3.6 step 4 table). */
+export function attendedAdmits(effective, reason) {
+    switch (effective) {
+        case "running":
+        case "resuming":
+        case "detached":
+        case "parked":
+        case "suspended_grant_expired":
+            return true;
+        case "suspended":
+            return reason === "budget_reached" || reason === "grant_expired";
+        default:
+            return false;
+    }
+}
+/** The count_tokens route (wave-0 fix ruling 22), path without a query string, as the proxy sends it upstream. */
+export const COUNT_TOKENS_PATH = "/v1/messages/count_tokens";
+/** The same route at the gateway door (provider-prefixed). */
+export const GATEWAY_COUNT_TOKENS_PATH = "/anthropic/v1/messages/count_tokens";
+/** Whether a path (no query string) is the count_tokens route, bare or at the gateway door. */
+export function isCountTokensPath(path) {
+    return path === COUNT_TOKENS_PATH || path === GATEWAY_COUNT_TOKENS_PATH;
+}
+/** Whether a request skips the posture step: POST /v1/messages/count_tokens with no chain (ruling 22). */
+export function isUnchainedCountTokens(r) {
+    return r.method === "POST" && isCountTokensPath(r.path) && !r.chain;
+}
+export const RESOLVER_FAULT = "fault";
+/** The admission function. Total: every input maps to exactly one verdict; it never throws. */
+export function admit(input) {
+    const fenceSource = nofenceHonoured(input.durableAdmit) ? "nofence" : "fresh";
+    const posture = input.posture ?? "unattended";
+    if (input.resolver === null)
+        return { kind: "baseline_unknown_key", step: "unknown_key" };
+    const d = input.resolver === RESOLVER_FAULT ? null : parseResolverDurable(input.resolver);
+    const refuse = (step, extra = {}) => ({
+        kind: "refuse",
+        step,
+        code: ADMISSION_STEP_CODE[step],
+        posture,
+        fenceSource,
+        ...extra,
+    });
+    if (d === null)
+        return refuse("resolver_fault");
+    if (d.key_state === "revoked")
+        return refuse("revoked");
+    if (input.pinAgentId === null || input.pinAgentId !== d.agent_id)
+        return refuse("identity");
+    if (d.durable_mode === "tracked")
+        return refuse("tracked");
+    const ended = endedBody(d.effective_state, d.state_reason);
+    if (ended !== null)
+        return refuse("terminal", { state: ended.state, state_reason: ended.state_reason });
+    if (d.fenced && fenceSource === "fresh")
+        return refuse("fenced");
+    if (!attendedAdmits(d.effective_state, d.state_reason)) {
+        return refuse("stopped", {
+            state: d.effective_state,
+            state_reason: d.state_reason,
+        });
+    }
+    const guardFault = !guardStateOk(d.guard_state);
+    if (input.request !== undefined && isUnchainedCountTokens(input.request))
+        return {
+            kind: "admit_unchained",
+            step: "admit",
+            posture: null,
+            guardFault,
+            fenceSource,
+            helloTransition: false,
+            writes: false,
+        };
+    if (posture === "unattended") {
+        return {
+            kind: "refuse",
+            step: "posture",
+            code: guardFault ? "durable_guard_unavailable" : "durable_unattended_unavailable",
+            posture,
+            fenceSource,
+        };
+    }
+    return {
+        kind: "admit",
+        step: "admit",
+        posture: "attended",
+        guardFault,
+        fenceSource,
+        helloTransition: d.effective_state === "resuming",
+    };
+}
+// ---- Truth table (data the eval diffs against its own oracle) ---------------------------------
+export const ADMISSION_REQUEST_KINDS = ["standard", "count_tokens_unchained"];
+const REQUEST_OF = {
+    standard: { method: "POST", path: "/v1/messages", chain: false },
+    count_tokens_unchained: { method: "POST", path: COUNT_TOKENS_PATH, chain: false },
+};
+/** HTTP status of a truth-table outcome (null = the baseline unknown-key answer); throws on an unknown outcome. */
+export function admissionStatusOf(outcome) {
+    if (!Object.prototype.hasOwnProperty.call(STATUS, outcome))
+        throw new RangeError(`unknown admission outcome: ${outcome}`);
+    return STATUS[outcome];
+}
+const STATUS = {
+    admit: 200,
+    admit_unchained: 200,
+    baseline_unknown_key: null,
+    durable_admission_unavailable: 503,
+    durable_key_revoked: 401,
+    durable_identity_mismatch: 409,
+    durable_unlocked: 410,
+    durable_session_ended: 410,
+    durable_lease_fenced: 409,
+    durable_session_stopped: 423,
+    durable_guard_unavailable: 503,
+    durable_unattended_unavailable: 503,
+};
+const FIXTURE_AGENT = "00000000-0000-4000-8000-000000000001";
+const OTHER_AGENT = "00000000-0000-4000-8000-000000000002";
+/** A well-formed resolver object for a row of the truth table. */
+export function fixtureResolver(over = {}) {
+    return {
+        key_state: "active",
+        session_id: "00000000-0000-4000-8000-0000000000aa",
+        aip_session_id: "smolt-0000aaaa-c00000000000000000000000000000000",
+        durable_mode: "locked",
+        state: "running",
+        effective_state: "running",
+        state_reason: null,
+        epoch: 1,
+        fenced: false,
+        agent_id: FIXTURE_AGENT,
+        home_cell: "test",
+        posture: "attended",
+        executor_kind: "host",
+        host_unattended: true,
+        unattended_enabled: false,
+        grant_live: true,
+        expires_at: null,
+        lease_expires_at: "2026-10-16T12:00:00.000000Z",
+        lease_executor_id: "00000000-0000-4000-8000-0000000000ee",
+        attach_until: null,
+        attach_live: null,
+        sealed: true,
+        outage_mode: null,
+        charter_hash: "a".repeat(64),
+        guard_state: { spend_usd: 0 },
+        has_pointer: false,
+        ...over,
+    };
+}
+/** Every (persisted state, reason) pair, with its persisted effective state and the derived ones. */
+export function stateRows() {
+    const rows = [];
+    for (const state of SESSION_STATES) {
+        for (const reason of STATE_REASONS[state]) {
+            const candidates = [
+                "resuming",
+                "running",
+                "detached",
+                "parked",
+                "suspended",
+                "suspended_grant_expired",
+                "paused",
+                "completed",
+                "failed",
+                "killed",
+                "expired",
+            ];
+            for (const eff of candidates) {
+                if (isEffectiveStateConsistent(state, reason, eff))
+                    rows.push({ state, state_reason: reason, effective_state: eff });
+            }
+        }
+    }
+    return rows;
+}
+/** The full cross product over the admission dimensions, each row decided by `admit`. */
+export function admissionTruthTable() {
+    const out = [];
+    for (const s of stateRows()) {
+        for (const fenced of [false, true]) {
+            for (const key_state of KEY_STATES) {
+                for (const durable_mode of ["tracked", "locked"]) {
+                    for (const posture of POSTURES) {
+                        for (const guard_ok of [true, false]) {
+                            for (const nofence of [false, true]) {
+                                for (const pin of ["match", "absent", "mismatch"]) {
+                                    for (const request of ADMISSION_REQUEST_KINDS) {
+                                        const resolver = fixtureResolver({
+                                            ...s,
+                                            fenced,
+                                            key_state,
+                                            durable_mode,
+                                            posture,
+                                            guard_state: guard_ok ? { spend_usd: 0 } : null,
+                                        });
+                                        const v = admit({
+                                            resolver,
+                                            pinAgentId: pin === "match" ? FIXTURE_AGENT : pin === "mismatch" ? OTHER_AGENT : null,
+                                            posture,
+                                            durableAdmit: nofence ? NOFENCE_ADMIT_VALUE : undefined,
+                                            request: REQUEST_OF[request],
+                                        });
+                                        const outcome = v.kind === "refuse" ? v.code : v.kind;
+                                        out.push({
+                                            ...s,
+                                            fenced,
+                                            key_state,
+                                            durable_mode,
+                                            posture,
+                                            guard_ok,
+                                            nofence,
+                                            pin,
+                                            request,
+                                            hello_transition: v.kind === "admit" && v.helloTransition,
+                                            outcome,
+                                            status: admissionStatusOf(outcome),
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return out;
+}
+// ---- admit sweep digest (rulings 24.11, 24.11.1; C06-SWEEP-001/002) ----------------------------
+/** Golden vectors: a 3-dim toy sweep (every line) and C06 SWEEP_A (count, first 3 lines, digest). */
+export const ADMIT_SWEEP_VECTORS_PATH = "src/vectors/admit-sweep-vectors.json";
+/**
+ * The closed value set of each C06 sweep dimension (gen/fam-a.mjs SWEEP_A / SWEEP_B vocabulary).
+ * A null on a non-nullable resolver field reaches admit() as that null (a schema fault, 503).
+ * stored_state is "state" or "state:reason" ("null" for a NULL reason), state a SESSION_STATES value.
+ */
+export const ADMIT_SWEEP_VALUES = Object.freeze({
+    durable_mode: ["locked", "tracked", null],
+    key_state: ["active", "revoked", null],
+    fenced: [false, true, null],
+    pin: ["ok", "absent", "mismatch"],
+    chain_posture: ["attended", "unattended", null],
+    expires_past: [false, true],
+    grant_live: [true, false, null],
+    lease_expired: [false, true],
+    guard_state: ["ok", "fault"],
+    unattended_enabled: [false, true, null],
+    executor_kind: ["host", "fleet", "container", null],
+    outage_mode: [null, "stop", "continue"],
+    host_unattended: [true, false, null],
+    attach_live: [true, false, null],
+});
+/** The sweep clock: expires_past / lease_expired place the timestamp an hour before or after it. */
+const SWEEP_NOW = "2026-10-16T12:00:00.000000Z";
+const SWEEP_PAST = "2026-10-16T11:00:00.000000Z";
+const SWEEP_FUTURE = "2026-10-16T13:00:00.000000Z";
+function parseStoredState(v) {
+    if (typeof v !== "string")
+        throw new RangeError(`stored_state: unknown value ${JSON.stringify(v)}`);
+    const i = v.indexOf(":");
+    const state = i < 0 ? v : v.slice(0, i);
+    const reason = i < 0 || v.slice(i + 1) === "null" ? null : v.slice(i + 1);
+    if (!SESSION_STATES.includes(state))
+        throw new RangeError(`stored_state: unknown value ${JSON.stringify(v)}`);
+    return { state, state_reason: reason };
+}
+function checkSweep(sweep) {
+    if (!Array.isArray(sweep?.dims))
+        throw new TypeError(`admit sweep ${String(sweep?.name)}: dims must be an array of {name, values}`);
+    const seen = new Set();
+    for (const d of sweep.dims) {
+        const name = d?.name;
+        if (name !== "stored_state" && !Object.prototype.hasOwnProperty.call(ADMIT_SWEEP_VALUES, name))
+            throw new RangeError(`unknown sweep dimension ${String(name)}`);
+        if (seen.has(name))
+            throw new RangeError(`repeated sweep dimension ${name}`);
+        seen.add(name);
+        if (!Array.isArray(d.values) || d.values.length === 0)
+            throw new RangeError(`dimension ${name} must be a non-empty array`);
+        for (const x of d.values) {
+            if (name === "stored_state")
+                parseStoredState(x);
+            else if (!ADMIT_SWEEP_VALUES[name].includes(x))
+                throw new RangeError(`dimension ${name}: unknown value ${JSON.stringify(x)}`);
+        }
+    }
+}
+/** One tuple's verdict line: canonicalJson({code, state_reason, status}), absent fields null. */
+function sweepLine(t) {
+    const stored = parseStoredState(t.stored_state ?? "running");
+    const has = (k) => Object.prototype.hasOwnProperty.call(t, k);
+    const expires_at = t.expires_past === true ? SWEEP_PAST : null;
+    const lease_expires_at = t.lease_expired === true ? SWEEP_PAST : SWEEP_FUTURE;
+    const grant_live = has("grant_live") ? t.grant_live : true;
+    const effective_state = deriveEffectiveState({
+        state: stored.state,
+        state_reason: stored.state_reason,
+        expires_at,
+        grant_live: grant_live === true,
+        lease_expires_at,
+    }, Date.parse(SWEEP_NOW));
+    const posture = (has("chain_posture") ? t.chain_posture : "attended");
+    const over = {
+        state: stored.state,
+        state_reason: stored.state_reason,
+        effective_state,
+        expires_at,
+        lease_expires_at,
+        grant_live,
+        posture,
+        guard_state: t.guard_state === "fault" ? GUARD_STATE_FAULT : GUARD_STATE_OK,
+    };
+    for (const k of [
+        "durable_mode",
+        "key_state",
+        "fenced",
+        "unattended_enabled",
+        "executor_kind",
+        "outage_mode",
+        "host_unattended",
+        "attach_live",
+    ])
+        if (has(k))
+            over[k] = t[k];
+    const pin = t.pin ?? "ok";
+    const v = admit({
+        resolver: fixtureResolver(over),
+        pinAgentId: pin === "ok" ? FIXTURE_AGENT : pin === "mismatch" ? OTHER_AGENT : null,
+        posture,
+        durableAdmit: undefined,
+    });
+    const code = v.kind === "refuse" ? v.code : null;
+    const state_reason = v.kind === "refuse" ? (v.state_reason ?? null) : null;
+    const status = admissionStatusOf(v.kind === "refuse" ? v.code : v.kind);
+    return canonicalJson({ code, state_reason, status });
+}
+/**
+ * The sweep's verdict text: an odometer over `dims` (first entry slowest, values in array order),
+ * one sweepLine per tuple, each followed by LF (also after the last). Throws on a bad sweep.
+ */
+export function admitSweepText(sweep) {
+    checkSweep(sweep);
+    const dims = sweep.dims;
+    const idx = dims.map(() => 0);
+    const out = [];
+    for (;;) {
+        const t = {};
+        dims.forEach((d, j) => {
+            t[d.name] = d.values[idx[j]];
+        });
+        out.push(sweepLine(t), "\n");
+        let j = dims.length - 1;
+        while (j >= 0 && ++idx[j] === dims[j].values.length)
+            idx[j--] = 0;
+        if (j < 0)
+            return { tuples: out.length / 2, text: out.join("") };
+    }
+}
+/** verdicts_sha256: lowercase hex sha256 of the UTF-8 bytes of admitSweepText(sweep).text. */
+export async function admitSweepDigest(sweep) {
+    const { tuples, text } = admitSweepText(sweep);
+    return { tuples, verdicts_sha256: await sha256Hex(text) };
+}

package/dist/vendor/shared/durable-contract/arm.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The x-mnemom-durable-arm header grammar (design §4 I2; BACKBONE G1/C3; C06-R23, C13).
+ *
+ *   <ver>;hold=on|off;fence=on|off;posture=attended|unattended|none
+ *
+ * posture=none (wave-0 fix ruling 22.1) is the arm of an admit_unchained answer (a count_tokens
+ * with no chain): valid only on a count_tokens response (armValidFor); on any other path it is
+ * invalid and drops, and armForwards (no path) never forwards it.
+ *
+ * Frozen strictness (C13 OQ, "anchored exact grammar, fixed key order, lowercase, single header
+ * line"): ver is the literal `1`; keys in exactly this order; lowercase; no whitespace anywhere;
+ * no trailing `;`. A value carrying `,` (Node's join of duplicate header lines) is unparseable, so
+ * duplicate lines (conflicting or not) drop the response, as do a missing header and a trailer.
+ * The same bytes are the body of GET /internal/durable/arm.
+ */
+export declare const ARM_HEADER = "x-mnemom-durable-arm";
+export declare const ARM_VERSION = "1";
+export declare const ARM_ROUTE = "/internal/durable/arm";
+export interface ArmState {
+    hold: "on" | "off";
+    fence: "on" | "off";
+    posture: "attended" | "unattended" | "none";
+}
+export declare const ARM_RE: RegExp;
+export declare function formatArm(a: ArmState): string;
+/** Parse one header value; null when absent or not in the exact grammar. */
+export declare function parseArm(value: string | null | undefined): ArmState | null;
+/**
+ * The executor/proxy decision (C3, C13): forward only a parseable header, and never an unattended
+ * one without hold=on and fence=on. In M1 hold is always off, so every unattended answer drops.
+ */
+export declare function armForwards(value: string | null | undefined): boolean;
+/** The arm of a response on `path` (no query string), or null when absent, unparseable, or posture=none off count_tokens. */
+export declare function armValidFor(path: string, value: string | null | undefined): ArmState | null;
+/** The C3 decision on `path`: posture=none forwards on count_tokens only; every other arm as armForwards. */
+export declare function armForwardsFor(path: string, value: string | null | undefined): boolean;
+/** The M1 gateway's arm: hold=off always (no hold code), fence=off only for the exact bytes `nofence`. */
+export declare function m1Arm(durableAdmit: string | undefined, posture: ArmState["posture"]): ArmState;
+/** The proxy's local drop answer when the arm check fails (frozen template, zero upstream bytes). */
+export declare const ARM_DROP_STATUS = 502;
+export declare const ARM_DROP_HEADERS: Readonly<{
+    "content-type": "application/json";
+    "x-should-retry": "false";
+}>;
+export declare const ARM_DROP_BODY = "{\"type\":\"error\",\"error\":{\"type\":\"api_error\",\"message\":\"durable arm check failed: response dropped\"}}";
+/** Golden vectors: header value -> parse result (null = drop). */
+export declare const ARM_VECTORS: readonly {
+    value: string | null;
+    parsed: ArmState | null;
+    forwards: boolean;
+}[];