@mnemom/mnemom 0.17.33 → 0.17.34-next.2

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

@@ -0,0 +1,483 @@
+// GENERATED from shared/durable-contract/src/fixlines.ts by cli/scripts/sync-durable-contract.mjs; do not edit.
+/**
+ * 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 { ATTESTATION_CHECKS_M1 } from "./codes.js";
+import { PER_SESSION_BUDGET_LIMIT_USD, RESPAWN_FAILURES_SUSPEND_AT, RISK_LINE_VERSION, } from "./constants.js";
+export const LAUNCHER_KEYS = ["off", "ask", "always"];
+export const DONE_CLAUSE = "`mnemom agent done <name>`, then ";
+export const LAUNCHER_SUFFIX = " (set `mnemom agent config set durable always` first)";
+export const NEW_TOKEN = "mnemom agent <name> --new";
+const e = (kind, body, lead = "") => ({ kind, lead, body });
+export const FIX_LINES = {
+    // ---- budget (C08-R24, C11-R09, C16-R29) ----
+    budget_reached: e("command", "budget reached: `mnemom agent amend <name> --budget <n>` (up to <limit>)"),
+    above_limit_raise: e("command", "raise up to <limit>: `mnemom agent amend <name> --budget <limit>`"),
+    budget_at_limit: e("command", "`mnemom agent <name> --new`", "budget is at the per-session limit (<limit>): "),
+    // ---- ended and killed ----
+    agent_killed: e("command", "the agent was killed; start this work with another agent: `mnemom agent <name> --agent <another-agent>`"),
+    session_ended: e("command", "`mnemom agent <name> --new`", "this session has ended; start fresh: "),
+    session_transcript_missing: e("command", "`mnemom agent <name> --new`"),
+    // ---- stopped reasons (C01-R16 d-i, C11-R09) ----
+    paused_owner: e("command", "`mnemom agent resume <name>`"),
+    agent_contained: e("command", "an org admin resumes the agent: `mnemom agent containment resume <agent>`"),
+    respawn_failed: e("command", "`mnemom agent resume <name>`"),
+    attestation_failed: e("command", "`mnemom agent resume <name>`"),
+    /** suspended(approval_expired|approval_denied) (ruling 34.22): the wait was left; the owner resumes by hand. */
+    approval_expired: e("command", "`mnemom agent resume <name>`", "the approval expired and this session needs you to resume it: "),
+    approval_denied: e("command", "`mnemom agent resume <name>`", "the approval was denied and this session needs you to resume it: "),
+    attestation_cwd_missing: e("command", "`cd <toplevel> && mnemom agent <name> --new`", "restore <cwd> (e.g. `git worktree add <cwd> <branch>`), then `mnemom agent resume <name>`; or "),
+    attestation_cwd_not_toplevel: e("command", "`cd <checkout> && mnemom agent <name> --new`"),
+    grant_expired: e("command", "`mnemom agent host renew`"),
+    grant_warning: e("command", "grant ends in <days> days: `mnemom agent host renew`"),
+    identity_mismatch: e("command", "`mnemom agent <name> --new`"),
+    /**
+     * 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.
+     */
+    stopped_no_m1_remedy: e("command", "`mnemom agent <name> --new`", "this session cannot be resumed in this release: "),
+    /** suspended(account_balance) (wave-0 fix ruling 4). */
+    account_balance: e("command", "`mnemom agent <name> --new`", "the Mnemom account is out of credit; add credit, then "),
+    /** budget_raise (or amend --budget) on paused(owner) (wave-0 fix ruling 4). */
+    budget_while_paused: e("command", "resume it first: `mnemom agent resume <name>`, then `mnemom agent amend <name> --budget <n>`"),
+    // ---- claim unavailable surfaced by host status (C08-R16, C12-R30) ----
+    guard: e("command", "`mnemom agent <name> --new`"),
+    // ---- home and daemon (C01-R16 b, c, k; C01-R28; C12-R39) ----
+    seat_wait_timeout: e("command", "`mnemom agent host status`"),
+    daemon_not_running: e("command", "the host daemon is not running here: `mnemom agent host install`"),
+    daemon_idle: e("command", "`mnemom experimental enable durable`", "daemon: idle (durable disabled in config): "),
+    unreachable_home: e("command", "`mnemom agent <name> --new`"),
+    session_homed_elsewhere: e("command", "run `mnemom agent <name>` on <machine>"),
+    session_homed_elsewhere_stale: e("command", "`mnemom agent <name> --new`", "run `mnemom agent <name>` on <machine>; if <machine> is gone for good: "),
+    resume_live: e("command", "`mnemom agent <name>` attaches"),
+    // ---- lock (C02-R05, R22, R26, R27) ----
+    lock_not_entitled: e("action", "durable sessions are not enabled for this org yet: ask support@mnemom.ai"),
+    lock_mfa_required: e("action", "enrol a passkey or TOTP factor, then check with `mnemom agent doctor`"),
+    lock_branch_unprotected: e("action", "add a ruleset or branch protection to <repo>, then rerun"),
+    lock_agent_shared: e("command", "`mnemom agent lock <name> --own-agent`"),
+    no_executor: e("command", "`mnemom agent host install`"),
+    tool_classes: e("action", "declare every tool input_dependent (or omit tool_classes) and lock again"),
+    remote_control: e("command", "`mnemom agent lock <name>` (the CLI drops --remote-control)"),
+    cwd_subdirectory: e("command", "start it at the repo root: `cd <toplevel> && mnemom agent <name> --new`"),
+    cwd_not_git: e("command", "start it in a git checkout: `cd <checkout> && mnemom agent <name> --new`"),
+    cwd_symlink_transcript: e("command", "`cd <realpath> && mnemom agent <name> --new`"),
+    launch_spec_change: e("command", "`mnemom agent <name> --new <flags>`"),
+    /** C14-R11: offered beside launch_spec_change only when this is the agent's sole locked session. */
+    launch_spec_change_sole_unlock: e("command", "`mnemom agent sessions unlock <name>`, relaunch, `mnemom agent lock <name>`"),
+    // ---- durable-only (C02-R24, final F11): the trailing config clause is added by renderDurableOnly ----
+    // ruling 21: `<another-agent>` is printed literally (never filled in); the hyphen keeps it outside
+    // PLACEHOLDER_RE, so no caller supplies a value for it.
+    durable_only_agent: e("command", "`mnemom agent <name> --agent <another-agent>`, or <precondition>"),
+    // The api's create refusal while another session is locked on the agent (dogfood walk5): the
+    // reader finishes or reuses the holder, or starts <name> on another agent. <holder> is the
+    // locked session's name; `<another-agent>` stays literal (ruling 21).
+    durable_only_held: e("command", "<holder> is locked on this agent: finish it with `mnemom agent done <holder>`, carry on in it with `mnemom agent <holder>`, or start <name> on another agent with `mnemom agent <name> --agent <another-agent>`"),
+    // ---- owner verbs (owner-verb table step 3; final F04, F06) ----
+    not_owner_admin: e("command", "an org admin can stop the agent: `mnemom agent containment pause <agent>`"),
+    not_owner_info: e("informational", "this session belongs to <owner>"),
+    tracked_pause: e("command", "pause applies to locked sessions: `mnemom agent lock <name>`, then `mnemom agent pause <name>`"),
+    tracked_resume: e("command", "this session is not paused; continue it: `mnemom agent <name>`"),
+    tracked_budget: e("command", "budgets apply to locked sessions: `mnemom agent lock <name>`"),
+    device_step_login: e("command", "this change needs a signed-in owner: `mnemom login`, then rerun"),
+    containment_login: e("command", "org containment needs a signed-in admin: `mnemom login`, then rerun"),
+    // ---- plugin integrity before claim (ruling 25; RULINGS-evals U13; C12-R36, C14-R28) ----
+    integrity: e("command", "installed CLI fails its integrity check: `npm i -g @mnemom/mnemom@<cli_version>`"),
+    // ---- gateway unattended (C06-R14, C08-R14) ----
+    unattended: e("command", "unattended work starts in a later release; type in the seat (`mnemom agent <name>`)"),
+};
+/** The clause renderDurableOnly appends for launcher keys off and ask (C02-R24). */
+export const DURABLE_ONLY_CONFIG_CLAUSE = ", or `mnemom agent config set durable always` and rerun";
+export function isRuled(entry) {
+    return entry.body.includes(NEW_TOKEN);
+}
+const PLACEHOLDER_RE = /<([a-z_]+)>/g;
+function substitute(template, params) {
+    return template.replace(PLACEHOLDER_RE, (_, p) => {
+        const v = params[p];
+        if (v === undefined)
+            throw new RangeError(`fix line placeholder <${p}> has no value`);
+        return v;
+    });
+}
+/** The placeholders an entry needs (lead, done clause when ruled, body). */
+export function placeholdersOf(key) {
+    const entry = FIX_LINES[key];
+    const text = entry.lead + (isRuled(entry) ? DONE_CLAUSE : "") + entry.body;
+    return [...new Set([...text.matchAll(PLACEHOLDER_RE)].map((m) => m[1]))];
+}
+/** Render one catalogue entry under the fix-line rule. Throws on an unknown or missing placeholder. */
+export function renderFixLine(key, ctx) {
+    const entry = FIX_LINES[key];
+    if (!isRuled(entry))
+        return substitute(entry.lead + entry.body, ctx.params);
+    const done = ctx.nameHeld ? DONE_CLAUSE : "";
+    const suffix = ctx.launcherKey === "always" ? "" : LAUNCHER_SUFFIX;
+    return substitute(entry.lead + done + entry.body, ctx.params) + suffix;
+}
+/** The durable_only_agent entry's trailing precondition clause (C02-R24, wave-0 fix ruling 16.1). */
+export const DURABLE_ONLY_PRECONDITION_CLAUSE = ", or <precondition>";
+/**
+ * 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 const DURABLE_ONLY_PRECONDITION = Object.freeze({
+    lock_not_entitled: "ask support@mnemom.ai to enable durable sessions for this org",
+    lock_mfa_required: "enrol a passkey or TOTP factor (check with `mnemom agent doctor`), then rerun",
+    lock_branch_unprotected: "add a ruleset or branch protection to <repo>, then rerun",
+    lock_agent_shared: "run `mnemom agent lock <name> --own-agent` and rerun",
+    no_executor: "run `mnemom agent host install` and rerun",
+    cwd_subdirectory: "start it at the repo root: `cd <toplevel> && mnemom agent <name> --new`",
+    cwd_not_git: "start it in a git checkout: `cd <checkout> && mnemom agent <name> --new`",
+    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 const LOCK_REFUSAL_FIX = Object.freeze({
+    durable_lock_not_entitled: "lock_not_entitled",
+    durable_lock_mfa_required: "lock_mfa_required",
+    durable_lock_branch_unprotected: "lock_branch_unprotected",
+    durable_lock_agent_shared: "lock_agent_shared",
+    durable_no_executor: "no_executor",
+    durable_cwd_not_root: Object.freeze({
+        subdirectory: "cwd_subdirectory",
+        not_git: "cwd_not_git",
+        symlink_transcript: "cwd_symlink_transcript",
+    }),
+    durable_precondition_unavailable: null,
+});
+/** The fix entry a lock refusal fills <precondition> with, or null (no clause). Throws when durable_cwd_not_root has no cwd_kind. */
+export function lockRefusalFixKey(refusal) {
+    const v = LOCK_REFUSAL_FIX[refusal.code];
+    if (v === null || typeof v === "string")
+        return v;
+    if (refusal.cwd_kind === undefined)
+        throw new RangeError(`${refusal.code} needs a cwd_kind to pick its fix entry`);
+    return v[refusal.cwd_kind];
+}
+/**
+ * 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 function renderDurableOnly(launcherKey, params) {
+    return renderDurableOnlyWith(DURABLE_ONLY_PRECONDITION, launcherKey, params);
+}
+function renderDurableOnlyWith(clauses, launcherKey, params) {
+    const body = FIX_LINES.durable_only_agent.body;
+    const otherOnly = body.slice(0, body.length - DURABLE_ONLY_PRECONDITION_CLAUSE.length);
+    const { name, refusal } = params;
+    const key = refusal === null ? null : lockRefusalFixKey(refusal);
+    const base = key === null
+        ? substitute(otherOnly, { name })
+        : substitute(body, {
+            name,
+            precondition: substitute(clauses[key], { ...params.fixParams, name }),
+        });
+    return launcherKey === "always" ? base : base + DURABLE_ONLY_CONFIG_CLAUSE;
+}
+/**
+ * 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 function renderDurableOnlyHeld(params) {
+    return substitute(FIX_LINES.durable_only_held.body, { name: params.name, holder: params.holder });
+}
+// ---- Stopped-state fixes (wave-0 fix ruling 4) ------------------------------------------------
+/** The stopped effective states: the ones a row-8 owner-verb refusal and the CLI stopped line cover. */
+export const STOPPED_EFFECTIVE_STATES = ["paused", "suspended", "suspended_grant_expired"];
+/** The key STOPPED_FIX uses for a NULL state_reason, and for "any reason" under suspended_grant_expired. */
+export const STOPPED_FIX_NULL_REASON = "null";
+export 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 const STOPPED_FIX = Object.freeze({
+    paused: Object.freeze({
+        [STOPPED_FIX_NULL_REASON]: "stopped_no_m1_remedy",
+        owner: "paused_owner",
+        agent_contained: "agent_contained",
+        breakglass: "stopped_no_m1_remedy",
+    }),
+    suspended: Object.freeze({
+        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",
+    }),
+    suspended_grant_expired: Object.freeze({ [STOPPED_FIX_ANY_REASON]: "grant_expired" }),
+});
+/** 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 function stoppedFixKey(effective, reason, opts = {}) {
+    if (effective === "suspended_grant_expired")
+        return STOPPED_FIX.suspended_grant_expired["*"];
+    if (effective !== "paused" && effective !== "suspended")
+        throw new RangeError(`not a stopped state: ${effective}`);
+    const table = STOPPED_FIX[effective];
+    const k = reason === null ? STOPPED_FIX_NULL_REASON : reason;
+    const key = Object.prototype.hasOwnProperty.call(table, k) ? table[k] : undefined;
+    if (key === undefined)
+        throw new RangeError(`${effective} cannot carry reason ${String(reason)}`);
+    if (key === "budget_reached")
+        return budgetFixKey(opts.committedBudgetUsd ?? 0, PER_SESSION_BUDGET_LIMIT_USD, "reached");
+    if (key === "attestation_failed" && opts.cwdCause === "missing")
+        return "attestation_cwd_missing";
+    if (key === "attestation_failed" && opts.cwdCause === "not_toplevel")
+        return "attestation_cwd_not_toplevel";
+    return key;
+}
+/**
+ * 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 const STOPPED_REASON_TEXT = Object.freeze({
+    respawn_failed: "the seat failed to start <n> times in a row",
+    attestation_failed: "the claim check <check> failed",
+});
+export function renderStoppedReasonText(reason, check) {
+    if (reason === "respawn_failed")
+        return substitute(STOPPED_REASON_TEXT.respawn_failed, {
+            n: String(RESPAWN_FAILURES_SUSPEND_AT),
+        });
+    if (check === undefined || !ATTESTATION_CHECKS_M1.includes(check))
+        throw new RangeError(`not an M1 attestation check: ${String(check)}`);
+    return substitute(STOPPED_REASON_TEXT.attestation_failed, { check });
+}
+/**
+ * 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 const U05_FIXTURE_CHECK = "12";
+/** The rendered texts the C01-X-055/056 fixtures assert (n = 3; check = U05_FIXTURE_CHECK). */
+export const U05_CHECK_TEXT_RESPAWN_FAILED = renderStoppedReasonText("respawn_failed");
+export const U05_CHECK_TEXT_ATTESTATION_FAILED = renderStoppedReasonText("attestation_failed", U05_FIXTURE_CHECK);
+/** The budget refusal fix (429, 422 and stopped): amend while below the limit, budget_at_limit at or above it. */
+export function budgetFixKey(committedBudgetUsd, limitUsd, surface) {
+    if (committedBudgetUsd >= limitUsd)
+        return "budget_at_limit";
+    return surface === "reached" ? "budget_reached" : "above_limit_raise";
+}
+// ---- Lint (C11-R27 static half: the eval executes the lines; this checks their shape) ----------
+/** Commands that exist in M1. A backticked command must start with one of these. */
+export const M1_COMMAND_PREFIXES = [
+    "mnemom agent ",
+    "mnemom login",
+    "mnemom experimental enable durable",
+    "cd <",
+    "git worktree add ",
+    /** The CLI reinstall the integrity line names (ruling 25; U13). Only this package, never npm at large. */
+    "npm i -g @mnemom/mnemom@",
+];
+/** Tokens no fix line may contain (U12; C01-R16). */
+export const FORBIDDEN_FIX_TOKENS = ["--local", "host breakglass"];
+/** Shape lint over a catalogue (defaults to FIX_LINES). Empty result = clean. */
+export function lintFixCatalogue(catalogue = FIX_LINES) {
+    const out = [];
+    for (const [key, entry] of Object.entries(catalogue)) {
+        const text = entry.lead + entry.body;
+        for (const tok of FORBIDDEN_FIX_TOKENS) {
+            if (text.includes(tok))
+                out.push({ key, problem: `forbidden token ${tok}` });
+        }
+        if (entry.lead.includes(NEW_TOKEN))
+            out.push({ key, problem: "--new in the lead escapes the rule" });
+        if (text.includes("mnemom agent done <name>"))
+            out.push({ key, problem: "done clause restated; the rule adds it" });
+        if (text.includes("config set durable always") && key !== "durable_only_agent") {
+            out.push({ key, problem: "launcher suffix restated; the rule adds it" });
+        }
+        const commands = [...text.matchAll(/`([^`]+)`/g)].map((m) => m[1]);
+        if (entry.kind === "command" && commands.length === 0)
+            out.push({ key, problem: "command entry has no command" });
+        if (entry.kind === "informational" && commands.length > 0)
+            out.push({ key, problem: "informational entry names a command" });
+        for (const c of commands) {
+            if (!M1_COMMAND_PREFIXES.some((p) => c.startsWith(p)))
+                out.push({ key, problem: `not an M1 command: ${c}` });
+        }
+    }
+    return out;
+}
+/** Wordings no rendered durable_only line may contain (wave-0 fix ruling 16.1). */
+export const DURABLE_ONLY_FORBIDDEN = ["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 function lintDurableOnly(clauses = DURABLE_ONLY_PRECONDITION) {
+    const out = [];
+    for (const [key, clause] of Object.entries(clauses)) {
+        if (!/^[a-z]/.test(clause))
+            out.push({ key, problem: "clause does not start lowercase" });
+        if ((clause.match(/\brerun\b/g) ?? []).length > 1)
+            out.push({ key, problem: "clause says rerun more than once" });
+    }
+    const fixParams = {
+        repo: "acme/web",
+        toplevel: "/wt/web",
+        checkout: "/src/web",
+        realpath: "/real/web",
+    };
+    const refusals = [null];
+    for (const [code, v] of Object.entries(LOCK_REFUSAL_FIX)) {
+        if (v !== null && typeof v === "object")
+            for (const cwd_kind of Object.keys(v))
+                refusals.push({ code, cwd_kind });
+        else
+            refusals.push({ code });
+    }
+    for (const refusal of refusals) {
+        for (const lk of ["always", "ask", "off"]) {
+            const line = renderDurableOnlyWith(clauses, lk, {
+                name: "web",
+                refusal,
+                fixParams,
+            });
+            const key = `${refusal?.code ?? "none"}${refusal?.cwd_kind ? `/${refusal.cwd_kind}` : ""}/${lk}`;
+            for (const bad of DURABLE_ONLY_FORBIDDEN)
+                if (line.includes(bad))
+                    out.push({ key, problem: `contains '${bad}'` });
+        }
+    }
+    return out;
+}
+// ---- Fixed CLI texts and templates (C01-R16 non-TTY, C01-R24 show, C01-R25 spend, C14-R12) ----
+export 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 function renderNonTtyLocked(name, droppedFlags) {
+    const line = substitute(NON_TTY_LOCKED_TEMPLATE, { name });
+    return droppedFlags.length === 0 ? line : `${line} (flags dropped: ${droppedFlags.join(", ")})`;
+}
+/** The adopt Note grammar (C14-R12): '<with-you text>; flags dropped: <list>'. */
+export const ADOPT_WITH_YOU_TEXT = "approvals with you";
+export function renderAdoptNote(droppedFlags) {
+    return droppedFlags.length === 0
+        ? ADOPT_WITH_YOU_TEXT
+        : `${ADOPT_WITH_YOU_TEXT}; flags dropped: ${droppedFlags.join(", ")}`;
+}
+/** `mnemom agent show` sections, in order; the --json keys are the same strings in the same order. */
+export const SHOW_KEYS = [
+    "state",
+    "machine",
+    "sharing",
+    "goal",
+    "rules",
+    "pins",
+    "limits",
+    "approvals",
+    "outage",
+    "storage",
+    "seat",
+    "journal",
+];
+/** show keys that do not apply to a tracked session. */
+export const SHOW_KEYS_LOCKED_ONLY = [
+    "machine",
+    "pins",
+    "limits",
+    "approvals",
+    "outage",
+    "seat",
+];
+/** The not-applicable value: human output prints NA_TEXT, --json carries null. */
+export const NA_TEXT = "-";
+export const APPROVALS_TEXT_M1 = "with you";
+export 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 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 const SEAT_TEXT_M1 = "leave without stopping it: tmux detach (ctrl-b d); `/exit` restarts the seat";
+export 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 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 const DEVICE_PAGE_MARKERS = [
+    "data-subject-kind",
+    "data-subject-runtime",
+    "data-runtime-self-declared",
+    "data-risk-sentence-id",
+    "data-risk-line-version",
+];
+export const RISK_SENTENCE_ID_HOST = "laptop";
+/** The marker values for one enrollment subject, from its stored row. M1 knows kind 'host' only. */
+export function devicePageMarkerValues(subject) {
+    if (subject.kind !== "host")
+        throw new RangeError(`no risk sentence for kind ${subject.kind}`);
+    return {
+        "data-subject-kind": subject.kind,
+        "data-subject-runtime": subject.runtime,
+        "data-runtime-self-declared": subject.runtimeSelfDeclared ? "true" : "false",
+        "data-risk-sentence-id": RISK_SENTENCE_ID_HOST,
+        "data-risk-line-version": String(RISK_LINE_VERSION),
+    };
+}
+/** Spend column (C01-R25): guard_state.spend_usd to cents, two decimals, no currency sign; tracked rows print NA_TEXT. */
+export function formatSpendCents(spendUsd) {
+    if (spendUsd === null)
+        return NA_TEXT;
+    if (!Number.isFinite(spendUsd) || spendUsd < 0)
+        throw new RangeError(`spend out of range: ${spendUsd}`);
+    return (Math.round((spendUsd + Number.EPSILON) * 100) / 100).toFixed(2);
+}
+/**
+ * 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 function grantWarningDays(remainingSeconds, warningWindowSeconds) {
+    if (!(remainingSeconds > 0) || remainingSeconds > warningWindowSeconds)
+        return null;
+    return Math.ceil(remainingSeconds / 86400);
+}