@mnemom/mnemom 0.17.3-next.5 → 0.17.3

package/dist/commands/agent-config.d.ts

@@ -13,8 +13,11 @@
  * Settable keys are the single source of truth in lib/code-config.ts CONFIG_KEYS.
  * The secret Anthropic key is NOT a config key — it lives in ~/.mnemom/launcher.json.
  */
+import { type ExperimentalId } from "../lib/experimental.js";
 /** Entry point for `mnemom agent config <verb> [args...]`. Throws on misuse. */
-export declare function agentConfigCommand(argv: string[]): Promise<void>;
+export declare function agentConfigCommand(argv: string[], opts?: {
+    enabled?: readonly ExperimentalId[];
+}): Promise<void>;
 /**
  * `$VISUAL` / `$EDITOR` is a program plus optional plain flags (`code --wait`, `emacsclient -t`),
  * never shell syntax: the value is split on whitespace and every token must be a bare

package/dist/commands/agent-config.js

@@ -16,15 +16,17 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { LAUNCHER_CONFIG_PATH, CONFIG_KEYS, configKeySpec, loadLauncherConfig, writeLauncherConfig, } from "../lib/launcher-config.js";
+import { loadExperimentalState } from "../lib/cli-config.js";
+import { configKeyMark } from "../lib/experimental.js";
 const out = (line = "") => console.log(line);
 const err = (line = "") => console.error(line);
 /** Entry point for `mnemom agent config <verb> [args...]`. Throws on misuse. */
-export async function agentConfigCommand(argv) {
+export async function agentConfigCommand(argv, opts = {}) {
     const [verb, ...rest] = argv;
     switch (verb) {
         case undefined:
         case "list":
-            return listConfig();
+            return listConfig(opts.enabled ?? loadExperimentalState().enabled);
         case "path":
             out(LAUNCHER_CONFIG_PATH);
             return;
@@ -40,7 +42,8 @@ export async function agentConfigCommand(argv) {
             throw new Error(`mnemom agent config: unknown verb '${verb}'. Use list | get | set | unset | edit | path.`);
     }
 }
-function listConfig() {
+/** Settings of experimental features that are off are marked `(experimental, off)`. */
+function listConfig(enabled) {
     const cfg = loadLauncherConfig();
     const rows = [];
     for (const spec of CONFIG_KEYS) {
@@ -54,13 +57,13 @@ function listConfig() {
         out("");
         out("Settable keys:");
         for (const spec of CONFIG_KEYS)
-            out(`  ${spec.key.padEnd(22)} ${spec.describe}`);
+            out(`  ${spec.key.padEnd(22)} ${spec.describe}${configKeyMark(spec.key, undefined, enabled)}`);
         return;
     }
     const width = Math.max(...rows.map(([k]) => k.length));
     out(`# ${LAUNCHER_CONFIG_PATH}`);
     for (const [k, v] of rows)
-        out(`${k.padEnd(width)}  ${v}`);
+        out(`${k.padEnd(width)}  ${v}${configKeyMark(k, v, enabled)}`);
 }
 function getConfig(key) {
     if (!key)

package/dist/commands/agent-doctor.js

@@ -14,7 +14,8 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { anthropicKeySource, checkRcCapability, resolveCliBin } from "./agent.js";
-import { isProdGateway, resolveAnthropicDoor, resolveGatewayHost } from "../lib/agent.js";
+import { isProdGateway, resolveAnthropicDoor, resolveGatewayHost, singleCellError, } from "../lib/agent.js";
+import { getApiUrl, getGatewayUrl } from "../lib/config.js";
 import { LAUNCHER_CONFIG_PATH } from "../lib/launcher-config.js";
 import { getCodeEntitlement, MnemomApiError } from "../lib/api.js";
 import { isLoggedIn } from "../lib/auth.js";
@@ -52,6 +53,14 @@ export async function agentDoctorCommand(options = {}) {
         add("ok", "Anthropic key: found in ~/.mnemom/launcher.json");
     else
         add("miss", "Anthropic key: none found", "export MNEMOM_AGENT_ANTHROPIC_KEY=sk-ant-… (or ANTHROPIC_API_KEY), or run `mnemom agent` once and accept the save prompt");
+    // ── one cell: the launch door must be the CLI's own cell ──
+    const cellError = singleCellError({
+        door: resolveAnthropicDoor(env),
+        apiUrl: getApiUrl(),
+        cellGateway: getGatewayUrl(),
+    });
+    if (cellError)
+        add("miss", "cell: mixed — a launch would be refused", cellError);
     // ── gateway health ──
     const host = resolveGatewayHost(env);
     const cell = isProdGateway(env) ? "us-2/prod" : "custom";

package/dist/commands/agent-session.d.ts

@@ -8,12 +8,13 @@
  *   1. a SESSION NAME — labels the session in traces and the claude.ai session
  *      list (defaults to the current folder's name).
  *
- * GOAL ALIGNMENT is not prompted for: it defaults to IMPLICIT. A bare launch
- * runs governed with the goal inferred from your own messages
- * (`x-mnemom-goal-mode: implicit`, no contract). `--goal` seals a one-line
- * contract instead (`x-mnemom-contract`); `--no-implicit` (or launcher.toml
- * `goal_mode = "off"`) turns alignment off — neither header is sent. The mode is
- * resolved upstream (`resolveImplicit`) and announced on the launch line.
+ * GOAL ALIGNMENT is not prompted for. `--goal` seals a one-line contract
+ * (`x-mnemom-contract`). Implicit alignment — the goal inferred from your own
+ * messages (`x-mnemom-goal-mode: implicit`, no contract) — is the experimental
+ * `implicit` feature: while it is on a bare launch runs implicit, while it is off
+ * (the default) a bare launch runs with alignment off. `--no-implicit` (or
+ * launcher.toml `goal_mode = "off"`) turns it off. The mode is resolved upstream
+ * (`resolveImplicit`) and announced on the launch line.
  *
  * Non-interactive runs (pipes, CI) never prompt — they get a clear error asking
  * for a name. Pure apart from the injected `ask` functions, so every arm is

package/dist/commands/agent-session.js

@@ -8,12 +8,13 @@
  *   1. a SESSION NAME — labels the session in traces and the claude.ai session
  *      list (defaults to the current folder's name).
  *
- * GOAL ALIGNMENT is not prompted for: it defaults to IMPLICIT. A bare launch
- * runs governed with the goal inferred from your own messages
- * (`x-mnemom-goal-mode: implicit`, no contract). `--goal` seals a one-line
- * contract instead (`x-mnemom-contract`); `--no-implicit` (or launcher.toml
- * `goal_mode = "off"`) turns alignment off — neither header is sent. The mode is
- * resolved upstream (`resolveImplicit`) and announced on the launch line.
+ * GOAL ALIGNMENT is not prompted for. `--goal` seals a one-line contract
+ * (`x-mnemom-contract`). Implicit alignment — the goal inferred from your own
+ * messages (`x-mnemom-goal-mode: implicit`, no contract) — is the experimental
+ * `implicit` feature: while it is on a bare launch runs implicit, while it is off
+ * (the default) a bare launch runs with alignment off. `--no-implicit` (or
+ * launcher.toml `goal_mode = "off"`) turns it off. The mode is resolved upstream
+ * (`resolveImplicit`) and announced on the launch line.
  *
  * Non-interactive runs (pipes, CI) never prompt — they get a clear error asking
  * for a name. Pure apart from the injected `ask` functions, so every arm is
@@ -65,11 +66,9 @@ export async function resolveSessionSetup(input, ask) {
     say(`  (Next time you can pass it directly: mnemom agent <name>.)`);
     const typed = await ask.askInput(`Session name [${fallback}]:`);
     const scenario = sanitizeAgentName(typed.trim()) || fallback;
-    // ── 2. goal alignment — resolved upstream, no prompt. Implicit is the DEFAULT
-    // (a bare launch runs governed with the goal inferred from your messages), so
-    // there is nothing to pick here: `--goal` seals a contract, the default (and
-    // `--implicit` / `goal_mode = "implicit"`) is implicit, and `--no-implicit` /
-    // `goal_mode = "off"` turns it off. The launch line announces the mode.
+    // ── 2. goal alignment — resolved upstream, no prompt: `--goal` seals a contract,
+    // the `implicit` experimental feature (when on) makes implicit the default, and
+    // `--no-implicit` / `goal_mode = "off"` turns it off. The launch line announces the mode.
     if (flagGoal) {
         return { scenario, goal: flagGoal, goalAlignment: "on", prompted: true };
     }

package/dist/commands/agent-sessions.d.ts

@@ -26,6 +26,11 @@ export interface SessionCommandDeps {
      * one `live goal` line an implicit session gets. Optional: absent ⇒ no line.
      */
     fetchGoal?: (record: SessionRecord) => Promise<GoalShowResponse>;
+    /**
+     * The gateway of the cell this CLI reads live state from. A session that ran on another
+     * cell is not looked up there (it would always read as "no sealed contract"). Absent ⇒ no check.
+     */
+    cellGateway?: () => string;
     out: (line: string) => void;
     err: (line: string) => void;
 }

package/dist/commands/agent-sessions.js

@@ -14,7 +14,8 @@
  * only the server's hash is shown, labelled "sealed hash".
  */
 import { readSessionRecords } from "../lib/agent-ledger.js";
-import { MNEMOM_DIR } from "../lib/config.js";
+import { getGatewayUrl, MNEMOM_DIR } from "../lib/config.js";
+import { sameOrigin } from "../lib/agent.js";
 import { getAgentSession, MnemomApiError } from "../lib/api.js";
 import { fmt, formatRelativeAge } from "../lib/format.js";
 import { goalControlFetch } from "../lib/goal-api.js";
@@ -31,6 +32,7 @@ export const liveSessionDeps = {
         const creds = await resolveLaunchCreds();
         return goalControlFetch(record, "show", { thread: "main" }, { fetch, creds });
     },
+    cellGateway: () => getGatewayUrl(),
     out: (line) => console.log(line),
     err: (line) => console.error(line),
 };
@@ -180,6 +182,9 @@ export function buildShowView(local, remote, reason) {
     if (local.context_profile)
         launchBits.push(`context ${local.context_profile}`);
     L.push(fmt.label("launch:       ", launchBits.join(" · ")));
+    if (local.experimental?.length) {
+        L.push(fmt.label("experimental: ", local.experimental.join(", ")));
+    }
     L.push(fmt.label("conversation: ", local.conversation_id));
     const goalMode = resolveGoalMode(local, remote);
     L.push(fmt.label("goal alignment:", goalBadge(goalMode)));
@@ -315,9 +320,13 @@ export async function agentShowCommand(ref, opts, deps) {
     const { record, others } = resolved;
     let remote = null;
     let reason;
+    const cell = deps.cellGateway?.();
     if (record.agent_id === null) {
         reason = "agent id was not resolved at launch";
     }
+    else if (cell !== undefined && !sameOrigin(record.gateway_host, cell)) {
+        reason = `this session ran on ${record.gateway_host}, not this CLI's cell (${cell}) — point the CLI at that cell to read it`;
+    }
     else {
         try {
             remote = await deps.fetchSession(record.conversation_id, record.agent_id, record.org_id);

package/dist/commands/agent-setup.js

@@ -26,10 +26,10 @@
 import { claimAgent, getAgentByName, getMe, getMuBalance, getMyPersonalOrg, MnemomApiError, mintProtectionCapability, putAlignmentCard, putProtectionCard, } from "../lib/api.js";
 import { getAuthInfo, isLoggedIn, loginWithBrowser, loginWithDeviceFlow, resolveAuth, } from "../lib/auth.js";
 import { getActiveOrg } from "../lib/cli-config.js";
-import { getWebsiteUrl } from "../lib/config.js";
+import { getApiUrl, getGatewayUrl, getWebsiteUrl } from "../lib/config.js";
 import { fmt } from "../lib/format.js";
 import { askYesNo, isInteractive } from "../lib/prompt.js";
-import { resolveGatewayHost, sanitizeAgentName } from "../lib/agent.js";
+import { resolveAnthropicDoor, resolveGatewayHost, sanitizeAgentName, singleCellError, } from "../lib/agent.js";
 import { configKeySpec, loadLauncherConfig, writeLauncherConfig } from "../lib/launcher-config.js";
 import { deriveHashProof } from "./agents.js";
 import { birthThroughGateway } from "./wrap.js";
@@ -273,6 +273,13 @@ async function publishDefaultCards(agentId) {
 /** `mnemom agent setup [--agent <slug>]` — the explicit provisioning entry point. */
 export async function agentSetupCommand(opts = {}) {
     const gatewayHost = resolveGatewayHost(process.env);
+    const cellError = singleCellError({
+        door: resolveAnthropicDoor(process.env),
+        apiUrl: getApiUrl(),
+        cellGateway: getGatewayUrl(),
+    });
+    if (cellError)
+        throw new Error(cellError.replace("mnemom agent:", "mnemom agent setup:"));
     // Sign in (offer sign-up) and enforce the MU balance before any account write.
     try {
         await ensureSessionAndBalance({});

package/dist/commands/agent.d.ts

@@ -25,6 +25,7 @@
  * line, or the proxy's stdin under RC). It is never logged, printed, or passed as
  * an argv value.
  */
+import { type ExperimentalId } from "../lib/experimental.js";
 import { type ContextProfile, type LaunchShape, type SealedContractEnvelope } from "../lib/agent.js";
 export interface AgentOptions {
     goal?: string;
@@ -87,6 +88,12 @@ export interface AgentOptions {
      * Undefined = the full default order.
      */
     keySource?: "env" | "store" | "prompt";
+    /**
+     * The experimental features on for this launch (`mnemom experimental`), already gated
+     * upstream in index.ts. Announced on stderr, recorded in the ledger, and sent in the
+     * session-config header's `experimental` array. Absent/empty ⇒ none of the three.
+     */
+    experimental?: readonly ExperimentalId[];
     passthrough?: string[];
     /** Print the resolved launch plan and exit — no key read, no spawn. */
     dryRun?: boolean;
@@ -245,4 +252,6 @@ export declare function printPlan(ctx: {
     contextProfile: ContextProfile;
     /** The decoded `x-mnemom-session-config` overlay (`buildSessionConfig`); empty ⇒ no header. */
     sessionConfig: Record<string, string>;
+    /** The experimental features on for this launch (the header's `experimental` array). */
+    experimental?: readonly string[];
 }): void;

package/dist/commands/agent.js

@@ -31,16 +31,17 @@ import { randomUUID } from "node:crypto";
 import { tmpdir, homedir } from "node:os";
 import { basename, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { MNEMOM_DIR } from "../lib/config.js";
+import { getApiUrl, getGatewayUrl, MNEMOM_DIR } from "../lib/config.js";
 import { getAgentByName } from "../lib/api.js";
 import { LEDGER_FILE, appendSessionRecord, resolveRetentionDays, toLedgerContract, } from "../lib/agent-ledger.js";
 import { loadCliConfig } from "../lib/cli-config.js";
 import { configKeySpec, loadLauncherConfig, writeLauncherConfig } from "../lib/launcher-config.js";
+import { experimentalNotice } from "../lib/experimental.js";
 import { fmt } from "../lib/format.js";
 import { askInput, askYesNo, isInteractive } from "../lib/prompt.js";
 import { goalAlignmentLine, resolveSessionSetup } from "./agent-session.js";
 import { AgentIdentityMismatchError, defaultAgentSlug, ensureGovernedAgent, ensureSessionAndBalance, isQuietPreambleExit, resolveDefaultSlug, resolvePreflightedAccount, } from "./agent-setup.js";
-import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, HANDOFF_RC_KEY_ENV_NAME, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, resolveAnthropicDoor, resolveConversationId, resolveGatewayHost, resolveLaunchShape, resolveRemoteControlShape, passthroughName, sanitizeAgentName, sessionDisplayName, SESSION_NAME_ENV, SESSION_CONFIG_HEADER, } from "../lib/agent.js";
+import { assembleContract, buildGoalModeHeader, buildCustomHeaders, buildHandoffMcpConfigJson, buildSessionConfig, buildSessionConfigB64, resolveContextHandoff, resolveContextProfile, resolveHandoffGatewayHost, HANDOFF_RC_KEY_ENV_NAME, isProdGateway, launchPreferenceExplicit, launchPreflighted, remoteControlAllowed, resolveAnthropicDoor, resolveConversationId, resolveGatewayHost, singleCellError, resolveLaunchShape, resolveRemoteControlShape, passthroughName, sanitizeAgentName, sessionDisplayName, SESSION_NAME_ENV, SESSION_CONFIG_HEADER, } from "../lib/agent.js";
 import { LAUNCHER_STORE_PATH, mergeStore } from "../lib/launcher-store.js";
 import { slackChannelArgs } from "../lib/slack-launch.js";
 /** The CLI's own provider-key store (zero 1Password): ~/.mnemom/launcher.json, 0600. */
@@ -60,9 +61,9 @@ function sayContextProfile(profile) {
 }
 /** Entry point for `mnemom agent [scenario]`. Throws on fatal misconfig. */
 export async function agentCommand(scenarioArg, options = {}) {
-    // ── session name + goal ── (a bare `mnemom agent` in a terminal asks for both,
-    // goal alignment is implicit by default (inferred from your messages); --goal
-    // seals a contract and --no-implicit turns it off — all resolved upstream.
+    // ── session name + goal ── (a bare `mnemom agent` in a terminal asks for the name;
+    // goal alignment is resolved upstream: --goal seals a contract, implicit alignment
+    // is on by default only while the `implicit` experimental feature is on.
     const session = await resolveSessionSetup({
         scenario: scenarioArg,
         goal: options.goal,
@@ -108,6 +109,9 @@ export async function agentCommand(scenarioArg, options = {}) {
     // ── door ──
     const gatewayHost = resolveGatewayHost(env);
     const door = resolveAnthropicDoor(env);
+    const cellError = singleCellError({ door, apiUrl: getApiUrl(), cellGateway: getGatewayUrl() });
+    if (cellError)
+        throw new Error(cellError);
     const cellNote = isProdGateway(env) ? "us-2/prod" : `custom (${gatewayHost})`;
     const yolo = options.yolo !== false; // default ON
     const contextHint = options.contextHint !== false; // default ON
@@ -121,8 +125,14 @@ export async function agentCommand(scenarioArg, options = {}) {
         env,
     });
     const contextHandoff = resolveContextHandoff({ contextHandoff: options.contextHandoff, env });
+    const experimental = options.experimental ?? [];
     const sessionConfig = buildSessionConfig({ profile: contextProfile, contextHandoff });
-    const sessionConfigB64 = buildSessionConfigB64({ profile: contextProfile, contextHandoff });
+    const sessionConfigB64 = buildSessionConfigB64({
+        profile: contextProfile,
+        contextHandoff,
+        experimental,
+    });
+    const expNotice = experimentalNotice(experimental);
     // ── which CLI executable (name or full path) ── resolve GRACEFULLY: if it's not
     // found we don't crash with a technical error — we ask for the path at launch.
     let cli;
@@ -163,7 +173,10 @@ export async function agentCommand(scenarioArg, options = {}) {
             cli: planCli,
             contextProfile,
             sessionConfig,
+            experimental,
         });
+        if (expNotice)
+            say(expNotice);
         if (previewShape === "remote-control") {
             say("mnemom agent: the plan shows Remote Control because this machine can run it; the real launch uses it only if your account is entitled (internal Mnemom accounts), else terminal-only.");
         }
@@ -290,6 +303,8 @@ export async function agentCommand(scenarioArg, options = {}) {
         contextProfile,
     });
     logLaunch({ shape, door, agent, conversationId, cellNote, envelope, goalMode, cli });
+    if (expNotice)
+        say(expNotice);
     say(goalAlignmentLine(goalAlignmentMode(envelope, goalMode)));
     sayContextProfile(contextProfile);
     // ── handoff MCP tool (MNE-7564) ── OFF by default: absent/false ⇒ handoffMcpConfigPath stays
@@ -396,6 +411,7 @@ export async function recordSessionLaunch(ctx) {
         goal_mode: goalAlignmentMode(ctx.envelope, ctx.goalMode),
         context_profile: ctx.contextProfile,
         cc_session_id: ctx.ccSessionId ?? null,
+        ...(ctx.options.experimental?.length ? { experimental: [...ctx.options.experimental] } : {}),
     }, {
         dir: MNEMOM_DIR,
         now: () => new Date(),
@@ -1110,6 +1126,8 @@ export function printPlan(ctx) {
         for (const [k, v] of overlay)
             L.push(`    ${k}=${v}`);
     }
+    if (ctx.experimental?.length)
+        L.push(`  experimental:  ${ctx.experimental.join(", ")}`);
     if (ctx.envelope) {
         L.push(`  contract:      ${ctx.envelope.canonical}`);
         L.push(`  contract sha:  ${ctx.envelope.sha}`);

package/dist/commands/experimental.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `mnemom experimental list [--json] | enable <id> | disable <id>` — turn experimental
+ * features on and off (registry: lib/experimental.ts; stored in ~/.mnemom/config.json).
+ */
+import { type ExperimentalId, type ExperimentalPrefs } from "../lib/experimental.js";
+export interface ExperimentalDeps {
+    stored(): ExperimentalPrefs | undefined;
+    persist(ids: ExperimentalId[]): void;
+    env: Record<string, string | undefined>;
+    log(line: string): void;
+}
+export declare function experimentalListCommand(opts?: {
+    json?: boolean;
+}, deps?: ExperimentalDeps): void;
+export declare function experimentalEnableCommand(id: string | undefined, deps?: ExperimentalDeps): void;
+export declare function experimentalDisableCommand(id: string | undefined, deps?: ExperimentalDeps): void;
+/** The one-time migration (lib/experimental.ts migrateExperimental) against the real files. */
+export declare function runExperimentalMigration(): void;

package/dist/commands/experimental.js

@@ -0,0 +1,78 @@
+/**
+ * `mnemom experimental list [--json] | enable <id> | disable <id>` — turn experimental
+ * features on and off (registry: lib/experimental.ts; stored in ~/.mnemom/config.json).
+ */
+import { EXPERIMENTAL_CONTRACT, EXPERIMENTAL_ENV, EXPERIMENTAL_FEATURES, EXPERIMENTAL_IDS, isExperimentalId, migrateExperimental, resolveExperimental, } from "../lib/experimental.js";
+import { loadCliConfig, setExperimentalEnabled } from "../lib/cli-config.js";
+import { launcherEntries, loadLauncherConfig } from "../lib/launcher-config.js";
+function defaultDeps() {
+    return {
+        stored: () => loadCliConfig().experimental,
+        persist: (ids) => setExperimentalEnabled(ids),
+        env: process.env,
+        log: (line) => console.log(line),
+    };
+}
+function requireId(id, verb) {
+    if (!id)
+        throw new Error(`mnemom experimental ${verb}: an <id> is required.`);
+    const v = id.trim().toLowerCase();
+    if (!isExperimentalId(v)) {
+        throw new Error(`Unknown experimental feature '${id}'. Valid ids: ${EXPERIMENTAL_IDS.join(", ")}.`);
+    }
+    return v;
+}
+export function experimentalListCommand(opts = {}, deps = defaultDeps()) {
+    const state = resolveExperimental({ stored: deps.stored(), env: deps.env });
+    const rows = EXPERIMENTAL_FEATURES.map((f) => ({
+        id: f.id,
+        enabled: state.enabled.includes(f.id),
+        summary: f.summary,
+        since: f.since,
+        gates: f.gates,
+    }));
+    if (opts.json) {
+        deps.log(JSON.stringify({ contract: EXPERIMENTAL_CONTRACT, source: state.source, features: rows }, null, 2));
+        return;
+    }
+    deps.log(EXPERIMENTAL_CONTRACT);
+    deps.log("");
+    const width = Math.max(...rows.map((r) => r.id.length));
+    for (const r of rows) {
+        deps.log(`${r.enabled ? "on " : "off"}  ${r.id.padEnd(width)}  ${r.summary}`);
+    }
+    deps.log("");
+    if (state.source === "env") {
+        deps.log(`(set by ${EXPERIMENTAL_ENV} in your environment — it overrides config.json)`);
+    }
+    deps.log("Turn one on with `mnemom experimental enable <id>`.");
+}
+function toggle(verb, rawId, deps) {
+    const id = requireId(rawId, verb);
+    const current = new Set(resolveExperimental({ stored: deps.stored(), env: {} }).enabled);
+    if (verb === "enable")
+        current.add(id);
+    else
+        current.delete(id);
+    const next = EXPERIMENTAL_IDS.filter((x) => current.has(x));
+    deps.persist(next);
+    deps.log(verb === "enable" ? `${id}: on. ${EXPERIMENTAL_CONTRACT}` : `${id}: off.`);
+    if ((deps.env[EXPERIMENTAL_ENV] ?? "").trim()) {
+        deps.log(`note: ${EXPERIMENTAL_ENV} is set in your environment and overrides this.`);
+    }
+}
+export function experimentalEnableCommand(id, deps = defaultDeps()) {
+    toggle("enable", id, deps);
+}
+export function experimentalDisableCommand(id, deps = defaultDeps()) {
+    toggle("disable", id, deps);
+}
+/** The one-time migration (lib/experimental.ts migrateExperimental) against the real files. */
+export function runExperimentalMigration() {
+    migrateExperimental({
+        stored: () => loadCliConfig().experimental,
+        launcherEntries: () => launcherEntries(loadLauncherConfig()),
+        persist: (ids) => setExperimentalEnabled(ids),
+        writeErr: (line) => void process.stderr.write(line),
+    });
+}

package/dist/index.d.ts

@@ -7,4 +7,4 @@ export { program };
  * unknown — so it bypasses commander entirely and reaches the sub-verb parser
  * verbatim. Exported (not auto-run) so the bypass is unit-testable.
  */
-export declare function runEntrypoint(argv?: string[]): void;
+export declare function runEntrypoint(argv?: string[], migrate?: () => void): void;