@mnemom/mnemom 0.17.34-next.1 → 0.17.34-next.2

package/dist/index.js

@@ -37,14 +37,13 @@ import { agentDoctorCommand } from "./commands/agent-doctor.js";
 import { agentSetupCommand, parseGovernanceFlag } from "./commands/agent-setup.js";
 import { agentInviteCommand, runAgentInvocation } from "./commands/agent-invite.js";
 import { agentFirstRunCommand, offerFirstRunOnLaunch } from "./commands/agent-first-run.js";
-import { showImplicitDefaultNoticeOnce } from "./commands/agent-implicit-notice.js";
-import { isPrerelease } from "./lib/update/semver.js";
 import { applyConfigToEnv, launcherEntries, loadLauncherConfig, withoutDisabledExperimental, } from "./lib/launcher-config.js";
-import { loadExperimentalState } from "./lib/cli-config.js";
-import { assertEnabled, availableFeatures, EXPERIMENTAL_CONTRACT, gateCheck, ignoredSettingLines, reportCliError, } from "./lib/experimental.js";
+import { loadCliConfig, loadExperimentalState } from "./lib/cli-config.js";
+import { isSeatProxyArgv, runSeatProxyEntry } from "./durable/seat-proxy-entry.js";
+import { assertEnabled, EXPERIMENTAL_CONTRACT, gateCheck, ignoredSettingLines, reportCliError, } from "./lib/experimental.js";
 import { durableVerbOffLines } from "./durable/gate.js";
 import { experimentalDisableCommand, experimentalEnableCommand, experimentalListCommand, runExperimentalMigration, } from "./commands/experimental.js";
-import { parseCompactAt, parseContextProfile, passthroughIsPrint, resolveImplicitSource, selectLaunchAgent, splitSessionArg, } from "./lib/agent.js";
+import { parseCompactAt, parseContextProfile, resolveImplicit, selectLaunchAgent, splitSessionArg, } from "./lib/agent.js";
 import { wrapCommand } from "./commands/wrap.js";
 import { onboardCommand } from "./commands/onboard.js";
 import { skillsListCommand, skillsDescribeCommand } from "./commands/skills.js";
@@ -54,6 +53,16 @@ import { updateCommand } from "./commands/update.js";
 import { runAction } from "./lib/update/action.js";
 import { configListCommand, configGetCommand, configSetCommand, configUnsetCommand, } from "./commands/config.js";
 import { defaultStartupDeps, maybeRunUpdateHook } from "./lib/update/startup.js";
+import { durableActionGate, durableGate, durableOn, optionShapesOf, } from "./lib/durable/gate.js";
+import { durableSessionsCommand, durableShowCommand } from "./commands/durable-sessions.js";
+import { durablePreflight } from "./lib/durable/launch.js";
+import { durableRefusalExit } from "./lib/durable/refusal.js";
+import { liveDoctorDurableLines, liveLockVerbDeps, liveSessionsReadDeps, liveVerbDeps, } from "./lib/durable/live.js";
+import { amendCommand, containmentCommand, ownerVerbCommand, unlockCommand, } from "./commands/durable-verbs.js";
+import { lockCommand } from "./commands/durable-lock.js";
+import { registerHostCommands } from "./host/commands.js";
+import { hostArgvGate } from "./host/gate.js";
+import { homedir } from "node:os";
 program
     .name("mnemom")
     .description("Transparent AI agent tracing")
@@ -122,14 +131,11 @@ program
 // ── experimental features (lib/experimental.ts) ── While a feature is off its flags and
 // commands are hidden from --help (decided once, at load) and using one fails with a
 // pointer to `mnemom experimental enable <id>` (decided per invocation, in the action).
-// A prerelease (`next`) build also makes PRERELEASE_AVAILABLE usable (door one's T16).
-const PRERELEASE_BUILD = isPrerelease(CLI_VERSION);
-const loadAvailableFeatures = () => availableFeatures(loadExperimentalState().enabled, PRERELEASE_BUILD);
-const experimentalAtLoad = loadAvailableFeatures();
+const experimentalAtLoad = loadExperimentalState().enabled;
 const hiddenUnless = (id) => !experimentalAtLoad.includes(id);
 /** preAction guard for a gated command: print the guidance and exit 2 while `id` is off. */
 function requireExperimental(what, id) {
-    const message = gateCheck(what, id, loadAvailableFeatures());
+    const message = gateCheck(what, id, loadExperimentalState().enabled);
     if (message) {
         console.error(message);
         process.exit(2);
@@ -153,6 +159,8 @@ function printAgentHelp(verb) {
         : undefined;
     (sub ?? agentCmd).outputHelp();
 }
+// `agent --new` is a durable option: held here so DURABLE_GATED_OPTIONS can name it.
+const agentNewOption = new Option("--new", "EXPERIMENTAL (`mnemom experimental enable durable`): start a fresh session under this name; never continue one").hideHelp(hiddenUnless("durable"));
 const agentCmd = program
     .command("agent [session] [passthrough...]")
     .description("Launch your governed agent (Claude Code in v1) through the Mnemom gateway — governed identity + optional sealed goal contract. Plain `mnemom agent` asks for a session name. " +
@@ -172,7 +180,7 @@ const agentCmd = program
     "platform cards (strictest wins). See `mnemom protection` for that mode.")
     .option("--lead-directed", "Seal the standard lead-directed requirement: own-branch push and draft/ready PR creation, " +
     "from a git worktree, on the lead's direction — not merging. Requires --goal; idempotent.")
-    .addOption(new Option("--implicit", "EXPERIMENTAL (`mnemom experimental enable implicit`): implicit goal alignment — the gateway infers the goal from your messages and revises it as you steer (the default while the feature is on, and on a `next` build for every launch but `-p`; not combinable with --goal/--requirement/--allow/--forbid/--goal-id/--mode/--lead-directed; the guardrail ceilings still apply)").hideHelp(hiddenUnless("implicit")))
+    .addOption(new Option("--implicit", "EXPERIMENTAL (`mnemom experimental enable implicit`): implicit goal alignment — the gateway infers the goal from your messages and revises it as you steer (the default while the feature is on; not combinable with --goal/--requirement/--allow/--forbid/--goal-id/--mode/--lead-directed; the guardrail ceilings still apply)").hideHelp(hiddenUnless("implicit")))
     .option("--no-implicit", "Turn implicit goal alignment OFF for this launch (overrides launcher.toml goal_mode = implicit)")
     .option("--conversation-id <id>", "x-mnemom-conversation-id (default: auto-generated)")
     .option("--cli <name|path>", "Coding-agent CLI to launch: a name or full path (default: claude)")
@@ -234,6 +242,7 @@ const agentCmd = program
     }
     return v;
 }))
+    .addOption(agentNewOption)
     .addOption(new Option("--context-handoff", "EXPERIMENTAL (`mnemom experimental enable context-handoff`): register the `handoff(note)` MCP tool and tell the gateway to turn on the context-handoff capability for this session").hideHelp(hiddenUnless("context-handoff")))
     .option("--no-context-handoff", "Keep context handoff off for this launch even when launcher.toml (context_handoff = true) or MNEMOM_AGENT_CONTEXT_HANDOFF turns it on")
     .option("--compaction-intercept", "Turn the compaction intercept on for this launch even when launcher.toml (compaction_intercept = false) or MNEMOM_AGENT_COMPACTION_INTERCEPT=0 turns it off. On by default: the gateway reports the real context size (so Claude Code compacts at its own threshold) and answers the compaction at once from its fold")
@@ -264,14 +273,18 @@ const agentCmd = program
         });
     }
     catch (error) {
+        const durableExit = durableRefusalExit(error, {
+            out: (l) => process.stdout.write(`${l}\n`),
+            err: (l) => console.error(l),
+        });
+        if (durableExit !== null)
+            process.exit(durableExit);
         const report = reportCliError(error);
         console.error(...report.args);
         process.exit(report.code);
     }
     async function launchAgent(scenario) {
         const experimental = loadExperimentalState().enabled;
-        // What a flag, key or command may use: the enabled features, plus implicit on `next`.
-        const available = availableFeatures(experimental, PRERELEASE_BUILD);
         // The one place the flag's raw string becomes `number | null` (see the argParser's
         // comment for why commander can't carry `null` through parseArg directly). Already
         // validated by the argParser, so this never throws.
@@ -279,7 +292,7 @@ const agentCmd = program
         // Sub-verb: `mnemom agent config …` manages persistent settings and never
         // launches. (A scenario literally named "config" is reserved for this.)
         if (scenario === "config") {
-            await agentConfigCommand(passthrough, { enabled: available });
+            await agentConfigCommand(passthrough, { enabled: experimental });
             return;
         }
         // Sub-verb: `mnemom agent slack …` posts/receives Slack messages as this
@@ -299,7 +312,8 @@ const agentCmd = program
                 used: opts.contextHandoff === true,
             },
             { what: "--implicit", id: "implicit", used: opts.implicit === true },
-        ], available);
+            { what: "--new", id: "durable", used: opts.new === true },
+        ], experimental);
         if (opts.gateway)
             process.env.MNEMOM_AGENT_GATEWAY = opts.gateway;
         // Persistent settings (~/.mnemom/launcher.toml) sit UNDER env and flags:
@@ -312,11 +326,11 @@ const agentCmd = program
         for (const line of ignoredSettingLines({
             entries: launcherEntries(rawCfg),
             env: process.env,
-            enabled: available,
+            enabled: experimental,
         })) {
             console.error(line);
         }
-        const cfg = withoutDisabledExperimental(rawCfg, available);
+        const cfg = withoutDisabledExperimental(rawCfg, experimental);
         applyConfigToEnv(cfg, process.env);
         // Sub-verb: `mnemom agent doctor` runs a read-only preflight and never
         // launches. Placed after config load so it reports the effective settings.
@@ -326,7 +340,11 @@ const agentCmd = program
             return;
         }
         if (scenario === "doctor") {
-            await agentDoctorCommand({ cli: opts.cli, agent: program.opts().agent ?? cfg.agent });
+            await agentDoctorCommand({
+                cli: opts.cli,
+                agent: program.opts().agent ?? cfg.agent,
+                ...(experimental.includes("durable") ? { durable: liveDoctorDurableLines } : {}),
+            });
             return;
         }
         // Validated up front so a typo fails before any sign-in or provisioning.
@@ -349,22 +367,14 @@ const agentCmd = program
         const numToStr = (n) => n === undefined ? undefined : String(n);
         // Implicit mode: --implicit / --no-implicit win; a --goal statement seals
         // (the standing config default never overrides it); else launcher.toml
-        // `goal_mode`; else implicit while the `implicit` feature is on; else, on a
-        // `next` build, implicit unless the launch is headless `-p` (T16); else off.
-        // Pure + unit-tested in lib/agent.ts.
-        const goalMode = resolveImplicitSource({
+        // `goal_mode`; else implicit while the `implicit` feature is on, off while it is
+        // off. Pure + unit-tested in lib/agent.ts.
+        const implicit = resolveImplicit({
             goal: opts.goal,
             implicit: opts.implicit,
             configGoalMode: cfg.goalMode,
             experimentalOn: experimental.includes("implicit"),
-            prerelease: PRERELEASE_BUILD,
-            print: passthroughIsPrint(passthrough),
         });
-        const implicit = goalMode.implicit;
-        // The T16 default tells the user once, the first time it applies.
-        if (implicit && goalMode.source === "prerelease") {
-            showImplicitDefaultNoticeOnce({ dryRun: opts.dryRun });
-        }
         // Config guardrails apply only when goal alignment is actually intended (a
         // --goal is present, or implicit mode — where they ride on the mode header),
         // so a saved ceiling never forces an unrequested contract (which would
@@ -374,6 +384,20 @@ const agentCmd = program
         // shadows a subcommand `--agent` under commander@12 — the MNE-238 class),
         // exactly as status/logs/onboard read it.
         const parentOpts = program.opts();
+        // Durable (gate on only, BACKBONE C1): refusals decided before any registry call or spawn
+        // (nested launch, --server, the S1 name grammar); the registry plan runs in agentCommand.
+        const durableOn = experimental.includes("durable");
+        const durableKey = cfg.durable ?? "off";
+        if (durableOn) {
+            const refusal = durablePreflight({
+                name: scenario,
+                env: process.env,
+                server: opts.server === true,
+                launcherKey: durableKey,
+            });
+            if (refusal !== null)
+                throw refusal;
+        }
         // First interactive launch only: offer (opt-in) the local look at what Mnemom
         // would have saved. Tracked in ~/.mnemom/first-run.json; never blocks the launch.
         await offerFirstRunOnLaunch({ dryRun: opts.dryRun });
@@ -423,6 +447,9 @@ const agentCmd = program
             keySource: cfg.keySource,
             passthrough,
             dryRun: opts.dryRun,
+            ...(durableOn
+                ? { durable: { launcherKey: durableKey, newSession: opts.new === true } }
+                : {}),
         });
     }
 });
@@ -848,6 +875,7 @@ policyCmd
 // ============================================================================
 // Agent management — sub-verbs of `mnemom agent` (the launcher above): list / claim / move.
 // ============================================================================
+const agentHostCmd = registerHostCommands(agentCmd, hiddenUnless("durable"));
 agentCmd
     .command("list")
     .description("List the agents in your active org (set with `mnemom org use`), or every org you belong to if none is set (ADR-062 org-scoped)")
@@ -941,13 +969,25 @@ const agentSessionsCmd = agentCmd
     .option("--json", "Output the rows as JSON instead of a table")
     .action(async (opts) => {
     try {
-        await agentSessionsCommand({ all: opts.all, json: opts.json }, liveSessionDeps);
+        const ledger = async () => {
+            await agentSessionsCommand({ all: opts.all, json: opts.json }, liveSessionDeps);
+            return 0;
+        };
+        // Durable on: the server registry (C01-R12); off: the ledger, exactly as before.
+        if (durableOn(loadExperimentalState().enabled))
+            process.exitCode = await durableSessionsCommand(opts, liveSessionsReadDeps(), ledger);
+        else
+            await ledger();
     }
     catch (error) {
         console.error("Error:", error instanceof Error ? error.message : error);
         process.exit(1);
     }
 });
+// `sessions` has no subcommands before M1: its usage line is captured here, before any durable
+// sub-verb (C4 `adopt`, C1 `unlock`) is added, and restored once they are all registered while
+// durable is off (commander counts hidden subcommands in `[command]`; C17-R09).
+const agentSessionsPreM1Usage = agentSessionsCmd.usage();
 /** preAction (and --help) guard for a durable verb: while durable is off it does not exist (C14-R22). */
 function requireDurableVerb(word, what) {
     const lines = durableVerbOffLines(word, what, loadExperimentalState().enabled);
@@ -987,11 +1027,14 @@ const agentSessionsAdoptCmd = agentSessionsCmd
     }
 });
 /**
- * The durable-gated commands (BACKBONE Flags/CLI: off lists no durable verb). The committed
- * command-tree.json leaves them out whatever the generating machine's experimental state
- * (scripts/gen-command-tree.mjs); a piece that registers another durable verb adds it here.
+ * The durable-gated commands and options (BACKBONE Flags/CLI: off lists no durable verb). The
+ * committed command-tree.json leaves them out whatever the generating machine's experimental
+ * state (scripts/gen-command-tree.mjs); --help shows them only once durable is enabled. A piece
+ * that registers another durable verb or option adds it here.
  */
-export const DURABLE_GATED_COMMANDS = new Set([agentSessionsAdoptCmd]);
+const durableGatedCommands = new Set([agentHostCmd, agentSessionsAdoptCmd]);
+export const DURABLE_GATED_COMMANDS = durableGatedCommands;
+export const DURABLE_GATED_OPTIONS = new Set([agentNewOption]);
 // commander answers --help before preAction: gate the help too, so the verb does not exist while off.
 const adoptOutputHelp = agentSessionsAdoptCmd.outputHelp.bind(agentSessionsAdoptCmd);
 agentSessionsAdoptCmd.outputHelp = ((...args) => {
@@ -1017,13 +1060,92 @@ agentCmd
             }
             followIntervalMs = seconds * 1000;
         }
-        await agentShowCommand(ref, { json: opts.json, follow: opts.follow, followIntervalMs }, liveSessionDeps);
+        const ledger = async () => {
+            await agentShowCommand(ref, { json: opts.json, follow: opts.follow, followIntervalMs }, liveSessionDeps);
+            return 0;
+        };
+        // Durable on: resolve the name through the registry (C01-R12, R24); --follow and a ref
+        // the registry does not know stay on the ledger view.
+        if (durableOn(loadExperimentalState().enabled) && !opts.follow)
+            process.exitCode = await durableShowCommand(ref, { json: opts.json }, liveSessionsReadDeps(), ledger);
+        else
+            await ledger();
     }
     catch (error) {
         console.error("Error:", error instanceof Error ? error.message : error);
         process.exit(1);
     }
 });
+/**
+ * Read an option value the user typed on this parse from `cmd`, then clear it: commander keeps
+ * option values on the command object across parses, so a value left behind would carry into the
+ * next parse of the same program (another amend, or a launch that reads the guardrail).
+ */
+function takeParentOption(cmd, key) {
+    if (cmd.getOptionValueSource(key) !== "cli")
+        return undefined;
+    const v = cmd.getOptionValue(key);
+    cmd.setOptionValueWithSource(key, undefined, "default");
+    return v;
+}
+// ── durable verbs (BACKBONE C1; EXPERIMENTAL `durable`) ── hidden while durable is off, and
+// unreachable then: runEntrypoint's durable gate exits 2 on these words before commander parses.
+// Each handler returns its exit status (refusals rendered by lib/durable/refusal.ts).
+{
+    const hidden = hiddenUnless("durable");
+    // The action-level gate (C17): while durable is off the action exits 2 with the pointer before it
+    // builds any client, for any argv shape that got past runEntrypoint's scan.
+    const exitWith = async (what, run) => {
+        const gated = durableActionGate(what, loadExperimentalState().enabled);
+        if (gated !== null) {
+            console.error(gated);
+            process.exitCode = 2;
+            return;
+        }
+        process.exitCode = await run();
+    };
+    const gate = (cmd) => {
+        durableGatedCommands.add(cmd);
+        return cmd;
+    };
+    gate(agentCmd.command("lock <name>", { hidden }))
+        .description("EXPERIMENTAL (durable): lock a session so the host daemon keeps it running")
+        .option("--own-agent", "Lock even though other sessions share the agent (they are locked too)")
+        .option("--json", "Output the answer as JSON")
+        .action((name, o) => exitWith("`mnemom agent lock`", () => lockCommand(name, o, liveLockVerbDeps())));
+    for (const verb of ["pause", "resume", "done", "kill"]) {
+        gate(agentCmd.command(`${verb} <name>`, { hidden }))
+            .description(`EXPERIMENTAL (durable): ${verb} a session`)
+            .option("--json", "Output the answer as JSON")
+            .action((name, o) => exitWith(`\`mnemom agent ${verb}\``, () => ownerVerbCommand(verb, name, o, liveVerbDeps())));
+    }
+    gate(agentCmd.command("amend <name>", { hidden }))
+        .description("EXPERIMENTAL (durable): lower a session's limits, or raise its budget (approved by device step)")
+        .option("--budget <usd>", "New budget in USD")
+        .option("--turns <n>", "New turn ceiling (lowering only)")
+        .option("--json", "Output the answer as JSON")
+        .action((name, o) => {
+        // `agent` has its own --budget (the launch guardrail), and commander hands an option the
+        // parent knows to the parent wherever it sits in argv: amend's --budget lands there.
+        const budget = takeParentOption(agentCmd, "budget");
+        return exitWith("`mnemom agent amend`", () => amendCommand(name, { ...o, budget }, liveVerbDeps()));
+    });
+    const containmentCmd = gate(agentCmd.command("containment", { hidden })).description("EXPERIMENTAL (durable): org admin containment of an agent (pause | resume)");
+    for (const verb of ["pause", "resume"]) {
+        containmentCmd
+            .command(`${verb} <agent>`)
+            .description(`${verb} every session of an agent (org admin, signed in)`)
+            .action((agent) => exitWith(`\`mnemom agent containment ${verb}\``, () => containmentCommand(verb, agent, liveVerbDeps())));
+    }
+    // `sessions` has no subcommands before M1: keep its usage line byte-identical (commander
+    // counts hidden subcommands in `[command]`). Captured before C4's `adopt` was added too.
+    const sessionsUsage = agentSessionsPreM1Usage;
+    gate(agentSessionsCmd.command("unlock <name>", { hidden }))
+        .description("EXPERIMENTAL (durable): unlock a locked session back to tracked (device step)")
+        .action((name) => exitWith("`mnemom agent sessions unlock`", () => unlockCommand(name, liveVerbDeps())));
+    if (hidden)
+        agentSessionsCmd.usage(sessionsUsage);
+}
 // `mnemom agent run --watch|--once` — the thin runner (ruling 34.12; Doors W-L13): claim served-phase
 // jobs from the org's ready pool and run their signed phases. Exit 0 done/no_job, 1 failed,
 // 2 usage, 3 refused.
@@ -2291,6 +2413,13 @@ export { program };
 // Parse argv only when invoked as the CLI entrypoint — not when imported.
 // The symlink-safe guard lives in ./lib/entrypoint so it can be unit-tested
 // without executing this module's top-level parse().
+/**
+ * The value-taking options of the program, `agent` and `agent sessions`: the durable gate steps over
+ * them (and their values) to find the verb word, as commander does before it dispatches.
+ */
+export function agentOptionShapes() {
+    return optionShapesOf([program, agentCmd, agentSessionsCmd]);
+}
 /**
  * The entrypoint dispatch. `mnemom agent slack …` owns its own flags (--thread,
  * --channel, …), which the `agent` launcher options would otherwise reject as
@@ -2298,8 +2427,41 @@ export { program };
  * verbatim. Exported (not auto-run) so the bypass is unit-testable.
  */
 export function runEntrypoint(argv = process.argv.slice(2), migrate = runExperimentalMigration) {
+    // The durable seat proxy (C3) is spawned by the host daemon; its stdout carries only READY, so it
+    // runs before the migration and the update hook (durable/seat-proxy-entry.ts holds the gate).
+    if (isSeatProxyArgv(argv)) {
+        runSeatProxyEntry(argv, {
+            stored: () => loadCliConfig().experimental,
+            stderr: (line) => void process.stderr.write(line),
+            exit: (code) => process.exit(code),
+            run: async (rest) => (await import("./durable/seat-proxy.js")).seatProxyMain(rest),
+        });
+        return;
+    }
     // First run after the upgrade that introduced experimental features: keep on whatever
     // launcher.toml already uses (commands/experimental.ts; never throws).
+    // `mnemom agent host …` with durable off: gated before commander's help/usage paths and before
+    // the one-time migration below can write config.json (C17-R10: no HOME write). C2 owns the
+    // `host` word (config.json-only gate for `host run`, C12-R25/R39), so the C1 verb-word gate
+    // below steps aside for it (integration r1: the C1 gate documents "until C2 registers its handler").
+    const hostGate = hostArgvGate(argv, { env: process.env, home: homedir() });
+    if (hostGate) {
+        console.error(hostGate.message);
+        process.exit(hostGate.code);
+        return;
+    }
+    // Durable verb words while `durable` is off: exit 2 with the pointer before commander can
+    // answer --help, and before the one-time migration below can write config.json (BACKBONE
+    // Flags/CLI: no HTTP, no HOME write, no process).
+    const hostArgv = argv[0] === "agent" && argv[1] === "host";
+    const durableGateMessage = hostArgv
+        ? null
+        : durableGate(argv, loadExperimentalState().enabled, agentOptionShapes());
+    if (durableGateMessage !== null) {
+        console.error(durableGateMessage);
+        process.exit(2);
+        return;
+    }
     migrate();
     if (argv[0] === "agent" && argv[1] === "slack") {
         requireExperimental("`mnemom agent slack`", "slack");

package/dist/lib/agent.d.ts

@@ -925,47 +925,29 @@ export declare function buildHandoffMcpConfigJson(p: HandoffMcpParams): string;
  * per-session statement, so it is always a per-launch `--goal`.
  */
 export type GoalModeDefault = "implicit" | "off";
-/**
- * Where a launch's goal mode came from (`resolveImplicitSource`). `prerelease` is door
- * one's T16 default (decisions 12 and 22): implicit by default on a `-next.N` build with
- * nothing configured. It is the only source that shows the one-time notice.
- */
-export type ImplicitSource = "flag" | "goal" | "config" | "experimental" | "prerelease" | "default";
-/** Does a Claude Code passthrough run headless (`-p` / `--print`)? */
-export declare function passthroughIsPrint(passthrough: readonly string[]): boolean;
 /**
  * Is this launch implicit-mode? Precedence, highest wins:
  *   1. an explicit flag — `--implicit` (true) or `--no-implicit` (false);
  *   2. a `--goal` statement — a sealed contract is a per-launch choice that the
- *      standing config default must never silently override, so a launch never
- *      runs both modes;
+ *      standing config default must never silently override;
  *   3. the config default `goal_mode` — `"off"` turns alignment off, `"implicit"`
  *      keeps it implicit;
- *   4. with the `implicit` experimental feature ON, IMPLICIT (as before T16);
- *   5. on a prerelease (`next`) build, IMPLICIT for an interactive or Remote Control
- *      launch and OFF for a headless `-p` one (OD-13: T16 never covers `-p`);
- *   6. otherwise OFF — stable without the experimental feature behaves as today.
+ *   4. with the `implicit` experimental feature ON, IMPLICIT: the gateway infers
+ *      the goal from the user's own messages (turn it off for a launch with
+ *      `--no-implicit`, or standing with `goal_mode = "off"`); with it OFF (the
+ *      default), OFF.
  * Pure so every arm is unit-tested; the caller passes the resolved value on to
  * `assembleContract` / `buildGoalModeHeader` (which still refuse `--implicit`
  * combined with a contract flag — that conflict is EXPLICIT and is reported).
  */
-export declare function resolveImplicitSource(opts: {
+export declare function resolveImplicit(opts: {
     goal?: string;
     implicit?: boolean;
     configGoalMode?: GoalModeDefault;
     /**
      * Is the `implicit` experimental feature on? Off ⇒ the default is OFF and
      * `goal_mode = implicit` is ignored (`--implicit` is refused upstream, before
-     * this runs), unless this is a prerelease build. Omitted ⇒ on.
+     * this runs). Omitted ⇒ on.
      */
     experimentalOn?: boolean;
-    /** Is this a prerelease (`-next.N`) CLI build? `isPrerelease(CLI_VERSION)`. Omitted ⇒ no. */
-    prerelease?: boolean;
-    /** Does the launch run Claude Code headless (`-p`)? `passthroughIsPrint`. */
-    print?: boolean;
-}): {
-    implicit: boolean;
-    source: ImplicitSource;
-};
-/** `resolveImplicitSource(opts).implicit`. */
-export declare function resolveImplicit(opts: Parameters<typeof resolveImplicitSource>[0]): boolean;
+}): boolean;

package/dist/lib/agent.js

@@ -1353,42 +1353,27 @@ export function buildHandoffMcpConfig(p) {
 export function buildHandoffMcpConfigJson(p) {
     return JSON.stringify(buildHandoffMcpConfig(p));
 }
-/** Does a Claude Code passthrough run headless (`-p` / `--print`)? */
-export function passthroughIsPrint(passthrough) {
-    return passthrough.some((a) => a === "-p" || a === "--print" || a.startsWith("--print="));
-}
 /**
  * Is this launch implicit-mode? Precedence, highest wins:
  *   1. an explicit flag — `--implicit` (true) or `--no-implicit` (false);
  *   2. a `--goal` statement — a sealed contract is a per-launch choice that the
- *      standing config default must never silently override, so a launch never
- *      runs both modes;
+ *      standing config default must never silently override;
  *   3. the config default `goal_mode` — `"off"` turns alignment off, `"implicit"`
  *      keeps it implicit;
- *   4. with the `implicit` experimental feature ON, IMPLICIT (as before T16);
- *   5. on a prerelease (`next`) build, IMPLICIT for an interactive or Remote Control
- *      launch and OFF for a headless `-p` one (OD-13: T16 never covers `-p`);
- *   6. otherwise OFF — stable without the experimental feature behaves as today.
+ *   4. with the `implicit` experimental feature ON, IMPLICIT: the gateway infers
+ *      the goal from the user's own messages (turn it off for a launch with
+ *      `--no-implicit`, or standing with `goal_mode = "off"`); with it OFF (the
+ *      default), OFF.
  * Pure so every arm is unit-tested; the caller passes the resolved value on to
  * `assembleContract` / `buildGoalModeHeader` (which still refuse `--implicit`
  * combined with a contract flag — that conflict is EXPLICIT and is reported).
  */
-export function resolveImplicitSource(opts) {
+export function resolveImplicit(opts) {
     if (opts.implicit !== undefined)
-        return { implicit: opts.implicit, source: "flag" };
+        return opts.implicit;
     if (hasText(opts.goal))
-        return { implicit: false, source: "goal" };
-    const experimentalOn = opts.experimentalOn !== false;
-    if (!experimentalOn && !opts.prerelease)
-        return { implicit: false, source: "default" };
-    if (opts.configGoalMode !== undefined) {
-        return { implicit: opts.configGoalMode === "implicit", source: "config" };
-    }
-    if (experimentalOn)
-        return { implicit: true, source: "experimental" };
-    return { implicit: !opts.print, source: opts.print ? "default" : "prerelease" };
-}
-/** `resolveImplicitSource(opts).implicit`. */
-export function resolveImplicit(opts) {
-    return resolveImplicitSource(opts).implicit;
+        return false;
+    if (opts.experimentalOn === false)
+        return false;
+    return opts.configGoalMode !== "off";
 }

package/dist/lib/claude-plugin.d.ts

@@ -65,11 +65,16 @@ export declare const PLUGIN_ENV: {
     readonly launcherVersion: "MNEMOM_CC_LAUNCHER_VERSION";
 };
 export type PluginEnvName = (typeof PLUGIN_ENV)[keyof typeof PLUGIN_ENV];
+/**
+ * Set to "1" only on a launch with the `durable` experimental gate on (BACKBONE C1): the mod then
+ * offers `/mnemom lock`. Absent otherwise, so a launch with durable off has the same env as before.
+ */
+export declare const PLUGIN_DURABLE_ENV = "MNEMOM_CC_DURABLE";
 /**
  * Whether this launch loads the plugin: `--plugin` / `--no-plugin` (an explicit boolean) wins,
  * then MNEMOM_AGENT_PLUGIN (1/true/yes/on ⇒ on), else OFF: the plugin lands dark.
  */
-export declare function pluginEnabled(optionPlugin: boolean | undefined, env: NodeJS.ProcessEnv): boolean;
+export declare function pluginEnabled(optionPlugin: boolean | undefined, env: NodeJS.ProcessEnv, durable?: boolean): boolean;
 /**
  * The bundled plugin's folder (the one holding `.claude-plugin/plugin.json`), or null when it is
  * missing. Lives at `<package>/plugins/mnemom`, next to `dist/` and `src/`, so it is
@@ -97,12 +102,16 @@ export interface PluginLaunch {
     launcherExec?: readonly string[];
     scenario: string;
     launcherVersion: string;
+    /** The `durable` gate is on for this launch (adds PLUGIN_DURABLE_ENV=1). */
+    durable?: boolean;
 }
 /**
  * The `MNEMOM_CC_*` block for the child env. Pure: no key, no header, nothing the gateway
  * authenticates with — just what the launch log already prints to stderr.
  */
-export declare function buildPluginEnv(launch: PluginLaunch): Record<PluginEnvName, string>;
+export declare function buildPluginEnv(launch: PluginLaunch): Record<PluginEnvName, string> & {
+    [PLUGIN_DURABLE_ENV]?: "1";
+};
 /** Writes the block onto a child env in place (the launch shapes all build their env first). */
 export declare function applyPluginEnv(childEnv: NodeJS.ProcessEnv, launch: PluginLaunch): void;
 /**

package/dist/lib/claude-plugin.js

@@ -67,14 +67,22 @@ export const PLUGIN_ENV = {
     session: "MNEMOM_CC_SESSION",
     launcherVersion: "MNEMOM_CC_LAUNCHER_VERSION",
 };
+/**
+ * Set to "1" only on a launch with the `durable` experimental gate on (BACKBONE C1): the mod then
+ * offers `/mnemom lock`. Absent otherwise, so a launch with durable off has the same env as before.
+ */
+export const PLUGIN_DURABLE_ENV = "MNEMOM_CC_DURABLE";
 const TRUTHY = new Set(["1", "true", "yes", "on"]);
 /**
  * Whether this launch loads the plugin: `--plugin` / `--no-plugin` (an explicit boolean) wins,
  * then MNEMOM_AGENT_PLUGIN (1/true/yes/on ⇒ on), else OFF: the plugin lands dark.
  */
-export function pluginEnabled(optionPlugin, env) {
+export function pluginEnabled(optionPlugin, env, durable = false) {
     if (optionPlugin !== undefined)
         return optionPlugin;
+    // BACKBONE C1 "plugin on for durable sessions": with the durable gate on it defaults on.
+    if (durable)
+        return true;
     const raw = (env.MNEMOM_AGENT_PLUGIN ?? "").trim().toLowerCase();
     return TRUTHY.has(raw);
 }
@@ -121,6 +129,7 @@ export function buildPluginEnv(launch) {
         [PLUGIN_ENV.launcherExec]: exec.length > 0 ? JSON.stringify(exec) : "",
         [PLUGIN_ENV.session]: clean(launch.scenario),
         [PLUGIN_ENV.launcherVersion]: clean(launch.launcherVersion),
+        ...(launch.durable ? { [PLUGIN_DURABLE_ENV]: "1" } : {}),
     };
 }
 /** Writes the block onto a child env in place (the launch shapes all build their env first). */