@mnemom/mnemom 0.17.33 → 0.17.34-next.2

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

@@ -0,0 +1,133 @@
+// GENERATED from shared/durable-contract/src/arm.ts by cli/scripts/sync-durable-contract.mjs; do not edit.
+/**
+ * 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.
+ */
+import { NOFENCE_ADMIT_VALUE } from "./constants.js";
+import { isCountTokensPath } from "./admission.js";
+export const ARM_HEADER = "x-mnemom-durable-arm";
+export const ARM_VERSION = "1";
+export const ARM_ROUTE = "/internal/durable/arm";
+export const ARM_RE = /^1;hold=(on|off);fence=(on|off);posture=(attended|unattended|none)$/;
+export function formatArm(a) {
+    return `${ARM_VERSION};hold=${a.hold};fence=${a.fence};posture=${a.posture}`;
+}
+/** Parse one header value; null when absent or not in the exact grammar. */
+export function parseArm(value) {
+    if (typeof value !== "string")
+        return null;
+    const m = ARM_RE.exec(value);
+    if (!m)
+        return null;
+    return {
+        hold: m[1],
+        fence: m[2],
+        posture: m[3],
+    };
+}
+/**
+ * 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 function armForwards(value) {
+    const a = parseArm(value);
+    if (a === null || a.posture === "none")
+        return false;
+    return a.posture === "attended" || (a.hold === "on" && a.fence === "on");
+}
+/** The arm of a response on `path` (no query string), or null when absent, unparseable, or posture=none off count_tokens. */
+export function armValidFor(path, value) {
+    const a = parseArm(value);
+    if (a === null || (a.posture === "none" && !isCountTokensPath(path)))
+        return null;
+    return a;
+}
+/** The C3 decision on `path`: posture=none forwards on count_tokens only; every other arm as armForwards. */
+export function armForwardsFor(path, value) {
+    const a = armValidFor(path, value);
+    if (a === null)
+        return false;
+    return a.posture === "none" || armForwards(value);
+}
+/** The M1 gateway's arm: hold=off always (no hold code), fence=off only for the exact bytes `nofence`. */
+export function m1Arm(durableAdmit, posture) {
+    return { hold: "off", fence: durableAdmit === NOFENCE_ADMIT_VALUE ? "off" : "on", posture };
+}
+/** The proxy's local drop answer when the arm check fails (frozen template, zero upstream bytes). */
+export const ARM_DROP_STATUS = 502;
+export const ARM_DROP_HEADERS = Object.freeze({
+    "content-type": "application/json",
+    "x-should-retry": "false",
+});
+export 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 const ARM_VECTORS = [
+    {
+        value: "1;hold=off;fence=on;posture=attended",
+        parsed: { hold: "off", fence: "on", posture: "attended" },
+        forwards: true,
+    },
+    {
+        value: "1;hold=off;fence=off;posture=attended",
+        parsed: { hold: "off", fence: "off", posture: "attended" },
+        forwards: true,
+    },
+    {
+        value: "1;hold=on;fence=on;posture=unattended",
+        parsed: { hold: "on", fence: "on", posture: "unattended" },
+        forwards: true,
+    },
+    {
+        value: "1;hold=off;fence=on;posture=unattended",
+        parsed: { hold: "off", fence: "on", posture: "unattended" },
+        forwards: false,
+    },
+    {
+        value: "1;hold=on;fence=off;posture=unattended",
+        parsed: { hold: "on", fence: "off", posture: "unattended" },
+        forwards: false,
+    },
+    {
+        value: "1;hold=on;fence=on;posture=attended",
+        parsed: { hold: "on", fence: "on", posture: "attended" },
+        forwards: true,
+    },
+    {
+        value: "1;hold=off;fence=on;posture=none",
+        parsed: { hold: "off", fence: "on", posture: "none" },
+        forwards: false,
+    },
+    { value: null, parsed: null, forwards: false },
+    { value: "", parsed: null, forwards: false },
+    { value: "v1;hold=off;fence=on;posture=attended", parsed: null, forwards: false },
+    { value: "2;hold=off;fence=on;posture=attended", parsed: null, forwards: false },
+    { value: "1;fence=on;hold=off;posture=attended", parsed: null, forwards: false },
+    { value: "1;HOLD=off;fence=on;posture=attended", parsed: null, forwards: false },
+    { value: "1;hold=off;fence=on;posture=Attended", parsed: null, forwards: false },
+    { value: "1; hold=off;fence=on;posture=attended", parsed: null, forwards: false },
+    { value: "1;hold=off;fence=on;posture=attended ", parsed: null, forwards: false },
+    { value: "1;hold=off;fence=on;posture=attended;", parsed: null, forwards: false },
+    { value: "1;hold=off;fence=on", parsed: null, forwards: false },
+    {
+        value: "1;hold=off;fence=on;posture=attended, 1;hold=off;fence=on;posture=attended",
+        parsed: null,
+        forwards: false,
+    },
+    {
+        value: "1;hold=on;fence=on;posture=attended, 1;hold=off;fence=off;posture=unattended",
+        parsed: null,
+        forwards: false,
+    },
+    { value: "1;hold=maybe;fence=on;posture=attended", parsed: null, forwards: false },
+];

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

@@ -0,0 +1,29 @@
+/**
+ * The one canonical JSON and the hash primitives every durable writer uses (C10-R08, C14-R08,
+ * C18-R02). WebCrypto only, so the same code runs in Workers, Node >= 20 and the CLI.
+ *
+ * canonicalJson is RFC 8785 (JCS) for the JSON value space the durable contract uses:
+ *  - object keys sorted by UTF-16 code units (Array.prototype.sort's default order, which is what
+ *    RFC 8785 section 3.2.3 specifies), no whitespace;
+ *  - strings and numbers serialised exactly as JSON.stringify does (RFC 8785 section 3.2.2 is
+ *    ECMAScript Number.prototype.toString, which JSON.stringify uses);
+ *  - an object member whose value is undefined is omitted (as JSON.stringify and the npm
+ *    `canonicalize` package do), so `{a: undefined}` hashes like `{}`. Writers that need "absent
+ *    equals null" (the journal preimage, C10-R08) normalise before calling this;
+ *  - non-finite numbers, bigint, functions and symbols throw TypeError (they have no JSON form).
+ * It differs from the api's attestation canonicalJson only on those edge cases (that one emits
+ * `"k":undefined` for an undefined member); for plain JSON data the bytes are identical.
+ */
+export declare function canonicalJson(value: unknown): string;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function utf8(text: string): Uint8Array;
+/** sha256 of a UTF-8 string or raw bytes, lowercase hex (64 chars). */
+export declare function sha256Hex(input: string | Uint8Array): Promise<string>;
+/** HMAC-SHA256(key, message), lowercase hex. Used for principal_ref (C10-R15). */
+export declare function hmacSha256Hex(key: Uint8Array, message: string): Promise<string>;
+/** RFC 4648 section 5 base64url, no padding. */
+export declare function base64urlEncode(bytes: Uint8Array): string;
+/** Strict base64url decode: null on any character outside the alphabet or an impossible length. */
+export declare function base64urlDecode(text: string): Uint8Array | null;
+export declare const HEX64_RE: RegExp;
+export declare const UUID_RE: RegExp;

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

@@ -0,0 +1,98 @@
+// GENERATED from shared/durable-contract/src/canonical.ts by cli/scripts/sync-durable-contract.mjs; do not edit.
+/**
+ * The one canonical JSON and the hash primitives every durable writer uses (C10-R08, C14-R08,
+ * C18-R02). WebCrypto only, so the same code runs in Workers, Node >= 20 and the CLI.
+ *
+ * canonicalJson is RFC 8785 (JCS) for the JSON value space the durable contract uses:
+ *  - object keys sorted by UTF-16 code units (Array.prototype.sort's default order, which is what
+ *    RFC 8785 section 3.2.3 specifies), no whitespace;
+ *  - strings and numbers serialised exactly as JSON.stringify does (RFC 8785 section 3.2.2 is
+ *    ECMAScript Number.prototype.toString, which JSON.stringify uses);
+ *  - an object member whose value is undefined is omitted (as JSON.stringify and the npm
+ *    `canonicalize` package do), so `{a: undefined}` hashes like `{}`. Writers that need "absent
+ *    equals null" (the journal preimage, C10-R08) normalise before calling this;
+ *  - non-finite numbers, bigint, functions and symbols throw TypeError (they have no JSON form).
+ * It differs from the api's attestation canonicalJson only on those edge cases (that one emits
+ * `"k":undefined` for an undefined member); for plain JSON data the bytes are identical.
+ */
+export function canonicalJson(value) {
+    return encode(value);
+}
+function encode(value) {
+    if (value === null)
+        return "null";
+    switch (typeof value) {
+        case "boolean":
+            return value ? "true" : "false";
+        case "string":
+            return JSON.stringify(value);
+        case "number":
+            if (!Number.isFinite(value))
+                throw new TypeError("canonicalJson: non-finite number");
+            return JSON.stringify(value);
+        case "object":
+            return Array.isArray(value)
+                ? encodeArray(value)
+                : encodeObject(value);
+        default:
+            throw new TypeError(`canonicalJson: unsupported type ${typeof value}`);
+    }
+}
+function encodeArray(items) {
+    // An undefined array slot has no JSON form other than null (JSON.stringify's rule).
+    return `[${items.map((v) => (v === undefined ? "null" : encode(v))).join(",")}]`;
+}
+function encodeObject(obj) {
+    const parts = [];
+    for (const key of Object.keys(obj).sort()) {
+        const v = obj[key];
+        if (v === undefined)
+            continue;
+        parts.push(`${JSON.stringify(key)}:${encode(v)}`);
+    }
+    return `{${parts.join(",")}}`;
+}
+const HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+export function bytesToHex(bytes) {
+    let out = "";
+    for (const b of bytes)
+        out += HEX[b];
+    return out;
+}
+export function utf8(text) {
+    return new TextEncoder().encode(text);
+}
+/** sha256 of a UTF-8 string or raw bytes, lowercase hex (64 chars). */
+export async function sha256Hex(input) {
+    const bytes = typeof input === "string" ? utf8(input) : input;
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return bytesToHex(new Uint8Array(digest));
+}
+/** HMAC-SHA256(key, message), lowercase hex. Used for principal_ref (C10-R15). */
+export async function hmacSha256Hex(key, message) {
+    const k = await crypto.subtle.importKey("raw", key, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const sig = await crypto.subtle.sign("HMAC", k, utf8(message));
+    return bytesToHex(new Uint8Array(sig));
+}
+/** RFC 4648 section 5 base64url, no padding. */
+export function base64urlEncode(bytes) {
+    let bin = "";
+    for (const b of bytes)
+        bin += String.fromCharCode(b);
+    return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+const B64URL_RE = /^[A-Za-z0-9_-]*$/;
+/** Strict base64url decode: null on any character outside the alphabet or an impossible length. */
+export function base64urlDecode(text) {
+    if (!B64URL_RE.test(text) || text.length % 4 === 1)
+        return null;
+    const padded = text.replace(/-/g, "+").replace(/_/g, "/") + "===".slice(0, (4 - (text.length % 4)) % 4);
+    const bin = atob(padded);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        out[i] = bin.charCodeAt(i);
+    // Reject non-canonical encodings (trailing bits set), so one byte string has one text form.
+    return base64urlEncode(out) === text ? out : null;
+}
+export const HEX64_RE = /^[0-9a-f]{64}$/;
+export const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;

package/dist/vendor/shared/durable-contract/cell-id.d.ts

@@ -0,0 +1,22 @@
+/**
+ * normalizeCellId: a byte-faithful port of api src/cells/cell-id.ts (BACKBONE S1; design §0.5).
+ * CELL_ID -> test | us-1 | us-2; anything else, unset or a non-string -> null, and a null is never
+ * coerced into a default (the caller fails closed: 503 durable_cell_unmapped at create, door
+ * `unmapped` at the gateway). Whitespace is String.prototype.trim.
+ *
+ * The api table is NOT rewired to this one (it sits on the billing path); the two agree through
+ * the golden vectors in ./vectors/cell-id-vectors.json, a byte copy of the api file whose sha256
+ * is API_CELL_ID_VECTORS_SHA256. This file is also the gateway's pinned copy: the api file's
+ * _comment says "the gateway pins a copy of this file", and on this base the gateway has none, so
+ * the gateway imports it from here.
+ */
+export declare const CANONICAL_CELL_IDS: readonly ["test", "us-1", "us-2"];
+export type CanonicalCellId = (typeof CANONICAL_CELL_IDS)[number];
+/** sha256 of api src/cells/cell-id-vectors.json at api origin/main (c9e1dae8). */
+export declare const API_CELL_ID_VECTORS_SHA256 = "0fe7b8e6583c18e534e6021701d58260be3538073701c0ce87173b9810748cb8";
+export declare const CELL_ID_VECTORS_PATH = "src/vectors/cell-id-vectors.json";
+export declare function normalizeCellId(cellId: unknown): CanonicalCellId | null;
+/** The gateway door attribute (design §3.6 step 3); diagnostic only in M1. */
+export declare const DOOR_VALUES: readonly ["match", "mismatch", "unmapped"];
+export type Door = (typeof DOOR_VALUES)[number];
+export declare function doorOf(envCellId: unknown, homeCell: CanonicalCellId): Door;

package/dist/vendor/shared/durable-contract/cell-id.js

@@ -0,0 +1,38 @@
+// GENERATED from shared/durable-contract/src/cell-id.ts by cli/scripts/sync-durable-contract.mjs; do not edit.
+/**
+ * normalizeCellId: a byte-faithful port of api src/cells/cell-id.ts (BACKBONE S1; design §0.5).
+ * CELL_ID -> test | us-1 | us-2; anything else, unset or a non-string -> null, and a null is never
+ * coerced into a default (the caller fails closed: 503 durable_cell_unmapped at create, door
+ * `unmapped` at the gateway). Whitespace is String.prototype.trim.
+ *
+ * The api table is NOT rewired to this one (it sits on the billing path); the two agree through
+ * the golden vectors in ./vectors/cell-id-vectors.json, a byte copy of the api file whose sha256
+ * is API_CELL_ID_VECTORS_SHA256. This file is also the gateway's pinned copy: the api file's
+ * _comment says "the gateway pins a copy of this file", and on this base the gateway has none, so
+ * the gateway imports it from here.
+ */
+export const CANONICAL_CELL_IDS = ["test", "us-1", "us-2"];
+/** sha256 of api src/cells/cell-id-vectors.json at api origin/main (c9e1dae8). */
+export const API_CELL_ID_VECTORS_SHA256 = "0fe7b8e6583c18e534e6021701d58260be3538073701c0ce87173b9810748cb8";
+export const CELL_ID_VECTORS_PATH = "src/vectors/cell-id-vectors.json";
+export function normalizeCellId(cellId) {
+    switch (typeof cellId === "string" ? cellId.trim() : "") {
+        case "test":
+            return "test";
+        case "us-1":
+            return "us-1";
+        case "us-prod":
+        case "us-2-prod":
+            return "us-2";
+        default:
+            return null;
+    }
+}
+/** The gateway door attribute (design §3.6 step 3); diagnostic only in M1. */
+export const DOOR_VALUES = ["match", "mismatch", "unmapped"];
+export function doorOf(envCellId, homeCell) {
+    const here = normalizeCellId(envCellId);
+    if (here === null)
+        return "unmapped";
+    return here === homeCell ? "match" : "mismatch";
+}

package/dist/vendor/shared/durable-contract/cli-output.d.ts

@@ -0,0 +1,342 @@
+/**
+ * `mnemom agent <verb> --json` on a refused durable verb (wave-0 fix ruling 19). stdout carries
+ * exactly one JSON document, the ruling-14 error envelope: an API or gateway refusal body is passed
+ * through unchanged; a refusal the CLI decides itself (S1 codes with status null, such as
+ * session_homed_elsewhere or durable_cwd_not_root) is built here in the same shape, with the code's
+ * closed fields and the rendered fix line in details.fix. stderr is the same with or without
+ * --json (refusal line, fix line, machine code), and nothing reaches stdout on a refusal without it.
+ */
+import { type ClaimUnavailableCause, type DurableCode, type DurableErrorBody, type DurableErrorDetails } from "./codes.js";
+import { TRANSCRIPT_GUARD_MODES } from "./paths.js";
+import { type SessionState } from "./states.js";
+/** Exit status of every refused or failed `mnemom agent` verb, with or without --json. */
+export declare const CLI_REFUSAL_EXIT = 1;
+/** Exit status of a usage error and of the experimental gate (C04-R01, ruling 9); never a refusal. */
+export declare const CLI_USAGE_EXIT = 2;
+/**
+ * The --json stdout document for a CLI-side refusal: durableErrorBody with details always present
+ * and carrying the rendered fix line. Throws on a missing or empty fix, and on a field outside `fix`
+ * and the code's closed fields.
+ */
+export declare function cliRefusalJson<C extends DurableCode>(code: C, message: string, details: DurableErrorDetails & {
+    readonly fix: string;
+}): DurableErrorBody<C>;
+/** Hex characters a fingerprint keeps: the sha256 prefix host status prints (ruling 26; C12-R23). */
+export declare const FINGERPRINT_HEX_CHARS = 12;
+/** A secret's fingerprint: the first FINGERPRINT_HEX_CHARS lowercase hex characters of its sha256. */
+export declare function fingerprint(value: string): Promise<string>;
+/** The host status field type tokens that carry no nested spec. */
+type HostStatusScalarType = "boolean" | "string" | "uuid" | "integer" | "positive_integer" | "pid" | "port" | "hex64" | "fingerprint";
+/**
+ * A host status field: a type token and nullability, discriminated by type so an enum always
+ * carries its values, an array its item schema and an object its fields.
+ */
+export type HostStatusField = {
+    readonly type: HostStatusScalarType;
+    readonly nullable: boolean;
+} | {
+    readonly type: "enum";
+    readonly nullable: boolean;
+    readonly values: readonly string[];
+} | {
+    readonly type: "array";
+    readonly nullable: boolean;
+    readonly item: Readonly<Record<string, HostStatusField>>;
+} | {
+    readonly type: "object";
+    readonly nullable: boolean;
+    readonly fields: Readonly<Record<string, HostStatusField>>;
+};
+/**
+ * One seat row (rulings 26, 26.1; C12-R23): pid is the pane pid; state is the session's stored state
+ * (the DB probe); spec_path is the local launch-spec file the daemon spawned the seat from. Every
+ * field describes the seat at call time, so a value that does not exist yet (mid-spawn) or any more
+ * (claude exited) is null: proxy_pid until the seat proxy runs, proxy_port until it listens,
+ * socket_path until the socket exists, claude_pid while claude is not running. A non-null
+ * proxy_port implies a non-null proxy_pid.
+ */
+export declare const HOST_STATUS_SEAT: Readonly<{
+    session_id: {
+        type: "uuid";
+        nullable: false;
+    };
+    epoch: {
+        type: "integer";
+        nullable: false;
+    };
+    spawn_id: {
+        type: "uuid";
+        nullable: false;
+    };
+    state: {
+        type: "enum";
+        nullable: false;
+        values: readonly ["resuming", "running", "detached", "parked", "suspended", "paused", "completed", "failed", "killed", "expired", "ready"];
+    };
+    pid: {
+        type: "pid";
+        nullable: false;
+    };
+    proxy_pid: {
+        type: "pid";
+        nullable: true;
+    };
+    claude_pid: {
+        type: "pid";
+        nullable: true;
+    };
+    proxy_port: {
+        type: "port";
+        nullable: true;
+    };
+    socket_path: {
+        type: "string";
+        nullable: true;
+    };
+    spec_path: {
+        type: "string";
+        nullable: false;
+    };
+    spec_sha256: {
+        type: "hex64";
+        nullable: false;
+    };
+}>;
+/**
+ * One session entry (ruling 24.12, Wassim option 1; C12-R31): claim_unavailable is the last
+ * durable_claim_unavailable cause and the count of consecutive unavailable claims, or null when the
+ * session's last claim was not unavailable.
+ */
+export declare const HOST_STATUS_SESSION: Readonly<{
+    session_id: {
+        type: "uuid";
+        nullable: false;
+    };
+    claim_unavailable: {
+        type: "object";
+        nullable: true;
+        fields: Readonly<{
+            cause: {
+                type: "enum";
+                nullable: false;
+                values: readonly ["schema", "arm_probe", "entitlement_lookup", "protection_probe", "guard", "lease_cap_config"];
+            };
+            consecutive: {
+                type: "positive_integer";
+                nullable: false;
+            };
+        }>;
+    };
+}>;
+/**
+ * `mnemom agent host status --json` (ruling 26, Wassim option 1; C12-R04, R23, R31): one closed
+ * document, key order as frozen. The nonce and key appear only as fingerprints, never raw.
+ */
+export declare const HOST_STATUS_JSON: Readonly<{
+    installed: {
+        type: "boolean";
+        nullable: false;
+    };
+    loaded: {
+        type: "boolean";
+        nullable: false;
+    };
+    /** The host instance name (launchd label and tmux socket name), from config/env (C12-R04). */
+    instance: {
+        type: "string";
+        nullable: false;
+    };
+    daemon_pid: {
+        type: "pid";
+        nullable: true;
+    };
+    lock_holder_pid: {
+        type: "pid";
+        nullable: true;
+    };
+    lock_path: {
+        type: "string";
+        nullable: false;
+    };
+    transcript_guard: {
+        type: "enum";
+        nullable: false;
+        values: readonly ["link", "copy"];
+    };
+    /** The stored boot-bound nonce's fingerprint; null with no state file or no nonce yet (26.1). */
+    nonce_fingerprint: {
+        type: "fingerprint";
+        nullable: true;
+    };
+    /** The executor key's fingerprint; null with no readable state file, whatever installed says (26.1). */
+    key_fingerprint: {
+        type: "fingerprint";
+        nullable: true;
+    };
+    seats: {
+        type: "array";
+        nullable: false;
+        item: Readonly<{
+            session_id: {
+                type: "uuid";
+                nullable: false;
+            };
+            epoch: {
+                type: "integer";
+                nullable: false;
+            };
+            spawn_id: {
+                type: "uuid";
+                nullable: false;
+            };
+            state: {
+                type: "enum";
+                nullable: false;
+                values: readonly ["resuming", "running", "detached", "parked", "suspended", "paused", "completed", "failed", "killed", "expired", "ready"];
+            };
+            pid: {
+                type: "pid";
+                nullable: false;
+            };
+            proxy_pid: {
+                type: "pid";
+                nullable: true;
+            };
+            claude_pid: {
+                type: "pid";
+                nullable: true;
+            };
+            proxy_port: {
+                type: "port";
+                nullable: true;
+            };
+            socket_path: {
+                type: "string";
+                nullable: true;
+            };
+            spec_path: {
+                type: "string";
+                nullable: false;
+            };
+            spec_sha256: {
+                type: "hex64";
+                nullable: false;
+            };
+        }>;
+    };
+    sessions: {
+        type: "array";
+        nullable: false;
+        item: Readonly<{
+            session_id: {
+                type: "uuid";
+                nullable: false;
+            };
+            claim_unavailable: {
+                type: "object";
+                nullable: true;
+                fields: Readonly<{
+                    cause: {
+                        type: "enum";
+                        nullable: false;
+                        values: readonly ["schema", "arm_probe", "entitlement_lookup", "protection_probe", "guard", "lease_cap_config"];
+                    };
+                    consecutive: {
+                        type: "positive_integer";
+                        nullable: false;
+                    };
+                }>;
+            };
+        }>;
+    };
+}>;
+export interface HostStatusSeat {
+    readonly session_id: string;
+    readonly epoch: number;
+    readonly spawn_id: string;
+    readonly state: SessionState;
+    readonly pid: number;
+    readonly proxy_pid: number | null;
+    readonly claude_pid: number | null;
+    readonly proxy_port: number | null;
+    readonly socket_path: string | null;
+    readonly spec_path: string;
+    readonly spec_sha256: string;
+}
+export interface HostStatusSession {
+    readonly session_id: string;
+    readonly claim_unavailable: {
+        readonly cause: ClaimUnavailableCause;
+        readonly consecutive: number;
+    } | null;
+}
+export interface HostStatusJson {
+    readonly installed: boolean;
+    readonly loaded: boolean;
+    readonly instance: string;
+    readonly daemon_pid: number | null;
+    readonly lock_holder_pid: number | null;
+    readonly lock_path: string;
+    readonly transcript_guard: (typeof TRANSCRIPT_GUARD_MODES)[number];
+    readonly nonce_fingerprint: string | null;
+    readonly key_fingerprint: string | null;
+    readonly seats: readonly HostStatusSeat[];
+    readonly sessions: readonly HostStatusSession[];
+}
+/**
+ * Host status documents for the three enrollment states ruling 26.1 names. The fingerprints are of
+ * "vector-executor-key" (4b27142c3a90) and "vector-nonce" (55ccea8c7f0d).
+ */
+export declare const HOST_STATUS_JSON_VECTORS: Readonly<{
+    /** Not enrolled: no state file, so neither fingerprint exists. */
+    no_state_file: Readonly<{
+        installed: false;
+        loaded: false;
+        daemon_pid: null;
+        lock_holder_pid: null;
+        nonce_fingerprint: null;
+        key_fingerprint: null;
+        instance: "ai.mnemom.agent-host.default";
+        lock_path: "/Users/dev/.mnemom/durable/host.lock";
+        transcript_guard: "link";
+        seats: readonly [];
+        sessions: readonly [];
+    }>;
+    /** Enrolled and running, before the daemon has written its first nonce. */
+    enrolled_no_nonce: Readonly<{
+        nonce_fingerprint: null;
+        key_fingerprint: "4b27142c3a90";
+        installed: true;
+        loaded: true;
+        instance: "ai.mnemom.agent-host.default";
+        daemon_pid: 4000;
+        lock_holder_pid: 4000;
+        lock_path: "/Users/dev/.mnemom/durable/host.lock";
+        transcript_guard: "link";
+        seats: readonly [];
+        sessions: readonly [];
+    }>;
+    /** Uninstalled: the state file and enrollment stay (C12 F6-05, R24). */
+    not_installed_with_state_file: Readonly<{
+        installed: false;
+        loaded: false;
+        daemon_pid: null;
+        lock_holder_pid: null;
+        nonce_fingerprint: "55ccea8c7f0d";
+        key_fingerprint: "4b27142c3a90";
+        instance: "ai.mnemom.agent-host.default";
+        lock_path: "/Users/dev/.mnemom/durable/host.lock";
+        transcript_guard: "link";
+        seats: readonly [];
+        sessions: readonly [];
+    }>;
+}>;
+/**
+ * True for exactly the frozen document: HOST_STATUS_JSON closed at every level. Given the raw
+ * `secrets`, also false when either appears in any key or string value (only fingerprints may).
+ */
+export declare function hostStatusJsonOk(v: unknown, secrets?: {
+    readonly nonce: string;
+    readonly key: string;
+}): v is HostStatusJson;
+export {};