@mnemom/mnemom 0.17.33 → 0.17.34-next.2

package/dist/vendor/shared/durable-contract/executor-state.js

@@ -0,0 +1,32 @@
+// GENERATED from shared/durable-contract/src/executor-state.ts by cli/scripts/sync-durable-contract.mjs; do not edit.
+/**
+ * The executor state file's shape (wave-0 fix ruling 24.14; C12-R05). EXECUTOR_STATE_FILE holds the
+ * executor key, the executor id, the nonce and the boot id the nonce is bound to, as one closed
+ * object. The host instance name is deliberately absent (C12-R04: read from config/env, so a copied
+ * file does not carry it). Internal: customers never read or edit this file; its location
+ * (paths.ts) is the customer-facing part.
+ */
+import { fieldOk } from "./admission.js";
+export const EXECUTOR_STATE_VERSION = 1;
+/** Field order is the file's key order. version is the integer EXECUTOR_STATE_VERSION. */
+export const EXECUTOR_STATE_SCHEMA = Object.freeze({
+    version: { type: "integer", nullable: false },
+    executor_id: { type: "uuid", nullable: false },
+    /** The SECRET_KINDS executor_key spelling; this file is its only allowed home. */
+    executor_key: { type: "string", nullable: false },
+    nonce: { type: "string", nullable: false },
+    boot_id: { type: "string", nullable: false },
+});
+/** True for exactly the frozen shape: every key present and well typed, no other key, version 1. */
+export function executorStateOk(v) {
+    if (v === null || typeof v !== "object" || Array.isArray(v))
+        return false;
+    const o = v;
+    const keys = Object.keys(EXECUTOR_STATE_SCHEMA);
+    if (Object.keys(o).some((k) => !keys.includes(k)))
+        return false;
+    for (const [k, spec] of Object.entries(EXECUTOR_STATE_SCHEMA))
+        if (!(k in o) || !fieldOk(spec, o[k]))
+            return false;
+    return o.version === EXECUTOR_STATE_VERSION;
+}

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

@@ -0,0 +1,318 @@
+/**
+ * The fix-line catalogue, the fix-line rule and the catalogue lint (BACKBONE "Fix-line catalogue",
+ * "Fix-line rule"; C01-R16, C02-R05/R26, C11-R09/R27, C14-R11, C16-R29, final F04/F06/F11/F14).
+ *
+ * Every line is quoted ONCE here and rendered by `renderFixLine`; no other module restates one.
+ * An entry is `lead + [done clause] + body + [suffix]`:
+ *  - `ruled` entries (their body contains `mnemom agent <name> --new`) obey the fix-line rule:
+ *    (a) DONE_CLAUSE is inserted before the body whenever a non-terminal row holds the name
+ *        (the caller says so: `nameHeld`); (b) LAUNCHER_SUFFIX is appended whenever the launcher
+ *        key is not `always`.
+ *  - every other entry renders lead + body verbatim.
+ * Placeholders are `<name>`-style; `renderFixLine` refuses a missing or unknown one.
+ *
+ * Text decisions recorded here (S1 owns them):
+ *  - Every done clause is "`mnemom agent done <name>`, then " WITH the comma (the rule's own
+ *    wording). Two backbone quotations of the `budget_at_limit` and `guard` lines omit the comma;
+ *    the rule governs, so the catalogue carries the comma everywhere.
+ *  - The unattended line puts the command in backticks like every other line (C08-R14 wording;
+ *    the C06-R14 quotation without backticks is the same line).
+ */
+import { type CwdCheckCause, type CwdKind } from "./codes.js";
+import type { EffectiveState, StateReason } from "./states.js";
+export declare const LAUNCHER_KEYS: readonly ["off", "ask", "always"];
+export type LauncherKey = (typeof LAUNCHER_KEYS)[number];
+export declare const DONE_CLAUSE = "`mnemom agent done <name>`, then ";
+export declare const LAUNCHER_SUFFIX = " (set `mnemom agent config set durable always` first)";
+export declare const NEW_TOKEN = "mnemom agent <name> --new";
+export type FixKind = 
+/** A line whose commands a person can run as written in M1 (C11-R27 lint executes it). */
+"command"
+/** An action that is not a shell command (enrol a factor, protect a branch); still M1-workable. */
+ | "action"
+/** The single lint exemption: an informational refusal with no caller command (non-admin durable_not_owner). */
+ | "informational";
+export interface FixEntry {
+    readonly kind: FixKind;
+    readonly lead: string;
+    readonly body: string;
+}
+export declare const FIX_LINES: {
+    readonly budget_reached: FixEntry;
+    readonly above_limit_raise: FixEntry;
+    readonly budget_at_limit: FixEntry;
+    readonly agent_killed: FixEntry;
+    readonly session_ended: FixEntry;
+    readonly session_transcript_missing: FixEntry;
+    readonly paused_owner: FixEntry;
+    readonly agent_contained: FixEntry;
+    readonly respawn_failed: FixEntry;
+    readonly attestation_failed: FixEntry;
+    /** suspended(approval_expired|approval_denied) (ruling 34.22): the wait was left; the owner resumes by hand. */
+    readonly approval_expired: FixEntry;
+    readonly approval_denied: FixEntry;
+    readonly attestation_cwd_missing: FixEntry;
+    readonly attestation_cwd_not_toplevel: FixEntry;
+    readonly grant_expired: FixEntry;
+    readonly grant_warning: FixEntry;
+    readonly identity_mismatch: FixEntry;
+    /**
+     * Stopped reasons M1 has no remedy for (wave-0 fix ruling 4): suspended(card_drift,
+     * enforce_refused, charter_breach, owner_departed), paused(breakglass) and the fixture-only
+     * paused(null). done-then-new is the only exit that works in M1.
+     */
+    readonly stopped_no_m1_remedy: FixEntry;
+    /** suspended(account_balance) (wave-0 fix ruling 4). */
+    readonly account_balance: FixEntry;
+    /** budget_raise (or amend --budget) on paused(owner) (wave-0 fix ruling 4). */
+    readonly budget_while_paused: FixEntry;
+    readonly guard: FixEntry;
+    readonly seat_wait_timeout: FixEntry;
+    readonly daemon_not_running: FixEntry;
+    readonly daemon_idle: FixEntry;
+    readonly unreachable_home: FixEntry;
+    readonly session_homed_elsewhere: FixEntry;
+    readonly session_homed_elsewhere_stale: FixEntry;
+    readonly resume_live: FixEntry;
+    readonly lock_not_entitled: FixEntry;
+    readonly lock_mfa_required: FixEntry;
+    readonly lock_branch_unprotected: FixEntry;
+    readonly lock_agent_shared: FixEntry;
+    readonly no_executor: FixEntry;
+    readonly tool_classes: FixEntry;
+    readonly remote_control: FixEntry;
+    readonly cwd_subdirectory: FixEntry;
+    readonly cwd_not_git: FixEntry;
+    readonly cwd_symlink_transcript: FixEntry;
+    readonly launch_spec_change: FixEntry;
+    /** C14-R11: offered beside launch_spec_change only when this is the agent's sole locked session. */
+    readonly launch_spec_change_sole_unlock: FixEntry;
+    readonly durable_only_agent: FixEntry;
+    readonly durable_only_held: FixEntry;
+    readonly not_owner_admin: FixEntry;
+    readonly not_owner_info: FixEntry;
+    readonly tracked_pause: FixEntry;
+    readonly tracked_resume: FixEntry;
+    readonly tracked_budget: FixEntry;
+    readonly device_step_login: FixEntry;
+    readonly containment_login: FixEntry;
+    readonly integrity: FixEntry;
+    readonly unattended: FixEntry;
+};
+export type FixKey = keyof typeof FIX_LINES;
+/** The clause renderDurableOnly appends for launcher keys off and ask (C02-R24). */
+export declare const DURABLE_ONLY_CONFIG_CLAUSE = ", or `mnemom agent config set durable always` and rerun";
+export declare function isRuled(entry: FixEntry): boolean;
+export interface FixRenderContext {
+    launcherKey: LauncherKey;
+    /** A non-terminal row holds the name (names are unique among non-terminal sessions, C11-R25). */
+    nameHeld: boolean;
+    params: Readonly<Record<string, string>>;
+}
+/** The placeholders an entry needs (lead, done clause when ruled, body). */
+export declare function placeholdersOf(key: FixKey): string[];
+/** Render one catalogue entry under the fix-line rule. Throws on an unknown or missing placeholder. */
+export declare function renderFixLine(key: FixKey, ctx: FixRenderContext): string;
+/** The durable_only_agent entry's trailing precondition clause (C02-R24, wave-0 fix ruling 16.1). */
+export declare const DURABLE_ONLY_PRECONDITION_CLAUSE = ", or <precondition>";
+/** The fix entries a lock refusal can pick (LOCK_REFUSAL_FIX values). */
+export type LockRefusalFixKey = "lock_not_entitled" | "lock_mfa_required" | "lock_branch_unprotected" | "lock_agent_shared" | "no_executor" | "cwd_subdirectory" | "cwd_not_git" | "cwd_symlink_transcript";
+/**
+ * The frozen <precondition> clause of each lock fix entry (wave-0 fix ruling 16.1), worded by the
+ * kind of fix so a whole fix entry is never wrapped in 'fix ... and rerun': a setup command run
+ * before relaunching ('run `<cmd>` and rerun'); a command that is itself the relaunch (the cwd
+ * entries: no rerun); an action, then a retry ('<action>, then rerun', rerun once); nothing the
+ * user can fix alone (not entitled: who can, no rerun). Every clause starts lowercase after ', or '.
+ */
+export declare const DURABLE_ONLY_PRECONDITION: Readonly<{
+    readonly lock_not_entitled: "ask support@mnemom.ai to enable durable sessions for this org";
+    readonly lock_mfa_required: "enrol a passkey or TOTP factor (check with `mnemom agent doctor`), then rerun";
+    readonly lock_branch_unprotected: "add a ruleset or branch protection to <repo>, then rerun";
+    readonly lock_agent_shared: "run `mnemom agent lock <name> --own-agent` and rerun";
+    readonly no_executor: "run `mnemom agent host install` and rerun";
+    readonly cwd_subdirectory: "start it at the repo root: `cd <toplevel> && mnemom agent <name> --new`";
+    readonly cwd_not_git: "start it in a git checkout: `cd <checkout> && mnemom agent <name> --new`";
+    readonly cwd_symlink_transcript: "start it from the real path: `cd <realpath> && mnemom agent <name> --new`";
+}>;
+/**
+ * The fix entry of each lock refusal code (wave-0 fix ruling 16): what fills durable_only_agent's
+ * <precondition>. durable_cwd_not_root picks its entry by cwd_kind; durable_precondition_unavailable
+ * is null: it means retry, so the durable-only line carries no precondition clause for it.
+ */
+export declare const LOCK_REFUSAL_FIX: Readonly<{
+    readonly durable_lock_not_entitled: "lock_not_entitled";
+    readonly durable_lock_mfa_required: "lock_mfa_required";
+    readonly durable_lock_branch_unprotected: "lock_branch_unprotected";
+    readonly durable_lock_agent_shared: "lock_agent_shared";
+    readonly durable_no_executor: "no_executor";
+    readonly durable_cwd_not_root: Readonly<{
+        subdirectory: "cwd_subdirectory";
+        not_git: "cwd_not_git";
+        symlink_transcript: "cwd_symlink_transcript";
+    }>;
+    readonly durable_precondition_unavailable: null;
+}>;
+export type LockRefusalCode = keyof typeof LOCK_REFUSAL_FIX;
+/** The lock refusal a durable-only launch hit: its code, and cwd_kind for durable_cwd_not_root. */
+export interface LockRefusal {
+    code: LockRefusalCode;
+    cwd_kind?: CwdKind;
+}
+/** The fix entry a lock refusal fills <precondition> with, or null (no clause). Throws when durable_cwd_not_root has no cwd_kind. */
+export declare function lockRefusalFixKey(refusal: LockRefusal): LockRefusalFixKey | null;
+/**
+ * The durable_only_agent entry (final F11; wave-0 fix rulings 6, Wassim option 1, and 16). The
+ * precondition clause appears only when a lock precondition really refused (`refusal` non-null and
+ * not durable_precondition_unavailable); its <precondition> is the clause DURABLE_ONLY_PRECONDITION
+ * holds for the refusing code's fix entry (LOCK_REFUSAL_FIX; ruling 16.1), rendered with `name`
+ * plus `fixParams` (<repo>, <toplevel>, <checkout>, <realpath>). The config clause appears only
+ * for launcher keys off and ask; never an unlock offer. So off, ask answered N and non-TTY ask (no
+ * lock attempted) print the other-agent and config options; always with a lock refusal prints the other-agent and precondition options; ask
+ * answered Y with a lock refusal prints all three, in that order.
+ */
+export declare function renderDurableOnly(launcherKey: LauncherKey, params: {
+    name: string;
+    refusal: LockRefusal | null;
+    fixParams?: Readonly<Record<string, string>>;
+}): string;
+/**
+ * The api's durable_only_agent answer to a create while another session (<holder>) is locked on the
+ * agent: the durable_only_held entry. Distinct from renderDurableOnly, which is the launcher's own
+ * line when THIS launch would not end locked.
+ */
+export declare function renderDurableOnlyHeld(params: {
+    name: string;
+    holder: string;
+}): string;
+/** The stopped effective states: the ones a row-8 owner-verb refusal and the CLI stopped line cover. */
+export declare const STOPPED_EFFECTIVE_STATES: readonly ["paused", "suspended", "suspended_grant_expired"];
+export type StoppedEffectiveState = (typeof STOPPED_EFFECTIVE_STATES)[number];
+/** The key STOPPED_FIX uses for a NULL state_reason, and for "any reason" under suspended_grant_expired. */
+export declare const STOPPED_FIX_NULL_REASON = "null";
+export declare const STOPPED_FIX_ANY_REASON = "*";
+/**
+ * One map for owner-verb row-8 refusals and the CLI's stopped-state line, so they cannot diverge:
+ * effective state -> state_reason -> fix key. Total over every stopped (state, reason) pair in
+ * STATE_REASONS; suspended_grant_expired takes grant_expired over any stored reason. Two entries
+ * are refined by stoppedFixKey: budget_reached becomes budget_at_limit at or above the per-session
+ * limit, and attestation_failed with a cwd cause takes its attestation_cwd_* line.
+ */
+export declare const 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";
+    }>;
+}>;
+export interface StoppedFixOptions {
+    /** The committed budget (budget_reached only); at or above the limit the fix is budget_at_limit. */
+    committedBudgetUsd?: number;
+    /** The cause of the last attestation.failed when its check is `cwd` (attestation_failed only). */
+    cwdCause?: CwdCheckCause | null;
+}
+/** The STOPPED_FIX entry for an effective state and its stored reason. Throws on a non-stopped state or a reason the state cannot carry. */
+export declare function stoppedFixKey(effective: EffectiveState, reason: StateReason | null, opts?: StoppedFixOptions): FixKey;
+/**
+ * The check-specific sentence `mnemom agent <name>` prints next to the `mnemom agent resume <name>`
+ * fix for these two stopped reasons (wave-0 fix ruling 1.22; RULINGS-evals C11 U05 note). <n> is
+ * RESPAWN_FAILURES_SUSPEND_AT; <check> is the check of the session's last attestation.failed.
+ */
+export declare const STOPPED_REASON_TEXT: Readonly<{
+    respawn_failed: "the seat failed to start <n> times in a row";
+    attestation_failed: "the claim check <check> failed";
+}>;
+export declare function renderStoppedReasonText(reason: keyof typeof STOPPED_REASON_TEXT, check?: string): string;
+/**
+ * The attestation check the C01 stopped-line fixtures seed in their last attestation.failed
+ * (check 12, branch protection: reachable in M1). The dataset seeds `$S1.U05_FIXTURE_CHECK`.
+ */
+export declare const U05_FIXTURE_CHECK = "12";
+/** The rendered texts the C01-X-055/056 fixtures assert (n = 3; check = U05_FIXTURE_CHECK). */
+export declare const U05_CHECK_TEXT_RESPAWN_FAILED: string;
+export declare const U05_CHECK_TEXT_ATTESTATION_FAILED: string;
+/** The budget refusal fix (429, 422 and stopped): amend while below the limit, budget_at_limit at or above it. */
+export declare function budgetFixKey(committedBudgetUsd: number, limitUsd: number, surface: "reached" | "raise"): FixKey;
+/** Commands that exist in M1. A backticked command must start with one of these. */
+export declare const M1_COMMAND_PREFIXES: readonly ["mnemom agent ", "mnemom login", "mnemom experimental enable durable", "cd <", "git worktree add ", "npm i -g @mnemom/mnemom@"];
+/** Tokens no fix line may contain (U12; C01-R16). */
+export declare const FORBIDDEN_FIX_TOKENS: readonly ["--local", "host breakglass"];
+export interface LintFinding {
+    key: string;
+    problem: string;
+}
+/** Shape lint over a catalogue (defaults to FIX_LINES). Empty result = clean. */
+export declare function lintFixCatalogue(catalogue?: Readonly<Record<string, FixEntry>>): LintFinding[];
+/** Wordings no rendered durable_only line may contain (wave-0 fix ruling 16.1). */
+export declare const DURABLE_ONLY_FORBIDDEN: readonly ["rerun and rerun", ", then rerun, then", "or fix "];
+/**
+ * Lint every durable_only line: each lock refusal (each cwd_kind) under each launcher key, rendered
+ * with sample params. Flags a forbidden wording, 'rerun' twice in one clause, and a clause that does
+ * not start lowercase.
+ */
+export declare function lintDurableOnly(clauses?: Readonly<Record<LockRefusalFixKey, string>>): LintFinding[];
+export declare const NON_TTY_LOCKED_TEMPLATE = "`<name>` is locked; the host daemon runs it. Attach: `mnemom agent <name>`";
+/** The single non-TTY stdout line (owner Q4, final F03), with the builder's dropped flags if any. */
+export declare function renderNonTtyLocked(name: string, droppedFlags: readonly string[]): string;
+/** The adopt Note grammar (C14-R12): '<with-you text>; flags dropped: <list>'. */
+export declare const ADOPT_WITH_YOU_TEXT = "approvals with you";
+export declare function renderAdoptNote(droppedFlags: readonly string[]): string;
+/** `mnemom agent show` sections, in order; the --json keys are the same strings in the same order. */
+export declare const SHOW_KEYS: readonly ["state", "machine", "sharing", "goal", "rules", "pins", "limits", "approvals", "outage", "storage", "seat", "journal"];
+/** show keys that do not apply to a tracked session. */
+export declare const SHOW_KEYS_LOCKED_ONLY: readonly ["machine", "pins", "limits", "approvals", "outage", "seat"];
+/** The not-applicable value: human output prints NA_TEXT, --json carries null. */
+export declare const NA_TEXT = "-";
+export declare const APPROVALS_TEXT_M1 = "with you";
+export declare const OUTAGE_TEXT_M1 = "if Mnemom is unavailable this session's model calls stop until it is back; nothing runs on its own in this release";
+export declare const STORAGE_TEXT_M1 = "goal text: encrypted, erasable, purged 30 days after the session ends; charter, journal and session row: content-free; transcript: on this machine only";
+export declare const SEAT_TEXT_M1 = "leave without stopping it: tmux detach (ctrl-b d); `/exit` restarts the seat";
+export declare const JOURNAL_TAIL_N = 10;
+/**
+ * The laptop risk line, version RISK_LINE_VERSION (constants.ts). Printed at host install, in the
+ * adopt summary and on lock, never recorded as seen (C02-R17). It is the design §2.2 sentence
+ * minus what M1 lacks (no Slack approvals, no org-limit raises in M1).
+ */
+export declare const 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.";
+/**
+ * The device verification page's harness markers (C04-R08; wave-0 fix 3d): HTML attributes, values
+ * from server state only (never from the submitted form). The visible text is RISK_LINE_TEXT.
+ *   data-subject-kind           the stored kind ('host' in M1)
+ *   data-subject-runtime        the stored runtime string
+ *   data-runtime-self-declared  'true' | 'false'
+ *   data-risk-sentence-id       RISK_SENTENCE_ID_HOST for kind host
+ *   data-risk-line-version      String(RISK_LINE_VERSION)
+ */
+export declare const DEVICE_PAGE_MARKERS: readonly ["data-subject-kind", "data-subject-runtime", "data-runtime-self-declared", "data-risk-sentence-id", "data-risk-line-version"];
+export type DevicePageMarker = (typeof DEVICE_PAGE_MARKERS)[number];
+export declare const RISK_SENTENCE_ID_HOST = "laptop";
+/** The marker values for one enrollment subject, from its stored row. M1 knows kind 'host' only. */
+export declare function devicePageMarkerValues(subject: {
+    kind: string;
+    runtime: string;
+    runtimeSelfDeclared: boolean;
+}): Readonly<Record<DevicePageMarker, string>>;
+/** Spend column (C01-R25): guard_state.spend_usd to cents, two decimals, no currency sign; tracked rows print NA_TEXT. */
+export declare function formatSpendCents(spendUsd: number | null): string;
+/**
+ * Days shown in the grant warning: ceil(remaining / 1 day), so "6 days" at six days left and
+ * "1 days" in the last day. null (no warning) above GRANT_WARNING_S or when already expired.
+ */
+export declare function grantWarningDays(remainingSeconds: number, warningWindowSeconds: number): number | null;