@mnemom/mnemom 0.17.33 → 0.17.34-next.2

package/dist/vendor/shared/durable-contract/freeze-record.d.ts

@@ -0,0 +1,787 @@
+/**
+ * The freeze record: every frozen value by name, as the eval runner reads `$S1.<NAME>` and
+ * `$S1.<NAME>.<path>` (CASE-DSL section 5.2). Built from the modules, never restated.
+ *
+ *   FREEZE_RECORD      scalars (string, number, boolean, or null while a calibration is pending)
+ *   FREEZE_STRUCTURED  frozen lists, tables and maps (JSON values)
+ *   FREEZE_ALIASES     the DSL spellings datasets already use, each naming one canonical entry
+ *
+ * A name lives in exactly one of the three. Names the datasets cite that are not S1 values (lane
+ * URLs, installed versions, baselines, module paths of other lanes) are not here on purpose: they
+ * are lane or case bindings.
+ */
+export declare const FREEZE_RECORD: Readonly<{
+    DURABLE_CONTRACT_VERSION: "1.0.0";
+    DURABLE_SCHEMA_VERSION: 1;
+    LEASE_SECONDS_DEFAULT: 90;
+    LEASE_SECONDS_MIN: 5;
+    LEASE_SECONDS_MAX: 90;
+    RESUME_RESET_SECONDS_DEFAULT: 600;
+    RESUME_RESET_SECONDS_MIN: 5;
+    RESUME_RESET_SECONDS_MAX: 600;
+    HEARTBEAT_DIVISOR: 3;
+    RESPAWN_FAILURES_SUSPEND_AT: 3;
+    RESPAWN_CONCURRENCY: 4;
+    LEASE_KEY_TOUCH_SECONDS: 60;
+    STALE_SERVE_M1: false;
+    NOFENCE_M1: true;
+    NOFENCE_ADMIT_VALUE: "nofence";
+    RESOLVER_TIMEOUT_MS: 2000;
+    ARM_PROBE_TIMEOUT_MS: 2000;
+    ARM_PROBE_TTL_S: 10;
+    PROTECTION_CACHE_S: 300;
+    GRANT_TTL_S: number;
+    GRANT_WARNING_S: number;
+    CLEAN_EXIT_MAX: 3;
+    CLEAN_EXIT_WINDOW_S: 600;
+    EXECUTOR_POLL_S: 10;
+    EXECUTOR_LIVE_S: number;
+    ATTACH_WAIT_S: number;
+    CLAIM_BACKOFF_BASE_S: 2;
+    CLAIM_BACKOFF_MAX_S: 60;
+    CLAIM_BACKOFF_JITTER: 0.2;
+    CLAIM_UNAVAILABLE_SURFACE_N: 5;
+    TRACKED_STOP_GRACE_S: 5;
+    SEAT_MAX_ATTEMPTS_NONRETRY: 1;
+    TURN_WAIT_MS: 500;
+    TURN_HEADER_MAX_LEN: 8192;
+    TURN_ENTRIES_MAX: 32;
+    SWEEP_MAX_ROWS: 200;
+    SWEEP_BATCH_SIZE: 50;
+    SWEEP_TIME_BUDGET_MS: 10000;
+    SWEEP_CRON: "*/5 * * * *";
+    PER_SESSION_BUDGET_LIMIT_USD: 20;
+    CONTRACT_STATEMENT_MAX_CHARS: 4000;
+    CONTRACT_JSON_MAX_BYTES: 8192;
+    EVENT_DETAIL_MAX_CHARS: 280;
+    CONTRACT_PURGE_AFTER_S: number;
+    DEVICE_STEP_FRESHNESS_S: 300;
+    STEP_UP_BLOB_FIELD: "su";
+    /** test_integrity baseline runs and flaky retry cap (ruling 31.1). */
+    TEST_FLAKY_RUNS: 3;
+    /** durable_approvals target CHECK text A1 mirrors (ruling 32.12). */
+    DURABLE_APPROVALS_TARGET_CHECK: string;
+    OWNER_MUTATION_APPROVAL_TTL_S: number;
+    DEVICE_POLL_INTERVAL_S: 5;
+    RISK_LINE_VERSION: 1;
+    RISK_LINE_VERSION_TEXT: string;
+    RENDERER_VERSION: 1;
+    PLUGIN_HASH_RECIPE_VERSION: 1;
+    ADMIT_SWEEP_VECTORS_PATH: "src/vectors/admit-sweep-vectors.json";
+    FINGERPRINT_HEX_CHARS: 12;
+    PLUGIN_DIR: "plugins/mnemom";
+    PLUGIN_MANIFEST_PATH: "plugins/integrity-manifest.json";
+    EVENT_PREIMAGE_VERSION: 1;
+    /** The calibrated names (CALIBRATED_PENDING) carry the DSL spelling; L_SPAWN / T_HELLO_S are aliases. */
+    L_spawn: number | null;
+    T_hello: number | null;
+    L_SPAWN_MIN: 20;
+    L_SPAWN_MAX: 90;
+    API_CELL_ID_VECTORS_SHA256: "0fe7b8e6583c18e534e6021701d58260be3538073701c0ce87173b9810748cb8";
+    LEASE_KEY_PREFIX: "mnm_ds_";
+    ARM_HEADER: "x-mnemom-durable-arm";
+    ARM_VERSION: "1";
+    GENESIS_PREV_HASH: string;
+    GATEWAY_EVENTS_ROUTE: "/internal/durable/events";
+    CHARTER_PREIMAGE_VERSION: 1;
+    SESSION_NAME_MAX_CHARS: 64;
+    RISK_LINE_TEXT: "Here the session acts with your account's access on this machine. Never-rules and holds are tripwires, not walls; a container is the recommended home for work on its own.";
+    TEST_MODE_ENV: "DURABLE_SESSIONS_TEST_MODE";
+    DEVICE_VERIFY_AAL_DEFAULT: "off";
+    SPAN_DURABLE_ADMISSION: "durable_admission";
+    SPAN_DURABLE_CLAIM: "durable_claim";
+    SPAN_DURABLE_SEAT_HELLO: "durable_seat_hello";
+    SPAN_DURABLE_SWEEP: "durable_sweep";
+    SPAN_DEVICE_VERIFY_WOULD_REFUSE: "device_verify_would_refuse";
+    SWEEP_LOG_NAME: "durable_sweep_run";
+    OWNER_MUTATION_CLIENT_ID: "mnemom-durable-owner-mutation";
+    EXECUTOR_STATE_DIR: ".mnemom/durable";
+    EXECUTOR_STATE_FILE: ".mnemom/durable/executor-state.json";
+    EXECUTOR_STATE_DIR_MODE: 448;
+    EXECUTOR_STATE_FILE_MODE: 384;
+    OLD_ROUTE_BRANCH: "amend";
+    OLD_ROUTE_REFRESH: "lazy";
+    U05_FIXTURE_CHECK: "12";
+    U05_CHECK_TEXT_RESPAWN_FAILED: string;
+    U05_CHECK_TEXT_ATTESTATION_FAILED: string;
+    RISK_SENTENCE_ID_HOST: "laptop";
+    SPAN_DURABLE_ENROLLMENT: "durable_enrollment";
+    ENROLL_POLL_ERROR_STATUS: 400;
+    /** Ruling 19: every refusal exits 1 (with or without --json); usage errors and the gate exit 2. */
+    CLI_REFUSAL_EXIT: 1;
+    CLI_USAGE_EXIT: 2;
+    EXECUTOR_KEY_HEADER: "X-Mnemom-Api-Key";
+    INTERNAL_KEY_HEADER: "X-Internal-Key";
+    CHARTER_SEALED_AT_PATTERN: string;
+    DURABLE_POOL_CLAIM_FLAG: "DURABLE_POOL_CLAIM";
+    OIDC_EXCHANGE_AUDIENCE: "mnemom-executor";
+    LIVE_LEASE_CAP_MIN: 1;
+    LIVE_LEASE_CAP_MAX: 1000;
+    ORG_CAP_LOCK_PREFIX: "durable_org_cap:";
+    DEFAULT_LEASE_CAP_ENV: "DURABLE_DEFAULT_LEASE_CAP";
+    DISPATCH_SESSION_CID_PREFIX: "dispatch-";
+    DISPATCH_SESSION_NAME_PREFIX: "job-";
+    READY_SESSIONS_LIMIT_MIN: 1;
+    READY_SESSIONS_LIMIT_MAX: 50;
+    READY_USER_TEXT: "waiting for a runner";
+    RUNNER_FAILED_PHASE_PATTERN: string;
+    AGENT_SESSIONS_READY_CHECK: string;
+    AGENT_SESSIONS_WAIT_PARKED_CHECK: string;
+    AGENT_EXECUTORS_SCOPE_CHECK: "scope IN ('user','org')";
+}>;
+export type FreezeName = keyof typeof FREEZE_RECORD;
+export declare const FREEZE_STRUCTURED: Readonly<{
+    /** Every frozen error code, keyed by itself (`$S1.CODES.durable_lease_fenced` is the code). */
+    CODES: {
+        readonly [x: string]: string;
+    };
+    /** durable_claim_outcome values, keyed by themselves. */
+    CLAIM_OUTCOME: {
+        readonly unavailable: "unavailable";
+        readonly acquired: "acquired";
+        readonly reclaimed: "reclaimed";
+        readonly epoch_bump: "epoch_bump";
+        readonly needs_key: "needs_key";
+        readonly lost_race: "lost_race";
+        readonly ineligible: "ineligible";
+        readonly rate_limited: "rate_limited";
+    };
+    /**
+     * The C10-R0 (i)-(k) journal refusals by role, as C10 cases cite them
+     * (`$S1.JOURNAL_CODES.unknown_kind`). No "not homed" entry: S1 freezes no such code.
+     */
+    JOURNAL_CODES: Readonly<{
+        readonly append_conflict: "durable_append_conflict";
+        readonly idempotency_conflict: "durable_idempotency_conflict";
+        readonly unknown_kind: "durable_unknown_kind";
+        readonly writer_class: "durable_writer_refused";
+        readonly refs_invalid: "durable_refs_invalid";
+    }>;
+    EXECUTOR_WRITABLE_KINDS: readonly ["executor.spawned", "session.waiting", "executor.turn_continued"];
+    GATEWAY_WRITABLE_KINDS: readonly ["lease.zombie_call", "identity.mismatch", "guard.unavailable"];
+    EVENT_PREIMAGE_FIELDS: readonly ["v", "session_id", "seq", "ts", "kind", "epoch", "idempotency_key", "principal_ref", "detail_sha256", "refs_sha256", "prev_hash"];
+    CHARTER_PREIMAGE_FIELDS: readonly ["v", "session_id", "version", "prev_hash", "charter", "created_at"];
+    CHARTER_HASH_EXCLUDED_COLUMNS: readonly ["hash", "contract_ciphertext", "wrapped_data_key", "cipher_key_ref", "contract_purge_after", "signature"];
+    PIN_KEYS: readonly ["card_content_hash", "policy_engine_major"];
+    M1_SPAN_NAMES: readonly ["durable_admission", "durable_claim", "durable_seat_hello", "durable_sweep", "device_verify_would_refuse", "durable_enrollment"];
+    SPAN_ATTRIBUTE_KEYS: {
+        readonly durable_admission: readonly import("./telemetry.js").DurableAttributeKey[];
+        readonly durable_claim: readonly import("./telemetry.js").DurableAttributeKey[];
+        readonly durable_seat_hello: readonly import("./telemetry.js").DurableAttributeKey[];
+        readonly durable_sweep: readonly import("./telemetry.js").DurableAttributeKey[];
+        readonly device_verify_would_refuse: readonly import("./telemetry.js").DurableAttributeKey[];
+        readonly durable_enrollment: readonly import("./telemetry.js").DurableAttributeKey[];
+    };
+    ATTRIBUTE_VALUES: {
+        readonly durable_refusal: readonly ["none", "unknown_key", "durable_admission_unavailable", "durable_key_revoked", "durable_identity_mismatch", "durable_unlocked", "durable_session_ended", "durable_lease_fenced", "durable_session_stopped", "durable_guard_unavailable", "durable_unattended_unavailable", "goal_contract_enforce_refused", "durable_route_refused", "durable_executor_key_refused", "contract_mismatch"];
+        readonly durable_posture: readonly ["attended", "unattended"];
+        readonly durable_door: readonly ["match", "mismatch", "unmapped"];
+        readonly durable_effective_state: readonly ["resuming", "running", "detached", "parked", "suspended", "suspended_grant_expired", "paused", "completed", "failed", "killed", "expired", "ready", "unknown"];
+        readonly durable_fence_source: readonly ["fresh", "nofence"];
+        readonly durable_charter_source: readonly ["pg", "rehydrated", "lru", "kv", "unavailable", "none"];
+        readonly durable_arm: readonly ["anchor", "key_gate"];
+        readonly durable_never_hold: readonly ["off"];
+        readonly durable_guard: readonly ["ok", "unavailable", "not_applicable"];
+        readonly durable_claim_outcome: readonly ["acquired", "reclaimed", "epoch_bump", "needs_key", "lost_race", "ineligible", "unavailable", "rate_limited"];
+        readonly durable_claim_cause: readonly ["schema", "arm_probe", "entitlement_lookup", "protection_probe", "guard", "lease_cap_config"];
+        readonly durable_hello_outcome: readonly ["accepted", "repeat", "late", "refused"];
+        readonly outcome: readonly ["ok", "error", "disabled"];
+        readonly budget_exhausted: readonly ["true", "false"];
+        readonly lag_bucket: readonly ["none", "<1m", "1-5m", "5-30m", ">30m"];
+        readonly device_verify_would_refuse: readonly ["true"];
+        readonly device_verify_reason: readonly ["aal", "freshness"];
+        readonly device_verify_assurance: readonly ["aal1", "aal2"];
+        readonly durable_enrollment_outcome: readonly ["started", "approved", "refused_aal", "refused_stale", "refused_not_self", "refused_machine", "refused_entitlement", "denied", "expired", "consumed", "replay"];
+    };
+    M1_TABLES: readonly ["agent_sessions", "durable_lease_keys", "agent_session_charters", "agent_session_events", "durable_event_kinds", "agent_session_chains", "agent_executors", "agent_durable_profiles", "durable_cell_state", "durable_org_policy", "durable_user_policy", "durable_approvals", "durable_approval_attestations"];
+    M1_COLUMNS: {
+        readonly agent_sessions: readonly string[];
+        readonly durable_lease_keys: readonly string[];
+        readonly agent_session_charters: readonly string[];
+        readonly agent_session_events: readonly string[];
+        readonly durable_event_kinds: readonly string[];
+        readonly agent_session_chains: readonly string[];
+        readonly agent_executors: readonly string[];
+        readonly agent_durable_profiles: readonly string[];
+        readonly durable_cell_state: readonly string[];
+        readonly durable_org_policy: readonly string[];
+        readonly durable_user_policy: readonly string[];
+        readonly durable_approvals: readonly string[];
+        readonly durable_approval_attestations: readonly string[];
+    };
+    M1_FUNCTIONS: readonly ["resolve_durable_session_key", "agent_durable_only", "durable_schema_version", "durable_attest_begin", "durable_claim_lease", "durable_heartbeat", "durable_seat_hello", "durable_seat_exit", "durable_fail_session", "durable_release_lease", "durable_append_event", "durable_fence_check", "durable_guard_add", "durable_revoke_executor", "durable_sweep", "durable_kill_agent_sessions", "durable_agent_killed"];
+    M1_ARBITERS: readonly import("./schema.js").Arbiter[];
+    EXECUTE_EXCEPTIONS: readonly string[];
+    /** durable_approvals subjects and target rule (ruling 32.12). */
+    DURABLE_APPROVAL_SUBJECTS: readonly ["unlock", "unpause_contained", "grant_renewal", "budget_raise", "enrollment", "question"];
+    DURABLE_APPROVAL_SESSIONLESS_SUBJECTS: readonly ["grant_renewal", "enrollment"];
+    FIX_LINES: {
+        readonly budget_reached: import("./fixlines.js").FixEntry;
+        readonly above_limit_raise: import("./fixlines.js").FixEntry;
+        readonly budget_at_limit: import("./fixlines.js").FixEntry;
+        readonly agent_killed: import("./fixlines.js").FixEntry;
+        readonly session_ended: import("./fixlines.js").FixEntry;
+        readonly session_transcript_missing: import("./fixlines.js").FixEntry;
+        readonly paused_owner: import("./fixlines.js").FixEntry;
+        readonly agent_contained: import("./fixlines.js").FixEntry;
+        readonly respawn_failed: import("./fixlines.js").FixEntry;
+        readonly attestation_failed: import("./fixlines.js").FixEntry;
+        readonly approval_expired: import("./fixlines.js").FixEntry;
+        readonly approval_denied: import("./fixlines.js").FixEntry;
+        readonly attestation_cwd_missing: import("./fixlines.js").FixEntry;
+        readonly attestation_cwd_not_toplevel: import("./fixlines.js").FixEntry;
+        readonly grant_expired: import("./fixlines.js").FixEntry;
+        readonly grant_warning: import("./fixlines.js").FixEntry;
+        readonly identity_mismatch: import("./fixlines.js").FixEntry;
+        readonly stopped_no_m1_remedy: import("./fixlines.js").FixEntry;
+        readonly account_balance: import("./fixlines.js").FixEntry;
+        readonly budget_while_paused: import("./fixlines.js").FixEntry;
+        readonly guard: import("./fixlines.js").FixEntry;
+        readonly seat_wait_timeout: import("./fixlines.js").FixEntry;
+        readonly daemon_not_running: import("./fixlines.js").FixEntry;
+        readonly daemon_idle: import("./fixlines.js").FixEntry;
+        readonly unreachable_home: import("./fixlines.js").FixEntry;
+        readonly session_homed_elsewhere: import("./fixlines.js").FixEntry;
+        readonly session_homed_elsewhere_stale: import("./fixlines.js").FixEntry;
+        readonly resume_live: import("./fixlines.js").FixEntry;
+        readonly lock_not_entitled: import("./fixlines.js").FixEntry;
+        readonly lock_mfa_required: import("./fixlines.js").FixEntry;
+        readonly lock_branch_unprotected: import("./fixlines.js").FixEntry;
+        readonly lock_agent_shared: import("./fixlines.js").FixEntry;
+        readonly no_executor: import("./fixlines.js").FixEntry;
+        readonly tool_classes: import("./fixlines.js").FixEntry;
+        readonly remote_control: import("./fixlines.js").FixEntry;
+        readonly cwd_subdirectory: import("./fixlines.js").FixEntry;
+        readonly cwd_not_git: import("./fixlines.js").FixEntry;
+        readonly cwd_symlink_transcript: import("./fixlines.js").FixEntry;
+        readonly launch_spec_change: import("./fixlines.js").FixEntry;
+        readonly launch_spec_change_sole_unlock: import("./fixlines.js").FixEntry;
+        readonly durable_only_agent: import("./fixlines.js").FixEntry;
+        readonly durable_only_held: import("./fixlines.js").FixEntry;
+        readonly not_owner_admin: import("./fixlines.js").FixEntry;
+        readonly not_owner_info: import("./fixlines.js").FixEntry;
+        readonly tracked_pause: import("./fixlines.js").FixEntry;
+        readonly tracked_resume: import("./fixlines.js").FixEntry;
+        readonly tracked_budget: import("./fixlines.js").FixEntry;
+        readonly device_step_login: import("./fixlines.js").FixEntry;
+        readonly containment_login: import("./fixlines.js").FixEntry;
+        readonly integrity: import("./fixlines.js").FixEntry;
+        readonly unattended: import("./fixlines.js").FixEntry;
+    };
+    RESERVED_SESSION_VERBS: readonly ["sessions", "show", "setup", "doctor", "config", "list", "claim", "move", "export", "help", "invite", "lock", "done", "kill", "pause", "resume", "amend", "host", "containment"];
+    CANONICAL_CELL_IDS: readonly ["test", "us-1", "us-2"];
+    KEY_EFFECT_OF_TRANSITION: {
+        readonly pause: "fence";
+        readonly complete: "fence";
+        readonly kill: "fence";
+        readonly expire: "fence";
+        readonly fail: "fence";
+        readonly containment: "fence";
+        readonly unlock: "revoke";
+        readonly claim_supersede: "revoke";
+        readonly executor_revoke: "revoke";
+        readonly respawn_failed_suspend: "revoke";
+    };
+    REVOKING_TRANSITIONS: readonly ["claim_supersede", "executor_revoke", "unlock", "respawn_failed_suspend"];
+    TEST_MODE_GUARD_LISTS: {
+        readonly gateway: readonly string[];
+        readonly api: readonly string[];
+        readonly cli: readonly string[];
+    };
+    TEST_MODE_MODULE: {
+        readonly gateway: string;
+        readonly api: string;
+        readonly cli: string;
+    };
+    /** The C17-R18 integrity allowlist (ruling 31(2)). */
+    TEST_ALLOWLIST: readonly import("./test-mode.js").TestAllowlistEntry[];
+    /** M1 CLI command paths and long options (ruling 32.01; E4 D1 product_missing). */
+    M1_CLI_SURFACE: readonly import("./cli-surface.js").CliSurfaceEntry[];
+    /** Pre-M1 `mnemom agent` launcher sub-verbs, first word only (ruling 32.35). */
+    PRE_M1_LAUNCHER_SUBVERBS: readonly ["config", "doctor", "help", "setup", "slack"];
+    /** The exports a pure_fn step may call (ruling 32.34; CASE-DSL rule 30). */
+    PURE_FN_EXPORTS: readonly import("./pure-fn.js").PureFnExport[];
+    /** M1 exports a pure_fn step may name before they land (ruling 33.01; E4 detector D4). */
+    PURE_FN_M1_PENDING: readonly import("./pure-fn.js").PureFnPending[];
+    /** The resolver per-field schema (C06-R15). */
+    RESOLVER_SCHEMA: Readonly<Record<string, import("./admission.js").FieldSpec>>;
+    /** guard_state fixtures (jsonb) the datasets write: passes guardStateOk / the shape fault. */
+    GUARD_STATE_OK: Readonly<{
+        spend_usd: number;
+    }>;
+    GUARD_STATE_FAULT: Readonly<{
+        spend_usd: string;
+    }>;
+    /** Executor and internal routes: `$S1.ROUTES.<name>.path`, or `.pre` + id + `.post`. */
+    ROUTES: Readonly<{
+        exec_enroll: import("./routes.js").FixedRoute;
+        exec_enroll_poll: import("./routes.js").FixedRoute;
+        exec_list: import("./routes.js").FixedRoute;
+        exec_revoke: import("./routes.js").ScopedRoute;
+        exec_renew: import("./routes.js").ScopedRoute;
+        exec_sessions: import("./routes.js").FixedRoute;
+        exec_attest: import("./routes.js").ScopedRoute;
+        exec_claim: import("./routes.js").ScopedRoute;
+        exec_hello: import("./routes.js").ScopedRoute;
+        exec_release: import("./routes.js").ScopedRoute;
+        exec_append: import("./routes.js").ScopedRoute;
+        exec_seat_exit: import("./routes.js").ScopedRoute;
+        exec_fail: import("./routes.js").ScopedRoute;
+        exec_heartbeat: import("./routes.js").FixedRoute;
+        exec_ready_list: import("./routes.js").FixedRoute;
+        exec_oidc_exchange: import("./routes.js").FixedRoute;
+        own_lock: import("./routes.js").ScopedRoute;
+        own_unlock: import("./routes.js").ScopedRoute;
+        own_pause: import("./routes.js").ScopedRoute;
+        own_resume: import("./routes.js").ScopedRoute;
+        own_complete: import("./routes.js").ScopedRoute;
+        own_kill: import("./routes.js").ScopedRoute;
+        own_amend: import("./routes.js").ScopedRoute;
+        own_fail: import("./routes.js").ScopedRoute;
+        own_events: import("./routes.js").ScopedRoute;
+        int_events: import("./routes.js").FixedRoute;
+        int_arm: import("./routes.js").FixedRoute;
+        int_sweep: import("./routes.js").FixedRoute;
+        int_charter: import("./routes.js").FixedRoute;
+    }>;
+    /**
+     * The closed list of freeze-record names allowed to be null (ruling 1.03): null until ruling 34.17.
+     * Empty since the ruling 34.17 calibration set L_spawn and T_hello.
+     */
+    CALIBRATED_PENDING: readonly [];
+    TERMINAL_EVENT_KINDS: readonly ["session.completed", "session.failed", "session.killed", "session.expired"];
+    SECRET_SCOPE: Readonly<{
+        secrets: readonly ["owner_jwt", "owner_refresh_token", "owner_api_key", "lease_key", "executor_key", "enroll_poll_secret"];
+        encodings: readonly ["raw", "base64", "base64url", "hex", "percent", "json_escaped"];
+        surfaces: readonly ["host_files", "process_env", "process_argv", "tmux_global_env", "tmux_session_env", "tmux_scrollback", "tmpdir_files", "seat_transcripts", "durable_spans", "durable_logs"];
+        allow: readonly Readonly<{
+            secret: import("./secret-scope.js").SecretKind;
+            path: ".mnemom/durable/executor-state.json";
+        }>[];
+        excluded_paths: readonly string[];
+    }>;
+    ENROLL_POLL_ERRORS: readonly ["authorization_pending", "slow_down", "access_denied", "expired_token", "already_consumed"];
+    DEVICE_PAGE_MARKERS: readonly ["data-subject-kind", "data-subject-runtime", "data-runtime-self-declared", "data-risk-sentence-id", "data-risk-line-version"];
+    STOPPED_FIX: Readonly<{
+        readonly paused: Readonly<{
+            null: "stopped_no_m1_remedy";
+            owner: "paused_owner";
+            agent_contained: "agent_contained";
+            breakglass: "stopped_no_m1_remedy";
+        }>;
+        readonly suspended: Readonly<{
+            budget_reached: "budget_reached";
+            enforce_refused: "stopped_no_m1_remedy";
+            charter_breach: "stopped_no_m1_remedy";
+            account_balance: "account_balance";
+            identity_mismatch: "identity_mismatch";
+            grant_expired: "grant_expired";
+            card_drift: "stopped_no_m1_remedy";
+            attestation_failed: "attestation_failed";
+            owner_departed: "stopped_no_m1_remedy";
+            respawn_failed: "respawn_failed";
+            approval_expired: "approval_expired";
+            approval_denied: "approval_denied";
+        }>;
+        readonly suspended_grant_expired: Readonly<{
+            "*": "grant_expired";
+        }>;
+    }>;
+    STOPPED_REASON_TEXT: Readonly<{
+        respawn_failed: "the seat failed to start <n> times in a row";
+        attestation_failed: "the claim check <check> failed";
+    }>;
+    /** executor-state.json: closed {version: 1, executor_id, executor_key, nonce, boot_id} (24.14). */
+    EXECUTOR_STATE_SCHEMA: Readonly<{
+        readonly version: {
+            readonly type: "integer";
+            readonly nullable: false;
+        };
+        readonly executor_id: {
+            readonly type: "uuid";
+            readonly nullable: false;
+        };
+        readonly executor_key: {
+            readonly type: "string";
+            readonly nullable: false;
+        };
+        readonly nonce: {
+            readonly type: "string";
+            readonly nullable: false;
+        };
+        readonly boot_id: {
+            readonly type: "string";
+            readonly nullable: false;
+        };
+    }>;
+    /** Heartbeat request entry / response entry keys; match results by session_id (24.15). */
+    HEARTBEAT_ENTRY_FIELDS: readonly ["session_id", "epoch", "spawn_id"];
+    HEARTBEAT_RESULT_FIELDS: readonly ["session_id", "extended", "reason", "lease_expires_at"];
+    /** GET exec_sessions body: only sessions[] and each item's uuid id are frozen (24.16). */
+    EXEC_SESSIONS_RESPONSE: Readonly<{
+        sessions: Readonly<{
+            item: Readonly<{
+                id: "uuid";
+                agent_id: "string";
+                state: "session_state";
+                state_reason: "state_reason|null";
+                lease_epoch: "integer";
+                lease_expires_at: "timestamp|null";
+                held_here: "boolean";
+                cc_session_id: "string|null";
+                cwd: "string|null";
+                spec: "object|null";
+            }>;
+        }>;
+        grant_expired: Readonly<{
+            sessions: "empty";
+            grant_expires_at: "timestamp";
+            grant_expired: true;
+        }>;
+    }>;
+    /** Owner session view: cc_session_id present, string or null; the view is otherwise open (#1085). */
+    OWNER_SESSION_VIEW_FIELDS: Readonly<{
+        cc_session_id: "string|null";
+    }>;
+    /** Claim refusal details (24.22.1): lost_race reasons, ineligible reasons and their presence rules. */
+    CLAIM_LOST_RACE_REASONS: readonly ["stale_tokens", "lease_live", "org_lease_cap"];
+    CLAIM_INELIGIBLE_REASONS: readonly ["bad_nonce", "bad_attest_failure", "not_found", "not_locked", "not_home", "not_owner", "executor_revoked", "executor_breakglass", "terminal", "expired", "cell_unmapped", "agent_killed", "paused", "agent_contained", "suspended", "profile", "respawn_failed", "attestation_failed", "identity_mismatch", "budget_reached", "grant_expired", "not_pool_member", "waiting"];
+    CLAIM_INELIGIBLE_DETAILS: Readonly<{
+        readonly bad_nonce: {};
+        readonly bad_attest_failure: {};
+        readonly not_found: {};
+        readonly not_locked: {};
+        readonly not_home: {};
+        readonly not_owner: {};
+        readonly executor_revoked: {};
+        readonly executor_breakglass: {};
+        readonly terminal: {
+            readonly state: "terminal_state";
+        };
+        readonly expired: {};
+        readonly cell_unmapped: {};
+        readonly agent_killed: {};
+        readonly paused: {
+            readonly state_reason: "paused";
+        };
+        readonly agent_contained: {
+            readonly state_reason: "agent_contained";
+        };
+        readonly suspended: {
+            readonly state_reason: "suspended";
+        };
+        readonly profile: {};
+        readonly respawn_failed: {
+            readonly state_reason: "reason";
+        };
+        readonly attestation_failed: {
+            readonly state_reason: "reason";
+            readonly check: "attestation_check";
+        };
+        readonly identity_mismatch: {
+            readonly state_reason: "reason";
+            readonly check: "attestation_check";
+        };
+        readonly budget_reached: {
+            readonly state_reason: "reason";
+            readonly check: "attestation_check";
+        };
+        readonly grant_expired: {
+            readonly state_reason: "reason";
+            readonly check: "attestation_check";
+        };
+        readonly not_pool_member: {};
+        readonly waiting: {
+            readonly wait_reason: "parked_only";
+        };
+    }>;
+    /** durable_refs_invalid details.reason for a refused park (34.06.3.1). */
+    PARK_REFUSAL_REASONS: readonly ["approval_not_open", "approval_wrong_session", "approval_wrong_subject", "wait_ref_shape"];
+    /** host status --json, closed: top level, seats[] and sessions[] (rulings 26, 24.12). */
+    HOST_STATUS_JSON: Readonly<{
+        installed: {
+            type: "boolean";
+            nullable: false;
+        };
+        loaded: {
+            type: "boolean";
+            nullable: false;
+        };
+        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"];
+        };
+        nonce_fingerprint: {
+            type: "fingerprint";
+            nullable: true;
+        };
+        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;
+                        };
+                    }>;
+                };
+            }>;
+        };
+    }>;
+    /** host status --json for no state file, enrolled with no nonce, uninstalled with a state file (26.1). */
+    HOST_STATUS_JSON_VECTORS: Readonly<{
+        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_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 [];
+        }>;
+        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 [];
+        }>;
+    }>;
+    /** C06 sweep dimension vocabulary admitSweepDigest accepts; dims arrive ordered (24.11.1). */
+    ADMIT_SWEEP_VALUES: Readonly<Record<string, readonly unknown[]>>;
+    /** Pack-time plugin integrity manifest, closed (ruling 25). */
+    PLUGIN_MANIFEST_SCHEMA: Readonly<{
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["recipe_version", "plugin_dir", "files", "dir_hash"];
+        readonly properties: {
+            readonly recipe_version: {
+                readonly const: 1;
+            };
+            readonly plugin_dir: {
+                readonly const: "plugins/mnemom";
+            };
+            readonly files: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["path", "sha256"];
+                    readonly properties: {
+                        readonly path: {
+                            readonly type: "string";
+                            readonly pattern: "^(?!.*(?:^|/)\\.{1,2}(?:/|$))[^/\\\\\\u0000]+(?:/[^/\\\\\\u0000]+)*$";
+                        };
+                        readonly sha256: {
+                            readonly type: "string";
+                            readonly pattern: "^[0-9a-f]{64}$";
+                        };
+                    };
+                };
+            };
+            readonly dir_hash: {
+                readonly type: "string";
+                readonly pattern: "^[0-9a-f]{64}$";
+            };
+        };
+    }>;
+    PLUGIN_MANIFEST_FAILURES: readonly ["missing", "unparseable", "recipe", "dir_hash", "not_regular", "added", "removed", "edited"];
+    HEARTBEAT_REQUEST_KEYS: readonly ["nonce", "entries"];
+    CLAIM_BODY_KEYS: readonly ["nonce", "tokens", "new_key"];
+    CHARTER_BY_HASH_BODY_KEYS: readonly ["session_id", "charter_hash"];
+    CHARTER_BY_HASH_RESPONSE: Readonly<{
+        conversation_id: "string";
+        version: "integer>=1";
+        sealed_at: "utc_timestamp";
+        contract: Readonly<{
+            statement: "string";
+            requirements: "string[]";
+            allowed_paths: "string[]";
+            forbidden_paths: "string[]";
+        }>;
+    }>;
+    GATEWAY_EVENTS_BODY_KEYS: readonly ["session_id", "kind", "epoch", "idempotency_key", "refs"];
+    READY_CAUSES: readonly ["dispatched", "lease_expired", "wait_cleared"];
+    WAIT_REASONS: readonly ["approval", "moving", "mnemom_unavailable", "ci", "question", "budget"];
+    PARKED_ONLY_WAIT_REASONS: readonly ["ci", "question", "budget"];
+    WAIT_REF_KEYS: Readonly<{
+        readonly ci: readonly ["repo_id", "head_sha"];
+        readonly question: readonly ["approval_id"];
+        readonly budget: readonly ["approval_id"];
+    }>;
+    CLEAR_WAIT_OUTCOMES: readonly ["cleared", "stale_ref", "already_clear"];
+    EXECUTOR_SCOPES: readonly ["user", "org"];
+    ORG_SCOPE_EXECUTOR_KINDS: readonly ["container", "fleet"];
+    OIDC_EXCHANGE_REFUSALS: readonly ["bad_issuer", "repo_not_enrolled", "ref_not_allowed", "pool_flag_off"];
+    ORG_POLICY_LIMIT_KEYS: readonly ["per_session_budget_usd", "live_lease_cap"];
+    POOL_CLAIM_FIELDS: readonly ["contract_sha256", "contract_version", "cap"];
+    CREATE_READY_SESSION_REFUSALS: readonly ["no_dispatch_agent", "seal_not_found", "cell_unmapped", "charter_mismatch"];
+    CREATE_READY_SESSION_OUTCOMES: readonly ["created", "existing", "refused"];
+    CREATE_READY_SESSION_ANSWERS: Readonly<{
+        readonly created: readonly ["outcome", "session_id"];
+        readonly existing: readonly ["outcome", "session_id"];
+        readonly refused: readonly ["outcome", "reason"];
+    }>;
+    JOURNAL_APPROVAL_KINDS: readonly ["approval.resolved", "approval.consumed"];
+    RUNNER_OUTCOMES: readonly ["done", "no_job", "failed", "refused"];
+    RUNNER_OUTCOME_FIELDS: readonly ["v", "outcome", "session_id", "lease_epoch", "contract_sha256", "contract_version", "merge_strategy", "pr_url", "reason"];
+    RUNNER_EXIT_CODES: Readonly<{
+        readonly done: 0;
+        readonly no_job: 0;
+        readonly failed: 1;
+        readonly usage: 2;
+        readonly refused: 3;
+    }>;
+    RUNNER_FAILED_REASONS: readonly ["pr_open_failed"];
+    RUNNER_REFUSED_REASONS: readonly ["bundle_too_large", "bundle_malformed", "bundle_wrong_typ", "bundle_schema", "bundle_unknown_key", "bundle_unusable_key", "bundle_retired_key", "bundle_bad_signature", "bundle_code_digest_mismatch", "bundle_not_yet_valid", "bundle_expired", "bundle_binding_mismatch", "bundle_unavailable", "job_unavailable", "contract_bad_sha", "contract_too_large", "contract_sha_mismatch", "contract_not_a_contract", "contract_mismatch_unrecoverable", "claim_needs_key", "claim_ineligible", "claim_unavailable", "lease_lost", "executor_revoked", "executor_unauthorized", "oidc_bad_issuer", "oidc_repo_not_enrolled", "oidc_ref_not_allowed", "oidc_pool_flag_off", "oidc_unavailable", "api_unavailable"];
+    RUNNER_OPEN_MODE_TOLERATED: readonly ["bundle_unavailable", "job_unavailable", "api_unavailable"];
+    RUNNER_MERGE_STRATEGIES: readonly ["external", "merge_on_green"];
+}>;
+export type StructuredName = keyof typeof FREEZE_STRUCTURED;
+/** DSL spellings already in the case files (CASE-DSL section 5.2 names $S1.L_spawn), each to one canonical name. */
+export declare const FREEZE_ALIASES: Readonly<{
+    readonly L_SPAWN: "L_spawn";
+    readonly T_HELLO_S: "T_hello";
+    readonly PER_SESSION_BUDGET_LIMIT: "PER_SESSION_BUDGET_LIMIT_USD";
+    readonly PER_SESSION_LIMIT: "PER_SESSION_BUDGET_LIMIT_USD";
+    readonly DEFAULT_LEASE_SECONDS: "LEASE_SECONDS_DEFAULT";
+    readonly STATEMENT_MAX: "CONTRACT_STATEMENT_MAX_CHARS";
+    readonly GATEWAY_EVENTS_PATH: "GATEWAY_EVENTS_ROUTE";
+    readonly SPAN_NAME_HELLO: "SPAN_DURABLE_SEAT_HELLO";
+    readonly DEVICE_VERIFY_WOULD_REFUSE_SPAN: "SPAN_DEVICE_VERIFY_WOULD_REFUSE";
+    readonly SPAN_NAMES_M1: "M1_SPAN_NAMES";
+    readonly SPAN_KEYS_M1: "SPAN_ATTRIBUTE_KEYS";
+    readonly ARBITERS: "M1_ARBITERS";
+    readonly FUNCTION_EXECUTE_EXCEPTIONS: "EXECUTE_EXCEPTIONS";
+    readonly TEST_MODE_GUARD_URLS: "TEST_MODE_GUARD_LISTS";
+}>;
+/** True when `name` is a frozen S1 name (canonical or alias), set or not. */
+export declare function s1Has(name: string): boolean;
+/**
+ * True when `name` (canonical or alias) is a CALIBRATED_PENDING name whose value is still null: the
+ * G4 resolution check counts it RESOLVED_PENDING and the runner reports a case reading it NOT_RUN
+ * (s1_uncalibrated:<name>), never substituting a default (ruling 1.03).
+ */
+export declare function s1Pending(name: string): boolean;
+/**
+ * The ruling 1.03 test behind s1Pending: `canonical` is listed in `pending` and still null in
+ * `record`. Kept apart so the rule stays tested while CALIBRATED_PENDING is empty (ruling 34.17).
+ */
+export declare function pendingIn(record: Readonly<Record<string, unknown>>, pending: readonly string[], canonical: string): boolean;
+/**
+ * `record[canonical]` for s1Value: throws on an unknown name or an unset (null) value, naming the
+ * spelling the case used. Kept apart for the same reason as pendingIn.
+ */
+export declare function recordValueIn(record: Readonly<Record<string, unknown>>, canonical: string, name: string): unknown;
+/** `$S1.<NAME>` lookup for the case runner; throws on an unknown name or an unset (null) value. */
+export declare function s1Value(name: string): unknown;
+/** `$S1.<NAME>.<path>` lookup: `.field` segments and `[n]` indexes; throws on any missing segment. */
+export declare function s1Resolve(ref: string): unknown;